3

X'ícÕUã@s¬dZd
dl
Z
d
dlZd
dlmZmZ
d
dlmZmZ
dd„Z	dd„Z
Gd	d
„d
eƒZGdd„dƒZ
Gd
d„dƒZddd„
Zejdƒ
Zdd„Zddd„
Zd dd„
Zdd„ZdS)!zî
    babel.messages.pofile
    ~~~~~~~~~~~~~~~~~~~~~

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

    :copyright: (c) 2013-2022 by the Babel Team.
    :license: BSD, see LICENSE for more details.
éN)ÚCatalogÚMessage)ÚwraptextÚ_cmpc
Cs"d
d„}
tj
dƒ
j|
|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
    c
Ss2|jd
ƒ
}
|
dkrdS|
dkr"dS|
dkr.dS|
S)Né
Ú
nÚ

Ú
tú
	Ú
rú

)
Úgroup)ÚmatchÚ
m©rú6/tmp/pip-build-gk9425m9/babel/babel/messages/pofile.pyÚreplace_escapess







z!unescape.<locals>.replace_escapesz\\([\\trn"])réÿÿÿÿ)ÚreÚcompileÚsub)ÚstringrrrrÚunescapes

rc
CsFd
|kr:|jƒ}
|j
dƒ
r&|
dd…}
tt|
ƒ}dj|ƒ
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
    rz""rNÚ)Ú
splitlinesÚ
startswithÚmaprÚjoin)rZ
escaped_linesÚlinesrrrÚdenormalize*s







rcs eZ
dZd
Z‡f
dd„Z‡ZS)ÚPoFileErrorzDException thrown by PoParser when an invalid po file is encountered.cs,tƒj
|
›d
|›ƒ

||_||_||_dS)Nz on )ÚsuperÚ__init__ÚcatalogÚlineÚlineno)ÚselfÚmessager#r$r%)
Ú	__class__rrr"Ks



zPoFileError.__init__)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r"Ú
__classcell__rr)
r(rr Is

r c@sleZ
dZd
d„Zdd„Zdd„Zdd„Zd	d
„Zdd„Zd
d„Z	dd„Z
dd„Zdd„Zdd„Z
dd„ZdS)Ú_NormalizedStringc
Gs"g|_x|
D]}|j
|ƒ

qWdS)
N)Ú_strsÚappend)r&ÚargsÚargrrrr"Ts



z_NormalizedString.__init__cCs|jj
|
jƒƒ

dS)
N)r/r0Ústrip)r&Ú
srrrr0Ys
z_NormalizedString.appendc

Csd
jt
t|jƒƒ
S)Nr)rrrr/)
r&rrrr\s
z_NormalizedString.denormalizec

Cs
t|j
ƒ
S)
N)Úboolr/)
r&rrrÚ__bool___s
z_NormalizedString.__bool__c

Cstj
j|jƒ
S)
N)ÚosÚlineseprr/)
r&rrrÚ__repr__bs
z_NormalizedString.__repr__cCs|
sd
Stt
|ƒ
t
|
ƒ
ƒS)Nr)rÚstr)r&ÚotherrrrÚ__cmp__es

z_NormalizedString.__cmp__cCs|j|
ƒ
d
kS)Nr
)
r<)r&r;rrrÚ__gt__ks
z_NormalizedString.__gt__cCs|j|
ƒ
d
kS)Nr
)
r<)r&r;rrrÚ__lt__ns
z_NormalizedString.__lt__cCs|j|
ƒ
d
kS)Nr
)
r<)r&r;rrrÚ__ge__qs
z_NormalizedString.__ge__cCs|j|
ƒ
d
k
S)Nr
)
r<)r&r;rrrÚ__le__ts
z_NormalizedString.__le__cCs|j|
ƒ
d
kS)Nr
)
r<)r&r;rrrÚ__eq__ws
z_NormalizedString.__eq__cCs|j|
ƒ
d
kS)Nr
)
r<)r&r;rrrÚ__ne__zs
z_NormalizedString.__ne__N)r)r*r+r"r0rr6r9r<r=r>r?r@rArBrrrrr.Rsr.c@sreZ
dZd
ZddddgZddd„
Zd	d
„Zdd„Zd
d„Zddd„
Z	ddd„
Z
dd„Zdd„Zdd„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
|_||_|jƒ
dS)Nr
)r#Úignore_obsoleteÚcounterÚoffsetÚ
abort_invalidÚ_reset_message_state)r&r#rHrKrrrr"s





