~launchpad-pqm/launchpad/devel

POFile

======

Get evolution template for Ubuntu Hoary

    >>> import datetime

    >>> import pytz

    >>> from zope.component import getUtility

    >>> from canonical.launchpad.webapp.testing import verifyObject

    >>> from lp.registry.interfaces.distribution import IDistributionSet

    >>> from lp.registry.interfaces.person import IPersonSet

    >>> from lp.services.worlddata.interfaces.language import ILanguageSet

    >>> from lp.registry.interfaces.sourcepackagename import (

    ...     ISourcePackageNameSet)

    >>> from lp.translations.interfaces.pofile import IPOFile

    >>> from lp.translations.interfaces.potemplate import IPOTemplateSet

    >>> sourcepackagenameset = getUtility(ISourcePackageNameSet)

    >>> sourcepackagename = sourcepackagenameset['evolution']

    >>> distributionset = getUtility(IDistributionSet)

    >>> distribution = distributionset['ubuntu']

    >>> series = distribution['hoary']

    >>> potemplateset = getUtility(IPOTemplateSet)

    >>> potemplatesubset = potemplateset.getSubset(

    ...     distroseries=series, sourcepackagename=sourcepackagename)

    >>> potemplate = potemplatesubset['evolution-2.2']

    >>> UTC = pytz.timezone('UTC')

Get Xhosa translation

    >>> pofile = potemplate.getPOFileByLang('xh')

    >>> language_pt_BR = getUtility(

    ...     ILanguageSet).getLanguageByCode('pt_BR')

    >>> dummy_pofile = potemplate.getDummyPOFile(language_pt_BR)

Both implement the IPOFile interface:

    >>> verifyObject(IPOFile, pofile)

    True

    >>> verifyObject(IPOFile, dummy_pofile)

    True

DummyPOFile returns empty SelectResults for getPOTMsgSet* methods,

except for untranslated messages.

    >>> dummy_pofile.getPOTMsgSetTranslated().count()

    0

    >>> dummy_pofile.getPOTMsgSetDifferentTranslations().count()

    0

    >>> dummy_pofile.getPOTMsgSetWithNewSuggestions().count()

    0

    >>> dummy_pofile.getPOTMsgSetUntranslated().count()

    22

Get the set of POTMsgSets that are untranslated.

    >>> potmsgsets = list(pofile.getPOTMsgSetUntranslated())

    >>> len(potmsgsets)

    22

Get Spanish translation

    >>> pofile = potemplate.getPOFileByLang('es')

Get the set of POTMsgSets that are untranslated.

    >>> potmsgsets = list(pofile.getPOTMsgSetUntranslated())

    >>> len(potmsgsets)

    15

We need a helper method to better display test results.

    >>> def print_potmsgsets(potmsgsets, pofile):

    ...     for potmsgset in potmsgsets:

    ...         singular = plural = None

    ...         translation = ""

    ...         if potmsgset.singular_text:

    ...             singular = potmsgset.singular_text

    ...             if len(singular) > 20:

    ...                singular = singular[:17] + "..."

    ...         if potmsgset.plural_text:

    ...             plural = potmsgset.plural_text

    ...             if len(plural) > 20:

    ...                plural = plural[:17] + "..."

    ...         if pofile is not None:

    ...             message = potmsgset.getCurrentTranslation(

    ...                 pofile.potemplate, pofile.language,

    ...                 pofile.potemplate.translation_side)

    ...             if message is not None:

    ...                translation = message.translations[0]

    ...             if len(translation) > 20:

    ...                 translation = translation[:17] + "..."

    ...         print "%2d. %-20s   %-20s   %-20s" % (

    ...             potmsgset.getSequence(pofile.potemplate),

    ...             singular, plural, translation)

getFullLanguageCode

-------------------

Returns the complete code for this POFile's language.

    >>> print potemplate.getPOFileByLang('es').getFullLanguageCode()

    es

    >>> sr_latin = factory.makeLanguage('sr@latin', 'Serbian Latin')

    >>> print potemplate.getDummyPOFile(sr_latin).getFullLanguageCode()

    sr@latin

getFullLanguageName

-------------------

Returns the complete English name for this POFile's language.

    >>> print potemplate.getPOFileByLang('es').getFullLanguageName()

    Spanish

    >>> print potemplate.getDummyPOFile(sr_latin).getFullLanguageName()

    Serbian Latin

