Python po.pofile函数代码示例

def convertpo(inputfile, outputfile, templatefile):
  """reads in stdin using fromfileclass, converts using convertorclass, writes to stdout"""
  engstore = po.pofile(inputfile)
  forstore = po.pofile(templatefile)
  convertor = amo2po()
  outputstore = convertor.convertstore(engstore, forstore)
  if outputstore.isempty():
    return 0
  outputfile.write(str(outputstore))
  return 1

def create_pofile_from_babel(extracted):
    try:
        if settings.TOWER_ADD_HEADERS:
            catalog = po.pofile()
        else:
            catalog = po.pofile(inputfile="")
    except AttributeError:
        catalog = po.pofile(inputfile="")
    for filename, lineno, message, comments in extracted:
        unit = create_pounit(filename, lineno, message, comments)
        catalog.addunit(unit)
    catalog.removeduplicates()
    return catalog

def po2xlf(inputfile, originalfile, outputfile, lang = None):
  tree = etree.parse(originalfile)

  po = pofile()
  po.parse(open(inputfile))

  if lang is not None:
    fileNode = tree.xpath("//xlf:file", namespaces=namespaces)[0]
    fileNode.attrib['target-language'] = lang

  for po_unit in po.units:
    if po_unit.obsolete or len(po_unit.msgctxt) != 1:
      continue
    msgctxt = po_unit.msgctxt[0]
    nodes = tree.xpath('//xlf:trans-unit[@id={0}]'.format(msgctxt), namespaces=namespaces)
    if len(nodes) != 1:
      print 'WARNING: XLIFF file missing trans-unit with id {0}.'.format(msgctxt)
      continue
    tu = nodes[0]
    target = tu.xpath('xlf:target', namespaces=namespaces)
    if len(target) == 0:
      target = etree.Element('target', nsmap=namespaces)
      tu.append(target)
    else:
      target = target[0]
    target_text = unicode(po_unit.gettarget())
    if target_text is not None:
      target.text = target_text
  tree.write(outputfile, encoding='UTF-8')

 def po2dtd(self, posource, remove_untranslated=False):
     """helper that converts po source to dtd source without requiring files"""
     inputfile = wStringIO.StringIO(posource)
     inputpo = po.pofile(inputfile)
     convertor = po2dtd.po2dtd(remove_untranslated=remove_untranslated)
     outputdtd = convertor.convertstore(inputpo)
     return outputdtd

    def outputconflicts(self, options):
        """saves the result of the conflict match"""
        print("%d/%d different strings have conflicts" % (len(self.conflictmap), len(self.textmap)))
        reducedmap = {}

        def str_len(x):
            return len(x)

        for source, translations in six.iteritems(self.conflictmap):
            words = source.split()
            words.sort(key=str_len)
            source = words[-1]
            reducedmap.setdefault(source, []).extend(translations)
        # reduce plurals
        plurals = {}
        for word in reducedmap:
            if word + "s" in reducedmap:
                plurals[word] = word + "s"
        for word, pluralword in six.iteritems(plurals):
            reducedmap[word].extend(reducedmap.pop(pluralword))
        for source, translations in six.iteritems(reducedmap):
            flatsource = self.flatten(source, "-")
            fulloutputpath = os.path.join(options.output, flatsource + os.extsep + "po")
            conflictfile = po.pofile()
            for target, unit, filename in translations:
                unit.othercomments.append("# (poconflicts) %s\n" % filename)
                conflictfile.units.append(unit)
            with open(fulloutputpath, "wb") as fh:
                conflictfile.serialize(fh)

 def mergestore(self, origpropfile, translatedpropfile, personality="java",
                blankmsgstr=False, duplicatestyle="msgctxt"):
     """converts two .properties files to a .po file..."""
     self.personality = personality
     thetargetfile = po.pofile()
     if self.personality in ("mozilla", "skype"):
         targetheader = thetargetfile.init_headers(
                 x_accelerator_marker="&",
                 x_merge_on="location",
         )
     else:
         targetheader = thetargetfile.header()
     targetheader.addnote("extracted from %s, %s" % (origpropfile.filename, translatedpropfile.filename),
                          "developer")
     translatedpropfile.makeindex()
     # we try and merge the header po with any comments at the start of
     # the properties file
     appendedheader = False
     waitingcomments = []
     # loop through the original file, looking at units one by one
     for origprop in origpropfile.units:
         origpo = self.convertunit(origprop, "developer")
         if origpo is None:
             waitingcomments.extend(origprop.comments)
         # FIXME the storage class should not be creating blank units
         if origpo is "discard":
             continue
         # handle the header case specially...
         if not appendedheader:
             if origprop.isblank():
                 targetheader.addnote("".join(waitingcomments).rstrip(),
                                      "developer", position="prepend")
                 waitingcomments = []
                 origpo = None
             appendedheader = True
         # try and find a translation of the same name...
         if origprop.name in translatedpropfile.locationindex:
             translatedprop = translatedpropfile.locationindex[origprop.name]
             # Need to check that this comment is not a copy of the
             # developer comments
             translatedpo = self.convertunit(translatedprop, "translator")
             if translatedpo is "discard":
                 continue
         else:
             translatedpo = None
         # if we have a valid po unit, get the translation and add it...
         if origpo is not None:
             if translatedpo is not None and not blankmsgstr:
                 origpo.target = translatedpo.source
             origpo.addnote("".join(waitingcomments).rstrip(),
                            "developer", position="prepend")
             waitingcomments = []
             thetargetfile.addunit(origpo)
         elif translatedpo is not None:
             logger.error("didn't convert original property definition '%s'",
                          origprop.name)
     if self.personality == "gaia":
         thetargetfile = self.fold_gaia_plurals(thetargetfile)
     thetargetfile.removeduplicates(duplicatestyle)
     return thetargetfile

 def po2lang(self, posource):
     """helper that converts po source to .lang source without requiring files"""
     inputfile = wStringIO.StringIO(posource)
     inputpo = po.pofile(inputfile)
     convertor = po2mozlang.po2lang()
     outputlang = convertor.convertstore(inputpo)
     return outputlang

 def test_simplegrep_comments(self):
     """grep for a string in the comments"""
     posource = '# (review) comment\n#: test.c\nmsgid "test"\nmsgstr "rest"\n'
     poresult = self.pogrep(posource, "review", ["--search=comment"])
     assert poresult.index(posource) >= 0
     poresult = self.pogrep(posource, "test", ["--search=comment"])
     assert headerless_len(po.pofile(poresult).units) == 0

 def test_simplegrep_msgstr(self):
     """grep for a string in the target"""
     posource = '#: test.c\nmsgid "test"\nmsgstr "rest"\n'
     poresult = self.pogrep(posource, "rest", ["--search=msgstr"])
     assert poresult.index(posource) >= 0
     poresult = self.pogrep(posource, "test", ["--search=msgstr"])
     assert headerless_len(po.pofile(poresult).units) == 0

 def convertstore(self, inputfile, duplicatestyle="msgctxt"):
     """Converts a .xliff file to .po format"""
     # XXX: The inputfile is converted to string because Pootle supplies
     # XXX: a PootleFile object as input which cannot be sent to PoXliffFile
     # XXX: The better way would be to have a consistent conversion API.
     if not isinstance(inputfile, (io.IOBase, wStringIO.StringIO)):
         inputfile = str(inputfile)
     XliffFile = xliff.xlifffile.parsestring(inputfile)
     thetargetfile = po.pofile()
     targetheader = thetargetfile.header()
     # TODO: support multiple files
     for transunit in XliffFile.units:
         if transunit.isheader():
             thetargetfile.updateheader(add=True, **XliffFile.parseheader())
             if transunit.getnotes('translator'):
                 targetheader.addnote(transunit.getnotes('translator'),
                                      origin='translator',
                                      position='replace')
             if transunit.getnotes('developer'):
                 targetheader.addnote(transunit.getnotes('developer'),
                                      origin='developer',
                                      position='replace')
             targetheader.markfuzzy(transunit.isfuzzy())
             continue
         thepo = self.converttransunit(transunit)
         thetargetfile.addunit(thepo)
     thetargetfile.removeduplicates(duplicatestyle)
     return thetargetfile

    def merge_store(self, template_store, input_store, blankmsgstr=False,
                    duplicatestyle="msgctxt"):
        """Converts two JSON files to a PO file"""
        output_store = po.pofile()
        output_header = output_store.init_headers(charset="UTF-8",
                                                  encoding="8bit")
        output_header.addnote("extracted from %s, %s" % (template_store.filename,
                                                         input_store.filename),
                              "developer")

        input_store.makeindex()
        for template_unit in template_store.units:
            origpo = self.convert_unit(template_unit, "developer")
            # try and find a translation of the same name...
            template_unit_name = "".join(template_unit.getlocations())
            if template_unit_name in input_store.locationindex:
                translatedjson = input_store.locationindex[template_unit_name]
                translatedpo = self.convert_unit(translatedjson, "translator")
            else:
                translatedpo = None
            # if we have a valid po unit, get the translation and add it...
            if origpo is not None:
                if translatedpo is not None and not blankmsgstr:
                    origpo.target = translatedpo.source
                output_store.addunit(origpo)
            elif translatedpo is not None:
                print >> sys.stderr, "Error converting original JSON definition %s" % origpo.name
        output_store.removeduplicates(duplicatestyle)
        return output_store

 def po2lang(self, posource):
     """helper that converts po source to .lang source without requiring files"""
     inputfile = wStringIO.StringIO(posource)
     inputpo = po.pofile(inputfile)
     convertor = po2mozlang.po2lang(mark_active=False)
     outputlang = convertor.convertstore(inputpo)
     return bytes(outputlang).decode('utf-8')

 def po2web2py(self, po_source):
     """helper that converts po source to web2py source without requiring files"""
     input_file = wStringIO.StringIO(po_source)
     input_po = po.pofile(input_file)
     convertor = po2web2py.po2pydict()
     output_web2py = convertor.convertstore(input_po, False)
     return output_web2py.read()

 def test_convertphpempty(self):
     """checks that the convertphp function is working with empty template"""
     phpsource = ''
     phptemplate = ''
     posource = self.convertphp(phpsource, phptemplate, 0)
     pofile = po.pofile(wStringIO.StringIO(posource))
     assert len(pofile.units) == 0

def create_pofile_from_babel(extracted):
    catalog = po.pofile(inputfile="")
    for filename, lineno, message, comments in extracted:
        unit = create_pounit(filename, lineno, message, comments)
        catalog.addunit(unit)
    catalog.removeduplicates()
    return catalog