~chromium-team/chromium-browser/chromium-translations-tools.head

#!/usr/bin/python

# -*- coding: utf-8 -*-

# (c) 2010-2011, Fabien Tassin <fta@ubuntu.com>

# Convert grd/xtb files into pot/po for integration into the Launchpad

# translation system

## grd files contain the strings for the 'pot' file(s).

## Keys are alphabetical (IDS_XXX).

# Sources:

# - $SRC/chrome/app/*.grd

# - $SRC/webkit/glue/*.grd

## xtb files are referenced to by the grd files. They contain the translated

## strings for the 'po' our files. Keys are numerical (64bit ids).

# Sources:

# - $SRC/chrome/app/resources/*.xtb

# - $SRC/webkit/glue/resources/*.xtb

# and for launchpad contributed strings that already landed:

# - $SRC/third_party/launchpad_translations/*.xtb

## the mapping between those keys is done using FingerPrint()

## [ taken from grit ] on a stripped version of the untranslated string

## grd files contain a lot of <if expr="..."> (python-like) conditions.

## Evaluate those expressions but only skip strings with a lang restriction.

## For all other conditions (os, defines), simply expose them so translators

## know when a given string is expected.

## TODO: handle <message translateable="false">

import os, sys, shutil, re, getopt, codecs, urllib

from xml.dom import minidom

from xml.sax.saxutils import unescape

from datetime import datetime

from difflib import unified_diff

import textwrap, filecmp, json

lang_mapping = {

  'no':    'nb', # 'no' is obsolete and the more specific 'nb' (Norwegian Bokmal)

                 # and 'nn' (Norwegian Nynorsk) are preferred.

  'pt-PT': 'pt'

}

####

# vanilla from $SRC/tools/grit/grit/extern/FP.py (r10982)

# See svn log http://src.chromium.org/svn/trunk/src/tools/grit/grit/extern/FP.py

# Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.

# Use of this source code is governed by a BSD-style license that can be

# found in the LICENSE file.

try:

  import hashlib

  _new_md5 = hashlib.md5

except ImportError:

  import md5

  _new_md5 = md5.new

def UnsignedFingerPrint(str, encoding='utf-8'):

  """Generate a 64-bit fingerprint by taking the first half of the md5

  of the string."""

  hex128 = _new_md5(str).hexdigest()

  int64 = long(hex128[:16], 16)

  return int64

def FingerPrint(str, encoding='utf-8'):

  fp = UnsignedFingerPrint(str, encoding=encoding)

  # interpret fingerprint as signed longs

  if fp & 0x8000000000000000L:

    fp = - ((~fp & 0xFFFFFFFFFFFFFFFFL) + 1)

  return fp

####

