3

X'íc¤Vã@s–dZd
dl
Z
d
dlZd
dlmZ
d
dlmZmZmZm	Z	
d
dl
mZmZm
Z
mZ
Gdd„dƒZGdd	„d	ƒZGd
d„de
jƒZGdd
„d
ee
jƒZdS)a-

    babel.support
    ~~~~~~~~~~~~~

    Several classes and functions that help with integrating and using Babel
    in applications.

    .. note: the code in this module is not used by Babel itself

    :copyright: (c) 2013-2022 by the Babel Team.
    :license: BSD, see LICENSE for more details.
éN)
ÚLocale)Úformat_dateÚformat_datetimeÚformat_timeÚformat_timedelta)Úformat_decimalÚformat_currencyÚformat_percentÚformat_scientificc@sneZ
dZd
Zddd„
Zddd„
Zddd	„
Zdd
d„
Zd dd„
Zdd„Z	d!dd„
Z
dd„Zd"dd„
Zdd„Z
dS)#ÚFormataC
Wrapper class providing the various date and number formatting functions
    bound to a specific locale and time-zone.

    >>> from babel.util import UTC
    >>> from datetime import date
    >>> fmt = Format('en_US', UTC)
    >>> fmt.date(date(2007, 4, 1))
    u'Apr 1, 2007'
    >>> fmt.decimal(1.2345)
    u'1.234'
    NcCstj
|
ƒ
|_||_d
S)z¯Initialize the formatter.

        :param locale: the locale identifier or `Locale` instance
        :param tzinfo: the time-zone info (a `tzinfo` instance or `None`)
        N)rÚparseÚlocaleÚtzinfo)Úselfr
r©rú./tmp/pip-build-gk9425m9/babel/babel/support.pyÚ__init__%s
zFormat.__init__ÚmediumcCst|
||j
d
S)zÇReturn a date formatted according to the given pattern.

        >>> from datetime import date
        >>> fmt = Format('en_US')
        >>> fmt.date(date(2007, 4, 1))
        u'Apr 1, 2007'
        )
r
)rr
)rÚdateÚformatrrrr.szFormat.datecCst|
||j
|jd
S)a6
Return a date and time formatted according to the given pattern.

        >>> from datetime import datetime
        >>> from pytz import timezone
        >>> fmt = Format('en_US', tzinfo=timezone('US/Eastern'))
        >>> fmt.datetime(datetime(2007, 4, 1, 15, 30))
        u'Apr 1, 2007, 11:30:00 AM'
        )rr
)rrr
)rÚdatetimerrrrr8s	

zFormat.datetimecCst|
||j
|jd
S)a
Return a time formatted according to the given pattern.

        >>> from datetime import datetime
        >>> from pytz import timezone
        >>> fmt = Format('en_US', tzinfo=timezone('US/Eastern'))
        >>> fmt.time(datetime(2007, 4, 1, 15, 30))
        u'11:30:00 AM'
        )rr
)rrr
)rÚtimerrrrrDs	zFormat.timeÚsecondç333333ë?ÚlongFcCst|
|||||j
d
S)zÙReturn a time delta according to the rules of the given locale.

        >>> from datetime import timedelta
        >>> fmt = Format('en_US')
        >>> fmt.timedelta(timedelta(weeks=11))
        u'3 months'
        )ÚgranularityÚ	thresholdrÚ
add_directionr
)rr
)rÚdeltarrrrrrrÚ	timedeltaOs	


zFormat.timedeltacCst|
|j
d
S)zŒReturn an integer number formatted for the locale.

        >>> fmt = Format('en_US')
        >>> fmt.number(1099)
        u'1,099'
        )
r
)rr
)rÚnumberrrrr ]sz
Format.numbercCst|
||j
d
S)zŽReturn a decimal number formatted for the locale.

        >>> fmt = Format('en_US')
        >>> fmt.decimal(1.2345)
        u'1.234'
        )
