Ë
    ÛÍ:j×ý  ã                  ó0	  — U d Z ddlmZ ddlZddlZddlmZ ddlZddlZddl	Z	ddl
Z
ddlZddlZddlZddlZddlmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z  ddlm!Z! ddlm"Z" ddl#Z#ddl$m%Z% ddl$m&Z& ddl'm(Z( ddlm)Z) ddl$m*Z*  e!d«      Z+ e!d d!¬"«      Z, e!d#ed$ef   ¬%«      Z- e!d&d'¬%«      Z. e!d(d)¬%«      Z/ e!d*d+¬%«      Z0 e!d,d-¬%«      Z1dŸd.„Z2 G d/„ d0«      Z3d d1„Z4d¡d2„Z5	 d¢	 	 	 	 	 d£d3„Z6	 	 	 	 	 	 d¤d5„Z7d¥d6„Z8d¦d7„Z9d§d8„Z: e!d9d4¬%«      Z;d¨d:„Z<	 	 	 	 	 	 	 	 d©d;„Z= e!d<«      Z> e!d=«      Z? G d>„ d?«      Z@d@„ ZAedd$dAœ	 	 	 	 	 	 	 dªdB„«       ZBeddCdAœ	 	 	 	 	 	 	 d«dD„«       ZBddCdAœ	 	 	 	 	 	 	 d«dE„ZBd¬dF„ZC	 d­	 	 	 	 	 	 	 d®dG„ZD	 d¯	 	 	 	 	 d°dH„ZEd¯dI„ZF	 	 	 	 d±	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d²dJ„ZGdK„ ZHdL„ ZI	 	 	 d³	 	 	 	 	 	 	 	 	 d´dM„ZJ G dN„ dO«      ZKdP„ ZLdQ„ ZM	 	 	 	 dµdR„ZNdS„ ZOd¶dT„ZP e!dUdV¬%«      ZQ G dW„ dXee,   «      ZR G dY„ dZeRe,   «      ZS G d[„ d\eRe,   «      ZTe r	eRZUeRZVeWZXeWZYneTxZUZXeSxZVZYd·d]„ZZ G d^„ d_«      Z[e reWZ\ne[jº                  Z\ G d`„ da«      Z^d¸db„Z_d¹dc„Z`dºdd„Za	 	 d»	 	 	 	 	 	 	 	 	 	 	 d¼de„Zbd½df„Zcd¾dg„Zdd¿dh„Ze	 d¢	 	 	 	 	 dÀdi„Zf	 	 	 	 	 	 	 	 dÁdj„Zgdk„ Zh G dl„ dmeW«      Zi G dn„ doee+   «      Zj G dp„ dqee+   «      Zk G dr„ dsee+   «      Zl G dt„ duem«      Zn G dv„ dweo«      Zp G dx„ dyep¬z«      Zqe r	dd{lmrZr erZsneqZs e!d|ejè                  ¬%«      Zu	 dÂ	 	 	 	 	 	 	 	 	 dÃd}„ZvdawdÄd~„ZxdÅd„ZydÆd€„Zz G d�„ d‚e{«      Z|d¢dÇdƒ„Z}dÈd„„Z~i Zd…e€d†<   	 	 	 	 	 	 dÉd‡„Z� e
�j                  dˆ«      Zƒ	 	 dÊ	 	 	 	 	 	 	 dËd‰„Z„	 	 	 	 	 	 dÌdŠ„Z… e
�j                  d‹«      Z† e
�j                  dŒ«      Z‡e‡e†f	 	 	 	 	 	 	 dÍd�„Zˆ eod«      Z‰dŽ„ ZŠ e
�j                  d�«      Z‹ G d�„ d‘«      ZŒ G d’„ d“«      Z�d”„ ZŽd•„ Z�dÎd–„Z�dÏd—„Z‘	 	 	 	 	 	 	 	 dÐd˜„Z’ e
�j                  d™«      Z“dÑdš„Z”dÒd›„Z•dÂdœ„Z– G d�„ džejè                  «      Z—e—�j0                  Z˜e"e+e)e—�j0                     f   Z™y)Ó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                óª   — | j                  d«      } t        j                  «       }|j                  | «       t	        t
        |j                  «       «      S )Nzutf-8)Úencoder   Úmd5_not_for_securityÚupdater	   ÚstrÚ	hexdigest)ÚxÚms     úp/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/sqlalchemy/util/langhelpers.pyÚmd5_hexr2   ?   s<   € Ø	�‰�Ó€AÜ×#Ñ#Ó%€AØ‡H�HˆQ„KÜ”�Q—[‘[“]Ó#Ð#ó    c                  ó@   — e Zd ZU dZdZded<   dd„Z	 	 	 	 	 	 	 	 d	d„Zy)
Úsafe_reraisea  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]]r6   c                ó6   — t        j                  «       | _        y ©N)ÚsysÚexc_infor6   ©Úselfs    r1   Ú	__enter__zsafe_reraise.__enter__k   s   € ÜŸ™›ˆ�r3   c                ó²   — | j                   €J ‚|€,| j                   \  }}}|€J ‚d | _         |j                  |«      ‚d | _         |€J ‚|j                  |«      ‚r8   )r6   Úwith_traceback)r<   Útype_ÚvalueÚ	tracebackÚexc_typeÚ	exc_valueÚexc_tbs          r1   Ú__exit__zsafe_reraise.__exit__n   sq   € ð �~‰~Ð)Ð)Ð)àˆ=Ø*.¯.©.Ñ'ˆH�i ØÐ(Ð(Ð(Ø!ˆDŒNØ×*Ñ*¨6Ó2Ð2à!ˆDŒNØÐ$Ð$Ð$Ø×&Ñ& yÓ1Ð1r3   N©ÚreturnÚNone)r@   zOptional[Type[BaseException]]rA   zOptional[BaseException]rB   zOptional[types.TracebackType]rH   r   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú	__slots__Ú__annotations__r=   rF   © r3   r1   r5   r5   F   sH   … ñð0 €Iðó ó(ð2à,ð2ð 'ð2ð 1ð	2ð
 
ô2r3   r5   c              #  óÄ   K  — t        «       }| g}|rM|j                  «       } | |v rŒ|j                  | «       |j                  | j	                  «       «       | –— |rŒLy y ­wr8   )ÚsetÚpopÚaddÚextendÚ__subclasses__)ÚclsÚseenÚstacks      r1   Úwalk_subclassesrZ   �   sV   è ø€ Ü“U€DàˆE€EÙ
Ø�i‰i‹kˆØ�$‰;Øà�H‰H�SŒMØ�‰�S×'Ñ'Ó)Ô*ØŠ	ô ùs   ‚AA ÁA c                óf   — t        | t        «      r| S 	 t        | «      S # t        $ r d| z  cY S w xY w)Nzunprintable element %r)Ú
isinstancer-   Ú	Exception)Úelements    r1   Ústring_or_unprintabler_   �   s:   € Ü�'œ3ÔØˆð	6Ü�w“<ÐøÜò 	6Ø+¨gÑ5Ò5ð	6ús   ”
 Ÿ0¯0c                óz   — |xs | j                   }dj                  d„ t        j                  d|«      D «       «      S )Nú c              3  ó<   K  — | ]  }|j                  «       –— Œ y ­wr8   )Úlower)Ú.0Úns     r1   ú	<genexpr>z(clsname_as_plain_name.<locals>.<genexpr>�   s   è ø€ ÒN !�A—G‘G—IÑNùs   ‚z([A-Z][a-z]+|SQL))rJ   ÚjoinÚreÚfindall)rW   Úuse_nameÚnames      r1   Úclsname_as_plain_namerl   ™   s3   € ð Ò#�s—|‘|€DØ�8‰8ÑN¤r§z¡zÐ2FÈÓ'MÔNÓNÐNr3   úCallable[..., Any]c                óz   — t        | t        «      s| j                  }n| }|j                  }t	        ||«      }||k7  S )z1Return True if the two class methods don't match.)r\   ÚtypeÚ	__class__rJ   Úgetattr)Úinstance_or_clsÚagainst_methodÚcurrent_clsÚmethod_nameÚcurrent_methods        r1   Úmethod_is_overriddenrw       s@   € ô �o¤tÔ,Ø%×/Ñ/‰à%ˆà ×)Ñ)€Kä'.¨{¸KÓ'H€Nà˜^Ñ+Ð+r3   c                óÆ   — g }| j                   | j                  | j                  fD ]/  }t        |d«      r|j	                  «       }|j                  |«       Œ1 t        |«      S )zrdecode a slice object as sent to __getitem__.

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

    Ú	__index__)ÚstartÚstopÚstepÚhasattrry   ÚappendÚtuple)ÚslcÚretr/   s      r1   Údecode_slicer‚   ²   sW   € ð €CØ�Y‰Y˜Ÿ™ #§(¡(Ð*ò ˆÜ�1�kÔ"Ø—‘“ˆAØ�
‰
�1�ðô �‹:Ðr3   c           
   '  óê   ‡K  — t        | «      }|D ]^  Št        j                  ‰ft        ˆfd„t	        d«      «      «      }|D ]  }||vsŒ|j                  |«       |–—  ŒQ t        d‰z  «      ‚ y ­w)Nc                ó    •— ‰t        | «      z   S r8   ©r-   )ÚiÚbases    €r1   ú<lambda>z!_unique_symbols.<locals>.<lambda>Å   s   ø€ ˜$¤ Q£™-€ r3   iè  z&exhausted namespace for symbol base %s)rR   Ú	itertoolsÚchainÚmapÚrangerT   Ú	NameError)ÚusedÚbasesÚused_setÚpoolÚsymr‡   s        @r1   Ú_unique_symbolsr“   À   s…   øè ø€ Ü�4‹y€HØò MˆÜ�‰ØˆGÜÓ'¬¨t«Ó5ó