findPOTMsgSetsContaining

------------------------

It is common to want to find those POTMsgSets which contain a certain

substring in their original English string.

    >>> found_potmsgsets = (

    ...     dummy_pofile.findPOTMsgSetsContaining(u"contact"))

    >>> found_potmsgsets.count()

    4

    >>> print_potmsgsets(found_potmsgsets, dummy_pofile)

     7. contact's header:      None

    14. The location and ...   None

    15. %d contact             %d contacts

    16. Opening %d contac...   Opening %d contac...

Search is case-insensitive.

    >>> found_potmsgsets = (

    ...     dummy_pofile.findPOTMsgSetsContaining(u"CONTact"))

    >>> found_potmsgsets.count()

    4

    >>> print_potmsgsets(found_potmsgsets, dummy_pofile)

     7. contact's header:      None

    14. The location and ...   None

    15. %d contact             %d contacts

    16. Opening %d contac...   Opening %d contac...

Search will look through plural msgids as well.

    >>> found_potmsgsets = (

    ...     dummy_pofile.findPOTMsgSetsContaining(u"contacts"))

    >>> found_potmsgsets.count()

    2

    >>> print_potmsgsets(found_potmsgsets, dummy_pofile)

    15. %d contact             %d contacts

    16. Opening %d contac...   Opening %d contac...

Looking for a non-existing string returns an empty SelectResults.

    >>> found_potmsgsets = (

    ...     dummy_pofile.findPOTMsgSetsContaining(u"non-existing-string"))

    >>> found_potmsgsets.count()

    0

Trying to find a string shorter than two characters doesn't work.

    >>> found_potmsgsets = (

    ...     dummy_pofile.findPOTMsgSetsContaining(u"a"))

    Traceback (most recent call last):

    ...

    AssertionError: You can not search for strings shorter than 2 characters.

In a Spanish translation, you will also get matching translations.

    >>> found_potmsgsets = (

    ...     pofile.findPOTMsgSetsContaining(u"ventana"))

    >>> found_potmsgsets.count()

    1

    >>> print_potmsgsets(found_potmsgsets, pofile)

    16. Opening %d contac...   Opening %d contac...   Abrir %d contacto...

Searching for translations is case insensitive.

    >>> found_potmsgsets = (

    ...     pofile.findPOTMsgSetsContaining(u"VENTANA"))

    >>> found_potmsgsets.count()

    1

    >>> print_potmsgsets(found_potmsgsets, pofile)

    16. Opening %d contac...   Opening %d contac...   Abrir %d contacto...

Searching for plural forms other than the first one also works.

    >>> found_potmsgsets = (

    ...     pofile.findPOTMsgSetsContaining(u"estos"))

    >>> found_potmsgsets.count()

    1

    >>> print_potmsgsets(found_potmsgsets, pofile)

    16. Opening %d contac...   Opening %d contac...   Abrir %d contacto...

One can find a message by looking for a suggestion (non-current

translation).

    >>> found_potmsgsets = (

    ...     pofile.findPOTMsgSetsContaining(u"tarjetas"))

    >>> found_potmsgsets.count()

    1

    >>> print_potmsgsets(found_potmsgsets, pofile)

     5.  cards                 None                    caratas

path

----

A PO file has a storage path that determines where the file is to be

stored in a filesystem tree (such as an export tarball).  The path ends

with the actual file name and should include a language code.

    >>> pofile_xh = potemplate.getPOFileByLang('xh')

    >>> pofile_xh.path

    u'xh.po'

To change this path, use setPathIfUnique().

    >>> pofile_xh.setPathIfUnique('xh2.po')

    >>> pofile_xh.path

    u'xh2.po'

The path must be unique within its distribution series package or

product release series, so that a single file system tree can contain

all translations found there.

If the given path is not locally unique, setPathIfUnique() simply does

nothing.  There can be no naming conflict in that case because the PO

file's existing path is already supposed to be unique.

Here we try to copy the path of another translation of the same template

but the PO file correctly retains its original path.

    >>> pofile_xh.setPathIfUnique(pofile.path)

    >>> pofile_xh.path

    u'xh2.po'

updateHeader()

--------------

This method is used to update the header of the POFile to a newer