r
)rr
)rr rrrrÚdecimalfszFormat.decimalcCst|
||j
d
S)zHReturn a number in the given currency formatted for the locale.
        )
r
)rr
)rr Úcurrencyrrrr"oszFormat.currencycCst|
||j
d
S)zReturn a number formatted as percentage for the locale.

        >>> fmt = Format('en_US')
        >>> fmt.percent(0.34)
        u'34%'
        )
r
)r	r
)rr rrrrÚpercenttszFormat.percentcCst|
|j
d
S)zLReturn a number formatted using scientific notation for the locale.
        )
r
)r
r
)rr rrrÚ
scientific}szFormat.scientific)
N)Nr)Nr)Nr)rrrF)
N)
N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rrrrrr r!r"r#r$rrrrrs
	






	
	
	rc@s
eZ
dZd
ZddddddgZdd	„Zed
d„ƒ
Zdd
„Zdd„Z	dd„Z
dd„Zdd„Zdd„Z
dd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zd4d5„Zd6d7„Zd8d9„Zd:d;„Zd<d=„Z d>d?„Z!d@dA„Z"dBS)CÚ	LazyProxyaClass for proxy objects that delegate to a specified function to evaluate
    the actual object.

    >>> def greeting(name='world'):
    ...     return 'Hello, %s!' % name
    >>> lazy_greeting = LazyProxy(greeting, name='Joe')
    >>> print(lazy_greeting)
    Hello, Joe!
    >>> u'  ' + lazy_greeting
    u'  Hello, Joe!'
    >>> u'(%s)' % lazy_greeting
    u'(Hello, Joe!)'

    This can be used, for example, to implement lazy translation functions that
    delay the actual translation until the string is actually used. The
    rationale for such behavior is that the locale of the user may not always
    be available. In web applications, you only know the locale when processing
    a request.

    The proxy implementation attempts to be as complete as possible, so that
    the lazy objects should mostly work as expected, for example for sorting:

    >>> greetings = [
    ...     LazyProxy(greeting, 'world'),
    ...     LazyProxy(greeting, 'Joe'),
    ...     LazyProxy(greeting, 'universe'),
    ... ]
    >>> greetings.sort()
    >>> for greeting in greetings:
    ...     print(greeting)
    Hello, Joe!
    Hello, universe!
    Hello, world!
    Ú_funcÚ_argsÚ_kwargsÚ_valueÚ_is_cache_enabledÚ_attribute_errorcOsd|jd
dƒ}t
j|d|
ƒ
t
j|d|ƒ
t
j|d|ƒ
t
j|d|ƒ
t
j|ddƒ
t
j|ddƒ
dS)	NÚenable_cacheTr*r+r,r.r-r/)ÚpopÚobjectÚ__setattr__)rÚfuncÚargsÚkwargsZis_cache_enabledrrrr¨s





zLazyProxy.__init__c
Csp|jdkrjy|j
|j|jŽ
}
Wn2tk
rP
}
ztj|d
|ƒ
‚WYdd}~XnX|js\|
Stj|d|
ƒ
|jS)Nr/r-)r-r*r+r,ÚAttributeErrorr2r3r.)rÚvalueÚerrorrrrr8²s








zLazyProxy.valuecCs
|
|jkS)
N)
r8)rÚkeyrrrÚ__contains__Às
zLazyProxy.__contains__c

Cs
t|j
ƒ
S)
N)Úboolr8)
rrrrÚ__bool__Ãs
zLazyProxy.__bool__c

Cs
t|j
ƒ
S)
N)Údirr8)
rrrrÚ__dir__Æs
zLazyProxy.__dir__c

Cs
t|j
ƒ
S)
N)Úiterr8)
rrrrÚ__iter__És
zLazyProxy.__iter__c

Cs
t|j
ƒ
S)
N)Úlenr8)
rrrrÚ__len__Ìs
zLazyProxy.__len__c

