openerp/tools/translate.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 import codecs
  23 import csv
  24 import fnmatch
  25 import inspect
  26 import locale
  27 import os
  28 import openerp.pooler as pooler
  29 import openerp.sql_db as sql_db
  30 import re
  31 import logging
  32 import tarfile
  33 import tempfile
  34 import threading
  35 from babel.messages import extract
  36 from os.path import join
  37
  38 from datetime import datetime
  39 from lxml import etree
  40
  41 import config
  42 import misc
  43 from misc import UpdateableStr
  44 from misc import SKIPPED_ELEMENT_TYPES
  45 import osutil
  46 from openerp import SUPERUSER_ID
  47
  48 _logger = logging.getLogger(__name__)
  49
  50 # used to notify web client that these translations should be loaded in the UI
  51 WEB_TRANSLATION_COMMENT = "openerp-web"
  52
  53 _LOCALE2WIN32 = {
  54     'af_ZA': 'Afrikaans_South Africa',
  55     'sq_AL': 'Albanian_Albania',
  56     'ar_SA': 'Arabic_Saudi Arabia',
  57     'eu_ES': 'Basque_Spain',
  58     'be_BY': 'Belarusian_Belarus',
  59     'bs_BA': 'Serbian (Latin)',
  60     'bg_BG': 'Bulgarian_Bulgaria',
  61     'ca_ES': 'Catalan_Spain',
  62     'hr_HR': 'Croatian_Croatia',
  63     'zh_CN': 'Chinese_China',
  64     'zh_TW': 'Chinese_Taiwan',
  65     'cs_CZ': 'Czech_Czech Republic',
  66     'da_DK': 'Danish_Denmark',
  67     'nl_NL': 'Dutch_Netherlands',
  68     'et_EE': 'Estonian_Estonia',
  69     'fa_IR': 'Farsi_Iran',
  70     'ph_PH': 'Filipino_Philippines',
  71     'fi_FI': 'Finnish_Finland',
  72     'fr_FR': 'French_France',
  73     'fr_BE': 'French_France',
  74     'fr_CH': 'French_France',
  75     'fr_CA': 'French_France',
  76     'ga': 'Scottish Gaelic',
  77     'gl_ES': 'Galician_Spain',
  78     'ka_GE': 'Georgian_Georgia',
  79     'de_DE': 'German_Germany',
  80     'el_GR': 'Greek_Greece',
  81     'gu': 'Gujarati_India',
  82     'he_IL': 'Hebrew_Israel',
  83     'hi_IN': 'Hindi',
  84     'hu': 'Hungarian_Hungary',
  85     'is_IS': 'Icelandic_Iceland',
  86     'id_ID': 'Indonesian_indonesia',
  87     'it_IT': 'Italian_Italy',
  88     'ja_JP': 'Japanese_Japan',
  89     'kn_IN': 'Kannada',
  90     'km_KH': 'Khmer',
  91     'ko_KR': 'Korean_Korea',
  92     'lo_LA': 'Lao_Laos',
  93     'lt_LT': 'Lithuanian_Lithuania',
  94     'lat': 'Latvian_Latvia',
  95     'ml_IN': 'Malayalam_India',
  96     'mi_NZ': 'Maori',
  97     'mn': 'Cyrillic_Mongolian',
  98     'no_NO': 'Norwegian_Norway',
  99     'nn_NO': 'Norwegian-Nynorsk_Norway',
 100     'pl': 'Polish_Poland',
 101     'pt_PT': 'Portuguese_Portugal',
 102     'pt_BR': 'Portuguese_Brazil',
 103     'ro_RO': 'Romanian_Romania',
 104     'ru_RU': 'Russian_Russia',
 105     'sr_CS': 'Serbian (Cyrillic)_Serbia and Montenegro',
 106     'sk_SK': 'Slovak_Slovakia',
 107     'sl_SI': 'Slovenian_Slovenia',
 108     #should find more specific locales for spanish countries,
 109     #but better than nothing
 110     'es_AR': 'Spanish_Spain',
 111     'es_BO': 'Spanish_Spain',
 112     'es_CL': 'Spanish_Spain',
 113     'es_CO': 'Spanish_Spain',
 114     'es_CR': 'Spanish_Spain',
 115     'es_DO': 'Spanish_Spain',
 116     'es_EC': 'Spanish_Spain',
 117     'es_ES': 'Spanish_Spain',
 118     'es_GT': 'Spanish_Spain',
 119     'es_HN': 'Spanish_Spain',
 120     'es_MX': 'Spanish_Spain',
 121     'es_NI': 'Spanish_Spain',
 122     'es_PA': 'Spanish_Spain',
 123     'es_PE': 'Spanish_Spain',
 124     'es_PR': 'Spanish_Spain',
 125     'es_PY': 'Spanish_Spain',
 126     'es_SV': 'Spanish_Spain',
 127     'es_UY': 'Spanish_Spain',
 128     'es_VE': 'Spanish_Spain',
 129     'sv_SE': 'Swedish_Sweden',
 130     'ta_IN': 'English_Australia',
 131     'th_TH': 'Thai_Thailand',
 132     'tr_TR': 'Turkish_Turkey',
 133     'uk_UA': 'Ukrainian_Ukraine',
 134     'vi_VN': 'Vietnamese_Viet Nam',
 135     'tlh_TLH': 'Klingon',
 136
 137 }
 138
 139
 140 class UNIX_LINE_TERMINATOR(csv.excel):
 141     lineterminator = '\n'
 142
 143 csv.register_dialect("UNIX", UNIX_LINE_TERMINATOR)
 144
 145 #
 146 # Warning: better use self.pool.get('ir.translation')._get_source if you can
 147 #
 148 def translate(cr, name, source_type, lang, source=None):
 149     if source and name:
 150         cr.execute('select value from ir_translation where lang=%s and type=%s and name=%s and src=%s', (lang, source_type, str(name), source))
 151     elif name:
 152         cr.execute('select value from ir_translation where lang=%s and type=%s and name=%s', (lang, source_type, str(name)))
 153     elif source:
 154         cr.execute('select value from ir_translation where lang=%s and type=%s and src=%s', (lang, source_type, source))
 155     res_trans = cr.fetchone()
 156     res = res_trans and res_trans[0] or False
 157     return res
 158
 159 class GettextAlias(object):
 160
 161     def _get_db(self):
 162         # find current DB based on thread/worker db name (see netsvc)
 163         db_name = getattr(threading.currentThread(), 'dbname', None)
 164         if db_name:
 165             return sql_db.db_connect(db_name)
 166
 167     def _get_cr(self, frame, allow_create=True):
 168         is_new_cr = False
 169         cr = frame.f_locals.get('cr', frame.f_locals.get('cursor'))
 170         if not cr:
 171             s = frame.f_locals.get('self', {})
 172             cr = getattr(s, 'cr', None)
 173         if not cr and allow_create:
 174             db = self._get_db()
 175             if db is not None:
 176                 cr = db.cursor()
 177                 is_new_cr = True
 178         return cr, is_new_cr
 179
 180     def _get_uid(self, frame):
 181         return frame.f_locals.get('uid') or frame.f_locals.get('user')
 182
 183     def _get_lang(self, frame):
 184         lang = None
 185         ctx = frame.f_locals.get('context')
 186         if not ctx:
 187             kwargs = frame.f_locals.get('kwargs')
 188             if kwargs is None:
 189                 args = frame.f_locals.get('args')
 190                 if args and isinstance(args, (list, tuple)) \
 191                         and isinstance(args[-1], dict):
 192                     ctx = args[-1]
 193             elif isinstance(kwargs, dict):
 194                 ctx = kwargs.get('context')
 195         if ctx:
 196             lang = ctx.get('lang')
 197         s = frame.f_locals.get('self', {})
 198         if not lang:
 199             c = getattr(s, 'localcontext', None)
 200             if c:
 201                 lang = c.get('lang')
 202         if not lang:
 203             # Last resort: attempt to guess the language of the user
 204             # Pitfall: some operations are performed in sudo mode, and we
 205             #          don't know the originial uid, so the language may
 206             #          be wrong when the admin language differs.
 207             pool = getattr(s, 'pool', None)
 208             (cr, dummy) = self._get_cr(frame, allow_create=False)
 209             uid = self._get_uid(frame)
 210             if pool and cr and uid:
 211                 lang = pool.get('res.users').context_get(cr, uid)['lang']
 212         return lang
 213
 214     def __call__(self, source):
 215         res = source
 216         cr = None
 217         is_new_cr = False
 218         try:
 219             frame = inspect.currentframe()
 220             if frame is None:
 221                 return source
 222             frame = frame.f_back
 223             if not frame:
 224                 return source
 225             lang = self._get_lang(frame)
 226             if lang:
 227                 cr, is_new_cr = self._get_cr(frame)
 228                 if cr:
 229                     # Try to use ir.translation to benefit from global cache if possible
 230                     pool = pooler.get_pool(cr.dbname)
 231                     res = pool.get('ir.translation')._get_source(cr, SUPERUSER_ID, None, ('code','sql_constraint'), lang, source)
 232                 else:
 233                     _logger.debug('no context cursor detected, skipping translation for "%r"', source)
 234             else:
 235                 _logger.debug('no translation language detected, skipping translation for "%r" ', source)
 236         except Exception:
 237             _logger.debug('translation went wrong for "%r", skipped', source)
 238                 # if so, double-check the root/base translations filenames
 239         finally:
 240             if cr and is_new_cr:
 241                 cr.close()
 242         return res
 243
 244 _ = GettextAlias()
 245
 246
 247 def quote(s):
 248     """Returns quoted PO term string, with special PO characters escaped"""
 249     assert r"\n" not in s, "Translation terms may not include escaped newlines ('\\n'), please use only literal newlines! (in '%s')" % s
 250     return '"%s"' % s.replace('\\','\\\\') \
 251                      .replace('"','\\"') \
 252                      .replace('\n', '\\n"\n"')
 253
 254 re_escaped_char = re.compile(r"(\\.)")
 255 re_escaped_replacements = {'n': '\n', }
 256
 257 def _sub_replacement(match_obj):
 258     return re_escaped_replacements.get(match_obj.group(1)[1], match_obj.group(1)[1])
 259
 260 def unquote(str):
 261     """Returns unquoted PO term string, with special PO characters unescaped"""
 262     return re_escaped_char.sub(_sub_replacement, str[1:-1])
 263
 264 # class to handle po files
 265 class TinyPoFile(object):
 266     def __init__(self, buffer):
 267         self.buffer = buffer
 268
 269     def warn(self, msg, *args):
 270         _logger.warning(msg, *args)
 271
 272     def __iter__(self):
 273         self.buffer.seek(0)
 274         self.lines = self._get_lines()
 275         self.lines_count = len(self.lines)
 276
 277         self.first = True
 278         self.extra_lines= []
 279         return self
 280
 281     def _get_lines(self):
 282         lines = self.buffer.readlines()
 283         # remove the BOM (Byte Order Mark):
 284         if len(lines):
 285             lines[0] = unicode(lines[0], 'utf8').lstrip(unicode( codecs.BOM_UTF8, "utf8"))
 286
 287         lines.append('') # ensure that the file ends with at least an empty line
 288         return lines
 289
 290     def cur_line(self):
 291         return self.lines_count - len(self.lines)
 292
 293     def next(self):
 294         trans_type = name = res_id = source = trad = None
 295         if self.extra_lines:
 296             trans_type, name, res_id, source, trad, comments = self.extra_lines.pop(0)
 297             if not res_id:
 298                 res_id = '0'
 299         else:
 300             comments = []
 301             targets = []
 302             line = None
 303             fuzzy = False
 304             while not line:
 305                 if 0 == len(self.lines):
 306                     raise StopIteration()
 307                 line = self.lines.pop(0).strip()
 308             while line.startswith('#'):
 309                 if line.startswith('#~ '):
 310                     break
 311                 if line.startswith('#.'):
 312                     line = line[2:].strip()
 313                     if not line.startswith('module:'):
 314                         comments.append(line)
 315                 elif line.startswith('#:'):
 316                     for lpart in line[2:].strip().split(' '):
 317                         trans_info = lpart.strip().split(':',2)
 318                         if trans_info and len(trans_info) == 2:
 319                             # looks like the translation trans_type is missing, which is not
 320                             # unexpected because it is not a GetText standard. Default: 'code'
 321                             trans_info[:0] = ['code']
 322                         if trans_info and len(trans_info) == 3:
 323                             # this is a ref line holding the destination info (model, field, record)
 324                             targets.append(trans_info)
 325                 elif line.startswith('#,') and (line[2:].strip() == 'fuzzy'):
 326                     fuzzy = True
 327                 line = self.lines.pop(0).strip()
 328             while not line:
 329                 # allow empty lines between comments and msgid
 330                 line = self.lines.pop(0).strip()
 331             if line.startswith('#~ '):
 332                 while line.startswith('#~ ') or not line.strip():
 333                     if 0 == len(self.lines):
 334                         raise StopIteration()
 335                     line = self.lines.pop(0)
 336                 # This has been a deprecated entry, don't return anything
 337                 return self.next()
 338
 339             if not line.startswith('msgid'):
 340                 raise Exception("malformed file: bad line: %s" % line)
 341             source = unquote(line[6:])
 342             line = self.lines.pop(0).strip()
 343             if not source and self.first:
 344                 # if the source is "" and it's the first msgid, it's the special
 345                 # msgstr with the informations about the traduction and the
 346                 # traductor; we skip it
 347                 self.extra_lines = []
 348                 while line:
 349                     line = self.lines.pop(0).strip()
 350                 return self.next()
 351
 352             while not line.startswith('msgstr'):
 353                 if not line:
 354                     raise Exception('malformed file at %d'% self.cur_line())
 355                 source += unquote(line)
 356                 line = self.lines.pop(0).strip()
 357
 358             trad = unquote(line[7:])
 359             line = self.lines.pop(0).strip()
 360             while line:
 361                 trad += unquote(line)
 362                 line = self.lines.pop(0).strip()
 363
 364             if targets and not fuzzy:
 365                 trans_type, name, res_id = targets.pop(0)
 366                 for t, n, r in targets:
 367                     if t == trans_type == 'code': continue
 368                     self.extra_lines.append((t, n, r, source, trad, comments))
 369
 370         self.first = False
 371
 372         if name is None:
 373             if not fuzzy:
 374                 self.warn('Missing "#:" formated comment at line %d for the following source:\n\t%s',
 375                         self.cur_line(), source[:30])
 376             return self.next()
 377         return trans_type, name, res_id, source, trad, '\n'.join(comments)
 378
 379     def write_infos(self, modules):
 380         import openerp.release as release
 381         self.buffer.write("# Translation of %(project)s.\n" \
 382                           "# This file contains the translation of the following modules:\n" \
 383                           "%(modules)s" \
 384                           "#\n" \
 385                           "msgid \"\"\n" \
 386                           "msgstr \"\"\n" \
 387                           '''"Project-Id-Version: %(project)s %(version)s\\n"\n''' \
 388                           '''"Report-Msgid-Bugs-To: \\n"\n''' \
 389                           '''"POT-Creation-Date: %(now)s\\n"\n'''        \
 390                           '''"PO-Revision-Date: %(now)s\\n"\n'''         \
 391                           '''"Last-Translator: <>\\n"\n''' \
 392                           '''"Language-Team: \\n"\n'''   \
 393                           '''"MIME-Version: 1.0\\n"\n''' \
 394                           '''"Content-Type: text/plain; charset=UTF-8\\n"\n'''   \
 395                           '''"Content-Transfer-Encoding: \\n"\n'''       \
 396                           '''"Plural-Forms: \\n"\n'''    \
 397                           "\n"
 398
 399                           % { 'project': release.description,
 400                               'version': release.version,
 401                               'modules': reduce(lambda s, m: s + "#\t* %s\n" % m, modules, ""),
 402                               'now': datetime.utcnow().strftime('%Y-%m-%d %H:%M')+"+0000",
 403                             }
 404                           )
 405
 406     def write(self, modules, tnrs, source, trad, comments=None):
 407
 408         plurial = len(modules) > 1 and 's' or ''
 409         self.buffer.write("#. module%s: %s\n" % (plurial, ', '.join(modules)))
 410
 411         if comments:
 412             self.buffer.write(''.join(('#. %s\n' % c for c in comments)))
 413
 414         code = False
 415         for typy, name, res_id in tnrs:
 416             self.buffer.write("#: %s:%s:%s\n" % (typy, name, res_id))
 417             if typy == 'code':
 418                 code = True
 419
 420         if code:
 421             # only strings in python code are python formated
 422             self.buffer.write("#, python-format\n")
 423
 424         if not isinstance(trad, unicode):
 425             trad = unicode(trad, 'utf8')
 426         if not isinstance(source, unicode):
 427             source = unicode(source, 'utf8')
 428
 429         msg = "msgid %s\n"      \
 430               "msgstr %s\n\n"   \
 431                   % (quote(source), quote(trad))
 432         self.buffer.write(msg.encode('utf8'))
 433
 434
 435 # Methods to export the translation file
 436
 437 def trans_export(lang, modules, buffer, format, cr):
 438
 439     def _process(format, modules, rows, buffer, lang):
 440         if format == 'csv':
 441             writer = csv.writer(buffer, 'UNIX')
 442             # write header first
 443             writer.writerow(("module","type","name","res_id","src","value"))
 444             for module, type, name, res_id, src, trad, comments in rows:
 445                 # Comments are ignored by the CSV writer
 446                 writer.writerow((module, type, name, res_id, src, trad))
 447         elif format == 'po':
 448             writer = TinyPoFile(buffer)
 449             writer.write_infos(modules)
 450
 451             # we now group the translations by source. That means one translation per source.
 452             grouped_rows = {}
 453             for module, type, name, res_id, src, trad, comments in rows:
 454                 row = grouped_rows.setdefault(src, {})
 455                 row.setdefault('modules', set()).add(module)
 456                 if not row.get('translation') and trad != src:
 457                     row['translation'] = trad
 458                 row.setdefault('tnrs', []).append((type, name, res_id))
 459                 row.setdefault('comments', set()).update(comments)
 460
 461             for src, row in grouped_rows.items():
 462                 if not lang:
 463                     # translation template, so no translation value
 464                     row['translation'] = ''
 465                 elif not row.get('translation'):
 466                     row['translation'] = src
 467                 writer.write(row['modules'], row['tnrs'], src, row['translation'], row['comments'])
 468
 469         elif format == 'tgz':
 470             rows_by_module = {}
 471             for row in rows:
 472                 module = row[0]
 473                 rows_by_module.setdefault(module, []).append(row)
 474             tmpdir = tempfile.mkdtemp()
 475             for mod, modrows in rows_by_module.items():
 476                 tmpmoddir = join(tmpdir, mod, 'i18n')
 477                 os.makedirs(tmpmoddir)
 478                 pofilename = (lang if lang else mod) + ".po" + ('t' if not lang else '')
 479                 buf = file(join(tmpmoddir, pofilename), 'w')
 480                 _process('po', [mod], modrows, buf, lang)
 481                 buf.close()
 482
 483             tar = tarfile.open(fileobj=buffer, mode='w|gz')
 484             tar.add(tmpdir, '')
 485             tar.close()
 486
 487         else:
 488             raise Exception(_('Unrecognized extension: must be one of '
 489                 '.csv, .po, or .tgz (received .%s).' % format))
 490
 491     trans_lang = lang
 492     if not trans_lang and format == 'csv':
 493         # CSV files are meant for translators and they need a starting point,
 494         # so we at least put the original term in the translation column
 495         trans_lang = 'en_US'
 496     translations = trans_generate(lang, modules, cr)
 497     modules = set([t[0] for t in translations[1:]])
 498     _process(format, modules, translations, buffer, lang)
 499     del translations
 500
 501 def trans_parse_xsl(de):
 502     return list(set(trans_parse_xsl_aux(de, False)))
 503
 504 def trans_parse_xsl_aux(de, t):
 505     res = []
 506
 507     for n in de:
 508         t = t or n.get("t")
 509         if t:
 510                 if isinstance(n, SKIPPED_ELEMENT_TYPES) or n.tag.startswith('{http://www.w3.org/1999/XSL/Transform}'):
 511                     continue
 512                 if n.text:
 513                     l = n.text.strip().replace('\n',' ')
 514                     if len(l):
 515                         res.append(l.encode("utf8"))
 516                 if n.tail:
 517                     l = n.tail.strip().replace('\n',' ')
 518                     if len(l):
 519                         res.append(l.encode("utf8"))
 520         res.extend(trans_parse_xsl_aux(n, t))
 521     return res
 522
 523 def trans_parse_rml(de):
 524     res = []
 525     for n in de:
 526         for m in n:
 527             if isinstance(m, SKIPPED_ELEMENT_TYPES) or not m.text:
 528                 continue
 529             string_list = [s.replace('\n', ' ').strip() for s in re.split('\[\[.+?\]\]', m.text)]
 530             for s in string_list:
 531                 if s:
 532                     res.append(s.encode("utf8"))
 533         res.extend(trans_parse_rml(n))
 534     return res
 535
 536 def trans_parse_view(de):
 537     res = []
 538     if not isinstance(de, SKIPPED_ELEMENT_TYPES) and de.text and de.text.strip():
 539         res.append(de.text.strip().encode("utf8"))
 540     if de.tail and de.tail.strip():
 541         res.append(de.tail.strip().encode("utf8"))
 542     if de.tag == 'attribute' and de.get("name") == 'string':
 543         if de.text:
 544             res.append(de.text.encode("utf8"))
 545     if de.get("string"):
 546         res.append(de.get('string').encode("utf8"))
 547     if de.get("help"):
 548         res.append(de.get('help').encode("utf8"))
 549     if de.get("sum"):
 550         res.append(de.get('sum').encode("utf8"))
 551     if de.get("confirm"):
 552         res.append(de.get('confirm').encode("utf8"))
 553     if de.get("placeholder"):
 554         res.append(de.get('placeholder').encode("utf8"))
 555     for n in de:
 556         res.extend(trans_parse_view(n))
 557     return res
 558
 559 # tests whether an object is in a list of modules
 560 def in_modules(object_name, modules):
 561     if 'all' in modules:
 562         return True
 563
 564     module_dict = {
 565         'ir': 'base',
 566         'res': 'base',
 567         'workflow': 'base',
 568     }
 569     module = object_name.split('.')[0]
 570     module = module_dict.get(module, module)
 571     return module in modules
 572
 573
 574 def babel_extract_qweb(fileobj, keywords, comment_tags, options):
 575     """Babel message extractor for qweb template files.
 576     :param fileobj: the file-like object the messages should be extracted from
 577     :param keywords: a list of keywords (i.e. function names) that should
 578                      be recognized as translation functions
 579     :param comment_tags: a list of translator tags to search for and
 580                          include in the results
 581     :param options: a dictionary of additional options (optional)
 582     :return: an iterator over ``(lineno, funcname, message, comments)``
 583              tuples
 584     :rtype: ``iterator``
 585     """
 586     result = []
 587     def handle_text(text, lineno):
 588         text = (text or "").strip()
 589         if len(text) > 1: # Avoid mono-char tokens like ':' ',' etc.
 590             result.append((lineno, None, text, []))
 591
 592     # not using elementTree.iterparse because we need to skip sub-trees in case
 593     # the ancestor element had a reason to be skipped
 594     def iter_elements(current_element):
 595         for el in current_element:
 596             if isinstance(el, SKIPPED_ELEMENT_TYPES): continue
 597             if "t-js" not in el.attrib and \
 598                     not ("t-jquery" in el.attrib and "t-operation" not in el.attrib) and \
 599                     not ("t-translation" in el.attrib and el.attrib["t-translation"].strip() == "off"):
 600                 handle_text(el.text, el.sourceline)
 601                 for att in ('title', 'alt', 'label', 'placeholder'):
 602                     if att in el.attrib:
 603                         handle_text(el.attrib[att], el.sourceline)
 604                 iter_elements(el)
 605             handle_text(el.tail, el.sourceline)
 606
 607     tree = etree.parse(fileobj)
 608     iter_elements(tree.getroot())
 609
 610     return result
 611
 612
 613 def trans_generate(lang, modules, cr):
 614     dbname = cr.dbname
 615
 616     pool = pooler.get_pool(dbname)
 617     trans_obj = pool.get('ir.translation')
 618     model_data_obj = pool.get('ir.model.data')
 619     uid = 1
 620     l = pool.models.items()
 621     l.sort()
 622
 623     query = 'SELECT name, model, res_id, module'    \
 624             '  FROM ir_model_data'
 625
 626     query_models = """SELECT m.id, m.model, imd.module
 627             FROM ir_model AS m, ir_model_data AS imd
 628             WHERE m.id = imd.res_id AND imd.model = 'ir.model' """
 629
 630     if 'all_installed' in modules:
 631         query += ' WHERE module IN ( SELECT name FROM ir_module_module WHERE state = \'installed\') '
 632         query_models += " AND imd.module in ( SELECT name FROM ir_module_module WHERE state = 'installed') "
 633     query_param = None
 634     if 'all' not in modules:
 635         query += ' WHERE module IN %s'
 636         query_models += ' AND imd.module in %s'
 637         query_param = (tuple(modules),)
 638     query += ' ORDER BY module, model, name'
 639     query_models += ' ORDER BY module, model'
 640
 641     cr.execute(query, query_param)
 642
 643     _to_translate = []
 644     def push_translation(module, type, name, id, source, comments=None):
 645         tuple = (module, source, name, id, type, comments or [])
 646         # empty and one-letter terms are ignored, they probably are not meant to be
 647         # translated, and would be very hard to translate anyway.
 648         if not source or len(source.strip()) <= 1:
 649             _logger.debug("Ignoring empty or 1-letter source term: %r", tuple)
 650             return
 651         if tuple not in _to_translate:
 652             _to_translate.append(tuple)
 653
 654     def encode(s):
 655         if isinstance(s, unicode):
 656             return s.encode('utf8')
 657         return s
 658
 659     for (xml_name,model,res_id,module) in cr.fetchall():
 660         module = encode(module)
 661         model = encode(model)
 662         xml_name = "%s.%s" % (module, encode(xml_name))
 663
 664         if not pool.get(model):
 665             _logger.error("Unable to find object %r", model)
 666             continue
 667
 668         exists = pool.get(model).exists(cr, uid, res_id)
 669         if not exists:
 670             _logger.warning("Unable to find object %r with id %d", model, res_id)
 671             continue
 672         obj = pool.get(model).browse(cr, uid, res_id)
 673
 674         if model=='ir.ui.view':
 675             d = etree.XML(encode(obj.arch))
 676             for t in trans_parse_view(d):
 677                 push_translation(module, 'view', encode(obj.model), 0, t)
 678         elif model=='ir.actions.wizard':
 679             service_name = 'wizard.'+encode(obj.wiz_name)
 680             import openerp.netsvc as netsvc
 681             if netsvc.Service._services.get(service_name):
 682                 obj2 = netsvc.Service._services[service_name]
 683                 for state_name, state_def in obj2.states.iteritems():
 684                     if 'result' in state_def:
 685                         result = state_def['result']
 686                         if result['type'] != 'form':
 687                             continue
 688                         name = "%s,%s" % (encode(obj.wiz_name), state_name)
 689
 690                         def_params = {
 691                             'string': ('wizard_field', lambda s: [encode(s)]),
 692                             'selection': ('selection', lambda s: [encode(e[1]) for e in ((not callable(s)) and s or [])]),
 693                             'help': ('help', lambda s: [encode(s)]),
 694                         }
 695
 696                         # export fields
 697                         if not result.has_key('fields'):
 698                             _logger.warning("res has no fields: %r", result)
 699                             continue
 700                         for field_name, field_def in result['fields'].iteritems():
 701                             res_name = name + ',' + field_name
 702
 703                             for fn in def_params:
 704                                 if fn in field_def:
 705                                     transtype, modifier = def_params[fn]
 706                                     for val in modifier(field_def[fn]):
 707                                         push_translation(module, transtype, res_name, 0, val)
 708
 709                         # export arch
 710                         arch = result['arch']
 711                         if arch and not isinstance(arch, UpdateableStr):
 712                             d = etree.XML(arch)
 713                             for t in trans_parse_view(d):
 714                                 push_translation(module, 'wizard_view', name, 0, t)
 715
 716                         # export button labels
 717                         for but_args in result['state']:
 718                             button_name = but_args[0]
 719                             button_label = but_args[1]
 720                             res_name = name + ',' + button_name
 721                             push_translation(module, 'wizard_button', res_name, 0, button_label)
 722
 723         elif model=='ir.model.fields':
 724             try:
 725                 field_name = encode(obj.name)
 726             except AttributeError, exc:
 727                 _logger.error("name error in %s: %s", xml_name, str(exc))
 728                 continue
 729             objmodel = pool.get(obj.model)
 730             if not objmodel or not field_name in objmodel._columns:
 731                 continue
 732             field_def = objmodel._columns[field_name]
 733
 734             name = "%s,%s" % (encode(obj.model), field_name)
 735             push_translation(module, 'field', name, 0, encode(field_def.string))
 736
 737             if field_def.help:
 738                 push_translation(module, 'help', name, 0, encode(field_def.help))
 739
 740             if field_def.translate:
 741                 ids = objmodel.search(cr, uid, [])
 742                 obj_values = objmodel.read(cr, uid, ids, [field_name])
 743                 for obj_value in obj_values:
 744                     res_id = obj_value['id']
 745                     if obj.name in ('ir.model', 'ir.ui.menu'):
 746                         res_id = 0
 747                     model_data_ids = model_data_obj.search(cr, uid, [
 748                         ('model', '=', model),
 749                         ('res_id', '=', res_id),
 750                         ])
 751                     if not model_data_ids:
 752                         push_translation(module, 'model', name, 0, encode(obj_value[field_name]))
 753
 754             if hasattr(field_def, 'selection') and isinstance(field_def.selection, (list, tuple)):
 755                 for dummy, val in field_def.selection:
 756                     push_translation(module, 'selection', name, 0, encode(val))
 757
 758         elif model=='ir.actions.report.xml':
 759             name = encode(obj.report_name)
 760             fname = ""
 761             if obj.report_rml:
 762                 fname = obj.report_rml
 763                 parse_func = trans_parse_rml
 764                 report_type = "report"
 765             elif obj.report_xsl:
 766                 fname = obj.report_xsl
 767                 parse_func = trans_parse_xsl
 768                 report_type = "xsl"
 769             if fname and obj.report_type in ('pdf', 'xsl'):
 770                 try:
 771                     report_file = misc.file_open(fname)
 772                     try:
 773                         d = etree.parse(report_file)
 774                         for t in parse_func(d.iter()):
 775                             push_translation(module, report_type, name, 0, t)
 776                     finally:
 777                         report_file.close()
 778                 except (IOError, etree.XMLSyntaxError):
 779                     _logger.exception("couldn't export translation for report %s %s %s", name, report_type, fname)
 780
 781         for field_name,field_def in obj._table._columns.items():
 782             if field_def.translate:
 783                 name = model + "," + field_name
 784                 try:
 785                     trad = getattr(obj, field_name) or ''
 786                 except:
 787                     trad = ''
 788                 push_translation(module, 'model', name, xml_name, encode(trad))
 789
 790         # End of data for ir.model.data query results
 791
 792     cr.execute(query_models, query_param)
 793
 794     def push_constraint_msg(module, term_type, model, msg):
 795         if not hasattr(msg, '__call__'):
 796             push_translation(encode(module), term_type, encode(model), 0, encode(msg))
 797
 798     def push_local_constraints(module, model, cons_type='sql_constraints'):
 799         """Climb up the class hierarchy and ignore inherited constraints
 800            from other modules"""
 801         term_type = 'sql_constraint' if cons_type == 'sql_constraints' else 'constraint'
 802         msg_pos = 2 if cons_type == 'sql_constraints' else 1
 803         for cls in model.__class__.__mro__:
 804             if getattr(cls, '_module', None) != module:
 805                 continue
 806             constraints = getattr(cls, '_local_' + cons_type, [])
 807             for constraint in constraints:
 808                 push_constraint_msg(module, term_type, model._name, constraint[msg_pos])
 809
 810     for (_, model, module) in cr.fetchall():
 811         model_obj = pool.get(model)
 812
 813         if not model_obj:
 814             _logger.error("Unable to find object %r", model)
 815             continue
 816
 817         if model_obj._constraints:
 818             push_local_constraints(module, model_obj, 'constraints')
 819
 820         if model_obj._sql_constraints:
 821             push_local_constraints(module, model_obj, 'sql_constraints')
 822
 823     def get_module_from_path(path, mod_paths=None):
 824         if not mod_paths:
 825             # First, construct a list of possible paths
 826             def_path = os.path.abspath(os.path.join(config.config['root_path'], 'addons'))     # default addons path (base)
 827             ad_paths= map(lambda m: os.path.abspath(m.strip()),config.config['addons_path'].split(','))
 828             mod_paths=[def_path]
 829             for adp in ad_paths:
 830                 mod_paths.append(adp)
 831                 if not os.path.isabs(adp):
 832                     mod_paths.append(adp)
 833                 elif adp.startswith(def_path):
 834                     mod_paths.append(adp[len(def_path)+1:])
 835         for mp in mod_paths:
 836             if path.startswith(mp) and (os.path.dirname(path) != mp):
 837                 path = path[len(mp)+1:]
 838                 return path.split(os.path.sep)[0]
 839         return 'base'   # files that are not in a module are considered as being in 'base' module
 840
 841     modobj = pool.get('ir.module.module')
 842     installed_modids = modobj.search(cr, uid, [('state', '=', 'installed')])
 843     installed_modules = map(lambda m: m['name'], modobj.read(cr, uid, installed_modids, ['name']))
 844
 845     root_path = os.path.join(config.config['root_path'], 'addons')
 846
 847     apaths = map(os.path.abspath, map(str.strip, config.config['addons_path'].split(',')))
 848     if root_path in apaths:
 849         path_list = apaths
 850     else :
 851         path_list = [root_path,] + apaths
 852
 853     # Also scan these non-addon paths
 854     for bin_path in ['osv', 'report' ]:
 855         path_list.append(os.path.join(config.config['root_path'], bin_path))
 856
 857     _logger.debug("Scanning modules at paths: %s", path_list)
 858
 859     mod_paths = []
 860
 861     def verified_module_filepaths(fname, path, root):
 862         fabsolutepath = join(root, fname)
 863         frelativepath = fabsolutepath[len(path):]
 864         display_path = "addons%s" % frelativepath
 865         module = get_module_from_path(fabsolutepath, mod_paths=mod_paths)
 866         if ('all' in modules or module in modules) and module in installed_modules:
 867             return module, fabsolutepath, frelativepath, display_path
 868         return None, None, None, None
 869
 870     def babel_extract_terms(fname, path, root, extract_method="python", trans_type='code',
 871                                extra_comments=None, extract_keywords={'_': None}):
 872         module, fabsolutepath, _, display_path = verified_module_filepaths(fname, path, root)
 873         extra_comments = extra_comments or []
 874         if module:
 875             src_file = open(fabsolutepath, 'r')
 876             try:
 877                 for extracted in extract.extract(extract_method, src_file,
 878                                                  keywords=extract_keywords):
 879                     # Babel 0.9.6 yields lineno, message, comments
 880                     # Babel 1.3 yields lineno, message, comments, context
 881                     lineno, message, comments = extracted[:3]
 882                     push_translation(module, trans_type, display_path, lineno,
 883                                      encode(message), comments + extra_comments)
 884             except Exception:
 885                 _logger.exception("Failed to extract terms from %s", fabsolutepath)
 886             finally:
 887                 src_file.close()
 888
 889     for path in path_list:
 890         _logger.debug("Scanning files of modules at %s", path)
 891         for root, dummy, files in osutil.walksymlinks(path):
 892             for fname in fnmatch.filter(files, '*.py'):
 893                 babel_extract_terms(fname, path, root)
 894             # mako provides a babel extractor: http://docs.makotemplates.org/en/latest/usage.html#babel
 895             for fname in fnmatch.filter(files, '*.mako'):
 896                 babel_extract_terms(fname, path, root, 'mako', trans_type='report')
 897             # Javascript source files in the static/src/js directory, rest is ignored (libs)
 898             if fnmatch.fnmatch(root, '*/static/src/js*'):
 899                 for fname in fnmatch.filter(files, '*.js'):
 900                     babel_extract_terms(fname, path, root, 'javascript',
 901                                         extra_comments=[WEB_TRANSLATION_COMMENT],
 902                                         extract_keywords={'_t': None, '_lt': None})
 903             # QWeb template files
 904             if fnmatch.fnmatch(root, '*/static/src/xml*'):
 905                 for fname in fnmatch.filter(files, '*.xml'):
 906                     babel_extract_terms(fname, path, root, 'openerp.tools.translate:babel_extract_qweb',
 907                                         extra_comments=[WEB_TRANSLATION_COMMENT])
 908
 909     out = []
 910     _to_translate.sort()
 911     # translate strings marked as to be translated
 912     for module, source, name, id, type, comments in _to_translate:
 913         trans = '' if not lang else trans_obj._get_source(cr, uid, name, type, lang, source)
 914         out.append([module, type, name, id, source, encode(trans) or '', comments])
 915     return out
 916
 917 def trans_load(cr, filename, lang, verbose=True, module_name=None, context=None):
 918     try:
 919         fileobj = misc.file_open(filename)
 920         _logger.info("loading %s", filename)
 921         fileformat = os.path.splitext(filename)[-1][1:].lower()
 922         result = trans_load_data(cr, fileobj, fileformat, lang, verbose=verbose, module_name=module_name, context=context)
 923         fileobj.close()
 924         return result
 925     except IOError:
 926         if verbose:
 927             _logger.error("couldn't read translation file %s", filename)
 928         return None
 929
 930 def trans_load_data(cr, fileobj, fileformat, lang, lang_name=None, verbose=True, module_name=None, context=None):
 931     """Populates the ir_translation table."""
 932     if verbose:
 933         _logger.info('loading translation file for language %s', lang)
 934     if context is None:
 935         context = {}
 936     db_name = cr.dbname
 937     pool = pooler.get_pool(db_name)
 938     lang_obj = pool.get('res.lang')
 939     trans_obj = pool.get('ir.translation')
 940     iso_lang = misc.get_iso_codes(lang)
 941     try:
 942         ids = lang_obj.search(cr, SUPERUSER_ID, [('code','=', lang)])
 943
 944         if not ids:
 945             # lets create the language with locale information
 946             lang_obj.load_lang(cr, SUPERUSER_ID, lang=lang, lang_name=lang_name)
 947
 948
 949         # now, the serious things: we read the language file
 950         fileobj.seek(0)
 951         if fileformat == 'csv':
 952             reader = csv.reader(fileobj, quotechar='"', delimiter=',')
 953             # read the first line of the file (it contains columns titles)
 954             for row in reader:
 955                 f = row
 956                 break
 957         elif fileformat == 'po':
 958             reader = TinyPoFile(fileobj)
 959             f = ['type', 'name', 'res_id', 'src', 'value', 'comments']
 960         else:
 961             _logger.error('Bad file format: %s', fileformat)
 962             raise Exception(_('Bad file format'))
 963
 964         # read the rest of the file
 965         line = 1
 966         irt_cursor = trans_obj._get_import_cursor(cr, SUPERUSER_ID, context=context)
 967
 968         for row in reader:
 969             line += 1
 970             # skip empty rows and rows where the translation field (=last fiefd) is empty
 971             #if (not row) or (not row[-1]):
 972             #    continue
 973
 974             # dictionary which holds values for this line of the csv file
 975             # {'lang': ..., 'type': ..., 'name': ..., 'res_id': ...,
 976             #  'src': ..., 'value': ..., 'module':...}
 977             dic = dict.fromkeys(('name', 'res_id', 'src', 'type', 'imd_model', 'imd_name', 'module', 'value', 'comments'))
 978             dic['lang'] = lang
 979             for i, field in enumerate(f):
 980                 dic[field] = row[i]
 981
 982             # This would skip terms that fail to specify a res_id
 983             if not dic.get('res_id'):
 984                 continue
 985
 986             res_id = dic.pop('res_id')
 987             if res_id and isinstance(res_id, (int, long)) \
 988                 or (isinstance(res_id, basestring) and res_id.isdigit()):
 989                     dic['res_id'] = int(res_id)
 990                     dic['module'] = module_name
 991             else:
 992                 tmodel = dic['name'].split(',')[0]
 993                 if '.' in res_id:
 994                     tmodule, tname = res_id.split('.', 1)
 995                 else:
 996                     tmodule = False
 997                     tname = res_id
 998                 dic['imd_model'] = tmodel
 999                 dic['imd_name'] =  tname
