ó
    Ñ]jhý  ã                  óŒ	  • % S r SSKJr  SSKrSSKrSSKJr  SSKrSSKrSSK	r	SSK
r
SSKrSSKrSSKrSSKrSSKJr  SSKJr  SSKJr  SSKJr  SS	KJr  SS
KJr  SSKJr  SSKJr  SSKJr  SSKJr  SSKJr  SSKJr  SSKJr  SSKJr  SSKJr  SSKJr  SSKJ r   SSKJ!r!  SSKJ"r"  SSK#r#SSK$J%r%  SSK$J&r&  SSK'J(r(  SSKJ)r)  SSK$J*r*  \!" S5      r+\!" S S!S"9r,\!" S#\S$\4   S%9r-\!" S&S'S%9r.\!" S(S)S%9r/\!" S*S+S%9r0\!" S,S-S%9r1SŸS. jr2 " S/ S05      r3S S1 jr4S¡S2 jr5 S¢     S£S3 jjr6      S¤S5 jr7S¥S6 jr8S¦S7 jr9S§S8 jr:\!" S9S4S%9r;S¨S: jr<        S©S; jr=\!" S<5      r>\!" S=5      r? " S> S?5      r@S@ rA\SS$SA.       SªSB jj5       rB\SSCSA.       S«SD jj5       rBSSCSA.       S«SE jjrBS¬SF jrC S­       S®SG jjrD S¯     S°SH jjrES¯SI jrF    S±               S²SJ jjrGSK rHSL rI   S³         S´SM jjrJ " SN SO5      rKSP rLSQ rM    SµSR jrNSS rOS¶ST jrP\!" SUSVS%9rQ " SW SX\\,   5      rR " SY SZ\R\,   5      rS " S[ S\\R\,   5      rT\ (       a	  \RrU\RrV\WrX\WrYO\T=rUrX\S=rVrYS·S] jrZ " S^ S_5      r[\ (       a  \Wr\O\[Rº                  r\ " S` Sa5      r^S¸Sb jr_S¹Sc jr`SºSd jra  S»           S¼Se jjrbS½Sf jrcS¾Sg jrdS¿Sh jre S¢     SÀSi jjrf        SÁSj jrgSk rh " Sl Sm\W5      ri " Sn So\\+   5      rj " Sp Sq\\+   5      rk " Sr Ss\\+   5      rl " St Su\m5      rn " Sv Sw\o5      rp " Sx Sy\pSz9rq\ (       a	  SS{KJrrr  \rrsO\qrs\!" S|\Rè                  S%9ru SÂ         SÃS} jjrvSqwSÄS~ jrxSÅS jrySÆS€ jrz " S� S‚\{5      r|S¢SÇSƒ jjr}SÈS„ jr~0 rS…\€S†'         SÉS‡ jr�\
GR                  " Sˆ5      rƒ  SÊ       SËS‰ jjr„      SÌSŠ jr…\
GR                  " S‹5      r†\
GR                  " SŒ5      r‡\‡\†4       SÍS� jjrˆ\o" S5      r‰SŽ rŠ\
GR                  " S�5      r‹ " S� S‘5      rŒ " S’ S“5      r�S” rŽS• r�SÎS– jr�SÏS— jr‘        SÐS˜ jr’\
GR                  " S™5      r“SÑSš jr”SÒS› jr•SÂSœ jr– " S� Sž\Rè                  5      r—\—GR0                  r˜\"\+\)\—GR0                     4   r™g)Óz…Routines to help with the creation, loading and introspection of
modules, classes, hierarchies, attributes, functions, and methods.

é    )ÚannotationsN©Úupdate_wrapper)ÚCodeType)ÚAny)ÚCallable)Úcast)ÚDict)Ú	FrozenSet)ÚGeneric)ÚIterator)ÚList)ÚNoReturn)ÚOptional)Úoverload)ÚSequence)ÚSet)ÚTuple)ÚType)ÚTYPE_CHECKING)ÚTypeVar)ÚUnioné   )Ú_collections)Úcompat)ÚHAS_CYEXTENSION)ÚLiteralé   )ÚexcÚ_TÚ_T_coT)Ú	covariantÚ_F.)ÚboundÚ_MPzmemoized_property[Any]Ú_MAz#HasMemoized.memoized_attribute[Any]Ú_HPzhybridproperty[Any]Ú_HMzhybridmethod[Any]c                ó¬   • U R                  S5      n [        R                  " 5       nUR                  U 5        [	        [
        UR                  5       5      $ )Nzutf-8)Úencoder   Úmd5_not_for_securityÚupdater	   ÚstrÚ	hexdigest)ÚxÚms     ÚX/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sqlalchemy/util/langhelpers.pyÚmd5_hexr2   >   s<   € Ø	�‰�Ó€AÜ×#Ò#Ó%€AØ‡H�HˆQ„KÜ”�Q—[‘[“]Ó#Ð#ó    c                  óL   • \ rS rSr% SrSrS\S'   S	S jr        S
S jrSr	g)Úsafe_reraiseéE   aÔ  Reraise an exception after invoking some
handler code.

Stores the existing exception info before
invoking so that it is maintained across a potential
coroutine context switch.

e.g.::

    try:
        sess.commit()
    except:
        with safe_reraise():
            sess.rollback()

TODO: we should at some point evaluate current behaviors in this regard
based on current greenlet, gevent/eventlet implementations in Python 3, and
also see the degree to which our own asyncio (based on greenlet also) is
impacted by this. .rollback() will cause IO / context switch to occur in
all these scenarios; what happens to the exception context from an
"except:" block if we don't explicitly store it? Original issue was #2703.

)Ú	_exc_infozdUnion[None, Tuple[Type[BaseException], BaseException, types.TracebackType], Tuple[None, None, None]]r7   c                ó8   • [         R                  " 5       U l        g ©N)ÚsysÚexc_infor7   ©Úselfs    r1   Ú	__enter__Úsafe_reraise.__enter__j   s   € ÜŸš›ˆ�r3   c                ó¸   • U R                   c   eUc,  U R                   u  pEnUc   eS U l         UR                  U5      eS U l         Uc   eUR                  U5      er9   )r7   Úwith_traceback)r=   Útype_ÚvalueÚ	tracebackÚexc_typeÚ	exc_valueÚexc_tbs          r1   Ú__exit__Úsafe_reraise.__exit__m   so   € ð �~‰~Ñ)Ð)Ð)à‰=Ø*.¯.©.Ñ'ˆH ØÑ(Ð(Ð(Ø!ˆDŒNØ×*Ñ*¨6Ó2Ð2à!ˆDŒNØÑ$Ð$Ð$Ø×&Ñ& yÓ1Ð1r3   N©ÚreturnÚNone)rB   zOptional[Type[BaseException]]rC   zOptional[BaseException]rD   zOptional[types.TracebackType]rK   r   )
Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Ú	__slots__Ú__annotations__r>   rH   Ú__static_attributes__© r3   r1   r5   r5   E   sH   ‡ ñð0 €Iðó ô(ð2à,ð2ð 'ð2ð 1ð	2ð
 
÷2r3   r5   c              #  óÞ   #   • [        5       nU /nU(       aU  UR                  5       n X;   a  M  UR                  U 5        UR                  U R	                  5       5        U v •  U(       a  MT  g g 7fr9   )ÚsetÚpopÚaddÚextendÚ__subclasses__)ÚclsÚseenÚstacks      r1   Úwalk_subclassesr_   €   sU   é € Ü“U€DàˆE€EÞ
Ø�i‰i‹kˆØ‹;Ùà�H‰H�SŒMØ�‰�S×'Ñ'Ó)Ô*ØŠ	÷ Š%ùs   ‚A'A-Á+A-c                ór   • [        U [        5      (       a  U $  [        U 5      $ ! [         a    SU -  s $ f = f)Nzunprintable element %r)Ú
isinstancer-   Ú	Exception)Úelements    r1   Ústring_or_unprintablerd   Ž   s=   € Ü�'œ3×ÑØˆð	6Ü�w“<ÐøÜó 	6Ø+¨gÑ5Ò5ð	6ús   ™
$ ¤6µ6c                ó†   • U=(       d    U R                   nSR                  S [        R                  " SU5       5       5      $ )NÚ c              3  ó@   #   • U  H  oR                  5       v •  M     g 7fr9   )Úlower)Ú.0Úns     r1   Ú	<genexpr>Ú(clsname_as_plain_name.<locals>.<genexpr>œ   s   é € ÐNÒ'M !—G‘G—I�IÒ'Mùs   ‚z([A-Z][a-z]+|SQL))rM   ÚjoinÚreÚfindall)r\   Úuse_nameÚnames      r1   Úclsname_as_plain_namerr   ˜   s3   € ð ×#�s—|‘|€DØ�8‰8ÑN¤r§z¢zÐ2FÈÔ'MÓNÓNÐNr3   úCallable[..., Any]c                ó€   • [        U [        5      (       d  U R                  nOU nUR                  n[	        X#5      nXA:g  $ )z1Return True if the two class methods don't match.)ra   ÚtypeÚ	__class__rM   Úgetattr)Úinstance_or_clsÚagainst_methodÚcurrent_clsÚmethod_nameÚcurrent_methods        r1   Úmethod_is_overriddenr}   Ÿ   s?   € ô �o¤t×,Ñ,Ø%×/Ñ/‰à%ˆà ×)Ñ)€Kä'.¨{Ó'H€NàÑ+Ð+r3   c                óÔ   • / nU R                   U R                  U R                  4 H5  n[        US5      (       a  UR	                  5       nUR                  U5        M7     [        U5      $ )zjdecode a slice object as sent to __getitem__.

takes into account the 2.5 __index__() method, basically.

Ú	__index__)ÚstartÚstopÚstepÚhasattrr   ÚappendÚtuple)ÚslcÚretr/   s      r1   Údecode_slicerˆ   ±   sU   € ð €CØ�Y‰Y˜Ÿ™ #§(¡(Ó*ˆÜ�1�k×"Ñ"Ø—‘“ˆAØ�
‰
�1Žñ +ô �‹:Ðr3   c           
   '  óø   ^#   • [        U 5      nU Hd  m[        R                  " T4[        U4S j[	        S5      5      5      nU H   nXB;  d  M
  UR                  U5        Uv •    MV     [        ST-  5      e   g 7f)Nc                ó    >• T[        U 5      -   $ r9   ©r-   )ÚiÚbases    €r1   Ú<lambda>Ú!_unique_symbols.<locals>.<lambda>Ä   s   ø€ ˜$¤ Q£š-r3   iè  z&exhausted namespace for symbol base %s)rW   Ú	itertoolsÚchainÚmapÚrangerY   Ú	NameError)ÚusedÚbasesÚused_setÚpoolÚsymr�   s        @r1   Ú_unique_symbolsrš   ¿   st   øé € Ü�4‹y€HÛˆÜ�ŠØˆGÜÔ'¬¨t«Ó5ó
