Ë
    V.jì ã                  ól	  — 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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*¬&«      Z0 e"d+d,¬&«      Z1 e"d-d.¬&«      Z2e'jf                  rd£d/„Z4nd£d0„Z4d¤d1„Z5 G d2„ d3«      Z6d¥d4„Z7d¦d5„Z8	 d§	 	 	 	 	 d¨d6„Z9	 	 	 	 	 	 d©d8„Z:dªd9„Z;d«d:„Z<d¬d;„Z= e"d<d7¬&«      Z>d­d=„Z?d>„ Z@	 	 	 	 	 	 	 	 d®d?„ZA e"d@«      ZB e"dA«      ZC G dB„ dC«      ZDdD„ ZEedd%dEœ	 	 	 	 	 	 	 d¯dF„«       ZFeddGdEœ	 	 	 	 	 	 	 d°dH„«       ZFddGdEœ	 	 	 	 	 	 	 d°dI„ZFd±dJ„ZG	 d²	 	 	 	 	 	 	 d³dK„ZH	 d´	 	 	 	 	 dµdL„ZId´dM„ZJ	 	 	 	 d¶	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d·dN„ZKdO„ ZLdP„ ZM	 	 	 d¸	 	 	 	 	 	 	 	 	 d¹dQ„ZN G dR„ dS«      ZOdT„ ZPdU„ ZQ	 	 	 	 dºdV„ZRdW„ ZSd»dX„ZT e"dYdZ¬&«      ZU G d[„ d\ee-   «      ZV G d]„ d^eVe-   «      ZW G d_„ d`eVe-   «      ZXe!r	eVZYeVZZe[Z\e[Z]neXxZYZ\eWxZZZ]d¼da„Z^ G db„ dc«      Z_e!re[Z`ne_jÂ                  Z` G dd„ de«      Zbd½df„Zcd¾dg„Zdd¿dh„Ze	 	 dÀ	 	 	 	 	 	 	 	 	 	 	 dÁdi„ZfdÂdj„ZgdÃdk„ZhdÄdl„Zi	 d§	 	 	 	 	 dÅdm„Zj	 	 	 	 	 	 	 	 dÆdn„Zkdo„ Zl G dp„ dqe[«      Zm G dr„ dsee,   «      Zn G dt„ duee,   «      Zo G dv„ dwee,   «      Zp G dx„ dyeq«      Zr G dz„ d{es«      Zt G d|„ d}et¬~«      Zue!r	ddlmvZv evZwneuZw e"d€ejð                  ¬&«      Zy	 dÇ	 	 	 	 	 	 	 	 	 dÈd�„Zzda{dÉd‚„Z|dÊdƒ„Z}dËd„„Z~ 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Œ esd«      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›�j8                  Zœe#e,e*e›�j8                     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)ÚMapping)Ú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                ó,   — t        j                  | «      S ©N)ÚinspectÚget_annotations©Úobjs    ú]C:\xampp\htdocs\tradingbinance\backend\.venv\Lib\site-packages\sqlalchemy/util/langhelpers.pyr-   r-   A   s   € Ü×&Ñ& sÓ+Ð+ó    c                ó²   — t        | t        «      r| j                  j                  dd «      }nt	        | dd «      }|€t
        j                  S t        d|«      S )NÚ__annotations__úMapping[str, Any])Ú
isinstanceÚtypeÚ__dict__ÚgetÚgetattrr   Ú
EMPTY_DICTr	   )r/   Úanns     r0   r-   r-   F   sS   € ô �cœ4Ô Ø—,‘,×"Ñ"Ð#4°dÓ;‰Cä˜#Ð0°$Ó7ˆCàˆ;Ü×*Ñ*Ð*äÐ+¨SÓ1Ð1r1   c                óª   — | j                  d«      } t        j                  «       }|j                  | «       t	        t
        |j                  «       «      S )Nzutf-8)Úencoder   Úmd5_not_for_securityÚupdater	   ÚstrÚ	hexdigest)ÚxÚms     r0   Úmd5_hexrD   W   s<   € Ø	�‰�Ó€AÜ×#Ñ#Ó%€AØ‡H�HˆQ„KÜ”�Q—[‘[“]Ó#Ð#r1   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]]rG   c                ó6   — t        j                  «       | _        y r+   )ÚsysÚexc_inforG   ©Úselfs    r0   Ú	__enter__zsafe_reraise.__enter__ƒ   s   € ÜŸ™›ˆ�r1   c                ó²   — | j                   €J ‚|€,| j                   \  }}}|€J ‚d | _         |j                  |«      ‚d | _         |€J ‚|j                  |«      ‚r+   )rG   Úwith_traceback)rL   Útype_ÚvalueÚ	tracebackÚexc_typeÚ	exc_valueÚexc_tbs          r0   Ú__exit__zsafe_reraise.__exit__†   sq   € ð �~‰~Ð)Ð)Ð)àˆ=Ø*.¯.©.Ñ'ˆH�i ØÐ(Ð(Ð(Ø!ˆDŒNØ×*Ñ*¨6Ó2Ð2à!ˆDŒNØÐ$Ð$Ð$Ø×&Ñ& yÓ1Ð1r1   N©ÚreturnÚNone)rP   zOptional[Type[BaseException]]rQ   zOptional[BaseException]rR   zOptional[types.TracebackType]rX   r   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú	__slots__r3   rM   rV   © r1   r0   rF   rF   ^   sH   … ñð0 €Iðó ó(ð2à,ð2ð 'ð2ð 1ð	2ð
 
ô2r1   rF   c              #  óÄ   K  — t        «       }| g}|rM|j                  «       } | |v rŒ|j                  | «       |j                  | j	                  «       «       | –— |rŒLy y ­wr+   )ÚsetÚpopÚaddÚextendÚ__subclasses__)ÚclsÚseenÚstacks      r0   Úwalk_subclassesri   ™   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)r5   r@   Ú	Exception)Úelements    r0   Ústring_or_unprintablerm   §   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r+   )Úlower)Ú.0Úns     r0   Ú	<genexpr>z(clsname_as_plain_name.<locals>.<genexpr>µ   s   è ø€ ÐNÑ'M !�A—G‘G—IÑ'Mùs   ‚z([A-Z][a-z]+|SQL))rZ   ÚjoinÚreÚfindall)rf   Úuse_nameÚnames      r0   Úclsname_as_plain_namerz   ±   s3   € ð Ò#�s—|‘|€DØ�8‰8ÑN¤r§z¡zÐ2FÈÔ'MÓNÓNÐNr1   úCallable[..., Any]c                óz   — t        | t        «      s| j                  }n| }|j                  }t	        ||«      }||k7  S )z1Return True if the two class methods don't match.)r5   r6   Ú	__class__rZ   r9   )Úinstance_or_clsÚagainst_methodÚcurrent_clsÚmethod_nameÚcurrent_methods        r0   Úmethod_is_overriddenrƒ   ¸   s@   € ô �o¤tÔ,Ø%×/Ñ/‰à%ˆà ×)Ñ)€Kä'.¨{¸KÓ'H€Nà˜^Ñ+Ð+r1   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Úhasattrr…   ÚappendÚtuple)ÚslcÚretrB   s      r0   Údecode_slicerŽ   Ê   sR   € ð €CØ�Y‰Y˜Ÿ™ #§(¡(Ó*ˆÜ�1�kÔ"Ø—‘“ˆAØ�
‰
�1�ð +ô �‹:Ðr1   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 r+   ©r@   )ÚiÚbases    €r0   Ú<lambda>z!_unique_symbols.<locals>.<lambda>Ý   s   ø€ ˜$¤ Q£š-r1   iè  z&exhausted namespace for symbol base %s)ra   Ú	itertoolsÚchainÚmapÚrangerc   Ú	NameError)ÚusedÚbasesÚused_setÚpoolÚsymr“   s        @r0   Ú_unique_symbolsrŸ   Ø   sw   øè ø€ Ü�4‹y€HÛˆÜ�‰ØˆGÜÓ'¬¨t«Ó5ó
ˆó ˆCØ˜(Ò"Ø—‘˜SÔ!Ø’	Ùð	 ô ÐDÀtÑKÓLÐLñ ù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   Nr_   )Úfnrs   Úbs      r0   Ú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	        j
                  | «      }i }t        ||«      }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  }t         j"                  | j$                     }|j                  t'        |«      «       |j                  |‰
