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