3

e��Y
y�@s 
dZd
dl
Z
d
dlZd
dlmZ
d
dlmZmZ
d
dlmZ
d
dl	m
Z

d
dlmZ
d
dlm
Z
d
d	lmZ
d
d
lmZ
d
dlmZ
d
dlmZmZmZmZ
d
d
lmZmZmZmZ
dddgZe
j de
j!�Z"dd�Z#Gdd�de$�Z%Gdd�de&�Z'dZ(e�
rdd�Z)ne
Z)Gdd�de$�Z*dS)z�
    babel.messages.catalog
    ~~~~~~~~~~~~~~~~~~~~~~

    Data structures for message catalogs.

    :copyright: (c) 2013 by the Babel Team.
    :license: BSD, see LICENSE for more details.
�N)
�parse_header)�datetime�time)
�get_close_matches)
�message_from_string)
�copy)
�__version__)
�Locale)
�format_datetime)
�
get_plural)�odict�distinct�LOCALTZ�FixedOffsetTimezone)�string_types�number_types�PY2�cmp�Message�Catalog�TranslationErrorz�
    \%
        (?:\(([\w]*)\))?
        (
            [-#0\ +]?(?:\*|[\d]+)?
            (?:\.(?:\*|[\d]+))?
            [hlL]?
        )
        ([diouxXeEfFgGcrs%])
c
Cs�tj
d
|�}
tj|
jd�
d�}tj|�
}tj|�
}|
jd�
}|dk	r�|d|dd�}}|dd�|dd�}}	t|d�
}
t|�
}t|	�
}|d	}
|
|7}
|
|
9}
t	|
�
}|j
|d
�
}|S)Nz+^(?P<datetime>.*?)(?P<tzoffset>[+-]\d{4})?$rz%Y-%m-%d %H:%M�tzoffsetr
�
��
1�<)
�tzinfo)�re�matchrZstrptime�groupZmktimerZ
fromtimestamp�intr�replace)�valuerZttZtsZdtrZplus_minus_s�restZhours_offset_sZ
mins_offset_sZ
plus_minusZhours_offsetZmins_offsetZnet_mins_offset�r$�/usr/lib/python3.6/catalog.py�_parse_datetime_header+s"












r&c@s�eZ
dZd
Zdfffffddfdd�
Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
d dd�
Zedd��
Zedd��
Zedd��
ZdS)!rz0Representation of a single message in a catalog.�Nc

Cs�|
|_|r|j
rd}||_tt|�
�
|_t|�
|_|
rL|jrL|jj	d�

n|jj
d�

tt|�
�
|_tt|�
�
|_t
|t�r�|g
|_n
t|�
|_||_|	|_dS)a_Create the message object.

        :param id: the message ID, or a ``(singular, plural)`` tuple for
                   pluralizable messages
        :param string: the translated message string, or a
                       ``(singular, plural)`` tuple for pluralizable messages
        :param locations: a sequence of ``(filename, lineno)`` tuples
        :param flags: a set or sequence of flags
        :param auto_comments: a sequence of automatic comments for the message
        :param user_comments: a sequence of user comments for the message
        :param previous_id: the previous message ID, or a ``(singular, plural)``
                            tuple for pluralizable messages
        :param lineno: the line number on which the msgid line was found in the
                       PO file, if any
        :param context: the message context
        r'z
python-formatN)r'r')�id�pluralizable�string�listr
�	locations�set�flags�
python_format�add�discard�
auto_comments�
user_comments�
isinstancer�previous_id�lineno�context)
�selfr(r*r,r.r2r3r5r6r7r$r$r%�__init__Ns 

















zMessage.__init__c

Csd
t|�
j
|jt|j�
fS)Nz<%s %r (flags: %r)>)�type�__name__r(r+r.)
r8r$r$r%�__repr__ss

zMessage.__repr__cCsd
d�}t||�
||
�
�S)z0Compare Messages, taking into account plural idsc