1000                 dic['module'] = tmodule
1001                 dic['res_id'] = None
1002
1003             irt_cursor.push(dic)
1004
1005         irt_cursor.finish()
1006         trans_obj.clear_caches()
1007         if verbose:
1008             _logger.info("translation file loaded succesfully")
1009     except IOError:
1010         filename = '[lang: %s][format: %s]' % (iso_lang or 'new', fileformat)
1011         _logger.exception("couldn't read translation file %s", filename)
1012
1013 def get_locales(lang=None):
1014     if lang is None:
1015         lang = locale.getdefaultlocale()[0]
1016
1017     if os.name == 'nt':
1018         lang = _LOCALE2WIN32.get(lang, lang)
1019
1020     def process(enc):
1021         ln = locale._build_localename((lang, enc))
1022         yield ln
1023         nln = locale.normalize(ln)
1024         if nln != ln:
1025             yield nln
1026
1027     for x in process('utf8'): yield x
1028
1029     prefenc = locale.getpreferredencoding()
1030     if prefenc:
1031         for x in process(prefenc): yield x
1032
1033         prefenc = {
1034             'latin1': 'latin9',
1035             'iso-8859-1': 'iso8859-15',
1036             'cp1252': '1252',
1037         }.get(prefenc.lower())
1038         if prefenc:
1039             for x in process(prefenc): yield x
1040
1041     yield lang
1042
1043
1044
1045 def resetlocale():
1046     # locale.resetlocale is bugged with some locales.
1047     for ln in get_locales():
1048         try:
1049             return locale.setlocale(locale.LC_ALL, ln)
1050         except locale.Error:
1051             continue
1052
1053 def load_language(cr, lang):
1054     """Loads a translation terms for a language.
1055     Used mainly to automate language loading at db initialization.
1056
1057     :param lang: language ISO code with optional _underscore_ and l10n flavor (ex: 'fr', 'fr_BE', but not 'fr-BE')
1058     :type lang: str
1059     """
1060     pool = pooler.get_pool(cr.dbname)
1061     language_installer = pool.get('base.language.install')
1062     uid = 1
1063     oid = language_installer.create(cr, uid, {'lang': lang})
1064     language_installer.lang_install(cr, uid, [oid], context=None)
1065
1066 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
1067