|| d| j$                  i«       t        t(        j*                  t-        ||| j                  «      «      }	t/        | d| «      j0                  |	_        | |	_        t5        |	| «      S )Nznot a decoratable functionzTuple[str, ...]r   r   é   Útargetr¡   )r¨   r¡   F©Úgroupedry   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)
rZ   Ú__func__)r,   Ú
isfunctionÚismethodrk   r   Úinspect_getfullargspecÚ!_update_argspec_defaults_into_envr‹   r	   rZ   rŸ   Údictr?   Úformat_argspec_plusÚiscoroutinefunctionÚreprrI   Úmodulesr[   ÚvarsÚtypesÚFunctionTypeÚ_exec_code_in_envr9   Ú__defaults__Ú__wrapped__r   )r¡   ÚspecÚenvÚnamesÚ	targ_nameÚfn_nameÚmetadataÚcodeÚmodÚ	decoratedr¨   s             €r0   Údecoratezdecorator.<locals>.decorateù   sÏ  ø€ Ü×!Ñ! "Ô%¬g×.>Ñ.>¸rÔ.BÜÐ8Ó9Ð9ä×,Ñ,¨RÓ0ˆØ ˆä0°°sÓ;ˆô ”$Ð(¨$¨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™“=Ñ ðð ñ	ñ ðð ñ	ð ô �k‰k˜"Ÿ-™-Ñ(ˆØ�
‰
”4˜“9ÔØ�
‰
�I˜v w°°JÀÇÁÐNÔOäÜ×ÑÜ˜d C¨¯©Ó5ó
ˆ	ô ")¨¨Z¸Ó!<×!IÑ!Iˆ	Ôà "ˆ	ÔÜ˜i¨Ó,Ð,r1   )r¡   r¤   rX   r¤   r   )r¨   rÈ   s   ` r0   Ú	decoratorrÉ   ö   s   ø€ õ?-ôB ˜( FÓ+Ð+r1   c                ó0  — | j                   r‰g }d}| j                   D ]K  }t        |«      j                  dvr!d|z  }|||<   |j                  |«       |dz  }Œ;|j                  |«       ŒM t	        | «      }t        |«      |d<   t        j                  |Ž S | S )zCgiven a FullArgSpec, convert defaults to be symbol names in an env.r   )ÚbuiltinsÚ__builtin__zx%dr   r§   )Údefaultsr6   r[   rŠ   Úlistr‹   r   ÚFullArgSpec)r¿   rÀ   Únew_defaultsr’   Úargry   Úelems          r0   r³   r³   =  sœ   € ð ‡}‚}ØˆØˆØ—=”=ˆCÜ�C‹y×#Ñ#Ð+FÑFØ˜q‘y�Ø��D‘	Ø×#Ñ# DÔ)Ø�Q‘‘à×#Ñ# CÕ(ð !ô �D‹zˆÜ˜Ó%ˆˆQ‰Ü×!Ñ! 4Ð(Ð(àˆr1   c                ó$   — t        | |«       ||   S r+   )Úexec)rÅ   rÀ   rÃ   s      r0   r¼   r¼   R  s   € ô 	ˆˆs„OØˆw‰<Ðr1   Ú_PFÚ_TEc                  ó4   — e Zd Z	 d	 	 	 dd„Zd„ Zdd„Zd	d„Zy)
ÚPluginLoaderNc                ó.   — || _         i | _        || _        y r+   )ÚgroupÚimplsÚauto_fn)rL   rÚ   rÜ   s      r0   Ú__init__zPluginLoader.__init__^  s   € ð ˆŒ
Ø%'ˆŒ
Øˆ�r1   c                ó8   — | j                   j                  «        y r+   )rÛ   ÚclearrK   s    r0   rß   zPluginLoader.cleare  s   € Ø�
‰
×ÑÕr1   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Ú   ry   Úloadr    ÚNoSuchModuleError)rL   ry   ÚloaderÚimpls       r0   rã   zPluginLoader.loadh  s³   € Ø�4—:‘:ÑØ#�4—:‘:˜dÑ#Ó%Ð%à�<Š<Ø—\‘\ $Ó'ˆFÙØ#)�—
‘
˜4Ñ Ù“x�ä×1Ñ1°$·*±*Ö=ˆDØ�y‰y˜DÓ Ø#'§9¡9�—
‘
˜4Ñ Ø—y‘y“{Ò"ð >ô
 ×#Ò#Ø*.¯*«*±dÐ;ó
ð 	
r1   c                ó2   ‡‡— ˆˆfd„}|| j                   |<   y )Nc                 ó|   •— t        ‰«      } ‰j                  d«      dd  D ]  }t        | |«      } Œ t        | ‰«      S )NÚ.r   )Ú
__import__Úsplitr9   )rÆ   ÚtokenÚ
modulepathÚobjnames     €€r0   rã   z#PluginLoader.register.<locals>.load|  sB   ø€ Ü˜ZÓ(ˆCØ#×)Ñ)¨#Ó.¨q¨rÓ2�Ü˜c 5Ó)‘ð 3ä˜3 Ó(Ð(r1   )rÛ   )rL   ry   rí   rî   rã   s     `` r0   ÚregisterzPluginLoader.register{  s   ù€ õ	)ð  ˆ�
‰
�4Òr1   r+   )rÚ   r@   rÜ   zOptional[Callable[..., Any]])ry   r@   rX   r   )ry   r@   rí   r@   rî   r@   rX   rY   )rZ   r[   r\   rÝ   rß   rã   rï   r_   r1   r0   rØ   rØ   ]  s)   „ àBFðØðØ#?óòó
ô& r1   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_argcountrÎ   Úco_varnamesÚboolÚco_flagsÚAttributeErrorr   r²   )r¡   Úco_varkeywordsÚcoÚnargsr¿   s        r0   Ú_inspect_func_argsrû   …  sŽ   € ð
Ü ×/Ñ/ˆð �[‰[ˆØ—‘ˆä�—‘  Ð'Ó(Ü�—‘˜~Ñ-Ó.ð
ð 	
øô ò &ô
 ×,Ñ,¨RÓ0ˆØ�A‰wœ˜T !™W›Ð%Ò%ð&ús   ‚A Á1BÂB)Ú_setÚraiseerrc                ó   — y r+   r_   ©rf   rü   rý   s      r0   Úget_cls_kwargsr   ™  s   € ð r1   Fc                ó   — y r+   r_   rÿ   s      r0   r   r   ¢  s   € ð r1   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ü   rL   )ra   r7   r8   r5   rº   r»   rò   r   rû   r?   Ú	TypeErrorÚ	__bases__r   Údiscard)	rf   rü   rý   ÚtoplevelÚctrÚhas_initrÁ   Úhas_kwÚcs	            r0   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�ÔØ€Kr1   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    r0   Úget_func_kwargsr  Ý  s   € ô ×(Ñ(¨Ó.¨qÑ1Ð1r1   c           	     ó�  — t        j                  | «      rt        d| z  «      ‚t        j                  | «      r’|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   NT)Úno_selfÚ_is_initr¯   Ú__call__)r  zCan't inspect callable: %s)r,   Ú	isbuiltinr  r°   r   r²   rÏ   ÚargsÚvarargsÚvarkwrÍ   Ú
kwonlyargsÚkwonlydefaultsr   r±   Ú__self__r¯   ÚisclassÚget_callable_argspecrÝ   r‰   r  )r¡   r  r  r¿   s       r0   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Ó:Ð:r1   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§   r_   c                ó   — dt        | «      z   S ©NÚ=r‘   ©rB   s    r0   r”   z%format_argspec_plus.<locals>.<lambda>s  s   € ˜c¤C¨£Fšlr1   )Úformatvaluec                ó   — dt        | «      z   S r  r‘   r   s    r0   r”   z%format_argspec_plus.<locals>.<lambda>|  s   €  #¬¨A«¢,r1   )Úgrouped_argsÚself_argÚ	apply_posÚapply_kwÚapply_pos_proxiedÚapply_kw_proxiedéÿÿÿÿ)	Úcallabler   r²   Úinspect_formatargspecÚlenr	   r   r   r´   )r¡   rª   r¿   r  r%  r$  r'  Únum_defaultsÚ	name_argsÚdefaulted_valsr&  r(  s               r0   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ô
ð 	
r1   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::

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

    z(self)rL   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        r0   Úformat_argspec_initr4  •  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 r+   r_   )rf   s    r0   rÈ   z&create_proxy_methods.<locals>.decorateÇ  s   € Øˆ
r1   r_   )Ú
target_clsÚtarget_cls_sphinx_nameÚproxy_cls_sphinx_nameÚclassmethodsÚmethodsÚ
attributesÚuse_intermediate_variablerÈ   s           r0   Úcreate_proxy_methodsr>  ´  s   € ò&ð €Or1   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)zúinspect.getargspec with considerations for typical __init__ methods

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

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

    rL   Nr  Úkwargs)r   r²   r  r1  rÝ   )r2  s    r0   Úgetargspec_initrA  Í  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.

    )r5   rº   Ú
MethodTyper  r¯   )Úfunc_or_clss    r0   Úunbound_method_to_callablerE  ß  s.   € ô �+œu×/Ñ/Ô0¸×9MÒ9MØ×#Ñ#Ð#àÐr1   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r+   )r·   r9   )rr   rÑ   r/   s     €r0   rt   zgeneric_repr.<locals>.<genexpr>  s    øè ø€ ÐD¹8°C”$”w˜s C¨Ó.×/¹8ùs   ƒ #r  Ú(ú, Ú))r   Úto_listr1  ÚOrderedDictÚ	enumerater   r²   rÝ   rÍ   r,  r  rd   r  r?   Úzipr  r‰   r9   r·   ÚitemsrŠ   rk   r}   rZ   ru   )r/   Úadditional_kwÚ
to_inspectÚ
omit_kwargÚmissingÚpos_argsÚkw_argsÚvargsr’   Úinspr¿   Údefault_lenrÑ   ÚdefaultÚoutputÚvalÚdefvals   `                r0   Úgeneric_reprr]  ë  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Ñ/H¨�c˜7’^Ð/HÑIôò Ø—}’}Ð$�}Ø—‘ô -0Ø ŸI™I { l mÐ4°d·m±mô-ôñ-™L˜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¨   ry   r@  Ú__weakref__c                óJ   — | j                   | j                  | j                  dœS )N©r¨   ry   r@  rb  rK   s    r0   Ú__getstate__z$portable_instancemethod.__getstate__A  s!   € à—k‘kØ—I‘IØ—k‘kñ
ð 	
r1   c                óZ   — |d   | _         |d   | _        |j                  dd«      | _        y )Nr¨   ry   r@  r_   )r¨   ry   r8   r@  )rL   Ústates     r0   Ú__setstate__z$portable_instancemethod.__setstate__H  s*   € Ø˜H‘oˆŒØ˜&‘MˆŒ	Ø—i‘i ¨"Ó-ˆ�r1   c                óV   — |j                   | _        |j                  | _        || _        y r+   )r  r¨   rZ   ry   r@  )rL   Úmethr@  s      r0   rÝ   z portable_instancemethod.__init__M  s   € Ø—m‘mˆŒØ—M‘MˆŒ	Øˆ�r1   c                ó„   — |j                  | j                  «        t        | j                  | j                  «      |i |¤ŽS r+   )r?   r@  r9   r¨   ry   )rL   rÑ   Úkws      r0   r  z portable_instancemethod.__call__R  s3   € Ø
�	‰	�$—+‘+ÔØ.Œw�t—{‘{ D§I¡IÓ.°Ð:°rÑ:Ð:r1   N)r_   )	rZ   r[   r\   r]   r^   rc  rf  rÝ   r  r_   r1   r0   r_  r_  9  s"   „ ñð
 :€Iò