version.

This is the new header we are going to apply.

    >>> new_header_string = '''Project-Id-Version: es

    ... POT-Creation-Date: 2004-08-18 11:10+0200

    ... PO-Revision-Date: 2005-08-18 13:22+0000

    ... Last-Translator: Carlos Perell\xc3\xb3 Mar\xc3\xadn

    ... <carlos@canonical.com>

    ... Language-Team: Spanish <traductores@es.gnome.org>

    ... MIME-Version: 1.0

    ... Content-Type: text/plain; charset=UTF-8

    ... Content-Transfer-Encoding: 8bit

    ... Report-Msgid-Bugs-To: serrador@hispalinux.es'''

We can get an ITranslationHeaderData from the file format importer.

    >>> from lp.translations.interfaces.translationimporter import (

    ...     ITranslationImporter)

    >>> translation_importer = getUtility(ITranslationImporter)

    >>> format_importer = translation_importer.getTranslationFormatImporter(

    ...     pofile.potemplate.source_file_format)

    >>> new_header = format_importer.getHeaderFromString(new_header_string)

    >>> new_header.comment = ' This is the top comment.'

Before doing any change, we can see what's right now in the database:

    >>> pofile.topcomment.splitlines()[:2]

    [u' traducci\xf3n de es.po al Spanish',

     u' translation of es.po to Spanish']

    >>> print pofile.header

    Project-Id-Version: es

    POT-Creation-Date: 2004-08-17 11:10+0200

    PO-Revision-Date: 2005-04-07 13:22+0000

    ...

    Plural-Forms: nplurals=2; plural=(n != 1);

Let's update the header with the new one.

    >>> pofile.updateHeader(new_header)

The new comment is now applied.

    >>> pofile.topcomment

    u' This is the top comment.'

And the new header contains the new string.

    >>> print pofile.header

    Project-Id-Version: es

    Report-Msgid-Bugs-To: serrador@hispalinux.es

    POT-Creation-Date: 2004-08-18 11:10+0200

    PO-Revision-Date: 2005-08-18 13:22+0000

    ...

isTranslationRevisionDateOlder

------------------------------

This method helps to compare two PO files header and decide if the given

one is older than the one we have in the IPOFile object. We are using

this method, for instance, to know if a new imported PO file should be

ignored because we already have a newer one.

This test is to be sure that the date comparation is working and that

two headers with the same date will always be set as newer, because lazy

translators forget to update that field from time to time and sometimes,

we were losing translations because we were ignoring those imports too.

    >>> print pofile.header

    Project-Id-Version: es

    ...

    PO-Revision-Date: 2005-08-18 13:22+0000

    ...

    >>> header = pofile.getHeader()

First, with the same date, we don't consider it older.

    >>> pofile.isTranslationRevisionDateOlder(header)

    False

Now, we can see how we detect that it's older with an older date.

    >>> header.translation_revision_date = datetime.datetime(

    ...     2005, 8, 18, 13, 21, tzinfo=UTC)

    >>> pofile.isTranslationRevisionDateOlder(header)

    True

If the revision date of the stored translation file is missing, the new

one is considered an update.

    >>> from zope.security.proxy import removeSecurityProxy

    >>> from lp.translations.utilities.gettext_po_parser import (

    ...     POHeader)

    >>> old_pofile = removeSecurityProxy(potemplate.newPOFile('tl'))

    >>> old_pofile.header = """

    ...     Project-Id-Version: foo

    ...     MIME-Version: 1.0

    ...     Content-Type: text/plain; charset=UTF-8

    ...     Content-Transfer-Encoding: 8bit

    ...     """

    >>> new_header = POHeader("""

    ...     Project-Id-Version: foo

    ...     PO-Revision-Date: 2007-05-03 14:00+0200

    ...     MIME-Version: 1.0

    ...     Content-Type: text/plain; charset=UTF-8

    ...     Content-Transfer-Encoding: 8bit

    ...     """)

    >>> old_pofile.isTranslationRevisionDateOlder(new_header)

    False

This even goes if the new file also omits the revision date.

    >>> new_header = POHeader("""

    ...     Project-Id-Version: foo

    ...     MIME-Version: 1.0

    ...     Content-Type: text/plain; charset=UTF-8

    ...     Content-Transfer-Encoding: 8bit

    ...     """)

    >>> old_pofile.isTranslationRevisionDateOlder(new_header)

    False