Ss4t|t
�r$|jr$|jd
|jp dfS|j|jp0dfS)Nr
r')r4rr)r(r7)
�objr$r$r%�values_to_compareys


z*Message.__cmp__.<locals>.values_to_compare)
r)r8�otherr>r$r$r%�__cmp__wszMessage.__cmp__cCs|j|
�
d
kS)Nr
)
r@)r8r?r$r$r%�__gt__s
zMessage.__gt__cCs|j|
�
d
kS)Nr
)
r@)r8r?r$r$r%�__lt__�s
zMessage.__lt__cCs|j|
�
d
kS)Nr
)
r@)r8r?r$r$r%�__ge__�s
zMessage.__ge__cCs|j|
�
d
k
S)Nr
)
r@)r8r?r$r$r%�__le__�s
zMessage.__le__cCs|j|
�
d
kS)Nr
)
r@)r8r?r$r$r%�__eq__�s
zMessage.__eq__cCs|j|
�
d
kS)Nr
)
r@)r8r?r$r$r%�__ne__�s
zMessage.__ne__c

Cs2tt
t|j|j|j|j|j|j|j	|j
|jf	��S)
N)r�maprr(r*r,r.r2r3r5r6r7)
r8r$r$r%�clone�s



z
Message.clonecCs^d
dlm
}
g}xH|D]@}y||
|�
Wqtk
rT
}
z|j|�

WYdd}~XqXqW|S)a�
Run various validation checks on the message.  Some validations
        are only performed if the catalog is provided.  This method returns
        a sequence of `TranslationError` objects.

        :rtype: ``iterator``
        :param catalog: A catalog instance that is passed to the checkers
        :see: `Catalog.check` for a way to perform checks for all messages
              in a catalog.
        r
)
�checkersN)Zbabel.messages.checkersrIr�append)r8�catalogrI�errorsZchecker�
er$r$r%�check�s







 
z
Message.checkc

Cs
d
|jkS)a
Whether the translation is fuzzy.

        >>> Message('foo').fuzzy
        False
        >>> msg = Message('foo', 'foo', flags=['fuzzy'])
        >>> msg.fuzzy
        True
        >>> msg
        <Message 'foo' (flags: ['fuzzy'])>

        :type:  `bool`�fuzzy)
r.)
r8r$r$r%rO�s
z
Message.fuzzyc

Cst|j
ttf�S)
z�Whether the message is plurizable.

        >>> Message('foo').pluralizable
        False
        >>> Message(('foo', 'bar')).pluralizable
        True

        :type:  `bool`)r4r(r+�tuple)
r8r$r$r%r)�s
zMessage.pluralizablec
Cs,|j}
t
|
ttf�s|
g
}
td
d�|
D�
�
S)z�Whether the message contains Python-style parameters.

        >>> Message('foo %(name)s bar').python_format
        True
        >>> Message(('foo %(name)s', 'foo %(name)s')).python_format
        True

        :type:  `bool`c
ss|]}
tj
|
�
V
qdS)
N)�
PYTHON_FORMAT�search)�.0r(r$r$r%�	<genexpr>�sz(Message.python_format.<locals>.<genexpr>)r(r4r+rP�any)r8Zidsr$r$r%r/�s



zMessage.python_format)
N)r;�
__module__�__qualname__�__doc__r9r<r@rArBrCrDrErFrHrN�propertyrOr)r/r$r$r$r%rKs 

$
c
@seZ
dZd
ZdS)rz_Exception thrown by translation checkers when invalid message
    translations are encountered.N)r;rVrWrXr$r$r$r%r�sz�# Translations template for PROJECT.
# Copyright (C) YEAR ORGANIZATION
# This file is distributed under the same license as the PROJECT project.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#c
CsHt|j
d
�
�
}
i}x0|
j�D]$\}}|jd
�
}|jd
�
}|||<qW|S)N�utf8)r�encode�items�decode)Z
header_string�headersZdecoded_headers�namer"r$r$r%�
_parse_header�s