class EvalConditions:

  """ A class allowing an <if expr="xx"/> to be evaluated, based on an array of defines,

    a dict of local variables.

    As of Chromium 10:

    - the known defines are:

      [ 'chromeos', '_google_chrome', 'toolkit_views', 'touchui', 'use_titlecase' ]

      On Linux, only [ 'use_titlecase' ] is set.

    - the known variables are:

      'os'  ('linux2' on Linux)

      'lang'

    See http://src.chromium.org/svn/trunk/src/build/common.gypi

  """

  def eval(self, expression, defines = [ 'use_titlecase' ], vars = { 'os': "linux2" }):

    def pp_ifdef(match):

      return str(match.group(1) in defines)

    # evaluate all ifdefs

    expression = re.sub(r"pp_ifdef\('(.*?)'\)", pp_ifdef, expression)

    # evaluate the whole expression using the vars dict

    vars['__builtins__'] = { 'True': True, 'False': False } # prevent eval from using the real current globals

    return eval(expression, vars)

  def lang_eval(self, expression, lang):

    """ only evaluate the expression against the lang, ignore all defines and other variables.

    This is needed to ignore a string that has lang restrictions (numerals, plurals, ..) but

    still keep it even if it's OS or defined don't match the local platform.

    """

    conditions = [ x for x in re.split(r'\s+(and|or)\s+', expression) if x.find('lang') >= 0 ]

    if len(conditions) == 0:

      return True

    assert len(conditions) == 1, "Expression '%s' has multiple lang conditions" % expression

    vars = { 'lang': lang, '__builtins__': { 'True': True, 'False': False } }

    return eval(conditions[0], vars)

  def test(self):

    data = [

      { 'expr': "lang == 'ar'",

        'vars': { 'lang': 'ar' },

        'result': True

        },

      { 'expr': "lang == 'ar'",

        'vars': { 'lang': 'fr' },

        'result': False

        },

      { 'expr': "lang in ['ar', 'ro', 'lv']",

        'vars': { 'lang': 'ar' },

        'result': True

        },

      { 'expr': "lang in ['ar', 'ro', 'lv']",

        'vars': { 'lang': 'pt-BR' },

        'result': False

        },

      { 'expr': "lang not in ['ar', 'ro', 'lv']",

        'vars': { 'lang': 'ar' },

        'result': False

        },

      { 'expr': "lang not in ['ar', 'ro', 'lv']",

        'vars': { 'lang': 'no' },

        'result': True

        },

      { 'expr': "os != 'linux2' and os != 'darwin' and os.find('bsd') == -1",

        'vars': { 'lang': 'no', 'os': 'bsdos' },

        'result': False,

        'lresult': True  # no lang restriction in 'expr', so 'no' is ok

        },

      { 'expr': "os != 'linux2' and os != 'darwin' and os.find('bsd') > -1",

        'vars': { 'lang': 'no', 'os': 'bsdos' },

        'result': True,

        },

      { 'expr': "not pp_ifdef('chromeos')",

        'vars': { 'lang': 'no' },

        'defines': [],

        'result': True,

        },

      { 'expr': "not pp_ifdef('chromeos')",

        'vars': { 'lang': 'no' },

        'defines': [ 'chromeos' ],

        'result': False,

        'lresult': True  # no lang restriction in 'expr', so 'no' is ok

        },

      { 'expr': "pp_ifdef('_google_chrome') and (os == 'darwin')",

        'vars': { 'lang': 'no', 'os': 'linux2' },

        'defines': [ 'chromeos' ],

        'result': False,

        'lresult': True  # no lang restriction in 'expr', so 'no' is ok

        },

      { 'expr': "pp_ifdef('_google_chrome') and (os == 'darwin')",

        'vars': { 'lang': 'no', 'os': 'darwin' },

        'defines': [ '_google_chrome' ],

        'result': True

        },

      { 'expr': "not pp_ifdef('chromeos') and pp_ifdef('_google_chrome') and 'pt-PT' == lang",

        'vars': { 'lang': 'pt-PT', 'os': 'darwin' },

        'defines': [ '_google_chrome' ],

        'result': True

        },

      { 'expr': "not pp_ifdef('chromeos') and pp_ifdef('_google_chrome') and 'pt-PT' == lang",

        'vars': { 'lang': 'pt-PT', 'os': 'darwin' },

        'defines': [ ],

        'result': False,

        'lresult': True

        },

     ]

    i = -1

    for d in data:

      i += 1

      defines = d['defines'] if 'defines' in d else []

      vars = d['vars'] if 'vars' in d else {}

      lvars = vars.copy() # make a copy because eval modifies it

      res = self.eval(d['expr'], defines = defines, vars = lvars)

      assert res == d['result'], "FAILED %d: expr: \"%s\" returned %s with vars = %s and defines = %s" % \

          (i, d['expr'], repr(res), repr(vars), repr(defines))

    print "All %d tests passed for EvalConditions.eval()" % (i + 1)

    i = -1

    for d in data:

      i += 1

      assert 'lang' in vars, "All test must have a 'lang' in 'vars', test %d doesn't: %s" % (i, repr(d))

      res = self.lang_eval(d['expr'], lang = d['vars']['lang'])

      expected = d['lresult'] if 'lresult' in d else d['result']

      assert res == expected, "FAILED %d: expr: \"%s\" returned %s with lang = %s for the lang_eval test" % \

          (i, d['expr'], repr(res), d['vars']['lang'])

    print "All %d tests passed for EvalConditions.lang_eval()" % (i + 1)

