def convertmixedunit(self, labeldtd, accesskeydtd):
     labelpo = self.convertunit(labeldtd)
     accesskeypo = self.convertunit(accesskeydtd)
     if labelpo is None:
         return accesskeypo
     if accesskeypo is None:
         return labelpo
     thepo = po.pounit(encoding="UTF-8")
     thepo.addlocations(labelpo.getlocations())
     thepo.addlocations(accesskeypo.getlocations())
     thepo.msgidcomment = thepo._extract_msgidcomments() + labelpo._extract_msgidcomments()
     thepo.msgidcomment = thepo._extract_msgidcomments() + accesskeypo._extract_msgidcomments()
     thepo.addnote(labelpo.getnotes("developer"), "developer")
     thepo.addnote(accesskeypo.getnotes("developer"), "developer")
     thepo.addnote(labelpo.getnotes("translator"), "translator")
     thepo.addnote(accesskeypo.getnotes("translator"), "translator")
     # redo the strings from original dtd...
     label = dtd.unquotefromdtd(labeldtd.definition).decode('UTF-8')
     accesskey = dtd.unquotefromdtd(accesskeydtd.definition).decode('UTF-8')
     label = accesskeyfn.combine(label, accesskey)
     if label is None:
         return None
     thepo.source = label
     thepo.target = ""
     return thepo

    def converttransunit(self, transunit):
        """makes a pounit from the given transunit"""
        thepo = po.pounit()

        # Header
        if transunit.getrestype() == "x-gettext-domain-header":
            thepo.source = ""
        else:
            thepo.source = transunit.source
        thepo.target = transunit.target

        # Location comments
        locations = transunit.getlocations()
        if locations:
            thepo.addlocations(locations)

        # NOTE: Supporting both <context> and <note> tags in xliff files
        # for comments
        # Translator comments
        trancomments = transunit.getnotes("translator")
        if trancomments:
            thepo.addnote(trancomments, origin="translator")

        # Automatic and Developer comments
        autocomments = transunit.getnotes("developer")
        if autocomments:
            thepo.addnote(autocomments, origin="developer")

        # See 5.6.1 of the spec. We should not check fuzzyness, but approved
        # attribute
        if transunit.isfuzzy():
            thepo.markfuzzy(True)

        return thepo

 def convertunit(self, source_str, target_str):
     pounit = po.pounit(encoding="UTF-8")
     pounit.settypecomment('python-format')
     pounit.source = source_str
     if target_str:
         pounit.target = target_str
     return pounit

    def convert_l20nunit(self, unit):
        po_unit = po.pounit(encoding="UTF-8")
        po_unit.setid(unit.getid())
        po_unit.addlocation(unit.getid())
        po_unit.source = unit.value
        po_unit.addnote(unit.comment, "developer")

        return po_unit

 def convertunit(self, csvunit):
     """converts csv unit to po unit"""
     pounit = po.pounit(encoding="UTF-8")
     if csvunit.location:
         pounit.addlocation(csvunit.location)
     pounit.source = csvunit.source
     pounit.target = csvunit.target
     return pounit

 def convertunit(self, inputunit, origin):
     """Converts a .php unit to a .po unit"""
     outputunit = po.pounit(encoding="UTF-8")
     outputunit.addnote(inputunit.getnotes(origin), origin)
     outputunit.addlocation("".join(inputunit.getlocations()))
     outputunit.source = inputunit.source
     outputunit.target = ""
     return outputunit

 def convertmixedunit(self, labeldtd, accesskeydtd):
     label_unit = self.convertunit(labeldtd)
     accesskey_unit = self.convertunit(accesskeydtd)
     if label_unit is None:
         return accesskey_unit
     if accesskey_unit is None:
         return label_unit
     target_unit = po.pounit(encoding="UTF-8")
     return self.mixer.mix_units(label_unit, accesskey_unit, target_unit)

 def convertmixedunit(self, labelprop, accesskeyprop, commenttype):
     label_unit = self.convertunit(labelprop, commenttype)
     accesskey_unit = self.convertunit(accesskeyprop, commenttype)
     if label_unit is None:
         return accesskey_unit
     if accesskey_unit is None:
         return label_unit
     target_unit = po.pounit(encoding="UTF-8")
     return self.mixer.mix_units(label_unit, accesskey_unit, target_unit)

 def count(self, source, expectedsource, target=None, expectedtarget=None):
     """simple helper to check the respective word counts"""
     poelement = po.pounit(source)
     if target is not None:
         poelement.target = target
     wordssource, wordstarget = statsdb.wordsinunit(poelement)
     print('Source (expected=%d; actual=%d): "%s"' % (expectedsource, wordssource, source))
     assert wordssource == expectedsource
     if target is not None:
         print('Target (expected=%d; actual=%d): "%s"' % (expectedtarget, wordstarget, target))
         assert wordstarget == expectedtarget

 def convert_unit(self, input_unit, commenttype):
     """Converts a .rc unit to a .po unit. Returns None if empty
     or not for translation."""
     if input_unit is None:
         return None
     # escape unicode
     output_unit = po.pounit(encoding="UTF-8")
     output_unit.addlocation("".join(input_unit.getlocations()))
     output_unit.source = input_unit.source
     output_unit.target = ""
     return output_unit