plural_forms

------------

This method returns a number of plural forms for the language of the

POFile, or a default of 2 when language doesn't specify it: 2 is the

most common value for number of plural forms, so most likely to be

correct for any new language.  Even if the default value is incorrect,

it is handled gracefully by the rest of the system (see doc/poimport.txt

for example).

When the language has number of plural forms defined, that value is

used.

    >>> from lp.registry.interfaces.product import IProductSet

    >>> evolution = getUtility(IProductSet).getByName('evolution')

    >>> evolution_trunk = evolution.getSeries('trunk')

    >>> evolution_pot = evolution_trunk.getPOTemplate('evolution-2.2')

    >>> serbian = getUtility(ILanguageSet)['sr']

    >>> serbian.pluralforms

    3

    >>> evolution_sr = evolution_pot.getDummyPOFile(serbian)

    >>> evolution_sr.plural_forms

    3

And when a language has no plural forms defined, a POFile defaults to 2,

the most common number of plural forms:

    >>> divehi = getUtility(ILanguageSet)['dv']

    >>> print divehi.pluralforms

    None

    >>> evolution_dv = evolution_pot.getDummyPOFile(divehi)

    >>> evolution_dv.plural_forms

    2

export

------

This method serializes an IPOFile as a .po file.

Get a concrete POFile we know doesn't have a UTF-8 encoding.

    >>> from lp.translations.model.pofile import POFile

    >>> pofile = POFile.get(24)

    >>> print pofile.header

    Project-Id-Version: PACKAGE VERSION

    ...

    Content-Type: text/plain; charset=EUC-JP

    ...

Now, let's export it with its default encoding.

    >>> stream = pofile.export()

    >>> stream_list = stream.splitlines()

The header is not changed.

    >>> for i in range(len(stream_list)):

    ...     if stream_list[i].startswith('"Content-Type:'):

    ...         print stream_list[i]

    "Content-Type: text/plain; charset=EUC-JP\n"

And checking one of the translations, we can see that it's using the

EUC-JP encoding.

    >>> for i in range(len(stream_list)):

    ...     if (stream_list[i].startswith('msgstr') and

    ...         'prefs.js' in stream_list[i]):

    ...         break

    >>> stream_list[i]

    'msgstr "\xc0\xdf\xc4\xea\xa4\xce\xa5\xab...\xa5\xba\xa4\xcb

    /etc/mozilla/prefs.js

    \xa4\xac\xcd\xf8\xcd\xd1\xa4\xc7\xa4\xad\xa4\xde\xa4\xb9\xa1\xa3"'

Now, let's force the UTF-8 encoding.

    >>> stream = pofile.export(force_utf8=True)

    >>> stream_list = stream.splitlines()

We can see that the header has been updated to have UTF-8

    >>> for i in range(len(stream_list)):

    ...     if stream_list[i].startswith('"Content-Type:'):

    ...         print stream_list[i]

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

And the encoding used is also using UTF-8 chars.

    >>> for i in range(len(stream_list)):

    ...     if (stream_list[i].startswith('msgstr') and

    ...         'prefs.js' in stream_list[i]):

    ...         break

    >>> stream_list[i]

    'msgstr "\xe8\xa8\xad\xe5\xae\x9a\xe3\x81...\xba\xe3\x81\xab

    /etc/mozilla/prefs.js

    \xe3\x81\x8c\xe5\x88\xa9\xe7\x94\xa8\xe3...\x99\xe3\x80\x82"'

There are some situations when a msgid_plural changes, while the msgid

singular remains unchanged.

So for a concrete export, we have a message like:

    >>> pofile_es = potemplate.getPOFileByLang('es')

    >>> print pofile_es.export(force_utf8=True).decode('utf8')

    # ...

    ...

    #: addressbook/gui/widgets/foo.c:345

    #, c-format

    msgid "%d foo"

    msgid_plural "%d bars"

    msgstr[0] ""

    ...

When it changes...

    >>> potmsgset = potemplate.getPOTMsgSetByMsgIDText(

    ...     u'%d foo', u'%d bars')

    # It has plural forms.

    >>> print potmsgset.plural_text

    %d bars

    # We change the plural form.

    >>> potmsgset.updatePluralForm(u'something else')

    >>> from canonical.database.sqlbase import flush_database_updates

    >>> flush_database_updates()

    >>> print potmsgset.plural_text

    something else

