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