B

�`#~�@s4
dZd
dl
Z
d
dlZd
dlmZ
d
dlmZ
d
dlmZmZ
d
dl	m
Z

d
dlmZ
d
dl
m
Z

d
d	lmZ
d
d
lmZmZ
d
dlmZ
d
dlmZ
d
d
lmZmZmZ
d
dlmZmZmZm Z m!Z!m"Z"
dddgZ#e
�$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-2021 by the Babel Team.
    :license: BSD, see LICENSE for more details.
�N)
�parse_header)
�OrderedDict)�datetime�time)
�get_close_matches)
�message_from_string)
�copy)
�__version__)�Locale�UnknownLocaleError)
�format_datetime)
�
get_plural)�distinct�LOCALTZ�FixedOffsetTimezone)�string_types�number_types�PY2�cmp�	text_type�
force_text�Message�Catalog�TranslationErrorz�
    \%
        (?:\(([\w]*)\))?
        (
            [-#0\ +]?(?:\*|[\d]+)?
            (?:\.(?:\*|[\d]+))?
            [hlL]?
        )
        ([diouxXeEfFgGcrs%])
c
Cs�t�
d
|�}
t�|
�d�
d�}t�|�
}t�|�
}|
�d�
}|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)�valuer!ZttZtsZdtrZplus_minus_s�restZhours_offset_sZ
mins_offset_sZ
plus_minusZhours_offsetZmins_offsetZnet_mins_offset�r'�G/opt/alt/python37/lib/python3.7/site-packages/babel/messages/catalog.py�_parse_datetime_header,s"












r)c@s�eZ
dZd
Zd!dd�
Zdd�Zd	d
�Zdd�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.�r'Nc

Cs�|
|_|s|j
rd
}||_tt|�
�
|_t|�
|_|
rJ|jrJ|j�	d�

n|j�
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*r*z
python-formatN)�id�pluralizable�string�listr�	locations�set�flags�
python_format�add�discard�
auto_comments�
user_comments�
isinstancer�previous_id�lineno�context)
�selfr+r-r/r1r5r6r8r9r:r'r'r(�__init__Os 


















zMessage.__init__c

Csd
t|�
j
|jt|j�
fS)Nz<%s %r (flags: %r)>)�type�__name__r+r.r1)
r;r'r'r(�__repr__ts

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

Ss4t|t
�r$|jr$|jd
|jp dfS|j|jp0dfS)Nr
r*)r7rr,r+r:)
�objr'r'r(�values_to_comparezs


z*Message.__cmp__.<locals>.values_to_compare)
r)r;�otherrAr'r'r(�__cmp__xszMessage.__cmp__cCs|�|
�
d
kS)Nr
)
rC)r;rBr'r'r(�__gt__�s
zMessage.__gt__cCs|�|
�
d
kS)Nr
)
rC)r;rBr'r'r(�__lt__�s
zMessage.__lt__cCs|�|
�
d
kS)Nr
)
rC)r;rBr'r'r(�__ge__�s
zMessage.__ge__cCs|�|
�
d
k
S)Nr
)
rC)r;rBr'r'r(�__le__�s
zMessage.__le__cCs|�|
�
d
kS)Nr
)
rC)r;rBr'r'r(�__eq__�s
zMessage.__eq__cCs|�|
�
d
kS)Nr
)
rC)r;rBr'r'r(�__ne__�s
zMessage.__ne__c

Cs2tt
t|j|j|j|j|j|j|j	|j
|jf	��S)
N)r�maprr+r-r/r1r5r6r8r9r:)
r;r'r'r(�clone�s



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

Wdd}~XYqXqW|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.checkersrLr�append)r;�catalogrL�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)
r1)
r;r'r'r(rR�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`)r7r+r.�tuple)
r;r'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|]}
t�
|
�
V
qdS)
N)�
PYTHON_FORMAT�search)�.0r+r'r'r(�	<genexpr>�sz(Message.python_format.<locals>.<genexpr>)r+r7r.rS�any)r;Zidsr'r'r(r2�s



zMessage.python_format)r*r'r'r'r'r'NN)
N)r>�
__module__�__qualname__�__doc__r<r?rCrDrErFrGrHrIrKrQ�propertyrRr,r2r'r'r'r(rLs 