ˆð ò 	MˆCØ˜(Ò"Ø—‘˜SÔ!Ø’	Ùð		Mô ÐDÀtÑKÓLÐLñMùs   ƒAA3Á(A3c              #  óH   K  — |r|| dz   z  } | |«      –— ||z  }|rŒyy­w)z6Call the given function given each nonzero bit from n.r   NrP   )Úfnre   Úbs      r1   Úmap_bitsr—   Ð   s1   è ø€ ñ Ø�!��a‘‰LˆÙ�‹eŠØ	ˆQ‰ˆô ùs   ‚" "Ú_Fnc                ó(   ‡ — dˆ fd„}t        |‰ «      S )z'A signature-matching decorator factory.c                ó"  •— t        j                  | «      s t        j                  | «      st        d«      ‚t	        | dd «      }|�%d | _        	 t        j                  | «      }|| _        nt        j                  | «      }dt        |j                  xs d«      z  }t        j                  |j                  xs d«      }|j                  i ||¬«      }t        t        d|d   «      «      t        d|dd	 «      z   | j                   fz   }t#        |d
d«      \  }}t        ||¬«      }|j%                  t'        |d¬«      «       | j                   |d<   t        j(                  | «      rd|d<   d|d<   n
d|d<   d|d<   dt+        |d   «      v rd|z  }	nd|z  }	|‰|| d| j,                  i}
t        t.        j0                  t3        |	|
| j                   «      «      }| j4                  |_        | j6                  |_        t9        || «      S # || _        w xY w)Nznot a decoratable functionÚ__annotate__r8   rP   )r   ÚdefaultsÚkwonlydefaultszTuple[str, ...]r   r   é   Útargetr•   )rŸ   r•   F©Úgroupedrk   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)
rJ   )ÚinspectÚ
isfunctionÚismethodr]   rq   r›   r   Úinspect_getfullargspecÚlenrœ   ÚdictÚfromkeysr�   Ú_replacer   r	   rJ   r“   r,   Úformat_argspec_plusÚiscoroutinefunctionÚreprrK   Ú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   Údecoratezdecorator.<locals>.decorateá   s%  ø€ Ü×!Ñ! "Ô%¬g×.>Ñ.>¸rÔ.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Ñˆ	�7ä-1¸ÀwÔ-OˆØ�‰Ô+¨D¸%Ô@ÔAØŸ;™;ˆ�Ñä×&Ñ& rÔ*Ø!)ˆH�XÑØ(0ˆH�_Ò%à!#ˆH�XÑØ(*ˆH�_Ñ%ð ”4˜˜Q™“=Ñ ðð ñ‰Dð
ð ñˆDð �vØ�RØ˜Ÿ™ð
ˆô Ü×ÑÜ˜d C¨¯©Ó5ó
ˆ	ð "$§¡ˆ	ÔØ#%×#4Ñ#4ˆ	Ô Ü˜i¨Ó,Ð,øðE #+�•ús   ÁH È	H)r•   r˜   rH   r˜   r   )rŸ   rÁ   s   ` r1   Ú	decoratorrÂ   Þ   s   ø€ õN-ô` ˜( FÓ+Ð+r3   c                ó$   — t        | |«       ||   S r8   )Úexec)r¾   r¿   r¼   s      r1   r³   r³   4  s   € ô 	ˆˆs„OØˆw‰<Ðr3   Ú_PFÚ_TEc                  ó<   — e Zd Z	 d	 	 	 dd„Zd„ Zd	d„Zd
d„Zdd„Zy)ÚPluginLoaderNc                ó.   — || _         i | _        || _        y r8   )ÚgroupÚimplsÚauto_fn)r<   rÊ   rÌ   s      r1   Ú__init__zPluginLoader.__init__@  s   € ð ˆŒ
Ø%'ˆŒ
Øˆ�r3   c                ó8   — | j                   j                  «        y r8   )rË   Úclearr;   s    r1   rÏ   zPluginLoader.clearG  s   € Ø�
‰
×ÑÕr3   c                ó¶  — || j                   v r | j                   |   «       S | j                  r)| j                  |«      }|r|| j                   |<    |«       S t        j                  | j                  «      D ]<  }|j
                  |k(  sŒ|j                  | j                   |<   |j                  «       c S  t        j                  d| j                  ›d|›�«      ‚)NzCan't load plugin: ú:)	rË   rÌ   r   Úimportlib_metadata_getrÊ   rk   Úloadr   ÚNoSuchModuleError)r<   rk   ÚloaderÚimpls       r1   rÓ   zPluginLoader.loadJ  s¸   € Ø�4—:‘:ÑØ#�4—:‘:˜dÑ#Ó%Ð%à�<Š<Ø—\‘\ $Ó'ˆFÙØ#)�—
‘
˜4Ñ Ù“x�ä×1Ñ1°$·*±*Ó=ò 	#ˆDØ�y‰y˜DÓ Ø#'§9¡9�—
‘
˜4Ñ Ø—y‘y“{Ò"ð	#ô
 ×#Ò#Ø*.¯*«*±dÐ;ó
ð 	
r3   c                ó2   ‡‡— ˆˆfd„}|| j                   |<   y )Nc                 ó|   •— t        ‰«      } ‰j                  d«      dd  D ]  }t        | |«      } Œ t        | ‰«      S )Nú.r   )Ú
__import__Úsplitrq   )ÚmodÚtokenÚ
modulepathÚobjnames     €€r1   rÓ   z#PluginLoader.register.<locals>.load^  sG   ø€ Ü˜ZÓ(ˆCØ#×)Ñ)¨#Ó.¨q¨rÐ2ò *�Ü˜c 5Ó)‘ð*ä˜3 Ó(Ð(r3   ©rË   )r<   rk   rÞ   rß   rÓ   s     `` r1   ÚregisterzPluginLoader.register]  s   ù€ õ	)ð  ˆ�
‰
�4Òr3   c                ó   — | j                   |= y r8   rà   )r<   rk   s     r1   Ú
deregisterzPluginLoader.deregisterf  s   € Ø�J‰J�tÑr3   r8   )rÊ   r-   rÌ   zOptional[Callable[..., Any]])rk   r-   rH   r   )rk   r-   rÞ   r-   rß   r-   rH   rI   )rk   r-   rH   rI   )rJ   rK   rL   rÍ   rÏ   rÓ   rá   rã   rP   r3   r1   rÈ   rÈ   ?  s.   „ àBFðØðØ#?óòó
ó& ôr3   rÈ   c                ó"  — 	 t         j                  }| j                  }|j                  }t	        |j
                  d | «      t        |j                  |z  «      fS # t        $ r+ t        j                  | «      }|d   t        |d   «      fcY S w xY w)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ð   j  sŽ   € ð
Ü ×/Ñ/ˆð �[‰[ˆØ—‘ˆä�—‘  Ð'Ó(Ü�—‘˜~Ñ-Ó.ð
ð 	
øô ò &ô
 ×,Ñ,¨RÓ0ˆØ�A‰wœ˜T !™W›Ð%Ò%ð&ús   ‚A Á1BÂB)Ú_setÚraiseerrc                ó   — y r8   rP   ©rW   rñ   rò   s      r1   Úget_cls_kwargsrõ   ~  s   € ð r3   Fc                ó   — y r8   rP   rô   s      r1   rõ   rõ   ‡  s   € ð r3   c               óÊ  — |du }|r
t        «       }|€J ‚| j                  j                  dd«      }|xr@ t        |t        j
                  «      xr$ t        |j                  t        j                  «      }|r5t        |«      \  }}|j                  |«       |s|s|rt        d| › d�«      ‚yd}|r|r | j                  D ]  }t        ||¬«      �Œ n |j                  d«       |S )ae  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<   )rR   Ú__dict__Úgetr\   r±   r²   ræ   r   rð   r,   Ú	TypeErrorÚ	__bases__rõ   Údiscard)	rW   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Ó/‰ˆˆvØ�‰�EÔá™hÙÜØ   Ð%EÐFóð ð àˆá‘vØ—‘ò 	ˆAÜ˜a dÔ+Ñ3Ùð	ð 	‡L�L�ÔØ€Kr3   c                ó2   — t        j                  | «      d   S )zƒReturn 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           	     óü  — t        j                  | «      rt        d| z  «      ‚t        j                  | «      s6t	        | d«      r¼t        j
                  | «      s§t        j                  | «      s’|r{|ryt        j                  | «      }t        j                  |j                  dd |j                  |j                  |j                  |j                  |j                  |j                   «      S t        j                  | «      S t        j                  | «      r²|r‘|s| j"                  rƒt        j                  | j$                  «      }t        j                  |j                  dd |j                  |j                  |j                  |j                  |j                  |j                   «      S t        j                  | j$                  «      S t        j
                  | «      rt'        | j(                  |d¬«      S t	        | d«      rt        j                  | j$                  «      S t	        | d«      rDt        j                  | j*                  «      rt'        | j*                  |¬	«      S t        d
| z  «      ‚t        d
| z  «      ‚)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æ   r   NT)Úno_selfÚ_is_initÚ__func__Ú__call__)r  zCan't inspect callable: %s)r¦   Ú	isbuiltinrú   r§   r}   Úisclassr¨   r   r©   ÚFullArgSpecÚargsÚvarargsÚvarkwrœ   Ú
kwonlyargsr�   r   Ú__self__r  Úget_callable_argspecrÍ   r	  )r•   r  r  r·   s       r1   r  r  Í  sñ  € ô ×Ñ˜ÔÜÐ3°bÑ8Ó9Ð9Ü	×	Ñ	˜BÔ	Ü��JÔÜ—‘ Ô#Ü× Ñ  Ô$á™Ü×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           
     óú  — t        | «      rt        j                  | «      }n| }t        j                  |Ž }t        j                  |d   |d   |d   d|d   «      }|d   r1|d   d   }t        j                  |d   dd |d   |d   d|d   «      }n|d   rd|d   z  }|}nd}|}d}|d   r&|t	        t        t        t           |d   «      «      z  }|d   r|t	        |d   «      z  }|d   |d   z   }|r	|d|z
  d }	nd}	t        j                  ||d   |d   |	d	„ ¬
«      }
|d   r%t        j                  |dd |d   |d   |	d„ ¬
«      }n|
}|rt        ||||
||¬«      S t        |||dd |
dd |dd |dd ¬«      S )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ž   rP   c                ó   — dt        | «      z   S ©Nú=r…   ©r/   s    r1   rˆ   z%format_argspec_plus.<locals>.<lambda>\  s   € ˜c¤C¨£F™l€ r3   )Úformatvaluec                ó   — dt        | «      z   S r  r…   r  s    r1   rˆ   z%format_argspec_plus.<locals>.<lambda>e  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                ó¼   — | t         j                  u rd}|rdnd}|rdnd}n	 t        | |¬«      S t	        d|||||¬
«      S # t        $ r d}|r|nd}|rdnd	}Y Œ*w xY w)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°wÔ?Ð?ô
 ØØ!ØØØ!Ø ôð øô	 ò 	LØ4ˆLÙ#*‘<Ð0GˆDÙ-4Ñ)Ð:KŠGð	Lús   £A ÁAÁAc                ó   — d„ }|S )aS  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                ó   — | S r8   rP   )rW   s    r1   rÁ   z&create_proxy_methods.<locals>.decorate²  s   € Øˆ