...the export reflects that change.

    >>> print pofile_es.export(force_utf8=True).decode('utf8')

    # ...

    ...

    #: addressbook/gui/widgets/foo.c:345

    #, c-format

    msgid "%d foo"

    msgid_plural "something else"

    msgstr[0] ""

    ...

createMessageSetFromText

------------------------

This method returns a new IPOMsgSet for the associated text.

Let's get the IPOFile we are going to use for this test.

    >>> pofile_sr = potemplate.newPOFile('sr')

And the msgid we are looking for.

    >>> msgid = u'Found %i invalid file.'

    >>> msgid_plural = u'Found %i invalid files.'

Now, just to be sure that this entry doesn't exist yet:

    >>> potmsgset = pofile_sr.potemplate.getOrCreateSharedPOTMsgSet(

    ...     singular_text=msgid, plural_text=msgid_plural)

    >>> print potmsgset.getCurrentTranslation(

    ...     pofile_sr.potemplate, pofile_sr.language,

    ...     pofile_sr.potemplate.translation_side)

    None

Is time to create it.  We need some extra privileges here.

    >>> from lp.app.interfaces.launchpad import ILaunchpadCelebrities

    >>> login('carlos@canonical.com')

    >>> rosetta_experts = getUtility(ILaunchpadCelebrities).rosetta_experts

    >>> translations = {0: u''}

    >>> is_current_upstream = False

    >>> lock_timestamp = datetime.datetime.now(UTC)

    >>> translation_message = factory.makeCurrentTranslationMessage(

    ...     pofile_sr, potmsgset, rosetta_experts, translations=translations,

    ...     current_other=is_current_upstream)

As we can see, is the msgid we were looking for.

    >>> print translation_message.potmsgset.msgid_singular.msgid

    Found %i invalid file.

    >>> print pofile_sr.language.code

    sr

    >>> print translation_message.language.code

    sr

We created it without translations.

    >>> translation_message.translations

    [None, None, None]

People who contributed translations

-----------------------------------

The 'contributors' property of a POFile returns all the people who

contributed translations to it.

    >>> def print_names(persons):

    ...     """Print name for each of `persons`."""

    ...     for person in persons:

    ...         print person.name

    ...     print "--"

    >>> evolution = getUtility(IProductSet).getByName('evolution')

    >>> evolution_trunk = evolution.getSeries('trunk')

    >>> potemplatesubset = potemplateset.getSubset(

    ...     productseries=evolution_trunk)

    >>> evolution_template = potemplatesubset['evolution-2.2']

    >>> evolution_es = evolution_template.getPOFileByLang('es')

    >>> print_names(evolution_es.contributors)

    carlos

    mark

    no-priv

    --

If you have a distroseries and want to know all the people who

contributed translations on a given language for that distroseries, you

can use the getPOFileContributorsByLanguage() method of IDistroSeries.

    >>> from lp.registry.model.distroseries import DistroSeries

    >>> from lp.services.worlddata.model.language import Language

    >>> hoary = DistroSeries.selectOneBy(name="hoary")

    >>> spanish = Language.selectOneBy(code="es")

    >>> print_names(hoary.getPOFileContributorsByLanguage(spanish))

    jorge-gonzalez-gonzalez

    carlos

    valyag

    name16

    name12

    tsukimi

    --

    # We can see that there is another translator that doesn't appear in

    # previous list because the template he translated is not current.

    >>> non_current_pofile = POFile.get(31)

    >>> non_current_pofile.potemplate.iscurrent

    False

    >>> print_names(non_current_pofile.contributors)

    jordi

    --

    >>> non_current_pofile.potemplate.distroseries == hoary

    True

    >>> non_current_pofile.language == spanish

    True

The rosetta_experts team is special: it never shows up in contributors

lists.

    >>> experts_pofile = factory.makePOFile('nl')

    >>> experts_message = factory.makeCurrentTranslationMessage(

    ...     pofile=experts_pofile, translator=rosetta_experts,

    ...     reviewer=rosetta_experts, translations=['hi'])

    >>> print_names(experts_pofile.contributors)

    --

getPOTMsgSetTranslated