class StringCvt:

  """ A class converting grit formatted strings to gettext back and forth.

    The idea is to always have:

    a/ grd2gettext(xtb2gettext(s)) == s

    b/ xtb2gettext(s) produces a string that the msgfmt checker likes and

    that makes sense to translators

    c/ grd2gettext(s) produces a string acceptable by upstream

  """

  def xtb2gettext(self, string):

    """ parse the xtb (xml encoded) string and convert it to a gettext string """

    def fold(string):

      return textwrap.wrap(string, break_long_words=False, width=76, drop_whitespace=False,

                           expand_tabs=False, replace_whitespace=False, break_on_hyphens=False)

    s = string.replace('\\n', '\\\\n')

    # escape all single '\' (not followed by 'n')

    s = re.sub(r'(?<!\\)(\\[^n\\\\])', r'\\\1', s)

    # remove all xml encodings

    s = self.unescape_xml(s)

    # replace '<ph name="FOO"/>' by '%{FOO}'

    s = re.sub(r'<ph name="(.*?)"/>', r'%{\1}', s)

    # fold

    # 1/ fold at \n

    # 2/ fold each part at ~76 char

    v = []

    ll = s.split('\n')

    sz = len(ll)

    if sz > 1:

      i = 0

      for l in ll:

        i += 1

        if i == sz:

          v.extend(fold(l))

        else:

          v.extend(fold(l + '\\n'))

    else:

      v.extend(fold(ll[0]))

    if len(v) > 1:

      v[:0] = [ '' ]

    s = '"' + '"\n"'.join(v)  + '"'

    return s

  def decode_xml_entities(self, string):

    def replace_xmlent(match):

      if match.group(1)[:1] == 'x':

        return unichr(int("0" + match.group(1), 16))

      else:

        return unichr(int(match.group(1)))

    return re.sub(r'&#(x\w+|\d+);', replace_xmlent, string)

  def unescape_xml(self, string):

    string = unescape(string).replace('"', '\\"').replace(''', "'")

    string = self.decode_xml_entities(string)

    return string

  def grd2gettext(self, string):

    """ parse the string returned from minidom and convert it to a gettext string.

    This is similar to str_cvt_xtb2gettext but minidom has its own magic for encoding 

    """

    return self.xtb2gettext(string)

  def gettext2xtb(self, string):

    """ parse the gettext string and convert it to an xtb (xml encoded) string. """

    u = []

    for s in string.split(u'\n'):

      # remove the enclosing double quotes

      u.append(s[1:][:-1])

    s = u"".join(u)

    # encode the xml special chars

    s = s.replace("&", "&") # must be first!

    s = s.replace("<", "&lt;")

    s = s.replace(">", ">")

    s = s.replace('\\"', """)

    # special case, html comments

    s = re.sub(r'&lt;!--(.*?)--&gt;', r'<!--\1-->', s, re.S)

    # replace non-ascii by &#xxx; codes

    # s = s.encode("ascii", "xmlcharrefreplace")

    # replace '%{FOO}' by '<ph name="FOO"/>'

    s = re.sub(r'%{(.*?)}', r'<ph name="\1"/>', s)

    # unquote \\n and \\\\n

    s = re.sub(r'(?<!\\)\\n', r'\n', s)

    # unquote all control chars

    s = re.sub(r'\\\\([^\\])', r'\\\1', s)

    # launchpad seems to always quote tabs 

    s = s.replace("\\t", "\t")

    return s

  def test(self):

    # unit tests

    data = [

      # tab

      { 'id': '0',

        'xtb': u'foo	bar',

        'po': u'"foo	bar"' },

      { 'id': '1',

        'xtb': u'foo\tbar',

        'po': u'"foo\tbar"' },

      # &

      { 'id': '6779164083355903755',

        'xtb': u'Supprime&r',

        'po': u'"Supprime&r"' },

      # "

      { 'id': '4194570336751258953',

        'xtb': u'Activer la fonction "taper pour cliquer"',

        'po': u'"Activer la fonction \\"taper pour cliquer\\""' },

      # < / >

      { 'id': '7615851733760445951',

        'xtb': u'<aucun cookie sélectionné>',

        'po': u'"<aucun cookie sélectionné>"' },

      # <ph name="FOO"/>

      { 'id': '5070288309321689174',

        'xtb': u'<ph name="EXTENSION_NAME"/> :',

        'po': u'"%{EXTENSION_NAME} :"' },

      { 'id': '1467071896935429871',

        'xtb': u'Téléchargement de la mise à jour du système : <ph name="PERCENT"/>% terminé',

        'po': u'"Téléchargement de la mise à jour du système : %{PERCENT}% terminé"' },

      # line folding

      { 'id': '1526811905352917883',

        'xtb': u'Une nouvelle tentative de connexion avec SSL 3.0 a dû être effectuée. Cette opération indique généralement que le serveur utilise un logiciel très ancien et qu\'il est susceptible de présenter d\'autres problèmes de sécurité.',

        'po': u'""\n"Une nouvelle tentative de connexion avec SSL 3.0 a dû être effectuée. Cette "\n"opération indique généralement que le serveur utilise un logiciel très "\n"ancien et qu\'il est susceptible de présenter d\'autres problèmes de sécurité."' },

      { 'id': '7999229196265990314',

        'xtb': u'Les fichiers suivants ont été créés :\n\nExtension : <ph name="EXTENSION_FILE"/>\nFichier de clé : <ph name="KEY_FILE"/>\n\nConservez votre fichier de clé en lieu sûr. Vous en aurez besoin lors de la création de nouvelles versions de l\'extension.',

        'po': u'""\n"Les fichiers suivants ont été créés :\\n"\n"\\n"\n"Extension : %{EXTENSION_FILE}\\n"\n"Fichier de clé : %{KEY_FILE}\\n"\n"\\n"\n"Conservez votre fichier de clé en lieu sûr. Vous en aurez besoin lors de la "\n"création de nouvelles versions de l\'extension."' },

      # quoted LF

      { 'id': '4845656988780854088',

        'xtb': u'Synchroniser uniquement les paramètres et\\ndonnées qui ont changé depuis la dernière connexion\\n(requiert votre mot de passe précédent)',

        'po': u'""\n"Synchroniser uniquement les paramètres et\\\\ndonnées qui ont changé depuis la"\n" dernière connexion\\\\n(requiert votre mot de passe précédent)"' },

      { 'id': '1761265592227862828', # lang: 'el'

        'xtb': u'Συγχρονισμός όλων των ρυθμίσεων και των δεδομένων\\n (ενδέχεται να διαρκέσει ορισμένο χρονικό διάστημα)',

        'po': u'""\n"Συγχρονισμός όλων των ρυθμίσεων και των δεδομένων\\\\n (ενδέχεται να διαρκέσει"\n" ορισμένο χρονικό διάστημα)"' },

      { 'id': '1768211415369530011', # lang: 'de'

        'xtb': u'Folgende Anwendung wird gestartet, wenn Sie diese Anforderung akzeptieren:\\n\\n <ph name="APPLICATION"/>',

        'po': u'""\n"Folgende Anwendung wird gestartet, wenn Sie diese Anforderung "\n"akzeptieren:\\\\n\\\\n %{APPLICATION}"' },

      # weird controls

      { 'id': '5107325588313356747', # lang: 'es-419'

        'xtb': u'Para ocultar el acceso a este programa, debes desinstalarlo. Para ello, utiliza\\n<ph name="CONTROL_PANEL_APPLET_NAME"/> del Panel de control.\\n\¿Deseas iniciar <ph name="CONTROL_PANEL_APPLET_NAME"/>?',

        'po': u'""\n"Para ocultar el acceso a este programa, debes desinstalarlo. Para ello, "\n"utiliza\\\\n%{CONTROL_PANEL_APPLET_NAME} del Panel de control.\\\\n\\\\¿Deseas "\n"iniciar %{CONTROL_PANEL_APPLET_NAME}?"' }

    ]

    for string in data:

      s = u"<x>" + string['xtb'] + u"</x>"

      s = s.encode('ascii', 'xmlcharrefreplace')

      dom = minidom.parseString(s)

      s = dom.firstChild.toxml()[3:][:-4]

      e = self.grd2gettext(s)

      if e != string['po']:

        assert False, "grd2gettext() failed for id " + string['id'] + \

            ". \nExpected: " + repr(string['po']) + "\nGot:      " + repr(e)

      e = self.xtb2gettext(string['xtb'])

      if e != string['po']:

        assert False, "xtb2gettext() failed for id " + string['id'] + \

            ". \nExpected: " + repr(string['po']) + "\nGot:      " + repr(e)

      u = self.gettext2xtb(e)

      if u != string['xtb']:

        assert False, "gettext2xtb() failed for id " + string['id'] + \

            ". \nExpected: " + repr(string['xtb']) + "\nGot:      " + repr(u)

      print string['id'] + " ok"

    # more tests with only po to xtb to test some weird launchpad po exports

    data2 = [

      { 'id': '1768211415369530011', # lang: 'de'

        'po': u'""\n"Folgende Anwendung wird gestartet, wenn Sie diese Anforderung akzeptieren:\\\\"\n"n\\\\n %{APPLICATION}"',

        'xtb': u'Folgende Anwendung wird gestartet, wenn Sie diese Anforderung akzeptieren:\\n\\n <ph name="APPLICATION"/>' },

      ]

    for string in data2:

      u = self.gettext2xtb(string['po'])

      if u != string['xtb']:

        assert False, "gettext2xtb() failed for id " + string['id'] + \

            ". \nExpected: " + repr(string['xtb']) + "\nGot:      " + repr(u)

      print string['id'] + " ok"

######

class PotFile(dict):

  """

 Read and write gettext pot files

  """

  def __init__(self, filename, date = None, debug = False, branch_name = "default", branch_dir = os.getcwd()):

    self.debug = debug

    self.lang = None

    self.filename = filename

    self.tfile = filename + ".new"

    self.branch_dir = branch_dir

    self.branch_name = branch_name

    self.template_date = date

    self.translation_date = "YEAR-MO-DA HO:MI+ZONE"

    self.is_pot = True

    self.fd = None

    self.fd_mode = "rb"

    if self.template_date is None:

      self.template_date = datetime.utcnow().strftime("%Y-%m-%d %H:%M+0000")

    self.strings = []

  def add_string(self, id, comment, string, translation = "", origin = None):

    self.strings.append({ 'id': id, 'comment': comment, 'string': string,

                          'origin': origin, 'translation': translation })

  def replace_file_if_newer(self):

    filename = os.path.join(self.branch_dir, self.filename) if self.branch_dir is not None \

        else self.filename

    tfile = os.path.join(self.branch_dir, self.tfile) if self.branch_dir is not None \

        else self.tfile

    if os.path.isfile(filename) and filecmp.cmp(filename, tfile) == 1:

      os.unlink(tfile)

      return 0

    else:

      os.rename(tfile, filename)

      return 1

  def get_mtime(self, file):

    rfile = os.path.join(self.branch_dir, file)

    if self.debug:

      print "getmtime(%s) [%s]" % (file, os.path.abspath(rfile))

    return os.path.getmtime(rfile)

  def open(self, mode = "rb", filename = None):

    if filename is not None:

      self.filename = filename

      self.tfile = filename + ".new"

    rfile = os.path.join(self.branch_dir, self.filename)

    rtfile = os.path.join(self.branch_dir, self.tfile)

    if self.fd is not None:

      self.close()

    self.fd_mode = mode

    if mode.find("r") != -1:

      if self.debug:

        print "open %s [mode=%s] from branch '%s' [%s]" % (self.filename, mode, self.branch_name, os.path.abspath(rfile))

      self.fd = codecs.open(rfile, mode, encoding="utf-8")

    else:

      if self.debug:

        print "open %s [mode=%s] from branch '%s' [%s]" % (self.tfile, mode, self.branch_name, os.path.abspath(rtfile))

      self.fd = codecs.open(rtfile, mode, encoding="utf-8")

  def close(self):

    self.fd.close()

    self.fd = None

    if self.fd_mode.find("w") != -1:

      return self.replace_file_if_newer()

  def read_string(self):

    string = {}

    cur = None

    while 1:

      s = self.fd.readline()

      if len(s) == 0 or s == "\n":

        break # EOF or end of block

      if s.rfind('\n') == len(s) - 1:

        s = s[:-1]  # chomp

      if s.find("# ") == 0 or s == "#":  # translator-comment

        if 'comment' not in string:

          string['comment'] = ''

        string['comment'] += s[2:]

        continue

      if s.find("#:") == 0: # reference

        if 'reference' not in string:

          string['reference'] = ''

        string['reference'] += s[2:]

        if s[2:].find(" id: ") == 0:

          string['id'] = s[7:].split(' ')[0]

        continue

      if s.find("#.") == 0: # extracted-comments

        if 'extracted' not in string:

          string['extracted'] = ''

        string['extracted'] += s[2:]

        if s[2:].find(" - condition: ") == 0:

          if 'conditions' not in string:

            string['conditions'] = []

          string['conditions'].append(s[16:])

        continue

      if s.find("#~") == 0: # obsolete messages

        continue

      if s.find("#") == 0: # something else

        print "%s not expected. Skip" % repr(s)

        continue  # not supported/expected

      if s.find("msgid ") == 0:

        cur = "string"

        if cur not in string:

          string[cur] = u""

        else:

          string[cur] += "\n"

        string[cur] += s[6:]

        continue

      if s.find("msgstr ") == 0:

        cur = "translation"

        if cur not in string:

          string[cur] = u""

        else:

          string[cur] += "\n"

        string[cur] += s[7:]

        continue

      if s.find('"') == 0:

        if cur is None:

          print "'%s' not expected here. Skip" % s

          continue

        string[cur] += "\n" + s

        continue

      print "'%s' not expected here. Skip" % s

    return None if string == {} else string

  def write(self, string):

    self.fd.write(string)

  def write_header(self):

    lang_team = "LANGUAGE <LL@li.org>" if self.is_pot else "%s <%s@li.org>" % (self.lang, self.lang)

    lang_str = "template" if self.is_pot else "for lang '%s'" % self.lang

    date = "YEAR-MO-DA HO:MI+ZONE" if self.is_pot else \

        datetime.fromtimestamp(self.translation_date).strftime("%Y-%m-%d %H:%M+0000")

    self.write("# Chromium Translations %s.\n" 

               "# Copyright (C) 2010-2011 Fabien Tassin\n"

               "# This file is distributed under the same license as the chromium-browser package.\n"

               "# Fabien Tassin <fta@ubuntu.com>, 2010-2011.\n"

               "#\n" % lang_str)

    # FIXME: collect contributors (can LP export them?)

    self.write('msgid ""\n'

               'msgstr ""\n'

               '"Project-Id-Version: chromium-browser.head\\n"\n'

               '"Report-Msgid-Bugs-To: https://bugs.launchpad.net/ubuntu/+source/chromium-browser/+filebug\\n"\n'

               '"POT-Creation-Date: %s\\n"\n'

               '"PO-Revision-Date: %s\\n"\n'

               '"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"\n'

               '"Language-Team: %s\\n"\n'

               '"MIME-Version: 1.0\\n"\n'

               '"Content-Type: text/plain; charset=UTF-8\\n"\n'

               '"Content-Transfer-Encoding: 8bit\\n"\n\n' % \

                 (datetime.fromtimestamp(self.template_date).strftime("%Y-%m-%d %H:%M+0000"),

                  date, lang_team))

  def write_footer(self):

    pass

  def write_all_strings(self):

    for string in self.strings:

      self.write(u"#. %s\n" % u"\n#. ".join(string['comment'].split("\n")))

      self.write(u"#: id: %s (used in the following branches: %s)\n" % \

                   (string['id'], ", ".join(string['origin'])))

      self.write(u'msgid %s\n' % StringCvt().xtb2gettext(string['string']))

      self.write(u'msgstr %s\n\n' % StringCvt().xtb2gettext(string['translation']))

  def export_file(self, directory = None, filename = None):

    self.open(mode = "wb", filename = filename)

    self.write_header()

    self.write_all_strings()

    self.write_footer()

    return self.close()

  def import_file(self):

    self.mtime = self.get_mtime(self.filename)

    self.open()

    while 1:

      string = self.read_string()

      if string is None:

        break

      self.strings.append(string)

    self.close()

  def pack_comment(self, data):

    comment = ""

    for ent in sorted(data, lambda x,y: cmp(x['code'], y['code'])):

      comment += "%s\n- description: %s\n" % (ent['code'], ent['desc'])

      if ent['test'] is not None:

        comment += "- condition: %s\n" % ent['test']

    comment = comment[:-1] # strip trailing \n

    return comment

  def get_origins(self, data):

    o = []

    for ent in sorted(data, lambda x,y: cmp(x['code'], y['code'])):

      for origin in ent['origin']:

        if origin not in o:

          o.append(origin)

    return o

  def import_grd(self, grd):

    imported = 0

    for id in sorted(grd.supported_ids.keys()):

      if 'ids' not in grd.supported_ids[id]:

        continue

      comment = self.pack_comment(grd.supported_ids[id]['ids'])

      string = grd.supported_ids[id]['ids'][0]['val']

      origin = self.get_origins(grd.supported_ids[id]['ids'])

      self.strings.append({ 'id': id, 'comment': comment, 'string': string,

                            'origin': origin, 'translation': '' })

      imported += 1

    if self.debug:

      print "imported %d strings from the grd template" % imported

class PoFile(PotFile):

  """

 Read and write gettext po files

  """

  def __init__(self, lang, filename, template, date = None, debug = None,

               branch_name = "default", branch_dir = os.getcwd()):

    super(PoFile, self).__init__(filename, date = template.template_date, debug = debug,

                                 branch_name = branch_name, branch_dir = branch_dir)

    self.template = template

    self.lang = lang

    self.translation_date = date

    self.is_pot = False

  def import_xtb(self, xtb):

    # only import strings present in the current template

    imported = 0

    for id in sorted(xtb.template.supported_ids.keys()):

      if 'ids' not in xtb.template.supported_ids[id]:

        continue

      translation = xtb.strings[id] if id in xtb.strings else ""

      comment = self.template.pack_comment(xtb.template.supported_ids[id]['ids'])

      string = xtb.template.supported_ids[id]['ids'][0]['val']