Cs
t|j
ƒ
S)
N)Ústrr8)
rrrrÚ__str__Ïs
zLazyProxy.__str__cCs
|j|
S)
N)
r8)rÚotherrrrÚ__add__Òs
zLazyProxy.__add__cCs
|
|jS)
N)
r8)rrFrrrÚ__radd__Õs
zLazyProxy.__radd__cCs
|j|
S)
N)
r8)rrFrrrÚ__mod__Øs
zLazyProxy.__mod__cCs
|
|jS)
N)
r8)rrFrrrÚ__rmod__Ûs
zLazyProxy.__rmod__cCs
|j|
S)
N)
r8)rrFrrrÚ__mul__Þs
zLazyProxy.__mul__cCs
|
|jS)
N)
r8)rrFrrrÚ__rmul__ás
zLazyProxy.__rmul__c
Os|j|
|Ž
S)
N)
r8)rr5r6rrrÚ__call__äs
zLazyProxy.__call__cCs
|j|
kS)
N)
r8)rrFrrrÚ__lt__çs
zLazyProxy.__lt__cCs
|j|
k
S)
N)
r8)rrFrrrÚ__le__ês
zLazyProxy.__le__cCs
|j|
kS)
N)
r8)rrFrrrÚ__eq__ís
zLazyProxy.__eq__cCs
|j|
kS)
N)
r8)rrFrrrÚ__ne__ðs
zLazyProxy.__ne__cCs
|j|
kS)
N)
r8)rrFrrrÚ__gt__ós
zLazyProxy.__gt__cCs
|j|
kS)
N)
r8)rrFrrrÚ__ge__ös
zLazyProxy.__ge__cCst|j
|
ƒ
dS)
N)Údelattrr8)rÚnamerrrÚ__delattr__ùs
zLazyProxy.__delattr__cCs|jdk	r|j‚
t
|j|
ƒS)
N)r/Úgetattrr8)rrUrrrÚ__getattr__üs



zLazyProxy.__getattr__cCst|j
|
|ƒ
dS)
N)Úsetattrr8)rrUr8rrrr3

s
zLazyProxy.__setattr__cCs|j|
=dS)
N)
r8)rr:rrrÚ__delitem__
s
zLazyProxy.__delitem__cCs
|j|
S)
N)
r8)rr:rrrÚ__getitem__
s
zLazyProxy.__getitem__cCs||j|
<dS)
N)
r8)rr:r8rrrÚ__setitem__

s
zLazyProxy.__setitem__c

Cs t|j
f
|jžd
|ji
|j—Ž
S)Nr0)r)r*r+r.r,)
rrrrÚ__copy__

s


zLazyProxy.__copy__cCsDd
dlm
}
t||j|
ƒf
||j|
ƒžd||j|
ƒi
||j|
ƒ—Ž
S)Nr
)
Údeepcopyr0)Úcopyr^r)r*r+r.r,)rÚmemor^rrrÚ__deepcopy__
s




zLazyProxy.__deepcopy__N)#r%r&r'r(Ú	__slots__rÚpropertyr8r;r=r?rArCrErGrHrIrJrKrLrMrNrOrPrQrRrSrVrXr3rZr[r\r]rarrrrr)ƒs>"

r)csÖeZ
dZd
Zd)‡f
dd„	Zdd„Zdd„Zdd	„ZeZd
d„Z	dd
„Z
dd„ZeZdZ
dd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd „ZeZd!d"„Zd#d$„Zd%d&„ZeZd'd(„ZejjZejjZ ‡Z!S)*ÚNullTranslationsNcsJi|_d
d„|_
tƒj|
d

ttdt|
ddƒg
ƒƒ
|_|j|_	i|_
dS)a
Initialize a simple translations class which is not backed by a
        real catalog. Behaves similar to gettext.NullTranslations but also
        offers Babel's on *gettext methods (e.g. 'dgettext()').

        :param fp: a file-like object (ignored in this class)
        c