----------------------

With this method we can get all POTMsgSet objects that are fully

translated for a given POFile.

    >>> def print_message_status(potmsgsets, pofile):

    ...     print "%-10s %-5s %-10s %-11s" % (

    ...         "msgid", "form", "translat.", "Has plurals")

    ...     for potmsgset in potmsgsets:

    ...         translationmessage = potmsgset.getCurrentTranslation(

    ...             pofile.potemplate, pofile.language,

    ...             pofile.potemplate.translation_side)

    ...         msgid = potmsgset.msgid_singular.msgid

    ...         if len(msgid) > 10:

    ...             msgid = msgid[:7] + '...'

    ...         for index in range(len(translationmessage.translations)):

    ...             if translationmessage.translations[index] is None:

    ...                 translation = 'None'

    ...             else:

    ...                 translation = translationmessage.translations[index]

    ...                 if len(translation) > 10:

    ...                     translation = translation[:7] + '...'

    ...             print "%-10s %-5s %-10s %s" % (

    ...                 msgid, index, translation,

    ...                 potmsgset.msgid_plural is not None)

    >>> potmsgsets_translated = evolution_es.getPOTMsgSetTranslated()

    >>> print_message_status(

    ...     potmsgsets_translated, evolution_es)

    msgid      form  translat.  Has plurals

    evoluti... 0     libreta... False

    current... 0     carpeta... False

    have       0     tiene      False

     cards     0      tarjetas  False

    The loc... 0     La ubic... False

    %d contact 0     %d cont... True

    %d contact 1     %d cont... True

    Opening... 0     Abrir %... True

    Opening... 1     Abrir %... True

    EncFS P... 0     Contras... False

getTranslationsFilteredBy

-------------------------

This method returns a list of TranslationMessages in a given POFile