r3   rP   )Ú
target_clsÚtarget_cls_sphinx_nameÚproxy_cls_sphinx_nameÚclassmethodsÚmethodsÚ
attributesÚuse_intermediate_variablerÁ   s           r1   Úcreate_proxy_methodsr5  Ÿ  s   € ò&ð €Or3   c                ó�   — 	 t        j                  | «      S # t        $ r% | t        j                  u r	dgdddfcY S dgdddfcY S w xY w)a  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ú   r(  rÍ   )r)  s    r1   Úgetargspec_initr8  ¸  sU   € ð6Ü×,Ñ,¨VÓ4Ð4øÜò 6Ø”V—_‘_Ñ$Ø�H˜d D¨$Ð/Ò/à�H˜f h°Ð5Ò5ð	6ús   ‚ —"A»AÁAc                ój   — t        | t        j                  «      r| j                  s| j                  S | S )zSAdjust the incoming callable such that a 'self' argument is not
    required.

    )r\   r±   Ú
MethodTyper  r  )Úfunc_or_clss    r1   Úunbound_method_to_callabler<  Ì  s.   € ô �+œu×/Ñ/Ô0¸×9MÒ9MØ×#Ñ#Ð#àÐr3   c           	     óŠ  ‡ — |€‰ g}nt        j                  |«      }t        «       }g }t        j                  «       }d}t	        |«      D �]/  \  }}		 t        j                  |	j                  «      }
|
j                  rt        |
j                  «      nd}|dk(  rY|
j                  r|
j                  }|r |j                  |
j                  d|  «       nN|j                  |
j                  dd «       n/|j                  |
j                  d|  D �cg c]  }||f‘Œ c}«       |sŒÚ|
j                  sJ ‚|j                  t        |
j                  | d |
j                  «      D ��cg c]	  \  }}||f‘Œ c}}«       �Œ2 g }|j                  ˆ fd„|D «       «       |�>t!        ‰ |«      r2|j                  t#        ‰ |«      D �cg c]  }t%        |«      ‘Œ c}«       |j'                  «       D ]7  \  }}||v rŒ	 t#        ‰ ||«      }||ur||k7  r|j)                  |›d|›�«       Œ9 |r7|D ]2  \  }}	 t#        ‰ ||«      }||ur||k7  r|j)                  |›d|›�«       Œ4 ‰ j,                  j.                  ›ddj1                  |«      ›d�S c c}w c c}}w # t        $ r Y �ŒTw xY wc c}w # t*        $ r Y ŒÉw xY w# t*        $ r Y Œšw xY w)	z}Produce a __repr__() based on direct association of the __init__()
    specification vs. same-named attributes present.

    Nr   r   c              3  óJ   •K  — | ]  }t        t        ‰|d «      «      –— Œ y ­wr8   )r°   rq   )rd   ÚargÚobjs     €r1   rf   zgeneric_repr.<locals>.<genexpr>  s   øè ø€ ÒD°C”$”w˜s C¨Ó.×/ÑDùs   ƒ #r  ú(ú, ú))r   Úto_listr(  ÚOrderedDictÚ	enumerater   r©   rÍ   rœ   rª   r  rU   r  r,   Úziprú   r}   rq   r°   Úitemsr~   r]   rp   rJ   rg   )r@  Úadditional_kwÚ
to_inspectÚ
omit_kwargÚmissingÚpos_argsÚkw_argsÚvargsr†   Úinspr·   Údefault_lenr?  ÚdefaultÚoutputÚvalÚdefvals   `                r1   Úgeneric_reprrV  Ø  s®  ø€ ð ÐØ�U‰
ä!×)Ñ)¨*Ó5ˆ
ä‹h€Gà€HÜ2>×2JÑ2JÓ2L€GØ€EÜ˜ZÓ(ó ‰ˆˆ4ð	Ü×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¨�c˜7’^ÒIôò Ø—}’}Ð$�}Ø—‘ô -0Ø ŸI™I { l mÐ4°d·m±mó-÷á(˜C ð ˜gšóöð+ð: €Fà
‡M�MÓD¸8ÔDÔDàÐœW S¨%Ô0Ø�‰¬G°C¸Ó,?Ö@ S”t˜C•yÒ@ÔAà—}‘}“ò ‰ˆˆVØ�*ÑØð	Ü˜#˜s GÓ,ˆCØ˜'Ñ! c¨V¢mØ—‘ª©cÐ2Ô3øðñ Ø(ò 	‰KˆC�ðÜ˜c 3¨Ó0�Ø˜gÑ%¨#°ª-Ø—M‘MªS±#Ð"6Ô7øð		ð —}‘}×-Ó-¨t¯y©y¸Õ/@ÐAÐAùòO Jùóøô' ò 	Úð	üò> Aøô ò 	Ùð	ûô ò ÙðúsH   ÁJÄJ
Å$JÇ J"Ç5,J'È.,J6Ê	JÊJÊ'	J3Ê2J3Ê6	KËKc                  ó.   — e Zd ZdZdZd„ Zd„ Zdd„Zd„ Zy)	Úportable_instancemethodz_Turn an instancemethod into a (parent, name) pair
    to produce a serializable callable.

    )rŸ   rk   r7  Ú__weakref__c                óJ   — | j                   | j                  | j                  dœS )N©rŸ   rk   r7  r[  r;   s    r1   Ú__getstate__z$portable_instancemethod.__getstate__.  s!   € à—k‘kØ—I‘IØ—k‘kñ
ð 	
r3   c                óZ   — |d   | _         |d   | _        |j                  dd«      | _        y )NrŸ   rk   r7  rP   )rŸ   rk   rù   r7  )r<   Ústates     r1   Ú__setstate__z$portable_instancemethod.__setstate__5  s*   € Ø˜H‘oˆŒØ˜&‘MˆŒ	Ø—i‘i ¨"Ó-ˆ�r3   c                óV   — |j                   | _        |j                  | _        || _        y r8   )r  rŸ   rJ   rk   r7  )r<   Úmethr7  s      r1   rÍ   z portable_instancemethod.__init__:  s   € Ø—m‘mˆŒØ—M‘MˆŒ	Øˆ�r3   c                ó„   — |j                  | j                  «        t        | j                  | j                  «      |i |¤ŽS r8   )r,   r7  rq   rŸ   rk   )r<   r?  Úkws      r1   r	  z portable_instancemethod.__call__?  s3   € Ø
�	‰	�$—+‘+ÔØ.Œw�t—{‘{ D§I¡IÓ.°Ð:°rÑ:Ð:r3   N)rP   )	rJ   rK   rL   rM   rN   r\  r_  rÍ   r	  rP   r3   r1   rX  rX  &  s"   „ ñð
 :€Iò
ò.ó
ó
;r3   rX  c                ó  ‡— | hŠt        | j                  «      }|r×|j                  «       }ˆfd„|j                  D «       }|D ]$  }|j	                  |«       ‰j                  |«       Œ& |j                  dk(  st        |d«      sŒlt        |t        «      s|j                  «       n|j                  |«      D �cg c]  }|‰vr|‘Œ
 c}D ]$  }|j	                  |«       ‰j                  |«       Œ& |rŒ×t        ‰«      S c c}w )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  ó,   •K  — | ]  }|‰vsŒ|–— Œ y ­wr8   rP   )rd   Ú_Úhiers     €r1   rf   z"class_hierarchy.<locals>.<genexpr>S  s   øè ø€ Ò9�q¨1°Dª=”Ñ9ùs   ƒ	�ÚbuiltinsrV   )rè   Ú__mro__rS   rû   r~   rT   rK   r}   Ú
issubclassro   rV   )rW   Úprocessr  r�   r–   rf  Úsrg  s          @r1   Úclass_hierarchyrm  D  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Øô " !¤TÔ*ð × Ñ Ô"à×%Ñ% aÓ(ö
àð
 ˜‰}ò ò
ò 
	ˆAð �N‰N˜1ÔØ�H‰H�Q�Kð
	ò ô, �‹:Ðùò
s   Â9C>c              #  ó˜   K  — t        | «      }|D ]6  }| j                  D ]%  }||j                  v sŒ||j                  |   f–—  Œ6 Œ8 y­w)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)Údirri  rø   )rW   ÚkeysÚkeyr  s       r1   Úiterate_attributesrr  j  sU   è ø€ ô ˆs‹8€DØò ˆØ—‘ò 	ˆAØ�a—j‘jÒ Ø˜AŸJ™J s™OÐ,Ò,Ùñ	ñùs
   ‚.A
±A
c                óÐ  — |r|}nN|€d}t        |«      D �cg c]6  }|j                  d«      r#|j                  d«      rt        | |«      s||vr|‘Œ8 }}|D ]Ø  }	 t	        ||«      }	t        |	d«      sŒt	        |	d|	«      }	t        t        j                  |	«      }
	 t        j                  |
«      }t        j                  |d   «      }t        j                  |d   dd «      }d
t        «       z  }|duxr ||ixs i }t        ||«       	 |
j                  ||   _        t!        | |||   «       ŒÚ yc c}w # t        $ r Y Œìw xY w# t        $ r d}d	}Y Œrw xY w# t        $ r Y ŒEw xY w)z9Automates delegation of __specials__ for a proxying type.N)rN   Ú__del__Ú__getattribute__Ú__metaclass__r\  r_  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)ro  Ú
startswithÚendswithr}   rq   r	   r±   r²   rì   r   r©   r#  rú   ÚlocalsrÄ   r´   Úsetattr)Úinto_clsÚfrom_clsÚskipÚonlyrk   Úfrom_instanceÚdundersr0   r)  Úmaybe_fnr•   r·   Úfn_argsÚd_argsÚpyr¿   s                   r1   Úmonkeypatch_proxied_specialsr…  z  s   € ñ Ø‰àˆ<ðˆDô ˜“]ö	
àà—‘˜TÔ"Ø—J‘J˜tÔ$Ü ¨!Ô,Ø˜T‘Mò ð	
ˆð 	
ð ò /ˆð	Ü˜x¨Ó0ˆHÜ˜8 ZÔ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Ô$ô 	�˜& # f¡+Õ.ñ?/ùò	
øô& ò 	Ùð	ûô ò 	%Ø+ˆGØ$ŠFð	%ûô ò 	Ùð	úsB   —;D2ÁD7Á3'D7ÂAEÄEÄ7	EÅEÅEÅEÅ	E%Å$E%c                ó6   — t        | d| «      t        |d|«      u S )z;Return True if the two methods are the same implementation.r  )rq   )Úmeth1Úmeth2s     r1   Úmethods_equivalentr‰  ½  s(   € ô �5˜* eÓ,´Øˆz˜5ó1ð ð r3   c           	     óÚ  — |s|st        d«      ‚t        |t        «      rt        | |«      r| S t        |xs+ t	        |«      D �cg c]  }|j                  d«      rŒ|‘Œ c}«      }t        t	        | «      «      }t        j                  }t        |t        «      r|}n(|st        «       }t        j                  }nt        |«      } ||j                  |«      |«      r| S t        | t        «      s<|t        j                  u xr dxs d}t        | ›d|›ddj                  |«      ›�«      ‚ G d„ d	«      }	|rd
|j                  z   |	_        t        «       }
t        | «      D ]Z  \  }}||vrt        d|z  «      ‚t        |«      st        |›d|›d�«      ‚t        |	|t!        |«      «       |
j#                  |«       Œ\  ||
|«      r|	S t        ddj                  ||
z
  «      z  «      ‚c c}w )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 requiredrf  zany ofzall ofz does not implement z: rB  c                  ó   — e Zd ZdZy)ú(as_interface.<locals>.AnonymousInterfacezA callable-holding shell.N©rJ   rK   rL   rM   rP   r3   r1   ÚAnonymousInterfacerŒ    s   „ Ú'r3   rŽ  Ú	Anonymousz%r: unknown in this interfacer  z is not callablez,dictionary does not contain required keys %s)rú   r\   ro   rR   ro  rw  ÚoperatorÚgeÚgtÚintersectionr«   rg   rJ   Údictlike_iteritemsr"  rz  ÚstaticmethodrT   )r@  rW   r2  Úrequiredr0   Ú	interfaceÚimplementedÚcompliesÚ	qualifierrŽ  Úfoundr)  rÖ   s                r1   Úas_interfacerœ  Å  sÅ  € ñB ‘wÜÐLÓMÐMä�#”tÔ¤¨C°Ô!5Øˆ
ä�GÒM¬3¨s«8ÖM a¸1¿<¹<ÈÕ;L¢Ò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ÜÐ" F¬L¸Ó,>Ô?Ø�	‰	�&Õðñ ��xÔ Ø!Ð!ä
Ø6Ø
�)‰)�H˜uÑ$Ó
%ñ	&óð ùòS  Ns   ÁG(ÁG(Ú_GFDzgeneric_fn_descriptor[Any]c                  ó”   — e Zd ZU dZded<   ded<   ded<   ddd	„Zedd
„«       Zedd„«       Zdd„Zerdd„Z	dd„Z
dd„Zedd„«       Zy)Úgeneric_fn_descriptorag  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]rM   r-   rJ   Nc                ó^   — || _         |xs |j                  | _        |j                  | _        y r8   ©r¡  rM   rJ   ©r<   r¡  Údocs      r1   rÍ   zgeneric_fn_descriptor.__init__-  s$   € ØˆŒ	ØÒ*˜dŸl™lˆŒØŸ™ˆ�r3   c                 ó   — y r8   rP   ©r<   r@  rW   s      r1   Ú__get__zgeneric_fn_descriptor.__get__2  s   € Ø:=r3   c                 ó   — y r8   rP   r¨  s      r1   r©  zgeneric_fn_descriptor.__get__5  s   € Ø7:r3   c                ó   — t        «       ‚r8   ©ÚNotImplementedErrorr¨  s      r1   r©  zgeneric_fn_descriptor.__get__8  ó   € Ü!Ó#Ð#r3   c                 ó   — y r8   rP   ©r<   ÚinstancerA   s      r1   Ú__set__zgeneric_fn_descriptor.__set__=  ó   � r3   c                 ó   — y r8   rP   )r<   r±  s     r1   Ú
__delete__z generic_fn_descriptor.__delete__?  r³  r3   c                ó   — t        «       ‚r8   r¬  ©r<   r@  s     r1   Ú_resetzgeneric_fn_descriptor._resetA  r®  r3   c                ó   — t        «       ‚r8   r¬  ©rW   r@  rk   s      r1   Úresetzgeneric_fn_descriptor.resetD  s   € ä!Ó#Ð#r3   r8   )r¡  r   r¦  r¢  )r<   r�  r@  rI   rW   r   rH   r�  )r@  r(  rW   r   rH   r!   )r<   r�  r@  r   rW   r   rH   zUnion[_GFD, _T_co]©r±  r   rA   r   rH   rI   ©r±  r   rH   rI   )r@  r   rH   rI   )r@  r   rk   r-   rH   rI   )rJ   rK   rL   rM   rO   rÍ   r   r©  r   r²  rµ  r¸  Úclassmethodr»  rP   r3   r1   rŸ  rŸ    sf   … ñð ÓØÓØƒMô&ð
 Ú=ó Ø=àÚ:ó Ø:ó$ñ ãAã8ó$ð ò$ó ñ$r3   rŸ  c                  ó   — e Zd ZdZesd„ Zyy)Ú_non_memoized_propertyzÉ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                ó,   — |€| S | j                  |«      S r8   ©r¡  r¨  s      r1   r©  z_non_memoized_property.__get__T  s   € Øˆ{Ø�Ø—9‘9˜S“>Ð!r3   N)rJ   rK   rL   rM   r   r©  rP   r3   r1   rÀ  rÀ  I  s   „ ññ ó	"ð r3   rÀ  c                  ó0   — e Zd ZdZesd„ Zd„ Zed„ «       Zy)Ú_memoized_propertyz2A read-only @property that is only evaluated once.c                ób   — |€| S | j                  |«      x|j                  | j                  <   }|S r8   )r¡  rø   rJ   ©r<   r@  rW   Úresults       r1   r©  z_memoized_property.__get___  s0   € Øˆ{Ø�Ø37·9±9¸S³>ÐAˆC�L‰L˜Ÿ™Ñ'¨&ØˆMr3   c                óD   — t         j                  || j                  «       y r8   )rÄ  r»  rJ   r·  s     r1   r¸  z_memoized_property._resete  s   € Ü× Ñ   d§m¡mÕ4r3   c                ó<   — |j                   j                  |d «       y r8   )rø   rS   rº  s      r1   r»  z_memoized_property.reseth  s   € à�‰×Ñ˜˜tÕ$r3   N)	rJ   rK   rL   rM   r   r©  r¸  r¾  r»  rP   r3   r1   rÄ  rÄ  Z  s&   „ Ù<áò	ò5ð ñ%ó ñ%r3   rÄ  c                ó&   ‡ — ˆ fd„}t        |‰ «      S )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                ó¢   •‡—  ‰| g|¢­i |¤ŽŠˆfd„}‰j                   |_         ‰j                  |_        || j                  ‰j                   <   ‰S )Nc                 ó   •— ‰S r8   rP   ©Úarc  rÇ  s     €r1   Úmemoz6memoized_instancemethod.<locals>.oneshot.<locals>.memo•  s   ø€ ØˆMr3   )rJ   rM   rø   ©r<   r  rc  rÏ  rÇ  r•   s       @€r1   Úoneshotz(memoized_instancemethod.<locals>.oneshot’  sK   ù€ Ù�DÐ&˜4Ò& 2Ñ&ˆô	ð Ÿ™ˆŒØ—z‘zˆŒØ%)ˆ�‰�b—k‘kÑ"Øˆr3   r   )r•   rÑ  s   ` r1   Úmemoized_instancemethodrÒ  ‰  s   ø€ ô	ô ˜' 2Ó&Ð&r3   c                  óx   — e Zd ZU dZesdZ e«       Zded<   dd„Z	dd„Z