Sst|d
kƒ
S)Né
)
Úint)
Ú
nrrrÚ<lambda>.
sz+NullTranslations.__init__.<locals>.<lambda>)
ÚfpNrU)Ú_catalogÚpluralÚsuperrÚlistÚfilterrWÚfilesÚDEFAULT_DOMAINÚdomainÚ_domains)rri)
Ú	__class__rrr#
s






zNullTranslations.__init__cCs|jj
|
|ƒj|ƒ
S)
zULike ``gettext()``, but look the message up in the specified
        domain.
        )rrÚgetÚgettext)rrqÚmessagerrrÚdgettext4
szNullTranslations.dgettextcCs*d
dl}|j
dtdƒ
|jj|
|ƒj|ƒ
S)zVLike ``lgettext()``, but look the message up in the specified
        domain.
        r
Nz1ldgettext() is deprecated, use dgettext() insteadé)ÚwarningsÚwarnÚDeprecationWarningrrrtÚlgettext)rrqrvryrrrÚ	ldgettext:
s


zNullTranslations.ldgettextcCs|jj
|
|ƒj|ƒ
S)
zVLike ``ugettext()``, but look the message up in the specified
        domain.
        )rrrtÚugettext)rrqrvrrrÚ	udgettextC
szNullTranslations.udgettextcCs|jj
|
|ƒj|||ƒS)
zVLike ``ngettext()``, but look the message up in the specified
        domain.
        )rrrtÚngettext)rrqÚsingularrkÚnumrrrÚ	dngettextK
szNullTranslations.dngettextcCs.d
dl}|j
dtdƒ
|jj|
|ƒj|||ƒS)zWLike ``lngettext()``, but look the message up in the specified
        domain.
        r
Nz3ldngettext() is deprecated, use dngettext() insteadrx)ryrzr{rrrtÚ	lngettext)rrqrrkr‚ryrrrÚ
ldngettextQ
s


zNullTranslations.ldngettextcCs|jj
|
|ƒj|||ƒS)
zVLike ``ungettext()`` but look the message up in the specified
        domain.
        )rrrtÚ	ungettext)rrqrrkr‚rrrÚ
udngettextZ
szNullTranslations.udngettextz%s%scCsF|j|
|f}t
ƒ}|jj||ƒ}||krB|jr>|jj|
|ƒS|S|S)
a¯
Look up the `context` and `message` id in the catalog and return the
        corresponding message string, as an 8-bit string encoded with the
        catalog's charset encoding, if known.  If there is no entry in the
        catalog for the `message` id and `context` , and a fallback has been
        set, the look up is forwarded to the fallback's ``pgettext()``
        method. Otherwise, the `message` id is returned.
        )ÚCONTEXT_ENCODINGr2rjrtÚ	_fallbackÚpgettext)rÚcontextrvÚctxt_msg_idÚmissingÚtmsgrrrrŠi
s






zNullTranslations.pgettextcCs@d
dl}|j
dtdƒ
|j|
|ƒ}t|ddƒp4tjƒ}|j|ƒ
S)zÄEquivalent to ``pgettext()``, but the translation is returned in the
        preferred system encoding, if no other encoding was explicitly set with
        ``bind_textdomain_codeset()``.
        r
Nz1lpgettext() is deprecated, use pgettext() insteadrxÚ_output_charset)ryrzr{rŠrWr
ÚgetpreferredencodingÚencode)rr‹rvryrŽÚencodingrrrÚ	lpgettextz
s




zNullTranslations.lpgettextcCsh|j|
|f}y|j
||j|ƒ
f}|Stk
rb


