HEX

File: //usr/lib/python3.9/site-packages/babel/messages/__pycache__/pofile.cpython-39.pyc
a

�`�V�@s�dZddlmZddlZddlZddlmZmZddlm	Z	ddl
mZmZdd�Z
d	d
�ZGdd�de�ZGd
d�de�ZGdd�de�Zd dd�Ze�d�Zdd�Zd!dd�Zd"dd�Zdd�ZdS)#z�
    babel.messages.pofile
    ~~~~~~~~~~~~~~~~~~~~~

    Reading and writing of files in the ``gettext`` PO (portable object)
    format.

    :copyright: (c) 2013-2021 by the Babel Team.
    :license: BSD, see LICENSE for more details.
�)�print_functionN)�Catalog�Message)�wraptext)�	text_type�cmpcCs"dd�}t�d��||dd��S)z�Reverse `escape` the given string.

    >>> print(unescape('"Say:\\n  \\"hello, world!\\"\\n"'))
    Say:
      "hello, world!"
    <BLANKLINE>

    :param string: the string to unescape
    cSs2|�d�}|dkrdS|dkr"dS|dkr.dS|S)N��n�
�t�	�r�
)�group)�match�m�r�9/usr/lib/python3.9/site-packages/babel/messages/pofile.py�replace_escapes s
z!unescape.<locals>.replace_escapesz\\([\\trn"])r���)�re�compile�sub)�stringrrrr�unescapes

rcCsFd|vr:|��}|�d�r&|dd�}tt|�}d�|�St|�SdS)a�Reverse the normalization done by the `normalize` function.

    >>> print(denormalize(r'''""
    ... "Say:\n"
    ... "  \"hello, world!\"\n"'''))
    Say:
      "hello, world!"
    <BLANKLINE>

    >>> print(denormalize(r'''""
    ... "Say:\n"
    ... "  \"Lorem ipsum dolor sit "
    ... "amet, consectetur adipisicing"
    ... " elit, \"\n"'''))
    Say:
      "Lorem ipsum dolor sit amet, consectetur adipisicing elit, "
    <BLANKLINE>

    :param string: the string to denormalize
    r
�""rN�)�
splitlines�
startswith�mapr�join)rZ
escaped_lines�linesrrr�denormalize-s


r"cs eZdZdZ�fdd�Z�ZS)�PoFileErrorzDException thrown by PoParser when an invalid po file is encountered.cs0tt|��dj||d��||_||_||_dS)Nz{message} on {lineno})�message�lineno)�superr#�__init__�format�catalog�liner%)�selfr$r)r*r%��	__class__rrr'NszPoFileError.__init__)�__name__�
__module__�__qualname__�__doc__r'�
__classcell__rrr,rr#Lsr#c@speZdZdd�Zdd�Zdd�Zdd�ZeZd	d
�Zdd�Z	d
d�Z
dd�Zdd�Zdd�Z
dd�Zdd�ZdS)�_NormalizedStringcGsg|_|D]}|�|�q
dS�N)�_strs�append)r+�args�argrrrr'Wsz_NormalizedString.__init__cCs|j�|���dSr4)r5r6�strip)r+�srrrr6\sz_NormalizedString.appendcCsd�tt|j��S)Nr)r rrr5�r+rrrr"_sz_NormalizedString.denormalizecCs
t|j�Sr4)�boolr5r;rrr�__nonzero__bsz_NormalizedString.__nonzero__cCstj�|j�Sr4)�os�linesepr r5r;rrr�__repr__gsz_NormalizedString.__repr__cCs|sdStt|�t|��S)Nr)rr�r+�otherrrr�__cmp__jsz_NormalizedString.__cmp__cCs|�|�dkS�Nr�rCrArrr�__gt__psz_NormalizedString.__gt__cCs|�|�dkSrDrErArrr�__lt__ssz_NormalizedString.__lt__cCs|�|�dkSrDrErArrr�__ge__vsz_NormalizedString.__ge__cCs|�|�dkSrDrErArrr�__le__ysz_NormalizedString.__le__cCs|�|�dkSrDrErArrr�__eq__|sz_NormalizedString.__eq__cCs|�|�dkSrDrErArrr�__ne__sz_NormalizedString.__ne__N)r.r/r0r'r6r"r=�__bool__r@rCrFrGrHrIrJrKrrrrr3Usr3c@sneZdZdZgd�Zddd�Zdd�Zdd	�Zd
d�Zddd
�Z	ddd�Z
dd�Zdd�Zdd�Z
dd�ZdS)�PoFileParserz�Support class to  read messages from a ``gettext`` PO (portable object) file
    and add them to a `Catalog`

    See `read_po` for simple cases.
    )�msgid�msgstr�msgctxt�msgid_pluralFcCs*||_||_d|_d|_||_|��dSrD)r)�ignore_obsolete�counter�offset�
abort_invalid�_reset_message_state)r+r)rRrUrrrr'�szPoFileParser.__init__cCsFg|_g|_g|_g|_g|_g|_d|_d|_d|_d|_	d|_
dS)NF)�messages�translations�	locations�flags�
user_comments�
auto_comments�context�obsolete�in_msgid�	in_msgstr�
in_msgctxtr;rrrrV�sz!PoFileParser._reset_message_statec
Cs<|j��t|j�dkr.tdd�|jD��}n|jd��}t|ttf�r�dd�t|j	j
�D�}|jD]2\}}||j	j
kr�|�d|jd�qf|��||<qft|�}n|jdd��}|j
r�|j
��}nd}t||t|j�t|j�|j|j|jd|d	�}|j�r|j�s"||j	j|<n
||j	|<|jd7_|��dS)
z�
        Add a message to the catalog based on the current parser state and
        clear the state ready to process the next message.
        rcSsg|]}|���qSr)r")�.0rrrr�
<listcomp>��z-PoFileParser._add_message.<locals>.<listcomp>rcSsg|]}d�qS)rr)rb�_rrrrc�rdrz5msg has more translations than num_plurals of catalogN)r%r])rX�sort�lenrW�tupler"�
isinstance�list�ranger)�num_plurals�_invalid_pofilerTr]rrY�setrZr\r[r^rRrSrV)r+rNr�idx�translationrPr$rrr�_add_message�s4

�
zPoFileParser._add_messagecCs|jr|��dSr4)rWrqr;rrr�_finish_current_message�sz$PoFileParser._finish_current_messagecCs*|�d�r|�||�n|�|||�dS)N�")r�!_process_string_continuation_line�_process_keyword_line)r+r%r*r^rrr�_process_message_line�s
z"PoFileParser._process_message_linec	CsF|jD]Z}z4|�|�r<|t|�dvr<|t|�d�}WqtWqty^|�||d�Yq0q|�||d�dS|dvr�|��||_|dkr�||_|dvr�d|_d|_	|j
�t|��n�|d	k�r(d|_	d|_
|�d
��r|dd��dd�\}}|j�t|�t|�g�n|j�d
t|�g�n|dk�rBd|_t|�|_dS)N)� �[z$Keyword must be followed by a stringz0Start of line didn't match any expected keyword.)rNrPrN)rNrQFTrOrxr�]rrP)�	_keywordsrrg�
IndexErrorrmrrr^rTrar_rWr6r3r`�splitrX�intr])r+r%r*r^�keywordr8ro�msgrrrru�s8