dd„Z G d„ d	ee   «      Zedd
„«       Zy)ÚHasMemoizedzA mixin class that maintains the names of memoized elements in a
    collection for easy cache clearing, generative, etc.

    rP   zFrozenSet[str]Ú_memoized_keysc                ó^   — | j                   D ]  }| j                  j                  |d «       Œ  y r8   )rÕ  rø   rS   ©r<   Úelems     r1   Ú_reset_memoizationszHasMemoized._reset_memoizations­  s+   € Ø×'Ñ'ò 	*ˆDØ�M‰M×Ñ˜d DÕ)ñ	*r3   c                óF   — | j                   D ]  }|| j                  vrŒJ ‚ y r8   )rÕ  rø   r×  s     r1   Ú_assert_no_memoizationsz#HasMemoized._assert_no_memoizations±  s)   € Ø×'Ñ'ò 	-ˆDØ˜tŸ}™}Ò,Ð,Ð,ñ	-r3   c                óN   — || j                   |<   | xj                  |hz  c_        y r8   )rø   rÕ  )r<   rq  rA   s      r1   Ú_set_memoized_attributez#HasMemoized._set_memoized_attributeµ  s#   € Ø"ˆ�‰�cÑØ×Ò ˜uÑ$Ör3   c                  ód   — e Zd ZU dZded<   ded<   ded<   ddd	„Zedd
„«       Zedd„«       Zd„ Zy)úHasMemoized.memoized_attributezTA read-only @property that is only evaluated once.

        :meta private:

        úCallable[..., _T]r¡  r¢  rM   r-   rJ   Nc                ó^   — || _         |xs |j                  | _        |j                  | _        y r8   r¤  r¥  s      r1   rÍ   z'HasMemoized.memoized_attribute.__init__Ä  s$   € ØˆDŒIØÒ. $§,¡,ˆDŒLØ ŸM™MˆD�Mr3   c                 ó   — y r8   rP   r¨  s      r1   r©  z&HasMemoized.memoized_attribute.__get__É  s   € Ø<?r3   c                 ó   — y r8   rP   r¨  s      r1   r©  z&HasMemoized.memoized_attribute.__get__Ì  s   € Ø58r3   c                ó¢   — |€| S | j                  |«      x|j                  | j                  <   }|xj                  | j                  hz  c_        |S r8   )r¡  rø   rJ   rÕ  rÆ  s       r1   r©  z&HasMemoized.memoized_attribute.__get__Ï  sG   € Øˆ{Ø�Ø37·9±9¸S³>ÐAˆC�L‰L˜Ÿ™Ñ'¨&Ø×Ò 4§=¡= /Ñ1ÕØˆMr3   r8   )r¡  rà  r¦  r¢  )r<   r&   r@  rI   rW   r   rH   r&   )r@  r   rW   r   rH   r    )rJ   rK   rL   rM   rO   rÍ   r   r©  rP   r3   r1   Úmemoized_attributerß  ¹  sB   … ñ	ð  ÓØÓØ‹ô	*ð
 