ò.ó
ó
;r1   r_  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r+   r_   )rr   Ú_Úhiers     €r0   rt   z"class_hierarchy.<locals>.<genexpr>f  s   øè ø€ Ð9™K�q¨1°Dª=”™Kùs   ƒ	�rË   re   )rÎ   Ú__mro__rb   r  rŠ   rc   r[   r‰   Ú
issubclassr6   re   )rf   Úprocessr
  r›   r¢   rm  Úsrn  s          @r0   Úclass_hierarchyrs  W  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)Údirro  r7   )rf   ÚkeysÚkeyr
  s       r0   Úiterate_attributesrx  }  sK   è ø€ ô ˆ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)r^   Ú__del__Ú__getattribute__Ú__metaclass__rc  rf  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)ru  Ú
startswithÚendswithr‰   r9   r	   rº   r»   r÷   r   r²   r+  r  ÚlocalsrÔ   r½   Úsetattr)Úinto_clsÚfrom_clsÚskipÚonlyry   Úfrom_instanceÚdundersrC   r2  Úmaybe_fnr¡   r¿   Úfn_argsÚd_argsÚpyrÀ   s                   r0   Úmonkeypatch_proxied_specialsr‹  �  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¯   )r9   )Úmeth1Úmeth2s     r0   Úmethods_equivalentr�  Ð  s(   € ô �5˜* eÓ,´Øˆz˜5ó1ð ð r1   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 requiredrm  zany ofzall ofz does not implement z: rI  c                  ó   — e Zd ZdZy)ú(as_interface.<locals>.AnonymousInterfacezA callable-holding shell.N©rZ   r[   r\   r]   r_   r1   r0   ÚAnonymousInterfacer’    s   „ Ú'r1   r”  Ú	Anonymousz%r: unknown in this interfacer  z is not callablez,dictionary does not contain required keys %s)r  r5   r6   ra   ru  r}  ÚoperatorÚgeÚgtÚintersectionr´   ru   rZ   Údictlike_iteritemsr*  r€  Ústaticmethodrc   )r/   rf   r;  ÚrequiredrC   Ú	interfaceÚimplementedÚcompliesÚ	qualifierr”  Úfoundr2  ræ   s                r0   Úas_interfacer¢  Ø  sÄ  € ñB ‘wÜÐLÓMÐMä�#”tÔ¤¨C°Ô!5Øˆ
ä�GÒM¬3¨s¬8ÓM©8 a¸1¿<¹<ÈÕ;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ÜÐ" F¬L¸Ó,>Ô?Ø�	‰	�&Õð 0ñ ��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]r]   r@   rZ   Nc                ó^   — || _         |xs |j                  | _        |j                  | _        y r+   ©r§  r]   rZ   ©rL   r§  Údocs      r0   rÝ   zgeneric_fn_descriptor.__init__@  s$   € ØˆŒ	ØÒ*˜dŸl™lˆŒØŸ™ˆ�r1   c                 ó   — y r+   r_   ©rL   r/   rf   s      r0   Ú__get__zgeneric_fn_descriptor.__get__E  s   € Ø:=r1   c                 ó   — y r+   r_   r®  s      r0   r¯  zgeneric_fn_descriptor.__get__H  s   € Ø7:r1   c                ó   — t        «       ‚r+   ©ÚNotImplementedErrorr®  s      r0   r¯  zgeneric_fn_descriptor.__get__K  ó   € Ü!Ó#Ð#r1   c                 ó   — y r+   r_   ©rL   ÚinstancerQ   s      r0   Ú__set__zgeneric_fn_descriptor.__set__P  s   € ¸cr1   c                 ó   — y r+   r_   )rL   r·  s     r0   Ú
__delete__z generic_fn_descriptor.__delete__R  s   € °Sr1   c                ó   — t        «       ‚r+   r²  ©rL   r/   s     r0   Ú_resetzgeneric_fn_descriptor._resetT  r´  r1   c                ó   — t        «       ‚r+   r²  ©rf   r/   ry   s      r0   Úresetzgeneric_fn_descriptor.resetW  s   € ä!Ó#Ð#r1   r+   )r§  r¦  r¬  r¨  )rL   r£  r/   rY   rf   r   rX   r£  )r/   r1  rf   r   rX   r"   )rL   r£  r/   r   rf   r   rX   zUnion[_GFD, _T_co]©r·  r   rQ   r   rX   rY   ©r·  r   rX   rY   )r/   r   rX   rY   )r/   r   ry   r@   rX   rY   )rZ   r[   r\   r]   r3   rÝ   r   r¯  r   r¸  rº  r½  ÚclassmethodrÀ  r_   r1   r0   r¥  r¥  1  sf   … ñð ÓØÓØƒMô&ð
 Ú=ó Ø=àÚ:ó Ø:ó$ñ ãAã8ó$ð ò$ó ñ$r1   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 r+   ©r§  r®  s      r0   r¯  z_non_memoized_property.__get__g  s   € Øˆ{Ø�Ø—9‘9˜S“>Ð!r1   N)rZ   r[   r\   r]   r   r¯  r_   r1   r0   rÅ  rÅ  \  s   „ ññ ó	"ð r1   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 r+   )r§  r7   rZ   ©rL   r/   rf   Úresults       r0   r¯  z_memoized_property.__get__r  s0   € Øˆ{Ø�Ø37·9±9¸S³>ÐAˆC�L‰L˜Ÿ™Ñ'¨&ØˆMr1   c                óD   — t         j                  || j                  «       y r+   )rÉ  rÀ  rZ   r¼  s     r0   r½  z_memoized_property._resetx  s   € Ü× Ñ   d§m¡mÕ4r1   c                ó<   — |j                   j                  |d «       y r+   )r7   rb   r¿  s      r0   rÀ  z_memoized_property.reset{  s   € à�‰×Ñ˜˜tÕ$r1   N)	rZ   r[   r\   r]   r   r¯  r½  rÃ  rÀ  r_   r1   r0   rÉ  rÉ  m  s&   „ Ù<áò	ò5ð ñ%ó ñ%r1   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 r+   r_   ©Úarj  rÌ  s     €r0   Úmemoz6memoized_instancemethod.<locals>.oneshot.<locals>.memo¨  s   ø€ ØˆMr1   )rZ   r]   r7   ©rL   r  rj  rÔ  rÌ  r¡   s       @€r0   Úoneshotz(memoized_instancemethod.<locals>.oneshot¥  sK   ù€ Ù�DÐ&˜4Ò& 2Ñ&ˆô	ð Ÿ™ˆŒØ—z‘zˆŒØ%)ˆ�‰�b—k‘kÑ"Øˆr1   r   )r¡   rÖ  s   ` r0   Úmemoized_instancemethodr×  œ  s   ø€ ô	ô ˜' 2Ó&Ð&r1   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.

    r_   zFrozenSet[str]Ú_memoized_keysc                ó^   — | j                   D ]  }| j                  j                  |d «       Œ  y r+   )rÚ  r7   rb   ©rL   rÒ   s     r0   Ú_reset_memoizationszHasMemoized._reset_memoizationsÀ  s&   € Ø×'Ô'ˆDØ�M‰M×Ñ˜d DÕ)ñ (r1   c                óF   — | j                   D ]  }|| j                  vrŒJ ‚ y r+   )rÚ  r7   rÜ  s     r0   Ú_assert_no_memoizationsz#HasMemoized._assert_no_memoizationsÄ  s$   € Ø×'Ô'ˆDØ˜tŸ}™}Ò,Ð,Ð,ñ (r1   c                óN   — || j                   |<   | xj                  |hz  c_        y r+   )r7   rÚ  )rL   rw  rQ   s      r0   Ú_set_memoized_attributez#HasMemoized._set_memoized_attributeÈ  s#   € Ø"ˆ�‰�cÑØ×Ò ˜uÑ$Ör1   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¨  r]   r@   rZ   Nc                ó^   — || _         |xs |j                  | _        |j                  | _        y r+   rª  r«  s      r0   rÝ   z'HasMemoized.memoized_attribute.__init__×  s$   € ØˆDŒIØÒ. $§,¡,ˆDŒLØ ŸM™MˆD�Mr1   c                 ó   — y r+   r_   r®  s      r0   r¯  z&HasMemoized.memoized_attribute.__get__Ü  s   € Ø<?r1   c                 ó   — y r+   r_   r®  s      r0   r¯  z&HasMemoized.memoized_attribute.__get__ß  s   € Ø58r1   c                ó¢   — |€| S | j                  |«      x|j                  | j                  <   }|xj                  | j                  hz  c_        |S r+   )r§  r7   rZ   rÚ  rË  s       r0   r¯  z&HasMemoized.memoized_attribute.__get__â  sG   € Øˆ{Ø�Ø37·9±9¸S³>ÐAˆC�L‰L˜Ÿ™Ñ'¨&Ø×Ò 4§=¡= /Ñ1ÕØˆMr1   r+   )r§  rä  r¬  r¨  )rL   r'   r/   rY   rf   r   rX   r'   )r/   r   rf   r   rX   r!   )rZ   r[   r\   r]   r3   rÝ   r   r¯  r_   r1   r0   Úmemoized_attributerã  Ì  sB   … ñ	ð  ÓØÓØ‹ô	*ð
 
Ú?ó 
Ø?à	Ú8ó 
Ø8ó	r1   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 r+   r_   rÒ  s     €r0   rÔ  zBHasMemoized.memoized_instancemethod.<locals>.oneshot.<locals>.memoô  s   ø€ Ø�r1   )rZ   r]   r7   rÚ  rÕ  s       @€r0   rÖ  z4HasMemoized.memoized_instancemethod.<locals>.oneshotñ  sb   ù€ Ù˜Ð*˜tÒ* rÑ*ˆFôð ŸK™KˆDŒMØŸ:™:ˆDŒLØ)-ˆD�M‰M˜"Ÿ+™+Ñ&Ø×Ò B§K¡K =Ñ0ÕØˆMr1   )rL   r   r  r   rj  r   rX   r   r   )rf   r¡   rÖ  s    ` r0   r×  z#HasMemoized.memoized_instancemethodé  s   ø€ õ
	ô ˜g rÓ*Ð*r1   NrW   )rw  r@   rQ   r   rX   rY   ©r¡   r$   rX   r$   )rZ   r[   r\   r]   r   r^   Ú	frozensetrÚ  r3   rÝ  rß  rá  Úmemoized_propertyr!   ré  rÃ  r×  r_   r1   r0   rÙ  rÙ  ³  sT   … ññ
 ð ˆ	á%.£[€N�NÓ0ó*ó-ó%ôÐ.¨rÑ2ô ð: ò+ó ñ+r1   rÙ  c                  ó"   — e Zd ZdZdZd„ Zdd„Zy)ÚMemoizedSlotszÇ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__.

    r_   c                ó   — t        |«      ‚r+   )r÷   )rL   rw  s     r0   Ú_fallback_getattrzMemoizedSlots._fallback_getattr  s   € Ü˜SÓ!Ð!r1   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 r+   r_   rÒ  s     €r0   rÔ  z8MemoizedSlots.__getattr__.<locals>.oneshot.<locals>.memo%  s   ø€ Ø!�Mr1   )rZ   r]   r€  )r  rj  rÔ  rÌ  r¡   rw  rL   s      @€€€r0   rÖ  z*MemoizedSlots.__getattr__.<locals>.oneshot"  s>   ù€ Ù˜T˜ R™�ô"ð !#§¡�”Ø!Ÿz™z�”Ü˜˜c 4Ô(Ø�r1   )r}  r÷   r‰   r}   r9   r€  r]   ró  )rL   rw  rQ   rÖ  r¡   s   ``  @r0   Ú__getattr__zMemoizedSlots.__getattr__  s½   ú€ Ø�>‰>Ð+Ô,°·±Øô1