r`c
@s
eZ
dZd
Zddeddddddddddf
dd�
Zdd�Zdd	�Zeeed
d�Z	dd
�Z
dd�Zee
edd�Zedd��
Z
edd��
Zedd��
Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zdfffffddfd%d&�
Zd'd(�Zd2d)d*�
Zd3d+d,�
Zd4d.d/�
Zd5d0d1�
ZdS)6rz$Representation of a message catalog.NTcCs�||_|
rt
j|
�
}
|
|_||_t�|_|p.d
|_|p8d|_|pBd|_	|pLd|_
|
pVd|_|p`d|_|pjd|_
|dkr�tjt�
}nt|t�r�|jr�|jtd	�
}||_|	dkr�d
}	nt|	t�r�|	jr�|	jtd	�
}	|	|_|
|_t�|_d|_d|_dS)aDInitialize the catalog object.

        :param locale: the locale identifier or `Locale` object, or `None`
                       if the catalog is not bound to a locale (which basically
                       means it's a template)
        :param domain: the message domain
        :param header_comment: the header comment as string, or `None` for the
                               default header
        :param project: the project's name
        :param version: the project's version
        :param copyright_holder: the copyright holder of the catalog
        :param msgid_bugs_address: the email address or URL to submit bug
                                   reports to
        :param creation_date: the date the catalog was created
        :param revision_date: the date the catalog was revised
        :param last_translator: the name and email of the last translator
        :param language_team: the name and email of the language team
        :param charset: the encoding to use in the output (defaults to utf-8)
        :param fuzzy: the fuzzy bit on the catalog header
        �PROJECT�VERSION�ORGANIZATIONz
EMAIL@ADDRESSzFULL NAME <EMAIL@ADDRESS>zLANGUAGE <LL@li.org>zutf-8N)
rzYEAR-MO-DA HO:MI+ZONE)�domainr	�parse�locale�_header_commentr�	_messages�project�version�copyright_holder�msgid_bugs_address�last_translator�
language_team�charsetr�nowrr4rr!�
creation_date�
revision_daterO�obsolete�_num_plurals�_plural_expr)r8rfrd�header_commentrirjrkrlrqrrrmrnrorOr$r$r%r9�s6



























zCatalog.__init__c
Csv|j}
t
jt�
jd
�
}t|jd�r.|jjd
�
}|
jd|j�jd|j	�jd|�jd|j
�}
|jrr|
jdd|jj�}
|
S)	Nz%Y�strftimerarb�YEARrczTranslations templatez%s translations)
rgrrprrw�hasattrrrr!rirjrkrfZenglish_name)r8ZcommentZyearr$r$r%�_get_header_comment0
s













zCatalog._get_header_commentcCs
|
|_dS)
N)
rg)r8r*r$r$r%�_set_header_comment>
s
zCatalog._set_header_commenta�    The header comment for the catalog.

    >>> catalog = Catalog(project='Foobar', version='1.0',
    ...                   copyright_holder='Foo Company')
    >>> print(catalog.header_comment) #doctest: +ELLIPSIS
    # Translations template for Foobar.
    # Copyright (C) ... Foo Company
    # This file is distributed under the same license as the Foobar project.
    # FIRST AUTHOR <EMAIL@ADDRESS>, ....
    #

    The header can also be set from a string. Any known upper-case variables
    will be replaced when the header is retrieved again:

    >>> catalog = Catalog(project='Foobar', version='1.0',
    ...                   copyright_holder='Foo Company')
    >>> catalog.header_comment = '''\
    ... # The POT for my really cool PROJECT project.
    ... # Copyright (C) 1990-2003 ORGANIZATION
    ... # This file is distributed under the same license as the PROJECT
    ... # project.
    ... #'''
    >>> print(catalog.header_comment)
    # The POT for my really cool Foobar project.
    # Copyright (C) 1990-2003 Foo Company
    # This file is distributed under the same license as the Foobar
    # project.
    #

    :type: `unicode`
    )