Ú?ó 
Ø?à	Ú8ó 
Ø8ó	r3   rå  c                ó(   ‡— dˆfd„}t        |‰«      S )zMDecorate a method memoize its return value.

        :meta private:

        c                óâ   •‡—  ‰| g|¢­i |¤ŽŠˆfd„}‰j                   |_         ‰j                  |_        || j                  ‰j                   <   | xj                  ‰j                   hz  c_        ‰S )Nc                 ó   •— ‰S r8   rP   rÍ  s     €r1   rÏ  zBHasMemoized.memoized_instancemethod.<locals>.oneshot.<locals>.memoá  s   ø€ Ø�r3   )rJ   rM   rø   rÕ  rÐ  s       @€r1   rÑ  z4HasMemoized.memoized_instancemethod.<locals>.oneshotÞ  sb   ù€ Ù˜Ð*˜tÒ* rÑ*ˆFôð ŸK™KˆDŒMØŸ:™:ˆDŒLØ)-ˆD�M‰M˜"Ÿ+™+Ñ&Ø×Ò B§K¡K =Ñ0ÕØˆMr3   )r<   r   r  r   rc  r   rH   r   r   )rW   r•   rÑ  s    ` r1   rÒ  z#HasMemoized.memoized_instancemethodÖ  s   ø€ õ
	ô ˜g rÓ*Ð*r3   NrG   )rq  r-   rA   r   rH   rI   ©r•   r#   rH   r#   )rJ   rK   rL   rM   r   rN   Ú	frozensetrÕ  rO   rÙ  rÛ  rÝ  Úmemoized_propertyr    rå  r¾  rÒ  rP   r3   r1   rÔ  rÔ     sT   … ññ
 ð ˆ	á%.£[€N�NÓ0ó*ó-ó%ôÐ.¨rÑ2ô ð: ò+ó ñ+r3   rÔ  c                  ó"   — e Zd ZdZdZd„ Zdd„Zy)ÚMemoizedSlotsaT  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.

    rP   c                ó   — t        |«      ‚r8   )rì   )r<   rq  s     r1   Ú_fallback_getattrzMemoizedSlots._fallback_getattr   s   € Ü˜SÓ!Ð!r3   c                ó€  ‡ ‡‡— ‰j                  d«      s‰j                  d«      rt        ‰«      ‚t        ‰ j                  d‰› �«      r# t	        ‰ d‰› �«      «       }t        ‰ ‰|«       |S t        ‰ j                  d‰› �«      r)t	        ‰ d‰› �«      Šˆˆˆ fd„}‰j                  |_        |S ‰ j                  ‰«      S )NÚ_memoized_attr_Ú_memoized_method_c                 ó‚   •‡—  ‰| i |¤ŽŠˆfd„}‰j                   |_         ‰j                  |_        t        ‰‰|«       ‰S )Nc                 ó   •— ‰S r8   rP   rÍ  s     €r1   rÏ  z8MemoizedSlots.__getattr__.<locals>.oneshot.<locals>.memo  s   ø€ Ø!�Mr3   )rJ   rM   rz  )r  rc  rÏ  rÇ  rq  ra  r<   s      @€€€r1   rÑ  z*MemoizedSlots.__getattr__.<locals>.oneshot  s@   ù€ Ù˜tÐ* rÑ*�ô"ð !%§¡�”Ø#Ÿ|™|�”Ü˜˜c 4Ô(Ø�r3   )rw  rì   r}   rp   rq   rz  rM   rï  )r<   rq  rA   rÑ  ra  s   ``  @r1   Ú__getattr__zMemoizedSlots.__getattr__  s½   ú€ Ø�>‰>Ð+Ô,°·±Øô1
ô ! Ó%Ð%ô �T—^‘^ °s°eÐ%<Ô=Ø:”G˜D O°C°5Ð"9Ó:Ó<ˆEÜ�D˜#˜uÔ%ØˆLÜ�T—^‘^Ð'8¸¸Ð%>Ô?Ü˜4Ð#4°S°EÐ!:Ó;ˆDö	ð #Ÿl™lˆGŒOØˆNà×)Ñ)¨#Ó.Ð.r3   N)rq  r-   rH   r   )rJ   rK   rL   rM   rN   rï  rõ  rP   r3   r1   rí  rí  ó  s   „ ñð €Iò"ô/r3   rí  c                ó¤   — t        | t        «      r6| j                  «       j                  «       } | dv ry| dv ryt	        d| z  «      ‚t        | «      S )N)ÚtrueÚyesÚonÚyÚtÚ1T)ÚfalseÚnoÚoffre   ÚfÚ0FzString is not true/false: %r)r\   r-   Ústriprc   Ú
ValueErrorrê   )r@  s    r1   Úasboolr  $  sS   € Ü�#”sÔØ�i‰i‹k×ÑÓ!ˆØÐ6Ñ6ØØÐ9Ñ9ØäÐ;¸cÑAÓBÐBÜ�‹9Ðr3   c                 ó   ‡ — dˆ fd„}|S )zqReturn a callable that will evaluate a string as
    boolean, or one of a set of "alternate" string values.

    c                ó&   •— | ‰v r| S t        | «      S r8   )r  )r@  Útexts    €r1   Úbool_or_valuez"bool_or_str.<locals>.bool_or_value6  s   ø€ Ø�$‰;ØˆJä˜#“;Ðr3   )r@  r-   rH   zUnion[str, bool]rP   )r  r  s   ` r1   Úbool_or_strr	  0  s   ø€ õð Ðr3   c                ó    — | €| S t        | «      S )zCoerce to integer.)Úint)rA   s    r1   Úasintr  ?  s   € ð €}ØˆÜˆu‹:Ðr3   c                ó¶   — |€| }|| v rQt        |t        «      rt        | |   |«      s1| |   �+|t        u r|rt        | |   «      ||<   y || |   «      ||<   yyyy)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)r\   ro   rê   r  )rc  rq  r@   Ú
flexi_boolÚdests        r1   Úcoerce_kw_typer  G  ss   € ð €|Øˆð 	ˆr‰	Ü˜E¤4Ô(´
¸2¸c¹7ÀEÔ0JØˆs‰GÐà”D‰=™ZÜ˜r #™w›ˆD�ŠIá˜b ™g›ˆD�ŠIð  ð 1Kð 	r3   c                óJ   ‡ — t        |«      }|ft        ˆ fd„|D «       «      z   S )zbProduce a tuple structure that is cacheable using the __dict__ of
    obj to retrieve values

    c              3  ó^   •K  — | ]$  }|‰j                   v sŒ|‰j                   |   f–— Œ& y ­wr8   ©rø   ©rd   Úkr@  s     €r1   rf   z"constructor_key.<locals>.<genexpr>g  s.   øè ø€ ò Ø!"¨q°C·L±LÒ/@ˆˆC�L‰L˜‰OÔñùó   ƒ-—-)rõ   r   )r@  rW   rº   s   `  r1   Úconstructor_keyr  a  s2   ø€ ô
 ˜3Ó€EØˆ6”Eó Ø&+ôó ñ ð r3   c                ó|   ‡ — t        |«      }|j                  ˆ fd„|j                  |«      D «       «        ||i |¤ŽS )z„Instantiate cls using the __dict__ of obj as constructor arguments.

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

    c              3  ó^   •K  — | ]$  }|‰j                   v sŒ|‰j                   |   f–— Œ& y ­wr8   r  r  s     €r1   rf   z#constructor_copy.<locals>.<genexpr>t  s.   øè ø€ ò Ø!"¸aÀ3Ç<Á<Ò>OˆˆC�L‰L˜‰OÔñùr  )rõ   r,   Ú
difference)r@  rW   r  rc  rº   s   `    r1   Úconstructor_copyr  l  sE   ø€ ô ˜3Ó€EØ‡I�Ió Ø&+×&6Ñ&6°rÓ&:ôô ñ �Ð˜ÑÐr3   c                 óh   ‡‡— t        j                  «       Št        j                  d«      Šˆˆfd„} | S )z%Return a threadsafe counter function.r   c                 óJ   •— ‰5  t        ‰ «      cd d d «       S # 1 sw Y   y xY wr8   )Únext)ÚcounterÚlocks   €€r1   Ú_nextzcounter.<locals>._next�  s"   ø€ Øñ 	!Ü˜“=÷	!÷ 	!ò 	!ús   „™")Ú	threadingÚLockr‰   Úcount)r!  r  r   s    @@r1   r  r  z  s+   ù€ ô �>‰>Ó€DÜ�o‰o˜aÓ €Gõ!ð €Lr3   c                ó¤  — t        | d«      r8| j                  � t        | j                  t        «      rt        S | j                  S t	        | t
        «      rt        nt        } || t        «      rt        S  || t        «      rt        S  || t        «      rt        S t        | d«      rt        S t        | d«      rt        S t        | d«      rt        S |S )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~   rT   rR   )r}   r&  rj  rR   r\   ro   rè   r«   )ÚspecimenrR  Úisas      r1   Úduck_type_collectionr)  ˆ  s®   € ô ˆx˜Ô(à× Ñ Ð,´Ø×!Ñ!¤3ô2
ô ˆJà×(Ñ(Ð(ä" 8¬TÔ2�*¼
€CÙ
ˆ8”TÔÜˆÙ	ˆX”sÔ	Üˆ
Ù	ˆX”tÔ	Üˆäˆx˜Ô"ÜˆÜ	�˜5Ô	!Üˆ
Ü	�˜5Ô	!Üˆàˆr3   c           
     ó
  — t        | |«      r| S t        |t        «      r>t        j                  d|›ddj	                  d„ |D «       «      ›dt        | «      ›d�«      ‚t        j                  d|›d|›dt        | «      ›d�«      ‚)	Nz
Argument 'z ' is expected to be one of type z or c              3  ó&   K  — | ]	  }d |z  –— Œ y­w)z'%s'NrP   )rd   rÎ  s     r1   rf   z"assert_arg_type.<locals>.<genexpr>´  s   è ø€ Ò$A°A V¨a¥ZÑ$Aùs   ‚z, got 'ú'z' is expected to be of type 'z', got ')r\   r   r   ÚArgumentErrorrg   ro   )r?  Úargtyperk   s      r1   Úassert_arg_typer/  «  su   € ô �#�wÔØˆ
ä�gœuÔ%Ü×#Ò#â˜Ÿ™Ñ$A¸Ô$AÕAÄ4ÈÅ9ðNóð ô
 ×#Ò#âš¤$ s¥)ð-óð r3   c           	     óJ  ‡ ‡— t        ‰ d«      rt        ‰ j                  «       «      S t        ‰ dt        ‰ dd«      «      Š‰€t	        d‰ z  «      ‚t        ‰ d«      rˆ ˆfd„} |«       S t        ‰ d«      r"t        ˆfd	„‰ j                  «       D «       «      S t	        d‰ z  «      ‚)