ô ! Ó%Ð%ô �T—^‘^ °s°eÐ%<Ô=Ø:”G˜D O°C°5Ð"9Ó:Ó<ˆEÜ�D˜#˜uÔ%ØˆLÜ�T—^‘^Ð'8¸¸Ð%>Ô?Ü˜Ð!2°3°%Ð8Ó9ˆBö	ð !Ÿj™jˆGŒOØˆNà×)Ñ)¨#Ó.Ð.r1   N)rw  r@   rX   r   )rZ   r[   r\   r]   r^   ró  rù  r_   r1   r0   rñ  rñ    s   „ ñð €Iò"ô/r1   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Úoffrs   ÚfÚ0FzString is not true/false: %r)r5   r@   Ústriprq   Ú
ValueErrorrõ   r.   s    r0   Úasboolr  4  sS   € Ü�#”sÔØ�i‰i‹k×ÑÓ!ˆØÐ6Ñ6ØØÐ9Ñ9ØäÐ;¸cÑAÓBÐBÜ�‹9Ðr1   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 r+   )r  )r/   Útexts    €r0   Úbool_or_valuez"bool_or_str.<locals>.bool_or_valueF  s   ø€ Ø�$‰;ØˆJä˜#“;Ðr1   )r/   r@   rX   zUnion[str, bool]r_   )r  r  s   ` r0   Úbool_or_strr  @  s   ø€ õð Ðr1   c                ó    — | €| S t        | «      S )zCoerce to integer.)Úint)rQ   s    r0   Úasintr  O  s   € ð €}ØˆÜˆu‹:Ðr1   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)r5   r6   rõ   r  )rj  rw  rP   Ú
flexi_boolÚdests        r0   Úcoerce_kw_typer  W  ss   € ð €|Øˆð 	ˆr‰	Ü˜E¤4Ô(´
¸2¸c¹7ÀEÔ0JØˆs‰GÐà”D‰=™ZÜ˜r #™w›ˆD�ŠIá˜b ™g›ˆD�ŠIð  ð 1Kð 	r1   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r+   ©r7   ©rr   Úkr/   s     €r0   rt   z"constructor_key.<locals>.<genexpr>w  s-   øè ø€ ð Ù&+ ¨q°C·L±LÒ/@ˆˆC�L‰L˜‰OÔ¡eùó   ƒ-—-)r   r‹   )r/   rf   rÁ   s   `  r0   Úconstructor_keyr  q  s2   ø€ ô
 ˜3Ó€EØˆ6”Eó Ù&+óó ñ ð r1   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r+   r  r  s     €r0   rt   z#constructor_copy.<locals>.<genexpr>„  s.   øè ø€ ð Ù&: ¸aÀ3Ç<Á<Ò>OˆˆC�L‰L˜‰OÔÑ&:ùr  )r   r?   Ú
difference)r/   rf   r  rj  rÁ   s   `    r0   Úconstructor_copyr  |  sE   ø€ ô ˜3Ó€EØ‡I�Ió Ø&+×&6Ñ&6°rÔ&:óô ñ �Ð˜ÑÐr1   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r+   )Únext)ÚcounterÚlocks   €€r0   Ú_nextzcounter.<locals>._next‘  s   ø€ ÚÜ˜“=÷ �TŠTús   „™")Ú	threadingÚLockr•   Úcount)r%  r#  r$  s    @@r0   r#  r#  Š  s+   ù€ ô �>‰>Ó€DÜ�o‰o˜aÓ €Gõ!ð €Lr1   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Š   rc   ra   )r‰   r*  rp  ra   r5   r6   rÎ   r´   )ÚspecimenrY  Úisas      r0   Úduck_type_collectionr-  ˜  s®   € ô ˆx˜Ô(à× Ñ Ð,´Ø×!Ñ!¤3ô2
ô ˆJà×(Ñ(Ð(ä" 8¬TÔ2�*¼
€CÙ
ˆ8”TÔÜˆÙ	ˆX”sÔ	Üˆ
Ù	ˆX”tÔ	Üˆäˆx˜Ô"ÜˆÜ	�˜5Ô	!Üˆ
Ü	�˜5Ô	!Üˆàˆr1   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'Nr_   )rr   rÓ  s     r0   rt   z"assert_arg_type.<locals>.<genexpr>Ä  s   è ø€ Ð$A¹°A V¨a¥Z¹ùs   ‚z, got 'Ú'z' is expected to be of type 'z', got ')r5   r‹   r    ÚArgumentErrorru   r6   )rÑ   Úargtypery   s      r0   Úassert_arg_typer3  »  su   € ô �#�wÔØˆ
ä�gœuÔ%Ü×#Ò#â˜Ÿ™Ñ$A¹Ó$AÕAÄ4ÈÅ9ðNóð ô
 ×#Ò#âš¤$ s¥)ð-óð r1   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.rO  Ú__getitem__r8   NzObject '%r' is not dict-likeÚiterkeysc               3  óX   •K  — ‰j                  «       D ]  } ‰€J ‚|  ‰| «      f–— Œ y ­wr+   )r6  )rw  ÚdictlikeÚgetters    €€r0   Úiteratorz$dictlike_iteritems.<locals>.iteratorÙ  s5   øè ø€ Ø×(Ñ(Ö*�ØÐ)Ð)Ð)Ø™6 #›;Ð&Ó&ñ +ùs   ƒ'*rv  c              3  ó2   •K  — | ]  }| ‰|«      f–— Œ y ­wr+   r_   )rr   rw  r9  s     €r0   rt   z%dictlike_iteritems.<locals>.<genexpr>à  s   øè ø€ ÐB±/¨3�S™& ›+Ô&±/ùs   ƒ)r‰   rÎ   rO  r9   r  Úiterrv  )r8  r:  r9  s   ` @r0   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ÐBr1   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 r+   )ÚsuperrÝ   r]   )rL   r§  rÑ   rj  r}   s       €r0   rÝ   zclassproperty.__init__ò  s%   ø€ Ü‰Ñ˜Ð* Ò* rÒ*Ø—|‘|ˆ�r1   c                ó$   — | j                  |«      S r+   rÇ  r®  s      r0   r¯  zclassproperty.__get__ö  s   € Ø�y‰y˜‹~Ðr1   )r§  r?  rÑ   r   rj  r   r+   )r/   r   rf   zOptional[type]rX   r   )rZ   r[   r\   r]   r3   rÝ   r¯  Ú__classcell__©r}   s   @r0   r>  r>  å  s   ø… ñð Óõ$÷ð r1   r>  c                  ó$   — e Zd Zdd„Zdd„Zdd„Zy)Úhybridpropertyc                ó    — || _         || _        y r+   )r  Úclslevel©rL   r  s     r0   rÝ   zhybridproperty.__init__û  s   € ØˆŒ	Øˆ�r1   c                óN   — |€| j                  |«      }|S | j                  |«      S r+   ©rH  r  ©rL   r·  ÚownerÚclsvals       r0   r¯  zhybridproperty.__get__ÿ  ó*   € ØÐØ—]‘] 5Ó)ˆFØˆMà—9‘9˜XÓ&Ð&r1   c                ó   — || _         | S r+   ©rH  rI  s     r0   Ú
