Mercurial > babel > old > mirror
annotate babel/messages/catalog.py @ 80:8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
Added support to the frontends for `--msgid-bugs-address` that set's the `Report-Msgid-Bugs-To` header, which was also a missing header on `Catalog`, so, a bug found by chance :) (See #12, item 6)
author | palgarvio |
---|---|
date | Sun, 10 Jun 2007 08:42:21 +0000 |
parents | f5a6bf38df89 |
children | f421e5576d26 |
rev | line source |
---|---|
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
1 # -*- coding: utf-8 -*- |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
2 # |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
3 # Copyright (C) 2007 Edgewall Software |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
4 # All rights reserved. |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
5 # |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
6 # This software is licensed as described in the file COPYING, which |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
7 # you should have received as part of this distribution. The terms |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
8 # are also available at http://babel.edgewall.org/wiki/License. |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
9 # |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
10 # This software consists of voluntary contributions made by many |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
11 # individuals. For the exact contribution history, see the revision |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
12 # history and logs, available at http://babel.edgewall.org/log/. |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
13 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
14 """Data structures for message catalogs.""" |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
15 |
69 | 16 from datetime import datetime |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
17 import re |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
18 try: |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
19 set |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
20 except NameError: |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
21 from sets import Set as set |
69 | 22 import time |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
23 |
69 | 24 from babel import __version__ as VERSION |
66 | 25 from babel.core import Locale |
69 | 26 from babel.messages.plurals import PLURALS |
27 from babel.util import odict, UTC | |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
28 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
29 __all__ = ['Message', 'Catalog'] |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
30 __docformat__ = 'restructuredtext en' |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
31 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
32 PYTHON_FORMAT = re.compile(r'\%(\([\w]+\))?[diouxXeEfFgGcrs]').search |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
33 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
34 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
35 class Message(object): |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
36 """Representation of a single message in a catalog.""" |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
37 |
70 | 38 def __init__(self, id, string='', locations=(), flags=()): |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
39 """Create the message object. |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
40 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
41 :param id: the message ID, or a ``(singular, plural)`` tuple for |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
42 pluralizable messages |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
43 :param string: the translated message string, or a |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
44 ``(singular, plural)`` tuple for pluralizable messages |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
45 :param locations: a sequence of ``(filenname, lineno)`` tuples |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
46 :param flags: a set or sequence of flags |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
47 """ |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
48 self.id = id |
70 | 49 if not string and self.pluralizable: |
50 string = (u'', u'') | |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
51 self.string = string |
72
f5a6bf38df89
Fix for mixed singular/plural messages, follow-up to [70].
cmlenz
parents:
71
diff
changeset
|
52 self.locations = list(locations) |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
53 self.flags = set(flags) |
69 | 54 if id and self.python_format: |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
55 self.flags.add('python-format') |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
56 else: |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
57 self.flags.discard('python-format') |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
58 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
59 def __repr__(self): |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
60 return '<%s %r>' % (type(self).__name__, self.id) |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
61 |
69 | 62 def fuzzy(self): |
63 return 'fuzzy' in self.flags | |
64 fuzzy = property(fuzzy, doc="""\ | |
65 Whether the translation is fuzzy. | |
66 | |
67 >>> Message('foo').fuzzy | |
68 False | |
69 >>> Message('foo', 'foo', flags=['fuzzy']).fuzzy | |
70 True | |
71 | |
72 :type: `bool` | |
73 """) | |
74 | |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
75 def pluralizable(self): |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
76 return isinstance(self.id, (list, tuple)) |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
77 pluralizable = property(pluralizable, doc="""\ |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
78 Whether the message is plurizable. |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
79 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
80 >>> Message('foo').pluralizable |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
81 False |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
82 >>> Message(('foo', 'bar')).pluralizable |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
83 True |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
84 |
63
a60ecd4a4954
Move `Translations` and `LazyProxy` to new `babel.support` module, which should contain any convenience code that is useful for applications using Babel/I18n, but not used by Babel itself.
cmlenz
parents:
58
diff
changeset
|
85 :type: `bool` |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
86 """) |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
87 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
88 def python_format(self): |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
89 ids = self.id |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
90 if not isinstance(ids, (list, tuple)): |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
91 ids = [ids] |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
92 return bool(filter(None, [PYTHON_FORMAT(id) for id in ids])) |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
93 python_format = property(python_format, doc="""\ |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
94 Whether the message contains Python-style parameters. |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
95 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
96 >>> Message('foo %(name)s bar').python_format |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
97 True |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
98 >>> Message(('foo %(name)s', 'foo %(name)s')).python_format |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
99 True |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
100 |
63
a60ecd4a4954
Move `Translations` and `LazyProxy` to new `babel.support` module, which should contain any convenience code that is useful for applications using Babel/I18n, but not used by Babel itself.
cmlenz
parents:
58
diff
changeset
|
101 :type: `bool` |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
102 """) |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
103 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
104 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
105 class Catalog(object): |
80
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
106 """Representation of a message catalog.""" |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
107 |
69 | 108 def __init__(self, locale=None, domain=None, project=None, version=None, |
80
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
109 msgid_bugs_address=None, creation_date=None, |
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
110 revision_date=None, last_translator=None, charset='utf-8'): |
66 | 111 """Initialize the catalog object. |
112 | |
113 :param locale: the locale identifier or `Locale` object, or `None` | |
114 if the catalog is not bound to a locale (which basically | |
115 means it's a template) | |
80
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
116 :param domain: the message domain |
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
117 :param project: the project's name |
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
118 :param version: the project's version |
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
119 :param msgid_bugs_address: the address to report bugs about the catalog |
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
120 :param creation_date: the date the catalog was created |
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
121 :param revision_date: the date the catalog was revised |
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
122 :param last_translator: the name and email of the last translator |
66 | 123 """ |
124 self.domain = domain #: the message domain | |
125 if locale: | |
126 locale = Locale.parse(locale) | |
127 self.locale = locale #: the locale or `None` | |
69 | 128 self._messages = odict() |
129 | |
130 self.project = project or 'PROJECT' #: the project name | |
80
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
131 self.version = version or 'VERSION' #: the project version |
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
132 self.msgid_bugs_address = msgid_bugs_address or 'EMAIL@ADDRESS' |
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
133 |
69 | 134 if creation_date is None: |
135 creation_date = time.localtime() | |
136 elif isinstance(creation_date, datetime): | |
137 if creation_date.tzinfo is None: | |
138 creation_date = creation_date.replace(tzinfo=UTC) | |
139 creation_date = creation_date.timetuple() | |
140 self.creation_date = creation_date #: creation date of the template | |
141 if revision_date is None: | |
142 revision_date = time.localtime() | |
143 elif isinstance(revision_date, datetime): | |
144 if revision_date.tzinfo is None: | |
145 revision_date = revision_date.replace(tzinfo=UTC) | |
146 revision_date = revision_date.timetuple() | |
147 self.revision_date = revision_date #: last revision date of the catalog | |
148 self.last_translator = last_translator #: last translator name + email | |
70 | 149 self.charset = charset or 'utf-8' |
69 | 150 |
151 def headers(self): | |
152 headers = [] | |
153 headers.append(('Project-Id-Version', | |
154 '%s %s' % (self.project, self.version))) | |
80
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
155 headers.append(('Report-Msgid-Bugs-To', self.msgid_bugs_address)) |
69 | 156 headers.append(('POT-Creation-Date', |
157 time.strftime('%Y-%m-%d %H:%M%z', self.creation_date))) | |
158 if self.locale is None: | |
159 headers.append(('PO-Revision-Date', 'YEAR-MO-DA HO:MI+ZONE')) | |
160 headers.append(('Last-Translator', 'FULL NAME <EMAIL@ADDRESS>')) | |
161 headers.append(('Language-Team', 'LANGUAGE <LL@li.org>')) | |
162 else: | |
163 headers.append(('PO-Revision-Date', | |
164 time.strftime('%Y-%m-%d %H:%M%z', self.revision_date))) | |
165 headers.append(('Last-Translator', self.last_translator)) | |
166 headers.append(('Language-Team', '%s <LL@li.org>' % self.locale)) | |
167 headers.append(('MIME-Version', '1.0')) | |
70 | 168 headers.append(('Content-Type', |
169 'text/plain; charset=%s' % self.charset)) | |
69 | 170 headers.append(('Content-Transfer-Encoding', '8bit')) |
80
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
171 if self.locale is not None: |
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
172 headers.append(('Plural-Forms', self.plural_forms)) |
69 | 173 headers.append(('Generated-By', 'Babel %s' % VERSION)) |
174 return headers | |
175 headers = property(headers, doc="""\ | |
176 The MIME headers of the catalog, used for the special ``msgid ""`` entry. | |
177 | |
178 The behavior of this property changes slightly depending on whether a locale | |
179 is set or not, the latter indicating that the catalog is actually a template | |
180 for actual translations. | |
181 | |
182 Here's an example of the output for such a catalog template: | |
183 | |
184 >>> catalog = Catalog(project='Foobar', version='1.0', | |
185 ... creation_date=datetime(1990, 4, 1, 15, 30)) | |
186 >>> for name, value in catalog.headers: | |
187 ... print '%s: %s' % (name, value) | |
188 Project-Id-Version: Foobar 1.0 | |
80
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
189 Report-Msgid-Bugs-To: EMAIL@ADDRESS |
69 | 190 POT-Creation-Date: 1990-04-01 15:30+0000 |
191 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE | |
192 Last-Translator: FULL NAME <EMAIL@ADDRESS> | |
193 Language-Team: LANGUAGE <LL@li.org> | |
194 MIME-Version: 1.0 | |
195 Content-Type: text/plain; charset=utf-8 | |
196 Content-Transfer-Encoding: 8bit | |
197 Generated-By: Babel ... | |
198 | |
199 And here's an example of the output when the locale is set: | |
200 | |
201 >>> catalog = Catalog(locale='de_DE', project='Foobar', version='1.0', | |
202 ... creation_date=datetime(1990, 4, 1, 15, 30), | |
203 ... revision_date=datetime(1990, 8, 3, 12, 0), | |
204 ... last_translator='John Doe <jd@example.com>') | |
205 >>> for name, value in catalog.headers: | |
206 ... print '%s: %s' % (name, value) | |
207 Project-Id-Version: Foobar 1.0 | |
80
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
208 Report-Msgid-Bugs-To: EMAIL@ADDRESS |
69 | 209 POT-Creation-Date: 1990-04-01 15:30+0000 |
210 PO-Revision-Date: 1990-08-03 12:00+0000 | |
211 Last-Translator: John Doe <jd@example.com> | |
212 Language-Team: de_DE <LL@li.org> | |
213 MIME-Version: 1.0 | |
214 Content-Type: text/plain; charset=utf-8 | |
215 Content-Transfer-Encoding: 8bit | |
80
8e2e9d549693
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
72
diff
changeset
|
216 Plural-Forms: nplurals=2; plural=(n != 1) |
69 | 217 Generated-By: Babel ... |
218 | |
219 :type: `list` | |
220 """) | |
221 | |
70 | 222 def num_plurals(self): |
223 num = 2 | |
224 if self.locale: | |
225 if str(self.locale) in PLURALS: | |
226 num = PLURALS[str(self.locale)][0] | |
227 elif self.locale.language in PLURALS: | |
228 num = PLURALS[self.locale.language][0] | |
229 return num | |
230 num_plurals = property(num_plurals) | |
231 | |
69 | 232 def plural_forms(self): |
233 num, expr = ('INTEGER', 'EXPRESSION') | |
234 if self.locale: | |
235 if str(self.locale) in PLURALS: | |
236 num, expr = PLURALS[str(self.locale)] | |
237 elif self.locale.language in PLURALS: | |
238 num, expr = PLURALS[self.locale.language] | |
239 return 'nplurals=%s; plural=%s' % (num, expr) | |
240 plural_forms = property(plural_forms, doc="""\ | |
241 Return the plural forms declaration for the locale. | |
242 | |
243 >>> Catalog(locale='en_US').plural_forms | |
244 'nplurals=2; plural=(n != 1)' | |
245 >>> Catalog(locale='pt_BR').plural_forms | |
246 'nplurals=2; plural=(n > 1)' | |
247 | |
248 :type: `str` | |
249 """) | |
250 | |
251 def __contains__(self, id): | |
252 """Return whether the catalog has a message with the specified ID.""" | |
71
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
253 return self._key_for(id) in self._messages |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
254 |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
255 def __len__(self): |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
256 return len(self._messages) |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
257 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
258 def __iter__(self): |
66 | 259 """Iterates through all the entries in the catalog, in the order they |
260 were added, yielding a `Message` object for every entry. | |
261 | |
262 :rtype: ``iterator`` | |
263 """ | |
69 | 264 buf = [] |
265 for name, value in self.headers: | |
266 buf.append('%s: %s' % (name, value)) | |
267 yield Message('', '\n'.join(buf), flags=set(['fuzzy'])) | |
71
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
268 for key in self._messages: |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
269 yield self._messages[key] |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
270 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
271 def __repr__(self): |
66 | 272 locale = '' |
273 if self.locale: | |
274 locale = ' %s' % self.locale | |
275 return '<%s %r%s>' % (type(self).__name__, self.domain, locale) | |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
276 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
277 def __delitem__(self, id): |
66 | 278 """Delete the message with the specified ID.""" |
71
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
279 key = self._key_for(id) |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
280 if key in self._messages: |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
281 del self._messages[key] |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
282 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
283 def __getitem__(self, id): |
66 | 284 """Return the message with the specified ID. |
285 | |
286 :param id: the message ID | |
287 :return: the message with the specified ID, or `None` if no such message | |
288 is in the catalog | |
69 | 289 :rtype: `Message` |
66 | 290 """ |
71
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
291 return self._messages.get(self._key_for(id)) |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
292 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
293 def __setitem__(self, id, message): |
66 | 294 """Add or update the message with the specified ID. |
295 | |
296 >>> catalog = Catalog() | |
297 >>> catalog[u'foo'] = Message(u'foo') | |
298 >>> catalog[u'foo'] | |
299 <Message u'foo'> | |
300 | |
301 If a message with that ID is already in the catalog, it is updated | |
302 to include the locations and flags of the new message. | |
303 | |
304 >>> catalog = Catalog() | |
305 >>> catalog[u'foo'] = Message(u'foo', locations=[('main.py', 1)]) | |
306 >>> catalog[u'foo'].locations | |
307 [('main.py', 1)] | |
308 >>> catalog[u'foo'] = Message(u'foo', locations=[('utils.py', 5)]) | |
309 >>> catalog[u'foo'].locations | |
310 [('main.py', 1), ('utils.py', 5)] | |
311 | |
312 :param id: the message ID | |
313 :param message: the `Message` object | |
314 """ | |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
315 assert isinstance(message, Message), 'expected a Message object' |
71
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
316 key = self._key_for(id) |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
317 current = self._messages.get(key) |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
318 if current: |
71
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
319 if message.pluralizable and not current.pluralizable: |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
320 # The new message adds pluralization |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
321 current.id = message.id |
72
f5a6bf38df89
Fix for mixed singular/plural messages, follow-up to [70].
cmlenz
parents:
71
diff
changeset
|
322 current.string = message.string |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
323 current.locations.extend(message.locations) |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
324 current.flags |= message.flags |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
325 message = current |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
326 else: |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
327 if isinstance(id, (list, tuple)): |
70 | 328 assert isinstance(message.string, (list, tuple)) |
71
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
329 self._messages[key] = message |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
330 |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
331 def add(self, id, string=None, locations=(), flags=()): |
66 | 332 """Add or update the message with the specified ID. |
333 | |
334 >>> catalog = Catalog() | |
335 >>> catalog.add(u'foo') | |
336 >>> catalog[u'foo'] | |
337 <Message u'foo'> | |
338 | |
339 This method simply constructs a `Message` object with the given | |
340 arguments and invokes `__setitem__` with that object. | |
341 | |
342 :param id: the message ID, or a ``(singular, plural)`` tuple for | |
343 pluralizable messages | |
344 :param string: the translated message string, or a | |
345 ``(singular, plural)`` tuple for pluralizable messages | |
346 :param locations: a sequence of ``(filenname, lineno)`` tuples | |
347 :param flags: a set or sequence of flags | |
348 """ | |
71
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
349 self[id] = Message(id, string, list(locations), flags) |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
350 |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
351 def _key_for(self, id): |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
352 """The key for a message is just the singular ID even for pluralizable |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
353 messages. |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
354 """ |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
355 key = id |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
356 if isinstance(key, (list, tuple)): |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
357 key = id[0] |
b260ffa01a2d
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
70
diff
changeset
|
358 return key |