z?Return a (key, value) iterator for almost any dict-like object.rH  Ú__getitem__rù   NzObject '%r' is not dict-likeÚiterkeysc               3  óX   •K  — ‰j                  «       D ]  } ‰€J ‚|  ‰| «      f–— Œ y ­wr8   )r2  )rq  ÚdictlikeÚgetters    €€r1   Úiteratorz$dictlike_iteritems.<locals>.iteratorÉ  s:   øè ø€ Ø×(Ñ(Ó*ò '�ØÐ)Ð)Ð)Ø™6 #›;Ð&Ó&ñ'ùs   ƒ'*rp  c              3  ó2   •K  — | ]  }| ‰|«      f–— Œ y ­wr8   rP   )rd   rq  r5  s     €r1   rf   z%dictlike_iteritems.<locals>.<genexpr>Ð  s   øè ø€ ÒB¨3�S™& ›+Ô&ÑBùs   ƒ)r}   rè   rH  rq   rú   Úiterrp  )r4  r6  r5  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                  ó:   ‡ — e Zd ZU dZded<   dˆ fd„Zddd„Zˆ xZS )	ÚclasspropertyaA  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                óN   •— t        ‰| �  |g|¢­i |¤Ž |j                  | _        y r8   )ÚsuperrÍ   rM   )r<   r¡  r?  rc  rp   s       €r1   rÍ   zclassproperty.__init__â  s%   ø€ Ü‰Ñ˜Ð* Ò* rÒ*Ø—|‘|ˆ�r3   c                ó$   — | j                  |«      S r8   rÂ  r¨  s      r1   r©  zclassproperty.__get__æ  s   € Ø�y‰y˜‹~Ðr3   )r¡  r;  r?  r   rc  r   r8   )r@  r   rW   zOptional[type]rH   r   )rJ   rK   rL   rM   rO   rÍ   r©  Ú__classcell__©rp   s   @r1   r:  r:  Õ  s   ø… ñð Óõ$÷ð r3   r:  c                  ó$   — e Zd Zdd„Zdd„Zdd„Zy)Úhybridpropertyc                ó    — || _         || _        y r8   )r  Úclslevel©r<   r  s     r1   rÍ   zhybridproperty.__init__ë  s   € ØˆŒ	Øˆ�r3   c                óN   — |€| j                  |«      }|S | j                  |«      S r8   ©rD  r  ©r<   r±  ÚownerÚclsvals       r1   r©  zhybridproperty.__get__ï  ó*   € ØÐØ—]‘] 5Ó)ˆFØˆMà—9‘9˜XÓ&Ð&r3   c                ó   — || _         | S r8   ©rD  rE  s     r1   Ú
classlevelzhybridproperty.classlevelö  ó   € ØˆŒØˆr3   N©r  rà  ©r±  r   rI  r   rH   r    )r  rm   rH   zhybridproperty[_T])rJ   rK   rL   rÍ   r©  rN  rP   r3   r1   rB  rB  ê  s   „ óó'ôr3   rB  c                  ó4   — e Zd Zdd„Zdd„Zd	d„Zd
d„Zd
d„Zy)Úrw_hybridpropertyc                ó.   — || _         || _        d | _        y r8   )r  rD  ÚsetfnrE  s     r1   rÍ   zrw_hybridproperty.__init__ü  s   € ØˆŒ	ØˆŒØ37ˆ�
r3   c                óN   — |€| j                  |«      }|S | j                  |«      S r8   rG  rH  s       r1   r©  zrw_hybridproperty.__get__  rK  r3   c                óD   — | j                   €J ‚| j                  ||«       y r8   ©rU  r°  s      r1   r²  zrw_hybridproperty.__set__  s    € Ø�z‰zÐ%Ð%Ð%Ø�
‰
�8˜UÕ#r3   c                ó   — || _         | S r8   rX  rE  s     r1   Úsetterzrw_hybridproperty.setter  s   € ØˆŒ
Øˆr3   c                ó   — || _         | S r8   rM  rE  s     r1   rN  zrw_hybridproperty.classlevel  rO  r3   NrP  rQ  r¼  )r  rm   rH   zrw_hybridproperty[_T])rJ   rK   rL   rÍ   r©  r²  rZ  rN  rP   r3   r1   rS  rS  û  s   „ ó8ó
'ó$óôr3   rS  c                  ó(   — e Zd ZdZdd„Zdd„Zdd„Zy)	Úhybridmethodz/Decorate a function as cls- or instance- level.c                ó.   — |x| _         | _        || _        y r8   )r  r  rD  rE  s     r1   rÍ   zhybridmethod.__init__  s   € Ø$(Ð(ˆŒ	�D”MØˆ�r3   c                óŠ   — |€&| j                   j                  ||j                  «      S | j                  j                  ||«      S r8   )rD  r©  rp   r  )r<   r±  rI  s      r1   r©  zhybridmethod.__get__  sF   € ØÐØ—=‘=×(Ñ(Ø�u—‘óð ð —9‘9×$Ñ$Ø˜%óð r3   c                ó   — || _         | S r8   rM  rE  s     r1   rN  zhybridmethod.classlevel&  rO  r3   NrP  )r±  r   rI  r   rH   rà  )r  rm   rH   zhybridmethod[_T])rJ   rK   rL   rM   rÍ   r©  rN  rP   r3   r1   r]  r]    s   „ Ù9óóôr3   r]  c                  óz   — e Zd ZU dZded<   i Zded<    ej                  «       Z	 	 d	 	 	 	 	 	 	 dd„Z	d„ Z
d	„ Zd
„ Zy)ÚsymbolaI  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-   rk   zDict[str, symbol]ÚsymbolsNc                óf  — | j                   5  | j                  j                  |«      }|€Yt        |t        «      sJ ‚|€t        |«      }t        j                  t        |«      }||_	        |r||_
        || j                  |<   n|r||k7  rt        d|›d|› �«      ‚|cd d d «       S # 1 sw Y   y xY w)Nz#Can't replace canonical symbol for z with new int value )Ú_lockrc  rù   r\   r-   Úhashr  Ú__new__rb  rk   rM   rú   )rW   rk   r¦  Ú	canonicalr’   s        r1   rg  zsymbol.__new__?  sº   € ð �Y‰Yñ 	Ø—+‘+—/‘/ $Ó'ˆCØˆ{Ü! $¬Ô,Ð,Ð,ØÐ$Ü $ T£