classlevelzhybridproperty.classlevel  ó   € ØˆŒØˆr1   N©r  rä  ©r·  r   rM  r   rX   r!   )r  r{   rX   zhybridproperty[_T])rZ   r[   r\   rÝ   r¯  rR  r_   r1   r0   rF  rF  ú  s   „ óó'ôr1   rF  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 r+   )r  rH  ÚsetfnrI  s     r0   rÝ   zrw_hybridproperty.__init__  s   € ØˆŒ	ØˆŒØ37ˆ�
r1   c                óN   — |€| j                  |«      }|S | j                  |«      S r+   rK  rL  s       r0   r¯  zrw_hybridproperty.__get__  rO  r1   c                óD   — | j                   €J ‚| j                  ||«       y r+   ©rY  r¶  s      r0   r¸  zrw_hybridproperty.__set__  s    € Ø�z‰zÐ%Ð%Ð%Ø�
‰
�8˜UÕ#r1   c                ó   — || _         | S r+   r\  rI  s     r0   Úsetterzrw_hybridproperty.setter  s   € ØˆŒ
Øˆr1   c                ó   — || _         | S r+   rQ  rI  s     r0   rR  zrw_hybridproperty.classlevel   rS  r1   NrT  rU  rÁ  )r  r{   rX   zrw_hybridproperty[_T])rZ   r[   r\   rÝ   r¯  r¸  r^  rR  r_   r1   r0   rW  rW    s   „ ó8ó
'ó$óôr1   rW  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 r+   )r  r¯   rH  rI  s     r0   rÝ   zhybridmethod.__init__(  s   € Ø$(Ð(ˆŒ	�D”MØˆ�r1   c                óŠ   — |€&| j                   j                  ||j                  «      S | j                  j                  ||«      S r+   )rH  r¯  r}   r  )rL   r·  rM  s      r0   r¯  zhybridmethod.__get__,  s:   € ØÐØ—=‘=×(Ñ(¨°·±Ó@Ð@à—9‘9×$Ñ$ X¨uÓ5Ð5r1   c                ó   — || _         | S r+   rQ  rI  s     r0   rR  zhybridmethod.classlevel2  rS  r1   NrT  )r·  r   rM  r   rX   rä  )r  r{   rX   zhybridmethod[_T])rZ   r[   r\   r]   rÝ   r¯  rR  r_   r1   r0   ra  ra  %  s   „ Ù9óó6ôr1   ra  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@   ry   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 )Ú_lockrg  r8   r5   r@   Úhashr  Ú__new__rf  ry   r]   r  )rf   ry   r¬  Ú	canonicalrž   s        r0   rk  zsymbol.__new__K  s¯   € ð �Y‹YØ—+‘+—/‘/ $Ó'ˆCØˆ{Ü! $¬Ô,Ð,Ð,ØÐ$Ü $ T£
�IÜ—k‘k¤&¨)Ó4�Ø�”ÙØ"%�C”Kð %(�—‘˜DÒ!á ¨cÒ!1Ü#Ø=¸d¸Xð F.Ø.7¨[ð:óð ð ÷- �YŠYús   �BB'Â'B0c                ó>   — t         | j                  dt        | «      ffS )NrB   )rf  ry   r  rK   s    r0   Ú
__reduce__zsymbol.__reduce__i  s   € Ü˜Ÿ	™	 3¬¨D«	Ð2Ð2Ð2r1   c                ó   — t        | «      S r+   )r·   rK   s    r0   Ú__str__zsymbol.__str__l  s   € Ü�D‹zÐr1   c                ó"   — d| j                   ›d�S )Nzsymbol(rJ  )ry   rK   s    r0   Ú__repr__zsymbol.__repr__o  s   € Ø˜Ÿ™˜ QÐ'Ð'r1   )NN)ry   r@   r¬  r¨  rl  úOptional[int]rX   rf  )rZ   r[   r\   r]   r3   rg  r&  r'  ri  rk  rn  rp  rr  r_   r1   r0   rf  rf  7  si   … ñð ƒIà!#€GÐÓ#ØˆI�N‰NÓ€Eð
 "Ø#'ð	àðð ðð !ð	ð
 
