Mercurial > babel > old > babel-test
annotate babel/messages/catalog.py @ 203:e50aaaabb3d3
Minor changes to how previous msgids are processed.
author | cmlenz |
---|---|
date | Tue, 03 Jul 2007 21:19:27 +0000 |
parents | 0b1ba2423ab7 |
children | 2fe580515695 |
rev | line source |
---|---|
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
1 # -*- coding: utf-8 -*- |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
2 # |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
3 # Copyright (C) 2007 Edgewall Software |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
4 # All rights reserved. |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
5 # |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
6 # This software is licensed as described in the file COPYING, which |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
7 # you should have received as part of this distribution. The terms |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
8 # are also available at http://babel.edgewall.org/wiki/License. |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
9 # |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
10 # This software consists of voluntary contributions made by many |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
11 # individuals. For the exact contribution history, see the revision |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
12 # history and logs, available at http://babel.edgewall.org/log/. |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
13 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
14 """Data structures for message catalogs.""" |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
15 |
149
ba5150e9544e
Respect charset specified in PO headers in `read_po()`. Fixes #17.
cmlenz
parents:
131
diff
changeset
|
16 from cgi import parse_header |
67 | 17 from datetime import datetime |
165
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
18 from difflib import get_close_matches |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
19 from email import message_from_string |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
20 import re |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
21 try: |
27fba894d3ca
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 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
23 except NameError: |
27fba894d3ca
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
27fba894d3ca
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
a63812008056
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 |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
31 from babel.util import odict, LOCALTZ, UTC, FixedOffsetTimezone |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
32 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
33 __all__ = ['Message', 'Catalog'] |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
34 __docformat__ = 'restructuredtext en' |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
35 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
36 PYTHON_FORMAT = re.compile(r'\%(\([\w]+\))?[diouxXeEfFgGcrs]').search |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
37 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
38 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
39 class Message(object): |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
40 """Representation of a single message in a catalog.""" |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
41 |
149
ba5150e9544e
Respect charset specified in PO headers in `read_po()`. Fixes #17.
cmlenz
parents:
131
diff
changeset
|
42 def __init__(self, id, string=u'', locations=(), flags=(), auto_comments=(), |
203 | 43 user_comments=(), previous_id=()): |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
44 """Create the message object. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
45 |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
46 :param id: the message ID, or a ``(singular, plural)`` tuple for |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
47 pluralizable messages |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
48 :param string: the translated message string, or a |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
49 ``(singular, plural)`` tuple for pluralizable messages |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
50 :param locations: a sequence of ``(filenname, lineno)`` tuples |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
51 :param flags: a set or sequence of flags |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
52 :param auto_comments: a sequence of automatic comments for the message |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
53 :param user_comments: a sequence of user comments for the message |
203 | 54 :param previous_id: the previous message ID, or a ``(singular, plural)`` |
55 tuple for pluralizable messages | |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
56 """ |
107 | 57 self.id = id #: The message ID |
68 | 58 if not string and self.pluralizable: |
59 string = (u'', u'') | |
107 | 60 self.string = string #: The message translation |
70
2b0e18a04856
Fix for mixed singular/plural messages, follow-up to [70].
cmlenz
parents:
69
diff
changeset
|
61 self.locations = list(locations) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
62 self.flags = set(flags) |
67 | 63 if id and self.python_format: |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
64 self.flags.add('python-format') |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
65 else: |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
66 self.flags.discard('python-format') |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
67 self.auto_comments = list(auto_comments) |
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
68 self.user_comments = list(user_comments) |
203 | 69 if isinstance(previous_id, basestring): |
70 self.previous_id = [previous_id] | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
71 else: |
203 | 72 self.previous_id = list(previous_id) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
73 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
74 def __repr__(self): |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
75 return '<%s %r (flags: %r)>' % (type(self).__name__, self.id, |
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
76 list(self.flags)) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
77 |
67 | 78 def fuzzy(self): |
79 return 'fuzzy' in self.flags | |
80 fuzzy = property(fuzzy, doc="""\ | |
81 Whether the translation is fuzzy. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
82 |
67 | 83 >>> Message('foo').fuzzy |
84 False | |
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
85 >>> msg = Message('foo', 'foo', flags=['fuzzy']) |
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
86 >>> msg.fuzzy |
67 | 87 True |
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
88 >>> msg |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
89 <Message 'foo' (flags: ['fuzzy'])> |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
90 |
67 | 91 :type: `bool` |
92 """) | |
93 | |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
94 def pluralizable(self): |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
95 return isinstance(self.id, (list, tuple)) |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
96 pluralizable = property(pluralizable, doc="""\ |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
97 Whether the message is plurizable. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
98 |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
99 >>> Message('foo').pluralizable |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
100 False |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
101 >>> Message(('foo', 'bar')).pluralizable |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
102 True |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
103 |
61
da7efa40a9e2
Move `Translations` and `LazyProxy` to new `babel.support` module, which should contain any convenience code that is useful for applications using Babel/I18n, but not used by Babel itself.
cmlenz
parents:
56
diff
changeset
|
104 :type: `bool` |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
105 """) |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
106 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
107 def python_format(self): |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
108 ids = self.id |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
109 if not isinstance(ids, (list, tuple)): |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
110 ids = [ids] |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
111 return bool(filter(None, [PYTHON_FORMAT(id) for id in ids])) |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
112 python_format = property(python_format, doc="""\ |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
113 Whether the message contains Python-style parameters. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
114 |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
115 >>> Message('foo %(name)s bar').python_format |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
116 True |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
117 >>> Message(('foo %(name)s', 'foo %(name)s')).python_format |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
118 True |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
119 |
61
da7efa40a9e2
Move `Translations` and `LazyProxy` to new `babel.support` module, which should contain any convenience code that is useful for applications using Babel/I18n, but not used by Babel itself.
cmlenz
parents:
56
diff
changeset
|
120 :type: `bool` |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
121 """) |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
122 |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
123 |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
124 DEFAULT_HEADER = u"""\ |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
125 # Translations template for PROJECT. |
120 | 126 # Copyright (C) YEAR ORGANIZATION |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
127 # This file is distributed under the same license as the PROJECT project. |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
128 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR. |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
129 #""" |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
130 |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
131 |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
132 class Catalog(object): |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
133 """Representation of a message catalog.""" |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
134 |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
135 def __init__(self, locale=None, domain=None, header_comment=DEFAULT_HEADER, |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
136 project=None, version=None, copyright_holder=None, |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
137 msgid_bugs_address=None, creation_date=None, |
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
138 revision_date=None, last_translator=None, charset='utf-8', |
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
139 fuzzy=True): |
64 | 140 """Initialize the catalog object. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
141 |
64 | 142 :param locale: the locale identifier or `Locale` object, or `None` |
143 if the catalog is not bound to a locale (which basically | |
144 means it's a template) | |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
145 :param domain: the message domain |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
146 :param header_comment: the header comment as string, or `None` for the |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
147 default header |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
148 :param project: the project's name |
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
149 :param version: the project's version |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
150 :param copyright_holder: the copyright holder of the catalog |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
151 :param msgid_bugs_address: the email address or URL to submit bug |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
152 reports to |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
153 :param creation_date: the date the catalog was created |
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
154 :param revision_date: the date the catalog was revised |
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
155 :param last_translator: the name and email of the last translator |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
156 :param charset: the encoding to use in the output |
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
157 :param fuzzy: the fuzzy bit on the catalog header |
64 | 158 """ |
107 | 159 self.domain = domain #: The message domain |
64 | 160 if locale: |
161 locale = Locale.parse(locale) | |
107 | 162 self.locale = locale #: The locale or `None` |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
163 self._header_comment = header_comment |
67 | 164 self._messages = odict() |
165 | |
107 | 166 self.project = project or 'PROJECT' #: The project name |
167 self.version = version or 'VERSION' #: The project version | |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
168 self.copyright_holder = copyright_holder or 'ORGANIZATION' |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
169 self.msgid_bugs_address = msgid_bugs_address or 'EMAIL@ADDRESS' |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
170 |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
171 self.last_translator = last_translator or 'FULL NAME <EMAIL@ADDRESS>' |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
172 """Name and email address of the last translator.""" |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
173 |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
174 self.charset = charset or 'utf-8' |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
175 |
67 | 176 if creation_date is None: |
97 | 177 creation_date = datetime.now(LOCALTZ) |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
178 elif isinstance(creation_date, datetime) and not creation_date.tzinfo: |
97 | 179 creation_date = creation_date.replace(tzinfo=LOCALTZ) |
107 | 180 self.creation_date = creation_date #: Creation date of the template |
67 | 181 if revision_date is None: |
97 | 182 revision_date = datetime.now(LOCALTZ) |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
183 elif isinstance(revision_date, datetime) and not revision_date.tzinfo: |
97 | 184 revision_date = revision_date.replace(tzinfo=LOCALTZ) |
107 | 185 self.revision_date = revision_date #: Last revision date of the catalog |
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
186 self.fuzzy = fuzzy #: Catalog header fuzzy bit (`True` or `False`) |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
187 |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
188 self.obsolete = odict() #: Dictionary of obsolete messages |
67 | 189 |
107 | 190 def _get_header_comment(self): |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
191 comment = self._header_comment |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
192 comment = comment.replace('PROJECT', self.project) \ |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
193 .replace('VERSION', self.version) \ |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
194 .replace('YEAR', self.revision_date.strftime('%Y')) \ |
120 | 195 .replace('ORGANIZATION', self.copyright_holder) |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
196 if self.locale: |
107 | 197 comment = comment.replace('Translations template', '%s translations' |
198 % self.locale.english_name) | |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
199 return comment |
120 | 200 |
107 | 201 def _set_header_comment(self, string): |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
202 self._header_comment = string |
107 | 203 |
204 header_comment = property(_get_header_comment, _set_header_comment, doc="""\ | |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
205 The header comment for the catalog. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
206 |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
207 >>> catalog = Catalog(project='Foobar', version='1.0', |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
208 ... copyright_holder='Foo Company') |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
209 >>> print catalog.header_comment |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
210 # Translations template for Foobar. |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
211 # Copyright (C) 2007 Foo Company |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
212 # This file is distributed under the same license as the Foobar project. |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
213 # FIRST AUTHOR <EMAIL@ADDRESS>, 2007. |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
214 # |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
215 |
120 | 216 The header can also be set from a string. Any known upper-case variables |
217 will be replaced when the header is retrieved again: | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
218 |
120 | 219 >>> catalog = Catalog(project='Foobar', version='1.0', |
220 ... copyright_holder='Foo Company') | |
221 >>> catalog.header_comment = '''\\ | |
222 ... # The POT for my really cool PROJECT project. | |
223 ... # Copyright (C) 1990-2003 ORGANIZATION | |
224 ... # This file is distributed under the same license as the PROJECT | |
225 ... # project. | |
226 ... #''' | |
227 >>> print catalog.header_comment | |
228 # The POT for my really cool Foobar project. | |
229 # Copyright (C) 1990-2003 Foo Company | |
230 # This file is distributed under the same license as the Foobar | |
231 # project. | |
232 # | |
233 | |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
234 :type: `unicode` |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
235 """) |
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
236 |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
237 def _get_mime_headers(self): |
67 | 238 headers = [] |
239 headers.append(('Project-Id-Version', | |
240 '%s %s' % (self.project, self.version))) | |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
241 headers.append(('Report-Msgid-Bugs-To', self.msgid_bugs_address)) |
67 | 242 headers.append(('POT-Creation-Date', |
131
a63812008056
Use `dates.format_datetime` for dates in PO(T) header, as `datetime.strftime` produces wrong results on windows.
cmlenz
parents:
121
diff
changeset
|
243 format_datetime(self.creation_date, 'yyyy-MM-dd HH:mmZ', |
a63812008056
Use `dates.format_datetime` for dates in PO(T) header, as `datetime.strftime` produces wrong results on windows.
cmlenz
parents:
121
diff
changeset
|
244 locale='en'))) |
67 | 245 if self.locale is None: |
246 headers.append(('PO-Revision-Date', 'YEAR-MO-DA HO:MI+ZONE')) | |
247 headers.append(('Last-Translator', 'FULL NAME <EMAIL@ADDRESS>')) | |
248 headers.append(('Language-Team', 'LANGUAGE <LL@li.org>')) | |
249 else: | |
250 headers.append(('PO-Revision-Date', | |
131
a63812008056
Use `dates.format_datetime` for dates in PO(T) header, as `datetime.strftime` produces wrong results on windows.
cmlenz
parents:
121
diff
changeset
|
251 format_datetime(self.revision_date, |
a63812008056
Use `dates.format_datetime` for dates in PO(T) header, as `datetime.strftime` produces wrong results on windows.
cmlenz
parents:
121
diff
changeset
|
252 'yyyy-MM-dd HH:mmZ', locale='en'))) |
67 | 253 headers.append(('Last-Translator', self.last_translator)) |
254 headers.append(('Language-Team', '%s <LL@li.org>' % self.locale)) | |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
255 headers.append(('Plural-Forms', self.plural_forms)) |
67 | 256 headers.append(('MIME-Version', '1.0')) |
68 | 257 headers.append(('Content-Type', |
258 'text/plain; charset=%s' % self.charset)) | |
67 | 259 headers.append(('Content-Transfer-Encoding', '8bit')) |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
260 headers.append(('Generated-By', 'Babel %s\n' % VERSION)) |
67 | 261 return headers |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
262 |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
263 def _set_mime_headers(self, headers): |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
264 for name, value in headers: |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
265 name = name.lower() |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
266 if name == 'project-id-version': |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
267 parts = value.split(' ') |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
268 self.project = ' '.join(parts[:-1]) |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
269 self.version = parts[-1] |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
270 elif name == 'report-msgid-bugs-to': |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
271 self.msgid_bugs_address = value |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
272 elif name == 'last-translator': |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
273 self.last_translator = value |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
274 elif name == 'pot-creation-date': |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
275 # FIXME: this should use dates.parse_datetime as soon as that |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
276 # is ready |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
277 value, tzoffset, _ = re.split('[+-](\d{4})$', value, 1) |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
278 tt = time.strptime(value, '%Y-%m-%d %H:%M') |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
279 ts = time.mktime(tt) |
120 | 280 tzoffset = FixedOffsetTimezone(int(tzoffset[:2]) * 60 + |
281 int(tzoffset[2:])) | |
121 | 282 dt = datetime.fromtimestamp(ts) |
283 self.creation_date = dt.replace(tzinfo=tzoffset) | |
149
ba5150e9544e
Respect charset specified in PO headers in `read_po()`. Fixes #17.
cmlenz
parents:
131
diff
changeset
|
284 elif name == 'content-type': |
ba5150e9544e
Respect charset specified in PO headers in `read_po()`. Fixes #17.
cmlenz
parents:
131
diff
changeset
|
285 mimetype, params = parse_header(value) |
ba5150e9544e
Respect charset specified in PO headers in `read_po()`. Fixes #17.
cmlenz
parents:
131
diff
changeset
|
286 if 'charset' in params: |
ba5150e9544e
Respect charset specified in PO headers in `read_po()`. Fixes #17.
cmlenz
parents:
131
diff
changeset
|
287 self.charset = params['charset'].lower() |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
288 |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
289 mime_headers = property(_get_mime_headers, _set_mime_headers, doc="""\ |
67 | 290 The MIME headers of the catalog, used for the special ``msgid ""`` entry. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
291 |
67 | 292 The behavior of this property changes slightly depending on whether a locale |
293 is set or not, the latter indicating that the catalog is actually a template | |
294 for actual translations. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
295 |
67 | 296 Here's an example of the output for such a catalog template: |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
297 |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
298 >>> created = datetime(1990, 4, 1, 15, 30, tzinfo=UTC) |
67 | 299 >>> catalog = Catalog(project='Foobar', version='1.0', |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
300 ... creation_date=created) |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
301 >>> for name, value in catalog.mime_headers: |
67 | 302 ... print '%s: %s' % (name, value) |
303 Project-Id-Version: Foobar 1.0 | |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
304 Report-Msgid-Bugs-To: EMAIL@ADDRESS |
67 | 305 POT-Creation-Date: 1990-04-01 15:30+0000 |
306 PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE | |
307 Last-Translator: FULL NAME <EMAIL@ADDRESS> | |
308 Language-Team: LANGUAGE <LL@li.org> | |
309 MIME-Version: 1.0 | |
310 Content-Type: text/plain; charset=utf-8 | |
311 Content-Transfer-Encoding: 8bit | |
312 Generated-By: Babel ... | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
313 |
67 | 314 And here's an example of the output when the locale is set: |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
315 |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
316 >>> revised = datetime(1990, 8, 3, 12, 0, tzinfo=UTC) |
67 | 317 >>> catalog = Catalog(locale='de_DE', project='Foobar', version='1.0', |
95
008cd3f7d485
Fix for #11 (use local timezone in timestamps of generated POT).
cmlenz
parents:
87
diff
changeset
|
318 ... creation_date=created, revision_date=revised, |
67 | 319 ... last_translator='John Doe <jd@example.com>') |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
320 >>> for name, value in catalog.mime_headers: |
67 | 321 ... print '%s: %s' % (name, value) |
322 Project-Id-Version: Foobar 1.0 | |
78
ee043bb666f0
Fixed the plurals header on `Catalog` which should only be written if it's not a catalog template.
palgarvio
parents:
70
diff
changeset
|
323 Report-Msgid-Bugs-To: EMAIL@ADDRESS |
67 | 324 POT-Creation-Date: 1990-04-01 15:30+0000 |
325 PO-Revision-Date: 1990-08-03 12:00+0000 | |
326 Last-Translator: John Doe <jd@example.com> | |
327 Language-Team: de_DE <LL@li.org> | |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
328 Plural-Forms: nplurals=2; plural=(n != 1) |
67 | 329 MIME-Version: 1.0 |
330 Content-Type: text/plain; charset=utf-8 | |
331 Content-Transfer-Encoding: 8bit | |
332 Generated-By: Babel ... | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
333 |
67 | 334 :type: `list` |
335 """) | |
336 | |
68 | 337 def num_plurals(self): |
338 num = 2 | |
339 if self.locale: | |
340 if str(self.locale) in PLURALS: | |
341 num = PLURALS[str(self.locale)][0] | |
342 elif self.locale.language in PLURALS: | |
343 num = PLURALS[self.locale.language][0] | |
344 return num | |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
345 num_plurals = property(num_plurals, doc="""\ |
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
346 The number of plurals used by the locale. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
347 |
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
348 >>> Catalog(locale='en').num_plurals |
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
349 2 |
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
350 >>> Catalog(locale='cs_CZ').num_plurals |
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
351 3 |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
352 |
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
353 :type: `int` |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
354 """) |
68 | 355 |
67 | 356 def plural_forms(self): |
357 num, expr = ('INTEGER', 'EXPRESSION') | |
358 if self.locale: | |
359 if str(self.locale) in PLURALS: | |
360 num, expr = PLURALS[str(self.locale)] | |
361 elif self.locale.language in PLURALS: | |
362 num, expr = PLURALS[self.locale.language] | |
363 return 'nplurals=%s; plural=%s' % (num, expr) | |
364 plural_forms = property(plural_forms, doc="""\ | |
365 Return the plural forms declaration for the locale. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
366 |
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
97
diff
changeset
|
367 >>> Catalog(locale='en').plural_forms |
67 | 368 'nplurals=2; plural=(n != 1)' |
369 >>> Catalog(locale='pt_BR').plural_forms | |
370 'nplurals=2; plural=(n > 1)' | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
371 |
67 | 372 :type: `str` |
373 """) | |
374 | |
375 def __contains__(self, id): | |
376 """Return whether the catalog has a message with the specified ID.""" | |
69
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
377 return self._key_for(id) in self._messages |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
378 |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
379 def __len__(self): |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
380 """The number of messages in the catalog. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
381 |
84
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
382 This does not include the special ``msgid ""`` entry. |
4ff9cc26c11b
Some cosmetic changes for the new translator comments support.
cmlenz
parents:
80
diff
changeset
|
383 """ |
69
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
384 return len(self._messages) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
385 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
386 def __iter__(self): |
64 | 387 """Iterates through all the entries in the catalog, in the order they |
388 were added, yielding a `Message` object for every entry. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
389 |
64 | 390 :rtype: ``iterator`` |
391 """ | |
67 | 392 buf = [] |
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
393 for name, value in self.mime_headers: |
67 | 394 buf.append('%s: %s' % (name, value)) |
198
74a346c7846d
Correctly handle non-ASCII chars in the catalog MIME headers.
cmlenz
parents:
196
diff
changeset
|
395 flags = set() |
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
165
diff
changeset
|
396 if self.fuzzy: |
198
74a346c7846d
Correctly handle non-ASCII chars in the catalog MIME headers.
cmlenz
parents:
196
diff
changeset
|
397 flags |= set(['fuzzy']) |
74a346c7846d
Correctly handle non-ASCII chars in the catalog MIME headers.
cmlenz
parents:
196
diff
changeset
|
398 yield Message(u'', u'\n'.join(buf), flags=flags) |
69
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
399 for key in self._messages: |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
400 yield self._messages[key] |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
401 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
402 def __repr__(self): |
64 | 403 locale = '' |
404 if self.locale: | |
405 locale = ' %s' % self.locale | |
406 return '<%s %r%s>' % (type(self).__name__, self.domain, locale) | |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
407 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
408 def __delitem__(self, id): |
64 | 409 """Delete the message with the specified ID.""" |
69
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
410 key = self._key_for(id) |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
411 if key in self._messages: |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
412 del self._messages[key] |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
413 |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
414 def __getitem__(self, id): |
64 | 415 """Return the message with the specified ID. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
416 |
64 | 417 :param id: the message ID |
418 :return: the message with the specified ID, or `None` if no such message | |
419 is in the catalog | |
67 | 420 :rtype: `Message` |
64 | 421 """ |
69
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
422 return self._messages.get(self._key_for(id)) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
423 |
27fba894d3ca
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 __setitem__(self, id, message): |
64 | 425 """Add or update the message with the specified ID. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
426 |
64 | 427 >>> catalog = Catalog() |
428 >>> catalog[u'foo'] = Message(u'foo') | |
429 >>> catalog[u'foo'] | |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
430 <Message u'foo' (flags: [])> |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
431 |
64 | 432 If a message with that ID is already in the catalog, it is updated |
433 to include the locations and flags of the new message. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
434 |
64 | 435 >>> catalog = Catalog() |
436 >>> catalog[u'foo'] = Message(u'foo', locations=[('main.py', 1)]) | |
437 >>> catalog[u'foo'].locations | |
438 [('main.py', 1)] | |
439 >>> catalog[u'foo'] = Message(u'foo', locations=[('utils.py', 5)]) | |
440 >>> catalog[u'foo'].locations | |
441 [('main.py', 1), ('utils.py', 5)] | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
442 |
64 | 443 :param id: the message ID |
444 :param message: the `Message` object | |
445 """ | |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
446 assert isinstance(message, Message), 'expected a Message object' |
69
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
447 key = self._key_for(id) |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
448 current = self._messages.get(key) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
449 if current: |
69
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
450 if message.pluralizable and not current.pluralizable: |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
451 # The new message adds pluralization |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
452 current.id = message.id |
70
2b0e18a04856
Fix for mixed singular/plural messages, follow-up to [70].
cmlenz
parents:
69
diff
changeset
|
453 current.string = message.string |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
454 current.locations.extend(message.locations) |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
455 current.auto_comments.extend(message.auto_comments) |
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
456 current.user_comments.extend(message.user_comments) |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
457 current.flags |= message.flags |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
458 message = current |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
459 elif id == '': |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
460 # special treatment for the header message |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
461 headers = message_from_string(message.string.encode(self.charset)) |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
462 self.mime_headers = headers.items() |
120 | 463 self.header_comment = '\n'.join(['# %s' % comment for comment |
464 in message.user_comments]) | |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
465 self.fuzzy = message.fuzzy |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
466 else: |
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
467 if isinstance(id, (list, tuple)): |
68 | 468 assert isinstance(message.string, (list, tuple)) |
69
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
469 self._messages[key] = message |
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
diff
changeset
|
470 |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
471 def add(self, id, string=None, locations=(), flags=(), auto_comments=(), |
203 | 472 user_comments=(), previous_id=()): |
64 | 473 """Add or update the message with the specified ID. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
474 |
64 | 475 >>> catalog = Catalog() |
476 >>> catalog.add(u'foo') | |
477 >>> catalog[u'foo'] | |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
478 <Message u'foo' (flags: [])> |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
479 |
64 | 480 This method simply constructs a `Message` object with the given |
481 arguments and invokes `__setitem__` with that object. | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
482 |
64 | 483 :param id: the message ID, or a ``(singular, plural)`` tuple for |
484 pluralizable messages | |
485 :param string: the translated message string, or a | |
486 ``(singular, plural)`` tuple for pluralizable messages | |
487 :param locations: a sequence of ``(filenname, lineno)`` tuples | |
488 :param flags: a set or sequence of flags | |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
489 :param auto_comments: a sequence of automatic comments |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
490 :param user_comments: a sequence of user comments |
203 | 491 :param previous_id: the previous message ID, or a ``(singular, plural)`` |
492 tuple for pluralizable messages | |
64 | 493 """ |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
494 self[id] = Message(id, string, list(locations), flags, auto_comments, |
203 | 495 user_comments, previous_id) |
69
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
496 |
203 | 497 def update(self, template, no_fuzzy_matching=False): |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
498 """Update the catalog based on the given template catalog. |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
499 |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
500 >>> from babel.messages import Catalog |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
501 >>> template = Catalog() |
188 | 502 >>> template.add('green', locations=[('main.py', 99)]) |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
503 >>> template.add('blue', locations=[('main.py', 100)]) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
504 >>> template.add(('salad', 'salads'), locations=[('util.py', 42)]) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
505 >>> catalog = Catalog(locale='de_DE') |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
506 >>> catalog.add('blue', u'blau', locations=[('main.py', 98)]) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
507 >>> catalog.add('head', u'Kopf', locations=[('util.py', 33)]) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
508 >>> catalog.add(('salad', 'salads'), (u'Salat', u'Salate'), |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
509 ... locations=[('util.py', 38)]) |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
510 |
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
511 >>> catalog.update(template) |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
512 >>> len(catalog) |
188 | 513 3 |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
514 |
188 | 515 >>> msg1 = catalog['green'] |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
516 >>> msg1.string |
188 | 517 >>> msg1.locations |
518 [('main.py', 99)] | |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
519 |
188 | 520 >>> msg2 = catalog['blue'] |
521 >>> msg2.string | |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
522 u'blau' |
188 | 523 >>> msg2.locations |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
524 [('main.py', 100)] |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
525 |
188 | 526 >>> msg3 = catalog['salad'] |
527 >>> msg3.string | |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
528 (u'Salat', u'Salate') |
188 | 529 >>> msg3.locations |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
530 [('util.py', 42)] |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
531 |
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
532 Messages that are in the catalog but not in the template are removed |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
533 from the main collection, but can still be accessed via the `obsolete` |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
534 member: |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
535 |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
536 >>> 'head' in catalog |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
537 False |
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
538 >>> catalog.obsolete.values() |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
188
diff
changeset
|
539 [<Message 'head' (flags: [])>] |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
540 |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
541 :param template: the reference catalog, usually read from a POT file |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
542 :param no_fuzzy_matching: whether to use fuzzy matching of message IDs |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
543 """ |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
544 messages = self._messages |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
545 self._messages = odict() |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
546 |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
547 for message in template: |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
548 if message.id: |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
549 key = self._key_for(message.id) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
550 if key in messages: |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
551 oldmsg = messages.pop(key) |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
552 message.string = oldmsg.string |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
553 message.flags |= oldmsg.flags |
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
554 self[message.id] = message |
165
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
555 |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
556 else: |
200
2983c718f6e2
Added `--no-fuzzy-matching` to the frontends and also `--previous` which adds the old msgid's as comments. The latest closes #31.
palgarvio
parents:
198
diff
changeset
|
557 if no_fuzzy_matching is False: |
165
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
558 # do some fuzzy matching with difflib |
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
559 matches = get_close_matches(key.lower().strip(), |
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
560 [self._key_for(msgid) for msgid in messages], 1) |
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
561 if matches: |
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
562 oldmsg = messages.pop(matches[0]) |
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
563 message.string = oldmsg.string |
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
564 message.flags |= oldmsg.flags | set([u'fuzzy']) |
203 | 565 if isinstance(oldmsg.id, basestring): |
566 message.previous_id = [oldmsg.id] | |
567 else: | |
568 message.previous_id = list(oldmsg.id) | |
165
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
569 self[message.id] = message |
188 | 570 continue |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
571 |
165
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
572 self[message.id] = message |
650a6e996ede
Implement fuzzy matching to catalog updates. No frontend yet.
cmlenz
parents:
163
diff
changeset
|
573 |
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
574 self.obsolete = messages |
163
f2c78a271159
Added preliminary catalog updating/merging functionality.
cmlenz
parents:
149
diff
changeset
|
575 |
69
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
576 def _key_for(self, id): |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
577 """The key for a message is just the singular ID even for pluralizable |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
578 messages. |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
579 """ |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
580 key = id |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
581 if isinstance(key, (list, tuple)): |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
582 key = id[0] |
9b8079807245
Message catalogs can have multiple messages with the same ID, where some of them have plural strings, and others don't. Still the same message.
cmlenz
parents:
68
diff
changeset
|
583 return key |