zPoFileParser.__init__c

CsFg|_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_msgctxt)
r&rrrrL•s










z!PoFileParser._reset_message_statec

Cs@
|jj
ƒ
t|jƒ
d
kr.tdd„|jDƒ
ƒ
}
n|jdjƒ}
t|
ttfƒr¨dd„t|j	j
ƒ
Dƒ
}x<|jD]2\}}||j	j
krŽ|jd|jdƒ
qh|jƒ||<qhWt|ƒ
}n|jdd
jƒ}|j
rÌ|j
jƒ}nd	}t|
|t|jƒ
t|jƒ
|j|j|jd
|d
}|j
r|j
s&||j	j|
<n
||j	|
<|jd
7_|jƒ
d	S)z
        Add a message to the catalog based on the current parser state and
        clear the state ready to process the next message.
        rc
ss|]}
|
jƒV
qdS)
N)
r)Ú.0rrrrú	<genexpr>©sz,PoFileParser._add_message.<locals>.<genexpr>r
c
Ssg|]}
d‘qS)
rr)rXÚ
_rrrú
<listcomp>­sz-PoFileParser._add_message.<locals>.<listcomp>rz5msg has more translations than num_plurals of catalogN)r%rS)rNÚsortÚlenrMÚtuplerÚ
isinstanceÚlistÚranger#Únum_pluralsÚ_invalid_pofilerJrSrrOÚsetrPrRrQrTrHrIrL)r&rDrÚidxÚtranslationrFr'rrrÚ_add_message¢s2






















zPoFileParser._add_messagec


Cs|jr|j
ƒ
dS)
N)rMrg)
r&rrrÚ_finish_current_messageÅs

z$PoFileParser._finish_current_messagecCs*|jd
ƒ
r|j
||
ƒ
n|j|
||ƒ
dS)Nú
")rÚ!_process_string_continuation_lineÚ_process_keyword_line)r&r%r$rTrrrÚ_process_message_lineÉs


z"PoFileParser._process_message_linecCsH
xt|jD]X}y0|j
|ƒ
r:|t|ƒ
dkr:|t|ƒ
d…}PWqtk
r^


|j||
dƒ
YqXqW|j||
dƒ
dS|dkr†|jƒ
||_|dkrš|
|_|dkrÀd|_d	|_	|j
jt|ƒ
ƒ

n„|d
k
r*d|_	d	|_
|j
dƒ

r|dd…jddƒ\}}|jjt|ƒ
t|ƒ
gƒ

n|jjd
t|ƒ
gƒ

n|dk
rDd	|_t|ƒ
|_dS)Nú
 ú
[z$Keyword must be followed by a stringz0Start of line didn't match any expected keyword.rDrFrGFTrErú
]r
)rmrn)rDrF)rDrG)Ú	_keywordsrr]Ú
IndexErrorrcrhrTrJrWrUrMr0r.rVÚsplitrNÚintrS)r&r%r$rTÚkeywordr2reÚmsgrrrrkÏs8




















z"PoFileParser._process_keyword_linecCsV|jr|j
d}n6|jr(|jdd
}n |jr6|j}n|j|
|dƒ
dS|j|
ƒ

dS)Nrz<Got line starting with " but not in msgid, msgstr or msgctxtrr)rUrMrVrNrWrSrcr0)r&r$r%r4rrrrjøs