created by a certain person.

    >>> person_set = getUtility(IPersonSet)

    >>> carlos = person_set.getByName('carlos')

    >>> translationmessages = evolution_es.getTranslationsFilteredBy(carlos)

    >>> for translationmessage in translationmessages:

    ...     print translationmessage.translations

    [u'libreta de direcciones de Evolution']

    [u'carpeta de libretas de direcciones actual']

    [u'lalalala']

    [u'tiene ']

    [u' tarjetas']

    [u'La ubicaci\xf3n y jerarqu\xeda de las carpetas de contactos de

    Evolution ha cambiado desde Evolution 1.x.\n\nTenga paciencia mientras

    Evolution migra sus carpetas...']

    [u'%d contacto', u'%d contactos']

    [u'Abrir %d contacto abrir\xe1 %d ventanas nuevas tambi\xe9n.\n\xbfQuiere

    realmente mostrar este contacto?',

    u'Abrir %d contactos abrir\xe1 %d ventanas nuevas tambi\xe9n.\n\xbfQuiere

    realmente mostrar todos estos contactos?']

    [u'Contrase\xf1a de EncFS: ']

If the passed person is None, the call fails with an assertion.

    >>> translationmessages = evolution_es.getTranslationsFilteredBy(None)

    Traceback (most recent call last):

    ...

    AssertionError: You must provide a person to filter by.

Translation credits

-------------------

Translation credits are handled automatically, and cannot be

translated in any other way except through an upload from upstream.

Lets get Spanish translation for alsa-utils.

    >>> alsautils = getUtility(IProductSet).getByName('alsa-utils')

    >>> alsa_trunk = alsautils.getSeries('trunk')

    >>> alsa_template = alsa_trunk.getPOTemplate('alsa-utils')

    >>> alsa_translation = alsa_template.newPOFile('sr')

This translation file contains a translation-credits message. By default

it is created with a dummy translation

    >>> potmsgset = alsa_template.getPOTMsgSetByMsgIDText(

    ...     u'translation-credits')

    >>> current = potmsgset.getCurrentTranslation(

    ...     alsa_template, alsa_translation.language,

    ...     alsa_template.translation_side)

    >>> print current.translations

    [u'This is a dummy translation so that

    the credits are counted as translated.']

If we submit an upstream translation, the translation for this message

is updated.

    >>> new_credits = factory.makeCurrentTranslationMessage(

    ...     alsa_translation, potmsgset, alsa_translation.owner,

    ...     translations={0: u'Happy translator'}, current_other=True)

    >>> flush_database_updates()

    >>> current = potmsgset.getCurrentTranslation(

    ...     alsa_template, alsa_translation.language,

    ...     alsa_template.translation_side)

    >>> print current.translations

    [u'Happy translator']

If we submit non-upstream translation, it's rejected.

    >>> no_credits = potmsgset.submitSuggestion(

    ...     alsa_translation, alsa_translation.owner,

    ...     {0: u'Unhappy translator'})

    >>> print no_credits

    None

    >>> flush_database_updates()

    >>> current = potmsgset.getCurrentTranslation(

    ...     alsa_template, alsa_translation.language,

    ...     alsa_template.translation_side)

    >>> print current.translations

    [u'Happy translator']

POFileToTranslationFileDataAdapter

----------------------------------

POFileToTranslationFileDataAdapter is an adapter to export a POFile

object. It implements the ITranslationFileData interface which is a

common file format in-memory to convert from one file format to another.

    >>> from lp.translations.interfaces.translationcommonformat import (

    ...     ITranslationFileData)

    >>> evolution_sourcepackagename = sourcepackagenameset['evolution']

    >>> ubuntu = distributionset['ubuntu']

    >>> hoary = ubuntu['hoary']

    >>> potemplatesubset = potemplateset.getSubset(

    ...     distroseries=hoary, sourcepackagename=evolution_sourcepackagename)

    >>> evolution_22 = potemplatesubset['evolution-2.2']

    >>> evolution_ja = evolution_22.getPOFileByLang('ja')

Getting the translation file data is just a matter of adapting the

object to the ITranslationFileData interface. Since there are multiple

adapters for differnt purposes, this adapter is named.

    >>> from zope.component import getAdapter

    >>> translation_file_data = getAdapter(

    ...     evolution_ja, ITranslationFileData, 'all_messages')

We get an updated header based on some metadata in our database instead

of the imported one stored in POFile.header.

    >>> print evolution_ja.header

    Project-Id-Version: evolution

    Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>

    POT-Creation-Date: 2005-05-06 20:39:27.778946+00:00

    PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE

    Last-Translator: FULL NAME <EMAIL@ADDRESS>

    Language-Team: Japanese <ja@li.org>

    MIME-Version: 1.0

    Content-Type: text/plain; charset=UTF-8

    Content-Transfer-Encoding: 8bit

    Plural-Forms: nplurals=1; plural=0

    >>> print translation_file_data.header.getRawContent()

    Project-Id-Version: evolution

    Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>

    POT-Creation-Date: 2005-04-07 14:10+0200

    PO-Revision-Date: 2005-10-11 23:08+0000

    Last-Translator: Carlos Perell... <carlos@canonical.com>

    Language-Team: Japanese <ja@li.org>

    MIME-Version: 1.0

    Content-Type: text/plain; charset=UTF-8

    Content-Transfer-Encoding: 8bit

    Plural-Forms: nplurals=1; plural=0;

    X-Launchpad-Export-Date: ...-...-... ...:...+...

    X-Generator: Launchpad (build ...)

We can see that last translator is Carlos, just like the updated header

says:

    >>> evolution_ja.lasttranslator.displayname

    u'Carlos Perell\xf3 Mar\xedn'

And the PO Revision Date matches when was the PO file last changed.

    >>> print evolution_ja.date_changed

    2005-10-11 23:08:01.899322+00:00

POFileToChangedFromPackagedAdapter

----------------------------------

Another adapter to the ITranslationFileData interface includes only

those messages that were changed from their packaged version. The class

is called POFileToChangedFromPackagedAdapter and it is registered as a

named adapter, too.

    >>> translation_file_data = getAdapter(

    ...     evolution_ja, ITranslationFileData, 'changed_messages')

    >>> ITranslationFileData.providedBy(translation_file_data)

    True

POFile Security tests

=====================

Import the function that will help us to do this test.

    >>> from canonical.launchpad.webapp.authorization import check_permission

A Launchpad admin must have permission to edit an IPOFile always.

    >>> login('foo.bar@canonical.com')

    >>> check_permission('launchpad.Edit', pofile)

    True

And a Rosetta Expert too.

    >>> login('jordi@ubuntu.com')

    >>> check_permission('launchpad.Edit', pofile)

    True

And that's all, folks!