�IÜ—k‘k¤&¨)Ó4�Ø�”ÙØ"%�C”Kð %(�—‘˜DÒ!á ¨cÒ!1Ü#Ø=¸d¸Xð F.Ø.7¨[ð:óð ð ÷-	÷ 	ò 	ús   �BB'Â'B0c                ó>   — t         | j                  dt        | «      ffS )Nr/   )rb  rk   r  r;   s    r1   Ú
__reduce__zsymbol.__reduce__]  s   € Ü˜Ÿ	™	 3¬¨D«	Ð2Ð2Ð2r3   c                ó   — t        | «      S r8   )r°   r;   s    r1   Ú__str__zsymbol.__str__`  s   € Ü�D‹zÐr3   c                ó"   — d| j                   ›d�S )Nzsymbol(rC  )rk   r;   s    r1   Ú__repr__zsymbol.__repr__c  s   € Ø˜Ÿ™˜ QÐ'Ð'r3   )NN)rk   r-   r¦  r¢  rh  úOptional[int]rH   rb  )rJ   rK   rL   rM   rO   rc  r"  r#  re  rg  rj  rl  rn  rP   r3   r1   rb  rb  +  si   … ñð ƒIà!#€GÐÓ#ØˆI�N‰NÓ€Eð
 "Ø#'ð	àðð ðð !ð	ð
 
óò<3òó(r3   rb  c                  ó0   — e Zd Z	 	 	 	 	 	 	 	 	 	 dd„Zdd„Zy)Ú_IntFlagMetac                ó–  — g x| _         }|j                  «       D ]u  \  }}t        j                  d|«      rŒt	        |t
        «      rt        ||¬«      }n|j                  d«      st        d«      ‚ŒXt        | ||«       |j                  |«       Œw t        j                  |D �ci c]  }|j                  |“Œ c}«      | _        y c c}w )Nz^__.*__$)rh  rf  z#Expected integer values for IntFlag)Ú_itemsrH  rh   Úmatchr\   r  rb  rw  rú   rz  r~   r   Úimmutabledictrk   Ú__members__)	rW   Ú	classnamer�   Údict_rc  rH  r  Úvr’   s	            r1   rÍ   z_IntFlagMeta.__init__h  s°   € ð  ÐˆŒ
�UØ—K‘K“Mò 
	‰DˆAˆqÜ�x‰x˜ QÔ'ØÜ˜!œSÔ!Ü˜Q¨!Ô,‘Ø—\‘\ #Ô&ÜÐ EÓFÐFàÜ�C˜˜CÔ Ø�L‰L˜Õð
	ô '×4Ñ4Ø&+Ö,˜sˆS�X‰X�s‰]Ò,ó
ˆ�ùÚ,s   Â%Cc                ó   — t        d«      ‚)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__z_IntFlagMeta.__iter__�  s   € Ü!ð=ó
ð 	
r3   N)
rw  r-   r�   zTuple[Type[Any], ...]rx  úDict[str, Any]rc  r   rH   rI   )rH   zIterator[symbol])rJ   rK   rL   rÍ   r{  rP   r3   r1   rq  rq  g  s<   „ ð
àð
ð %ð
ð ð	
ð
 ð
ð 
ó
ô2
r3   rq  c                  ó   — e Zd ZdZy)Ú_FastIntFlagzÆAn 'IntFlag' copycat that isn't slow when performing bitwise
    operations.

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

    Nr�  rP   r3   r1   r~  r~  ‰  s   „ òr3   r~  )Ú	metaclass)ÚIntFlagÚ_Ec                ó¸   — |j                  «       D ]*  \  }}| |u r|c S |r| |j                  k(  r|c S | |v sŒ(|c S  | €yt        j                  d|› d| ›�«      ‚)aO  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': )rH  rk   r   r-  )r?  Úchoicesrk   Úresolve_symbol_namesÚ
enum_valueÚchoices         r1   Úparse_user_argument_for_enumr‡  ž  sv   € ð( &Ÿm™m›oò Ñˆ
�FØ�*ÑØÒÙ! c¨Z¯_©_Ò&<ØÒØ�FŠ]ØÒðð €{Øä
×
Ñ
Ð1°$°°s¸3¸'ÐBÓ
CÐCr3   c                ó,   — t         | _         t         dz  a y)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                óx   — 	  | |i |¤ŽS # t         $ r& t        dt        j                  «       dd z  «       Y yw xY w)zXexecutes the given function, catches all exceptions and converts to
    a warning.

    z%s('%s') ignoredr   r   N)r]   Úwarnr9   r:   )r  r  r7  s      r1   Úwarn_exceptionr�  Ð  sA   € ð
7Ù�TÐ$˜VÑ$Ð$øÜò 7ÜÐ¤#§,¡,£.°°1Ð"5Ñ5Ö6ð7ús   ‚
 Š,9¸9c                óV   — 	 t        | «      |kD  rd| d| z  S | S # t        $ r | cY S w xY w)Nz%s...r   )rª   rú   )rA   Úlen_s     r1   Úellipses_stringr�  Û  s=   € ðÜˆu‹:˜ÒØ˜U 1 T˜]Ñ*Ð*àˆLøÜò ØŠðús   ‚ ˜ š(§(c                  óP   ‡ — e Zd ZU dZded<   	 	 	 	 	 	 	 	 dˆ fd„Zdd„Zd	d„Zˆ xZS )
Ú_hash_limit_stringa/  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                ó€   •— ||z  d|z  z   }t         ‰| �  | |«      }t        d|t        |«      |z  fz  «      |_        |S )Nz6 (this warning may be suppressed after %d occurrences)z%s_%d)r=  rg  rf  r“  )rW   rA   Únumr  Úinterpolatedr<   rp   s         €r1   rg  z_hash_limit_string.__new__ò  sR   ø€ ð  ™ØDÀsÑJñ
ˆô ‰w‰˜s LÓ1ˆÜ˜' U¬D°Ó,>ÀÑ,DÐ$EÑEÓFˆŒ
Øˆr3   c                ó   — | j                   S r8   )r“  r;   s    r1   Ú__hash__z_hash_limit_string.__hash__ü  s   € Ø�z‰zÐr3   c                ó0   — t        | «      t        |«      k(  S r8   )rf  )r<   Úothers     r1   Ú__eq__z_hash_limit_string.__eq__ÿ  s   € Ü�D‹zœT %›[Ñ(Ð(r3   )rA   r-   r•  r  r  úSequence[Any]rH   r’  )rH   r  )rš  r   rH   rê   )	rJ   rK   rL   rM   rO   rg  r˜  r›  r?  r@  s   @r1   r’  r’  å  s>   ø… ñð ƒJðØðØ!ðØ)6ðà	õó÷)r3   r’  c                ó~   — |r!t        t        j                  | |¬«      «       yt        | t        j                  «       y)zdIssue 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¨tÔ4Õ5ä�sœCŸM™MÕ*r3   c                óV   — |rt        | d|«      } t        | t        j                  «       y)z\Issue 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                ó   ‡ ‡— ˆˆ fd„}|S )Nc                ó2   •— ‰‰ft         | j                  <   | S r8   )r¤  ræ   )r•   ÚcategoryÚmessages    €€r1   Úgoz#tag_method_for_warnings.<locals>.go   s   ø€ Ø&-¨xÐ%8Œ�b—k‘kÑ"Øˆ	r3   rP   )r¨  r§  r©  s   `` r1   Útag_method_for_warningsrª    s   ù€ õð €Ir3   z&^(?:sqlalchemy\.(?!testing)|alembic\.)c                óð  — 	 t        j                  |«      }dx}}|��|s6t        j                  t        |j
                  j                  dd«      «      sd}|j                  t        v r&d}t        |j                     \  }}|xs |}| › d|› d�} |j                  }|s|dz  }n|r|rn|�ŒŒ	 |�t        j                  | ||dz   ¬	«       y t        j                  | |dz   ¬	«       y # t        $ r d}Y ŒF d}Y ŒKxY w)
NFrJ   r¤   Tz (rC  r   r   )Ú
stacklevel)r9   Ú	_getframerh   rt  Ú_not_sa_patternÚ	f_globalsrù   Úf_coder¤  Úf_backr  Ú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ô-ð
 $(Ð ð
 �|‰|œ}Ñ,Ø$(Ð!Ü%2°5·<±<Ñ%@Ñ"�˜Ø#Ò0 y�Ø$˜I R¨ y°Ð2�à—L‘LˆEá#Ø˜a‘‘
Ù!Ñ&7Øð3 Òð6 ÐÜ�‰�g˜x°JÀ±NÖCä�‰�g¨*°q©.Ö9øôQ ò ð Š
ðð Š
ús   ‚C# Ã#C5Ã0C5c                ó"   ‡ ‡‡— ‰ gŠdˆ ˆˆfd„}|S )zNDecorate the given function to be a no-op after it is called exactly
    once.c                 ót   •— ‰}‰r‰j                  «       }	  || i |¤ŽS y #  ‰r‰j                  d|«       ‚ xY w)Nr   )rS   Úinsert)r?  rc  Ú	strong_fnÚonce_fnr•   ÚonceÚretry_on_exceptions       €€€r1   r©  zonly_once.<locals>.goe  sM   ø€ ð ˆ	ÙØ—h‘h“jˆGðÙ Ð* rÑ*Ð*ð øðÙ%Ø—K‘K  7Ô+Øús   —   7)r?  r   rc  r   rH   zOptional[_T]rP   )r•   r¾  r©  r½  s   `` @r1   Ú	only_oncer¿  ]  s   ú€ ð ˆ4€D÷ð €Ir3   z%sqlalchemy/([a-z_]+/){0,2}[a-z_]+\.pyzunit(?:2|test2?/)c                ó  — d}t        | «      dz
  }||k  r3|j                  | |   «      r|dz  }||k  r|j                  | |   «      rŒ||k  r3|j                  | |   «      r|dz  }||k  r|j                  | |   «      rŒ| ||dz    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_suffixrz   Úends        r1   Úchop_tracebackrÆ  {  s�   € ð" €EÜ
ˆb‹'�A‰+€CØ
�3Š,˜>×0Ñ0°°E±Ô;Ø�‰
ˆð �3Š,˜>×0Ñ0°°E±Õ;à
�3Š,˜>×0Ñ0°°C±Ô9Øˆq‰ˆð �3Š,˜>×0Ñ0°°C±Õ9àˆe�c˜A‘gÐÐr3   c                ó^   — d| z  }t        «       j                  «       }t        ||«       |d   S )Nz&def set(obj, value):    obj.%s = valuerR   )ry  ÚcopyrÄ   )Úattrnamer¾   r¿   s      r1   Ú
attrsetterrÊ  ˜  s,   € Ø3°hÑ>€DÜ
‹(�-‰-‹/€CÜˆˆs„OØˆu‰:Ðr3   z^__.+__$c                  ó(   ‡ — e Zd ZdZdZdˆ fd„Zˆ xZS )Ú
TypingOnlyz“A mixin class that marks a class as 'typing only', meaning it has
    absolutely no methods, attributes, or runtime functionality whatsoever.

    rP   c                óÖ   •— t         | j                  v rC| j                  D �ch c]  }t        j	                  |«      rŒ|’Œ }}|rt        d| › d|› d�«      ‚t        ‰| �  «        y c c}w )NzClass z< directly inherits TypingOnly but has additional attributes rÙ   )rÌ  rû   rø   Ú_dundersrt  ÚAssertionErrorr=  Ú__init_subclass__)rW   rk   Ú	remainingrp   s      €r1   rÐ  zTypingOnly.__init_subclass__ª  st   ø€ Ü˜Ÿ™Ñ&à!$§¡öØ´X·^±^ÀDÕ5I’ðˆIð ñ Ü$Ø˜S˜Eð "-Ø-6¨K°qð:óð ô 	‰Ñ!Õ#ùòs
   ¢A&½A&rG   )rJ   rK   rL   rM   rN   rÐ  r?  r@  s   @r1   rÌ  rÌ  ¢  s   ø„ ñð
 €I÷
$ñ 
$r3   rÌ  c                  óD   ‡ — e Zd ZU dZded<   	 dˆ fd„Zedd„«       Zˆ xZS )ÚEnsureKWArga6  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                ó   •— | j                   }| j                  }|re|D ]`  }t        j                  ||«      }|sŒ||   }t	        j
                  |«      }|j                  rŒC| j                  |«      }t        | ||«       Œb t        ‰| �)  «        y r8   )rÔ  rø   rh   rt  r   r©   r  Ú
_wrap_w_kwrz  r=  rÐ  )	rW   Úfn_regÚclsdictrq  r0   r•   r·   Úwrappedrp   s	           €r1   rÐ  zEnsureKWArg.__init_subclass__Ê  sƒ   ø€ Ø×!Ñ!ˆØ—,‘,ˆÙØò 3�Ü—H‘H˜V SÓ)�ÚØ  ™�BÜ!×8Ñ8¸Ó<�DØŸ:›:Ø"%§.¡.°Ó"4˜Ü  S¨'Õ2ð3ô 	‰Ñ!Õ#r3   c                ó(   ‡— dˆfd„}t        |‰«      S )Nc                 ó   •—  ‰| Ž S r8   rP   )r?  rc  r•   s     €r1   Úwrapz$EnsureKWArg._wrap_w_kw.<locals>.wrapÚ  s   ø€ Ù�s�8ˆOr3   )r?  r   rc  r   rH   r   r   )rW   r•   rÜ  s    ` r1   rÖ  zEnsureKWArg._wrap_w_kwØ  s   ø€ õ	ô ˜d BÓ'Ð'r3   rG   )r•   rm   rH   rm   )	rJ   rK   rL   rM   rO   rÐ  r¾  rÖ  r?  r@  s   @r1   rÓ  rÓ  ·  s.   ø… ñð Óðõ$ð ò(ó ô(r3   rÓ  c                óv  — t        |d«      rt        | |«      S | }|j                  j                  |_        t        |d«      r|j                  |_        t        |j
                  d«      r3|j
                  j                  r|j
                  j                  |_        |S |j                  r|j                  |_        |S )z‘Augment functools.update_wrapper() to work with objects with
    a ``__call__()`` method.

    :param fn:
      object with __call__ method

    rJ   rK   rM   )r}   r   rp   rJ   rK   r	  rM   )Úwrapperr•   Ú_fs      r1   Úwrap_callablerà  à  s‘   € ô ˆr�:ÔÜ˜g rÓ*Ð*àˆØ—l‘l×+Ñ+ˆŒÜ�2�|Ô$ØŸM™MˆBŒMä�2—;‘; 	Ô*¨r¯{©{×/BÒ/BØŸ™×,Ñ,ˆBŒJð ˆ	ð �ZŠZØŸ™ˆBŒJàˆ	r3   c                óœ  — d| vr| j                  d«      S d}g g}d}t        | «      }||k  r}| |   }|dk(  r8|dk(  r-||dz
  k  r%| |dz      dk(  r|d   j                  d«       |dz  }n6|dz  }n0|dk(  r|dk(  r|j                  g «       n|d   j                  |«       |dz  }||k  rŒ}|D �cg c]  }dj                  |«      ‘Œ c}S c c}w )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   r!  r¤   )rÛ   rª   r~   rg   )rA   r^  rÇ  ÚidxÚlvÚcharrÝ   s          r1   Úquoted_token_parserræ  ø  sí   € ð$ �%ÑØ�{‰{˜3ÓÐð €EØ!˜d€FØ
€CÜ	ˆU‹€BØ
�Š(Ø�S‰zˆØ�3Š;Ø˜Šz˜c B¨¡Fšl¨u°S¸1±W©~ÀÒ/DØ�r‘
×!Ñ! #Ô&Ø�q‘‘à˜‘
‘Ø�SŠ[˜U ašZØ�M‰M˜"Õà�2‰J×Ñ˜dÔ#Øˆq‰ˆð �‹(ð )/Ö/˜uˆB�G‰G�E�NÒ/Ð/ùÒ/s   Â.C	c                ó@   ‡ ‡— t        j                  ‰ «      Š ˆ ˆfd„}|S )Nc                óš   •— | j                   d uxr | j                   xs d}|rt        |‰D �ci c]  }|‰“Œ c}«      }|| _         | S c c}w )Nr¤   )rM   Úinject_param_text)r•   r¦  ÚparamÚparamsr  s      €€r1   rÁ   z$add_parameter_text.<locals>.decorate'  sO   ø€ Ø�j‰j Ð$Ò3¨¯©Ò9°rˆÙÜ# CÀ6Ö)J¸%¨%°©+Ò)JÓKˆCØˆŒ
Øˆ	ùò *Ks   ®
A
)r   rD  )rë  r  rÁ   s   `` r1   Úadd_parameter_textrì  $  s   ù€ Ü×!Ñ! &Ó)€Fõð €Or3   c                óÒ   — | j                  dd«      }t        |«      dk(  r| S |\  }}|j                  d«      s|dz   t        j                  |«      z   S t        j                  | «      S )Nú
r   ra   )rÛ   rª   rw  ÚtextwrapÚdedent)r  Ú
split_textÚ	firstlinerÑ  s       r1   Ú_dedent_docstringró  1  sc   € Ø—‘˜D !Ó$€JÜ
ˆ:ƒ˜!ÒØˆà)Ñˆ	�9Ø×Ñ Ô$Ø˜4Ñ¤(§/¡/°)Ó"<Ñ<Ð<ä�‰˜tÓ$Ð$r3   c                óö  — t        | xs d«      }|j                  d«      }t        |«      dk(  r|j                  d«       t	        j
                  |«      j                  d«      }|d   r|j                  dd«       t        |«      D ��cg c]  \  }}|j                  «       rŒ|‘Œ }}}|j                  dd«       |t        |t        |«      dz
  «         }	|d|	 |z   ||	d  z   }dj                  |«      S c c}}w )Nr¤   rî  r   r   )ró  rÛ   rª   r~   rï  rð  rº  rF  r  Úminrg   )