óò<3òó(r1   rf  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^__.*__$)rl  rm  z#Expected integer values for IntFlag)Ú_itemsrO  rv   Úmatchr5   r  rf  r}  r  r€  rŠ   r   Úimmutabledictry   Ú__members__)	rf   Ú	classnamer›   Údict_rj  rO  r  Úvrž   s	            r0   rÝ   z_IntFlagMeta.__init__t  s¯   € ð  ÐˆŒ
�UØ—K‘K–M‰DˆAˆqÜ�x‰x˜ QÔ'ØÜ˜!œSÔ!Ü˜Q¨!Ô,‘Ø—\‘\ #Ô&ÜÐ EÓFÐFàÜ�C˜˜CÔ Ø�L‰L˜Õð "ô '×4Ñ4Ù&+Ó,¡e˜sˆS�X‰X�s‰] eÑ,ó
ˆ�ùÚ,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²  rK   s    r0   Ú__iter__z_IntFlagMeta.__iter__�  s   € Ü!ð=ó
ð 	
r1   N)
r{  r@   r›   zTuple[Type[Any], ...]r|  úDict[str, Any]rj  r   rX   rY   )rX   zIterator[symbol])rZ   r[   r\   rÝ   r  r_   r1   r0   ru  ru  s  s<   „ ð
àð
ð %ð
ð ð	
ð
 ð
ð 
ó
ô2
r1   ru  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“  r_   r1   r0   r‚  r‚  •  s   „ òr1   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': )rO  ry   r    r1  )rÑ   Úchoicesry   Úresolve_symbol_namesÚ
enum_valueÚchoices         r0   Úparse_user_argument_for_enumr‹  ª  sq   € ð( &Ÿm™mžoÑˆ
�FØ�*ÑØÒÙ! c¨Z¯_©_Ò&<ØÒØ�FŠ]ØÒð .ð €{Øä
×
Ñ
Ð1°$°°s¸3¸'ÐBÓ
CÐCr1   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    r0   Úset_creation_orderrŽ  Ï  s   € ô  /€HÔÜ�qÑ�Or1   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)rk   ÚwarnrI   rJ   )r  r  r@  s      r0   Ú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  )rQ   Úlen_s     r0   Ú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)rA  rk  rj  r—  )rf   rQ   Únumr  ÚinterpolatedrL   r}   s         €r0   rk  z_hash_limit_string.__new__þ  sR   ø€ ð  ™ØDÀsÑJñ
ˆô ‰w‰˜s LÓ1ˆÜ˜' U¬D°Ó,>ÀÑ,DÐ$EÑEÓFˆŒ
Øˆr1   c                ó   — | j                   S r+   )r—  rK   s    r0   Ú__hash__z_hash_limit_string.__hash__  s   € Ø�z‰zÐr1   c                ó0   — t        | «      t        |«      k(  S r+   )rj  )rL   Úothers     r0   Ú__eq__z_hash_limit_string.__eq__  s   € Ü�D‹zœT %›[Ñ(Ð(r1   )rQ   r@   r™  r  r  úSequence[Any]rX   r–  )rX   r  )rž  r   rX   rõ   )	rZ   r[   r\   r]   r3   rk  rœ  rŸ  rC  rD  s   @r0   r–  r–  ñ  s>   ø… ñð ƒJðØðØ!ðØ)6ðà	õó÷)r1   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     r0   r�  r�    s(   € ñ Ü”s—}‘} S¨tÔ4Õ5ä�sœCŸM™MÕ*r1   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     r0   Úwarn_limitedr§    s#   € ñ
 Ü   b¨$Ó/ˆÜ�3œŸ™Õ&r1   z)Dict[CodeType, Tuple[str, Type[Warning]]]Ú_warning_tagsc                ó   ‡ ‡— ˆˆ fd„}|S )Nc                ó2   •— ‰‰ft         | j                  <   | S r+   )r¨  rò   )r¡   ÚcategoryÚmessages    €€r0   Úgoz#tag_method_for_warnings.<locals>.go,  s   ø€ Ø&-¨xÐ%8Œ�b—k‘kÑ"Øˆ	r1   r_   )r¬  r«  r­  s   `` r0   Útag_method_for_warningsr®  )  s   ù€ õð €Ir1   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)
