grthtrhthjhtyjytjytkergtrhtrjytjerhrfh4:24 29/09/2026B Ø@Z°? £Ñã>@s´ddlZddlmZmZddlZddlZddlZddlZddlZddlZ ddl Z ddl Z ddl m Z m Z mZdddddd d d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAg>Zd«dCdD„ZdEdF„ZdGdH„ZdIdJ„ZdKdL„ZdMdN„ZgZdOdP„ZdQdR„ZGdSdT„dTƒZGdUdV„dVƒZGdWdX„dXeedBdY�ZeddZd[�Zed>d\d[�Zedd]d[�Zed d^d[�Zed d_d[�Z Gd`d„dedBdY�Z!Gdad „d eedBdY�Z"d2d d0d4d5d/d1d ddbœ Z#dcdd„Z$Gdedf„dfedBdY�Z%Gdgdh„dhe%dBdY�Z&Gdid„dƒZ'Gdjdk„dkƒZ(Gdldm„dmƒZ)dnd9„Z*dodp„Z+e j,e j-e j.e j/e e efZ0d¬dqd:„Z1drd<„Z2dsd=„Z3dtdu„Z4dvd?„Z5Gdwdx„dxe6ƒZ7Gdydz„dze'e7d{�Z8e"d|ƒZ9e"d}ƒZ:e"d~ƒZ;e"ddBd€�Ze"dƒdBd„�Z?e"d…dBe6d†�Z@e"d8eAeBƒZCd­d‡dˆ„ZDeDejjEd‰ƒZEeDejjFe<ƒZFeDejjGefƒZUeDejjVe:e;fƒZVeDejjWe<ƒZWeDejjXe9ƒZXeDejjYd‰ƒZYe&eZd‰dŒdBd��Z[dŽe[_QeDe\e9dŒd��Z]eDej^e9ƒZ_eDe`e9dŒd��ZReDeaefƒZeeDejjfe>ƒZfeDejge<ƒZheDejie<ƒZjeDeke:e;fdŒd��ZleDejme:e;fƒZneDejoe:e;fƒZoeDejpe9ƒZpeDejqe:e;fƒZqeDejjre°sz&_collect_type_vars..)rHrÚappendrJÚ_specialÚextendÚ__parameters__Útuple)rXr_rR)r`rSÚ_collect_type_vars¥s  rgcCsšt|tƒs|St|jƒ}x\t|jƒD]N\}}t|tƒrbx:t|ƒD]\}}||kr@||||<q@Wq$t|||ƒ||<q$W|jtkrŒtt |ƒS|  t |ƒ¡S)N) rHrJÚlistÚ__args__Ú enumeraterÚ _subs_tvarsrKrrfÚ copy_with)Útpr`ZsubsZnew_argsÚarOÚiZtvarrRrRrSrk´s     rkc Cs^|jst|›d�ƒ‚t|ƒ}t|jƒ}||krZtd||kr>dnd›d|›d|›d|›�ƒ‚dS)Nz is not a generic classzToo ZmanyZfewz parameters for z ; actual z , expected )rerLÚlen)ÚclsÚ parametersZalenZelenrRrRrSÚ_check_genericÇs  rscCsÆg}xn|D]f}t|tƒr0|jtkr0| |j¡q t|tƒrft|ƒdkrf|dtkrf| |dd…¡q | |¡q Wt |ƒ}t|ƒt|ƒkr¾g}x(|D] }||kr–| |¡|  |¡q–W|}t|ƒS)Nré) rHrJrKrrdrirfrprbÚsetÚremove)rrÚparamsÚpZ all_paramsZ new_paramsr_rRrRrSÚ_remove_dups_flattenÔs  "  rycs4t ¡ˆƒ‰t ˆj¡t ˆ¡‡‡fdd„ƒ}|S)Ncs*y ˆ||ŽStk rYnXˆ||ŽS)N)rL)ÚargsÚkwds)ÚcachedÚfuncrRrSÚinnerøs  z_tp_cache..inner)Ú functoolsÚ lru_cacheÚ _cleanupsrbÚ cache_clearÚwraps)r}r~rR)r|r}rSÚ _tp_cacheñs  r„csbt|tƒr| ˆˆ¡St|tƒr^t‡‡fdd„|jDƒƒ}||jkrH|S| |¡}|j|_|S|S)Nc3s|]}t|ˆˆƒVqdS)N)Ú _eval_type)r^rn)ÚglobalnsÚlocalnsrRrSú sz_eval_type..)rHr Ú _evaluaterJrfrirlrc)r_r†r‡Zev_argsÚresrR)r†r‡rSr…s     r…c@seZdZdZdd„ZdS)Ú_Final)Ú __weakref__cOsd|krtdƒ‚dS)NÚ_rootz&Cannot subclass special typing classes)rL)Úselfrzr{rRrRrSÚ__init_subclass__sz_Final.__init_subclass__N)rZrVrWÚ __slots__r�rRrRrRrSr‹sr‹c@seZdZdd„Zdd„ZdS)Ú _ImmutablecCs|S)NrR)rŽrRrRrSÚ__copy__sz_Immutable.__copy__cCs|S)NrR)rŽZmemorRrRrSÚ __deepcopy__!sz_Immutable.__deepcopy__N)rZrVrWr’r“rRrRrRrSr‘sr‘csleZdZdZ‡fdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z e dd„ƒZ‡ZS)rM)Ú_nameÚ_doccsBt|ƒdkr6t|dtƒr6t|dtƒr6td|›�ƒ‚tƒ |¡S)NérrtzCannot subclass )rprHrIrfrLÚsuperÚ__new__)rqrzr{)Ú __class__rRrSr˜,s  z_SpecialForm.__new__cCs||_||_dS)N)r”r•)rŽÚnameÚdocrRrRrSÚ__init__9sz_SpecialForm.__init__cCst|tƒstS|j|jkS)N)rHrMÚNotImplementedr”)rŽÚotherrRrRrSÚ__eq__=s z_SpecialForm.__eq__cCs t|jfƒS)N)Úhashr”)rŽrRrRrSÚ__hash__Bsz_SpecialForm.__hash__cCs d|jS)Nztyping.)r”)rŽrRrRrSÚ__repr__Esz_SpecialForm.__repr__cCs|jS)N)r”)rŽrRrRrSÚ __reduce__Hsz_SpecialForm.__reduce__cOstd|›�ƒ‚dS)NzCannot instantiate )rL)rŽrzr{rRrRrSÚ__call__Ksz_SpecialForm.__call__cCst|›d�ƒ‚dS)Nz! cannot be used with isinstance())rL)rŽr\rRrRrSÚ__instancecheck__Nsz_SpecialForm.__instancecheck__cCst|›d�ƒ‚dS)Nz! cannot be used with issubclass())rL)rŽrqrRrRrSÚ__subclasscheck__Qsz_SpecialForm.__subclasscheck__csÀ|jdkr t|dƒ}t||fƒS|jdkrŠ|dkr:tdƒ‚t|tƒsJ|f}d‰t‡fdd„|Dƒƒ}t|ƒ}t|ƒd kr€|d St||ƒS|jd kr®t|d ƒ}t|t dƒfSt|›d �ƒ‚dS)Nr z"ClassVar accepts only single type.rrRz Cannot take a Union of no types.z)Union[arg, ...]: each arg must be a type.c3s|]}t|ˆƒVqdS)N)rT)r^rx)rPrRrSrˆ_sz+_SpecialForm.__getitem__..rtrr z#Optional[t] requires a single type.z is not subscriptable) r”rTrJrLrHrfryrprrG)rŽrrÚitemrOrR)rPrSÚ __getitem__Ts$         z_SpecialForm.__getitem__)rZrVrWr�r˜rœrŸr¡r¢r£r¤r¥r¦r„r¨Ú __classcell__rRrR)r™rSrM%s rM)r�a`Special type indicating an unconstrained type. - Any is compatible with every type. - Any assumed to have all methods. - All values assumed to be instances of Any. Note that all the above statements are true from the point of view of static type checkers. At runtime, Any should not be used with instance or class checks. )r›aSpecial type indicating functions that never return. Example:: from typing import NoReturn def stop() -> NoReturn: raise Exception('no way') This type is invalid in other positions, e.g., ``List[NoReturn]`` will fail in static type checkers. a3Special type construct to mark class variables. An annotation wrapped in ClassVar indicates that a given attribute is intended to be used as a class variable and should not be set on instances of that class. Usage:: class Starship: stats: ClassVar[Dict[str, int]] = {} # class variable damage: int = 10 # instance variable ClassVar accepts only types and cannot be further subscribed. Note that ClassVar is not a class itself, and should not be used with isinstance() or issubclass(). a'Union type; Union[X, Y] means either X or Y. To define a union, use e.g. Union[int, str]. Details: - The arguments must be types and there must be at least one. - None as an argument is a special case and is replaced by type(None). - Unions of unions are flattened, e.g.:: Union[Union[int, str], float] == Union[int, str, float] - Unions of a single argument vanish, e.g.:: Union[int] == int # The constructor actually returns int - Redundant arguments are skipped, e.g.:: Union[int, str, int] == Union[int, str] - When comparing unions, the argument order is ignored, e.g.:: Union[int, str] == Union[str, int] - You cannot subclass or instantiate a union. - You can use Optional[X] as a shorthand for Union[X, None]. zEOptional type. Optional[X] is equivalent to Union[X, None]. c@s:eZdZdZddd„Zdd„Zdd„Zd d „Zd d „Zd S)r )Ú__forward_arg__Ú__forward_code__Ú__forward_evaluated__Ú__forward_value__Ú__forward_is_argument__TcCsnt|tƒstd|›�ƒ‚yt|ddƒ}Wn"tk rJtd|›�ƒ‚YnX||_||_d|_d|_||_ dS)Nz*Forward reference must be a string -- got zÚevalz/Forward reference must be an expression -- got F) rHrIrLÚcompileÚ SyntaxErrorrªr«r¬r­r®)rŽrOrQÚcoderRrRrSrœ½s zForwardRef.__init__cCsj|jr||k rd|dkr(|dkr(i}}n|dkr6|}n |dkrB|}tt|j||ƒd|jd�|_d|_|jS)Nz*Forward references must evaluate to types.)rQT)r¬rTr¯r«r®r­)rŽr†r‡rRrRrSr‰Ês   zForwardRef._evaluatecCs>t|tƒstS|jr2|jr2|j|jko0|j|jkS|j|jkS)N)rHr r�r¬rªr­)rŽržrRrRrSrŸÙs     zForwardRef.__eq__cCs t|jƒS)N)r rª)rŽrRrRrSr¡ászForwardRef.__hash__cCsd|j›d�S)Nz ForwardRef(ú))rª)rŽrRrRrSr¢äszForwardRef.__repr__N)T) rZrVrWr�rœr‰rŸr¡r¢rRrRrRrSr ¶s  c@s2eZdZdZddddœdd„Zdd„Zd d „ZdS) r)rZÚ __bound__Ú__constraints__Ú __covariant__Ú__contravariant__NF)ÚboundÚ covariantÚ contravariantc sÒ||_|r|rtdƒ‚t|ƒ|_t|ƒ|_|r>|dk r>tdƒ‚|rVt|ƒdkrVtdƒ‚d‰t‡fdd„|Dƒƒ|_|r„t |dƒ|_ nd|_ yt   d¡j  d d ¡}Wnttfk r¾d}YnX|d krÎ||_dS) Nz"Bivariant types are not supported.z-Constraints cannot be combined with bound=...rtz"A single constraint is not allowedz:TypeVar(name, constraint, ...): constraints must be types.c3s|]}t|ˆƒVqdS)N)rT)r^r_)rPrRrSrˆ#sz#TypeVar.__init__..zBound must be a type.rZÚ__main__Útyping)rZÚ ValueErrorÚboolr¶r·rLrprfrµrTr´ÚsysÚ _getframeÚ f_globalsÚgetÚAttributeErrorrV)rŽršr¸r¹rºZ constraintsZdef_modrR)rPrSrœs(    zTypeVar.__init__cCs&|jr d}n|jrd}nd}||jS)Nú+ú-ú~)r¶r·rZ)rŽÚprefixrRrRrSr¢/s zTypeVar.__repr__cCs|jS)N)rZ)rŽrRrRrSr£8szTypeVar.__reduce__)rZrVrWr�rœr¢r£rRrRrRrSrès , ) rhrfÚdictruÚ frozensetÚdequeÚ defaultdictrGr7cCs| d¡o| d¡S)NÚ__)Ú startswithÚendswith)ÚattrrRrRrSÚ _is_dunderSsrÐcsŠeZdZddddœdd„Zedd„ƒZd d „Zd d „Zd d„Zdd„Z dd„Z dd„Z dd„Z ‡fdd„Z dd„Zdd„Zdd„Z‡ZS)rJTFN)ÚinstÚspecialršcCsz||_||_|r*|dkr*|j}t ||¡}||_t|tƒs@|f}||_tdd„|Dƒƒ|_ t |ƒ|_ d|_ |sv|j |_ dS)Ncss*|]"}|tkrdn|tkrdn|VqdS).rRN)Ú_TypingEllipsisÚ _TypingEmpty)r^rnrRrRrSrˆjsz)_GenericAlias.__init__..)Ú_instrcrZÚ_normalize_aliasrÂr”rHrfrKrirgrer�rV)rŽÚoriginrwrÑrÒršZ orig_namerRrRrSrœ`s     z_GenericAlias.__init__cs^|jttfkrtd|›�ƒ‚t|tƒs,|f}d‰t‡fdd„|Dƒƒ}t||ƒt||j|ƒS)Nz%Cannot subscript already-subscripted z*Parameters to generic types must be types.c3s|]}t|ˆƒVqdS)N)rT)r^rx)rPrRrSrˆzsz,_GenericAlias.__getitem__..) rKr rFrLrHrfrsrkre)rŽrwrR)rPrSr¨rs  z_GenericAlias.__getitem__cCst|j||j|jd�S)N)ršrÑ)rJrKr”rÕ)rŽrwrRrRrSrl~sz_GenericAlias.copy_withcCs¸|jdks&t|jƒdkrx|jdtkrx|jr8d|j}n t|jƒ}|jshdd dd„|jDƒ¡›d �}nd }|›|›�S|jr‚d Sd d d d„|jdd…Dƒ¡›dt|jdƒ›d �S)Nrérztyping.ú[z, cSsg|] }t|ƒ‘qSrR)r])r^rnrRrRrSraŠsz*_GenericAlias.__repr__..ú]Úztyping.Callableztyping.Callable[[cSsg|] }t|ƒ‘qSrR)r])r^rnrRrRrSra�séÿÿÿÿz], )r”rpriÚEllipsisr]rKrcÚjoin)rŽršrzrRrRrSr¢‚s     z_GenericAlias.__repr__cCsRt|tƒstS|j|jkrdS|jtkrF|jtkrFt|jƒt|jƒkS|j|jkS)NF)rHrJr�rKrrÉri)rŽržrRrRrSrŸ”s  z_GenericAlias.__eq__cCs,|jtkrttt|jƒfƒSt|j|jfƒS)N)rKrr rÉri)rŽrRrRrSr¡�s z_GenericAlias.__hash__cOsT|js$td|j›d|j ¡›d�ƒ‚|j||Ž}y ||_Wntk rNYnX|S)NzType z cannot be instantiated; use z () instead)rÕrLr”ÚlowerrKZ__orig_class__rÃ)rŽrzÚkwargsÚresultrRrRrSr¤¢s  z_GenericAlias.__call__cCs¦|jrZg}|j|kr | |j¡| |¡}tdd„||dd…DƒƒsR| t¡t|ƒS|jtkrž| |¡}x.||dd…D]}t|tƒr€||k r€dSq€W|jfS)Ncss"|]}t|tƒpt|tƒVqdS)N)rHrJÚ issubclassr )r^ÚbrRrRrSrˆ³sz0_GenericAlias.__mro_entries__..rtrR) r”rKrbÚindexÚanyr rfrHrJ)rŽÚbasesrŠrorãrRrRrSÚ__mro_entries__­s      z_GenericAlias.__mro_entries__cCs*d|jkrt|ƒst|j|ƒSt|ƒ‚dS)NrK)Ú__dict__rÐÚgetattrrKrÃ)rŽrÏrRrRrSÚ __getattr__¾s z_GenericAlias.__getattr__cs2t|ƒs|dkr tƒ ||¡nt|j||ƒdS)N)r”rÕrc)rÐr—Ú __setattr__ÚsetattrrK)rŽrÏÚval)r™rRrSrëÅsz_GenericAlias.__setattr__cCs| t|ƒ¡S)N)r¦rG)rŽr\rRrRrSr¥Ësz_GenericAlias.__instancecheck__cCs<|jr0t|tƒst||jƒS|jr0t|j|jƒStdƒ‚dS)NzBSubscripted generics cannot be used with class and instance checks)rcrHrJrârKrL)rŽrqrRrRrSr¦Îs   z_GenericAlias.__subclasscheck__cCs |jr |jS|jr tƒ|j}n|j}|tkrht|jƒdkrJ|jdtksht|jdd…ƒ|jdf}n*t |jƒ}t|ƒdkr’t |dt ƒs’|\}t j ||ffS)NrØrrÜrt) rcr”ÚglobalsrKrrprirÝrhrfrHÚoperatorÚgetitem)rŽr×rzrRrRrSr£×s z_GenericAlias.__reduce__)rZrVrWrœr„r¨rlr¢rŸr¡r¤rçrêrër¥r¦r£r©rRrR)r™rSrJWs      rJcs(eZdZdd„Ze‡fdd„ƒZ‡ZS)Ú_VariadicGenericAliascCs€|jdks|js| |¡St|tƒr0t|ƒdkr8tdƒ‚|\}}|tkrRt|f}n$t|tƒsjtd|›�ƒ‚t|ƒ|f}| |¡S)NrrØz6Callable must be used as Callable[[arg, ...], result].z1Callable[args, result]: args must be a list. Got ) r”rcÚ__getitem_inner__rHrfrprLrÝrh)rŽrwrzrárRrRrSr¨ís    z!_VariadicGenericAlias.__getitem__cs |jtkr�|jr�|dkr$| tf¡St|tƒs4|f}t|ƒdkrl|ddkrld‰t|dˆƒ}| |tf¡Sd‰t‡fdd „|Dƒƒ}| |¡S|jt j j krþ|jrþ|\}}d ‰t|ˆƒ}|t krÐ| t|f¡Sd ‰t‡fd d „|Dƒƒ}||f}| |¡St ƒ |¡S) NrRrØrt.z Tuple[t, ...]: t must be a type.rz*Tuple[t0, t1, ...]: each t must be a type.c3s|]}t|ˆƒVqdS)N)rT)r^rx)rPrRrSrˆ sz:_VariadicGenericAlias.__getitem_inner__..z.Callable[args, result]: result must be a type.z6Callable[[arg, ...], result]: each arg must be a type.c3s|]}t|ˆƒVqdS)N)rT)r^rO)rPrRrSrˆs)rKrfrcrlrÔrHrprTrÓÚ collectionsÚabcrrÝr—r¨)rŽrwrxrzrá)r™)rPrSròýs.      z'_VariadicGenericAlias.__getitem_inner__)rZrVrWr¨r„ròr©rRrR)r™rSrñésrñcs8eZdZdZ‡fdd„Zedd„ƒZ‡fdd„Z‡ZS)r rRcsP|tkrtdƒ‚tƒjtjkr8|jtjk r8tƒ |¡}ntƒj|f|ž|Ž}|S)NzHType Generic cannot be instantiated; it can be used only as a base class)r rLr—r˜Úobjectrœ)rqrzr{r\)r™rRrSr˜.s zGeneric.__new__cs¦t|tƒs|f}|s.|tk r.td|j›d�ƒ‚d‰t‡fdd„|Dƒƒ}|tkrˆtdd„|Dƒƒsjtdƒ‚tt|ƒƒt|ƒkrœtdƒ‚n|t kr’n t ||ƒt ||ƒS) NzParameter list to z[...] cannot be emptyz*Parameters to generic types must be types.c3s|]}t|ˆƒVqdS)N)rT)r^rx)rPrRrSrˆ@sz,Generic.__class_getitem__..css|]}t|tƒVqdS)N)rHr)r^rxrRrRrSrˆCsz5Parameters to Generic[...] must all be type variablesz-Parameters to Generic[...] must all be unique) rHrfr rLrWr ÚallrprurFrsrJ)rqrwrR)rPrSÚ__class_getitem__8s$   zGeneric.__class_getitem__c stƒj||Žg}d|jkr(t|jk}nt|jko:|jdk}|rHtdƒ‚d|jk�r t|jƒ}d}x8|jD].}t |t ƒrj|j tkrj|dk r’tdƒ‚|j }qjW|dkrª|}n`t |ƒ}t |ƒ‰|ˆk�sd ‡fdd„|Dƒ¡}d dd„|Dƒ¡} td |›d | ›d �ƒ‚|}t|ƒ|_ dS) NÚ__orig_bases__rFz!Cannot inherit from plain Genericz0Cannot inherit from Generic[...] multiple types.z, c3s|]}|ˆkrt|ƒVqdS)N)rI)r^r_)ÚgvarsetrRrSrˆosz,Generic.__init_subclass__..css|]}t|ƒVqdS)N)rI)r^ÚgrRrRrSrˆpszSome type variables (z) are not listed in Generic[rÚ)r—r�rèr røÚ __bases__rZrLrgrHrJrKrerurÞrf) rqrzràr`ÚerrorZgvarsÚbaseZtvarsetZs_varsZs_args)r™)rùrSr�Qs6         zGeneric.__init_subclass__) rZrVrWr�r˜r„r÷r�r©rRrR)r™rSr s c@s eZdZdS)rÔN)rZrVrWrRrRrRrSrÔwsrÔc@s eZdZdS)rÓN)rZrVrWrRrRrRrSrÓ~srÓcCs|S)NrR)ÚtyprírRrRrSr<‚sc Cs�y |j}Wntk riSX|j}|j}|d|…}|jp@d}|j}|rTt|ƒni}|t|ƒ}x&t||d…|ƒD]\}} | ||<qxW|S)NrR) Ú__code__rÃÚ co_argcountÚ co_varnamesÚ __defaults__Ú__kwdefaults__rÈrpÚzip) r}r²Z pos_countZ arg_namesÚdefaultsZ kwdefaultsrŠZ pos_offsetršÚvaluerRrRrSÚ _get_defaults�s     rc CsÌt|ddƒriSt|tƒr°i}xŒt|jƒD]~}|dkrFtj|jj}n|}|j  di¡}xN|  ¡D]B\}}|dkrztdƒ}t|t ƒr�t |dd�}t |||ƒ}|||<qbWq*W|S|dk�rt|tjƒrÎ|j}n&|} xt| dƒræ| j} qÔWt| diƒ}|dk�r|}n|dk�r|}t|ddƒ}|dk�rFt|tƒ�r8iStd |¡ƒ‚t|ƒ} t|ƒ}xp|  ¡D]d\}}|dk�rztdƒ}t|t ƒ�rŽt |ƒ}t |||ƒ}|| k�rº| |dk�rºt|}|||<�q`W|S)NÚ__no_type_check__Ú__annotations__F)rQÚ __wrapped__Ú __globals__z1{!r} is not a module, class, method, or function.)rérHrGÚreversedÚ__mro__r¿ÚmodulesrVrèrÂÚitemsrIr r…rXÚ ModuleTypeÚhasattrr Ú_allowed_typesrLÚformatrrÈr ) r\r†r‡ZhintsrýZ base_globalsÚannršrZnsobjrrRrRrSr=¦s\                  cCs t|tƒr||j ¡}x0|j ¡D]"\}}||j|fkr | |¡q Wx4| ¡D](}t|tj ƒrfd|_ t|tƒrPt |ƒqPWy d|_ Wnt k ršYnX|S)NT) rHrGrèÚcopyrrûÚpopÚvaluesrXrYrr?rL)rOZ arg_attrsrÏrír\rRrRrSr?üs      cst ˆ¡‡fdd„ƒ}|S)Ncsˆ||Ž}t|ƒ}|S)N)r?)rzr{r})Ú decoratorrRrSÚwrapped_decorators z2no_type_check_decorator..wrapped_decorator)rrƒ)rrrR)rrSr@scOs tdƒ‚dS)Nz´You should not call an overloaded function. A series of @overload-decorated functions outside a stub module should always be followed by an implementation that is not @overload-ed.)ÚNotImplementedError)rzr{rRrRrSÚ_overload_dummy&srcCstS)N)r)r}rRrRrSrB/scs,eZdZ‡fdd„Zdd„Zdd„Z‡ZS)Ú _ProtocolMetacs"t|jkrtƒ |¡Stdƒ‚dS)Nz+Protocols cannot be used with isinstance().)rFrûr—r¥rL)rŽr\)r™rRrSr¥Ss  z_ProtocolMeta.__instancecheck__csL|js tS|tkrdS| ¡}x(|D] ‰t‡fdd„|jDƒƒs$dSq$WdS)NTc3s|]}ˆ|jkVqdS)N)rè)r^Úd)rÏrRrSrˆesz2_ProtocolMeta.__subclasscheck__..F)Ú _is_protocolr�rFÚ_get_protocol_attrsrår )rŽrqÚattrsrR)rÏrSr¦Xs z_ProtocolMeta.__subclasscheck__cCs&g}x.|jD]$}t|ddƒr |jdkr | |¡q Wtƒ}�xä|D]Ü}xÖ|j ¡D]È}xÂ|jD]$}||k r^||jkr^t|ddƒs^Pq^W| d¡sR|dkrR|dkrR|dkrR|dkrR|dkrR|d krR|d krR|d krR|d krR|d krR|dkrR|dkrR|dkrR|dkrR|dkrR|dkrR| |¡qRWqBW|S)NrFrFZ_abc_Ú__abstractmethods__r rŒZ_gorgrèrir�rZ__next_in_mro__rerKrøZ __extra__Z __tree_hash__rV) r rérZrbrurèÚkeysrÍÚadd)rŽZprotocol_basesÚcr rýrÏrRrRrSris<     z!_ProtocolMeta._get_protocol_attrs)rZrVrWr¥r¦rr©rRrR)r™rSrLs rcs$eZdZdZdZ‡fdd„Z‡ZS)rFrRTcs tƒ |¡S)N)r—r÷)rqrw)r™rRrSr÷œsz_Protocol.__class_getitem__)rZrVrWr�rr÷r©rRrR)r™rSrF�srF)Ú metaclassÚTÚKTÚVTÚT_co)r¹ÚV_coÚVT_coÚT_contra)rºÚCT_co)r¹r¸cCst||d|d�S)NT)rÒrÑ)rJ)r×rwrÑrRrRrSÚ_alias²sr.rR)rÒa�Callable type; Callable[[int], str] is a function of (int) -> str. The subscription syntax must always be used with exactly two values: the argument list and the return type. The argument list must be a list of types or ellipsis; the return type must be a single type. There is no syntax to indicate optional or keyword arguments, such function types are rarely used as callback types. F)rÑrÒa@Tuple type; Tuple[X, Y] is the cross-product type of X and Y. Example: Tuple[T1, T2] is a tuple of two elements corresponding to type variables T1 and T2. Tuple[int, float, str] is a tuple of an int, a float and a string. To specify a variable-length tuple of homogeneous type, use Tuple[T, ...]. )rÑa¾A special construct usable to annotate class objects. For example, suppose we have the following classes:: class User: ... # Abstract base for User classes class BasicUser(User): ... class ProUser(User): ... class TeamUser(User): ... And a function that takes a class argument that's a subclass of User and returns an instance of the corresponding class:: U = TypeVar('U', bound=User) def new_user(user_class: Type[U]) -> U: user = user_class() # (Here we could write the user object to a database) return user joe = new_user(BasicUser) At this point the type checker knows that joe has type BasicUser. c@s"eZdZdZeedœdd„ƒZdS)r.rR)ÚreturncCsdS)NrR)rŽrRrRrSÚ__int__ szSupportsInt.__int__N)rZrVrWr�rÚintr0rRrRrRrSr.sc@s"eZdZdZeedœdd„ƒZdS)r-rR)r/cCsdS)NrR)rŽrRrRrSÚ __float__szSupportsFloat.__float__N)rZrVrWr�rÚfloatr2rRrRrRrSr-sc@s"eZdZdZeedœdd„ƒZdS)r,rR)r/cCsdS)NrR)rŽrRrRrSÚ __complex__szSupportsComplex.__complex__N)rZrVrWr�rÚcomplexr4rRrRrRrSr,sc@s"eZdZdZeedœdd„ƒZdS)r+rR)r/cCsdS)NrR)rŽrRrRrSÚ __bytes__'szSupportsBytes.__bytes__N)rZrVrWr�rÚbytesr6rRrRrRrSr+#sc@s"eZdZdZeedœdd„ƒZdS)r*rR)r/cCsdS)NrR)rŽrRrRrSÚ__abs__0szSupportsAbs.__abs__N)rZrVrWr�rr)r8rRrRrRrSr*,sc@s&eZdZdZedeedœdd„ƒZdS)r/rRr)Úndigitsr/cCsdS)NrR)rŽr9rRrRrSÚ __round__9szSupportsRound.__round__N)r)rZrVrWr�rr1r)r:rRrRrRrSr/5sc svd‰‡fdd„|Dƒ}t |dd„|Dƒ¡}t |¡|_|_yt d¡j dd¡|_ Wnt t fk rpYnX|S)NzDNamedTuple('Name', [(f0, t0), (f1, t1), ...]); each t must be a typecsg|]\}}|t|ˆƒf‘qSrR)rT)r^Únr_)rPrRrSra@sz!_make_nmtuple..cSsg|] \}}|‘qSrRrR)r^r;r_rRrRrSraAsrØrZr») róÚ namedtupler6r Ú _field_typesr¿rÀrÁrÂrVrÃr½)ršrXÚnm_tplrR)rPrSÚ _make_nmtuple>sr?) r˜rœr�Ú__getnewargs__Ú_fieldsÚ_field_defaultsr=Ú_makeÚ_replaceÚ_asdictZ_source)rVrZr cseZdZ‡fdd„Z‡ZS)ÚNamedTupleMetac sü| dd¡rtƒ ||||¡S| di¡}t|| ¡ƒ}g}i}xP|D]H}||krn||} | | ¡| ||<qF|rFtdj|d |  ¡¡d�ƒ‚qFWt   |¡|j_ t |ƒ|j_||_xD|D]<} | tkrÒtd| ƒ‚q¸| tkr¸| |jkr¸t|| || ƒq¸W|S)Nr�Fr zXNon-default namedtuple field {field_name} cannot follow default field(s) {default_names}z, )Ú field_nameZ default_namesz&Cannot overwrite NamedTuple attribute )rÂr—r˜r?rrbrLrrÞr"rór6r rfrrBÚ _prohibitedrÃrcrArì) rqÚtypenameræÚnsrXr>rZ defaults_dictrGZ default_valueÚkey)r™rRrSr˜Vs0       zNamedTupleMeta.__new__)rZrVrWr˜r©rRrR)r™rSrFTsrFc@seZdZdZdd„Zde_dS)r9TcOsÊ|s tdƒ‚|^}}|r"|^}}nd|kr6| d¡}ntdƒ‚|r~y |\}Wq¢tk rztdt|ƒd›d�ƒd‚Yq¢Xn$d|kržt|ƒdkrž| d¡}nd}|dkr´| ¡}n |rÀtd ƒ‚t||ƒS) Nz*NamedTuple.__new__(): not enough argumentsrIzGNamedTuple.__new__() missing 1 required positional argument: 'typename'z@NamedTuple.__new__() takes from 2 to 3 positional arguments but rØz were givenÚfieldsrtzIEither list of fields or keywords can be provided to NamedTuple, not both)rLrr½rprr?)rzràrqrIrLrRrRrSr˜�s,      zNamedTuple.__new__z*($cls, typename, fields=None, /, **kwargs)N)rZrVrWr�r˜Ú__text_signature__rRrRrRrSr9sscCsdd„}||_||_|S)NcSs|S)NrR)ÚxrRrRrSÚnew_typeÂszNewType..new_type)rZZ __supertype__)ršrmrOrRrRrSr>¯sc@sšeZdZdZeedœdd„ƒZeedœdd„ƒZeddœdd „ƒZ ee dœd d „ƒZ ee dœd d „ƒZ eddœdd„ƒZee dœdd„ƒZed6e edœdd„ƒZee dœdd„ƒZed7e edœdd„ƒZed8e eedœdd„ƒZed9e e e dœd d!„ƒZee dœd"d#„ƒZee dœd$d%„ƒZed:e e d&œd'd(„ƒZee dœd)d*„ƒZeee d+œd,d-„ƒZeeedd.œd/d0„ƒZed1dœd2d3„ƒZeddœd4d5„ƒZdS);ÚIOrR)r/cCsdS)NrR)rŽrRrRrSÚmodeászIO.modecCsdS)NrR)rŽrRrRrSršåszIO.nameNcCsdS)NrR)rŽrRrRrSÚcloseészIO.closecCsdS)NrR)rŽrRrRrSÚclosedísz IO.closedcCsdS)NrR)rŽrRrRrSÚfilenoñsz IO.filenocCsdS)NrR)rŽrRrRrSÚflushõszIO.flushcCsdS)NrR)rŽrRrRrSÚisattyùsz IO.isattyrÜ)r;r/cCsdS)NrR)rŽr;rRrRrSÚreadýszIO.readcCsdS)NrR)rŽrRrRrSÚreadablesz IO.readable)Úlimitr/cCsdS)NrR)rŽrYrRrRrSÚreadlinesz IO.readline)Úhintr/cCsdS)NrR)rŽr[rRrRrSÚ readlines sz IO.readlinesr)ÚoffsetÚwhencer/cCsdS)NrR)rŽr]r^rRrRrSÚseek szIO.seekcCsdS)NrR)rŽrRrRrSÚseekablesz IO.seekablecCsdS)NrR)rŽrRrRrSÚtellszIO.tell)Úsizer/cCsdS)NrR)rŽrbrRrRrSÚtruncatesz IO.truncatecCsdS)NrR)rŽrRrRrSÚwritablesz IO.writable)Úsr/cCsdS)NrR)rŽrerRrRrSÚwrite!szIO.write)Úlinesr/cCsdS)NrR)rŽrgrRrRrSÚ writelines%sz IO.writelinesz IO[AnyStr]cCsdS)NrR)rŽrRrRrSÚ __enter__)sz IO.__enter__cCsdS)NrR)rŽrGrÚ tracebackrRrRrSÚ__exit__-sz IO.__exit__)rÜ)rÜ)rÜ)r)N)rZrVrWr�rrIrQršrrRr¾rSr1rTrUrVr;rWrXrZr5r\r_r`rarcrdrfrhrirkrRrRrRrSrPÒsR rPc@s>eZdZdZeeeefedœdd„ƒZ eddœdd„ƒZ dS) ÚBinaryIOrR)rer/cCsdS)NrR)rŽrerRrRrSrf7szBinaryIO.write)r/cCsdS)NrR)rŽrRrRrSri;szBinaryIO.__enter__N) rZrVrWr�rrr7Ú bytearrayr1rfrirRrRrRrSrl2s rlc@s€eZdZdZeedœdd„ƒZeedœdd„ƒZee edœdd„ƒZ ee dœd d „ƒZ ee dœd d „ƒZeddœd d„ƒZdS)ÚTextIOrR)r/cCsdS)NrR)rŽrRrRrSÚbufferEsz TextIO.buffercCsdS)NrR)rŽrRrRrSÚencodingIszTextIO.encodingcCsdS)NrR)rŽrRrRrSÚerrorsMsz TextIO.errorscCsdS)NrR)rŽrRrRrSÚline_bufferingQszTextIO.line_bufferingcCsdS)NrR)rŽrRrRrSÚnewlinesUszTextIO.newlinescCsdS)NrR)rŽrRrRrSriYszTextIO.__enter__N)rZrVrWr�rrlrorIrpr rqr¾rrrrsrrirRrRrRrSrn@srnc@s"eZdZdddgZeZeZeZdS)ÚiorPrnrlN)rZrVrWÚ__all__rPrnrlrRrRrRrSrt^s rtz.ioc@seZdZddgZeZeZdS)ÚreÚPatternÚMatchN)rZrVrWrurwrxrRrRrRrSrvmsrvz.re)T)NN)T)‹rôrrróZcollections.abcÚ contextlibrrïrvZ stdlib_rer¿rXrrrrurTr]rgrkrsryr�r„r…r‹r‘rMrrAr rr r rrÖrÐrJrñr rÔrÓr<rrYÚBuiltinFunctionTypeÚ MethodTyperrr=r?r@rrBrGrrFr&r'r(r)r*r+r,r-r7rIr;r.rr"r%r$r#rrr)r rr&rÚ__doc__r7rrrrrrrrfr rhr5rÊr2rurÉr8rrrr!ÚAbstractContextManagerrÚAbstractAsyncContextManagerr(rÈr3rËr4r6r1r0r:r'rr.r-r,r+r*r/r?rHrcrFr9r>rCrDrPrlrnrtrZrrwrxrRrRrRrSÚs� !   E  2a/_   V D                  <`