z.PoFileParser._process_string_continuation_linec
Cs>
|jƒ
|
d
d…j
dƒ
r¦xˆ|
dd…jƒjƒD]p}|jdƒ
}|dkryt||d
d…ƒ
}Wntk
rt


w0YnX|jj|d|…|fƒ

q0|jj|dfƒ

q0Wn”|
d
d…j
dƒ
rêx€|
dd…jƒjdƒ
D]}|j	j|j
ƒƒ

qÐWnP|
d
d…j
dƒ

r"|
dd…j
ƒ}|
r:|jj|ƒ

n|jj|
d
d…j
ƒƒ

dS)Nrú
:ér
ú
,Ú
.)
rhrÚlstriprrÚrfindrsÚ
ValueErrorrOr0rPr3rRrQ)r&r$ÚlocationÚposr%ÚflagÚcommentrrrÚ_process_comment
s&














zPoFileParser._process_commentcCsàxŒt|
ƒ
D]€\}}|j
ƒ}t|tƒs2|j|jjƒ
}|s8q
|jd
ƒ
r~|dd…jdƒ
rr|j||dd…j	ƒdd
qŠ|j
|ƒ

q
|j||ƒ
q
W|jƒ
|jrÜ|j
s°|js°|jrÜ|jjtdƒ
ƒ

|jjd	tdƒ
gƒ

|jƒ
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ú
~rwT)
rTz""r
)Ú	enumerater3r_r:Údecoder#ÚcharsetrrlrzrrhrIrPrQrRrMr0r.rNrg)r&Úfileobjr%r$rrrÚparse
s 












zPoFileParser.parsecCsJt|
t
ƒst‚
|jr$t||j|
|ƒ‚
td
|ƒ
tdj|dt|
ƒ
ƒƒ

dS)NzWARNING:z!WARNING: Problem on line {0}: {1}r)	r_r:ÚAssertionErrorrKr r#ÚprintÚformatÚrepr)r&r$r%rurrrrc<
s





zPoFileParser._invalid_pofileN)FF)
F)
F)r)r*r+r,rpr"rLrgrhrlrkrjrrˆrcrrrrrCs




#

)rCFcCs*t|
||d
}t
|||d}|j|ƒ

|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 io 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†)
rK)rrCrˆ)r‡rrŽrHr†rKr#ÚparserrrrÚread_poG
s/



rzL(\s+|[^\s\w]*\w+[a-zA-Z]-(?=\w+[a-zA-Z])|(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w))c

Cs0d
|jddƒjddƒjddƒjdd	ƒjd
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\\r
z\trz\rrz\nriz\")
Úreplace)
rrrrÚescapeƒ
s




r“réLc
s>
|rÜ|d
krÜtˆƒ
}g}xÌ|j
dƒ
D]²}tt|ƒ
ƒ
||krÌtj|ƒ
}|jƒ
x†|rÈg}d}xX|r´tt|d
ƒ
ƒ
d|}	||	|krž|j|jƒƒ

||	7}q^|s°|j|jƒƒ

Pq^W|jdj|ƒ
ƒ

qPWq$|j|ƒ

q$Wn
|j
dƒ
}t|ƒ
dk
rút|ƒ
S|
r"|d
r"|d=|d
d7<ddj‡f
dd	„|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
    r
Trwrrrz""
c
sg|]}
ˆt|
ƒ
‘qSr)
r“)rXr$)
Úprefixrrr[Ï
sznormalize.<locals>.<listcomp>rrrr)	r]rr“ÚWORD_SEPrrÚreverser0Úpopr)
rr•ÚwidthÚ	prefixlenrr$ÚchunksÚbufÚsizeÚ
lr)
r•rÚ	normalize•
s6






















rŸTc
sŠd#‡f
dd„	‰‡‡fdd„‰
d$‡
‡fdd„	}
d%‡‡
‡fdd	„	}d
}|rLd}n|rTd}
xÜtˆ|d
D
]Ê}
|
j
sÆ|rvqdˆj}ˆrºˆdkrºg}x"|jƒD]}|t|ˆdd7}q–Wdj|ƒ
}ˆ
|dƒ