|jrN|jj|
|||ƒS|d
krZ|S|SYnXdS)a^Do a plural-forms lookup of a message id.  `singular` is used as the
        message id for purposes of lookup in the catalog, while `num` is used to
        determine which plural form to use.  The returned message string is an
        8-bit string encoded with the catalog's charset encoding, if known.

        If the message id for `context` is not found in the catalog, and a
        fallback is specified, the request is forwarded to the fallback's
        ``npgettext()`` method.  Otherwise, when ``num`` is 1 ``singular`` is
        returned, and ``plural`` is returned in all other cases.
        reN)rˆrjrkÚKeyErrorr‰Ú	npgettext)rr‹rrkr‚rŒrŽrrrr•†
s







zNullTranslations.npgettextc	Cs˜d
dl}|j
dtdƒ
|j|
|f}y2|j||j|ƒ
f}t|ddƒpLtjƒ}|j	|ƒ
St
k
r’


|jr~|jj|
|||ƒS|dkrŠ|S|SYnXdS)zÅEquivalent to ``npgettext()``, but the translation is returned in the
        preferred system encoding, if no other encoding was explicitly set with
        ``bind_textdomain_codeset()``.
        r
Nz3lnpgettext() is deprecated, use npgettext() insteadrxrre)
ryrzr{rˆrjrkrWr
rr‘r”r‰Ú
lnpgettext)	rr‹rrkr‚ryrŒrŽr’rrrr–
s












zNullTranslations.lnpgettextcCsJ|j|
|f}t
ƒ}|jj||ƒ}||krF|jr>|jj|
|ƒSt|ƒ
S|S)
as
Look up the `context` and `message` id in the catalog and return the
        corresponding message string, as a Unicode string.  If there is no entry
        in the catalog for the `message` id and `context`, and a fallback has
        been set, the look up is forwarded to the fallback's ``upgettext()``
        method.  Otherwise, the `message` id is returned.
        )rˆr2rjrtr‰Ú	upgettextrD)rr‹rvÚctxt_message_idrrŽrrrr—²
s






zNullTranslations.upgettextcCsr|j|
|f}y|j
||j|ƒ
f}WnFtk
rl