Úgiven_doctextÚ
injecttextÚposÚdoctextÚlinesÚinjectlinesr•  ÚlineÚblanksÚ
inject_poss
             r1   Úinject_docstring_textrÿ  =  så   € ô % ]Ò%8°bÓ9€GØ�M‰M˜$Ó€EÜ
ˆ5ƒz�Q‚Ø�‰�RÔÜ—/‘/ *Ó-×3Ñ3°DÓ9€KØ�1‚~Ø×Ñ˜1˜bÔ!ä#,¨UÓ#3×H‘i�c˜4¸4¿:¹:½<ŠcÐH€FÑHØ
‡M�M�!�QÔàœ˜C¤ V£¨q¡Ó1Ñ2€Jà�!�JÐ +Ñ-°°j°kÐ0BÑB€EØ�9‰9�UÓÐùó Is   Â	C5Â"C5z(\s+):param (.+?):c                óê  — t        j                  | j                  «       «      }g }d }|�r9|j                  «       }t        j                  |«      }|€‰|rû|j                  d«      j                  d«      }||v r×dt        |j                  d«      «      z  dz   }|r8t        j
                  d|d   «      }	|	rdt        |	j                  d«      «      z  }|||   z   }nt|r|j                  d|dg«       d }n[|j                  «       s|j                  ||dg«       d }n4|j                  d«      r#|j                  ||j                  «       g«       �Œ'|j                  |«       |r�Œ9dj                  |«      S )	Nr   Ú*ra   r   z(\s+)\Sr   rî  z::)ÚcollectionsÚdequeÚ
splitlinesÚpopleftÚ
_param_regrt  rÊ   Úlstriprª   rh   rU   Úrstriprx  r~   rg   )
rù  Úinject_paramsÚdoclinesrú  Ú	to_injectrü  r0   rê  ÚindentÚm2s
             r1   ré  ré  T  sX  € Ü× Ñ  ×!3Ñ!3Ó!5Ó6€HØ€Eð €IÚ
Ø×ÑÓ!ˆä×Ñ˜TÓ"ˆàÐÙØŸ™ ›
×)Ñ)¨#Ó.�Ø˜MÑ)à ¤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                ó  — t        | «      dk(  ryt        | «      dk  }|r| dd n
| dd | dd z   } | D �cg c]  }t        |«      dkD  rd|dd z  n|‘Œ }}|rdj                  |«      S dj                  |dd «      ›d	|d   ›�S c c}w )
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ž   r!  é   z%s..rB  z, ..., )rª   rg   )rº   Úflagrk   Úress       r1   Úrepr_tuple_namesr    s¡   € ô ˆ5ƒz�Q‚ØÜˆu‹:˜‰?€DÙˆE�!�A‰J E¨!¨A J°°r°s°Ñ$;€EØFKÖ
L¸d¤ T£¨R¢ˆ6�D˜˜"�IÒ°TÑ9Ð
L€CÐ
LÙØ�y‰y˜‹~Ðà $§	¡	¨#¨a°¨(Õ 3°S¸²WÐ=Ð=ùò	 Ms   ´Bc                ó,   — t         ry| rt        d«      ‚y)NTzDcython extensions were expected to be installed, but are not presentF)r   ÚImportError)Úraise_s    r1   Úhas_compiled_extr  �  s"   € ÝØÙ	Üð"ó
ð 	
ð
 r3   c                  ó.   — e Zd Z ej                  «       Zy)Ú_MissingN)rJ   rK   rL   ÚenumÚautoÚMissingrP   r3   r1   r  r  ™  s   „ Øˆd�i‰i‹k�Gr3   r  )r/   r   rH   r-   )rW   úType[_T]rH   zIterator[Type[_T]])r^   r   rH   r-   r8   )rW   ú	Type[Any]rj   r¢  rH   r-   )rr   zUnion[Type[Any], object]rs   rm   rH   rê   )r€   ÚslicerH   úTuple[Any, ...])rŽ   úSequence[str]r�   r-   rH   zIterator[str])r•   zCallable[[int], Any]re   r  rH   zIterator[Any])rŸ   rm   rH   zCallable[[_Fn], _Fn])r¾   zUnion[str, types.CodeType]r¿   r|  r¼   r-   rH   rm   )rW   ro   rñ   úOptional[Set[str]]rò   zLiteral[True]rH   zSet[str])rW   ro   rñ   r!  rò   rê   rH   r!  )r  rm   rH   ú	List[str])FF)r•   rm   r  rê   r  rê   rH   zcompat.FullArgSpec)T)r•   z-Union[Callable[..., Any], compat.FullArgSpec]r¡   rê   rH   zDict[str, Optional[str]])rP   rP   rP   rP   )r.  r  r/  r-   r0  r-   r1  r   r2  r   r3  r   r4  r   rH   zCallable[[_T], _T])rP   NrP   )
r@  r   rI  zSequence[Tuple[str, Any]]rJ  z%Optional[Union[object, List[object]]]rK  r   rH   r-   )NNz
self.proxyN)NNNré  )r@  r   rH   rê   )r  r-   rH   z!Callable[[str], Union[str, bool]])rA   r   rH   ro  )TN)rc  r|  rq  r-   r@   r  r  rê   r  zOptional[Dict[str, Any]]rH   rI   )r@  r   rW   r  rH   r  )
r@  r    rW   r  r  r   rc  r   rH   r    )rH   zCallable[[], int])r'  r   rR  úOptional[Type[Any]]rH   r#  )r?  r   r.  z'Union[Tuple[Type[Any], ...], Type[Any]]rk   r-   rH   r   )F)
r?  r   rƒ  zDict[_E, List[Any]]rk   r-   r„  rê   rH   zOptional[_E]r½  )r  rm   r  r   r7  r   rH   r   )é   )r   r-   r¾   r¢  rH   rI   )r   r-   r  rœ  rH   rI   )r¨  r-   r§  zType[Warning]rH   úCallable[[_F], _F])Nr   )r¨  zUnion[str, Warning]r§  zOptional[Type[Warning]]r¬  r  rH   rI   )r•   rà  r¾  rê   rH   zCallable[..., Optional[_T]])rÂ  r"  rÃ  úre.Pattern[str]rÄ  r&  rH   r"  )rë  r   r  r-   rH   r%  )r  r-   rH   r-   )rö  r¢  r÷  r-   rø  r  rH   r-   )rù  r-   r	  zDict[str, str]rH   r-   )rº   r"  rH   r¢  )šrM   Ú
__future__r   r  r  Ú	functoolsr   r¦   r‰   r�  rh   r9   rï  r"  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   rZ   r_   rl   rw   r‚   r“   r—   r˜   rÂ   r³   rÅ   rÆ   rÈ   rð   rõ   r  r  r®   r+  r5  r8  r<  rV  rX  rm  rr  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í  r  r	  r  r  r  r  r  r)  r/  r”  r:  rB  rS  r]  r  rb  ro   rq  r~  r€  ÚFastIntFlagÚEnumr�  r‡  r‰  rŠ  r�  r�  r-   r’  rŒ  r£  r¤  rO   rª  Úcompiler®  rž  r¿  Ú_SQLA_REÚ_UNITTEST_RErÆ  ÚNoneTyperÊ  rÎ  rÌ  rÓ  rà  ræ  rì  ró  rÿ  r  ré  r  r  r  r  Ú	MissingOrrP   r3   r1   ú<module>r7     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€ó
S,ðlØ
$ðØ+9ðØDGðàóñ ˆeƒn€Ùˆeƒn€÷(ñ (òV
ð( 
ð  $Ø!ñ	Ø	ðð ðð ð	ð
 òó 
ðð 
à-1ÀEñØ	ðØ*ðØ=Aðàòó 
ðð .2ÀEñ2Ø	ð2Ø*ð2Ø=Að2àó2ój2ð EJð9;Øð9;Ø%)ð9;Ø=Að9;àó9;ðz 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 ˆ2�:Š:Ð>Ó?€Øˆr�zŠzÐ.Ó/€ð
 '3Ø&.ðØðà#ðð $ðð ó	ñ4 �‹:€òð ˆ2�:Š:�jÓ!€÷$ñ $÷*&(ñ &(òRò0)0óX
ó	%ðØ ðØ.1ðØ8;ðàóð( ˆR�ZŠZÐ-Ó.€
ó(óV>ó	ôˆt�y‰yô ð ×
Ò
€Ø�"�g˜h×.Ò.Ñ/Ð/Ñ0�	r3   