$
c
@seZ
dZd
ZdS)rz_Exception thrown by translation checkers when invalid message
    translations are encountered.N)r>rYrZr[r'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|�
d
�
�
}
i}x0|
��D]$\}}|�d
�
}|�d
�
}|||<qW|S)N�utf8)r�encode�items�decode)Z
header_string�headersZdecoded_headers�namer%r'r'r(�
_parse_header�s







rcc
@s0
eZ
dZd
Zddeddddddddddf
dd�
Zdd�Zdd	�Zd
d�Ze	ee�Z
e	e�
Zdd
�Zdd�Z
e	ee
dd�Zdd�Zdd�Ze	eedd�Ze	dd��
Ze	dd��
Ze	dd��
Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd9d,d-�
Zd.d/�Zd:d0d1�
Zd;d2d3�
Zd<d5d6�
Z d=d7d8�
Z!dS)>rz$Representation of a message catalog.NTcCs�||_|
|_
||_t�|_|p d
|_|p*d|_|p4d|_|p>d|_|
pHd|_	|pRd|_
|p\d|_|dkrtt�
t�
}nt|t�r�|js�|jtd	�
}||_|	dkr�d
}	nt|	t�r�|	js�|	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)�domain�locale�_header_commentr�	_messages�project�version�copyright_holder�msgid_bugs_address�last_translator�
language_team�charsetr�nowrr7rr$�
creation_date�
revision_daterR�obsolete�_num_plurals�_plural_expr)r;rhrg�header_commentrkrlrmrnrsrtrorprqrRr'r'r(r<�s2
























zCatalog.__init__cCs�|
dkrd|_d|_
dSt|
t�r6t|
�
|_|
|_
dSt|
t�rzt|
�
|_yt�|
�
|_
Wntk
rt


d|_
YnXdStd
|
�
�
dS)NzF`locale` must be a Locale, a locale identifier string, or None; got %r)	�_locale_identifier�_localer7r
rr�parser�	TypeError)r;rhr'r'r(�_set_locale/
s 
















zCatalog._set_localec


Cs|jS)
N)
rz)
r;r'r'r(�_get_localeD
s
zCatalog._get_localec


Cs|jS)
N)
ry)
r;r'r'r(�_get_locale_identifierG
s
zCatalog._get_locale_identifierc
Cs�|j}
t
�t�
�d
�
}t|jd�r.|j�d
�
}|
�d|j��d|j	��d|��d|j
�}
|jrf|jjn|j
}|r�|
�dd|�}
|
S)	Nz%Y�strftimerdre�YEARrfzTranslations templatez%s translations)rirrrrr��hasattrrtr$rkrlrmrhZenglish_name�locale_identifier)r;�commentZyearZlocale_namer'r'r(�_get_header_commentM
s













zCatalog._get_header_commentcCs
|
|_dS)
N)
ri)r;r-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
CsL
g}
|
�d
d|j
|jff�

|
�d|jf�

|
�dt|jddd�f�

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

n|
�d|jf�

|
�d	|jf�

|jr�|
�d
t
|j�
f�

|jr�d|jkr�|
�d|j�dt
|j�
�f�

n|
�d|jf�

|jdk	�
r|
�d
|jf�

|
�d�

|
�dd|jf�

|
�d�

|
�ddtf�

|
S)NzProject-Id-Versionz%s %szReport-Msgid-Bugs-TozPOT-Creation-Datezyyyy-MM-dd HH:mmZZen)
rhzPO-Revision-DatezLast-TranslatorZLanguageZLANGUAGEz
Language-TeamzPlural-Forms)zMIME-Versionz1.0zContent-Typeztext/plain; charset=%s)zContent-Transfer-EncodingZ8bitzGenerated-Byz	Babel %s
)rMrkrlrnrrsr7rtr�time_rror��strrpr$rh�plural_formsrqre)r;rar'r'r(�_get_mime_headers
s8



























zCatalog._get_mime_headerscCsT
�
xL|
D�
]B\}}t|�
�|jd
�}t||jd
�}|dkrd|�d�
}d�|dd��
|_|d|_q|dkrt||_q|dkr�||_q|dkr�|�	dd	�}|�
|�

q|d
kr�||_q|dkr�t|�
\}}d|kr�|d�
�|_q|d
k�
rtd|�
\}}t
|�dd��
|_|�dd�|_q|dk�
r2t|�
|_q|dkrd|krt|�
|_qWdS)N)
�encodingzproject-id-version�
 ���zreport-msgid-bugs-tozlast-translatorZlanguage�
-�
_z
language-teamzcontent-typerqzplural-formsz ;ZnpluralsrZpluralz(n != 1)zpot-creation-datezpo-revision-dater�)r�lowerrq�split�joinrkrlrnror$r}rprr#�getrvrwr)rsrt)r;rarbr%�partsZmimetypeZparamsr�r'r'r(�_set_mime_headers�
s:






























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
)rvrhr
)r;Znumr'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)'
        >>> Catalog(locale='ding').plural_expr  # unknown locale
        '(n != 1)'

        :type: `string_types`Nz(n != 1)r)rwrhr
)r;�exprr'r'r(�plural_exprs





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�)
r;r'r'r(r�s
zCatalog.plural_formscCs|�|
�
|j
kS)
z?Return whether the catalog has a message with the specified ID.)�_key_forrj)r;r+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.)�lenrj)
r;r'r'r(�__len__&szCatalog.__len__c
csvg}
x$|jD]\}}|
�
d
||f�

qWt�}|jr@|dh
O}tdd�|
�
|d�V
x|jD]}|j|V
q^WdS)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: %srRr*�

)
r1N)�mime_headersrMr0rRrr�rj)r;Zbufrbr%r1�keyr'r'r(�__iter__,s








zCatalog.__iter__c
Cs*d
}
|jrd|j}
dt
|�
j|j|
fS)Nr*z %sz	<%s %r%s>)rhr=r>rg)r;rhr'r'r(r?;s




zCatalog.__repr__cCs|�|
�

d
S)z)Delete the message with the specified ID.N)
�delete)r;r+r'r'r(�__delitem__AszCatalog.__delitem__cCs
|�|
�
S)
zUReturn the message with the specified ID.

        :param id: the message ID
        )
r�)r;r+r'r'r(�__getitem__EszCatalog.__getitem__cCs 
t|t
�std
�
�
|�|
|j�}|j�|�
}|r�|jrL|jsL|j|_|j	|_	t
t|j|j�
�
|_t
t|j
|j
�
�
|_
t
t|j|j�
�
|_|j|jO_|}nx|
dkr�t|j	�
��|_d�dd�|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|
���qS)
z# %s)
�rstrip)rV�
cr'r'r(�
<listcomp>usz'Catalog.__setitem__.<locals>.<listcomp>zExpected sequence but got %sN)r7r�AssertionErrorr�r:rjr�r,r+r-r.rr/r5r6r1rcr_r�r�rxrRrSr=)r;r+�messager�Zcurrentr'r'r(�__setitem__Ls0





















zCatalog.__setitem__r'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
        )r9r:)rr.)r;r+r-r/r1r5r6r8r9r:r�r'r'r(r3~s




zCatalog.addc
cs2x,|j�
�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``
        )
rNN)rj�valuesrQ)r;r�rOr'r'r(rQ�s	


z
Catalog.checkcCs|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
        )rjr�r�)r;r+r:r'r'r(r��szCatalog.getcCs"|�|
|�}||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�rj)r;r+r:r�r'r'r(r��s


zCatalog.deleteFcsB
�j���
��t��_g}|s6t��fd
d��D�
�
}t����
���fdd�}x�|
D]�}|jrV��|j|j�}|�kr�||||�
qV|s�t|t	�r�|d}	n|}	t
|	����|�
�d�}
|
r�|
d}||}|dk	r�||f}||||�
qV|�|j<qVWx,�D]$}
|�
s|
�k�
r�|
�j|
<�
qW|�
r6|
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�
�
|
�
�|
jf�qSr')r-r�r:)rV�msgid)�messagesr;r'r(r��s
z"Catalog.update.<locals>.<listcomp>csH
|��}d
}|
|krRd}��
|
�

��|
�
}t|jt�rD|jg
|_q^t|j�
|_n��|
d�}|j	|_	�
rztt
|j�
�
|_t|jttf�r�t|j	ttf�s�d}t|j	g
dg
t
|j�
d�
|_	n.t
|j	�
�jkr�d}t|j	dt
|j	�
��
|_	n"t|j	ttf��
rd}|j	d|_	|j|jO_|�
r:|jdh
O_|�|j<dS)NFTr*rr
rR)rKr3r�r7r+rr8r.�popr-rr6rSr�r�r1)r�Zoldkey�newkeyrRZoldmsg)�
fuzzy_matches�keep_user_commentsr��	remainingr;r'r(�_merge
s8















"








zCatalog.update.<locals>._merger
rN)rjrr�dictr0r+r�r:r7rSrr��strip�keysrurxrs)r;�templateZno_fuzzy_matchingZupdate_header_commentr�Zfuzzy_candidatesr�r�r�ZmatchkeyZmatchesr�Znewctxtr�r')r�r�r�r�r;r(�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)r7r.rS)r;r+r:r�r'r'r(r�Is




zCatalog._key_for)Nr'r'r'r'r'NN)
N)
N)FFT)
N)"r>rYrZr[�DEFAULT_HEADERr<r}r~rr\rhr�r�r�rxr�r�r�r�r�r�r�r�r�r?r�r�r�r3rQr�r�r�r�r'r'r'r(r�sJ




6

  12

 



)/r[r rZcgir�collectionsrrr�ZdifflibrZemailrrZbabelr	reZ
babel.corer
rZbabel.datesrZbabel.messages.pluralsr
Z
babel.utilrrrZ
babel._compatrrrrrr�__all__�compile�VERBOSErTr)�objectr�	Exceptionrr�rcrr'r'r'r(�<module>
s4