x|
jD]}|
|ƒ

qÎWx|
jD]}|
|dd
qæW|
s¨g}yt|
j	dd„d}Wnt
k

r6


|
j	}YnXx\|D]T\}}|
rj|	
rjd|jtj
dƒ|f}nd|jtj
dƒ}||k
r>|j|ƒ


q>W|
dj|ƒ
dd
|
j
rΈ
ddjd
g
t|
jƒ
ƒ
ƒ

|
jr |r |
dˆ|
jdƒ
dd
t|
jƒ
d kr |
d!ˆ|
jd ƒ
dd
||
ƒ

ˆ
dƒ

qdW|s†xJtˆjjƒ|d
D]4}
x|
jD]}|
|ƒ

qZW||
d"d
ˆ
dƒ

qNWd
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 io 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Ú
_normalizes
zwrite_po.<locals>._normalizec

s&t|t
ƒr|jˆjd
ƒ}ˆ
j|ƒ

dS)NÚbackslashreplace)r_r:Úencoder†Úwrite)
Útext)r#r‡rrÚ_writes



zwrite_po.<locals>._writecsBˆ
rˆ
d
krˆ
}nd}x&t||ƒD]}ˆd|
|j
ƒfƒ

q"WdS)Nr
r”z#%s %s
)rr3)r€r•Ú_widthr$)r¦r™rrÚ_write_comments



z write_po.<locals>._write_commentcs
t|j
ttfƒr¼|jr.ˆ
d
|
ˆ|j|
ƒfƒ

ˆ
d|
ˆ|j
d|
ƒfƒ

ˆ
d|
ˆ|j
d|
ƒfƒ

x¨tˆjƒ
D]D}y|j|}Wntk
rœ


d}YnXˆ
d|
|ˆ||
ƒfƒ

qrWnT|jrڈ
d
|
ˆ|j|
ƒfƒ

ˆ
d|
ˆ|j
|
ƒfƒ

ˆ
d|
ˆ|j
pd|
ƒfƒ

dS)	Nz
%smsgctxt %s
z%smsgid %s
r
z%smsgid_plural %s
rrz%smsgstr[%d] %s
z%smsgstr %s
)	r_Úidr`r^rSrarbrrq)r'r•rer)r¡r¦r#rrÚ_write_messages(


















z write_po.<locals>._write_messageNr'r})
Úsort_byr
z# )r™Úsubsequent_indentrry)
r•c

Ss"|d
t|dt
ƒr|dpdfS)Nr
rr)r_rs)
Ú
xrrrÚ<lambda>Nszwrite_po.<locals>.<lambda>)
r z%s:%dú
/z%srmrvz#%s
z, zmsgid %sú
|rzmsgid_plural %sz#~ )
r)
r)
r)Ú_sort_messagesr©Zheader_commentrrrrQrRÚsortedrOÚ	TypeErrorr’r7Úsepr0rPZprevious_idr]rTÚvalues)r‡r#r™Zno_locationZomit_headerZsort_outputZsort_by_filerHZinclude_previousZinclude_linenor¨rªr«r'Zcomment_headerrr$r€ZlocsrOÚfilenamer%r}r)r¡r¦r#r‡r™rÚwrite_poÒ
st.













































r·cCs6t|ƒ
}|
d
kr|j
ƒ
n|
dkr2|j
dd„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}c


Ss|jS)
N)
rO)
rrrrr®sz _sort_messages.<locals>.<lambda>)
r )r`r\)rMr«rrrr±ss






r±)NNFNF)rr”)r”FFFFFFT)r,r7rZbabel.messages.catalogrrZ
babel.utilrrrrÚ	Exceptionr r.rCrrr–r“rŸr·r±rrrrÚ<module>
s&

	-I
5

=