def create_pounit(filename, lineno, message, comments):
    unit = po.pounit(encoding='UTF-8')
    context, msgid = split_context(message)
    unit.setsource(msgid)
    if context:
        unit.msgctxt = ['"%s"' % context]
    for comment in comments:
        unit.addnote(comment, 'developer')

    unit.addlocation('%s:%s' % (filename, lineno))
    return unit

 def test_escaping_newline_tabs(self):
     """test that we handle all kinds of newline permutations"""
     dtdsource = '<!ENTITY  noupdatesfound.intro "A hard coded newline.\\nAnd tab\\t and a \\r carriage return.">\n'
     converter = dtd2po.dtd2po()
     thedtd = dtd.dtdunit()
     thedtd.parse(dtdsource)
     thepo = po.pounit()
     converter.convertstrings(thedtd, thepo)
     print(thedtd)
     print(thepo.source)
     # \n in a dtd should also appear as \n in the PO file
     assert thepo.source == r"A hard coded newline.\nAnd tab\t and a \r carriage return."

    def convert_unit(self, input_unit, commenttype):
        """Converts a JSON unit to a PO unit

        :return: None if empty or not for translation
        """
        if input_unit is None:
            return None
        # escape unicode
        output_unit = po.pounit(encoding="UTF-8")
        output_unit.addlocation(input_unit.getid())
        output_unit.source = input_unit.source
        output_unit.target = ""
        return output_unit

 def convertfile(self, tbxfile):
     """Converts a tbxfile to a tbxfile, and returns it. uses templatepo if
     given at construction
     """
     self.pofile = po.pofile()
     for tbxunit in tbxfile.units:
         term = po.pounit()
         term.source = tbxunit.source
         term.target = tbxunit.target
         term.setcontext(tbxunit.getnotes('definition'))
         term.addnote("Part of speech: %s" % tbxunit.getnotes('pos'), 'developer')
         self.pofile.addunit(term)
     self.pofile.removeduplicates()
     return self.pofile

    def convert_unit(self, input_unit, commenttype):
        """Converts a RESX unit to a PO unit
        @return: None if empty or not for translation
        """
        if input_unit is None:
            return None

        output_unit = po.pounit(encoding="UTF-8")
        output_unit.addlocation(input_unit.getid())
        output_unit.source = input_unit.source
        output_unit.addnote(input_unit.getnotes("developer"), "developer")
        output_unit.target = ""

        return output_unit

    def maketargetunit(self, part1, part2, translators_comment, key, subkey):
        """makes a base unit (.po or XLIFF) out of a subkey of two parts"""
        #TODO: Do better
        text1 = getattr(part1, subkey)
        if text1 == "":
            return None
        text2 = getattr(part2, subkey)

        unit = po.pounit(text1, encoding="UTF-8")
        unit.target = text2
        unit.addlocation(key + "." + subkey)
        if getattr(translators_comment, subkey).strip() != "":
            unit.addnote(getattr(translators_comment, subkey), origin="developer")
        return unit

 def convertmessage(self, contextname, messagenum, source, target, msgcomments, transtype):
     """makes a pounit from the given message"""
     thepo = po.pounit(encoding="UTF-8")
     thepo.addlocation("%s#%d" % (contextname, messagenum))
     thepo.source = source
     thepo.target = target
     if len(msgcomments) > 0:
         thepo.addnote(msgcomments)
     if transtype == "unfinished" and thepo.istranslated():
         thepo.markfuzzy()
     if transtype == "obsolete":
         # This should use the Gettext obsolete method but it would require quite a bit of work
         thepo.addnote("(obsolete)", origin="developer")
         # using the fact that -- quote -- "(this is nonsense)"
     return thepo

 def convertunit(self, thedtd):
     """converts a dtd unit to a po unit, returns None if empty or not for
     translation"""
     if thedtd is None:
         return None
     if getattr(thedtd, "entityparameter", None) == "SYSTEM":
         return None
     thepo = po.pounit(encoding="UTF-8")
     # remove unwanted stuff
     for commentnum in range(len(thedtd.comments)):
         commenttype, locnote = thedtd.comments[commentnum]
         # if this is a localization note
         if commenttype == 'locnote':
             # parse the locnote into the entity and the actual note
             typeend = quote.findend(locnote, 'LOCALIZATION NOTE')
             # parse the id
             idstart = locnote.find('(', typeend)
             if idstart == -1:
                 continue
             idend = locnote.find(')', (idstart + 1))
             entity = locnote[idstart+1:idend].strip()
             # parse the actual note
             actualnotestart = locnote.find(':', (idend + 1))
             actualnoteend = locnote.find('-->', idend)
             actualnote = locnote[actualnotestart+1:actualnoteend].strip()
             # if it's for this entity, process it
             if thedtd.entity == entity:
                 # if it says don't translate (and nothing more),
                 if actualnote.startswith("DONT_TRANSLATE"):
                     # take out the entity,definition and the
                     # DONT_TRANSLATE comment
                     thedtd.entity = ""
                     thedtd.definition = ""
                     del thedtd.comments[commentnum]
                     # finished this for loop
                     break
                 else:
                     # convert it into an automatic comment, to be
                     # processed by convertcomments
                     thedtd.comments[commentnum] = ("automaticcomment",
                                                    actualnote)
     # do a standard translation
     self.convertcomments(thedtd, thepo)
     self.convertstrings(thedtd, thepo)
     if thepo.isblank() and not thepo.getlocations():
         return None
     else:
         return thepo

    def convertunit(self, dtd_unit):
        """Converts a simple (non-mixed) dtd unit into a po unit.

        Returns None if empty or not for translation.
        """
        if dtd_unit is None:
            return None
        po_unit = po.pounit(encoding="UTF-8")
        # remove unwanted stuff
        for commentnum in range(len(dtd_unit.comments)):
            commenttype, locnote = dtd_unit.comments[commentnum]
            # if this is a localization note
            if commenttype == 'locnote':
                # parse the locnote into the entity and the actual note
                typeend = quote.findend(locnote, 'LOCALIZATION NOTE')
                # parse the id
                idstart = locnote.find('(', typeend)
                if idstart == -1:
                    continue
                idend = locnote.find(')', (idstart + 1))
                entity = locnote[idstart+1:idend].strip()
                # parse the actual note
                actualnotestart = locnote.find(':', (idend + 1))
                actualnoteend = locnote.find('-->', idend)
                actualnote = locnote[actualnotestart+1:actualnoteend].strip()
                # if it's for this entity, process it
                if dtd_unit.getid() == entity:
                    # if it says don't translate (and nothing more),
                    if actualnote.startswith("DONT_TRANSLATE"):
                        # take out the entity,definition and the
                        # DONT_TRANSLATE comment
                        dtd_unit.setid("")
                        dtd_unit.source = ""
                        del dtd_unit.comments[commentnum]
                        # finished this for loop
                        break
                    else:
                        # convert it into an automatic comment, to be
                        # processed by convertcomments
                        dtd_unit.comments[commentnum] = ("automaticcomment",
                                                       actualnote)
        # do a standard translation
        self.convertcomments(dtd_unit, po_unit)
        self.convertstrings(dtd_unit, po_unit)
        if po_unit.isblank() and not po_unit.getlocations():
            return None
        else:
            return po_unit

def create_pounit(filename, lineno, msgid, comments, context):
    # FIXME: Test context handling
    unit = po.pounit(encoding="UTF-8")
    unit.setsource(msgid)
    if context:
        unit.msgctxt = ['"%s"' % context]
    for comment in comments:
        unit.addnote(comment, "developer")

    unit.addlocation("%s:%s" % (filename, lineno))
    # FIXME: Add variable format flags
    # if python-format:
    #     unit.settypecomment('python-format', present=True)
    # if python-brace-format:
    #     unit.settypecomment('python-brace-format', present=True)
    return unit