ˆó ˆCØÕ"Ø—‘˜SÔ!Ø’	Úñ	 ô ÐDÀtÑKÓLÐLò ùs   ƒAA:Á+A:c              #  óZ   #   • U(       a   X) S-   -  nU " U5      v •  X-  nU(       a  M  gg7f)z6Call the given function given each nonzero bit from n.r   NrU   )Úfnrj   Úbs      r1   Úmap_bitsrž   Ï   s.   é € ö Ø��a‘‰LˆÙ�‹eŠØ	‰ˆ÷ Š!ùs   ‚%+©+Ú_Fnc                ó,   ^ • SU 4S jjn[        UT 5      $ )z'A signature-matching decorator factory.c                óD  >• [         R                  " U 5      (       d&  [         R                  " U 5      (       d  [        S5      e[	        U SS 5      nUb%  S U l         [        R                  " U 5      nXl        O[        R                  " U 5      nS[        UR                  =(       d    S5      -  n[        R                  UR                  =(       d    S5      nUR                  0 UUS9n[        [        SUS   5      5      [        SUSS	 5      -   U R                   4-   n[#        US
S5      u  pg[        XgS9nUR%                  ['        USS95        U R                   US'   [         R(                  " U 5      (       a  SUS'   SUS'   O
SUS'   SUS'   S[+        US   5      ;   a  SU-  n	OSU-  n	UTXpSU R,                  0n
[        [.        R0                  [3        XšU R                   5      5      nU R4                  Ul        U R6                  Ul        [9        X°5      $ ! Xl        f = f)Nznot a decoratable functionÚ__annotate__r9   rU   )r   ÚdefaultsÚkwonlydefaultszTuple[str, ...]r   r   é   Útargetrœ   )r¦   rœ   F©Úgroupedrq   zasync Úprefixzawait Útarget_prefixÚ Ú__zf%(prefix)sdef %(name)s%(grouped_args)s:
    return %(target_prefix)s%(target)s(%(fn)s, %(apply_pos)s)
ze%(prefix)sdef %(name)s%(grouped_args)s:
    return %(target_prefix)s%(target)s(%(fn)s, %(apply_kw)s)
rM   )ÚinspectÚ
isfunctionÚismethodrb   rw   r¢   r   Úinspect_getfullargspecÚlenr£   ÚdictÚfromkeysr¤   Ú_replacer…   r	   rM   rš   r,   Úformat_argspec_plusÚiscoroutinefunctionÚreprrN   ÚtypesÚFunctionTypeÚ_exec_code_in_envÚ__defaults__Ú__kwdefaults__r   )rœ   ÚannofuncÚspecÚempty_defaultsÚempty_kwdefaultsÚnamesÚ	targ_nameÚfn_nameÚmetadataÚcodeÚenvÚ	decoratedr¦   s               €r1   ÚdecorateÚdecorator.<locals>.decorateà   s&  ø€ Ü×!Ò! "×%Ñ%¬g×.>Ò.>¸r×.BÑ.BÜÐ8Ó9Ð9ô ˜2˜~¨tÓ4ˆØÑØ"ˆBŒOð+Ü×4Ò4°RÓ8�à"*•ä×0Ò0°Ó4ˆDð !¤3 t§}¡}×':¸Ó#;Ñ;ˆÜŸ=™=¨×)<Ñ)<×)BÀÓCÐØ�}‰}ØØ#Ø+ð ð 
ˆô ”$Ð(¨$¨q©'Ó2Ó3ÜÐ$ d¨1¨Q iÓ0ñ1à�{‰{ˆnñð 	ô
 -¨U°H¸dÓCÑˆ	ä-1¸Ñ-OˆØ�‰Ô+¨D¸%Ñ@ÔAØŸ;™;ˆ�Ñä×&Ò& r×*Ñ*Ø!)ˆH�XÑØ(0ˆH�_Ò%à!#ˆH�XÑØ(*ˆH�_Ñ%ð ”4˜˜Q™“=Ó ðð ñ	ñ ðð ñ	ð ð �vØØ˜Ÿ™ð
ˆô Ü×ÑÜ˜d¨¯©Ó5ó
ˆ	ð "$§¡ˆ	ÔØ#%×#4Ñ#4ˆ	Ô Ü˜iÓ,Ð,øðQ #+•ús   ÁH ÈH)rœ   rŸ   rK   rŸ   r   )r¦   rÈ   s   ` r1   Ú	decoratorrÊ   Ý   s   ø€ ÷T-ôl ˜( FÓ+Ð+r3   c                ó    • [        X5        X   $ r9   )Úexec)rÅ   rÆ   rÃ   s      r1   rº   rº   9  s   € ô 	ˆ„OØ‰<Ðr3   Ú_PFÚ_TEc                  óN   • \ rS rSr S	   S
S jjrS rSS jrSS jrSS jrSr	g)ÚPluginLoaderiD  Nc                ó*   • Xl         0 U l        X l        g r9   )ÚgroupÚimplsÚauto_fn)r=   rÒ   rÔ   s      r1   Ú__init__ÚPluginLoader.__init__E  s   € ð Œ
Ø%'ˆŒ
Ø�r3   c                ó8   • U R                   R                  5         g r9   )rÓ   Úclearr<   s    r1   rØ   ÚPluginLoader.clearL  s   € Ø�
‰
×ÑÕr3   c                óØ  • XR                   ;   a  U R                   U   " 5       $ U R                  (       a-  U R                  U5      nU(       a  X R                   U'   U" 5       $ [        R                  " U R                  5       H>  nUR
                  U:X  d  M  UR                  U R                   U'   UR                  5       s  $    [        R                  " SU R                  < SU< 35      e)NzCan't load plugin: Ú:)	rÓ   rÔ   r   Úimportlib_metadata_getrÒ   rq   Úloadr   ÚNoSuchModuleError)r=   rq   ÚloaderÚimpls       r1   rÝ   ÚPluginLoader.loadO  s­   € Ø—:‘:ÓØ—:‘:˜dÒ#Ó%Ð%à�<�<Ø—\‘\ $Ó'ˆFÞØ#)—