�docc
CsT
g}
|
jd
d|j
|jff�

|
jd|jf�

|
jdt|jddd�f�

t|jtt	ft
�rx|
jdt|jddd�f�

n|
jd|jf�

|
jd	|jf�

|jdk	r�|
jd
t
|j�
f�

|jdk	r�d|jkr�|
jd|jjdt
|j�
�f�

n|
jd|jf�

|jdk	�
r|
jd
|jf�

|
jd�

|
jdd|jf�

|
jd�

|
jddtf�

|
S)NzProject-Id-Versionz%s %szReport-Msgid-Bugs-TozPOT-Creation-Datezyyyy-MM-dd HH:mmZZen)
rfzPO-Revision-DatezLast-TranslatorZLanguageZLANGUAGEz
Language-TeamzPlural-Forms�MIME-Version�1.0zContent-Typeztext/plain; charset=%s�Content-Transfer-Encoding�8bitzGenerated-Byz	Babel %s
)r}r~)rr�)rJrirjrlr
rqr4rrr�time_rrmrf�strrnr!�plural_formsrorb)r8r^r$r$r%�_get_mime_headersb
s8




























zCatalog._get_mime_headerscCs>
�
x6|
D�
],\}}|j�}|d
krL|j
d�
}dj|dd��
|_|d|_q|dkr\||_q|dkrl||_q|dkr�|jdd�}tj	|�
|_
q|d	kr�||_q|d
kr�t|�
\}}d|kr�|dj�|_
q|dk�
rtd
|�
\}}t|jdd��
|_|jdd�|_q|dk�
rt|�
|_q|dkrd|krt|�
|_qWdS)Nzproject-id-version�
 rzreport-msgid-bugs-tozlast-translatorZlanguage�
-�
_z
language-teamzcontent-typerozplural-formsz ;ZnpluralsrZpluralz(n != 1)zpot-creation-datezpo-revision-daterx���r�)�lower�split�joinrirjrlrmr!r	rerfrnrror �getrtrur&rqrr)r8r^r_r"�partsZmimetypeZparamsr�r$r$r%�_set_mime_headers�
s8





























zCatalog._set_mime_headersa�    The MIME headers of the catalog, used for the special ``msgid ""`` entry.

    The behavior of this property changes slightly depending on whether a locale
    is set or not, the latter indicating that the catalog is actually a template
    for actual translations.

    Here's an example of the output for such a catalog template:

    >>> from babel.dates import UTC
    >>> created = datetime(1990, 4, 1, 15, 30, tzinfo=UTC)
    >>> catalog = Catalog(project='Foobar', version='1.0',
    ...                   creation_date=created)
    >>> for name, value in catalog.mime_headers:
    ...     print('%s: %s' % (name, value))
    Project-Id-Version: Foobar 1.0
    Report-Msgid-Bugs-To: EMAIL@ADDRESS
    POT-Creation-Date: 1990-04-01 15:30+0000
    PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE
    Last-Translator: FULL NAME <EMAIL@ADDRESS>
    Language-Team: LANGUAGE <LL@li.org>
    MIME-Version: 1.0
    Content-Type: text/plain; charset=utf-8
    Content-Transfer-Encoding: 8bit
    Generated-By: Babel ...

    And here's an example of the output when the locale is set:

    >>> revised = datetime(1990, 8, 3, 12, 0, tzinfo=UTC)
    >>> catalog = Catalog(locale='de_DE', project='Foobar', version='1.0',
    ...                   creation_date=created, revision_date=revised,
    ...                   last_translator='John Doe <jd@example.com>',
    ...                   language_team='de_DE <de@example.com>')
    >>> for name, value in catalog.mime_headers:
    ...     print('%s: %s' % (name, value))
    Project-Id-Version: Foobar 1.0
    Report-Msgid-Bugs-To: EMAIL@ADDRESS
    POT-Creation-Date: 1990-04-01 15:30+0000
    PO-Revision-Date: 1990-08-03 12:00+0000
    Last-Translator: John Doe <jd@example.com>
    Language: de_DE
    Language-Team: de_DE <de@example.com>
    Plural-Forms: nplurals=2; plural=(n != 1)
    MIME-Version: 1.0
    Content-Type: text/plain; charset=utf-8
    Content-Transfer-Encoding: 8bit
    Generated-By: Babel ...

    :type: `list`
    c
