hh@ ZddlZddlmZmZddlZddlZddlZddlZddlZddl Z ddl mZ ejdddk\rddlZ ddl mZmZmZgdZdZdZGd d eZGd d ed ZGdded ZGdded ZGdded ZdZ dZ!dZ"dZ#dZ$Gdded Z%e%d Z&Gdded Z'e'd Z(Gdd ed Z)e)d!Z*e)d"Z+e)d#Z,e)d$d %Z-e)d&d %Z.e)d'd %Z/e)d(d )Z0e)d*e1eZ2d+Z3dd,Z4d-Z5d.Z6gZ7d/Z8Gd0d1ed Z9e9d Z:Gd2d3ed Z;e;d Zd6Z?Gd7d8eejZAdZBd9ZCGd:d;eA<ZBGd=d>ZDGd?d@ZEGdAdBeAZFGdCdDeGeGeFEZHGdFdGeAZIGdHdIe jeIEZJGdJdKed ZKeKd ZLdLZMdMZNe je je je jeeefZSddNZTdOZUdPZVdQZWdRZXGdSdTeAZYGdUdVeY<ZZe jZ[e\e dWr+GdXdWeBe-e jYZ]ejdWe\e dZr2Gd[dZe]e.eBe-e0e.fe jYZ_ejdZe\e d\rVGd]d\eBe-e jYZ`Gd^d_e`e-e jYZaejd\ejd_Gd`daeBe-e jYZbGdbdcebe-e jYZcGdddeeZZdGdfdgeZZeGdhdieZZfGdjdkeZZgGdldmeZZhGdndoeZe-ZiGdpdqeZe-Zje\e drrGdsdrebe-e jYZknGdtdreZe-Zke jZlGdudveBe-e jYZme\e dwr0Gdxdwelebe-eme-e jYZnejdwe\e dwrGdydzene-e jYZpnGd{dzelebe-eme-e jYZpGd|d}epe*e jYZqe\e dwr!Gd~dene+eBe+e/fe jYZrn%Gddelebe+eme+eBe+e/fe jYZrGddere+e,fe jYZse\e drrHe\e dwrGddeke-ene-e jYZtn?Gddeleke-eme-e jYZtnGddelebe-eme-e jYZtGddete*e jYZuGddeteve jYZwGddexeue*exYZyGddejeue*ejYZ{Gdde|eqe*e|YZoGdde}epe-e}YZ~Gddelebe-e jYZGddee+epe+e jYZGddeeHe+e/fepeHe+e/feBe+e/fe jYZGddee/e jYZe\edrGddeBe-ejYZnGddeBe-Ze\edr-GddeBe-ej YZejdnejdddk\redGddeese+e,feYZGddejese+e,fejYZGddejee*evfejYZe\edr:ejdGddejese+e,fejYZe\e dre jZn e j ZGddece-eBe-e0e.feYZe\e dr2Gddeae-eBe-e0fe j"YZejde)dd eZGddeBeeYZdZejdddk\ZdZdZGddeZGdde<ZdZeZdZGddeBe2ZGddee1ZGddeeZGdÄdīZedze_eejDejB<ede2eejFdǫdȄZede2eejJddǫdʄZGd˄d̫Zedze_eejDejB<y#e $rddlZ Y 6wxYw#e $r?eej(Zeej*Zeej.ZY \wxYw)N)abstractmethodabstractproperty))WrapperDescriptorTypeMethodWrapperTypeMethodDescriptorType)6AnyCallableClassVarGenericOptionalTupleTypeTypeVarUnion AbstractSet GenericMeta ByteString ContainerContextManagerHashable ItemsViewIterableIteratorKeysViewMapping MappingViewMutableMappingMutableSequence MutableSetSequenceSized ValuesView Reversible SupportsAbs SupportsBytesSupportsComplex SupportsFloat SupportsIndex SupportsInt SupportsRoundCounterDequeDict DefaultDictListSet FrozenSet NamedTuple GeneratorAnyStrcastget_type_hintsNewType no_type_checkno_type_check_decoratorNoReturnoverloadText TYPE_CHECKINGc^tjdddk\r |jS|jS)Nr)rr)sys version_info __qualname____name__xs D/var/www/html/dev/engine/venv/lib/python3.12/site-packages/typing.py _qualnamerIis- v%~~zzc>d}|jdr ||vr|dd}|S)N) _TypeAlias _ForwardRef _TypingBase_FinalTypingBase_) startswith)nm whitelists rH _trim_namerUqs*PI }}Sb 1 V IrJcDeZdZdZdZddfd ZdZdZdZdZ xZ S) TypingMetaaMetaclass for most types defined in typing module (not a part of public API). This overrides __new__() to require an extra keyword parameter '_root', which serves as a guard against naive subclassing of the typing classes. Any legitimate class defined using a metaclass derived from TypingMeta must pass _root=True. This also defines a dummy constructor (all the work for most typing constructs is done in __new__) and a nicer repr(). F_rootc |s/tddjtt|xsdzt|||||S)NzCannot subclass %s, ()) TypeErrorjoinmap _type_reprsuper__new__)clsnamebases namespacerY __class__s rHrbzTypingMeta.__new__sK0!YYs:u'=>F$HI IwsD%;;rJcyNselfargskwdss rH__init__zTypingMeta.__init__ rJc|S)a'Override this in subclasses to interpret forward references. For example, List['C'] is internally stored as List[_ForwardRef('C')], which should evaluate to List[C], where C is an object found in globalns or localns (searching localns first, of course). rjrlglobalnslocalnss rH _eval_typezTypingMeta._eval_types  rJcyrirjrltvarss rH_get_type_varszTypingMeta._get_type_varsrprJcLtt|}|jd|SN.)rUrI __module__)rlqnames rH__repr__zTypingMeta.__repr__s9T?+//511rJ) rEr}rD__doc__ _is_protocolrbroruryr __classcell__rgs@rHrWrWxs+ L6;<   2rJrWcDeZdZdZdZdZfdZdZdZdZ dZ xZ S) rNz0Internal indicator of special typing constructs.) __weakref__cyrirjrks rHroz_TypingBase.__init__rprJct|dk(r4t|dtr!t|dtrt d|zt ||S)zConstructor. This only exists to give a better error message in case someone tries to subclass a special typing object (not a good idea). rrrQzCannot subclass %r)len isinstancestrtupler]rarb)rcrmrnrgs rHrbz_TypingBase.__new__sL IN47C(47E*0367 7ws##rJc|Srirjrrs rHruz_TypingBase._eval_types rJcyrirjrws rHryz_TypingBase._get_type_varsrprJcbt|}tt|}|jd|Sr{)typerUrIr})rlrcr~s rHrz_TypingBase.__repr__s(4j9S>*..%00rJc0tdt|z)NCannot instantiate %r)r]rrks rH__call__z_TypingBase.__call__s/$t*<==rJ) rEr}rDr __slots__rorbruryrrrrs@rHrNrNs): I  $ 1 >rJrNT) metaclassrYc2eZdZdZdZddfd ZdZxZS)rOzInternal mix-in class to prevent instantiation. Prevents instantiation unless _root=True is given in class call. It is used to create pseudo-singleton instances Any, Union, Optional, etc. rjFrXcRt||g|i|}|dur|Std|z)NTr)rarbr])rcrYrmrnrlrgs rHrbz_FinalTypingBase.__new__s8ws2T2T2 D=K/#566rJc>tt|jSri)rUrrErls rH __reduce__z_FinalTypingBase.__reduce__s$t*--..rJ)rEr}rDrrrbrrrs@rHrOrOs I"'7 /rJrOrXcJeZdZdZdZfdZdZdZdZdZ dZ d Z xZ S) rMz-Internal wrapper to hold a forward reference.)__forward_arg____forward_code____forward_evaluated____forward_value__ct||t|tst d| t |dd}||_||_d|_ d|_ y#t $rt d|wxYw)Nz*Forward reference must be a string -- got zevalz/Forward reference must be an expression -- got F) rarorrr]compile SyntaxErrorrrrr)rlargcodergs rHroz_ForwardRef.__init__s #s#cST T &3 F3D # $%*"!%  &"%& & &s AA2c|jr||ur?||ix}}n ||}n||}tt|j||d|_d|_|jS)Nz*Forward references must evaluate to types.T)r _type_checkrrrrrs rHruz_ForwardRef._eval_typess))WH-DGO%''7!""%0T**Hg><&>D "*.D &%%%rJct|tstS|jr@|jr4|j|jk(xr|j |j k(S|j|jk(Sri)rrMNotImplementedrrrrlothers rH__eq__z_ForwardRef.__eq__sn%-! !  % %%*E*E((E,A,AAF**e.E.EE G##u'<'<<eZdZdZdZdZdZdZdZdZ dZ d Z y ) rLa:Internal helper class for defining generic variants of concrete types. Note that this is not a type; let's call it a pseudo-type. It cannot be used in instance and subclass checks in parameterized form, i.e. ``isinstance(42, Match[str])`` raises ``TypeError`` instead of returning ``False``. )rdtype_var impl_type type_checkercHt|tsJt|t|tsJt|t|trJt|t|tt fsJt|||_||_||_||_ y)atInitializer. Args: name: The name, e.g. 'Pattern'. type_var: The type parameter, e.g. AnyStr, or the specific type, e.g. str. impl_type: The implementation type. type_checker: Function that takes an impl_type instance. and returns a value that should be a type_var instance. N) rrreprrrWrNrdrrr)rlrdrrrs rHroz_TypeAlias.__init__s$$0d4j0$)T*;DO;*i4Ed9oE4(T;$78H$x.H8   "(rJcL|jdt|jdS)N[])rdr`rrs rHrz_TypeAlias.__repr__0s99j&?@@rJct|jtstd|z|jjrKt|t r;t ||jjst|d|jdt|tr||jurtd|z|j|j||j|jS)Nz#%s cannot be further parameterized.z! is not a valid substitution for r|z%s cannot be re-parameterized.) rrrr]__constraints__r issubclassrgrdrr)rl parameters rH __getitem__z_TypeAlias.__getitem__3s$--1ADHI I == ( (Z 4-Hi)F)FG!*DMM!;<< i )it}}.L||Hg.. HrJc| tdSt|tr t|}t|trt|j dk(s!t|ttfst |st|d|fzzt|j dvr t|ddr(t|tr&|jttfvrtd|z|S)aCheck that the argument is a type, and return it (internal helper). As a special case, accept None and return type(None) instead. Also, _TypeAlias instances (e.g. Match, Pattern) are acceptable. The msg argument is a human-readable error message, e.g. "Union[arg, ...]: arg should be a type." We append the repr() of the actual value (truncated to 100 chars). N _ClassVarz Got %.100r.)_Union _Optional __origin__z&Plain %s is not valid as type argument) rrrrMrNrEcallabler]getattrrW_gorgr _Protocol)rmsgs rHrrfs {Dz#s#3 $c););{)J sT;/ 0#nv5566 S 55 Ct ,3 # gy5I(I@3FGG JrJct|trDt|ts4|jdk(r t |S|jdt |S|duryt|t j r |jSt|S)a;Return the repr() of an object, special-casing types (internal helper). If obj is a type, we return a shorter version than the default type.__repr__, based on the module and qualified name, which is typically enough to uniquely identify a type. For everything else, we fall back on repr(obj). builtinsr|....) rrrWr}rIr FunctionTyperEr)rs rHr`r`sn#tZZ%@ >>Z 'S> !..)C.99 cz#u))*|| 9rJc eZdZdZdZdZdZy)_Anya`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. rjctd)Nz%Any cannot be used with isinstance().rrs rHrz_Any.__instancecheck__?@@rJctd)Nz%Any cannot be used with issubclass().rrs rHrz_Any.__subclasscheck__rrJNrEr}rDrrrrrjrJrHrrs IAArJrc eZdZdZdZdZdZy) _NoReturnaSpecial 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. rjctd)Nz*NoReturn cannot be used with isinstance().rrs rHrz_NoReturn.__instancecheck__DEErJctd)Nz*NoReturn cannot be used with issubclass().rrs rHrz_NoReturn.__subclasscheck__rrJNrrjrJrHrrs IFFrJrcHeZdZdZdZddddfd ZdZdZd Zd Z xZ S) raType variable. Usage:: T = TypeVar('T') # Can be anything A = TypeVar('A', str, bytes) # Must be str or bytes Type variables exist primarily for the benefit of static type checkers. They serve as the parameters for generic types as well as for generic function definitions. See class Generic for more information on generic types. Generic functions work as follows: def repeat(x: T, n: int) -> List[T]: '''Return a list containing n references to x.''' return [x]*n def longest(x: A, y: A) -> A: '''Return the longest of two strings.''' return x if len(x) >= len(y) else y The latter example's signature is essentially the overloading of (str, str) -> str and (bytes, bytes) -> bytes. Also note that if the arguments are instances of some subclass of str, the return type is still plain str. At runtime, isinstance(x, T) and issubclass(C, T) will raise TypeError. Type variables defined with covariant=True or contravariant=True can be used do declare covariant or contravariant generic types. See PEP 484 for more details. By default generic types are invariant in all type variables. Type variables can be introspected. e.g.: T.__name__ == 'T' T.__constraints__ == () T.__covariant__ == False T.__contravariant__ = False A.__constraints__ == (str, bytes) )rE __bound__r __covariant____contravariant__NFbound covariant contravariantc^t||g||||d||_|r |r tdt ||_t ||_|r | td|rt|dk(r tddtfd|D|_ |rt|d|_ yd|_ y) Nrz"Bivariant types are not supported.z-Constraints cannot be combined with bound=...rQz"A single constraint is not allowedz:TypeVar(name, constraint, ...): constraints must be types.c36K|]}t|ywrir).0rrs rH z#TypeVar.__init__..s$NQ[C%8$NzBound must be a type.) rarorE ValueErrorboolrrr]rrrrr)rlrdrrr constraintsrrgs @rHrozTypeVar.__init__s  K  K5#,M K AB B!)_!%m!4 5,KL L 3{+q0@A AJ$$N+$NN (0GHDN!DNrJc0||vr|j|yyri)appendrws rHryzTypeVar._get_type_vars s u  LL  rJc`|jrd}n|jrd}nd}||jzS)N+-~)rrrE)rlprefixs rHrzTypeVar.__repr__s2   F  # #FF %%rJctd)Nz0Type variables cannot be used with isinstance().rrlinstances rHrzTypeVar.__instancecheck__JKKrJctd)Nz0Type variables cannot be used with issubclass().rrs rHrzTypeVar.__subclasscheck__rrJ) rEr}rDrrroryrrrrrs@rHrrs5'R7I26 "(&LLrJrTKTVTT_co)rV_coVT_coT_contra)rr7c|g}t|dr(t|ttfr|j ||St|t rt |D]\}}||k(s ||cS|S)zAn internal helper function: replace arg if it is a type variable found in tvars with corresponding substitution from args or with corresponding substitution sub-tree if arg is a generic type. _subs_tree)hasattrrrrNrr enumerate)rrxrmitvars rH _replace_argr-sp  }sL!j{K6P&Q~~eT**#w ' GAtd{Aw  JrJc |j|S|j}g}|j*|j||j}|j*g}|jD]}|jt||| |D]=}g}|jD](}|jt||j|*|}?|S)aAn internal helper function: calculate substitution tree for generic cls after replacing its type parameters with substitutions in tvars -> args (if any). Repeat the same following __origin__'s. Return a list of arguments with all possible substitutions performed. Arguments that are generic classes themselves are represented as tuples (so that no new classes are created by this function). For example: _subs_tree(List[Tuple[int, T]][str]) == [(Tuple, int, str)] )rr__args__r__parameters__) rcrxrmcurrent orig_chain tree_argsrocls new_tree_argss rHrrHs ~~ nnGJ    ('"$$    (I||9c5$789" == TC  c43F3F !R S T! " rJcg}|D]}t|tr.|jtur|j |j At|t r.t|dkDr |dtur|j |dd|j|t|tt|kr;g}|D])}|vs|j|j|+|}rJt||D]=ttstfdhz Ds-j?t fd|DS)zAn internal helper for Union creation and substitution: flatten Union's among parameters, then remove duplicates and strict subclasses. rrQNc3K|]>}t|tr |j t|txr t |@ywri)rrrrr)rt2t1s rHrz'_remove_dups_flatten..sC3!"k2}}0"d#: 2r(::3sAAc3,K|] }|vs| ywrirj)rr all_paramss rHrz'_remove_dups_flatten..s6qa:o6s ) rrrrextendrrrrsetremoverany) parametersparamsp new_paramsrr$r"s @@rH_remove_dups_flattenr-isF F  a Q\\U%: MM!** % 5 !c!fqjQqTU] MM!AB% MM!  VJ :V$  %AJ!!!$!!!$ %)z)~ VJ""d#  3#rd*3 3   b !" 6F6 66rJc |jstdt|zt|}t|j}||k7r'td||kDrdnddt|d|d|y)Nz%s is not a generic classzToo manyfewz parameters for z ; actual z , expected )rr]rr)rcr)alenelens rH_check_genericr3sr   3d3i?@@ z?D s!! "D t|#'$;E949dDRS SrJctjtjjtj fd}|S)zInternal wrapper caching __getitem__ of generic types with a fallback to original function for non-hashable arguments. cD |i|S#t$rYnwxYw|i|Srir)rmrncachedfuncs rHinnerz_tp_cache..inners: 4(4( (   T"T""s  ) functools lru_cache _cleanupsr cache_clearwraps)r7r8r6s` @rH _tp_cacher>sP #Y "4 (F V''(__T## LrJc~eZdZdZdZdddfd ZdZdZfdZfd Z e d Z dd Z d Z d ZdZdZxZS)raUnion 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] - When two arguments have a subclass relationship, the least derived argument is kept, e.g.:: class Employee: pass class Manager(Employee): pass Union[int, Employee, Manager] == Union[int, Employee] Union[Manager, int, Employee] == Union[int, Employee] Union[Employee, Manager] == Employee - Similar for object:: Union[int, object] == object - You cannot subclass or instantiate a union. - You can use Optional[X] as a shorthand for Union[X, None]. )rrr __tree_hash__FrXct||||g|d|i}|0d|_d|_d|_t t d|_|St|ts td|turt|}t|dk(r|dSt||_||_||_|j}t|trt t ||_|St ||_|S)NrY)rzExpected parameters=rQr)rarbrrrr frozensetr@rrr]rr-rrr)rcr)originrYrmrl subs_treergs rHrbz_Union.__new__swsJKKUK >"&D  DM"DO!%i &;!.sPQ 1h8PTrX)rrrurrg)rlrsrtev_args ev_origins `` rHruz_Union._eval_typesi == KP$--PPt'B dmm # T__(DK~~gy~==rJcd|jr$|jrt|j|yyyrirrryrws rHryz_Union._get_type_vars( ??t22 4.. 6 3?rJc|jt| S|j}t |t s t |S|dj|S)Nr)rrarrrrr _tree_repr)rltreergs rHrz_Union.__repr__ sP ?? "7#% % $&: Aw!!$''rJcg}|ddD]P}t|ts|jt|.|j|dj |Rt |ddj|zzS)NrQr[%s]r[)rrrr`rOrarr^rlrParg_listrrgs rHrOz_Union._tree_reprsu8 8Cc5) 30A 1 1# 67  8 w!FTYYx-@$@@@rJc|dk(r tdt|ts|f}|jdndtfd|D}|tur t |||j ||dS)Nrjz Cannot take a Union of no types.z)Union[arg, ...]: each arg must be a type.*Parameters to generic types must be types.c36K|]}t|ywrirrr+rs rHrz%_Union.__getitem__..$C1;q#.CrT)rCrY)r]rrrrr3rg)rlr)rs @rHrz_Union.__getitem__ss  >? ?*e,$J ?? "=C>CC CC u  4 ,~~jT~BBrJc|turtSt|||}t|}t|dk(r|dStf|zS)NrQr)rrr-rrlrxrmrs rHrz_Union._subs_tree)sI 5=LtUD1 (3 y>Q Q< x)##rJct|tr|j|jk(S|tur|j |k(S||uSri)rrr@rrrs rHrz _Union.__eq__2sG eV $%%)<)<< <  ??$- -5= rJc|jSrir@rs rHrz_Union.__hash__:!!!rJctd)Nz(Unions cannot be used with isinstance().rrs rHrz_Union.__instancecheck__=BCCrJctd)Nz(Unions cannot be used with issubclass().rrs rHrz_Union.__subclasscheck__@rarJNN)rEr}rDrrrbruryrrOr>rrrrrrrrs@rHrrsc)VNI6>7(A C C$!"DDrJrc$eZdZdZdZedZy)rzEOptional type. Optional[X] is equivalent to Union[X, None]. rjcBt|d}t|tdfS)Nz#Optional[t] requires a single type.)rrr)rlrs rHrz_Optional.__getitem__Os"#DES$t*_%%rJN)rEr}rDrrr>rrjrJrHrrGs  I&&rJrct}t|jddD];\}}t|ts|j t us*|j|dz}=|S)zHelper for Generic.__new__. Returns the class after the last occurrence of Generic or Generic[...] in cls.__mro__. NrQ)objectr__mro__rrrr)rc next_in_mrorcs rH _next_in_mrorlXs[ K#++cr*+-1 a %!''W*<++a!e,K- rJchtjtjrfd}|Sfd}|S)zConstruct a __subclasshook__ callable that incorporates the associated __extra__ class in subclass checks performed against cls. cjj|}|tur|Sj|jvryjj D]!}t |t rt||s!ytSNT) __extra____subclasshook__rri__subclasses__rrr)subclassressclsrcs rH __extrahook__z)_make_subclasshook..__extrahook__osw--00:C.( }} 0 00 446 dK0h-  " !rJcVjrt|jrytSro)rprr)rsrcs rHrvz)_make_subclasshook..__extrahook__}s }}Hcmm!D! !rJ)rrpabcABCMeta)rcrvs` rH_make_subclasshookrzfs1 #--- "$   " rJc\t|}d|vr|dD]}|j|d|S)zInternal helper: copy class __dict__ and clean slots class variables. (They will be re-created if necessary by normal class machinery.) rN)dictpop)dct dict_copyslots rH_no_slots_copyrs=S Iik* &D MM$ % & rJceZdZdZ dfd ZedZejdZedZejdZdZ dZ fd Z fd Z dd Z d Zd ZedZfdZdZfdZxZS)racMetaclass for generic types. This is a metaclass for typing.Generic and generic ABCs defined in typing module. User defined subclasses of GenericMeta can override __new__ and invoke super().__new__. Note that GenericMeta.__new__ has strict rules on what is allowed in its bases argument: * plain Generic is disallowed in bases; * Generic[...] should appear in bases at most once; * if Generic[...] is present, then it should list all type variables that appear in other bases. In addition, type of all generic bases is erased, e.g., C[int] is stripped to plain C. c ||Jtd|DsJ||J||J||J|t|}d} |D]R} | tur tdt | t s'| j tus:| td| j} T| |} n]t|} t| | ks@tddjfd|Dddjd | Dd | }|} |%t|tjur ||vr|f|z}td |D}td |Drtd |D}|j|||sdn |j dt"|I||||d} t"t | Od|s| n |j || _|rtd|Dnd| _t+| | _|| | _d|vr|st1| j2dddk(rt5| | _t |tjr#|j6| _|j8| _n$|"|j6| _|j8| _|rt;|dr|j<| _|r t?| jA| _"| St"t | | _"| S)zCreate a new generic class. GenericMeta.__new__ accepts keyword arguments that are used for internal bookkeeping, therefore an override should pass unused keyword arguments to super(). Nc3<K|]}t|tywrirr)rrs rHrz&GenericMeta.__new__..s=!z!W-=z!Cannot inherit from plain Genericz0Cannot inherit from Generic[...] multiple types.zSome type variables (r[c3>K|]}|vst|ywrir)rrgvarsets rHrz&GenericMeta.__new__..s"MaAW.s"9a3q6"9src3XK|]"}t|tr |jn|$ywri)rrrrbs rHrz&GenericMeta.__new__..s"RqA{!;aggBRs(*c3PK|]}t|txr|tu ywri)rrrrs rHrz&GenericMeta.__new__..s$N1z![)>aw.>>Ns$&c32K|]}|tus |ywri)rrs rHrz&GenericMeta.__new__..s?aw.>!?s )rrprTrXrc3HK|]}|turdn |turdn|yw).rjN)_TypingEllipsis _TypingEmpty)ras rHrz&GenericMeta.__new__..s1/$%&'/%9c$%$5b /s "rqrErvrD)#allrrr]rrrrr&r^rrxryrr(updaterrarb __setattr__rrl__next_in_mro____orig_bases__rrqrz _abc_registry _abc_cacherrDrrrr@)rcrdrerfrxrmrCextra orig_basesgvarsbasetvarset initial_basesrlrrgs @rHrbzGenericMeta.__new__s  % %%=u== Du D== '% '=< % %<> )6 )>u%E E 07?#$GHHt[172('NPP //E 0}e*e*')#"M5"MM"95"99;<<   e !;U@RHu$ERERR NN N?U??EU/546<<I JwsD%$G k4,W9?TV\\ S# 37/)-//<@  ,D1  "/D  i /E D)):r :o M$6t$>55 5zz555rJc|j>t|jtjr||j_y||_yyri)rrrprxryrrrlvalues rHrzGenericMeta._abc_negative_caches7 ?? "$..#++65:2380 #rJct|jtjr|jjS|j j Sri)rrprxry_abc_negative_cache_versionr#_abc_generic_negative_cache_versionrs rHrz'GenericMeta._abc_negative_cache_version s4 dnnckk 2>>== =zz===rJc|j>t|jtjr||j_y||_yyri)rrrprxryrrrs rHrz'GenericMeta._abc_negative_cache_versions7 ?? "$..#++6=B:;@8 #rJcd|jr$|jrt|j|yyyrirLrws rHryzGenericMeta._get_type_varsrMrJc |jr|jjnd}|jrtfd|jDnd}||jk(r||jk(r|S|j |j |j t|j|r t|nd|||j|jS)Nc38K|]}t|ywrirG)rrrsrts rHrz)GenericMeta._eval_type.."s*Q 1h8*rHrxrmrCrr) rrurrrgrE __bases__r__dict__rrpr)rlrsrtrJrIs `` rHruzGenericMeta._eval_types__//'B-1 .2]]*==**@D   'Gt}},DK~~dmm"nn,T]];;BJw$7#*%.$(NN)-)<)<> >rJcv|jt| S|j|j SrirrarrOrrlrgs rHrzGenericMeta.__repr__/1 ?? "7#% %t011rJc,g}|ddD]g}|dk(r|jdt|ts|jt|E|j|dj |it |ddj|zzS)NrQrjr\rrRr[)rrrr`rOrarr^rSs rHrOzGenericMeta._tree_repr4s8 8Cby%U+ 30A 1 1# 67  8w!FTYYx-@$@@@rJcj|j|St|||}|jft|zSri)rrrrr[s rHrzGenericMeta._subs_tree?s5 ?? "KtUD1  }uY///rJct|tstS|j |j||uS|j|jk(Sri)rrrrr@rs rHrzGenericMeta.__eq__EsH%-! ! ?? "e&6&6&>5= !!U%8%888rJc|jSrir^rs rHrzGenericMeta.__hash__Lr_rJc t|ts|f}|s)|jturt dt |zdtfd|D}|t urMtd|Ds t dtt|t|k7r t d|}|}nq|ttfvrt|}|}nU|tur|}|}nH|jt tfvrt dt|zt||t|}|}|j|fnd}|j!|j"||j$zt'|j(||||j*|j, S) Nz)Parameter list to %s[...] cannot be emptyrVc36K|]}t|ywrirrXs rHrz*GenericMeta.__getitem__..Ws;q{1c*;rc3<K|]}t|tywrir)rr+s rHrz*GenericMeta.__getitem__..Zs>!z!W->rz5Parameters to Generic[...] must all be type variablesz-Parameters to Generic[...] must all be uniquez'Cannot subscript already-subscripted %srjr)rrrrr]rIrrrr&r rrrrr3rgrErrrrpr)rlr*rxrmprependrs @rHrzGenericMeta.__getitem__Os&%(YF$**E1;ioMO O:;F;; 7?>v>>KMM3v;3v;.CEEED eX& &v&ED Y ED __) 4 4E J'( ( 4 (v&ED!__44'"~~dmm%6,T]];$)#'%)$(NN)-)<)<> >rJc|j0tjdjddvr t dy|t urt d|zt ||S)NrQrE)rxr9zCParameterized generics cannot be used with class or instance checksFz5Class %r cannot be used with class or instance checks)rrB _getframe f_globalsr]rrar)rlrcrgs rHrzGenericMeta.__subclasscheck__}sp ?? &}}Q))*5=QQ!566 7?13789 9w(--rJc.t|j|Sri)rrgrs rHrzGenericMeta.__instancecheck__s (,,d33rJc|jdr|jds|jds |jtt|||ytt|j||y)N___abc_)rRendswithrrarr)rlattrrrgs rHrzGenericMeta.__setattr__sX OOD !dmmD&9 OOG $ JJ  +t 0u = +tzz 6tU CrJ)NNNNNrc)rEr}rDrrbpropertyrsetterrryrurrOrrrr>rrrrrrs@rHrrs LP[B66 9 9>> !''A(A7> 2 A0 9"+>+>Z .4 D DrJrc|j_|jtjur-|jtjur|j|S|j|g|i|S|j}|jtjur.|jtjur|j|}n|j|g|i|} ||_|j|i||S#t $rYwxYwri)rrbrhror__orig_class__AttributeError)base_clsrcrmrnrCrs rH _generic_newrs ~~    . FOO3##C( (#8##C7$7$7 7    . FOO3""6*C"(""69D9D9C !$C   d#d#    sC44 D?DceZdZdZdZdZy)raCAbstract base class for generic types. A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:: class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc. This class can then be used as follows:: def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default rjcp|jtur tdt|j|g|i|S)NzHType Generic cannot be instantiated; it can be used only as a base class)rrr]rrrcrmrns rHrbzGeneric.__new__s@ 99 BC CC//DtDtDDrJNrEr}rDrrrbrjrJrHrrs(IErJr)rceZdZdZy)rzInternal placeholder for () or []. Used by TupleMeta and CallableMeta to allow empty list/tuple in specific places, without allowing them to sneak in where prohibited. NrEr}rDrrjrJrHrrsrJrceZdZdZy)rz(Internal placeholder for ... (ellipsis).NrrjrJrHrrs2rJrc8eZdZdZefdZdZdZxZS) TupleMetazMetaclass for Tuple (internal).cx|j|jturt||S|dk(rt|t fSt |ts|f}t|dk(r-|ddur&dt|d}t||tfSdtfd|D}t||S) NrjrrQ.z Tuple[t, ...]: t must be a type.rz*Tuple[t0, t1, ...]: each t must be a type.c36K|]}t|ywrirrXs rHrz(TupleMeta.__getitem__..rYr) rrrrarrrrrrr)rlr)r+rrgs @rHrzTupleMeta.__getitem__s ?? &$**E*A7&z2 2  7& 7 7*e,$J z?a JqMS$84CJqM3/A7&?';< <:C CC w":..rJcP|jt|tStd)Nz5Parameterized Tuple cannot be used with isinstance().)rrrr]rs rHrzTupleMeta.__instancecheck__+ == c5) )-. .rJcP|jt|tStd)Nz5Parameterized Tuple cannot be used with issubclass().)rrrr]rs rHrzTupleMeta.__subclasscheck__rrJ) rEr}rDrr>rrrrrs@rHrrs")//". .rJrceZdZdZdZdZy)ra@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, ...]. rjcd|jtur tdtt|g|i|S)Nz6Type Tuple cannot be instantiated; use tuple() instead)rrr]rrrs rHrbz Tuple.__new__s7 99 23 3E36666rJNrrjrJrHrrsI7rJr)rrcJeZdZdZfdZfdZfdZefdZxZ S) CallableMetaz"Metaclass for Callable (internal).cv|jt| S|j|j Srirrs rHrzCallableMeta.__repr__rrJc|jturt| |Sg}|ddD]P}t |t s|j t|.|j |dj|R|ddk(rt|dd|dzzSt|dddj|ddd|dd zS) NrQrrz [..., %s]z[[r[rgz], r) rr rarOrrrr`rr^rSs rHrOzCallableMeta._tree_reprs ::X %7%d+ +8 8Cc5) 30A 1 1# 67  8 A;% Q=;!#<< <T!W $ (3B- 8(2,GH IrJcV|j|jturt||St |t rt|dk7r td|\}}|tur t|f}n,t |tstd|fzt ||f}|j|S)zxA thin wrapper around __getitem_inner__ to provide the latter with hashable arguments to improve speed. rz6Callable must be used as Callable[[arg, ...], result].z8Callable[args, result]: args must be a list. Got %.100r.) rrr rarrrrr]Ellipsislist__getitem_inner__)rlr)rmresultrgs rHrzCallableMeta.__getitem__.s ?? &$**H*D7&z2 2*e,J10D<= =! f 8 "F+JdD)!/26!9::+v.J%%j11rJc|\}}dt|}|turt| t|fSdt fd|D}||fz}t| |S)Nz.Callable[args, result]: result must be a type.z6Callable[[arg, ...], result]: each arg must be a type.c36K|]}t|ywrir)rrrs rHrz1CallableMeta.__getitem_inner__..Js;s[c*;r)rrrarrr)rlr)rmrrrgs @rHrzCallableMeta.__getitem_inner__Bsk! f>VS) 8 7&'@A AF;d;;VI% w":..rJ) rEr}rDrrrOrr>rrrs@rHrrs*,2 I 2( / /rJrceZdZdZdZdZy)r aCallable 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. rjcp|jtur tdt|j|g|i|S)NzIType Callable cannot be instantiated; use a non-abstract subclass instead)rr r]rrrs rHrbzCallable.__new__\s@ 99 BC CC//DtDtDDrJNrrjrJrHr r OsIErJr cFeZdZdZdZd dZdZdZfdZdZ dZ xZ S) ra3Special 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(). __type__c ||_yrir)rltprns rHroz_ClassVar.__init__vs  rJc t|}|j0|t|dj|jdddSt dj|jdd)Nz{} accepts only single type.rQTrXz {} cannot be further subscripted)rrrformatrEr])rlitemrcs rHrz_ClassVar.__getitem__yso4j == {45<s'. #tS[[) $D"{{4??;DD ' --##$5r:C"yy{ $ e= JEeS)'.E"5,@#d  $ $  c5++ ,||HsM26H ?G  C*D 1E } c> *I++16#;8 8S!H KE{{} e =JE eS !&E5(G4 8  6UOEd  LrJct|tr|jj}|jj D])\}}||j |fzvs|j |+|jD]?}t|tjrd|_ t|ts5t|A d|_ |S#t$rY|SwxYw)aIDecorator to indicate that annotations are not type hints. The argument must be a class or function; if it is a class, it applies recursively to all methods and classes defined in that class (but not to methods defined in its superclasses or subclasses). This mutates the function(s) or class(es) in place. T) rrrcopyrrr}valuesrrr r;r])r arg_attrsrrrs rHr;r;s#tLL%%' ++- $ID#cmmsf,, d# $##% #C#u112(,%#t$c"  #  $ J   J sC CCcBtjfd}|S)zDecorator to give another decorator the @no_type_check effect. This wraps the decorator with something that wraps the decorated function in @no_type_check. c.|i|}t|}|Sri)r;)rmrnr7 decorators rHwrapped_decoratorz2no_type_check_decorator..wrapped_decorator3s!$'$'T" rJ)r9r=)rrs` rHr<r<,s(__Y  rJctd)z*Helper for @overload to raise when called.zYou 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)rmrns rH_overload_dummyr!<s  9 ::rJctS)a Decorator for overloaded functions/methods. In a stub file, place two or more stub definitions for the same function in a row, each decorated with @overload. For example: @overload def utf8(value: None) -> None: ... @overload def utf8(value: bytes) -> bytes: ... @overload def utf8(value: str) -> bytes: ... In a non-stub file (i.e. a regular .py file), do the same but follow it with an implementation. The implementation should *not* be decorated with @overload. For example: @overload def utf8(value: None) -> None: ... @overload def utf8(value: bytes) -> bytes: ... @overload def utf8(value: str) -> bytes: ... def utf8(value): # implementation goes here )r!)r7s rHr>r>Es 4 rJc.eZdZdZfdZdZdZxZS) _ProtocolMetaz~Internal metaclass for _Protocol. This exists so _Protocol classes can be generic without deriving from Generic. c\t|jvrt| |St d)Nz+Protocols cannot be used with isinstance().)rrrarr])rlrrgs rHrz_ProtocolMeta.__instancecheck__is+ DNN *7,S1 1EFFrJc|jstS|tury|j}|D]"t fd|j Dr"yy)NTc3:K|]}|jvywrir)rdrs rHrz2_ProtocolMeta.__subclasscheck__..{s?atqzz)?sF)rrr_get_protocol_attrsr(ri)rlrcattrsrs @rHrz_ProtocolMeta.__subclasscheck__nsV  ! ! 9 ((* D?3;;?? rJcXg}|jD]1}t|dds|jdk7s!|j|3t }|D]}|j j D]}|jD]%}||us||j vst|ddr%6|jdrI|dk7sO|dk7sU|dk7s[|dk7sa|dk7sg|d k7sm|d k7ss|d k7sy|d k7s|d k7s|dk7s|dk7s|dk7s|dk7s|dk7s|dk7s|j||S)NrFrr__abstractmethods__r rrrrrr*rrrrrpr@r}) rirrErr&rkeysrRadd)rlprotocol_basesrkr+rrs rHr*z!_ProtocolMeta._get_protocol_attrssL )Aq.%0QZZ;5N%%a( ) " (D **, ((A $!***< '>5 A( !OOG4 $99 $55 M1 N2 GO J. J. K/ $99 $55 $44 L0 $44 K/ O3 L0 $1 ( (6 rJ)rEr}rDrrrr*rrs@rHr$r$bs G "$rJr$ceZdZdZdZdZy)rzInternal base class for protocol classes. This implements a simple-minded structural issubclass check (similar but more general than the one-offs in collections.abc such as Hashable). rjTN)rEr}rDrrrrjrJrHrrsILrJr AwaitableceZdZdZy)r2rjNrEr}rDrrjrJrHr2r2 rJ)r CoroutineceZdZdZy)r6rjNr4rjrJrHr6r6 rJ AsyncIterableceZdZdZy)r9rjNr4rjrJrHr9r9r5rJceZdZdZy) AsyncIteratorrjNr4rjrJrHr<r<r8rJr<ceZdZdZy)rrjNr4rjrJrHrrIrJrceZdZdZy)rrjNr4rjrJrHrrr>rJrc&eZdZdZedefdZy)r,rjreturncyrirjrs rH__int__zSupportsInt.__int__ rJN)rEr}rDrrintrCrjrJrHr,r,s I   rJr,c&eZdZdZedefdZy)r*rjrAcyrirjrs rH __float__zSupportsFloat.__float__rDrJN)rEr}rDrrfloatrHrjrJrHr*r* I 5  rJr*c&eZdZdZedefdZy)r)rjrAcyrirjrs rH __complex__zSupportsComplex.__complex__rDrJN)rEr}rDrrcomplexrMrjrJrHr)r)s I W  rJr)c&eZdZdZedefdZy)r(rjrAcyrirjrs rH __bytes__zSupportsBytes.__bytes__rDrJN)rEr}rDrrbytesrQrjrJrHr(r(rJrJr(c&eZdZdZedefdZy)r+rjrAcyrirjrs rH __index__zSupportsIndex.__index__rDrJN)rEr}rDrrrErUrjrJrHr+r+s I 3  rJr+c&eZdZdZedefdZy)r'rjrAcyrirjrs rH__abs__zSupportsAbs.__abs__rDrJN)rEr}rDrrr rXrjrJrHr'r's I   rJr'c,eZdZdZeddedefdZy)r-rjndigitsrAcyrirj)rlrZs rH __round__zSupportsRound.__round__rDrJNr)rEr}rDrrrEr r\rjrJrHr-r- s'I  T  rJr-r&ceZdZdZy)r&rjNr4rjrJrHr&r&r5rJc"eZdZdZeddZy)r&rjcyrirjrs rH __reversed__zReversible.__reversed__s rJN)rAzIterator[T_co])rEr}rDrrrarjrJrHr&r&s    rJceZdZdZy)rrjNr4rjrJrHrr$r>rJr CollectionceZdZdZy)rcrjNr4rjrJrHrcrc)r8rJceZdZdZyrrjNr4rjrJrHrr3r8rJrceZdZdZyrfr4rjrJrHrr7r8rJceZdZdZy)r"rjNr4rjrJrHr"r"<r>rJr"ceZdZdZyrrjNr4rjrJrHrrBr8rJrceZdZdZyrjr4rjrJrHrrFr8rJceZdZdZy)r rjNr4rjrJrHr r Kr>rJr ceZdZdZyr#rjNr4rjrJrHr#r#QIrJr#ceZdZdZyrnr4rjrJrHr#r#UrorJceZdZdZyrnr4rjrJrHr#r#Yr8rJceZdZdZy)r!rjNr4rjrJrHr!r!^r>rJr!ceZdZdZy)rrjNr4rjrJrHrrbr>rJrceZdZdZdZy)r2rjcd|jtur tdtt|g|i|S)Nz4Type List cannot be instantiated; use list() instead)rr2r]rrrs rHrbz List.__new__j7 99 12 2D#5555rJNrEr}rDrrbrjrJrHr2r2f I6rJr2ceZdZdZdZy)r/rjc|jturtj|i|St tj|g|i|Sri)rr/ collectionsdequerrs rHrbz Deque.__new__usA 99 $$d3d3 3K--sBTBTBBrJNrwrjrJrHr/r/qs ICrJr/ceZdZdZdZy)r3rjcd|jtur tdtt|g|i|S)Nz2Type Set cannot be instantiated; use set() instead)rr3r]rr&rs rHrbz Set.__new__s7 99 01 1C4t4t44rJNrwrjrJrHr3r3{s I5rJr3ceZdZdZdZy)r4rjcd|jtur tdtt|g|i|S)Nz>Type FrozenSet cannot be instantiated; use frozenset() instead)rr4r]rrBrs rHrbzFrozenSet.__new__s7 99 !67 7Is:T:T::rJNrwrjrJrHr4r4s I;rJr4ceZdZdZy)rrjNr4rjrJrHrrr>rJrceZdZdZy)rrjNr4rjrJrHrrsIrJrceZdZdZy)rrjNr4rjrJrHrrs IrJrceZdZdZy)r%rjNr4rjrJrHr%r%r>rJr%AbstractContextManagerceZdZdZy)rrjNr4rjrJrHrrr5rJrcJeZdZdZdZej dZedZ y)rrjc|Srirjrs rH __enter__zContextManager.__enter__sKrJcyrirj)rlexc_type exc_value tracebacks rH__exit__zContextManager.__exit__srJc|tur9td|jDrtd|jDrytS)Nc38K|]}d|jvyw)rNr(rBs rHrz2ContextManager.__subclasshook__..sEa qzz1Ec38K|]}d|jvyw)rNr(rs rHrz2ContextManager.__subclasshook__..sDQ ajj0DrT)rr(rir)rcCs rHrqzContextManager.__subclasshook__s9n$ E199EED!))DD! !rJN) rEr}rDrrrxrr classmethodrqrjrJrHrrs:         "  "rJAbstractAsyncContextManagerceZdZdZy)AsyncContextManagerrjNr4rjrJrHrrr8rJr)ra class AsyncContextManager(Generic[T_co]): __slots__ = () async def __aenter__(self): return self @abc.abstractmethod async def __aexit__(self, exc_type, exc_value, traceback): return None @classmethod def __subclasshook__(cls, C): if cls is AsyncContextManager: if sys.version_info[:2] >= (3, 6): return _collections_abc._check_methods(C, "__aenter__", "__aexit__") if (any("__aenter__" in B.__dict__ for B in C.__mro__) and any("__aexit__" in B.__dict__ for B in C.__mro__)): return True return NotImplemented __all__.append('AsyncContextManager') ceZdZdZdZy)r0rjcd|jtur tdtt|g|i|S)Nz4Type Dict cannot be instantiated; use dict() instead)rr0r]rr|rs rHrbz Dict.__new__rvrJNrwrjrJrHr0r0rxrJr0ceZdZdZdZy)r1rjc|jturtj|i|St tj|g|i|Sri)rr1r{ defaultdictrrs rHrbzDefaultDict.__new__sA 99 #**D9D9 9K33SH4H4HHrJNrwrjrJrHr1r1sIIrJr1ceZdZdZdZy)r.rjc|jturtj|i|Sttj|g|i|Sri)rr.r{rrs rHrbzCounter.__new__sA 99 &&55 5K//DtDtDDrJNrwrjrJrHr.r.s IErJr.ChainMapceZdZdZdZy)rrjc|jturtj|i|Sttj|g|i|Sri)rrr{rrs rHrbzChainMap.__new__ sAyyH$"++T:T:: 4 4cIDIDI IrJNrwrjrJrHrrs  JrJr6ceZdZdZdZy)r6rjcd|jtur tdtt|g|i|S)Nz@Type Generator cannot be instantiated; create a subclass instead)rr6r]r_G_basers rHrbzGenerator.__new__s7 99 !89 9GS848488rJNrwrjrJrHr6r6s I9rJAsyncGeneratorceZdZdZy)rrjNr4rjrJrHrr$r8rJCT_co)rrceZdZdZdZy)raA 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. rjN)rEr}rDrrrjrJrHrr0s.IrJrc d}|Dcgc]\}}|t||f}}}tj||Dcgc]\}}| c}}}tj|x|_|_ t jdjjdd|_ |Scc}}wcc}}w#ttf$rY|SwxYw)NzDNamedTuple('Name', [(f0, t0), (f1, t1), ...]); each t must be a typerrE__main__) rr{ namedtuple OrderedDictr  _field_typesrBrrrr}rr)rdrrnrnm_tpls rH _make_nmtuplerKs PC27 8$!QaQ$ % 8E 8  # #D*?A1*? @F4?3J3J53QQFV0 MM!,66:::zR M 9*? J '  M sB$ B* .4B00CC) rbror__getnewargs___fields_field_defaultsr_make_replace_asdict_source)r}rErDr ceZdZfdZxZS)NamedTupleMetac |jddrt | ||||Sts t d|jdi}t ||j }g}i}|D]]}||vr||} |j| | ||<#|s&t dj|dj|jtj||j_ t||j_||_|D]@} | t"vrt%d| z| t&vs"| |j(vs1t+|| || B|S) NrYFz= 3.6:: class Employee(NamedTuple): name: str id: int This is equivalent to:: Employee = collections.namedtuple('Employee', ['name', 'id']) The resulting class has extra __annotations__ and _field_types attributes, giving an ordered dict mapping field names to types. __annotations__ should be preferred, while _field_types is kept to maintain pre PEP 526 compatibility. (The field names are in the _fields attribute, which is part of the namedtuple API.) Alternative equivalent keyword syntax is also accepted:: Employee = NamedTuple('Employee', name=str, id=int) In Python versions <= 3.5 use:: Employee = NamedTuple('Employee', [('name', str), ('id', int)]) Tc<|rts td|s td|d|dd}}|r |d|dd}}n=d|vr.|jd}ddl}|j dt dn td |r |\}nBd |vrKeyword syntax for NamedTuple is only supported in Python 3.6+z*NamedTuple.__new__(): not enough argumentsrrQrz4Passing 'typename' as keyword argument is deprecatedr) stacklevelzGNamedTuple.__new__() missing 1 required positional argument: 'typename'zMNamedTuple.__new__() takes from 2 to 3 positional arguments but {} were givenfieldsz2Passing 'fields' as keyword argument is deprecatedzIEither list of fields or keywords can be provided to NamedTuple, not both) rr]r}warningswarnDeprecationWarningrrrrr)rmkwargsrPrrrs rHrbzNamedTuple.__new__s[ %./ /HI Iq'484 !!Wd12hdH 6 !zz*-H  MMP,  <34 4  D  CK1$4ZZ)F  MMN,  <F >\\^F GH HXv..# D!--3VCIM-BDD Ds 8C++0Dz*($cls, typename, fields=None, /, **kwargs)N)rEr}rDrrYrb__text_signature__rjrJrHr5r5s2 E%/N"NGrJr5c(d}||_||_|S)a%NewType creates simple unique types with almost zero runtime overhead. NewType(name, tp) is considered a subtype of tp by static type checkers. At runtime, NewType(name, tp) returns a dummy function that simply returns its argument. Usage:: UserId = NewType('UserId', int) def name_by_id(user_id: UserId) -> str: ... UserId('user') # Fails type check name_by_id(42) # Fails type check name_by_id(UserId(42)) # OK num = UserId(5) + 1 # type: int c|SrirjrFs rHnew_typezNewType..new_typesrJ)rE __supertype__)rdrrs rHr:r:s&HH OrJFceZdZdZdZedefdZedefdZe d!dZ ede fdZ e de fd Ze d!d Ze de fd Ze d"d e defd Ze de fdZe d"de defdZe d"de deefdZe d#de de de fdZe de fdZe de fdZe d$de de fdZe de fdZe dede fdZe deeddfdZe d%dZe d!d Zy)&IOaGeneric base class for TextIO and BinaryIO. This is an abstract, generic version of the return of open(). NOTE: This does not distinguish between the different possible classes (text vs. binary, read vs. write vs. read/write, append-only, unbuffered). The TextIO and BinaryIO subclasses below capture the distinctions between text vs. binary, which is pervasive in the interface; however we currently do not offer a way to track the other distinctions in the type system. rjrAcyrirjrs rHmodezIO.moderDrJcyrirjrs rHrdzIO.name rDrJNcyrirjrs rHclosezIO.close rDrJcyrirjrs rHclosedz IO.closed rDrJcyrirjrs rHfilenoz IO.fileno rDrJcyrirjrs rHflushzIO.flush rDrJcyrirjrs rHisattyz IO.isatty rDrJrcyrirj)rlrs rHreadzIO.read rDrJcyrirjrs rHreadablez IO.readable rDrJlimitcyrirj)rlrs rHreadlinez IO.readline! rDrJhintcyrirj)rlrs rH readlinesz IO.readlines% rDrJoffsetwhencecyrirj)rlrrs rHseekzIO.seek) rDrJcyrirjrs rHseekablez IO.seekable- rDrJcyrirjrs rHtellzIO.tell1 rDrJsizecyrirj)rlrs rHtruncatez IO.truncate5 rDrJcyrirjrs rHwritablez IO.writable9 rDrJscyrirjrlrs rHwritezIO.write= rDrJlinescyrirj)rlrs rH writelinesz IO.writelinesA rDrJcyrirjrs rHrz IO.__enter__E rDrJcyrirj)rlrrrs rHrz IO.__exit__I rDrJ)rAN)rgr]ri)rAz IO[AnyStr]) rEr}rDrrrrrrdrrrrrErrrr7rrrr2rrrrrrrrrrrjrJrHrrsL I c   c                c 6   $   c 6   c 4<   3  C   $   c   S C   $   v #   V        rJrcJeZdZdZdZedeeefde fdZ eddZ y) BinaryIOz5Typed version of the return of open() in binary mode.rjrrAcyrirjrs rHrzBinaryIO.writeS rDrJcyrirjrs rHrzBinaryIO.__enter__W rDrJN)rAr) rEr}rDrrrrrR bytearrayrErrrjrJrHrrN sH?I uUI-. 3    rJrceZdZdZdZedefdZedefdZ ede efdZ ede fdZ edefdZed d Zy ) TextIOz3Typed version of the return of open() in text mode.rjrAcyrirjrs rHbufferz TextIO.buffera rDrJcyrirjrs rHencodingzTextIO.encodinge rDrJcyrirjrs rHerrorsz TextIO.errorsi rDrJcyrirjrs rHline_bufferingzTextIO.line_bufferingm rDrJcyrirjrs rHnewlineszTextIO.newlinesq rDrJcyrirjrs rHrzTextIO.__enter__u rDrJN)rAr )rEr}rDrrrrr rrrrrrr rrrrjrJrHr r \ s=I    #          #    rJr c$eZdZdZgdZeZeZeZy)ioz)Wrapper namespace for IO generic classes.)rr rN)rEr}rDr__all__rr rrjrJrHrrz s3*G B FHrJrz.ioPatternrc|jSri)pattern)r+s rHr s qyyrJMatchc.|jjSri)rer)ms rHrr sQTT\\rJc eZdZdZddgZeZeZy)r z&Wrapper namespace for re type aliases.rrN)rEr}rDrrrrrjrJrHr r  s0'"GG ErJr z.rerc)rxrrr{ contextlibr9r  stdlib_rerBrcollections.abccollections_abc ImportErrorrC_collections_abcrr r rrhro__str__rr^rrIrUrWrNrOrMrLryrrurr`rr rr=rr r r r r rrrRr7rrr-r3r;r>rrrrrlrzrryrrrrrrrrrr rr r8r rBuiltinFunctionType MethodTyperrr9r;r<r!r>r$rrrr2rr6r9r<rrr,r*r)r(r+r'r-r&r$rrcr3rr"rr r#r!rErrr2r|r/r&rBr4rrrr%rrrrexecr|r0rr1r.rr6r GeneratorTyperrrrrrrrr5r:r?r@rrr rrErrrmatchrrjrJrHr/s  0 *-BQ6!*TTJ b'2'2T">Jd">J/{$/&4;+T4;n@/D@/F$   >&A 4A* F F, 4 RLkRLn CL T] T]v&v&4( :T 2 5# &6B&7RS  $OD TODd T &  & 4  <JD*ckkJD\ 0E E<33. .D7E)7&6/;6/rE_--E(3 3l 4 ($$e&?&?""E$4$4'):%> ?L)UHTNIdO*55 NN<  ?L)j&+//eXd^Yt_+// Q'A'A  ?L)*R.'"e)"4'//%"y}gb%i6H'// WRV_O,J,J ?L) - z$'D)9,55  uj. $,55 5(4.)D/(11 hqk)H)H#o&@&@64#46CK  q19J9JC5#z!}C5; ;t,I;%$/J/J{2 B$--  E"e),-E"e),-E "%//U#?+E+E :/0j.O.O""0 :45gdm$.$J$J NN()bqV# 264B't6I+))>"b&+A#//IEk!!43<{7J7JE ; # NN:J;''B)?$--J ?K(''G!!G9h(< =9 ?,-t,gdHn.E.== NN#$ 4t475>6  !&:  ITDCN>CNL8  ] ] @  r%y   RW <  BKK Y->Y->->r-B(C( *7FDR)@$A) +  BKKWL*)* * 1VX--.>*s$e e& e#"e#&Af*)f*