‘
˜4Ñ Ù“x�ä×1Ò1°$·*±*Ö=ˆDØ�y‰y˜DÕ Ø#'§9¡9�—
‘
˜4Ñ Ø—y‘y“{Ò"ñ >ô
 ×#Ó#Ø*.¯*¬*²dÐ;ó
ð 	
r3   c                ó2   ^^• UU4S jnX@R                   U'   g )Nc                 ó~   >• [        T5      n TR                  S5      SS   H  n[        X5      n M     [        U T5      $ )NÚ.r   )Ú
__import__Úsplitrw   )ÚmodÚtokenÚ
modulepathÚobjnames     €€r1   rÝ   Ú#PluginLoader.register.<locals>.loadc  s@   ø€ Ü˜ZÓ(ˆCØ#×)Ñ)¨#Ó.¨q¨rÓ2�Ü˜cÓ)’ñ 3ä˜3 Ó(Ð(r3   ©rÓ   )r=   rq   ré   rê   rÝ   s     `` r1   ÚregisterÚPluginLoader.registerb  s   ù€ ö	)ð  �
‰
�4Òr3   c                ó   • U R                   U	 g r9   rì   )r=   rq   s     r1   Ú
deregisterÚPluginLoader.deregisterk  s   € Ø�J‰J�tÑr3   )rÔ   rÒ   rÓ   r9   )rÒ   r-   rÔ   zOptional[Callable[..., Any]])rq   r-   rK   r   )rq   r-   ré   r-   rê   r-   rK   rL   )rq   r-   rK   rL   )
rM   rN   rO   rP   rÕ   rØ   rÝ   rí   rð   rT   rU   r3   r1   rÐ   rÐ   D  s.   † àBFðØðØ#?õòô
ô& ÷r3   rÐ   c                ó&  •  [         R                  nU R                  nUR                  n[	        UR
                  S U 5      [        UR                  U-  5      4$ ! [         a,    [        R                  " U 5      nUS   [        US   5      4s $ f = f)Nr   r   )r­   ÚCO_VARKEYWORDSÚ__code__Úco_argcountÚlistÚco_varnamesÚboolÚco_flagsÚAttributeErrorr   r°   )rœ   Úco_varkeywordsÚcoÚnargsr¾   s        r1   Ú_inspect_func_argsrþ   o  sŽ   € ð
Ü ×/Ñ/ˆð �[‰[ˆØ—‘ˆä�—‘  Ð'Ó(Ü�—‘˜~Ñ-Ó.ð
ð 	
øô ó &ô
 ×,Ò,¨RÓ0ˆØ�A‰wœ˜T !™W›Ð%Ò%ð&ús   ‚A Á3BÂB)Ú_setÚraiseerrc               ó   • g r9   rU   ©r\   rÿ   r   s      r1   Úget_cls_kwargsr  ƒ  s   € ð r3   Fc               ó   • g r9   rU   r  s      r1   r  r  Œ  s   € ð r3   c               ó$  • USL nU(       a
  [        5       nUc   eU R                  R                  SS5      nU=(       aE    [        U[        R
                  5      =(       a$    [        UR                  [        R                  5      nU(       aD  [        U5      u  pgUR                  U5        U(       d  U(       d  U(       a  [        SU  S35      egOSnU(       a  U(       a  U R                   H  n[        X�S9b  M    O   UR                  S5        U$ )aA  Return the full set of inherited kwargs for the given `cls`.

Probes a class's __init__ method, collecting all named arguments.  If the
__init__ defines a \**kwargs catch-all, then the constructor is presumed
to pass along unrecognized keywords to its base classes, and the
collection process is repeated recursively on each of the bases.

Uses a subset of inspect.getfullargspec() to cut down on method overhead,
as this is used within the Core typing system to create copies of type
objects which is a performance-sensitive operation.

No anonymous tuple arguments please !

NrÕ   Fz
given cls z  doesn't have an __init__ method)rÿ   r=   )rW   Ú__dict__Úgetra   r¸   r¹   rô   r   rþ   r,   Ú	TypeErrorÚ	__bases__r  Údiscard)	r\   rÿ   r   ÚtoplevelÚctrÚhas_initrÁ   Úhas_kwÚcs	            r1   r  r  ’  sí   € ð" �tˆ|€HÞÜ‹uˆØÑÐÐà
�,‰,×
Ñ
˜: uÓ
-€Cð 	÷ 	5Ü�sœE×.Ñ.Ó/÷	5ä�s—|‘|¤U§^¡^Ó4ð ö Ü*¨3Ó/‰ˆØ�‰�EÔæžhÞÜØ   Ð%EÐFóð ð øàˆæ–vØ—”ˆAÜ˜aÑ+Ó3Ùñ ð 	‡L�L�ÔØ€Kr3   c                ó4   • [         R                  " U 5      S   $ )zwReturn the set of legal kwargs for the given `func`.

Uses getargspec so is safe to call for methods, functions,
etc.

r   )r   r°   )Úfuncs    r1   Úget_func_kwargsr  Ç  s   € ô ×(Ò(¨Ó.¨qÑ1Ð1r3   c           	     ó  • [         R                  " U 5      (       a  [        SU -  5      e[         R                  " U 5      (       aŸ  U(       a‚  U(       a{  [        R
                  " U 5      n[        R                  " UR                  SS UR                  UR                  UR                  UR                  UR                  UR                  5      $ [        R
                  " U 5      $ [         R                  " U 5      (       aÄ  U(       a�  U(       d  U R                  (       a…  [        R
                  " U R                   5      n[        R                  " UR                  SS UR                  UR                  UR                  UR                  UR                  UR                  5      $ [        R
                  " U R                   5      $ [         R"                  " U 5      (       a  [%        U R&                  USS9$ [)        U S5      (       a   [        R
                  " U R                   5      $ [)        U S5      (       aG  [         R                  " U R*                  5      (       a  [%        U R*                  US9$ [        S	U -  5      e[        S	U -  5      e)
zêReturn the argument signature for any callable.

All pure-Python callables are accepted, including
functions, methods, classes, objects with __call__;
builtins and other edge cases like functools.partial() objects
raise a TypeError.

zCan't inspect builtin: %sr   NT)Úno_selfÚ_is_initÚ__func__Ú__call__)r  zCan't inspect callable: %s)r­   Ú	isbuiltinr  r®   r   r°   ÚFullArgSpecÚargsÚvarargsÚvarkwr£   Ú
kwonlyargsr¤   r   r¯   Ú__self__r  ÚisclassÚget_callable_argspecrÕ   rƒ   r  )rœ   r  r  r¾   s       r1   r   r   Ò  sâ  € ô ×Ò˜×ÑÜÐ3°bÑ8Ó9Ð9Ü	×	Ò	˜B×	Ñ	ÞžÜ×0Ò0°Ó4ˆDÜ×%Ò%Ø—	‘	˜!˜"�Ø—‘Ø—
‘
Ø—‘Ø—‘Ø×#Ñ#Ø× Ñ óð ô ×0Ò0°Ó4Ð4Ü	×	Ò	˜"×	Ñ	Þž B§K§KÜ×0Ò0°·±Ó=ˆDÜ×%Ò%Ø—	‘	˜!˜"�Ø—‘Ø—
‘
Ø—‘Ø—‘Ø×#Ñ#Ø× Ñ óð ô ×0Ò0°·±Ó=Ð=Ü	�Š˜×	Ñ	Ü#Ø�K‰K °4ñ
ð 	
ô 
��Z×	 Ñ	 Ü×,Ò,¨R¯[©[Ó9Ð9Ü	��Z×	 Ñ	 Ü×Ò˜BŸK™K×(Ñ(Ü'¨¯©¸WÑEÐEäÐ8¸2Ñ=Ó>Ð>äÐ4°rÑ9Ó:Ð:r3   c           
     ó>  • [        U 5      (       a  [        R                  " U 5      nOU n[        R                  " U6 n[        R                  " US   US   US   SUS   5      nUS   (       a2  US   S   n[        R                  " US   SS US   US   SUS   5      nOUS   (       a  SUS   -  nUnOSnUnSnUS   (       a&  U[	        [        [        [           US   5      5      -  nUS   (       a  U[	        US   5      -  nUS   US   -   nU(       a	  USU-
  S n	OSn	[        R                  " UUS   US   U	S	 S
9n
US   (       a#  [        R                  " USS US   US   U	S S
9nOU
nU(       a  [        UUUU
UUS9$ [        UUUSS U
SS USS USS S9$ )a¤  Returns a dictionary of formatted, introspected function arguments.

A enhanced variant of inspect.formatargspec to support code generation.

fn
   An inspectable callable or tuple of inspect getargspec() results.
grouped
  Defaults to True; include (parens, around, argument) lists

Returns:

args
  Full inspect.formatargspec for fn
self_arg
  The name of the first positional argument, varargs[0], or None
  if the function defines no positional arguments.
apply_pos
  args, re-written in calling rather than receiving syntax.  Arguments are
  passed positionally.
apply_kw
  Like apply_pos, except keyword-ish args are passed as keywords.
apply_pos_proxied
  Like apply_pos but omits the self/cls argument

Example::

  >>> format_argspec_plus(lambda self, a, b, c=3, **d: 123)
  {'grouped_args': '(self, a, b, c=3, **d)',
   'self_arg': 'self',
   'apply_kw': '(self, a, b, c=c, **d)',
   'apply_pos': '(self, a, b, c, **d)'}

r   r   r   Né   z%s[0]r¥   rU   c                ó   • S[        U 5      -   $ ©NÚ=r‹   ©r/   s    r1   rŽ   Ú%format_argspec_plus.<locals>.<lambda>]  s   € ˜c¤C¨£Fšlr3   )Úformatvaluec                ó   • S[        U 5      -   $ r$  r‹   r&  s    r1   rŽ   r'  f  s   €  #¬¨A«¢,r3   )Úgrouped_argsÚself_argÚ	apply_posÚapply_kwÚapply_pos_proxiedÚapply_kw_proxiedéÿÿÿÿ)	Úcallabler   r°   Úinspect_formatargspecr±   r	   r   r   r²   )rœ   r¨   r¾   r  r,  r+  r.  Únum_defaultsÚ	name_argsÚdefaulted_valsr-  r/  s               r1   rµ   rµ   
  s  € ôH �‡|�|Ü×,Ò,¨RÓ0‰àˆä×'Ò'¨Ð.€Dä×,Ò,ØˆQ‰��a‘˜$˜q™' 4¨¨a©ó€Ið ˆA‡wØ˜‘7˜1‘:ˆä"×8Ò8Ø�‰G�A�BˆK˜˜a™ $ q¡'¨4°°a±ó
Ñð 
ˆa�à˜T !™WÑ$ˆà%ÑàˆØ%Ðà€LØˆA‡wØœœD¤¤s¡¨T°!©WÓ5Ó6Ñ6ˆØˆA‡wØœ˜D ™G›Ñ$ˆà�Q‘˜$˜q™'Ñ!€Iö Ø" 1 |Ñ#3Ð#5Ð6‰àˆä×+Ò+ØØˆQ‰ØˆQ‰ØÙ*ñ€Hð ˆA‡wÜ!×7Ò7Ø�a�bˆMØ�‰GØ�‰GØÙ.ñ
Ñð $ÐæÜØØØØØ/Ø-ñ
ð 	
ô ØØØ  "�oØ˜a �^Ø/°°"Ð5Ø-¨a°Ð3ñ
ð 	
r3   c           	     óÚ   • U [         R                  L a  SnU(       a  SOSnU(       a  SOSnO
 [        XS9$ [	        SUUUUUS
9$ ! [         a    SnU(       a  UOSnU(       a  SOS	n N2f = f)a  format_argspec_plus with considerations for typical __init__ methods

Wraps format_argspec_plus with error handling strategies for typical
__init__ cases:

.. sourcecode:: text

  object.__init__ -> (self)
  other unreflectable (usually C) -> (self, *args, **kwargs)

z(self)r=   z()r«   r§   z(self, *args, **kwargs)zself, *args, **kwargsz(*args, **kwargs)z*args, **kwargs)r+  r*  r,  r-  r.  r/  )ÚobjectrÕ   rµ   r  r²   )Úmethodr¨   r*  r  Úproxieds        r1   Úformat_argspec_initr:    s†   € ð ”—‘Ò ØˆÞ"‰x¨ˆÞ!‘$ r‰ð	LÜ& vÑ?Ð?ô
 ØØ!ØØØ!Ø ñð øô	 ó 	LØ4ˆLÞ#*‘<Ð0GˆDÞ-4Ñ)Ð:KŠGð	Lús   ®A Á"A*Á)A*c                ó   • S nU$ )a;  A class decorator indicating attributes should refer to a proxy
class.

This decorator is now a "marker" that does nothing at runtime.  Instead,
it is consumed by the tools/generate_proxy_methods.py script to
statically generate proxy methods and attributes that are fully
recognized by typing tools such as mypy.

c                ó   • U $ r9   rU   )r\   s    r1   rÈ   Ú&create_proxy_methods.<locals>.decorate³  s   € Øˆ
r3   rU   )Ú
target_clsÚtarget_cls_sphinx_nameÚproxy_cls_sphinx_nameÚclassmethodsÚmethodsÚ
attributesÚuse_intermediate_variablerÈ   s           r1   Úcreate_proxy_methodsrE     s   € ò&ð €Or3   c                ó–   •  [         R                  " U 5      $ ! [         a&    U [        R                  L a	  S/SSS4s $ S/SSS4s $ f = f)zÿinspect.getargspec with considerations for typical __init__ methods

Wraps inspect.getargspec with error handling for typical __init__ cases:

.. sourcecode:: text

  object.__init__ -> (self)
  other unreflectable (usually C) -> (self, *args, **kwargs)

r=   Nr  Úkwargs)r   r°   r  r7  rÕ   )r8  s    r1   Úgetargspec_initrH  ¹  sU   € ð6Ü×,Ò,¨VÓ4Ð4øÜó 6Ø”V—_‘_Ò$Ø�H˜d D¨$Ð/Ò/à�H˜f h°Ð5Ò5ð	6ús   ‚ ˜$A¾AÁAc                ó~   • [        U [        R                  5      (       a  U R                  (       d  U R                  $ U $ )zKAdjust the incoming callable such that a 'self' argument is not
required.

)ra   r¸   Ú
MethodTyper  r  )Úfunc_or_clss    r1   Úunbound_method_to_callablerL  Í  s1   € ô �+œu×/Ñ/×0Ñ0¸×9M×9MØ×#Ñ#Ð#àÐr3   c           	     ó$  ^ • Uc  T /nO[         R                  " U5      n[        5       n/ n[         R                  " 5       nSn[	        U5       GHO  u  p‰ [
        R                  " U	R                  5      n
U
R                  (       a  [        U
R                  5      OSnUS:X  ac  U
R                  (       a  U
R                  nU(       a   UR                  U
R                  SU*  5        OPUR                  U
R                  SS 5        O1UR                  U
R                  SU*   Vs/ s H  oÌU4PM     sn5        U(       a_  U
R                  (       d   eUR                  [        U
R                  U* S U
R                  5       VVs/ s H  u  pÍXÍ4PM
     snn5        GMO  GMR     / nUR                  U 4S jU 5       5        UbF  [!        T U5      (       a5  UR                  [#        T U5       Vs/ s H  n[%        U5      PM     sn5        UR'                  5        H@  u  nnXÃ;   a  M   [#        T XÄ5      nXôLa"  UU:w  a  UR)                  U< SU< 35        M>  M@  MB     U(       a?  U H9  u  nn [#        T XÄ5      nXôLa"  UU:w  a  UR)                  U< SU< 35        M7  M9  M;     T R,                  R.                  < SSR1                  U5      < S3$ s  snf s  snnf ! [         a     GMš  f = fs  snf ! [*         a     Mæ  f = f! [*         a     Mª  f = f)	zuProduce a __repr__() based on direct association of the __init__()
specification vs. same-named attributes present.

Nr   r   c              3  óP   >#   • U  H  n[        [        TUS 5      5      v •  M     g 7fr9   )r·   rw   )ri   ÚargÚobjs     €r1   rk   Úgeneric_repr.<locals>.<genexpr>  s"   øé € ÐDº8°C”$”w˜s C¨Ó.×/Ð/º8ùs   ƒ#&r%  Ú(ú, Ú))r   Úto_listr7  ÚOrderedDictÚ	enumerater   r°   rÕ   r£   r±   r  rZ   r  r,   Úzipr  rƒ   rw   r·   Úitemsr„   rb   rv   rM   rm   )rP  Úadditional_kwÚ
to_inspectÚ
omit_kwargÚmissingÚpos_argsÚkw_argsÚvargsrŒ   Úinspr¾   Údefault_lenrO  ÚdefaultÚoutputÚvalÚdefvals   `                r1   Úgeneric_reprrg  Ù  s¸  ø€ ð ÑØ�U‰
ä!×)Ò)¨*Ó5ˆ
ä‹h€Gà€HÜ2>×2JÒ2JÓ2L€GØ€EÜ˜Z×(‰ˆð	Ü×0Ò0°·±Ó?ˆDð 15··œ#˜dŸm™mÔ,À1ˆKØ�A‹vØ—<—<Ø ŸL™L�EÞØ—O‘O D§I¡I¨a°°Ð$=Õ>à—O‘O D§I¡I¨a¨b MÕ2à—‘Ø/3¯y©y¸¸K¸<Ñ/HÓIÒ/H¨˜7“^Ñ/HÑIôö Ø—}—}Ð$�}Ø—‘ô -0Ø ŸI™I { l mÐ4°d·m±mô-ôò-™L˜Cð ›ñ-ò÷ò ñ' )ð: €Fà
‡M�MÔD¹8ÓDÔDàÑœW S¨%×0Ñ0Ø�‰¬G°C¸Ô,?Ó@Ò,? S”t˜C–yÑ,?Ñ@ÔAà—}‘}–‰ˆˆVØÓÙð	Ü˜#˜sÓ,ˆCØÒ! c¨V£mØ—‘«ªcÐ2Ö3ñ '4Ñ!ñ 'ö Û(‰KˆC�ðÜ˜c 3Ó0�ØÒ%¨#°«-Ø—M‘M«S²#Ð"6Ö7ñ +8Ñ%ñ )ð —}‘}×-Ô-¨t¯y©y¸Ö/@ÐAÐAùòO Jùóøô' ó 	Ûð	üò> Aøô ó 	Úð	ûô ó ÚðúsH   Á KÄ"K
ÆKÇ+K+È%.K0É+.LË
K(Ë'K(Ë0
K>Ë=K>Ì
LÌLc                  ó8   • \ rS rSrSrSrS rS rS
S jrS r	Sr
g	)Úportable_instancemethodi'  zWTurn an instancemethod into a (parent, name) pair
to produce a serializable callable.

)r¦   rq   rG  Ú__weakref__c                óJ   • U R                   U R                  U R                  S.$ )N©r¦   rq   rG  rl  r<   s    r1   Ú__getstate__Ú$portable_instancemethod.__getstate__/  s!   € à—k‘kØ—I‘IØ—k‘kñ
ð 	
r3   c                óZ   • US   U l         US   U l        UR                  SS5      U l        g )Nr¦   rq   rG  rU   )r¦   rq   r  rG  )r=   Ústates     r1   Ú__setstate__Ú$portable_instancemethod.__setstate__6  s*   € Ø˜H‘oˆŒØ˜&‘MˆŒ	Ø—i‘i ¨"Ó-ˆ�r3   c                óT   • UR                   U l        UR                  U l        X l        g r9   )r  r¦   rM   rq   rG  )r=   ÚmethrG  s      r1   rÕ   Ú portable_instancemethod.__init__;  s   € Ø—m‘mˆŒØ—M‘MˆŒ	Ø�r3   c                ó„   • UR                  U R                  5        [        U R                  U R                  5      " U0 UD6$ r9   )r,   rG  rw   r¦   rq   )r=   rO  Úkws      r1   r  Ú portable_instancemethod.__call__@  s1   € Ø
�	‰	�$—+‘+ÔÜ�t—{‘{ D§I¡IÔ.°Ð:°rÑ:Ð:r3   )rG  rq   r¦   N)rU   )rM   rN   rO   rP   rQ   rR   rm  rq  rÕ   r  rT   rU   r3   r1   ri  ri  '  s"   † ñð
 :€Iò
ò.ô
õ
;r3   ri  c                óL  ^• U 1m[        U R                  5      nU(       aõ  UR                  5       nU4S jUR                   5       nU H%  nUR	                  U5        TR                  U5        M'     UR                  S:X  d  [        US5      (       d  M{  [        U[        5      (       d  UR                  5       OUR                  U5       Vs/ s H  nUT;  d  M  UPM     sn H%  nUR	                  U5        TR                  U5        M'     U(       a  Mõ  [        T5      $ s  snf )a  Return an unordered sequence of all classes related to cls.

Traverses diamond hierarchies.

Fibs slightly: subclasses of builtin types are not returned.  Thus
class_hierarchy(class A(object)) returns (A, object), not A plus every
class systemwide that derives from object.

c              3  ó6   >#   • U  H  oT;  d  M
  Uv •  M     g 7fr9   rU   )ri   Ú_Úhiers     €r1   rk   Ú"class_hierarchy.<locals>.<genexpr>T  s   øé € Ð9šK�q°D©=—‘šKùs   ƒ	�	Úbuiltinsr[   )rö   Ú__mro__rX   r	  r„   rY   rN   rƒ   Ú
issubclassru   r[   )r\   Úprocessr  r–   r�   r{  Úsr|  s          @r1   Úclass_hierarchyrƒ  E  s  ø€ ð ˆ5€DÜ�3—;‘;Ó€GÞ
Ø�K‰K‹MˆÜ9˜AŸKšKÓ9ˆãˆAØ�N‰N˜1ÔØ�H‰H�QŽKñ ð �<‰<˜:Ó%¬W°QÐ8H×-IÑ-IÙô " !¤T×*Ñ*ð × Ñ Ô"à×%Ñ% aÓ(ð)ó
ò)ð ð
 ˜‰}÷ ñ)ô
ˆAð �N‰N˜1ÔØ�H‰H�QŽKñ
÷ ˆ'ô, �‹:Ðùò
s   Ã
D!ÃD!c              #  ó¢   #   • [        U 5      nU H:  nU R                   H'  nX#R                  ;   d  M  X#R                  U   4v •    M8     M<     g7f)z½iterate all the keys and attributes associated
with a class, without using getattr().

Does not use getattr() so that class-sensitive
descriptors (i.e. property.__get__()) are not called.

N)Údirr  r  )r\   ÚkeysÚkeyr  s       r1   Úiterate_attributesrˆ  k  sF   é € ô ˆs‹8€DÛˆØ—”ˆAØ—j‘jÕ ØŸJ™J s™OÐ,Ò,Úó ò ùs
   ‚-A³Ac                ó6  • U(       a  UnOiUc  Sn[        U5       Vs/ s HN  nUR                  S5      (       d  M  UR                  S5      (       d  M3  [        X5      (       a  ME  Xr;  d  ML  UPMP     nnU Hæ  n [	        X5      n	[        U	S5      (       d  M"  [	        U	SU	5      n	[        [        R                  U	5      n
 [        R                  " U
5      n[        R                  " US   5      n[        R                  " US   SS 5      nS
[        5       -  nUSL=(       a    XE0=(       d    0 n[        Xï5         U
R                  Xø   l        [!        XXø   5        Mè     gs  snf ! [         a     Mý  f = f! [         a    SnS	n N|f = f! [         a     NIf = f)z9Automates delegation of __specials__ for a proxying type.N)rR   Ú__del__Ú__getattribute__Ú__metaclass__rm  rq  r¬   r  r  r   r   z(self, *args, **kw)z(*args, **kw)z?def %(method)s%(fn_args)s: return %(name)s.%(method)s%(d_args)s)r…  Ú
startswithÚendswithrƒ   rw   r	   r¸   r¹   rú   r   r°   r2  r  ÚlocalsrÌ   r»   Úsetattr)Úinto_clsÚfrom_clsÚskipÚonlyrq   Úfrom_instanceÚdundersr0   r8  Úmaybe_fnrœ   r¾   Úfn_argsÚd_argsÚpyrÆ   s                   r1   Úmonkeypatch_proxied_specialsr›  {  s¦  € ö Ø‰à‰<ðˆDô ˜”]ó	
â"�à—‘˜T×"ó ð —J‘J˜t×$ó	 ô
   ×,ó ð ‘M÷ Ù"ð 	ð 	
ó ˆð	Ü˜xÓ0ˆHÜ˜8 Z×0Ñ0ÙÜ˜x¨°XÓ>ˆHÜ”e×(Ñ(¨(Ó3ˆBð	%Ü×0Ò0°Ó4ˆDÜ×2Ò2°4¸±7Ó;ˆGÜ×1Ò1°$°q±'¸!¸"°+Ó>ˆFð3Ü5;³Xñ>ð 	ð  Ð%×?¨4Ð*?×EÀ2ð 	ô 	ˆRŒð	Ø')§¡ˆC‰KÔ$ô 	� #¡+Ö.ò? ùò	
øô& ó 	Úð	ûô ó 	%Ø+ˆGØ$ŠFð	%ûô ó 	Ùð	úsY   �E!»E!ÁE!Á%E!Á,E!Á:E&Â'E&Ã AE7Ä;FÅ&
E4Å3E4Å7FÆFÆ
FÆFc                ó6   • [        U SU 5      [        USU5      L $ )z;Return True if the two methods are the same implementation.r  )rw   )Úmeth1Úmeth2s     r1   Úmethods_equivalentrŸ  ¾  s(   € ô �5˜* eÓ,´Øˆz˜5ó1ð ð r3   c           	     ó|  • U(       d  U(       d  [        S5      e[        U[        5      (       a  [        X5      (       a  U $ [        U=(       d3    [	        U5       Vs/ s H  oDR                  S5      (       a  M  UPM     sn5      n[        [	        U 5      5      n[        R                  n[        U[        5      (       a  UnO-U(       d  [        5       n[        R                  nO[        U5      nU" UR                  U5      U5      (       a  U $ [        U [        5      (       dI  U[        R                  L =(       a    S=(       d    Sn[        U < SU< SSR                  U5      < 35      e " S S	5      n	U(       a  S
UR                  -   U	l        [        5       n
[        U 5       Ha  u  p¼Xµ;  a  [        SU-  5      e[        U5      (       d  [        U< SU< S35      e[        X›[!        U5      5        U
R#                  U5        Mc     U" X£5      (       a  U	$ [        SSR                  X:-
  5      -  5      es  snf )a*  Ensure basic interface compliance for an instance or dict of callables.

Checks that ``obj`` implements public methods of ``cls`` or has members
listed in ``methods``. If ``required`` is not supplied, implementing at
least one interface method is sufficient. Methods present on ``obj`` that
are not in the interface are ignored.

If ``obj`` is a dict and ``dict`` does not meet the interface
requirements, the keys of the dictionary are inspected. Keys present in
``obj`` that are not in the interface will raise TypeErrors.

Raises TypeError if ``obj`` does not meet the interface criteria.

In all passing cases, an object with callable members is returned.  In the
simple case, ``obj`` is returned as-is; if dict processing kicks in then
an anonymous class is returned.

obj
  A type, instance, or dictionary of callables.
cls
  Optional, a type.  All public methods of cls are considered the
  interface.  An ``obj`` instance of cls will always pass, ignoring
  ``required``..
methods
  Optional, a sequence of method names to consider as the interface.
required
  Optional, a sequence of mandatory implementations. If omitted, an
  ``obj`` that provides at least one interface method is considered
  sufficient.  As a convenience, required may be a type, in which case
  all public methods of the type are required.

z2a class or collection of method names are requiredr{  zany ofzall ofz does not implement z: rS  c                  ó   • \ rS rSrSrSrg)Ú(as_interface.<locals>.AnonymousInterfacei  zA callable-holding shell.rU   N©rM   rN   rO   rP   rQ   rT   rU   r3   r1   ÚAnonymousInterfacer¢    s   † Ü'r3   r¤  Ú	Anonymousz%r: unknown in this interfacer%  z is not callablez,dictionary does not contain required keys %s)r  ra   ru   rW   r…  r�  ÚoperatorÚgeÚgtÚintersectionr²   rm   rM   Údictlike_iteritemsr1  r�  ÚstaticmethodrY   )rP  r\   rB  Úrequiredr0   Ú	interfaceÚimplementedÚcompliesÚ	qualifierr¤  Úfoundr8  rà   s                r1   Úas_interfacer²  Æ  sÊ  € öB –wÜÐLÓMÐMä�#”t×Ñ¤¨C×!5Ñ!5Øˆ
ä�G×M¬3¨s¬8ÓMª8 a¿<¹<È×;L§©8ÑMÓN€IÜ”c˜#“h“-€Kä�{‰{€HÜ�(œD×!Ñ!Ø‰ÞÜ“5ˆÜ—;‘;‰ä�x“=ˆá�×(Ñ(¨Ó3°X×>Ñ>Øˆ
ô �cœ4× Ñ Ø¤§¡Ð+×8°×D¸Hˆ	Üã“I˜tŸy™y¨Õ3ð5ó
ð 	
÷
(ñ (ö Ø&1°C·L±LÑ&@ÐÔ#Ü‹E€Eä*¨3Ö/‰ˆØÓ"ÜÐ;¸fÑDÓEÐEÜ˜�~‰~Ü³v»tÐDÓEÐEÜÐ"¬L¸Ó,>Ô?Ø�	‰	�&Öñ 0ñ �× Ñ Ø!Ð!ä
Ø6Ø
�)‰)�HÑ$Ó
%ñ	&óð ùòS  Ns   ÁH9Á9H9Ú_GFDzgeneric_fn_descriptor[Any]c                  ó¸   • \ rS rSr% SrS\S'   S\S'   S\S'   SSS
 jjr\SS j5       r\SS j5       rSS jr\	(       a
  SS jr
SS jrSS jr\SS j5       rSrg	)Úgeneric_fn_descriptori  aO  Descriptor which proxies a function when the attribute is not
present in dict

This superclass is organized in a particular way with "memoized" and
"non-memoized" implementation classes that are hidden from type checkers,
as Mypy seems to not be able to handle seeing multiple kinds of descriptor
classes used for the same attribute.

úCallable[..., _T_co]ÚfgetúOptional[str]rQ   r-   rM   Nc                óf   • Xl         U=(       d    UR                  U l        UR                  U l        g r9   ©r·  rQ   rM   ©r=   r·  Údocs      r1   rÕ   Úgeneric_fn_descriptor.__init__.  s"   € ØŒ	Ø×*˜dŸl™lˆŒØŸ™ˆ�r3   c                ó   • g r9   rU   ©r=   rP  r\   s      r1   Ú__get__Úgeneric_fn_descriptor.__get__3  s   € Ø:=r3   c                ó   • g r9   rU   r¿  s      r1   rÀ  rÁ  6  s   € Ø7:r3   c                ó   • [        5       er9   ©ÚNotImplementedErrorr¿  s      r1   rÀ  rÁ  9  ó   € Ü!Ó#Ð#r3   c                ó   • g r9   rU   ©r=   ÚinstancerC   s      r1   Ú__set__Úgeneric_fn_descriptor.__set__>  s   € ¸cr3   c                ó   • g r9   rU   )r=   rÉ  s     r1   Ú
__delete__Ú generic_fn_descriptor.__delete__@  s   € °Sr3   c                ó   • [        5       er9   rÄ  ©r=   rP  s     r1   Ú_resetÚgeneric_fn_descriptor._resetB  rÆ  r3   c                ó   • [        5       er9   rÄ  ©r\   rP  rq   s      r1   ÚresetÚgeneric_fn_descriptor.resetE  s   € ä!Ó#Ð#r3   ©rQ   rM   r·  r9   )r·  r¶  r¼  r¸  )r=   r³  rP  rL   r\   r   rK   r³  )rP  r7  r\   r   rK   r!   )r=   r³  rP  r   r\   r   rK   zUnion[_GFD, _T_co]©rÉ  r   rC   r   rK   rL   ©rÉ  r   rK   rL   )rP  r   rK   rL   )rP  r   rq   r-   rK   rL   )rM   rN   rO   rP   rQ   rS   rÕ   r   rÀ  r   rÊ  rÍ  rÑ  ÚclassmethodrÕ  rT   rU   r3   r1   rµ  rµ    sf   ‡ ñð ÓØÓØƒMö&ð
 Û=ó Ø=àÛ:ó Ø:ô$ö äAä8ô$ð ó$ó ó$r3   rµ  c                  ó2   • \ rS rSrSr\(       d  S rSrgSrg)Ú_non_memoized_propertyiJ  z¹a plain descriptor that proxies a function.

primary rationale is to provide a plain attribute that's
compatible with memoized_property which is also recognized as equivalent
by mypy.

c                ó.   • Uc  U $ U R                  U5      $ r9   ©r·  r¿  s      r1   rÀ  Ú_non_memoized_property.__get__U  s   € Ø‰{Ø�Ø—9‘9˜S“>Ð!r3   rU   N)rM   rN   rO   rP   rQ   r   rÀ  rT   rU   r3   r1   rÜ  rÜ  J  s   † ñö õ	"ò r3   rÜ  c                  óB   • \ rS rSrSr\(       d  S rS r\S 5       r	Sr
g)Ú_memoized_propertyi[  z2A read-only @property that is only evaluated once.c                ód   • Uc  U $ U R                  U5      =UR                  U R                  '   nU$ r9   )r·  r  rM   ©r=   rP  r\   Úresults       r1   rÀ  Ú_memoized_property.__get__`  s0   € Ø‰{Ø�Ø37·9±9¸S³>ÐAˆC�L‰L˜Ÿ™Ñ'¨&ØˆMr3   c                óB   • [         R                  XR                  5        g r9   )rá  rÕ  rM   rÐ  s     r1   rÑ  Ú_memoized_property._resetf  s   € Ü× Ñ  §m¡mÕ4r3   c                ó<   • UR                   R                  US 5        g r9   )r  rX   rÔ  s      r1   rÕ  Ú_memoized_property.reseti  s   € à�‰×Ñ˜˜tÕ$r3   rU   N)rM   rN   rO   rP   rQ   r   rÀ  rÑ  rÚ  rÕ  rT   rU   r3   r1   rá  rá  [  s&   † Ù<æò	ò5ð ñ%ó ó%r3   rá  c                ó(   ^ • U 4S jn[        UT 5      $ )zÐDecorate a method memoize its return value.

Best applied to no-arg methods: memoization is not sensitive to
argument values, and will always return the same value even when
called with different arguments.

c                ó¢   >^• T" U /UQ70 UD6mU4S jnTR                   Ul         TR                  Ul        X0R                  TR                   '   T$ )Nc                 ó   >• T$ r9   rU   ©Úarw  rä  s     €r1   ÚmemoÚ6memoized_instancemethod.<locals>.oneshot.<locals>.memo–  s   ø€ ØˆMr3   )rM   rQ   r  ©r=   r  rw  rï  rä  rœ   s       @€r1   ÚoneshotÚ(memoized_instancemethod.<locals>.oneshot“  sI   ù€ Ù�DÐ&˜4Ò& 2Ñ&ˆõ	ð Ÿ™ˆŒØ—z‘zˆŒØ%)�‰�b—k‘kÑ"Øˆr3   r   )rœ   rò  s   ` r1   Úmemoized_instancemethodrô  Š  s   ø€ õ	ô ˜' 2Ó&Ð&r3   c                  ó’   • \ rS rSr% Sr\(       d  Sr\" 5       rS\	S'   SS jr
SS jrSS jr " S	 S
\\   5      r\SS j5       rSrg)ÚHasMemoizedi¡  zwA mixin class that maintains the names of memoized elements in a
collection for easy cache clearing, generative, etc.

rU   zFrozenSet[str]Ú_memoized_keysc                ób   • U R                    H  nU R                  R                  US 5        M!     g r9   )r÷  r  rX   ©r=   Úelems     r1   Ú_reset_memoizationsÚHasMemoized._reset_memoizations®  s&   € Ø×'Ô'ˆDØ�M‰M×Ñ˜d DÖ)ò (r3   c                óL   • U R                    H  nXR                  ;  a  M   e   g r9   )r÷  r  rù  s     r1   Ú_assert_no_memoizationsÚ#HasMemoized._assert_no_memoizations²  s"   € Ø×'Ô'ˆDØŸ}™}Õ,Ð,Ð,ò (r3   c                óL   • X R                   U'   U =R                  U1-  sl        g r9   )r  r÷  )r=   r‡  rC   s      r1   Ú_set_memoized_attributeÚ#HasMemoized._set_memoized_attribute¶  s!   € Ø"�‰�cÑØ×Ò ˜uÑ$Ör3   c                  ót   • \ rS rSr% SrS\S'   S\S'   S\S'   SSS
 jjr\SS j5       r\SS j5       rS rSr	g	)ÚHasMemoized.memoized_attributeiº  zDA read-only @property that is only evaluated once.

:meta private:

úCallable[..., _T]r·  r¸  rQ   r-   rM   Nc                óf   • Xl         U=(       d    UR                  U l        UR                  U l        g r9   rº  r»  s      r1   rÕ   Ú'HasMemoized.memoized_attribute.__init__Å  s"   € ØŒIØ×. $§,¡,ˆDŒLØ ŸM™MˆD�Mr3   c                ó   • g r9   rU   r¿  s      r1   rÀ  Ú&HasMemoized.memoized_attribute.__get__Ê  s   € Ø<?r3   c                ó   • g r9   rU   r¿  s      r1   rÀ  r	  Í  s   € Ø58r3   c                ó¤   • Uc  U $ U R                  U5      =UR                  U R                  '   nU=R                  U R                  1-  sl        U$ r9   )r·  r  rM   r÷  rã  s       r1   rÀ  r	  Ð  sG   € Ø‰{Ø�Ø37·9±9¸S³>ÐAˆC�L‰L˜Ÿ™Ñ'¨&Ø×Ò 4§=¡= /Ñ1ÕØˆMr3   r×  r9   )r·  r  r¼  r¸  )r=   r&   rP  rL   r\   r   rK   r&   )rP  r   r\   r   rK   r    )
rM   rN   rO   rP   rQ   rS   rÕ   r   rÀ  rT   rU   r3   r1   Úmemoized_attributer  º  sB   ‡ ñ	ð  ÓØÓØ‹ö	*ð
 
Û?ó 
Ø?à	Û8ó 
Ø8õ	r3   r  c                ó,   ^• SU4S jjn[        UT5      $ )z=Decorate a method memoize its return value.

:meta private:

c                óâ   >^• T" U /UQ70 UD6mU4S jnTR                   Ul         TR                  Ul        X0R                  TR                   '   U =R                  TR                   1-  sl        T$ )Nc                 ó   >• T$ r9   rU   rí  s     €r1   rï  ÚBHasMemoized.memoized_instancemethod.<locals>.oneshot.<locals>.memoâ  s   ø€ Ø�r3   )rM   rQ   r  r÷  rñ  s       @€r1   rò  Ú4HasMemoized.memoized_instancemethod.<locals>.oneshotß  s`   ù€ Ù˜Ð*˜tÒ* rÑ*ˆFõð ŸK™KˆDŒMØŸ:™:ˆDŒLØ)-�M‰M˜"Ÿ+™+Ñ&Ø×Ò B§K¡K =Ñ0ÕØˆMr3   )r=   r   r  r   rw  r   rK   r   r   )r\   rœ   rò  s    ` r1   rô  Ú#HasMemoized.memoized_instancemethod×  s   ø€ ÷
	ô ˜g rÓ*Ð*r3   NrJ   )r‡  r-   rC   r   rK   rL   ©rœ   r#   rK   r#   )rM   rN   rO   rP   rQ   r   rR   Ú	frozensetr÷  rS   rû  rþ  r  Úmemoized_propertyr    r  rÚ  rô  rT   rU   r3   r1   rö  rö  ¡  sT   ‡ ñö
 ð ˆ	á%.£[€N�NÓ0ô*ô-ô%ôÐ.¨rÑ2ô ð: ó+ó ó+r3   rö  c                  ó,   • \ rS rSrSrSrS rSS jrSrg)ÚMemoizedSlotsiô  a@  Apply memoized items to an object using a __getattr__ scheme.

This allows the functionality of memoized_property and
memoized_instancemethod to be available to a class using __slots__.

The memoized get is not threadsafe under freethreading and the
creator method may in extremely rare cases be called more than once.

rU   c                ó   • [        U5      er9   )rú   )r=   r‡  s     r1   Ú_fallback_getattrÚMemoizedSlots._fallback_getattr  s   € Ü˜SÓ!Ð!r3   c                óª  ^ ^^• TR                  S5      (       d  TR                  S5      (       a  [        T5      e[        T R                  ST 35      (       a#  [	        T ST 35      " 5       n[        T TU5        U$ [        T R                  ST 35      (       a*  [	        T ST 35      mUUU 4S jnTR                  Ul        U$ T R                  T5      $ )NÚ_memoized_attr_Ú_memoized_method_c                 ó„   >^• T" U 0 UD6mU4S jnTR                   Ul         TR                  Ul        [        TTU5        T$ )Nc                 ó   >• T$ r9   rU   rí  s     €r1   rï  Ú8MemoizedSlots.__getattr__.<locals>.oneshot.<locals>.memo  s   ø€ Ø!�Mr3   )rM   rQ   r�  )r  rw  rï  rä  r‡  rt  r=   s      @€€€r1   rò  Ú*MemoizedSlots.__getattr__.<locals>.oneshot  s@   ù€ Ù˜tÐ* rÑ*�õ"ð !%§¡�”Ø#Ÿ|™|�”Ü˜˜c 4Ô(Ø�r3   )r�  rú   rƒ   rv   rw   r�  rQ   r  )r=   r‡  rC   rò  rt  s   ``  @r1   Ú__getattr__ÚMemoizedSlots.__getattr__  sÉ   ú€ Ø�>‰>Ð+×,Ñ,°·±Ø÷1
ñ 1
ô ! Ó%Ð%ô �T—^‘^ °s°eÐ%<×=Ñ=Ü˜D O°C°5Ð"9Ô:Ó<ˆEÜ�D˜#˜uÔ%ØˆLÜ�T—^‘^Ð'8¸¸Ð%>×?Ñ?Ü˜4Ð#4°S°EÐ!:Ó;ˆD÷	ð #Ÿl™lˆGŒOØˆNà×)Ñ)¨#Ó.Ð.r3   N)r‡  r-   rK   r   )	rM   rN   rO   rP   rQ   rR   r  r"  rT   rU   r3   r1   r  r  ô  s   † ñð €Iò"÷/r3   r  c                ó¶   • [        U [        5      (       a:  U R                  5       R                  5       n U S;   a  gU S;   a  g[	        SU -  5      e[        U 5      $ )N)ÚtrueÚyesÚonÚyÚtÚ1T)ÚfalseÚnoÚoffrj   ÚfÚ0FzString is not true/false: %r)ra   r-   Ústriprh   Ú
ValueErrorrø   )rP  s    r1   Úasboolr2  %  sV   € Ü�#”s×ÑØ�i‰i‹k×ÑÓ!ˆØÐ6Ó6ØØÐ9Ó9ØäÐ;¸cÑAÓBÐBÜ�‹9Ðr3   c                 ó   ^ • SU 4S jjnU$ )ziReturn a callable that will evaluate a string as
boolean, or one of a set of "alternate" string values.

c                ó*   >• U T;   a  U $ [        U 5      $ r9   )r2  )rP  Útexts    €r1   Úbool_or_valueÚ"bool_or_str.<locals>.bool_or_value7  s   ø€ Ø�$‹;ØˆJä˜#“;Ðr3   )rP  r-   rK   zUnion[str, bool]rU   )r5  r6  s   ` r1   Úbool_or_strr8  1  s   ø€ ÷ð Ðr3   c                ó"   • U c  U $ [        U 5      $ )zCoerce to integer.)Úint)rC   s    r1   Úasintr;  @  s   € ð �}ØˆÜˆu‹:Ðr3   c                óÐ   • Uc  U nX;   a\  [        U[        5      (       a  [        X   U5      (       d3  X   b-  U[        L a  U(       a  [        X   5      XA'   gU" X   5      XA'   gggg)z©If 'key' is present in dict 'kw', coerce its value to type 'type\_' if
necessary.  If 'flexi_bool' is True, the string '0' is considered false
when coercing to boolean.
N)ra   ru   rø   r2  )rw  r‡  rB   Ú
flexi_boolÚdests        r1   Úcoerce_kw_typer?  H  sk   € ð �|Øˆð 	‹	Ü˜E¤4×(Ñ(´
¸2¹7ÀE×0JÑ0JØ‰GÑà”DŠ=žZÜ˜r™w›ˆDŠIá˜b™g›ˆDŠIð  ð 1Kð 	r3   c                óL   ^ • [        U5      nU4[        U 4S jU 5       5      -   $ )zZProduce a tuple structure that is cacheable using the __dict__ of
obj to retrieve values

c              3  óh   >#   • U  H'  oTR                   ;   d  M  UTR                   U   4v •  M)     g 7fr9   ©r  ©ri   ÚkrP  s     €r1   rk   Ú"constructor_key.<locals>.<genexpr>h  s-   øé € ð Ú&+ °C·L±LÑ/@ÓˆˆC�L‰L˜‰OÕ¢eùó   ƒ2š2)r  r…   )rP  r\   rÁ   s   `  r1   Úconstructor_keyrG  b  s2   ø€ ô
 ˜3Ó€EØˆ6”Eô Ù&+óó ñ ð r3   c                ó~   ^ • [        U5      nUR                  U 4S jUR                  U5       5       5        U" U0 UD6$ )z|Instantiate cls using the __dict__ of obj as constructor arguments.

Uses inspect to match the named arguments of ``cls``.

c              3  óh   >#   • U  H'  oTR                   ;   d  M  UTR                   U   4v •  M)     g 7fr9   rB  rC  s     €r1   rk   Ú#constructor_copy.<locals>.<genexpr>u  s.   øé € ð Ú&: À3Ç<Á<Ñ>OÓˆˆC�L‰L˜‰OÕÒ&:ùrF  )r  r,   Ú
difference)rP  r\   r  rw  rÁ   s   `    r1   Úconstructor_copyrL  m  sE   ø€ ô ˜3Ó€EØ‡I�Iô Ø&+×&6Ñ&6°rÔ&:óô ñ �Ð˜ÑÐr3   c                 ón   ^^• [         R                  " 5       m[        R                  " S5      mUU4S jn U $ )z%Return a threadsafe counter function.r   c                 óT   >• T   [        T 5      sS S S 5        $ ! , (       d  f       g = fr9   )Únext)ÚcounterÚlocks   €€r1   Ú_nextÚcounter.<locals>._next‚  s   ø€ ÚÜ˜“=÷ �T�Tús   „™
')Ú	threadingÚLockr�   Úcount)rR  rP  rQ  s    @@r1   rP  rP  {  s+   ù€ ô �>Š>Ó€DÜ�oŠo˜aÓ €Gö!ð €Lr3   c                ó   • [        U S5      (       a>  U R                  b%  [        U R                  [        5      (       a  [        $ U R                  $ [	        U [
        5      (       a  [        O[        nU" U [        5      (       a  [        $ U" U [        5      (       a  [        $ U" U [        5      (       a  [        $ [        U S5      (       a  [        $ [        U S5      (       a  [        $ [        U S5      (       a  [        $ U$ )z¸Given an instance or class, guess if it is or is acting as one of
the basic collection types: list, set and dict.  If the __emulates__
property is present, return that preferentially.
Ú__emulates__r„   rY   rW   )rƒ   rX  r€  rW   ra   ru   rö   r²   )Úspecimenrc  Úisas      r1   Úduck_type_collectionr[  ‰  sË   € ô ˆx˜×(Ñ(à× Ñ Ñ,´Ø×!Ñ!¤3÷2
ñ 2
ô ˆJà×(Ñ(Ð(ä" 8¬T×2Ñ2�*¼
€CÙ
ˆ8”T×ÑÜˆÙ	ˆX”s×	Ñ	Üˆ
Ù	ˆX”t×	Ñ	Üˆäˆx˜×"Ñ"ÜˆÜ	�˜5×	!Ñ	!Üˆ
Ü	�˜5×	!Ñ	!Üˆàˆr3   c           
     ó,  • [        X5      (       a  U $ [        U[        5      (       aB  [        R                  " SU< SSR	                  S U 5       5      < S[        U 5      < S35      e[        R                  " SU< SU< S[        U 5      < S35      e)	Nz
Argument 'z ' is expected to be one of type z or c              3  ó,   #   • U  H
  nS U-  v •  M     g7f)z'%s'NrU   )ri   rî  s     r1   rk   Ú"assert_arg_type.<locals>.<genexpr>µ  s   é € Ð$Aº°A V¨a¦Zºùs   ‚z, got 'Ú'z' is expected to be of type 'z', got ')ra   r…   r   ÚArgumentErrorrm   ru   )rO  Úargtyperq   s      r1   Úassert_arg_typerb  ¬  sy   € ô �#×ÑØˆ
ä�gœu×%Ñ%Ü×#Ó#ã˜Ÿ™Ñ$A¹Ó$AÖAÄ4ÈÆ9ðNóð ô
 ×#Ó#ã›¤$ s¦)ð-óð r3   c           	     ón  ^ ^• [        T S5      (       a  [        T R                  5       5      $ [        T S[        T SS5      5      mTc  [	        ST -  5      e[        T S5      (       a  U U4S jnU" 5       $ [        T S5      (       a#  [        U4S	 jT R                  5        5       5      $ [	        ST -  5      e)
z?Return a (key, value) iterator for almost any dict-like object.rY  Ú__getitem__r  NzObject '%r' is not dict-likeÚiterkeysc               3  ó^   >#   • TR                  5        H  n Tc   eU T" U 5      4v •  M     g 7fr9   )re  )r‡  ÚdictlikeÚgetters    €€r1   ÚiteratorÚ$dictlike_iteritems.<locals>.iteratorÊ  s4   øé € Ø×(Ñ(Ö*�ØÑ)Ð)Ð)Ø™6 #›;Ð&Ô&ò +ùs   ƒ*-r†  c              3  ó6   >#   • U  H  oT" U5      4v •  M     g 7fr9   rU   )ri   r‡  rh  s     €r1   rk   Ú%dictlike_iteritems.<locals>.<genexpr>Ñ  s   øé € ÐB²/¨3™& ›+Õ&²/ùs   ƒ)rƒ   rö   rY  rw   r  Úiterr†  )rg  ri  rh  s   ` @r1   rª  rª  ¾  s¢   ù€ ô ˆx˜×!Ñ!Ü�H—N‘NÓ$Ó%Ð%ä�X˜}¬g°hÀÀtÓ.LÓM€FØ�~ÜÐ6¸ÑAÓBÐBäˆx˜×$Ñ$ö	'ñ
 ‹zÐÜ	�˜6×	"Ñ	"ÜÔB°(·-±-´/ÓBÓBÐBäÐ6¸ÑAÓBÐBr3   c                  óJ   ^ • \ rS rSr% SrS\S'   SU 4S jjrS	S
S jjrSrU =r	$ )ÚclasspropertyiÖ  a)  A decorator that behaves like @property except that operates
on classes rather than instances.

The decorator is currently special when using the declarative
module, but note that the
:class:`~.sqlalchemy.ext.declarative.declared_attr`
decorator should be used for this purpose with declarative.

úCallable[[Any], Any]r·  c                óP   >• [         TU ]  " U/UQ70 UD6  UR                  U l        g r9   )ÚsuperrÕ   rQ   )r=   r·  rO  rw  rv   s       €r1   rÕ   Úclassproperty.__init__ã  s%   ø€ Ü‰Ò˜Ð* Ò* rÒ*Ø—|‘|ˆ�r3   c                ó$   • U R                  U5      $ r9   rÞ  r¿  s      r1   rÀ  Úclassproperty.__get__ç  s   € Ø�y‰y˜‹~Ðr3   )rQ   )r·  rp  rO  r   rw  r   r9   )rP  r   r\   zOptional[type]rK   r   )
rM   rN   rO   rP   rQ   rS   rÕ   rÀ  rT   Ú__classcell__©rv   s   @r1   ro  ro  Ö  s   ø‡ ñð Ó÷$÷ô r3   ro  c                  ó2   • \ rS rSrSS jrSS jrS	S jrSrg)
Úhybridpropertyië  c                ó   • Xl         Xl        g r9   )r  Úclslevel©r=   r  s     r1   rÕ   Úhybridproperty.__init__ì  s   € ØŒ	Ø�r3   c                óP   • Uc  U R                  U5      nU$ U R                  U5      $ r9   ©r{  r  ©r=   rÉ  ÚownerÚclsvals       r1   rÀ  Úhybridproperty.__get__ð  ó*   € ØÑØ—]‘] 5Ó)ˆFØˆMà—9‘9˜XÓ&Ð&r3   c                ó   • Xl         U $ r9   ©r{  r|  s     r1   Ú
classlevelÚhybridproperty.classlevel÷  ó   € ØŒØˆr3   r  N©r  r  ©rÉ  r   r�  r   rK   r    )r  rs   rK   zhybridproperty[_T])rM   rN   rO   rP   rÕ   rÀ  r‡  rT   rU   r3   r1   ry  ry  ë  s   † ôô'÷r3   ry  c                  óF   • \ rS rSrS	S jrS
S jrSS jrSS jrSS jrSr	g)Úrw_hybridpropertyiü  c                ó*   • Xl         Xl        S U l        g r9   )r  r{  Úsetfnr|  s     r1   rÕ   Úrw_hybridproperty.__init__ý  s   € ØŒ	ØŒØ37ˆ�
r3   c                óP   • Uc  U R                  U5      nU$ U R                  U5      $ r9   r  r€  s       r1   rÀ  Úrw_hybridproperty.__get__  r„  r3   c                óD   • U R                   c   eU R                  X5        g r9   ©r�  rÈ  s      r1   rÊ  Úrw_hybridproperty.__set__	  s   € Ø�z‰zÑ%Ð%Ð%Ø�
‰
�8Õ#r3   c                ó   • Xl         U $ r9   r”  r|  s     r1   ÚsetterÚrw_hybridproperty.setter  s   € ØŒ
Øˆr3   c                ó   • Xl         U $ r9   r†  r|  s     r1   r‡  Úrw_hybridproperty.classlevel  r‰  r3   )r{  r  r�  NrŠ  r‹  rØ  )r  rs   rK   zrw_hybridproperty[_T])
rM   rN   rO   rP   rÕ   rÀ  rÊ  r—  r‡  rT   rU   r3   r1   r�  r�  ü  s   † ô8ô
'ô$ô÷r3   r�  c                  ó6   • \ rS rSrSrSS jrS	S jrS
S jrSrg)Úhybridmethodi  z/Decorate a function as cls- or instance- level.c                ó,   • U=U l         U l        Xl        g r9   )r  r  r{  r|  s     r1   rÕ   Úhybridmethod.__init__  s   € Ø$(Ð(ˆŒ	�D”MØ�r3   c                óˆ   • Uc%  U R                   R                  X"R                  5      $ U R                  R                  X5      $ r9   )r{  rÀ  rv   r  )r=   rÉ  r�  s      r1   rÀ  Úhybridmethod.__get__  s6   € ØÑØ—=‘=×(Ñ(¨·±Ó@Ð@à—9‘9×$Ñ$ XÓ5Ð5r3   c                ó   • Xl         U $ r9   r†  r|  s     r1   r‡  Úhybridmethod.classlevel#  r‰  r3   )r  r{  r  NrŠ  )rÉ  r   r�  r   rK   r  )r  rs   rK   zhybridmethod[_T])	rM   rN   rO   rP   rQ   rÕ   rÀ  r‡  rT   rU   r3   r1   rœ  rœ    s   † Ù9ôô6÷r3   rœ  c                  ó†   • \ rS rSr% SrS\S'   0 rS\S'   \R                  " 5       r	  S       SS jjr
S	 rS
 rS rSrg)Úsymboli(  a)  A constant symbol.

>>> symbol("foo") is symbol("foo")
True
>>> symbol("foo")
<symbol 'foo>

A slight refinement of the MAGICCOOKIE=object() pattern.  The primary
advantage of symbol() is its repr().  They are also singletons.

Repeated calls of symbol('name') will all return the same instance.

r-   rq   zDict[str, symbol]ÚsymbolsNc                óŽ  • U R                      U R                  R                  U5      nUca  [        U[        5      (       d   eUc  [        U5      n[        R                  [        U5      nXl	        U(       a  X$l
        X@R                  U'   OU(       a  X4:w  a  [        SU< SU 35      eUsS S S 5        $ ! , (       d  f       g = f)Nz#Can't replace canonical symbol for z with new int value )Ú_lockr¥  r  ra   r-   Úhashr:  Ú__new__r¤  rq   rQ   r  )r\   rq   r¼  Ú	canonicalr™   s        r1   r©  Úsymbol.__new__<  sª   € ð �Y‹YØ—+‘+—/‘/ $Ó'ˆCØ‰{Ü! $¬×,Ñ,Ð,Ð,ØÑ$Ü $ T£
�IÜ—k‘k¤&¨)Ó4�Ø”ÞØ"%”Kð %(—‘˜DÒ!æ Ó!1Ü#Ø=¸d¹Xð F.Ø.7¨[ð:óð ð ÷- �Y�Yús   �BB6Â6
Cc                ó>   • [         U R                  S[        U 5      44$ )Nr/   )r¤  rq   r:  r<   s    r1   Ú
__reduce__Úsymbol.__reduce__Z  s   € Ü˜Ÿ	™	 3¬¨D«	Ð2Ð2Ð2r3   c                ó   • [        U 5      $ r9   )r·   r<   s    r1   Ú__str__Úsymbol.__str__]  s   € Ü�D‹zÐr3   c                ó$   • SU R                   < S3$ )Nzsymbol(rT  )rq   r<   s    r1   Ú__repr__Úsymbol.__repr__`  s   € Ø˜Ÿ™™ QÐ'Ð'r3   rU   )NN)rq   r-   r¼  r¸  rª  úOptional[int]rK   r¤  )rM   rN   rO   rP   rQ   rS   r¥  rT  rU  r§  r©  r­  r°  r³  rT   rU   r3   r1   r¤  r¤  (  sg   ‡ ñð ƒIà!#€GÐÓ#Ø�NŠNÓ€Eð
 "Ø#'ð	àðð ðð !ð	ð
 
õò<3òõ(r3   r¤  c                  ó<   • \ rS rSr          SS jrSS jrSrg)Ú_IntFlagMetaid  c                ó¸  • / =U l         nUR                  5        H‚  u  pg[        R                  " SU5      (       a  M#  [	        U[
        5      (       a
  [        XgS9nO#UR                  S5      (       d  [        S5      eMe  [        XU5        UR                  U5        M„     [        R                  " U Vs0 s H  oˆR                  U_M     sn5      U l        g s  snf )Nz^__.*__$)rª  r{  z#Expected integer values for IntFlag)Ú_itemsrY  rn   Úmatchra   r:  r¤  r�  r  r�  r„   r   Úimmutabledictrq   Ú__members__)	r\   Ú	classnamer–   Údict_rw  rY  rD  Úvr™   s	            r1   rÕ   Ú_IntFlagMeta.__init__e  s°   € ð  ÐˆŒ
�UØ—K‘K–M‰DˆAÜ�xŠx˜ Q×'Ñ'ÙÜ˜!œS×!Ñ!Ü˜QÑ,‘Ø—\‘\ #×&Ñ&ÜÐ EÓFÐFáÜ�C˜CÔ Ø�L‰L˜Öñ "ô '×4Ò4Ù&+Ó,¢e˜s�X‰X�sŠ]¡eÑ,ó
ˆ�ùÚ,s   Â4Cc                ó   • [        S5      e)Nz“iter not implemented to ensure compatibility with Python 3.11 IntFlag.  Please use __members__.  See https://github.com/python/cpython/issues/99304rÄ  r<   s    r1   Ú__iter__Ú_IntFlagMeta.__iter__~  s   € Ü!ð=ó
ð 	
r3   rU   N)
r½  r-   r–   zTuple[Type[Any], ...]r¾  úDict[str, Any]rw  r   rK   rL   )rK   zIterator[symbol])rM   rN   rO   rP   rÕ   rÂ  rT   rU   r3   r1   r·  r·  d  s<   † ð
àð
ð %ð
ð ð	
ð
 ð
ð 
ô
÷2
r3   r·  c                  ó   • \ rS rSrSrSrg)Ú_FastIntFlagi†  z¶An 'IntFlag' copycat that isn't slow when performing bitwise
operations.

the ``FastIntFlag`` class will return ``enum.IntFlag`` under TYPE_CHECKING
and ``_FastIntFlag`` otherwise.

rU   Nr£  rU   r3   r1   rÆ  rÆ  †  s   † ôr3   rÆ  )Ú	metaclass)ÚIntFlagÚ_Ec                óÌ   • UR                  5        H0  u  pEXL a  Us  $ U(       a  XR                  :X  a  Us  $ X;   d  M.  Us  $    U c  g[        R                  " SU SU < 35      e)a'  Given a user parameter, parse the parameter into a chosen value
from a list of choice objects, typically Enum values.

The user argument can be a string name that matches the name of a
symbol, or the symbol object itself, or any number of alternate choices
such as True/False/ None etc.

:param arg: the user argument.
:param choices: dictionary of enum values to lists of possible
    entries for each.
:param name: name of the argument.   Used in an :class:`.ArgumentError`
    that is raised if the parameter doesn't match any available argument.

NzInvalid value for 'z': )rY  rq   r   r`  )rO  Úchoicesrq   Úresolve_symbol_namesÚ
enum_valueÚchoices         r1   Úparse_user_argument_for_enumrÏ  ›  si   € ð( &Ÿm™mžoÑˆ
ØÒØÒÞ! c¯_©_Ó&<ØÒØ�]ØÒñ .ð �{Øä
×
Ò
Ð1°$°°s¸3¹'ÐBÓ
CÐCr3   c                ó,   • [         U l         [         S-  q g)zÎAssign a '_creation_order' sequence to the given instance.

This allows multiple instances to be sorted in order of creation
(typically within a single thread; the counter is not particularly
threadsafe).

r   N)Ú_creation_order)rÉ  s    r1   Úset_creation_orderrÒ  À  s   € ô  /€HÔÜ�qÑ�Or3   c                ó|   •  U " U0 UD6$ ! [          a'    [        S[        R                  " 5       SS -  5         gf = f)zPexecutes the given function, catches all exceptions and converts to
a warning.

z%s('%s') ignoredr   r   N)rb   Úwarnr:   r;   )r  r  rG  s      r1   Úwarn_exceptionrÕ  Í  sA   € ð
7Ù�TÐ$˜VÑ$Ð$øÜó 7ÜÐ¤#§,¢,£.°°1Ð"5Ñ5Ö6ð7ús   ‚
 Š.;º;c                óZ   •  [        U 5      U:”  a  SU SU -  $ U $ ! [         a    U s $ f = f)Nz%s...r   )r±   r  )rC   Úlen_s     r1   Úellipses_stringrØ  Ø  s=   € ðÜˆu‹:˜ÓØ˜U 1 T˜]Ñ*Ð*àˆLøÜó ØŠðús   ‚ ™ ›*©*c                  ó`   ^ • \ rS rSr% SrS\S'           S	U 4S jjrS
S jrSS jrSr	U =r
$ )Ú_hash_limit_stringiâ  a  A string subclass that can only be hashed on a maximum amount
of unique values.

This is used for warnings so that we can send out parameterized warnings
without the __warningregistry__ of the module,  or the non-overridable
"once" registry within warnings.py, overloading memory,


r:  Ú_hashc                ó|   >• X-  SU-  -   n[         TU ]  X5      n[        SU[        U5      U-  4-  5      Ul        U$ )Nz6 (this warning may be suppressed after %d occurrences)z%s_%d)rr  r©  r¨  rÛ  )r\   rC   Únumr  Úinterpolatedr=   rv   s         €r1   r©  Ú_hash_limit_string.__new__ï  sN   ø€ ð ™ØDÀsÑJñ
ˆô ‰w‰˜sÓ1ˆÜ˜' U¬D°Ó,>ÀÑ,DÐ$EÑEÓFˆŒ
Øˆr3   c                ó   • U R                   $ r9   ©rÛ  r<   s    r1   Ú__hash__Ú_hash_limit_string.__hash__ù  s   € Ø�z‰zÐr3   c                ó0   • [        U 5      [        U5      :H  $ r9   )r¨  )r=   Úothers     r1   Ú__eq__Ú_hash_limit_string.__eq__ü  s   € Ü�D‹zœT %›[Ñ(Ð(r3   rá  )rC   r-   rÝ  r:  r  úSequence[Any]rK   rÚ  )rK   r:  )rå  r   rK   rø   )rM   rN   rO   rP   rQ   rS   r©  râ  ræ  rT   rv  rw  s   @r1   rÚ  rÚ  â  sC   ø‡ ñð ƒJðØðØ!ðØ)6ðà	÷ô÷)ò )r3   rÚ  c                ó‚   • U(       a  [        [        R                  " XS95        g[        U [        R                  5        g)zXIssue a warning.

If msg is a string, :class:`.exc.SAWarning` is used as
the category.

)rÅ   N)Ú_warnings_warnr   Ú	SAWarning)ÚmsgrÅ   s     r1   rÔ  rÔ     s&   € ö Ü”s—}’} SÑ4Õ5ä�sœCŸM™MÕ*r3   c                ó`   • U(       a  [        U SU5      n [        U [        R                  5        g)zTIssue a warning with a parameterized string, limiting the number
of registrations.

é
   N)rÚ  rê  r   rë  )rì  r  s     r1   Úwarn_limitedrï    s#   € ö
 Ü   b¨$Ó/ˆÜ�3œŸ™Õ&r3   z)Dict[CodeType, Tuple[str, Type[Warning]]]Ú_warning_tagsc                ó   ^ ^• UU 4S jnU$ )Nc                ó2   >• TT4[         U R                  '   U $ r9   )rð  rô   )rœ   ÚcategoryÚmessages    €€r1   ÚgoÚ#tag_method_for_warnings.<locals>.go  s   ø€ Ø&-¨xÐ%8Œ�b—k‘kÑ"Øˆ	r3   rU   )rô  ró  rõ  s   `` r1   Útag_method_for_warningsr÷    s   ù€ öð €Ir3   z&^(?:sqlalchemy\.(?!testing)|alembic\.)c                ó,  •  [         R                  " U5      nS=pEUb®  U(       d<  [        R                  " [        UR
                  R                  SS5      5      (       d  SnUR                  [        ;   a*  Sn[        UR                     u  pgU=(       d    UnU  SU S3n UR                  nU(       d  US-  nOU(       a  U(       a  OUb  M®  Ub  [        R                  " XUS-   S	9  g [        R                  " XS-   S	9  g ! [         a    Sn NB  Sn NG= f)
NFrM   r«   Tz (rT  r   r   )Ú
stacklevel)r:   Ú	_getframern   rº  Ú_not_sa_patternÚ	f_globalsr  Úf_coderð  Úf_backr1  ÚwarningsrÔ  )rô  ró  rù  ÚframeÚstacklevel_foundÚwarning_tag_foundÚ_suffixÚ	_categorys           r1   rê  rê  '  s
  € ð%Ü—’˜jÓ)ˆð 05Ð4ÐØÑö $¬B¯HªHÜ §¡×!4Ñ!4°ZÀÓ!D÷-ñ -ð
 $(Ð ð
 �|‰|œ}Ó,Ø$(Ð!Ü'4°U·\±\Ñ'BÑ$�Ø#×0 y�Ø$˜I R¨ y°Ð2�à—L‘LˆEæ#Ø˜a‘‘
Þ!Ö&7Øð3 Óð6 ÑÜ�Š�g°JÀ±NÓCä�Š�g°q©.Ó9øôQ ó ð Š
ðð Š
ús   ‚D  Ä DÄDc                ó&   ^ ^^• T /mSU UU4S jjnU$ )zJDecorate the given function to be a no-op after it is called exactly
once.c                 óˆ   >• TnT(       a  TR                  5       n U" U 0 UD6$ g !   T(       a  TR                  SU5        e = f)Nr   )rX   Úinsert)rO  rw  Ú	strong_fnÚonce_fnrœ   ÚonceÚretry_on_exceptions       €€€r1   rõ  Úonly_once.<locals>.gob  sM   ø€ ð ˆ	ÞØ—h‘h“jˆGðÙ Ð* rÑ*Ð*ð øðÞ%Ø—K‘K  7Ô+Øús	   œ% ¥A)rO  r   rw  r   rK   zOptional[_T]rU   )rœ   r  rõ  r
  s   `` @r1   Ú	only_oncer  Z  s   ú€ ð ˆ4€D÷ñ ð €Ir3   z%sqlalchemy/([a-z_]+/){0,2}[a-z_]+\.pyzunit(?:2|test2?/)c                ó4  • Sn[        U 5      S-
  nX4::  a<  UR                  X   5      (       a$  US-  nX4::  a  UR                  X   5      (       a  M$  X4::  a<  UR                  X   5      (       a$  US-  nX4::  a  UR                  X   5      (       a  M$  XUS-    $ )aT  Chop extraneous lines off beginning and end of a traceback.

:param tb:
  a list of traceback lines as returned by ``traceback.format_stack()``

:param exclude_prefix:
  a regular expression object matching lines to skip at beginning of
  ``tb``

:param exclude_suffix:
  a regular expression object matching lines to skip at end of ``tb``
r   r   )r±   Úsearch)ÚtbÚexclude_prefixÚexclude_suffixr€   Úends        r1   Úchop_tracebackr  x  s—   € ð" €EÜ
ˆb‹'�A‰+€CØ
‹,˜>×0Ñ0°±×;Ñ;Ø�‰
ˆð ‹,˜>×0Ñ0°±×;Ó;à
‹,˜>×0Ñ0°±×9Ñ9Øˆq‰ˆð ‹,˜>×0Ñ0°±×9Ó9à�c˜A‘gÐÐr3   c                ó\   • SU -  n[        5       R                  5       n[        X5        US   $ )Nz&def set(obj, value):    obj.%s = valuerW   )r�  ÚcopyrÌ   )ÚattrnamerÅ   rÆ   s      r1   Ú
attrsetterr  •  s*   € Ø3°hÑ>€DÜ
‹(�-‰-‹/€CÜˆ„OØˆu‰:Ðr3   z^__.+__$c                  ó4   ^ • \ rS rSrSrSrSU 4S jjrSrU =r$ )Ú
TypingOnlyiŸ  z‹A mixin class that marks a class as 'typing only', meaning it has
absolutely no methods, attributes, or runtime functionality whatsoever.

rU   c                óö   >• [         U R                  ;   aQ  U R                   Vs1 s H!  n[        R	                  U5      (       a  M  UiM#     nnU(       a  [        SU  SU S35      e[        TU ]  5         g s  snf )NzClass z< directly inherits TypingOnly but has additional attributes rä   )r  r	  r  Ú_dundersrº  ÚAssertionErrorrr  Ú__init_subclass__)r\   rq   Ú	remainingrv   s      €r1   r  ÚTypingOnly.__init_subclass__§  sv   ø€ Ü˜Ÿ™Ó&à!$§¢óÚ!-˜´X·^±^ÀD×5I—¡ð ð ö Ü$Ø˜S˜Eð "-Ø-6¨K°qð:óð ô 	‰Ñ!Õ#ùòs   ¤A6ÁA6rJ   )	rM   rN   rO   rP   rQ   rR   r  rT   rv  rw  s   @r1   r  r  Ÿ  s   ø† ñð
 €I÷
$õ 
$r3   r  c                  óR   ^ • \ rS rSr% SrS\S'    SU 4S jjr\S	S j5       rSr	U =r
$ )
ÚEnsureKWArgi´  a"  Apply translation of functions to accept \**kw arguments if they
don't already.

Used to ensure cross-compatibility with third party legacy code, for things
like compiler visit methods that need to accept ``**kw`` arguments,
but may have been copied from old code that didn't accept them.

r-   Úensure_kwargc                óD  >• U R                   nU R                  nU(       ar  U Hl  n[        R                  " X5      nU(       d  M"  X#   n[        R
                  " U5      nUR                  (       a  MO  U R                  U5      n[        XU5        Mn     [        TU ])  5         g r9   )r#  r  rn   rº  r   r°   r  Ú
_wrap_w_kwr�  rr  r  )	r\   Úfn_regÚclsdictr‡  r0   rœ   r¾   Úwrappedrv   s	           €r1   r  ÚEnsureKWArg.__init_subclass__Ç  s|   ø€ Ø×!Ñ!ˆØ—,‘,ˆÞÛ�Ü—H’H˜VÓ)�ß�1Ø ™�BÜ!×8Ò8¸Ó<�DØŸ:Ÿ:™:Ø"%§.¡.°Ó"4˜Ü ¨'Ö2ñ ô 	‰Ñ!Õ#r3   c                ó,   ^• SU4S jjn[        UT5      $ )Nc                 ó   >• T" U 6 $ r9   rU   )rO  rw  rœ   s     €r1   ÚwrapÚ$EnsureKWArg._wrap_w_kw.<locals>.wrap×  s   ø€ Ù�s�8ˆOr3   )rO  r   rw  r   rK   r   r   )r\   rœ   r,  s    ` r1   r%  ÚEnsureKWArg._wrap_w_kwÕ  s   ø€ ÷	ô ˜d BÓ'Ð'r3   rU   rJ   )rœ   rs   rK   rs   )rM   rN   rO   rP   rQ   rS   r  rÚ  r%  rT   rv  rw  s   @r1   r"  r"  ´  s.   ø‡ ñð Óð÷$ð ó(ó ö(r3   r"  c                ó¦  • [        US5      (       a  [        X5      $ U nUR                  R                  Ul        [        US5      (       a  UR                  Ul        [        UR
                  S5      (       a8  UR
                  R                  (       a  UR
                  R                  Ul        U$ UR                  (       a  UR                  Ul        U$ )z�Augment functools.update_wrapper() to work with objects with
a ``__call__()`` method.

:param fn:
  object with __call__ method

rM   rN   rQ   )rƒ   r   rv   rM   rN   r  rQ   )Úwrapperrœ   Ú_fs      r1   Úwrap_callabler2  Ý  s˜   € ô ˆr�:×ÑÜ˜gÓ*Ð*àˆØ—l‘l×+Ñ+ˆŒÜ�2�|×$Ñ$ØŸM™MˆBŒMä�2—;‘; 	×*Ñ*¨r¯{©{×/B×/BØŸ™×,Ñ,ˆBŒJð ˆ	ð �Z�ZØŸ™ˆBŒJàˆ	r3   c                ó®  • SU ;  a  U R                  S5      $ Sn/ /nSn[        U 5      nX4:  a�  X   nUS:X  a9  US:X  a-  X4S-
  :  a%  XS-      S:X  a  US   R                  S5        US-  nO8US-  nO2US:X  a  US:X  a  UR                  / 5        OUS   R                  U5        US-  nX4:  a  M�  U Vs/ s H  nSR                  U5      PM     sn$ s  snf )a˜  Parse a dotted identifier with accommodation for quoted names.

Includes support for SQL-style double quotes as a literal character.

E.g.::

    >>> quoted_token_parser("name")
    ["name"]
    >>> quoted_token_parser("schema.name")
    ["schema", "name"]
    >>> quoted_token_parser('"Schema"."Name"')
    ['Schema', 'Name']
    >>> quoted_token_parser('"Schema"."Name""Foo"')
    ['Schema', 'Name""Foo']

Ú"rä   r   r   r0  r«   )ræ   r±   r„   rm   )rC   rp  rä  ÚidxÚlvÚcharrè   s          r1   Úquoted_token_parserr8  õ  sç   € ð$ �%ÓØ�{‰{˜3ÓÐð €EØ!˜d€FØ
€CÜ	ˆU‹€BØ
‹(Ø‰zˆØ�3‹;Ø˜‹z˜c¨¡F›l¨u¸1±W©~ÀÓ/DØ�r‘
×!Ñ! #Ô&Ø�q‘‘à˜‘
‘Ø�S‹[˜U a›ZØ�M‰M˜"Õà�2‰J×Ñ˜dÔ#Øˆq‰ˆð �(ñ )/Ó/ª˜uˆB�G‰G�EŽN©Ñ/Ð/ùÒ/s   Â4Cc                óD   ^ ^• [         R                  " T 5      m U U4S jnU$ )Nc                óº   >• U R                   S L=(       a    U R                   =(       d    SnU(       a  [        UT Vs0 s H  o"T_M     sn5      nXl         U $ s  snf )Nr«   )rQ   Úinject_param_text)rœ   r¼  ÚparamÚparamsr5  s      €€r1   rÈ   Ú$add_parameter_text.<locals>.decorate$  sO   ø€ Ø�j‰j Ð$×3¨¯©×9°rˆÞÜ# CÁ6Ó)JÂ6¸%°ª+Á6Ñ)JÓKˆCØŒ
Øˆ	ùò *Ks   ½A
)r   rU  )r=  r5  rÈ   s   `` r1   Úadd_parameter_textr?  !  s   ù€ Ü×!Ò! &Ó)€Föð €Or3   c                óà   • U R                  SS5      n[        U5      S:X  a  U $ Uu  p#UR                  S5      (       d  US-   [        R                  " U5      -   $ [        R                  " U 5      $ )NÚ
r   rf   )ræ   r±   r�  ÚtextwrapÚdedent)r5  Ú
split_textÚ	firstliner  s       r1   Ú_dedent_docstringrF  .  sd   € Ø—‘˜D !Ó$€JÜ
ˆ:ƒ˜!ÓØˆà)Ñˆ	Ø×Ñ ×$Ñ$Ø˜4Ñ¤(§/¢/°)Ó"<Ñ<Ð<ä�Š˜tÓ$Ð$r3   c                ó  • [        U =(       d    S5      nUR                  S5      n[        U5      S:X  a  UR                  S5        [        R
                  " U5      R                  S5      nUS   (       a  UR                  SS5        [        U5       VVs/ s H  u  pgUR                  5       (       a  M  UPM      nnnUR                  SS5        U[        U[        U5      S-
  5         n	USU	 U-   XIS  -   nSR                  U5      $ s  snnf )Nr«   rA  r   r   )rF  ræ   r±   r„   rB  rC  r  rW  r0  Úminrm   )
Úgiven_doctextÚ
injecttextÚposÚdoctextÚlinesÚinjectlinesrÝ  ÚlineÚblanksÚ
inject_poss
             r1   Úinject_docstring_textrR  :  sä   € ô % ]×%8°bÓ9€GØ�M‰M˜$Ó€EÜ
ˆ5ƒz�QƒØ�‰�RÔÜ—/’/ *Ó-×3Ñ3°DÓ9€KØ�1‡~Ø×Ñ˜1˜bÔ!ä#,¨UÔ#3ÔHÒ#3‘i�c¸4¿:¹:¿<�cÑ#3€FÑHØ
‡M�M�!�QÔàœ˜C¤ V£¨q¡Ó1Ñ2€Jà�!�JÐ +Ñ-°°kÐ0BÑB€EØ�9‰9�UÓÐùó Is   ÂDÂ4Dz(\s+):param (.+?):c                ó@  • [         R                  " U R                  5       5      n/ nS nU(       Ga^  UR                  5       n[        R                  U5      nUc™  U(       a‘  UR                  S5      R                  S5      nXq;   al  S[        UR                  S5      5      -  S-   nU(       a>  [        R
                  " SUS   5      n	U	(       a  S[        U	R                  S5      5      -  nX�U   -   nO‚U(       a  UR                  SUS/5        S nOdUR                  5       (       d  UR                  XTS/5        S nO9UR                  S5      (       a#  UR                  XRR                  5       /5        GMK  UR                  U5        U(       a  GM^  SR                  U5      $ )	Nr   Ú*rf   r   z(\s+)\Sr   rA  z::)ÚcollectionsÚdequeÚ
splitlinesÚpopleftÚ
_param_regrº  rÒ   Úlstripr±   rn   rZ   ÚrstriprŽ  r„   rm   )
rL  Úinject_paramsÚdoclinesrM  Ú	to_injectrO  r0   r<  ÚindentÚm2s
             r1   r;  r;  Q  sX  € Ü× Ò  ×!3Ñ!3Ó!5Ó6€HØ€Eð €Iß
Ø×ÑÓ!ˆä×Ñ˜TÓ"ˆàÑÞØŸ™ ›
×)Ñ)¨#Ó.�ØÓ)à ¤3 q§w¡w¨q£z£?Ñ2°SÑ8�Fö  ÜŸXšX j°(¸1±+Ó>˜ÞØ%(¬3¨r¯x©x¸«{Ó+;Ñ%;˜Fà &°uÑ)=Ñ =�IøÞØ�L‰L˜$ 	¨4Ð0Ô1Ø‰IØ—‘—‘Ø�L‰L˜$¨4Ð0Ô1Ø‰IØ�]‰]˜4× Ñ ð �L‰L˜$× 0Ñ 0Ó 2Ð3Ô4ÚØ�‰�TÔ÷? ‰(ðB �9‰9�UÓÐr3   c                ó4  • [        U 5      S:X  a  g[        U 5      S:*  nU(       a  U SS O
U SS U SS -   n U  Vs/ s H  n[        U5      S:”  a  SUSS -  OUPM     nnU(       a  SR                  U5      $ SR                  USS 5      < S	US   < 3$ s  snf )
zˆTrims a list of strings from the middle and return a string of up to
four elements. Strings greater than 11 characters will be truncatedr   Nr"  r¥   r0  é   z%s..rS  z, ..., )r±   rm   )rÁ   Úflagrq   Úress       r1   Úrepr_tuple_namesre  |  s¢   € ô ˆ5ƒz�QƒØÜˆu‹:˜‰?€DÞˆE�!�A‰J E¨!¨A J°°r°s°Ñ$;€EÙFKÓ
LÂe¸d¤ T£¨R£ˆ6�D˜˜"�IÒ°TÒ9Áe€CÐ
LÞØ�y‰y˜‹~Ðà $§	¡	¨#¨a°¨(Ö 3°S¸³WÐ=Ð=ùò	 Ms   º#Bc                ó@   • [         (       a  gU (       a  [        S5      eg)NTzDcython extensions were expected to be installed, but are not presentF)r   ÚImportError)Úraise_s    r1   Úhas_compiled_extri  Š  s$   € ß‚ØÞ	Üð"ó
ð 	
ð
 r3   c                  ó6   • \ rS rSr\R
                  " 5       rSrg)Ú_Missingi–  rU   N)rM   rN   rO   rP   ÚenumÚautoÚMissingrT   rU   r3   r1   rk  rk  –  s   † Ø�iŠi‹kƒGr3   rk  )r/   r   rK   r-   )r\   úType[_T]rK   zIterator[Type[_T]])rc   r   rK   r-   r9   )r\   ú	Type[Any]rp   r¸  rK   r-   )rx   zUnion[Type[Any], object]ry   rs   rK   rø   )r†   ÚslicerK   úTuple[Any, ...])r•   úSequence[str]r–   r-   rK   zIterator[str])rœ   zCallable[[int], Any]rj   r:  rK   zIterator[Any])r¦   rs   rK   zCallable[[_Fn], _Fn])rÅ   zUnion[str, types.CodeType]rÆ   rÄ  rÃ   r-   rK   rs   )r\   ru   rÿ   úOptional[Set[str]]r   zLiteral[True]rK   zSet[str])r\   ru   rÿ   rt  r   rø   rK   rt  )r  rs   rK   ú	List[str])FF)rœ   rs   r  rø   r  rø   rK   zcompat.FullArgSpec)T)rœ   z-Union[Callable[..., Any], compat.FullArgSpec]r¨   rø   rK   zDict[str, Optional[str]])rU   rU   rU   rU   )r>  rp  r?  r-   r@  r-   rA  rs  rB  rs  rC  rs  rD  rs  rK   zCallable[[_T], _T])rU   NrU   )
rP  r   rZ  zSequence[Tuple[str, Any]]r[  z%Optional[Union[object, List[object]]]r\  rs  rK   r-   )NNz
self.proxyN)NNNr  )rP  r   rK   rø   )r5  r-   rK   z!Callable[[str], Union[str, bool]])rC   r   rK   rµ  )TN)rw  rÄ  r‡  r-   rB   rp  r=  rø   r>  zOptional[Dict[str, Any]]rK   rL   )rP  r   r\   rp  rK   rr  )
rP  r    r\   ro  r  r   rw  r   rK   r    )rK   zCallable[[], int])rY  r   rc  úOptional[Type[Any]]rK   rv  )rO  r   ra  z'Union[Tuple[Type[Any], ...], Type[Any]]rq   r-   rK   r   )F)
rO  r   rË  zDict[_E, List[Any]]rq   r-   rÌ  rø   rK   zOptional[_E]rÙ  )r  rs   r  r   rG  r   rK   r   )é   )rì  r-   rÅ   r¸  rK   rL   )rì  r-   r  rè  rK   rL   )rô  r-   ró  zType[Warning]rK   úCallable[[_F], _F])Nr   )rô  zUnion[str, Warning]ró  zOptional[Type[Warning]]rù  r:  rK   rL   )rœ   r  r  rø   rK   zCallable[..., Optional[_T]])r  ru  r  úre.Pattern[str]r  ry  rK   ru  )r=  r   r5  r-   rK   rx  )r5  r-   rK   r-   )rI  r¸  rJ  r-   rK  r:  rK   r-   )rL  r-   r\  zDict[str, str]rK   r-   )rÁ   ru  rK   r¸  )šrQ   Ú
__future__r   rU  rl  Ú	functoolsr   r­   r�   r¦  rn   r:   rB  rT  r¸   r   Útypingr   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rÿ  r«   r   r   Ú_has_cyr   r   r   r    r!   r#   r%   r&   r'   r(   r2   r5   r_   rd   rr   r}   rˆ   rš   rž   rŸ   rÊ   rº   rÍ   rÎ   rÐ   rþ   r  r  r   rµ   r:  rE  rH  rL  rg  ri  rƒ  rˆ  r›  rŸ  r²  r³  rµ  rÜ  rá  r  Únon_memoized_propertyÚpropertyÚro_memoized_propertyÚro_non_memoized_propertyrô  rö  Ú!HasMemoized_ro_memoized_attributer  r  r2  r8  r;  r?  rG  rL  rP  r[  rb  rª  ro  ry  r�  rœ  r:  r¤  ru   r·  rÆ  rÈ  ÚFastIntFlagÚEnumrÉ  rÏ  rÑ  rÒ  rÕ  rØ  r-   rÚ  rÔ  rï  rð  rS   r÷  Úcompilerû  rê  r  Ú_SQLA_REÚ_UNITTEST_REr  ÚNoneTyper  r  r  r"  r2  r8  r?  rF  rR  rY  r;  re  ri  rk  rn  Ú	MissingOrrU   r3   r1   Ú<module>rŠ     s’  ðòõ #ã Û Ý $Û Û Û Û 	Û 
Û Û Û Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý  Ý Ý Û å Ý Ý $Ý Ý áˆTƒ]€Ù� 4Ñ(€ÙˆT˜ # s (Ñ+Ñ,€ÙˆeÐ3Ñ4€ÙˆeÐ@ÑA€ÙˆeÐ0Ñ1€ÙˆeÐ.Ñ/€ô$÷82ñ 82ôvô6ð /3ðOØ	ðOØ+ðOàõOð,Ø-ð,à&ð,ð 
ô,ô$ôMô ñ ˆeÐ/Ñ0€ô
Y,ðxØ
$ðØ+9ðØDGðàôñ ˆeƒn€Ùˆeƒn€÷(ñ (òV
ð( 
ð  $Ø!ñ	Ø	ðð ðð ð	ð
 ôó 
ðð 
à-1ÀEñØ	ðØ*ðØ=Aðàôó 
ðð .2ÀEñ2Ø	ð2Ø*ð2Ø=Að2àõ2ôj2ð EJð5;Øð5;Ø%)ð5;Ø=Að5;àõ5;ðr HLðr
Ø5ðr
Ø@Dðr
àõr
ôjðJ #%ØØ "Ø/1ðØðàðð ðð  ð	ð
 ðð ðð  -ðð õò26ò(	ð 02Ø8<Ø "ð	KBØ	ðKBà,ðKBð 6ðKBð ð	KBð
 	õKB÷\;ñ ;ò<#òLð& 
Ø	Ø	Øô@/òFôSñl ˆvÐ9Ñ:€ô($˜G E™Nô ($ôV"Ð2°5Ñ9ô "ô"%Ð.¨uÑ5ô %ö< ð .ÐØ1Ðð
 $ÐØ'Ñð 0BÐAÐÐ,Ø7MÐMÐÐ4ô'÷.J+ñ J+öZ Ø(0Ñ%à(3×(FÑ(FÐ%÷-/ñ -/ôb	ôôð Ø%)ð'Øð'à	ð'ð ð'ð ð	'ð
 #ð'ð 
õ'ô4ôôð 37ð Øð Ø/ð àõ ðFØ	ðØ>ðØFIðàôò$Cô0�Hô ô*�W˜R‘[ô ô"˜ ™ô ô4�7˜2‘;ô ô$9(ˆSô 9(ôx
�4ô 
ôD˜\ò ö Ýà�Kà€Kñ ˆT˜Ÿ™Ñ#€ð "'ð	DØ	ðDà ðDð ðDð ð	Dð
 õDðD €ô
ô7ôô)˜ô )ö<
+ô'ð <>€Ð8Ó =ðØðØ)ðàôð —*“*ÐFÓG€ð
 )-Øð0:Ø ð0:à%ð0:ð ð0:ð 
õ	0:ðfØðØ/3ðà ôð4 �:‹:Ð>Ó?€Ø�z‹zÐ.Ó/€ð
 '3Ø&.ðØðà#ðð $ðð õ	ñ4 �‹:€òð �:‹:�jÓ!€÷$ñ $÷*&(ñ &(òRò0)0ôX
ô	%ðØ ðØ.1ðØ8;ðàôð( �Z‹ZÐ-Ó.€
ô(ôV>ô	ôˆt�y‰yô ð ×
Ò
€Ø�"�g˜h×.Ò.Ñ/Ð/Ñ0�	r3   