Cs.|jd
kr(d}
|j
r"t|j
�
d}
|
|_|jS)z�The number of plurals used by the catalog or locale.

        >>> Catalog(locale='en').num_plurals
        2
        >>> Catalog(locale='ga').num_plurals
        5

        :type: `int`Nrr
)rtrfr)r8Znumr$r$r%�num_plurals�
s






zCatalog.num_pluralsc
Cs.|jd
kr(d}
|j
r"t|j
�
d}
|
|_|jS)a
The plural expression used by the catalog or locale.

        >>> Catalog(locale='en').plural_expr
        '(n != 1)'
        >>> Catalog(locale='ga').plural_expr
        '(n==1 ? 0 : n==2 ? 1 : n>=3 && n<=6 ? 2 : n>=7 && n<=10 ? 3 : 4)'

        :type: `string_types`Nz(n != 1)r)rurfr)r8�exprr$r$r%�plural_expr�
s






zCatalog.plural_exprc

Csd
|j|j
fS)z�Return the plural forms declaration for the locale.

        >>> Catalog(locale='en').plural_forms
        'nplurals=2; plural=(n != 1)'
        >>> Catalog(locale='pt_BR').plural_forms
        'nplurals=2; plural=(n > 1)'

        :type: `str`znplurals=%s; plural=%s)r�r�)
r8r$r$r%r��
s
zCatalog.plural_formscCs|j|
�
|j
kS)
z?Return whether the catalog has a message with the specified ID.)�_key_forrh)r8r(r$r$r%�__contains__szCatalog.__contains__c

Cs
t|j
�
S)
zeThe number of messages in the catalog.

        This does not include the special ``msgid ""`` entry.)�lenrh)
r8r$r$r%�__len__szCatalog.__len__c
cszg}
x$|jD]\}}|
j
d
||f�

qWt�}|jrD|tdg
�
O}tddj|
�
|d�V
x|jD]}|j|V
qbWdS)z�Iterates through all the entries in the catalog, in the order they
        were added, yielding a `Message` object for every entry.

        :rtype: ``iterator``z%s: %srOr'�

)
r.N)�mime_headersrJr-rOrr�rh)r8Zbufr_r"r.�keyr$r$r%�__iter__s







zCatalog.__iter__c
Cs*d
}
|jrd|j}
dt
|�
j|j|
fS)Nr'z %sz	<%s %r%s>)rfr:r;rd)r8rfr$r$r%r<s




zCatalog.__repr__cCs|j|
�

d
S)z)Delete the message with the specified ID.N)
�delete)r8r(r$r$r%�__delitem__!szCatalog.__delitem__cCs
|j|
�
S)
zUReturn the message with the specified ID.

        :param id: the message ID
        )