|jrN|jj|
|||ƒS|d
kr`t|ƒ
}nt|ƒ
}YnX|S)a$Do a plural-forms lookup of a message id.  `singular` is used as the
        message id for purposes of lookup in the catalog, while `num` is used to
        determine which plural form to use.  The returned message string is a
        Unicode string.

        If the message id for `context` is not found in the catalog, and a
        fallback is specified, the request is forwarded to the fallback's
        ``unpgettext()`` method.  Otherwise, when `num` is 1 `singular` is
        returned, and `plural` is returned in all other cases.
        re)rˆrjrkr”r‰Ú
unpgettextrD)rr‹rrkr‚r˜rŽrrrr™Â
s








zNullTranslations.unpgettextcCs|jj
|
|ƒj||ƒS)
zVLike `pgettext()`, but look the message up in the specified
        `domain`.
        )rrrtrŠ)rrqr‹rvrrrÚ	dpgettextÙ
szNullTranslations.dpgettextcCs|jj
|
|ƒj||ƒS)
zWLike `upgettext()`, but look the message up in the specified
        `domain`.
        )rrrtr—)rrqr‹rvrrrÚ
udpgettextß
szNullTranslations.udpgettextcCs|jj
|
|ƒj||ƒS)
zÅEquivalent to ``dpgettext()``, but the translation is returned in the
        preferred system encoding, if no other encoding was explicitly set with
        ``bind_textdomain_codeset()``.
        )rrrtr“)rrqr‹rvrrrÚ
ldpgettextç
szNullTranslations.ldpgettextcCs|jj
|
|ƒj||||ƒS)
zWLike ``npgettext``, but look the message up in the specified
        `domain`.
        )rrrtr•)rrqr‹rrkr‚rrrÚ
dnpgettextî
s
zNullTranslations.dnpgettextcCs|jj
|
|ƒj||||ƒS)
zXLike ``unpgettext``, but look the message up in the specified
        `domain`.
        )rrrtr™)rrqr‹rrkr‚rrrÚudnpgettextõ
s
zNullTranslations.udnpgettextcCs|jj
|
|ƒj||||ƒS)
zÆEquivalent to ``dnpgettext()``, but the translation is returned in
        the preferred system encoding, if no other encoding was explicitly set
        with ``bind_textdomain_codeset()``.
        )rrrtr–)rrqr‹rrkr‚rrrÚldnpgettextþ
s
zNullTranslations.ldnpgettext)
N)"r%r&r'rprrwr}rZ	dugettextrƒr…r‡Z
dungettextrˆrŠr“r•r–r—r™ršr›Z
dupgettextrœrržZdunpgettextrŸrurdr~r€r†Ú
__classcell__rr)
rsrrd
s6		
rdcs^eZ
dZd
ZdZd‡f
dd„	ZejjZejj	Z
eddd„
ƒ
Zdd	„Z
ddd„
Zd
d„Z‡ZS)ÚTranslationsz&An extended translation catalog class.ÚmessagesNcstƒj
|
d


|p|j|_dS)zºInitialize the translations catalog.

        :param fp: the file-like object the translation should be read from
        :param domain: the message domain (default: 'messages')
        )
riN)rlrrprq)rrirq)
rsrrrs
zTranslations.__init__cCsn|d
k	r*t|t
tfƒs|g
}dd„|Dƒ
}|s4|j}tj||
|ƒ}|sLtƒSt|dƒ}|||dSQRXd
S)ap
Load translations from the given directory.

        :param dirname: the directory containing the ``MO`` files
        :param locales: the list of locales in order of preference (items in
                        this list can be either `Locale` objects or locale
                        strings)
        :param domain: the message domain (default: 'messages')
        Nc
Ssg|]}
t|
ƒ
‘qSr)
rD)Ú.0r
rrrú
<listcomp>(sz%Translations.load.<locals>.<listcomp>Úrb)rirq)Ú
isinstancermÚtuplerpruÚfindrdÚopen)ÚclsÚdirnameZlocalesrqÚfilenamerirrrÚloads










zTranslations.loadc

Csd
t|ƒ
j
|jjdƒ
fS)Nz
<%s: "%s">zproject-id-version)Útyper%Ú_infort)
rrrrÚ__repr__1s


zTranslations.__repr__TcCsbt|
d
|j
ƒ}|r&||jkr&|j|
ƒ
S|jj|ƒ
}|rJ|dk	rJ|j|
ƒ

n|
j|ƒ

|
|j|<|S)a!Add the given translations to the catalog.

        If the domain of the translations is different than that of the
        current catalog, they are added as a catalog that is only accessible
        by the various ``d*gettext`` functions.

        :param translations: the `Translations` instance with the messages to
                             add
        :param merge: whether translations for message domains that have
                      already been added should be merged with the existing
                      translations
        rqN)rWrprqÚmergerrrtÚadd_fallback)rÚtranslationsr±rqÚexistingrrrÚadd5s








zTranslations.addcCs6t|
t
jƒr2|jj|
jƒ

t|
tƒr2|jj|
jƒ

|S)
a0
Merge the given translations into the catalog.

        Message translations in the specified catalog override any messages
        with the same identifier in the existing catalog.

        :param translations: the `Translations` instance with the messages to
                             merge
        )r¦ruÚGNUTranslationsrjÚupdater¡roÚextend)rr³rrrr±Os
	



zTranslations.merge)NN)NNN)
T)r%r&r'r(rprrur¶r~r€r†Úclassmethodr­r°rµr±r rr)
rsrr¡
s
	


r¡)r(rur
Z
babel.corerZbabel.datesrrrrZ
babel.numbersrrr	r
rr)rdr¶r¡rrrrÚ<module>s

kl