NFrZ   r­   Tz (rJ  r   r   )Ú
stacklevel)rI   Ú	_getframerv   rx  Ú_not_sa_patternÚ	f_globalsr8   Úf_coder¨  Úf_backr  Úwarningsr�  )r¬  r«  r°  ÚframeÚstacklevel_foundÚwarning_tag_foundÚ_suffixÚ	_categorys           r0   r¢  r¢  6  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˜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   )rb   Úinsert)rÑ   rj  Ú	strong_fnÚonce_fnr¡   ÚonceÚretry_on_exceptions       €€€r0   r­  zonly_once.<locals>.goq  sM   ø€ ð ˆ	ÙØ—h‘h“jˆGðÙ Ð* rÑ*Ð*ð øðÙ%Ø—K‘K  7Ô+Øús   —   7)rÑ   r   rj  r   rX   zOptional[_T]r_   )r¡   rÂ  r­  rÁ  s   `` @r0   Ú	only_oncerÃ  i  s   ú€ ð ˆ4€D÷ð €Ir1   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_suffixr†   Úends        r0   Ú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ÐÐr1   c                ó^   — d| z  }t        «       j                  «       }t        ||«       |d   S )Nz&def set(obj, value):    obj.%s = valuera   )r  ÚcopyrÔ   )ÚattrnamerÅ   rÀ   s      r0   Ú
attrsetterrÎ  ¤  s,   € Ø3°hÑ>€DÜ
‹(�-‰-‹/€CÜˆˆs„OØˆu‰:Ðr1   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.

    r_   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  r7   Ú_dundersrx  ÚAssertionErrorrA  Ú__init_subclass__)rf   ry   Ú	remainingr}   s      €r0   rÔ  zTypingOnly.__init_subclass__¶  sv   ø€ Ü˜Ÿ™Ñ&à!$§¢óÙ!-˜´X·^±^ÀDÕ5I’ ð ð ñ Ü$Ø˜S˜Eð "-Ø-6¨K°qð:óð ô 	‰Ñ!Õ#ùòs
   ¢A&½A&rW   )rZ   r[   r\   r]   r^   rÔ  rC  rD  s   @r0   rÐ  rÐ  ®  s   ø„ ñð
 €I÷
$ñ 
$r1   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 r+   )rØ  r7   rv   rx  r   r²   r  Ú
_wrap_w_kwr€  rA  rÔ  )	rf   Úfn_regÚclsdictrw  rC   r¡   r¿   Úwrappedr}   s	           €r0   rÔ  zEnsureKWArg.__init_subclass__Ö  s~   ø€ Ø×!Ñ!ˆØ—,‘,ˆÙÛ�Ü—H‘H˜V SÓ)�ÚØ  ™�BÜ!×8Ñ8¸Ó<�DØŸ:›:Ø"%§.¡.°Ó"4˜Ü  S¨'Õ2ð ô 	‰Ñ!Õ#r1   c                ó(   ‡— dˆfd„}t        |‰«      S )Nc                 ó   •—  ‰| Ž S r+   r_   )rÑ   rj  r¡   s     €r0   Úwrapz$EnsureKWArg._wrap_w_kw.<locals>.wrapæ  s   ø€ Ù�s�8ˆOr1   )rÑ   r   rj  r   rX   r   r   )rf   r¡   rà  s    ` r0   rÚ  zEnsureKWArg._wrap_w_kwä  s   ø€ õ	ô ˜d BÓ'Ð'r1   rW   )r¡   r{   rX   r{   )	rZ   r[   r\   r]   r3   rÔ  rÃ  rÚ  rC  rD  s   @r0   r×  r×  Ã  s.   ø… ñð Óðõ$ð ò(ó ô(r1   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

    rZ   r[   r]   )r‰   r   r}   rZ   r[   r  r]   )Úwrapperr¡   Ú_fs      r0   Úwrap_callablerä  ì  s‘   € ô ˆr�:ÔÜ˜g rÓ*Ð*àˆØ—l‘l×+Ñ+ˆŒÜ�2�|Ô$ØŸM™MˆBŒMä�2—;‘; 	Ô*¨r¯{©{×/BÒ/BØŸ™×,Ñ,ˆBŒJð ˆ	ð �ZŠZØŸ™ˆBŒJàˆ	r1   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Š   ru   )rQ   re  rÌ  ÚidxÚlvÚcharrì   s          r0   Ú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­   )r]   Úinject_param_text)r¡   r¬  ÚparamÚparamsr  s      €€r0   rÈ   z$add_parameter_text.<locals>.decorate3  sS   ø€ Ø�j‰j Ð$Ò3¨¯©Ò9°rˆÙÜ# CÁ6Ó)JÁ6¸%¨%°©+À6Ñ)JÓKˆCØˆŒ