z"PoFileParser._process_keyword_linecCsV|jr|jd}n6|jr(|jdd}n |jr6|j}n|�||d�dS|�|�dS)Nrrz<Got line starting with " but not in msgid, msgstr or msgctxt)r_rWr`rXrar]rmr6)r+r*r%r:rrrrt�sz.PoFileParser._process_string_continuation_linec	Cs6|��|dd��d�r�|dd�����D]p}|�d�}|dkr�zt||dd��}WntyrYq.Yn0|j�|d|�|f�q.|j�|df�q.n�|dd��d�r�|dd����d�D]}|j	�|�
��q�nP|dd��d��r|dd��
�}|�r2|j�|�n|j�|dd��
��dS)Nr�:�r�,�.)
rrr�lstripr|�rfindr}�
ValueErrorrYr6rZr9r\r[)r+r*�location�posr%�flag�commentrrr�_process_comment	s&

zPoFileParser._process_commentcCs�t|�D]�\}}|��}t|t�s0|�|jj�}|s6q|�d�r||dd��d�rp|j||dd��	�dd�q�|�
|�q|�||�q|��|js�|j
s�|js�|jr�|j�td��|j�d	td�g�|��dS)
z�
        Reads from the file-like object `fileobj` and adds any po file
        units found in it to the `Catalog` supplied to the constructor.
        �#rN�~r�T)r^rr)�	enumerater9rir�decoder)�charsetrrvr�r�rrrSrZr[r\rWr6r3rXrq)r+�fileobjr%r*rrr�parse$s 

zPoFileParser.parsecCsJt|t�sJ�|jr$t||j||��td|�td�|dt|���dS)NzWARNING:z!WARNING: Problem on line {0}: {1}r)rirrUr#r)�printr(�repr)r+r*r%rrrrrmAs

zPoFileParser._invalid_pofileN)FF)F)F)r.r/r0r1rzr'rVrqrrrvrurtr�r�rmrrrrrM�s

#

)rMFcCs*t|||d�}t|||d�}|�|�|S)a�Read messages from a ``gettext`` PO (portable object) file from the given
    file-like object and return a `Catalog`.

    >>> from datetime import datetime
    >>> from babel._compat import StringIO
    >>> buf = StringIO('''
    ... #: main.py:1
    ... #, fuzzy, python-format
    ... msgid "foo %(name)s"
    ... msgstr "quux %(name)s"
    ...
    ... # A user comment
    ... #. An auto comment
    ... #: main.py:3
    ... msgid "bar"
    ... msgid_plural "baz"
    ... msgstr[0] "bar"
    ... msgstr[1] "baaz"
    ... ''')
    >>> catalog = read_po(buf)
    >>> catalog.revision_date = datetime(2007, 4, 1)

    >>> for message in catalog:
    ...     if message.id:
    ...         print((message.id, message.string))
    ...         print(' ', (message.locations, sorted(list(message.flags))))
    ...         print(' ', (message.user_comments, message.auto_comments))
    (u'foo %(name)s', u'quux %(name)s')
      ([(u'main.py', 1)], [u'fuzzy', u'python-format'])
      ([], [])
    ((u'bar', u'baz'), (u'bar', u'baaz'))
      ([(u'main.py', 3)], [])
      ([u'A user comment'], [u'An auto comment'])

    .. versionadded:: 1.0
       Added support for explicit charset argument.

    :param fileobj: the file-like object to read the PO file from
    :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 ignore_obsolete: whether to ignore obsolete messages in the input
    :param charset: the character set of the catalog.
    :param abort_invalid: abort read if po file is invalid
    )�locale�domainr�)rU)rrMr�)r�r�r�rRr�rUr)�parserrrr�read_poLs/
r�zL(\s+|[^\s\w]*\w+[a-zA-Z]-(?=\w+[a-zA-Z])|(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w))cCs0d|�dd��dd��dd��dd	��d
d�S)z�Escape the given string so that it can be included in double-quoted
    strings in ``PO`` files.

    >>> escape('''Say:
    ...   "hello, world!"
    ... ''')
    '"Say:\\n  \\"hello, world!\\"\\n"'

    :param string: the string to escape
    z"%s"�\z\\rz\trz\rr
z\nrsz\")�replace)rrrr�escape�s����r�r�Lc
s0|r�|dkr�t��}g}|�d�D]�}tt|��||kr�t�|�}|��|r�g}d}|r�tt|d��d|}	||	|kr�|�|���||	7}qX|s�|�|���q�qX|�d�|��qLq"|�|�q"n
|�d�}t|�dkr�t|�S|�r|d�s|d=|dd7<dd��fd	d
�|D��S)a�Convert a string into a format that is appropriate for .po files.

    >>> print(normalize('''Say:
    ...   "hello, world!"
    ... ''', width=None))
    ""
    "Say:\n"
    "  \"hello, world!\"\n"

    >>> print(normalize('''Say:
    ...   "Lorem ipsum dolor sit amet, consectetur adipisicing elit, "
    ... ''', width=32))
    ""
    "Say:\n"
    "  \"Lorem ipsum dolor sit "
    "amet, consectetur adipisicing"
    " elit, \"\n"

    :param string: the string to normalize
    :param prefix: a string that should be prepended to every line
    :param width: the maximum line width; use `None`, 0, or a negative number
                  to completely disable line wrapping
    rTr�rrrr
z""
csg|]}�t|��qSr)r�)rbr*��prefixrrrc�rdznormalize.<locals>.<listcomp>)	rgrr��WORD_SEPr|�reverser6�popr )
rr��widthZ	prefixlenr!r*�chunks�buf�size�lrr�r�	normalize�s6


r�Tc
	sbd#�fdd�	���fdd��d$��fdd�	}
d%���fdd	�	}d
}|rLd}n|rTd}t�|d
�D�]�}
|
js�|rrq`�j}�r��dkr�g}|��D]}|t|�dd�7}q�d�|�}�|d�|
jD]}|
|�q�|
jD]}|
|dd�q�|�s�g}zt|
j	dd�d�}Wnt
�y$|
j	}Yn0|D]L\}}|�r\|	�r\|�d|�t
jd�|f�n|�d|�t
jd���q*|
d�|�dd�|
j�r��dd�dgt|
j���|
j�r|�r|
d�|
jd�dd�t|
j�d k�r|
d!�|
jd �dd�||
��d�q`|�s^t�j��|d
�D]0}
|
jD]}|
|��q6||
d"d��d��q,d
S)&a�Write a ``gettext`` PO (portable object) template file for a given
    message catalog to the provided file-like object.

    >>> catalog = Catalog()
    >>> catalog.add(u'foo %(name)s', locations=[('main.py', 1)],
    ...             flags=('fuzzy',))
    <Message...>
    >>> catalog.add((u'bar', u'baz'), locations=[('main.py', 3)])
    <Message...>
    >>> from babel._compat import BytesIO
    >>> buf = BytesIO()
    >>> write_po(buf, catalog, omit_header=True)
    >>> print(buf.getvalue().decode("utf8"))
    #: main.py:1
    #, fuzzy, python-format
    msgid "foo %(name)s"
    msgstr ""
    <BLANKLINE>
    #: main.py:3
    msgid "bar"
    msgid_plural "baz"
    msgstr[0] ""
    msgstr[1] ""
    <BLANKLINE>
    <BLANKLINE>

    :param fileobj: the file-like object to write to
    :param catalog: the `Catalog` instance
    :param width: the maximum line width for the generated output; use `None`,
                  0, or a negative number to completely disable line wrapping
    :param no_location: do not emit a location comment for every message
    :param omit_header: do not include the ``msgid ""`` entry at the top of the
                        output
    :param sort_output: whether to sort the messages in the output by msgid
    :param sort_by_file: whether to sort the messages in the output by their
                         locations
    :param ignore_obsolete: whether to ignore obsolete messages and not include
                            them in the output; by default they are included as
                            comments
    :param include_previous: include the old msgid as a comment when
                             updating the catalog
    :param include_lineno: include line number in the location comment
    rcst||�d�S)N)r�r�)r�)�keyr�)r�rr�
_normalizeszwrite_po.<locals>._normalizecs&t|t�r|��jd�}��|�dS)N�backslashreplace)rir�encoder��write)�text)r)r�rr�_writes
zwrite_po.<locals>._writecs>�r�dkr�}nd}t||�D]}�d||��f�q dS)Nrr�z#%s %s
)rr9)r�r��_widthr*)r�r�rr�_write_comment
s
z write_po.<locals>._write_commentc	st|jttf�r�|jr.�d|�|j|�f��d|�|jd|�f��d|�|jd|�f�t�j�D]B}z|j|}Wnty�d}Yn0�d||�||�f�qpnR|jrԈd|�|j|�f��d|�|j|�f��d|�|jp�d|�f�dS)	Nz
%smsgctxt %s
z%smsgid %s
rz%smsgid_plural %s
rrz%smsgstr[%d] %s
z%smsgstr %s
)	ri�idrjrhr]rkrlrr{)r$r�ror)r�r�r)rr�_write_messages2
��
�
��z write_po.<locals>._write_messageNr$r�)�sort_byrz# )r��subsequent_indentr
r�r�cSs"|dt|dt�r|dpdfS)Nrrr)rir})�xrrr�<lambda>Srdzwrite_po.<locals>.<lambda>�r�z%s:%d�/z%srwr�z#%s
z, zmsgid %s�|rzmsgid_plural %sz#~ )r)r)r)�_sort_messagesr�Zheader_commentrrr r[r\�sortedrY�	TypeErrorr6r�r>�seprZZprevious_idrgr^�values)r�r)r�Zno_locationZomit_headerZsort_outputZsort_by_filerRZinclude_previousZinclude_linenor�r�r�r$Zcomment_headerr!r*r�ZlocsrY�filenamer%r)r�r�r)r�r�r�write_po�s|.
�




�
���
�

r�cCs6t|�}|dkr|��n|dkr2|jdd�d�|S)z�
    Sort the given message iterable by the given criteria.

    Always returns a list.

    :param messages: An iterable of Messages.
    :param sort_by: Sort by which criteria? Options are `message` and `location`.
    :return: list[Message]
    r$r�cSs|jSr4)rY)rrrrr��rdz _sort_messages.<locals>.<lambda>r�)rjrf)rWr�rrrr�vs

r�)NNFNF)rr�)r�FFFFFFT)r1Z
__future__rr>rZbabel.messages.catalogrrZ
babel.utilrZ
babel._compatrrrr"�	Exceptionr#�objectr3rMr�rr�r�r�r�r�rrrr�<module>s,	/I
5

=