Mercurial > babel > old > babel-test
annotate babel/messages/catalog.py @ 507:b29ff192b610 stable-0.9.x
Python 2.3 compatibility: backporting r456 and r457 to 0.9 branch (see #233)
author | fschwarz |
---|---|
date | Fri, 04 Mar 2011 13:14:03 +0000 |
parents | 540e6652b785 |
children |
rev | line source |
---|---|
56
27fba894d3ca
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 -*- |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
2 # |
27fba894d3ca
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 |
27fba894d3ca
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. |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
5 # |
27fba894d3ca
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 |
27fba894d3ca
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 |
27fba894d3ca
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. |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
9 # |
27fba894d3ca
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 |
27fba894d3ca
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 |
27fba894d3ca
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/. |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
13 |
27fba894d3ca
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.""" |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
15 |
149
ba5150e9544e
Respect charset specified in PO headers in `read_po()`. Fixes #17.
cmlenz
parents:
131
diff
changeset
|
16 from cgi import parse_header |
67 | 17 from datetime import datetime |
165
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
18 from difflib import get_close_matches |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
19 from email import message_from_string |
369 | 20 from copy import copy |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
21 import re |
67 | 22 import time |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
23 |
67 | 24 from babel import __version__ as VERSION |
64 | 25 from babel.core import Locale |
131
a63812008056
Use `dates.format_datetime` for dates in PO(T) header, as `datetime.strftime` produces wrong results on windows.
cmlenz
parents:
121
diff
changeset
|
26 from babel.dates import format_datetime |
379 | 27 from babel.messages.plurals import get_plural |
507
b29ff192b610
Python 2.3 compatibility: backporting r456 and r457 to 0.9 branch (see #233)
fschwarz
parents:
479
diff
changeset
|
28 from babel.util import odict, distinct, set, LOCALTZ, UTC, FixedOffsetTimezone |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
29 |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
30 __all__ = ['Message', 'Catalog', 'TranslationError'] |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
31 __docformat__ = 'restructuredtext en' |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
32 |
369 | 33 |
34 PYTHON_FORMAT = re.compile(r'''(?x) | |
35 \% | |
36 (?:\(([\w]*)\))? | |
37 ( | |
38 [-#0\ +]?(?:\*|[\d]+)? | |
39 (?:\.(?:\*|[\d]+))? | |
40 [hlL]? | |
41 ) | |
42 ([diouxXeEfFgGcrs%]) | |
43 ''') | |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
44 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
45 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
46 class Message(object): |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
47 """Representation of a single message in a catalog.""" |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
48 |
149
ba5150e9544e
Respect charset specified in PO headers in `read_po()`. Fixes #17.
cmlenz
parents:
131
diff
changeset
|
49 def __init__(self, id, string=u'', locations=(), flags=(), auto_comments=(), |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
50 user_comments=(), previous_id=(), lineno=None): |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
51 """Create the message object. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
52 |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
53 :param id: the message ID, or a ``(singular, plural)`` tuple for |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
54 pluralizable messages |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
55 :param string: the translated message string, or a |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
56 ``(singular, plural)`` tuple for pluralizable messages |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
57 :param locations: a sequence of ``(filenname, lineno)`` tuples |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
58 :param flags: a set or sequence of flags |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
59 :param auto_comments: a sequence of automatic comments for the message |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
60 :param user_comments: a sequence of user comments for the message |
203 | 61 :param previous_id: the previous message ID, or a ``(singular, plural)`` |
62 tuple for pluralizable messages | |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
63 :param lineno: the line number on which the msgid line was found in the |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
64 PO file, if any |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
65 """ |
107 | 66 self.id = id #: The message ID |
68 | 67 if not string and self.pluralizable: |
68 string = (u'', u'') | |
107 | 69 self.string = string #: The message translation |
229 | 70 self.locations = list(distinct(locations)) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
71 self.flags = set(flags) |
67 | 72 if id and self.python_format: |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
73 self.flags.add('python-format') |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
74 else: |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
75 self.flags.discard('python-format') |
227 | 76 self.auto_comments = list(distinct(auto_comments)) |
77 self.user_comments = list(distinct(user_comments)) | |
203 | 78 if isinstance(previous_id, basestring): |
79 self.previous_id = [previous_id] | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
80 else: |
203 | 81 self.previous_id = list(previous_id) |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
82 self.lineno = lineno |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
83 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
84 def __repr__(self): |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
85 return '<%s %r (flags: %r)>' % (type(self).__name__, self.id, |
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
86 list(self.flags)) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
87 |
248
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
88 def __cmp__(self, obj): |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
89 """Compare Messages, taking into account plural ids""" |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
90 if isinstance(obj, Message): |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
91 plural = self.pluralizable |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
92 obj_plural = obj.pluralizable |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
93 if plural and obj_plural: |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
94 return cmp(self.id[0], obj.id[0]) |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
95 elif plural: |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
96 return cmp(self.id[0], obj.id) |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
97 elif obj_plural: |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
98 return cmp(self.id, obj.id[0]) |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
99 return cmp(self.id, obj.id) |
bedaaeadc1db
add a __cmp__ to Message that correctly sorts by id, taking into account plurals
pjenvey
parents:
229
diff
changeset
|
100 |
314 | 101 def clone(self): |
369 | 102 return Message(*map(copy, (self.id, self.string, self.locations, |
103 self.flags, self.auto_comments, | |
104 self.user_comments, self.previous_id, | |
105 self.lineno))) | |
106 | |
107 def check(self, catalog=None): | |
108 """Run various validation checks on the message. Some validations | |
109 are only performed if the catalog is provided. This method returns | |
110 a sequence of `TranslationError` objects. | |
111 | |
112 :rtype: ``iterator`` | |
113 :param catalog: A catalog instance that is passed to the checkers | |
114 :see: `Catalog.check` for a way to perform checks for all messages | |
115 in a catalog. | |
116 """ | |
117 from babel.messages.checkers import checkers | |
118 errors = [] | |
119 for checker in checkers: | |
120 try: | |
121 checker(catalog, self) | |
122 except TranslationError, e: | |
123 errors.append(e) | |
124 return errors | |
314 | 125 |
67 | 126 def fuzzy(self): |
127 return 'fuzzy' in self.flags | |
128 fuzzy = property(fuzzy, doc="""\ | |
129 Whether the translation is fuzzy. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
130 |
67 | 131 >>> Message('foo').fuzzy |
132 False | |
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
133 >>> msg = Message('foo', 'foo', flags=['fuzzy']) |
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
134 >>> msg.fuzzy |
67 | 135 True |
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
136 >>> msg |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
137 <Message 'foo' (flags: ['fuzzy'])> |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
138 |
67 | 139 :type: `bool` |
140 """) | |
141 | |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
142 def pluralizable(self): |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
143 return isinstance(self.id, (list, tuple)) |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
144 pluralizable = property(pluralizable, doc="""\ |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
145 Whether the message is plurizable. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
146 |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
147 >>> Message('foo').pluralizable |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
148 False |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
149 >>> Message(('foo', 'bar')).pluralizable |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
150 True |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
151 |
61
da7efa40a9e2
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:
56
diff
changeset
|
152 :type: `bool` |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
153 """) |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
154 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
155 def python_format(self): |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
156 ids = self.id |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
157 if not isinstance(ids, (list, tuple)): |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
158 ids = [ids] |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
159 return bool(filter(None, [PYTHON_FORMAT.search(id) for id in ids])) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
160 python_format = property(python_format, doc="""\ |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
161 Whether the message contains Python-style parameters. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
162 |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
163 >>> Message('foo %(name)s bar').python_format |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
164 True |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
165 >>> Message(('foo %(name)s', 'foo %(name)s')).python_format |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
166 True |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
167 |
61
da7efa40a9e2
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:
56
diff
changeset
|
168 :type: `bool` |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
169 """) |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
170 |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
171 |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
172 class TranslationError(Exception): |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
173 """Exception thrown by translation checkers when invalid message |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
174 translations are encountered.""" |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
175 |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
176 |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
177 DEFAULT_HEADER = u"""\ |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
178 # Translations template for PROJECT. |
120 | 179 # Copyright (C) YEAR ORGANIZATION |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
180 # This file is distributed under the same license as the PROJECT project. |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
181 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR. |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
182 #""" |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
183 |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
184 |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
185 class Catalog(object): |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
186 """Representation of a message catalog.""" |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
187 |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
188 def __init__(self, locale=None, domain=None, header_comment=DEFAULT_HEADER, |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
189 project=None, version=None, copyright_holder=None, |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
190 msgid_bugs_address=None, creation_date=None, |
206
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
191 revision_date=None, last_translator=None, language_team=None, |
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
192 charset='utf-8', fuzzy=True): |
64 | 193 """Initialize the catalog object. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
194 |
64 | 195 :param locale: the locale identifier or `Locale` object, or `None` |
196 if the catalog is not bound to a locale (which basically | |
197 means it's a template) | |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
198 :param domain: the message domain |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
199 :param header_comment: the header comment as string, or `None` for the |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
200 default header |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
201 :param project: the project's name |
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
202 :param version: the project's version |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
203 :param copyright_holder: the copyright holder of the catalog |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
204 :param msgid_bugs_address: the email address or URL to submit bug |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
205 reports to |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
206 :param creation_date: the date the catalog was created |
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
207 :param revision_date: the date the catalog was revised |
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
208 :param last_translator: the name and email of the last translator |
206
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
209 :param language_team: the name and email of the language team |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
210 :param charset: the encoding to use in the output |
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
211 :param fuzzy: the fuzzy bit on the catalog header |
64 | 212 """ |
107 | 213 self.domain = domain #: The message domain |
64 | 214 if locale: |
215 locale = Locale.parse(locale) | |
107 | 216 self.locale = locale #: The locale or `None` |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
217 self._header_comment = header_comment |
67 | 218 self._messages = odict() |
219 | |
107 | 220 self.project = project or 'PROJECT' #: The project name |
221 self.version = version or 'VERSION' #: The project version | |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
222 self.copyright_holder = copyright_holder or 'ORGANIZATION' |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
223 self.msgid_bugs_address = msgid_bugs_address or 'EMAIL@ADDRESS' |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
224 |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
225 self.last_translator = last_translator or 'FULL NAME <EMAIL@ADDRESS>' |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
226 """Name and email address of the last translator.""" |
206
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
227 self.language_team = language_team or 'LANGUAGE <LL@li.org>' |
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
228 """Name and email address of the language team.""" |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
229 |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
230 self.charset = charset or 'utf-8' |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
231 |
67 | 232 if creation_date is None: |
97 | 233 creation_date = datetime.now(LOCALTZ) |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
234 elif isinstance(creation_date, datetime) and not creation_date.tzinfo: |
97 | 235 creation_date = creation_date.replace(tzinfo=LOCALTZ) |
107 | 236 self.creation_date = creation_date #: Creation date of the template |
67 | 237 if revision_date is None: |
97 | 238 revision_date = datetime.now(LOCALTZ) |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
239 elif isinstance(revision_date, datetime) and not revision_date.tzinfo: |
97 | 240 revision_date = revision_date.replace(tzinfo=LOCALTZ) |
107 | 241 self.revision_date = revision_date #: Last revision date of the catalog |
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
242 self.fuzzy = fuzzy #: Catalog header fuzzy bit (`True` or `False`) |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
243 |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
244 self.obsolete = odict() #: Dictionary of obsolete messages |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
245 self._num_plurals = None |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
246 self._plural_expr = None |
67 | 247 |
107 | 248 def _get_header_comment(self): |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
249 comment = self._header_comment |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
250 comment = comment.replace('PROJECT', self.project) \ |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
251 .replace('VERSION', self.version) \ |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
252 .replace('YEAR', self.revision_date.strftime('%Y')) \ |
120 | 253 .replace('ORGANIZATION', self.copyright_holder) |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
254 if self.locale: |
107 | 255 comment = comment.replace('Translations template', '%s translations' |
256 % self.locale.english_name) | |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
257 return comment |
120 | 258 |
107 | 259 def _set_header_comment(self, string): |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
260 self._header_comment = string |
107 | 261 |
262 header_comment = property(_get_header_comment, _set_header_comment, doc="""\ | |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
263 The header comment for the catalog. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
264 |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
265 >>> catalog = Catalog(project='Foobar', version='1.0', |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
266 ... copyright_holder='Foo Company') |
314 | 267 >>> print catalog.header_comment #doctest: +ELLIPSIS |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
268 # Translations template for Foobar. |
314 | 269 # Copyright (C) ... Foo Company |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
270 # This file is distributed under the same license as the Foobar project. |
314 | 271 # FIRST AUTHOR <EMAIL@ADDRESS>, .... |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
272 # |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
273 |
120 | 274 The header can also be set from a string. Any known upper-case variables |
275 will be replaced when the header is retrieved again: | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
276 |
120 | 277 >>> catalog = Catalog(project='Foobar', version='1.0', |
278 ... copyright_holder='Foo Company') | |
279 >>> catalog.header_comment = '''\\ | |
280 ... # The POT for my really cool PROJECT project. | |
281 ... # Copyright (C) 1990-2003 ORGANIZATION | |
282 ... # This file is distributed under the same license as the PROJECT | |
283 ... # project. | |
284 ... #''' | |
285 >>> print catalog.header_comment | |
286 # The POT for my really cool Foobar project. | |
287 # Copyright (C) 1990-2003 Foo Company | |
288 # This file is distributed under the same license as the Foobar | |
289 # project. | |
290 # | |
291 | |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
292 :type: `unicode` |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
293 """) |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
294 |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
295 def _get_mime_headers(self): |
67 | 296 headers = [] |
297 headers.append(('Project-Id-Version', | |
298 '%s %s' % (self.project, self.version))) | |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
299 headers.append(('Report-Msgid-Bugs-To', self.msgid_bugs_address)) |
67 | 300 headers.append(('POT-Creation-Date', |
131
a63812008056
Use `dates.format_datetime` for dates in PO(T) header, as `datetime.strftime` produces wrong results on windows.
cmlenz
parents:
121
diff
changeset
|
301 format_datetime(self.creation_date, 'yyyy-MM-dd HH:mmZ', |
a63812008056
Use `dates.format_datetime` for dates in PO(T) header, as `datetime.strftime` produces wrong results on windows.
cmlenz
parents:
121
diff
changeset
|
302 locale='en'))) |
67 | 303 if self.locale is None: |
304 headers.append(('PO-Revision-Date', 'YEAR-MO-DA HO:MI+ZONE')) | |
305 headers.append(('Last-Translator', 'FULL NAME <EMAIL@ADDRESS>')) | |
306 headers.append(('Language-Team', 'LANGUAGE <LL@li.org>')) | |
307 else: | |
308 headers.append(('PO-Revision-Date', | |
131
a63812008056
Use `dates.format_datetime` for dates in PO(T) header, as `datetime.strftime` produces wrong results on windows.
cmlenz
parents:
121
diff
changeset
|
309 format_datetime(self.revision_date, |
a63812008056
Use `dates.format_datetime` for dates in PO(T) header, as `datetime.strftime` produces wrong results on windows.
cmlenz
parents:
121
diff
changeset
|
310 'yyyy-MM-dd HH:mmZ', locale='en'))) |
67 | 311 headers.append(('Last-Translator', self.last_translator)) |
206
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
312 headers.append(('Language-Team', |
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
313 self.language_team.replace('LANGUAGE', |
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
314 str(self.locale)))) |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
315 headers.append(('Plural-Forms', self.plural_forms)) |
67 | 316 headers.append(('MIME-Version', '1.0')) |
68 | 317 headers.append(('Content-Type', |
318 'text/plain; charset=%s' % self.charset)) | |
67 | 319 headers.append(('Content-Transfer-Encoding', '8bit')) |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
320 headers.append(('Generated-By', 'Babel %s\n' % VERSION)) |
67 | 321 return headers |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
322 |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
323 def _set_mime_headers(self, headers): |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
324 for name, value in headers: |
293 | 325 if name.lower() == 'content-type': |
210
6c8b69e150a9
When parsing catalog headers, look for the content-type first, to be able to use a specified encoding on all other headers.
cmlenz
parents:
206
diff
changeset
|
326 mimetype, params = parse_header(value) |
6c8b69e150a9
When parsing catalog headers, look for the content-type first, to be able to use a specified encoding on all other headers.
cmlenz
parents:
206
diff
changeset
|
327 if 'charset' in params: |
6c8b69e150a9
When parsing catalog headers, look for the content-type first, to be able to use a specified encoding on all other headers.
cmlenz
parents:
206
diff
changeset
|
328 self.charset = params['charset'].lower() |
6c8b69e150a9
When parsing catalog headers, look for the content-type first, to be able to use a specified encoding on all other headers.
cmlenz
parents:
206
diff
changeset
|
329 break |
6c8b69e150a9
When parsing catalog headers, look for the content-type first, to be able to use a specified encoding on all other headers.
cmlenz
parents:
206
diff
changeset
|
330 for name, value in headers: |
6c8b69e150a9
When parsing catalog headers, look for the content-type first, to be able to use a specified encoding on all other headers.
cmlenz
parents:
206
diff
changeset
|
331 name = name.lower().decode(self.charset) |
6c8b69e150a9
When parsing catalog headers, look for the content-type first, to be able to use a specified encoding on all other headers.
cmlenz
parents:
206
diff
changeset
|
332 value = value.decode(self.charset) |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
333 if name == 'project-id-version': |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
334 parts = value.split(' ') |
210
6c8b69e150a9
When parsing catalog headers, look for the content-type first, to be able to use a specified encoding on all other headers.
cmlenz
parents:
206
diff
changeset
|
335 self.project = u' '.join(parts[:-1]) |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
336 self.version = parts[-1] |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
337 elif name == 'report-msgid-bugs-to': |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
338 self.msgid_bugs_address = value |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
339 elif name == 'last-translator': |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
340 self.last_translator = value |
206
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
341 elif name == 'language-team': |
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
342 self.language_team = value |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
343 elif name == 'plural-forms': |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
344 _, params = parse_header(' ;' + value) |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
345 self._num_plurals = int(params.get('nplurals', 2)) |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
346 self._plural_expr = params.get('plural', '(n != 1)') |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
347 elif name == 'pot-creation-date': |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
348 # FIXME: this should use dates.parse_datetime as soon as that |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
349 # is ready |
479 | 350 value, tzoffset, _ = re.split('([+-]\d{4})$', value, 1) |
351 | |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
352 tt = time.strptime(value, '%Y-%m-%d %H:%M') |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
353 ts = time.mktime(tt) |
479 | 354 |
355 # Separate the offset into a sign component, hours, and minutes | |
356 plus_minus_s, rest = tzoffset[0], tzoffset[1:] | |
357 hours_offset_s, mins_offset_s = rest[:2], rest[2:] | |
358 | |
359 # Make them all integers | |
360 plus_minus = int(plus_minus_s + '1') | |
361 hours_offset = int(hours_offset_s) | |
362 mins_offset = int(mins_offset_s) | |
363 | |
364 # Calculate net offset | |
365 net_mins_offset = hours_offset * 60 | |
366 net_mins_offset += mins_offset | |
367 net_mins_offset *= plus_minus | |
368 | |
369 # Create an offset object | |
370 tzoffset = FixedOffsetTimezone(net_mins_offset) | |
371 | |
372 # Store the offset in a datetime object | |
121 | 373 dt = datetime.fromtimestamp(ts) |
374 self.creation_date = dt.replace(tzinfo=tzoffset) | |
475 | 375 elif name == 'po-revision-date': |
376 # Keep the value if it's not the default one | |
377 if 'YEAR' not in value: | |
378 # FIXME: this should use dates.parse_datetime as soon as | |
379 # that is ready | |
479 | 380 value, tzoffset, _ = re.split('([+-]\d{4})$', value, 1) |
475 | 381 tt = time.strptime(value, '%Y-%m-%d %H:%M') |
382 ts = time.mktime(tt) | |
479 | 383 |
384 # Separate the offset into a sign component, hours, and | |
385 # minutes | |
386 plus_minus_s, rest = tzoffset[0], tzoffset[1:] | |
387 hours_offset_s, mins_offset_s = rest[:2], rest[2:] | |
388 | |
389 # Make them all integers | |
390 plus_minus = int(plus_minus_s + '1') | |
391 hours_offset = int(hours_offset_s) | |
392 mins_offset = int(mins_offset_s) | |
393 | |
394 # Calculate net offset | |
395 net_mins_offset = hours_offset * 60 | |
396 net_mins_offset += mins_offset | |
397 net_mins_offset *= plus_minus | |
398 | |
399 # Create an offset object | |
400 tzoffset = FixedOffsetTimezone(net_mins_offset) | |
401 | |
402 # Store the offset in a datetime object | |
475 | 403 dt = datetime.fromtimestamp(ts) |
404 self.revision_date = dt.replace(tzinfo=tzoffset) | |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
405 |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
406 mime_headers = property(_get_mime_headers, _set_mime_headers, doc="""\ |
67 | 407 The MIME headers of the catalog, used for the special ``msgid ""`` entry. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
408 |
67 | 409 The behavior of this property changes slightly depending on whether a locale |
410 is set or not, the latter indicating that the catalog is actually a template | |
411 for actual translations. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
412 |
67 | 413 Here's an example of the output for such a catalog template: |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
414 |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
415 >>> created = datetime(1990, 4, 1, 15, 30, tzinfo=UTC) |
67 | 416 >>> catalog = Catalog(project='Foobar', version='1.0', |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
417 ... creation_date=created) |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
418 >>> for name, value in catalog.mime_headers: |
67 | 419 ... print '%s: %s' % (name, value) |
420 Project-Id-Version: Foobar 1.0 | |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
421 Report-Msgid-Bugs-To: EMAIL@ADDRESS |
67 | 422 POT-Creation-Date: 1990-04-01 15:30+0000 |
423 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE | |
424 Last-Translator: FULL NAME <EMAIL@ADDRESS> | |
425 Language-Team: LANGUAGE <LL@li.org> | |
426 MIME-Version: 1.0 | |
427 Content-Type: text/plain; charset=utf-8 | |
428 Content-Transfer-Encoding: 8bit | |
429 Generated-By: Babel ... | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
430 |
67 | 431 And here's an example of the output when the locale is set: |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
432 |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
433 >>> revised = datetime(1990, 8, 3, 12, 0, tzinfo=UTC) |
67 | 434 >>> catalog = Catalog(locale='de_DE', project='Foobar', version='1.0', |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
435 ... creation_date=created, revision_date=revised, |
206
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
436 ... last_translator='John Doe <jd@example.com>', |
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
437 ... language_team='de_DE <de@example.com>') |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
438 >>> for name, value in catalog.mime_headers: |
67 | 439 ... print '%s: %s' % (name, value) |
440 Project-Id-Version: Foobar 1.0 | |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
441 Report-Msgid-Bugs-To: EMAIL@ADDRESS |
67 | 442 POT-Creation-Date: 1990-04-01 15:30+0000 |
443 PO-Revision-Date: 1990-08-03 12:00+0000 | |
444 Last-Translator: John Doe <jd@example.com> | |
206
2fe580515695
Preserve language-team header in catalogs on update. Closes #35 again.
cmlenz
parents:
203
diff
changeset
|
445 Language-Team: de_DE <de@example.com> |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
446 Plural-Forms: nplurals=2; plural=(n != 1) |
67 | 447 MIME-Version: 1.0 |
448 Content-Type: text/plain; charset=utf-8 | |
449 Content-Transfer-Encoding: 8bit | |
450 Generated-By: Babel ... | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
451 |
67 | 452 :type: `list` |
453 """) | |
454 | |
68 | 455 def num_plurals(self): |
379 | 456 if self._num_plurals is None: |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
457 num = 2 |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
458 if self.locale: |
379 | 459 num = get_plural(self.locale)[0] |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
460 self._num_plurals = num |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
461 return self._num_plurals |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
462 num_plurals = property(num_plurals, doc="""\ |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
463 The number of plurals used by the catalog or locale. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
464 |
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
465 >>> Catalog(locale='en').num_plurals |
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
466 2 |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
467 >>> Catalog(locale='ga').num_plurals |
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
468 3 |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
469 |
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
470 :type: `int` |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
471 """) |
68 | 472 |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
473 def plural_expr(self): |
379 | 474 if self._plural_expr is None: |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
475 expr = '(n != 1)' |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
476 if self.locale: |
379 | 477 expr = get_plural(self.locale)[1] |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
478 self._plural_expr = expr |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
479 return self._plural_expr |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
480 plural_expr = property(plural_expr, doc="""\ |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
481 The plural expression used by the catalog or locale. |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
482 |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
483 >>> Catalog(locale='en').plural_expr |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
484 '(n != 1)' |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
485 >>> Catalog(locale='ga').plural_expr |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
486 '(n==1 ? 0 : n==2 ? 1 : 2)' |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
487 |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
488 :type: `basestring` |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
489 """) |
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
490 |
67 | 491 def plural_forms(self): |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
492 return 'nplurals=%s; plural=%s' % (self.num_plurals, self.plural_expr) |
67 | 493 plural_forms = property(plural_forms, doc="""\ |
494 Return the plural forms declaration for the locale. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
495 |
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
496 >>> Catalog(locale='en').plural_forms |
67 | 497 'nplurals=2; plural=(n != 1)' |
498 >>> Catalog(locale='pt_BR').plural_forms | |
499 'nplurals=2; plural=(n > 1)' | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
500 |
67 | 501 :type: `str` |
502 """) | |
503 | |
504 def __contains__(self, id): | |
505 """Return whether the catalog has a message with the specified ID.""" | |
69
9b8079807245
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:
68
diff
changeset
|
506 return self._key_for(id) in self._messages |
9b8079807245
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:
68
diff
changeset
|
507 |
9b8079807245
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:
68
diff
changeset
|
508 def __len__(self): |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
509 """The number of messages in the catalog. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
510 |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
511 This does not include the special ``msgid ""`` entry. |
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
512 """ |
69
9b8079807245
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:
68
diff
changeset
|
513 return len(self._messages) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
514 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
515 def __iter__(self): |
64 | 516 """Iterates through all the entries in the catalog, in the order they |
517 were added, yielding a `Message` object for every entry. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
518 |
64 | 519 :rtype: ``iterator`` |
520 """ | |
67 | 521 buf = [] |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
522 for name, value in self.mime_headers: |
67 | 523 buf.append('%s: %s' % (name, value)) |
198
74a346c7846d
Correctly handle non-ASCII chars in the catalog MIME headers.
cmlenz
parents:
196
diff
changeset
|
524 flags = set() |
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
525 if self.fuzzy: |
198
74a346c7846d
Correctly handle non-ASCII chars in the catalog MIME headers.
cmlenz
parents:
196
diff
changeset
|
526 flags |= set(['fuzzy']) |
210
6c8b69e150a9
When parsing catalog headers, look for the content-type first, to be able to use a specified encoding on all other headers.
cmlenz
parents:
206
diff
changeset
|
527 yield Message(u'', '\n'.join(buf), flags=flags) |
69
9b8079807245
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:
68
diff
changeset
|
528 for key in self._messages: |
9b8079807245
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:
68
diff
changeset
|
529 yield self._messages[key] |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
530 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
531 def __repr__(self): |
64 | 532 locale = '' |
533 if self.locale: | |
534 locale = ' %s' % self.locale | |
535 return '<%s %r%s>' % (type(self).__name__, self.domain, locale) | |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
536 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
537 def __delitem__(self, id): |
64 | 538 """Delete the message with the specified ID.""" |
69
9b8079807245
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:
68
diff
changeset
|
539 key = self._key_for(id) |
9b8079807245
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:
68
diff
changeset
|
540 if key in self._messages: |
9b8079807245
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:
68
diff
changeset
|
541 del self._messages[key] |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
542 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
543 def __getitem__(self, id): |
64 | 544 """Return the message with the specified ID. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
545 |
64 | 546 :param id: the message ID |
547 :return: the message with the specified ID, or `None` if no such message | |
548 is in the catalog | |
67 | 549 :rtype: `Message` |
64 | 550 """ |
69
9b8079807245
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:
68
diff
changeset
|
551 return self._messages.get(self._key_for(id)) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
552 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
553 def __setitem__(self, id, message): |
64 | 554 """Add or update the message with the specified ID. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
555 |
64 | 556 >>> catalog = Catalog() |
557 >>> catalog[u'foo'] = Message(u'foo') | |
558 >>> catalog[u'foo'] | |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
559 <Message u'foo' (flags: [])> |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
560 |
64 | 561 If a message with that ID is already in the catalog, it is updated |
562 to include the locations and flags of the new message. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
563 |
64 | 564 >>> catalog = Catalog() |
565 >>> catalog[u'foo'] = Message(u'foo', locations=[('main.py', 1)]) | |
566 >>> catalog[u'foo'].locations | |
567 [('main.py', 1)] | |
568 >>> catalog[u'foo'] = Message(u'foo', locations=[('utils.py', 5)]) | |
569 >>> catalog[u'foo'].locations | |
570 [('main.py', 1), ('utils.py', 5)] | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
571 |
64 | 572 :param id: the message ID |
573 :param message: the `Message` object | |
574 """ | |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
575 assert isinstance(message, Message), 'expected a Message object' |
69
9b8079807245
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:
68
diff
changeset
|
576 key = self._key_for(id) |
9b8079807245
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:
68
diff
changeset
|
577 current = self._messages.get(key) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
578 if current: |
69
9b8079807245
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:
68
diff
changeset
|
579 if message.pluralizable and not current.pluralizable: |
9b8079807245
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:
68
diff
changeset
|
580 # The new message adds pluralization |
9b8079807245
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:
68
diff
changeset
|
581 current.id = message.id |
70
2b0e18a04856
Fix for mixed singular/plural messages, follow-up to [70].
cmlenz
parents:
69
diff
changeset
|
582 current.string = message.string |
229 | 583 current.locations = list(distinct(current.locations + |
584 message.locations)) | |
228
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
227
diff
changeset
|
585 current.auto_comments = list(distinct(current.auto_comments + |
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
227
diff
changeset
|
586 message.auto_comments)) |
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
227
diff
changeset
|
587 current.user_comments = list(distinct(current.user_comments + |
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
227
diff
changeset
|
588 message.user_comments)) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
589 current.flags |= message.flags |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
590 message = current |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
591 elif id == '': |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
592 # special treatment for the header message |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
593 headers = message_from_string(message.string.encode(self.charset)) |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
594 self.mime_headers = headers.items() |
120 | 595 self.header_comment = '\n'.join(['# %s' % comment for comment |
596 in message.user_comments]) | |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
597 self.fuzzy = message.fuzzy |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
598 else: |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
599 if isinstance(id, (list, tuple)): |
278 | 600 assert isinstance(message.string, (list, tuple)), \ |
601 'Expected sequence but got %s' % type(message.string) | |
69
9b8079807245
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:
68
diff
changeset
|
602 self._messages[key] = message |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
603 |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
604 def add(self, id, string=None, locations=(), flags=(), auto_comments=(), |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
605 user_comments=(), previous_id=(), lineno=None): |
64 | 606 """Add or update the message with the specified ID. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
607 |
64 | 608 >>> catalog = Catalog() |
609 >>> catalog.add(u'foo') | |
610 >>> catalog[u'foo'] | |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
611 <Message u'foo' (flags: [])> |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
612 |
64 | 613 This method simply constructs a `Message` object with the given |
614 arguments and invokes `__setitem__` with that object. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
615 |
64 | 616 :param id: the message ID, or a ``(singular, plural)`` tuple for |
617 pluralizable messages | |
618 :param string: the translated message string, or a | |
619 ``(singular, plural)`` tuple for pluralizable messages | |
620 :param locations: a sequence of ``(filenname, lineno)`` tuples | |
621 :param flags: a set or sequence of flags | |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
622 :param auto_comments: a sequence of automatic comments |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
623 :param user_comments: a sequence of user comments |
203 | 624 :param previous_id: the previous message ID, or a ``(singular, plural)`` |
625 tuple for pluralizable messages | |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
626 :param lineno: the line number on which the msgid line was found in the |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
627 PO file, if any |
64 | 628 """ |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
629 self[id] = Message(id, string, list(locations), flags, auto_comments, |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
630 user_comments, previous_id, lineno=lineno) |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
631 |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
632 def check(self): |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
633 """Run various validation checks on the translations in the catalog. |
226 | 634 |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
635 For every message which fails validation, this method yield a |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
636 ``(message, errors)`` tuple, where ``message`` is the `Message` object |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
637 and ``errors`` is a sequence of `TranslationError` objects. |
226 | 638 |
220
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
639 :rtype: ``iterator`` |
677147547e2d
Added infrastructure for adding catalog checkers, and implement a checker that validations Python format parameters in translations, closing #19.
cmlenz
parents:
210
diff
changeset
|
640 """ |
369 | 641 for message in self._messages.values(): |
642 errors = message.check(catalog=self) | |
643 if errors: | |
644 yield message, errors | |
69
9b8079807245
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:
68
diff
changeset
|
645 |
203 | 646 def update(self, template, no_fuzzy_matching=False): |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
647 """Update the catalog based on the given template catalog. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
648 |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
649 >>> from babel.messages import Catalog |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
650 >>> template = Catalog() |
188 | 651 >>> template.add('green', locations=[('main.py', 99)]) |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
652 >>> template.add('blue', locations=[('main.py', 100)]) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
653 >>> template.add(('salad', 'salads'), locations=[('util.py', 42)]) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
654 >>> catalog = Catalog(locale='de_DE') |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
655 >>> catalog.add('blue', u'blau', locations=[('main.py', 98)]) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
656 >>> catalog.add('head', u'Kopf', locations=[('util.py', 33)]) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
657 >>> catalog.add(('salad', 'salads'), (u'Salat', u'Salate'), |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
658 ... locations=[('util.py', 38)]) |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
659 |
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
660 >>> catalog.update(template) |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
661 >>> len(catalog) |
188 | 662 3 |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
663 |
188 | 664 >>> msg1 = catalog['green'] |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
665 >>> msg1.string |
188 | 666 >>> msg1.locations |
667 [('main.py', 99)] | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
668 |
188 | 669 >>> msg2 = catalog['blue'] |
670 >>> msg2.string | |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
671 u'blau' |
188 | 672 >>> msg2.locations |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
673 [('main.py', 100)] |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
674 |
188 | 675 >>> msg3 = catalog['salad'] |
676 >>> msg3.string | |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
677 (u'Salat', u'Salate') |
188 | 678 >>> msg3.locations |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
679 [('util.py', 42)] |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
680 |
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
681 Messages that are in the catalog but not in the template are removed |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
682 from the main collection, but can still be accessed via the `obsolete` |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
683 member: |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
684 |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
685 >>> 'head' in catalog |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
686 False |
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
687 >>> catalog.obsolete.values() |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
688 [<Message 'head' (flags: [])>] |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
689 |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
690 :param template: the reference catalog, usually read from a POT file |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
691 :param no_fuzzy_matching: whether to use fuzzy matching of message IDs |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
692 """ |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
693 messages = self._messages |
314 | 694 remaining = messages.copy() |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
695 self._messages = odict() |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
696 |
314 | 697 # Prepare for fuzzy matching |
698 fuzzy_candidates = [] | |
699 if not no_fuzzy_matching: | |
700 fuzzy_candidates = [ | |
701 self._key_for(msgid) for msgid in messages | |
702 if msgid and messages[msgid].string | |
703 ] | |
704 fuzzy_matches = set() | |
705 | |
278 | 706 def _merge(message, oldkey, newkey): |
314 | 707 message = message.clone() |
278 | 708 fuzzy = False |
709 if oldkey != newkey: | |
710 fuzzy = True | |
314 | 711 fuzzy_matches.add(oldkey) |
712 oldmsg = messages.get(oldkey) | |
278 | 713 if isinstance(oldmsg.id, basestring): |
714 message.previous_id = [oldmsg.id] | |
715 else: | |
716 message.previous_id = list(oldmsg.id) | |
314 | 717 else: |
346
faf0ead3a132
Merged revisions [358:360], [364:370], [373:378], [380:382] from [source:trunk].
cmlenz
parents:
314
diff
changeset
|
718 oldmsg = remaining.pop(oldkey, None) |
278 | 719 message.string = oldmsg.string |
720 if isinstance(message.id, (list, tuple)): | |
721 if not isinstance(message.string, (list, tuple)): | |
722 fuzzy = True | |
723 message.string = tuple( | |
724 [message.string] + ([u''] * (len(message.id) - 1)) | |
725 ) | |
452 | 726 elif len(message.string) != self.num_plurals: |
278 | 727 fuzzy = True |
728 message.string = tuple(message.string[:len(oldmsg.string)]) | |
729 elif isinstance(message.string, (list, tuple)): | |
730 fuzzy = True | |
731 message.string = message.string[0] | |
732 message.flags |= oldmsg.flags | |
733 if fuzzy: | |
734 message.flags |= set([u'fuzzy']) | |
735 self[message.id] = message | |
736 | |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
737 for message in template: |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
738 if message.id: |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
739 key = self._key_for(message.id) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
740 if key in messages: |
278 | 741 _merge(message, key, key) |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
742 else: |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
743 if no_fuzzy_matching is False: |
165
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
744 # do some fuzzy matching with difflib |
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
745 matches = get_close_matches(key.lower().strip(), |
314 | 746 fuzzy_candidates, 1) |
165
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
747 if matches: |
278 | 748 _merge(message, matches[0], key) |
188 | 749 continue |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
750 |
165
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
751 self[message.id] = message |
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
752 |
314 | 753 self.obsolete = odict() |
754 for msgid in remaining: | |
755 if no_fuzzy_matching or msgid not in fuzzy_matches: | |
756 self.obsolete[msgid] = remaining[msgid] | |
472 | 757 # Make updated catalog's POT-Creation-Date equal to the template |
758 # used to update the catalog | |
759 self.creation_date = template.creation_date | |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
760 |
69
9b8079807245
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:
68
diff
changeset
|
761 def _key_for(self, id): |
9b8079807245
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:
68
diff
changeset
|
762 """The key for a message is just the singular ID even for pluralizable |
9b8079807245
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:
68
diff
changeset
|
763 messages. |
9b8079807245
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:
68
diff
changeset
|
764 """ |
9b8079807245
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:
68
diff
changeset
|
765 key = id |
9b8079807245
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:
68
diff
changeset
|
766 if isinstance(key, (list, tuple)): |
9b8079807245
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:
68
diff
changeset
|
767 key = id[0] |
9b8079807245
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:
68
diff
changeset
|
768 return key |