Øˆ	ùò *Ks   ®
A
)r   rK  )rï  r  rÈ   s   `` r0   Úadd_parameter_textrð  0  s   ù€ Ü×!Ñ! &Ó)€Fõð €Or1   c                óÒ   — | j                  dd«      }t        |«      dk(  r| S |\  }}|j                  d«      s|dz   t        j                  |«      z   S t        j                  | «      S )NÚ
r   ro   )rë   r,  r}  ÚtextwrapÚdedent)r  Ú
split_textÚ	firstlinerÕ  s       r0   Ú_dedent_docstringr÷  =  sc   € Ø—‘˜D !Ó$€JÜ
ˆ:ƒ˜!ÒØˆà)Ñˆ	�9Ø×Ñ Ô$Ø˜4Ñ¤(§/¡/°)Ó"<Ñ<Ð<ä�‰˜tÓ$Ð$r1   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¾  rM  r  Úminru   )
Úgiven_doctextÚ
injecttextÚposÚdoctextÚlinesÚinjectlinesr™  ÚlineÚblanksÚ
inject_poss
             r0   Úinject_docstring_textr  I  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¸4¿:¹:½<ŠcÐ#3€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   Ú*ro   r   z(\s+)\Sr   rò  z::)ÚcollectionsÚdequeÚ
splitlinesÚpopleftÚ
_param_regrx  rÚ   Úlstripr,  rv   rd   Úrstripr~  rŠ   ru   )
rý  Úinject_paramsÚdoclinesrþ  Ú	to_injectr   rC   rî  ÚindentÚm2s
             r0   rí  rí  `  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ÓÐr1   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..rI  z, ..., )r,  ru   )rÁ   Úflagry   Úress       r0   Úrepr_tuple_namesr  ‹  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                ó,   — t         ry| rt        d«      ‚y)NTzDcython extensions were expected to be installed, but are not presentF)r   ÚImportError)Úraise_s    r0   Úhas_compiled_extr  ™  s"   € ÝØÙ	Üð"ó
ð 	
ð
 r1   c                  ó.   — e Zd Z ej                  «       Zy)Ú_MissingN)rZ   r[   r\   ÚenumÚautoÚMissingr_   r1   r0   r  r  ¥  s   „ Øˆd�i‰i‹k�Gr1   r  )r/   r   rX   r4   )rB   r   rX   r@   )rf   úType[_T]rX   zIterator[Type[_T]])rl   r   rX   r@   r+   )rf   ú	Type[Any]rx   r¨  rX   r@   )r~   zUnion[Type[Any], object]r   r{   rX   rõ   )rŒ   ÚslicerX   úTuple[Any, ...])rš   úSequence[str]r›   r@   rX   zIterator[str])r¡   zCallable[[int], Any]rs   r  rX   zIterator[Any])r¨   r{   rX   zCallable[[_Fn], _Fn])rÅ   zUnion[str, types.CodeType]rÀ   r€  rÃ   r@   rX   r{   )rf   r6   rü   úOptional[Set[str]]rý   zLiteral[True]rX   zSet[str])rf   r6   rü   r%  rý   rõ   rX   r%  )r  r{   rX   ú	List[str])FF)r¡   r{   r  rõ   r  rõ   rX   zcompat.FullArgSpec)T)r¡   z-Union[Callable[..., Any], compat.FullArgSpec]rª   rõ   rX   zDict[str, Optional[str]])r_   r_   r_   r_   )r7  r!  r8  r@   r9  r@   r:  r$  r;  r$  r<  r$  r=  r$  rX   zCallable[[_T], _T])r_   Nr_   )
r/   r   rP  zSequence[Tuple[str, Any]]rQ  z%Optional[Union[object, List[object]]]rR  r$  rX   r@   )NNz
self.proxyN)NNNrí  )r/   r   rX   rõ   )r  r@   rX   z!Callable[[str], Union[str, bool]])rQ   r   rX   rs  )TN)rj  r€  rw  r@   rP   r!  r  rõ   r  zOptional[Dict[str, Any]]rX   rY   )r/   r   rf   r!  rX   r#  )
r/   r!   rf   r   r  r   rj  r   rX   r!   )rX   zCallable[[], int])r+  r   rY  úOptional[Type[Any]]rX   r'  )rÑ   r   r2  z'Union[Tuple[Type[Any], ...], Type[Any]]ry   r@   rX   r   )F)
rÑ   r   r‡  zDict[_E, List[Any]]ry   r@   rˆ  rõ   rX   zOptional[_E]rÂ  )r  r{   r  r   r@  r   rX   r   )é   )r¤  r@   rÅ   r¨  rX   rY   )r¤  r@   r  r   rX   rY   )r¬  r@   r«  zType[Warning]rX   úCallable[[_F], _F])Nr   )r¬  zUnion[str, Warning]r«  zOptional[Type[Warning]]r°  r  rX   rY   )r¡   rä  rÂ  rõ   rX   zCallable[..., Optional[_T]])rÆ  r&  rÇ  úre.Pattern[str]rÈ  r*  rX   r&  )rï  r   r  r@   rX   r)  )r  r@   rX   r@   )rú  r¨  rû  r@   rü  r  rX   r@   )rý  r@   r  zDict[str, str]rX   r@   )rÁ   r&  rX   r¨  )žr]   Ú
__future__r   r  r  Ú	functoolsr   r,   r•   r–  rv   rI   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   r   Ú_has_cyr   r   r    r!   r"   r$   r&   r'   r(   r)   Úpy310r-   rD   rF   ri   rm   rz   rƒ   rŽ   rŸ   r£   r¤   rÉ   r³   r¼   rÕ   rÖ   rØ   rû   r   r  r  rµ   r4  r>  rA  rE  r]  r_  rs  rx  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-  r3  rš  r>  rF  rW  ra  r  rf  r6   ru  r‚  r„  ÚFastIntFlagÚEnumr…  r‹  r�  rŽ  r‘  r”  r@   r–  r�  r§  r¨  r3   r®  Úcompiler²  r¢  rÃ  Ú_SQLA_REÚ_UNITTEST_RErÊ  ÚNoneTyperÎ  rÒ  rÐ  r×  rä  rê  rð  r÷  r  r
  rí  r  r  r  r  Ú	MissingOrr_   r1   r0   Ú<module>r<     s·  ðòõ #ã Û Ý $Û Û Û Û 	Û 
Û Û Û Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý Ý  Ý Ý Û å Ý Ý $Ý Ý áˆTƒ]€Ù� 4Ô(€ÙˆT˜ # s (Ñ+Ô,€ÙˆeÐ3Ô4€ÙˆeÐ@ÔA€ÙˆeÐ0Ô1€ÙˆeÐ.Ô/€ð 
‡<‚<ô,ó
2ó"$÷82ñ 82óvó6ð /3ðOØ	ðOØ+ðOàóOð,Ø-ð,à&ð,ð 
ó,ó$óMó ñ ˆeÐ/Ô0€ó
D,òNð*Ø
$ðØ+9ðØDGðàóñ ˆeƒn€Ùˆeƒn€÷% ñ % òP
ð( 
ð  $Ø!ñ	Ø	ðð ðð ð	ð
 òó 
ðð 
à-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ðF #%ØØ "Ø/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Ð%÷*/ñ */ó\	óóð Ø%)ð'Øð'à	ð'ð ð'ð ð	'ð
 #ð'ð 
ó'ó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�	r1   