r�)r8r(r$r$r%�__getitem__%szCatalog.__getitem__cCs"
t|t
�std
�
�
|j|
|j�}|jj|�
}|r�|jrN|jrN|j|_|j	|_	t
t|j|j�
�
|_t
t|j
|j
�
�
|_
t
t|j|j�
�
|_|j|jO_|}nx|
dkr�t|j	�
j�|_djdd�|jD�
�
|_|j|_n>t|
t
tf��
rt|j	t
tf��
stdt|j	�
�
�
||j|<dS)a�Add or update the message with the specified ID.

        >>> catalog = Catalog()
        >>> catalog[u'foo'] = Message(u'foo')
        >>> catalog[u'foo']
        <Message u'foo' (flags: [])>

        If a message with that ID is already in the catalog, it is updated
        to include the locations and flags of the new message.

        >>> catalog = Catalog()
        >>> catalog[u'foo'] = Message(u'foo', locations=[('main.py', 1)])
        >>> catalog[u'foo'].locations
        [('main.py', 1)]
        >>> catalog[u'foo'] = Message(u'foo', locations=[('utils.py', 5)])
        >>> catalog[u'foo'].locations
        [('main.py', 1), ('utils.py', 5)]

        :param id: the message ID
        :param message: the `Message` object
        zexpected a Message objectr'r�c
