babel/mirror: babel/messages/pofile.py annotate

annotate babel/messages/pofile.py @ 54:7dbcbc3f07e0 trunk

Rename the `babel.catalog` package to `babel.messages` for consistency with the other package names.

author	cmlenz
date	Fri, 08 Jun 2007 09:16:32 +0000
parents	babel/catalog/pofile.py@d484eb9a70d5
children	a258e4015eb6

rev	line source
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	1 # -- coding: utf-8 --
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	2 #
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	3 # Copyright (C) 2007 Edgewall Software
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	4 # All rights reserved.
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	5 #
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	6 # This software is licensed as described in the file COPYING, which
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	7 # you should have received as part of this distribution. The terms
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	8 # are also available at http://babel.edgewall.org/wiki/License.
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	9 #
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	10 # This software consists of voluntary contributions made by many
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	11 # individuals. For the exact contribution history, see the revision
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	12 # history and logs, available at http://babel.edgewall.org/log/.
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	13
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	14 """Reading and writing of files in the ``gettext`` PO (portable object)
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	15 format.
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	16
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	17 :see: `The Format of PO Files
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	18 <http://www.gnu.org/software/gettext/manual/gettext.html#PO-Files>`_
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	19 """
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	20
5 132526dcd074 * The creation-date header in generated PO files now includes the timezone offset. cmlenz parents: 1 diff changeset	21 from datetime import date, datetime
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	22 import re
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	23 try:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	24 set
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	25 except NameError:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	26 from sets import Set as set
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	27 import textwrap
5 132526dcd074 * The creation-date header in generated PO files now includes the timezone offset. cmlenz parents: 1 diff changeset	28 import time
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	29
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	30 from babel import __version__ as VERSION
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	31
51 d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	32 __all__ = ['escape', 'normalize', 'read_po', 'write_po', 'write_pot']
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	33
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	34 def read_po(fileobj):
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	35 """Read messages from a ``gettext`` PO (portable object) file from the given
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	36 file-like object.
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	37
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	38 This function yields tuples of the form:
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	39
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	40 ``(message, translation, locations, flags)``
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	41
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	42 where:
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	43
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	44 * ``message`` is the original (untranslated) message, or a
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	45 ``(singular, plural)`` tuple for pluralizable messages
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	46 * ``translation`` is the translation of the message, or a tuple of
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	47 translations for pluralizable messages
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	48 * ``locations`` is a sequence of ``(filename, lineno)`` tuples
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	49 * ``flags`` is a set of strings (for exampe, "fuzzy")
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	50
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	51 >>> from StringIO import StringIO
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	52 >>> buf = StringIO('''
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	53 ... #: main.py:1
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	54 ... #, fuzzy, python-format
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	55 ... msgid "foo %(name)s"
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	56 ... msgstr ""
21 cd9aa202568e Change pot header's first line, "Translations Template for %%(project)s." instead of "SOME DESCRIPTIVE TITLE.". '''`project`''' and '''`version`''' now default to '''PROJECT''' and '''VERSION''' respectively. Fixed a bug regarding '''Content-Transfer-Encoding''', it shouldn't be the charset, and we're defaulting to `8bit` untill someone complains. palgarvio parents: 17 diff changeset	57 ...
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	58 ... #: main.py:3
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	59 ... msgid "bar"
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	60 ... msgid_plural "baz"
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	61 ... msgstr[0] ""
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	62 ... msgstr[1] ""
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	63 ... ''')
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	64 >>> for message, translation, locations, flags in read_po(buf):
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	65 ... print (message, translation)
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	66 ... print ' ', (locations, flags)
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	67 (('foo %(name)s',), ('',))
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	68 ((('main.py', 1),), set(['fuzzy', 'python-format']))
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	69 (('bar', 'baz'), ('', ''))
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	70 ((('main.py', 3),), set([]))
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	71
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	72 :param fileobj: the file-like object to read the PO file from
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	73 :return: an iterator over ``(message, translation, location)`` tuples
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	74 :rtype: ``iterator``
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	75 """
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	76 messages = []
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	77 translations = []
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	78 locations = []
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	79 flags = []
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	80 in_msgid = in_msgstr = False
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	81
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	82 def pack():
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	83 translations.sort()
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	84 retval = (tuple(messages), tuple([t[1] for t in translations]),
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	85 tuple(locations), set(flags))
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	86 del messages[:]
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	87 del translations[:]
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	88 del locations[:]
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	89 del flags[:]
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	90 return retval
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	91
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	92 for line in fileobj.readlines():
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	93 line = line.strip()
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	94 if line.startswith('#'):
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	95 in_msgid = in_msgstr = False
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	96 if messages:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	97 yield pack()
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	98 if line[1:].startswith(':'):
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	99 for location in line[2:].lstrip().split():
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	100 filename, lineno = location.split(':', 1)
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	101 locations.append((filename, int(lineno)))
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	102 elif line[1:].startswith(','):
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	103 for flag in line[2:].lstrip().split(','):
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	104 flags.append(flag.strip())
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	105 elif line:
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	106 if line.startswith('msgid_plural'):
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	107 in_msgid = True
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	108 msg = line[12:].lstrip()
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	109 messages.append(msg[1:-1])
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	110 elif line.startswith('msgid'):
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	111 in_msgid = True
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	112 if messages:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	113 yield pack()
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	114 msg = line[5:].lstrip()
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	115 messages.append(msg[1:-1])
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	116 elif line.startswith('msgstr'):
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	117 in_msgid = False
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	118 in_msgstr = True
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	119 msg = line[6:].lstrip()
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	120 if msg.startswith('['):
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	121 idx, msg = msg[1:].split(']')
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	122 translations.append([int(idx), msg.lstrip()[1:-1]])
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	123 else:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	124 translations.append([0, msg[1:-1]])
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	125 elif line.startswith('"'):
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	126 if in_msgid:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	127 messages[-1] += line.rstrip()[1:-1]
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	128 elif in_msgstr:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	129 translations[-1][1] += line.rstrip()[1:-1]
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	130
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	131 if messages:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	132 yield pack()
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	133
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	134 POT_HEADER = """\
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	135 # Translations Template for %%(project)s.
27 54ad80b62674 Changing `write_po` to include licensing info, same as the project. Since the method is also to create the initial pot file, we also include the year in the copyright. We also mark the translations catalog template as fuzzy as it should be, only localized translations catalogs ready to be compiled should not include the fuzzy bit on the header. palgarvio parents: 26 diff changeset	136 # Copyright (C) %%(year)s ORGANIZATION
54ad80b62674 Changing `write_po` to include licensing info, same as the project. Since the method is also to create the initial pot file, we also include the year in the copyright. We also mark the translations catalog template as fuzzy as it should be, only localized translations catalogs ready to be compiled should not include the fuzzy bit on the header. palgarvio parents: 26 diff changeset	137 # This file is distributed under the same license as the
54ad80b62674 Changing `write_po` to include licensing info, same as the project. Since the method is also to create the initial pot file, we also include the year in the copyright. We also mark the translations catalog template as fuzzy as it should be, only localized translations catalogs ready to be compiled should not include the fuzzy bit on the header. palgarvio parents: 26 diff changeset	138 # %%(project)s project.
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	139 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	140 #
27 54ad80b62674 Changing `write_po` to include licensing info, same as the project. Since the method is also to create the initial pot file, we also include the year in the copyright. We also mark the translations catalog template as fuzzy as it should be, only localized translations catalogs ready to be compiled should not include the fuzzy bit on the header. palgarvio parents: 26 diff changeset	141 #, fuzzy
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	142 msgid ""
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	143 msgstr ""
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	144 "Project-Id-Version: %%(project)s %%(version)s\\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	145 "POT-Creation-Date: %%(creation_date)s\\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	146 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	147 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	148 "Language-Team: LANGUAGE <LL@li.org>\\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	149 "MIME-Version: 1.0\\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	150 "Content-Type: text/plain; charset=%%(charset)s\\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	151 "Content-Transfer-Encoding: 8bit\\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	152 "Generated-By: Babel %s\\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	153
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	154 """ % VERSION
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	155
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	156 PYTHON_FORMAT = re.compile(r'\%(\([\w]+\))?[diouxXeEfFgGcrs]').search
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	157
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	158 WORD_SEP = re.compile('('
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	159 r'\s+\|' # any whitespace
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	160 r'[^\s\w]*\w+[a-zA-Z]-(?=\w+[a-zA-Z])\|' # hyphenated words
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	161 r'(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w)' # em-dash
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	162 ')')
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	163
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	164 def escape(string):
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	165 r"""Escape the given string so that it can be included in double-quoted
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	166 strings in ``PO`` files.
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	167
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	168 >>> escape('''Say:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	169 ... "hello, world!"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	170 ... ''')
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	171 '"Say:\\n \\"hello, world!\\"\\n"'
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	172
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	173 :param string: the string to escape
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	174 :return: the escaped string
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	175 :rtype: `str` or `unicode`
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	176 """
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	177 return '"%s"' % string.replace('\\', '\\\\') \
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	178 .replace('\t', '\\t') \
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	179 .replace('\r', '\\r') \
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	180 .replace('\n', '\\n') \
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	181 .replace('\"', '\\"')
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	182
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	183 def normalize(string, width=76):
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	184 r"""This converts a string into a format that is appropriate for .po files.
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	185
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	186 >>> print normalize('''Say:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	187 ... "hello, world!"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	188 ... ''', width=None)
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	189 ""
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	190 "Say:\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	191 " \"hello, world!\"\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	192
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	193 >>> print normalize('''Say:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	194 ... "Lorem ipsum dolor sit amet, consectetur adipisicing elit, "
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	195 ... ''', width=32)
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	196 ""
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	197 "Say:\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	198 " \"Lorem ipsum dolor sit "
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	199 "amet, consectetur adipisicing"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	200 " elit, \"\n"
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	201
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	202 :param string: the string to normalize
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	203 :param width: the maximum line width; use `None`, 0, or a negative number
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	204 to completely disable line wrapping
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	205 :return: the normalized string
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	206 :rtype: `unicode`
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	207 """
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	208 if width and width > 0:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	209 lines = []
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	210 for idx, line in enumerate(string.splitlines(True)):
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	211 if len(escape(line)) > width:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	212 chunks = WORD_SEP.split(line)
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	213 chunks.reverse()
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	214 while chunks:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	215 buf = []
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	216 size = 2
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	217 while chunks:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	218 l = len(escape(chunks[-1])) - 2
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	219 if size + l < width:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	220 buf.append(chunks.pop())
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	221 size += l
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	222 else:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	223 if not buf:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	224 # handle long chunks by putting them on a
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	225 # separate line
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	226 buf.append(chunks.pop())
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	227 break
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	228 lines.append(u''.join(buf))
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	229 else:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	230 lines.append(line)
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	231 else:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	232 lines = string.splitlines(True)
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	233
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	234 if len(lines) == 1:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	235 return escape(string)
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	236
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	237 # Remove empty trailing line
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	238 if not lines[-1]:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	239 del lines[-1]
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	240 lines[-1] += '\n'
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	241 return u'""\n' + u'\n'.join([escape(l) for l in lines])
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	242
51 d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	243 def write_pot(fileobj, messages, project='PROJECT', version='VERSION', width=76,
21 cd9aa202568e Change pot header's first line, "Translations Template for %%(project)s." instead of "SOME DESCRIPTIVE TITLE.". '''`project`''' and '''`version`''' now default to '''PROJECT''' and '''VERSION''' respectively. Fixed a bug regarding '''Content-Transfer-Encoding''', it shouldn't be the charset, and we're defaulting to `8bit` untill someone complains. palgarvio parents: 17 diff changeset	244 charset='utf-8', no_location=False, omit_header=False):
51 d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	245 r"""Write a ``gettext`` PO (portable object) template file to the given
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	246 file-like object.
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	247
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	248 The `messages` parameter is expected to be an iterable object producing
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	249 tuples of the form:
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	250
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	251 ``(filename, lineno, funcname, message, flags)``
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	252
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	253 >>> from StringIO import StringIO
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	254 >>> buf = StringIO()
51 d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	255 >>> write_pot(buf, [
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	256 ... ('main.py', 1, None, u'foo %(name)s', ('fuzzy',)),
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	257 ... ('main.py', 3, 'ngettext', (u'bar', u'baz'), None)
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	258 ... ], omit_header=True)
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	259
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	260 >>> print buf.getvalue()
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	261 #: main.py:1
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	262 #, fuzzy, python-format
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	263 msgid "foo %(name)s"
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	264 msgstr ""
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	265 <BLANKLINE>
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	266 #: main.py:3
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	267 msgid "bar"
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	268 msgid_plural "baz"
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	269 msgstr[0] ""
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	270 msgstr[1] ""
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	271 <BLANKLINE>
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	272 <BLANKLINE>
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	273
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	274 :param fileobj: the file-like object to write to
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	275 :param messages: an iterable over the messages
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	276 :param project: the project name
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	277 :param version: the project version
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	278 :param width: the maximum line width for the generated output; use `None`,
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	279 0, or a negative number to completely disable line wrapping
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	280 :param charset: the encoding
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	281 :param no_location: do not emit a location comment for every message
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	282 :param omit_header: do not include the ``msgid ""`` entry at the top of the
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	283 output
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	284 """
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	285 def _normalize(key):
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	286 return normalize(key, width=width).encode(charset, 'backslashreplace')
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	287
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	288 def _write(text):
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	289 if isinstance(text, unicode):
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	290 text = text.encode(charset)
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	291 fileobj.write(text)
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	292
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	293 if not omit_header:
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	294 _write(POT_HEADER % {
27 54ad80b62674 Changing `write_po` to include licensing info, same as the project. Since the method is also to create the initial pot file, we also include the year in the copyright. We also mark the translations catalog template as fuzzy as it should be, only localized translations catalogs ready to be compiled should not include the fuzzy bit on the header. palgarvio parents: 26 diff changeset	295 'year': time.strftime('%Y'),
5 132526dcd074 * The creation-date header in generated PO files now includes the timezone offset. cmlenz parents: 1 diff changeset	296 'project': project,
132526dcd074 * The creation-date header in generated PO files now includes the timezone offset. cmlenz parents: 1 diff changeset	297 'version': version,
132526dcd074 * The creation-date header in generated PO files now includes the timezone offset. cmlenz parents: 1 diff changeset	298 'creation_date': time.strftime('%Y-%m-%d %H:%M%z'),
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	299 'charset': charset,
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	300 })
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	301
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	302 locations = {}
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	303 msgflags = {}
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	304 msgids = []
51 d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	305 plurals = {}
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	306
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	307 for filename, lineno, funcname, key, flags in messages:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	308 flags = set(flags or [])
51 d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	309 if isinstance(key, (list, tuple)):
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	310 assert len(key) == 2
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	311 plurals[key[0]] = key[1]
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	312 key = key[0]
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	313 if key in msgids:
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	314 locations[key].append((filename, lineno))
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	315 msgflags[key] \|= flags
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	316 else:
51 d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	317 if PYTHON_FORMAT(key):
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	318 flags.add('python-format')
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	319 else:
51 d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	320 flags.discard('python-format')
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	321
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	322 locations[key] = [(filename, lineno)]
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	323 msgflags[key] = flags
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	324 msgids.append(key)
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	325
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	326 for msgid in msgids:
7870274479f5 Import of initial code base. cmlenz parents: diff changeset	327 if not no_location:
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	328 locs = u' '.join([u'%s:%d' % item for item in locations[msgid]])
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	329 if width and width > 0:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	330 locs = textwrap.wrap(locs, width, break_long_words=False)
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	331 for line in locs:
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	332 _write('#: %s\n' % line.strip())
6 c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	333 flags = msgflags[msgid]
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy"). cmlenz parents: 5 diff changeset	334 if flags:
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	335 _write('#%s\n' % ', '.join([''] + list(flags)))
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	336
51 d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	337 if plurals.has_key(msgid):
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	338 _write('msgid %s\n' % _normalize(msgid))
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	339 _write('msgid_plural %s\n' % _normalize(plurals[msgid]))
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	340 _write('msgstr[0] ""\n')
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	341 _write('msgstr[1] ""\n')
1 7870274479f5 Import of initial code base. cmlenz parents: diff changeset	342 else:
24 b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	343 _write('msgid %s\n' % _normalize(msgid))
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	344 _write('msgstr ""\n')
b09e90803d1b Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks). cmlenz parents: 23 diff changeset	345 _write('\n')
51 d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	346
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	347 def write_po(fileobj, input_fileobj, language, country=None, project='PROJECT',
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	348 version='VERSION', first_author=None, first_author_email=None,
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	349 plurals=('INTEGER', 'EXPRESSION')):
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	350 r"""Write a ``gettext`` PO (portable object) file to the given file-like
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	351 object, from the given input PO template file.
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	352
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	353 >>> from StringIO import StringIO
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	354 >>> inbuf = StringIO(r'''# Translations Template for FooBar.
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	355 ... # Copyright (C) 2007 ORGANIZATION
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	356 ... # This file is distributed under the same license as the
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	357 ... # FooBar project.
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	358 ... # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	359 ... #
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	360 ... #, fuzzy
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	361 ... msgid ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	362 ... msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	363 ... "Project-Id-Version: FooBar 0.1\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	364 ... "POT-Creation-Date: 2007-06-07 22:54+0100\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	365 ... "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	366 ... "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	367 ... "Language-Team: LANGUAGE <LL@li.org>\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	368 ... "MIME-Version: 1.0\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	369 ... "Content-Type: text/plain; charset=utf-8\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	370 ... "Content-Transfer-Encoding: 8bit\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	371 ... "Generated-By: Babel 0.1dev-r50\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	372 ...
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	373 ... #: base.py:83 templates/index.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	374 ... #: templates/index2.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	375 ... msgid "Home"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	376 ... msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	377 ...
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	378 ... #: base.py:84 templates/index.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	379 ... msgid "Accounts"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	380 ... msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	381 ... ''')
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	382 >>> outbuf = StringIO()
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	383 >>> write_po(outbuf, inbuf, 'English', project='FooBar',
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	384 ... version='0.1', first_author='A Name',
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	385 ... first_author_email='user@domain.tld',
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	386 ... plurals=(2, '(n != 1)'))
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	387 >>> print outbuf.getvalue() # doctest: +ELLIPSIS
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	388 # English Translations for FooBar
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	389 # Copyright (C) 2007 ORGANIZATION
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	390 # This file is distributed under the same license as the
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	391 # FooBar project.
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	392 # A Name <user@domain.tld>, ...
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	393 #
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	394 #, fuzzy
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	395 msgid ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	396 msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	397 "Project-Id-Version: FooBar 0.1\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	398 "POT-Creation-Date: 2007-06-07 22:54+0100\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	399 "PO-Revision-Date: ...\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	400 "Last-Translator: A Name <user@domain.tld>\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	401 "Language-Team: LANGUAGE <LL@li.org>\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	402 "MIME-Version: 1.0\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	403 "Content-Type: text/plain; charset=utf-8\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	404 "Content-Transfer-Encoding: 8bit\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	405 "Plural-Forms: nplurals=2; plural=(n != 1);\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	406 "Generated-By: Babel ...\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	407 <BLANKLINE>
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	408 #: base.py:83 templates/index.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	409 #: templates/index2.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	410 msgid "Home"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	411 msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	412 <BLANKLINE>
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	413 #: base.py:84 templates/index.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	414 msgid "Accounts"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	415 msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	416 <BLANKLINE>
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	417 >>>
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	418 """
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	419
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	420 _first_author = ''
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	421 if first_author:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	422 _first_author += first_author
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	423 if first_author_email:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	424 _first_author += ' <%s>' % first_author_email
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	425
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	426 inlines = input_fileobj.readlines()
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	427 outlines = []
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	428 in_header = True
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	429 for index in range(len(inlines)):
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	430 if in_header:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	431 if '# Translations Template' in inlines[index]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	432 if country:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	433 line = '# %s (%s) Translations for %%s\n' % \
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	434 (language, country)
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	435 else:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	436 line = '# %s Translations for %%s\n' % language
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	437 outlines.append(line % project)
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	438 elif '# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.' in inlines[index]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	439 if _first_author:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	440 outlines.append(
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	441 '# %s, %s\n' % (_first_author, time.strftime('%Y'))
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	442 )
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	443 else:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	444 outlines.append(inlines[index])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	445 elif '"PO-Revision-Date:' in inlines[index]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	446 outlines.append(
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	447 '"PO-Revision-Date: %s\\n"\n' % \
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	448 time.strftime('%Y-%m-%d %H:%M%z')
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	449 )
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	450 elif '"Last-Translator:' in inlines[index]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	451 if _first_author:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	452 outlines.append(
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	453 '"Last-Translator: %s\\n"\n' % _first_author
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	454 )
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	455 else:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	456 outlines.append(inlines[index])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	457 elif '"Content-Transfer-Encoding:' in inlines[index]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	458 outlines.append(inlines[index])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	459 if '"Plural-Forms:' not in inlines[index+1]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	460 outlines.append(
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	461 '"Plural-Forms: nplurals=%s; plural=%s;\\n"\n' % plurals
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	462 )
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	463 elif inlines[index].endswith('\\n"\n') and \
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	464 inlines[index+1] == '\n':
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	465 in_header = False
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	466 outlines.append(inlines[index])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	467 else:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	468 outlines.append(inlines[index])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	469 else:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	470 outlines.extend(inlines[index:])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	471 break
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file. palgarvio parents: 27 diff changeset	472 fileobj.writelines(outlines)

Mercurial > babel > mirror

annotate babel/messages/pofile.py @ 54:7dbcbc3f07e0 trunk