Ssg|]}
d|
j��qS)
z# %s)
�rstrip)rS�
cr$r$r%�
<listcomp>Usz'Catalog.__setitem__.<locals>.<listcomp>zExpected sequence but got %sN)r4r�AssertionErrorr�r7rhr�r)r(r*r+r
r,r2r3r.r`r\r�r�rvrOrPr:)r8r(�messager�Zcurrentr$r$r%�__setitem__,s0





















zCatalog.__setitem__c
Cs*t|
|t
|�
||||||	d
�	}
|
||
<|
S)atAdd or update the message with the specified ID.

        >>> catalog = Catalog()
        >>> catalog.add(u'foo')
        <Message ...>
        >>> catalog[u'foo']
        <Message u'foo' (flags: [])>

        This method simply constructs a `Message` object with the given
        arguments and invokes `__setitem__` with that object.

        :param id: the message ID, or a ``(singular, plural)`` tuple for
                   pluralizable messages
        :param string: the translated message string, or a
                       ``(singular, plural)`` tuple for pluralizable messages
        :param locations: a sequence of ``(filename, lineno)`` tuples
        :param flags: a set or sequence of flags
        :param auto_comments: a sequence of automatic comments
        :param user_comments: a sequence of user comments
        :param previous_id: the previous message ID, or a ``(singular, plural)``
                            tuple for pluralizable messages
        :param lineno: the line number on which the msgid line was found in the
                       PO file, if any
        :param context: the message context
        )r6r7)rr+)r8r(r*r,r.r2r3r5r6r7r�r$r$r%r0^s




zCatalog.addc
cs2x,|jj
�D]}
|
j|d
�
}|r|
|fV
qWdS)aB
Run various validation checks on the translations in the catalog.

        For every message which fails validation, this method yield a
        ``(message, errors)`` tuple, where ``message`` is the `Message` object
        and ``errors`` is a sequence of `TranslationError` objects.

        :rtype: ``iterator``
        )
rKN)rh�valuesrN)r8r�rLr$r$r%rNs	


z
Catalog.checkcCs|jj
|j|
|��
S)
z�Return the message with the specified ID and context.

        :param id: the message ID
        :param context: the message context, or ``None`` for no context
        )rhr�r�)r8r(r7r$r$r%r��szCatalog.getcCs"|j|
|�}||j
kr|j
|=d
S)z�Delete the message with the specified ID and context.

        :param id: the message ID
        :param context: the message context, or ``None`` for no context
        N)r�rh)r8r(r7r�r$r$r%r��s


zCatalog.deleteFc
sD
�j�
�
j
��t��_g}|s6t�
�fd
d��
D�
�
}t����
��fdd�}x�|
D]�}|jrT�j|j|j�}|�
kr�||||�
qT|dkr�t|t	�r�|d}n|}t
|j�j�|j
�d�}	|	r�|	d}
||
}|dk	r�|
|f}
|||
|�
qT|�|j<qTWx,�D]$}|�
s|�k�
r�|�j|<�
qW|�
r8|
j�_|
j�_dS)	a�Update the catalog based on the given template catalog.

        >>> from babel.messages import Catalog
        >>> template = Catalog()
        >>> template.add('green', locations=[('main.py', 99)])
        <Message ...>
        >>> template.add('blue', locations=[('main.py', 100)])
        <Message ...>
        >>> template.add(('salad', 'salads'), locations=[('util.py', 42)])
        <Message ...>
        >>> catalog = Catalog(locale='de_DE')
        >>> catalog.add('blue', u'blau', locations=[('main.py', 98)])
        <Message ...>
        >>> catalog.add('head', u'Kopf', locations=[('util.py', 33)])
        <Message ...>
        >>> catalog.add(('salad', 'salads'), (u'Salat', u'Salate'),
        ...             locations=[('util.py', 38)])
        <Message ...>

        >>> catalog.update(template)
        >>> len(catalog)
        3

        >>> msg1 = catalog['green']
        >>> msg1.string
        >>> msg1.locations
        [('main.py', 99)]

        >>> msg2 = catalog['blue']
        >>> msg2.string
        u'blau'
        >>> msg2.locations
        [('main.py', 100)]

        >>> msg3 = catalog['salad']
        >>> msg3.string
        (u'Salat', u'Salate')
        >>> msg3.locations
        [('util.py', 42)]

        Messages that are in the catalog but not in the template are removed
        from the main collection, but can still be accessed via the `obsolete`
        member:

        >>> 'head' in catalog
        False
        >>> list(catalog.obsolete.values())
        [<Message 'head' (flags: [])>]

        :param template: the reference catalog, usually read from a POT file
        :param no_fuzzy_matching: whether to use fuzzy matching of message IDs
        c
s.g|]&}
|
r�|
jr�
j
|
�
�|
jf�qSr$)r*r�r7)rS�msgid)�messagesr8r$r%r��s
z"Catalog.update.<locals>.<listcomp>cs8
|j�}d
}|
|krRd}�j
|
�

�
j|
�
}t|jt�rD|jg
|_q^t|j�
|_n�j|
d�}|j	|_	t|jtt
f�r�t|j	tt
f�s�d}t
|j	g
dg
t|j�
d�
|_	n.t|j	�
�jkr�d}t
|j	dt|j	�
��
|_	n"t|j	tt
f��
rd}|j	d|_	|j
|j
O_
|�
r*|j
tdg
�
O_
|�|j<dS)NFTr'rr
rO)rHr0r�r4r(rr5r+�popr*rPr�r�r.r-)r�Zoldkey�newkeyrOZoldmsg)�
fuzzy_matchesr��	remainingr8r$r%�_merge�s4















"








zCatalog.update.<locals>._mergeFr
rN)rhrr�dictr-r(r�r7r4rPrr��strip�keysrsrvrq)
r8�templateZno_fuzzy_matchingZupdate_header_commentZfuzzy_candidatesr�r�r�ZmatchkeyZmatchesr�Znewctxtr�r$)r�r�r�r8r%�update�sF5


























zCatalog.updatecCs.|
}t|t
tf�r|
d
}|dk	r*||f}|S)z�The key for a message is just the singular ID even for pluralizable
        messages, but is a ``(msgid, msgctxt)`` tuple for context-specific
        messages.
        r
N)r4r+rP)r8r(r7r�r$r$r%r�%s




zCatalog._key_for)
N)
N)FF)
N)r;rVrWrX�DEFAULT_HEADERr9rzr{rYrvr�r�r�r�r�r�r�r�r�r<r�r�r�r0rNr�r�r�r�r$r$r$r%r�s@




8 12
 



)+rXrrZcgirrr�ZdifflibrZemailrrZbabelrrbZ
babel.corer	Zbabel.datesr
Zbabel.messages.pluralsrZ
babel.utilrr
rrZ
babel._compatrrrr�__all__�compile�VERBOSErQr&�objectr�	Exceptionrr�r`rr$r$r$r%�<module>
s2