+c`7@st ddlZddlmZmZddlZddlZddlZddlZddlZddl Z yddl jZ Wne k rddlZ YnXddddddd d d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1g/Z d2d3ZGd4d5d5eZGd6d7d7ZGd8d9d9eZGd:d;d;Zd<d=Zd>d?Zd@dAZdBdCZdDdEZGdFdGdGeZGdHddedIedJdKZGdLd d edIedJdKZedMZedNZedOZedPdQdKZedRdQdKZ edSdQdKZ!edTdUdKZ"ed)e#e$Z%GdVdWdWeZ&GdXd d edIe&dJdKZ'GdYdZdZeZ(Gd[ddedIe(dJdKZ)Gd\d]d]eZ*Gd^ddedIe*dJdKZ+Gd_d`d`eZ,GdaddedIe,dJdKZ-dbdcZ.dddeZ/dfdgZ0Gdhdidieej1Z2dZ3GdjdddIe2Z3dkd*Z4dldmZ5dddnd+Z6dod-Z7dpd.Z8dqdrZ9dsd/Z:Gdtdudue2Z;GdvdwdwdIe;Z<e j=Z=e>e d rGdxd d e3edye j?Z?ndZ?e>e drGdzdde3edye j@Z@Gd{d d e@edye jAZAn dZ@dZAGd|dde3edye jBZBGd}ddeBedye jCZCGd~d!d!e<ZDGdd d e<ZEGddde<ZFGddde<ZGGddde<eZHGdd"d"e<eZIe>e drGdddeBedye jJZJnGddde<eZJe jKZKGddde3edye jLZLGdd d eKeBeeLedye jMZNGdddeNedye jOZOGdddeKeBeeLee3ee!fdye jPZPGdddePeefdye jQZQe>e drRGdddeKeJeeLedye jRZRn-GdddeKeBeeLedye jRZRGdddeRedye jSZSGdddeReTdye jUZUeUjVeeWdGdd%d%eXeSedyeXZYGdd&d&eZeOedyeZZMGddde2Z[Gddde\eNedIe[dye\Z]GdddeKeBedye j^Z^Gddde^eeNedye j_Z_Gddde^e+ee!feNe+ee!fe3ee!fdye j`Z`Gddde^e!dye jaZae>edr` Gddde3edyejbZce jddGdd#d#eeeQeefdyeeZfGdd$d$ejgeQeefdyejgZhe>e d(r e jiZjn e jkZjGdd(d(eCee3ee"e fdyejZieddQdKdeZlGdddee3eldyeZmdd'Zndd,Zoe$ZpdZqGddde3e%ZrGdddere#ZsGdddere$ZtGdddZuevdeu_veuejweujv) __class__r:r;rDgs"zTypingMeta.__new__cOsdS)Nr:)selfargskwdsr:r:r;__init__mszTypingMeta.__init__cCs|S)a+Override this in subclasses to interpret forward references. For example, Union['C'] is internally stored as Union[_ForwardRef('C')], which should evaluate to _Union[C], where C is an object found in globalns or localns (searching localns first, of course). r:)rJglobalnslocalnsr:r:r; _eval_typepszTypingMeta._eval_typecCsdS)Nr:)rJtvarsr:r:r;_get_type_varszszTypingMeta._get_type_varscCsd|jt|fS)Nz%s.%s) __module__r<)rJr:r:r;__repr__}szTypingMeta.__repr__) r8rSr7__doc__ _is_protocolrDrMrPrRrTr:r:)rIr;r=Xs   r=c@s(eZdZdZfZddZdS)Finalz&Mix-in class to prevent instantiation.cOstd|jdS)NzCannot instantiate %r)r?rI)rJrKrLr:r:r;rDsz Final.__new__N)r8rSr7rU __slots__rDr:r:r:r;rWs rWcsXeZdZdZfddZddZddZdd Zd d ZS) _ForwardRefz$Wrapper to hold a forward reference.cst|ts"td|fyt|dd}Wn%tk r_td|fYnXtj||fidd}||_||_d|_ d|_ t }t j d}x(|dk r|j|kr|j}qW|dk st||_|S) Nz%ForwardRef must be a string -- got %rzevalz*ForwardRef must be an expression -- got %rr>TF) isinstancestrr?compile SyntaxErrorrCrD__forward_arg____forward_code____forward_evaluated____forward_value__globalsr5 _getframe f_globalsf_backAssertionError__forward_frame__)rEargcoderJZtyping_globalsframe)rIr:r;rDs& !       z_ForwardRef.__new__cCst|ts"td|ft|tsDtd|f|js|dkrr|dkrri}}n'|dkr|}n|dkr|}tt|j||d|_d|_|jS)Nz+ForwardRef localns must be a dict -- got %rz,ForwardRef globalns must be a dict -- got %rz*Forward references must evaluate to types.T)r\dictr?rb _type_checkrZrarc)rJrNrOr:r:r;rPs$         z_ForwardRef._eval_typecCstddS)Nz4Forward references cannot be used with isinstance().)r?)rJobjr:r:r;__instancecheck__sz_ForwardRef.__instancecheck__c Cs^|jsN|jj}|jj}y|j||Wntk rMdSYnXt||jS)NF)rbrirff_localsrP NameError issubclassrc)rJrErNrOr:r:r;__subclasscheck__s     z_ForwardRef.__subclasscheck__cCsd|jfS)Nz_ForwardRef(%r))r`)rJr:r:r;rTsz_ForwardRef.__repr__) r8rSr7rUrDrPrprtrTr:r:)rIr;rYs    rYc@sdeZdZdZdZddZdd Zd d Zd d ZddZ ddZ dS) _TypeAliasaInternal helper class for defining generic variants of concrete types. Note that this is not a type; let's call it a pseudo-type. It can be used in instance and subclass checks, e.g. isinstance(m, Match) or issubclass(type(m), Match). However, it cannot be itself the target of an issubclass() call; e.g. issubclass(Match, C) (for some arbitrary class C) raises TypeError rather than returning False. rFtype_var impl_type type_checkercOsQt|dkrDt|dtrDt|dtrDtdtj|S)zConstructor. This only exists to give a better error message in case someone tries to subclass a type alias (not a good idea). r4rr[z!A type alias cannot be subclassed)lenr\r]tupler?objectrD)rErKrLr:r:r;rDs  z_TypeAlias.__new__cCst|ts!tt|t|tsBtt|t|tsctt|t|t stt|||_||_||_||_ dS)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) r\r]rhreprtyper=rFrvrwrx)rJrFrvrwrxr:r:r;rMs !!!"   z_TypeAlias.__init__cCsd|jt|jfS)Nz%s[%s])rFrBrv)rJr:r:r;rTsz_TypeAlias.__repr__cCst|ts!tt|t|jtsCtd||jjrt|t |jjstd||jf|j |j ||j |j S)Nz#%s cannot be further parameterized.z&%s is not a valid substitution for %s.)r\r}rhr|rvr r?__constraints__rsr rIrFrwrx)rJZ parameterr:r:r; __getitem__s! z_TypeAlias.__getitem__cCstddS)Nz.Type aliases cannot be used with isinstance().)r?)rJror:r:r;rpsz_TypeAlias.__instancecheck__cCsX|tkrdSt|trD|j|jkoCt|j|jSt||jSdS)NT)rr\rurFrsrvrw)rJrEr:r:r;rts  z_TypeAlias.__subclasscheck__N)znameztype_varz impl_typez type_checker) r8rSr7rUrXrDrMrTrrprtr:r:r:r;rus    rucCs1x*|D]"}t|tr|j|qWdS)N)r\r=rR)typesrQtr:r:r;rRs rRcCsg}t||t|S)N)rRrz)rrQr:r:r; _type_varss rcCs't|tr|j||S|SdS)N)r\r=rP)rrNrOr:r:r;rP srPcCso|dkrtdSt|tr1t|}t|ttf rkt| rkt|d|f|S)avCheck that the argument is a type, and return it. 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). Nz Got %.100r.)r}r\r]rYrucallabler?)rjmsgr:r:r;rn's   #rncCs`t|trRt|t rR|jdkr8t|Sd|jt|fSn t|SdS)a)Return the repr() of an object, special-casing types. 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). builtinsz%s.%sN)r\r}r=rSr<r|)ror:r:r;rB<s  rBcsIeZdZdZdfddZddZfddZS) AnyMetazMetaclass for Any.Fcs%tj||||d|}|S)Nr>)rCrD)rErFrGrHr>rJ)rIr:r;rDPs!zAnyMeta.__new__cCstddS)Nz%Any cannot be used with isinstance().)r?)rJror:r:r;rpTszAnyMeta.__instancecheck__cs#t|tstj|SdS)NT)r\r}rCrt)rJrE)rIr:r;rtWszAnyMeta.__subclasscheck__)r8rSr7rUrDrprtr:r:)rIr;rMs  rc@seZdZdZfZdS)rzSpecial type indicating an unconstrained type. - Any object is an instance of Any. - Any class is a subclass of Any. - As a special case, Any and object are subclasses of each other. N)r8rSr7rUrXr:r:r:r;r]s  metaclassr>Tc sjeZdZdZddddddfddZd d Zd d Zd dZddZS)r a+Type 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) -> Sequence[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) will raise TypeError. However, issubclass(C, T) is true for any class C, and issubclass(str, A) and issubclass(bytes, A) are true, and issubclass(int, A) is false. (TODO: Why is this needed? This may change. See #136.) Type variables may be marked covariant or contravariant by passing covariant=True or contravariant=True. See PEP 484 for more details. By default type variables are invariant. Type variables can be introspected. e.g.: T.__name__ == 'T' T.__constraints__ == () T.__covariant__ == False T.__contravariant__ = False A.__constraints__ == (str, bytes) boundN covariantF contravariantcstj||tfidd}|r<|r<tdt||_t||_|rx|dk rxtd|rt|dkrtddt fdd |D|_ |rt |d |_ n d|_ |S) Nr>Tz+Bivariant type variables are not supported.z-Constraints cannot be combined with bound=...r[z"A single constraint is not allowedz:TypeVar(name, constraint, ...): constraints must be types.c3s|]}t|VqdS)N)rn).0r)rr:r; sz"TypeVar.__new__..zBound must be a type.) rCrDrW ValueErrorbool __covariant____contravariant__r?ryrzr~rn __bound__)rErFrrrZ constraintsrJ)rI)rr;rDs$    " zTypeVar.__new__cCs||kr|j|dS)N)append)rJrQr:r:r;rRs zTypeVar._get_type_varscCs5|jrd}n|jr$d}nd}||jS)N+-~)rrr8)rJprefixr:r:r;rTs     zTypeVar.__repr__cCstddS)Nz0Type variables cannot be used with isinstance().)r?)rJinstancer:r:r;rpszTypeVar.__instancecheck__csl|krdStkr dS|jdk r?t|jS|jrhtfdd|jDSdS)NTc3s|]}t|VqdS)N)rs)rc)rEr:r;rsz,TypeVar.__subclasscheck__..)rrrsr~any)rJrEr:)rEr;rts    zTypeVar.__subclasscheck__) r8rSr7rUrDrRrTrprtr:r:)rIr;r hs *   TKTVTT_corV_coVT_coT_contrarcseZdZdZddfddZddZdd Zfd d Zd d ZddZ ddZ ddZ ddZ S) UnionMetazMetaclass for Union.NFc s2|dkr+tj||||d|St|tsFtdg}d}xF|D]>}t|tr|j|jqY|jt ||qYWt |t t |krg} x4|D],} | kr| j| j | qW| } st t |x|D]tkr>tSttrPq(ttrbq(ttsts(t q(tfddhDr(j q(Wt dkrjStj|||idd} tfdd|D| _t| j| _| S) Nr>zExpected parameters=z)Union[arg, ...]: each arg must be a type.c3s<|]2}t|tst|to3t|VqdS)N)r\r r}rs)rZt2)t1r:r;rsz$UnionMeta.__new__..r[Tc3s!|]}|kr|VqdS)Nr:)rr) all_paramsr:r;rs)rCrDr\rzr?rextend__union_params__rrnsetryremoverhrr rur}rrpop frozenset__union_set_params__) rErFrGrH parametersr>paramsrpZ new_paramsrrJ)rI)rrr;rDsN           !"zUnionMeta.__new__cs^tfdd|jD}||jkr8|S|j|j|ji|ddSdS)Nc3s!|]}t|VqdS)N)rP)rr)rNrOr:r;r sz'UnionMeta._eval_type..r>T)rzrrIr8 __bases__)rJrNrOrr:)rNrOr;rP s zUnionMeta._eval_typecCs|jrt|j|dS)N)rrR)rJrQr:r:r;rRs zUnionMeta._get_type_varscsCtj}|jr?|ddjdd|jD7}|S)Nz[%s]z, css|]}t|VqdS)N)rB)rrr:r:r;rsz%UnionMeta.__repr__..)rCrTrr@)rJr)rIr:r;rTs  zUnionMeta.__repr__cCsv|jdk rtd|fkr3tdt|tsK|f}|j|j|jt|j|ddS)NzT) rr?r\rzrIr8rrm__dict__)rJrr:r:r;rs    zUnionMeta.__getitem__cCs#t|tstS|j|jkS)N)r\rNotImplementedr)rJotherr:r:r;__eq__*szUnionMeta.__eq__cCs t|jS)N)hashr)rJr:r:r;__hash__/szUnionMeta.__hash__cCstddS)Nz(Unions cannot be used with isinstance().)r?)rJror:r:r;rp2szUnionMeta.__instancecheck__cstkrdSjdkr,ttSttrnjdkrNdStfddjDSttrjkrdSjrttjSdSt fddjDSdS)NTFc3s|]}t|VqdS)N)rs)rr)rJr:r;r=sz.UnionMeta.__subclasscheck__..c3s|]}t|VqdS)N)rs)rr)rEr:r;rEs) rrr\rallr r~rsr r)rJrEr:)rErJr;rt5s    zUnionMeta.__subclasscheck__) r8rSr7rUrDrPrRrTrrrrprtr:r:)rIr;rs 5    rc@s"eZdZdZdZdZdS)r aUnion 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 - Corollary: if Any is present it is the sole survivor, e.g.:: Union[int, Any] == Any - Similar for object:: Union[int, object] == object - To cut a tie: Union[object, Any] == Union[Any, object] == Any. - You cannot subclass or instantiate a union. - You cannot write Union[X][Y] (what would it mean?). - You can use Optional[X] as a shorthand for Union[X, None]. N)r8rSr7rUrrr:r:r:r;r Hs 2cs7eZdZdZdfddZddZS) OptionalMetazMetaclass for Optional.Fcstj||||d|S)Nr>)rCrD)rErFrGrHr>)rIr:r;rDszOptionalMeta.__new__cCs#t|d}t|tdfS)Nz#Optional[t] requires a single type.)rnr r})rJrjr:r:r;rszOptionalMeta.__getitem__)r8rSr7rUrDrr:r:)rIr;rs rc@seZdZdZfZdS)rzKOptional type. Optional[X] is equivalent to Union[X, type(None)]. N)r8rSr7rUrXr:r:r:r;rs cseZdZdZdddfddZddZdd Zfd d Zd d ZddZ ddZ ddZ fddZ S) TupleMetazMetaclass for Tuple.NFcs7tj||||d|}||_||_|S)Nr>)rCrD__tuple_params____tuple_use_ellipsis__)rErFrGrHr use_ellipsisr>rJ)rIr:r;rDs!  zTupleMeta.__new__cCs|jrt|j|dS)N)rrR)rJrQr:r:r;rRs zTupleMeta._get_type_varscst|j}|dkr|Stfdd|D}||jkrN|S|j|j|ji|ddSdS)Nc3s!|]}t|VqdS)N)rP)rr)rNrOr:r;rsz'TupleMeta._eval_type..r>T)rrzrIr8r)rJrNrOtprr:)rNrOr;rPs  "zTupleMeta._eval_typecsxtj}|jdk rtdd|jD}|jrJ|jd|s]|jd|ddj|7}|S)NcSsg|]}t|qSr:)rB)rrr:r:r; s z&TupleMeta.__repr__..z...z()z[%s]z, )rCrTrrrr@)rJrr)rIr:r;rTs   zTupleMeta.__repr__c s|jdk r"td|ft|ts:|f}t|dkr{|dtkr{|dd}d}dn d}dtfdd |D}|j|j|jt |j |d |d dS) NzCannot re-parameterize %rr3r[Tz Tuple[t, ...]: t must be a type.Fz*Tuple[t0, t1, ...]: each t must be a type.c3s|]}t|VqdS)N)rn)rr)rr:r;rsz(TupleMeta.__getitem__..rr>) rr?r\rzryEllipsisrIr8rrmr)rJrrr:)rr;rs " zTupleMeta.__getitem__cCs5t|tstS|j|jko4|j|jkS)N)r\rrrr)rJrr:r:r;rszTupleMeta.__eq__cCs t|jS)N)rr)rJr:r:r;rszTupleMeta.__hash__cCstddS)Nz(Tuples cannot be used with isinstance().)r?)rJror:r:r;rpszTupleMeta.__instancecheck__cs|tkrdSt|ts/tj|St|trBdSt|tsatj|S|jdkrtdS|jdkrdS|j |j krdSt |jt |jkot ddt |j|jDS)NTFcss$|]\}}t||VqdS)N)rs)rr9rr:r:r;rsz.TupleMeta.__subclasscheck__..) rr\r}rCrtrsrzrrrryrzip)rJrE)rIr:r;rts$   zTupleMeta.__subclasscheck__) r8rSr7rUrDrRrPrTrrrrprtr:r:)rIr;rs       rc@seZdZdZfZdS)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 Sequence[T]. N)r8rSr7rUrXr:r:r:r;rs cseZdZdZdddfddZddZdd Zfd d Zd d ZddZ ddZ ddZ fddZ S) CallableMetazMetaclass for Callable.FNcs|dkr|dkrnh|tk rnt|tsItd|fdtfdd|D}dt|}tj||||d|}||_||_ |S)Nz8Callable[args, result]: args must be a list. Got %.100r.z6Callable[[arg, ...], result]: each arg must be a type.c3s|]}t|VqdS)N)rn)rrj)rr:r;rsz'CallableMeta.__new__..z.Callable[args, result]: result must be a type.r>) rr\listr?rzrnrCrD__args__ __result__)rErFrGrHr>rKresultrJ)rI)rr;rDs  !  zCallableMeta.__new__cCs|jrt|j|dS)N)rrR)rJrQr:r:r;rRs zCallableMeta._get_type_varsc s|jdkr"|jdkr"|S|jtkr=|j}nfdd|jD}t|j}||jkr||jkr|S|j|j|jid|d|ddSdS)Ncs"g|]}t|qSr:)rP)rr)rNrOr:r;rs z+CallableMeta._eval_type..rKrr>T)rrrrPrIr8r)rJrNrOrKrr:)rNrOr;rPs zCallableMeta._eval_typecstj}|jdk s-|jdk r|jtkrEd}n#ddjdd|jD}|d|t|jf7}|S)Nz...z[%s]z, css|]}t|VqdS)N)rB)rrr:r:r;r(sz(CallableMeta.__repr__..z[%s, %s])rCrTrrrr@rB)rJrZargs_r)rIr:r;rT"s zCallableMeta.__repr__c Cs|jdk s|jdk r*tdt|t sLt|dkrXtd|\}}|j|j|jt |j ddd|d|S)Nz,This Callable type is already parameterized.r3z6Callable must be used as Callable[[arg, ...], result].r>TrKr) rrr?r\rzryrIr8rrmr)rJrrKrr:r:r;r-s "  zCallableMeta.__getitem__cCs5t|tstS|j|jko4|j|jkS)N)r\rrrr)rJrr:r:r;r8szCallableMeta.__eq__cCst|jt|jAS)N)rrr)rJr:r:r;r>szCallableMeta.__hash__cCs>|jdkr.|jdkr.t|tjStddS)Nz,Callable[] cannot be used with isinstance().)rrr\collections_abcrr?)rJror:r:r;rpAszCallableMeta.__instancecheck__cs[|tkrdSt|ts/tj|S|jdkrQ|jdkrQdS||kS)NT)rr\rrCrtrr)rJrE)rIr:r;rtJs zCallableMeta.__subclasscheck__) r8rSr7rUrDrRrPrTrrrrprtr:r:)rIr;rs      rc@seZdZdZfZdS)raCallable 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; 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. N)r8rSr7rUrXr:r:r:r;rUs cCs8t|tstx|jdk r3|j}qW|S)z.Return the farthest origin of a generic class.N)r\ GenericMetarh __origin__)ar:r:r;_gorgcs rcCs:t|trt|ts$tt|t|kS)a%Return whether two generic classes are equivalent. The intention is to consider generic class X and any of its parameterized forms (X[T], X[int], etc.) as equivalent. However, X is not equivalent to a subclass of X. The relation is reflexive, symmetric and transitive. )r\rrhr)rbr:r:r;_geqvks $rcCsft}xYt|jddD]>\}}t|tr t|tkr |j|d}q W|S)zHelper for Generic.__new__. Returns the class after the last occurrence of Generic or Generic[...] in cls.__mro__. Nr[)r{ enumerate__mro__r\rrr)rEZ next_in_mroirr:r:r; _next_in_mrozs &!rcseZdZdZddddfddZddZfddZd d Zd d Zd dZ ddZ fddZ S)rzMetaclass for generic types.Nc stj||||dd}|dk rg|dk s?ttdd|Dst|nI|dkst||dkst||dkst|t|}d} xe|D]]} | tkrtdt| tr| j tkr| dk rtd| j } qW| dkr>|} nrt |} t | | kstddj fd d|Ddj d d| Df| }||_ ||_ ||_ ||_t||_|S) Nr>Tcss|]}t|tVqdS)N)r\r )rrr:r:r;rsz&GenericMeta.__new__..z!Cannot inherit from plain Genericz0Cannot inherit from Generic[...] multiple types.z6Some type variables (%s) are not listed in Generic[%s]z, c3s'|]}|krt|VqdS)N)r])rr)gvarsetr:r;rscss|]}t|VqdS)N)r])rgr:r:r;rs)rCrDrhrrrr?r\rr__parameters__rr@r __extra__r__next_in_mro__) rErFrGrHrQrKoriginextrarJZgvarsbaseZtvarset)rI)rr;rDsD! (            #    zGenericMeta.__new__cCs&|jr"|jr"t|j|dS)N)rrrR)rJrQr:r:r;rRszGenericMeta._get_type_varscs|jdk r!t|j}ntj}|jr`|ddjdd|jD7}|jr|ddjdd|jD7}|S)Nz[%s]z, css|]}t|VqdS)N)rB)rrr:r:r;rsz'GenericMeta.__repr__..z<%s>css|]}t|VqdS)N)rB)rrr:r:r;rs)rr|rCrTrr@r)rJr)rIr:r;rTs ! !zGenericMeta.__repr__cCsdt|tstS|jdk rV|j|jkoU|j|jkoU|j|jkS||kSdS)N)r\rrrrr)rJrr:r:r;rszGenericMeta.__eq__cCst|j|jfS)N)rr8r)rJr:r:r;rszGenericMeta.__hash__c st|ts|f}|s4tdt|dtfdd|D}|tkrtdd|Dstdtt|t|krtd|}d}n|tkr|}d}n|j ttfkr tdt |n|j s+td t |t|}t|j }||krtd ||krjd nd t |||ft |}|}|j |j|f|jt|jd |d|d|d|jS)Nz)Parameter list to %s[...] cannot be emptyz*Parameters to generic types must be types.c3s|]}t|VqdS)N)rn)rr)rr:r;rsz*GenericMeta.__getitem__..css|]}t|tVqdS)N)r\r )rrr:r:r;rsz5Parameters to Generic[...] must all be type variablesz-Parameters to Generic[...] must all be uniquez'Cannot subscript already-subscripted %sz%s is not a generic classz0Too %s parameters for %s; actual %s, expected %sZmanyZfewrQrKrr)r\rzr?r<rrryr _Protocolrr|rrrIr8rrmrr)rJrrQrKZalenZelenr:)rr;rsN          .   zGenericMeta.__getitem__cCs|j|jS)N)rtrI)rJrr:r:r;rp szGenericMeta.__instancecheck__csj|tkrdSt|tr"|j}|dk r"||jkr"t|jt|jksgtt|jt|jkstxt|j|j|jD]s\}}}t|t r |j rt ||s Pq|j rt ||s Pq||krPq||krPqWdSt j|r8dS|jdksVt|trZdSt ||jS)NTF)rr\rrryrrrhrr rrsrrCrtr)rJrErZp_selfZp_clsZp_origin)rIr:r;rts6  $$     zGenericMeta.__subclasscheck__) r8rSr7rUrDrRrTrrrrprtr:r:)rIr;rs 3   . rc@s(eZdZdZfZddZdS)raIAbstract base class for generic types. A generic type is typically declared by inheriting from an instantiation of this class 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 cOsU|jdkr|jj|St|}|jj|}|j|||SdS)N)rrrDrrM)rErKrLrror:r:r;rDWs  zGeneric.__new__N)r8rSr7rUrXrDr:r:r:r;r@s cCs|S)zCast a value to a type. This returns the value unchanged. To the type checker this signals that the return value has the designated type, but at runtime we intentionally don't check anything (we want this to be as fast as possible). r:)typvalr:r:r;r+asc Cs|j}|j}|j}|d|}|jp7f}|j}|rUt|ni}|t|}xCt||d|D](\}} ||kst| ||Return type hints for a function or method object. This is often the same as obj.__annotations__, but it handles forward references encoded as string literals, and if necessary adds Optional[t] if a default value equal to None is set. BEWARE -- the behavior of globalns and localns is counterintuitive (unless you are familiar with how eval() and exec() work). The search order is locals first, then globals. - If no dict arguments are passed, an attempt is made to use the globals from obj, and these are also used as the locals. If the object does not appear to have globals, an exception is raised. - If one dict argument is passed, it is used for both globals and locals. - If two dict arguments are passed, they specify globals and locals, respectively. __no_type_check__N __globals__) getattrrrm__annotations__itemsr\r]rYrPr)rorNrOrZhintsrFrr:r:r;r,|s$       cCsTt|trGx>|jjD]!}t|tjrd|_qWn d|_|S)a0Decorator 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 defined in that class (but not to methods defined in its superclasses or subclasses). This mutates the function(s) in place. T)r\r}rvaluesr FunctionTyper)rjror:r:r;r.s  cs%tjfdd}|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. cs||}t|}|S)N)r.)rKrLr) decoratorr:r;wrapped_decorators z2no_type_check_decorator..wrapped_decorator) functoolswraps)rrr:)rr;r/s!cOstddS)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.N)NotImplementedError)rKrLr:r:r;_overload_dummysrcCstS)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)rr:r:r;r0sc@s:eZdZdZddZddZddZdS) _ProtocolMetaz~Internal metaclass for _Protocol. This exists so _Protocol classes can be generic without deriving from Generic. cCstddS)Nz+Protocols cannot be used with isinstance().)r?)rJror:r:r;rpsz_ProtocolMeta.__instancecheck__csd|js tS|tkrdS|j}x4|D],tfdd|jDs0dSq0WdS)NTc3s|]}|jkVqdS)N)r)rd)attrr:r;rsz2_ProtocolMeta.__subclasscheck__..F)rVrr_get_protocol_attrsrr)rJrEattrsr:)rr;rts    "z_ProtocolMeta.__subclasscheck__cCsdg}x?|jD]4}t|ddr|jdkr|j|qWt}x |D]}x|jjD]}x|jD]5}||k r~||jkr~t|dd r~Pq~W|jd rn|dkrn|dkrn|dkrn|dkrn|dkrn|d krn|d krn|d krn|d krn|d krn|dkrn|j|qnWqXW|S)NrVFr_abc___abstractmethods__rrrXrrrrrrS) rrr8rrrkeys startswithadd)rJZprotocol_basesrrrrr:r:r;rs2!             z!_ProtocolMeta._get_protocol_attrsN)r8rSr7rUrprtrr:r:r:r;rs   rc@s"eZdZdZfZdZdS)rzInternal base class for protocol classes. This implements a simple-minded structural isinstance check (similar but more general than the one-offs in collections.abc such as Hashable). TN)r8rSr7rUrXrVr:r:r:r;r*s rc@seZdZfZdS)r N)r8rSr7rXr:r:r:r;r >s rc@seZdZfZdS)rN)r8rSr7rXr:r:r:r;rFs c@seZdZfZdS)rN)r8rSr7rXr:r:r:r;rIs c@seZdZfZdS)rN)r8rSr7rXr:r:r:r;rRs c@seZdZfZdS)rN)r8rSr7rXr:r:r:r;rVs c@s1eZdZfZeedddZdS)r")returncCsdS)Nr:)rJr:r:r;__int__]szSupportsInt.__int__N)r8rSr7rXrintrr:r:r:r;r"Zs c@s1eZdZfZeedddZdS)r!)rcCsdS)Nr:)rJr:r:r; __float__eszSupportsFloat.__float__N)r8rSr7rXrfloatrr:r:r:r;r!bs c@s1eZdZfZeedddZdS)SupportsComplex)rcCsdS)Nr:)rJr:r:r; __complex__mszSupportsComplex.__complex__N)r8rSr7rXrcomplexrr:r:r:r;rjs rc@s1eZdZfZeedddZdS) SupportsBytes)rcCsdS)Nr:)rJr:r:r; __bytes__uszSupportsBytes.__bytes__N)r8rSr7rXrbytesrr:r:r:r;rrs rc@s1eZdZfZeedddZdS)r )rcCsdS)Nr:)rJr:r:r;__abs__}szSupportsAbs.__abs__N)r8rSr7rXrrrr:r:r:r;r zs c@s7eZdZfZedeedddZdS)r#r)ndigitsrcCsdS)Nr:)rJrr:r:r; __round__szSupportsRound.__round__N)r8rSr7rXrrrr r:r:r:r;r#s c@seZdZfZdS)rN)r8rSr7rXr:r:r:r;rs c@s1eZdZfZeddddZdS)rzIterator[T_co])rcCsdS)Nr:)rJr:r:r; __reversed__szReversible.__reversed__N)r8rSr7rXrr r:r:r:r;rs c@seZdZfZdS)rN)r8rSr7rXr:r:r:r;rs c@seZdZdS)r N)r8rSr7r:r:r:r;r s c@seZdZdS)rN)r8rSr7r:r:r:r;rs c@seZdZdS)rN)r8rSr7r:r:r:r;rs c@seZdZdS)rN)r8rSr7r:r:r:r;rs c@seZdZdS)rN)r8rSr7r:r:r:r;rs c@seZdZdS)rN)r8rSr7r:r:r:r;rs c@seZdZdS)rN)r8rSr7r:r:r:r;rs c@seZdZdS)rN)r8rSr7r:r:r:r;rs c@seZdZddZdS)r&cOs.t|trtdtj|||S)Nz4Type List cannot be instantiated; use list() instead)rr&r?rrD)rErKrLr:r:r;rDs z List.__new__N)r8rSr7rDr:r:r:r;r&s c@seZdZddZdS)r'cOs.t|trtdtj|||S)Nz2Type Set cannot be instantiated; use set() instead)rr'r?rrD)rErKrLr:r:r;rDs z Set.__new__N)r8rSr7rDr:r:r:r;r's cs(eZdZdZfddZS)_FrozenSetMetazThis metaclass ensures set is not a subclass of FrozenSet. Without this metaclass, set would be considered a subclass of FrozenSet, because FrozenSet.__extra__ is collections.abc.Set, and set is a subclass of that. cs#t|trdStj|S)NF)rsr'rCrt)rJrE)rIr:r;rtsz _FrozenSetMeta.__subclasscheck__)r8rSr7rUrtr:r:)rIr;r s r c@s"eZdZfZddZdS) FrozenSetcOs.t|trtdtj|||S)Nz>Type FrozenSet cannot be instantiated; use frozenset() instead)rr r?rrD)rErKrLr:r:r;rDs zFrozenSet.__new__N)r8rSr7rXrDr:r:r:r;r s r c@seZdZdS)rN)r8rSr7r:r:r:r;rs c@seZdZdS)rN)r8rSr7r:r:r:r;rs c@seZdZdS)rN)r8rSr7r:r:r:r;rs c@seZdZdS)rN)r8rSr7r:r:r:r;rs AbstractContextManagerc@seZdZfZdS)ContextManagerN)r8rSr7rXr:r:r:r;rs rc@seZdZddZdS)r$cOs.t|trtdtj|||S)Nz4Type Dict cannot be instantiated; use dict() instead)rr$r?rmrD)rErKrLr:r:r;rDs z Dict.__new__N)r8rSr7rDr:r:r:r;r$ s c@seZdZddZdS)r%cOs1t|trtdtjj|||S)NzNType DefaultDict cannot be instantiated; use collections.defaultdict() instead)rr%r? collections defaultdictrD)rErKrLr:r:r;rDs zDefaultDict.__new__N)r8rSr7rDr:r:r:r;r%s cs(eZdZfZfddZS)r)cs1t|trtdtj|||S)Nz@Type Generator cannot be instantiated; create a subclass instead)rr)r?rCrD)rErKrL)rIr:r;rD*s zGenerator.__new__)r8rSr7rXrDr:r:)rIr;r)&s CTrc@seZdZdZdS)r aA 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. N)r8rSr7rUr:r:r:r;r 6s c Csdd|D}tj|dd|D}t||_y%tjdjjdd|_Wnt t fk rYnX|S)aTyped version of namedtuple. Usage:: Employee = typing.NamedTuple('Employee', [('name', str), 'id', int)]) This is equivalent to:: Employee = collections.namedtuple('Employee', ['name', 'id']) The resulting class has one extra attribute: _field_types, giving a dict mapping field names to types. (The field names are in the _fields attribute, which is part of the namedtuple API.) cSs"g|]\}}||fqSr:r:)rnrr:r:r;r_s zNamedTuple..cSsg|]\}}|qSr:r:)rrrr:r:r;r`s r[r8__main__) r namedtuplermZ _field_typesr5rerfgetrSAttributeErrorr)typenameZfieldsrEr:r:r;r(Os%cCs"dd}||_||_|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 cSs|S)Nr:)r9r:r:r;new_type}szNewType..new_type)r8Z __supertype__)rFrrr:r:r;r-js   Fc@sgeZdZdZfZeedddZeedddZe dddd Z e e dd d Z e e dd d Ze ddddZe e dddZe d6e edddZe e dddZe d7e edddZe d8e eedddZe de e e dd d!Ze e dd"d#Ze e dd$d%Ze de e d&d'd(Ze e dd)d*Ze ee d+d,d-Ze eedd.d/d0Ze d1dd2d3Ze ddd4d5ZdS)9IOaGeneric 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. )rcCsdS)Nr:)rJr:r:r;modeszIO.modecCsdS)Nr:)rJr:r:r;rFszIO.nameNcCsdS)Nr:)rJr:r:r;closeszIO.closecCsdS)Nr:)rJr:r:r;closedsz IO.closedcCsdS)Nr:)rJr:r:r;filenosz IO.filenocCsdS)Nr:)rJr:r:r;flushszIO.flushcCsdS)Nr:)rJr:r:r;isattysz IO.isattyr[)rrcCsdS)Nr:)rJrr:r:r;readszIO.readcCsdS)Nr:)rJr:r:r;readablesz IO.readable)limitrcCsdS)Nr:)rJr#r:r:r;readlinesz IO.readline)hintrcCsdS)Nr:)rJr%r:r:r; readlinessz IO.readlinesr)offsetwhencercCsdS)Nr:)rJr'r(r:r:r;seekszIO.seekcCsdS)Nr:)rJr:r:r;seekablesz IO.seekablecCsdS)Nr:)rJr:r:r;tellszIO.tell)sizercCsdS)Nr:)rJr,r:r:r;truncatesz IO.truncatecCsdS)Nr:)rJr:r:r;writablesz IO.writable)srcCsdS)Nr:)rJr/r:r:r;writeszIO.write)linesrcCsdS)Nr:)rJr1r:r:r; writelinessz IO.writelinesz IO[AnyStr]cCsdS)Nr:)rJr:r:r; __enter__sz IO.__enter__cCsdS)Nr:)rJr}r tracebackr:r:r;__exit__sz IO.__exit__rrr) r8rSr7rUrXrr]rrFrrrrrrrr r*r!r"r$r&r&r)r*r+r-r.r0r2r3r5r:r:r:r;rsT "!rc@s_eZdZdZfZeeeefe dddZ eddddZ dS) BinaryIOz5Typed version of the return of open() in binary mode.)r/rcCsdS)Nr:)rJr/r:r:r;r0szBinaryIO.write)rcCsdS)Nr:)rJr:r:r;r3szBinaryIO.__enter__N) r8rSr7rUrXrr r bytearrayrr0r3r:r:r:r;r6s %r6c@seZdZdZfZeedddZeedddZ eedddZ ee dd d Z ee dd d Zeddd dZdS)TextIOz3Typed version of the return of open() in text mode.)rcCsdS)Nr:)rJr:r:r;buffersz TextIO.buffercCsdS)Nr:)rJr:r:r;encodingszTextIO.encodingcCsdS)Nr:)rJr:r:r;errorssz TextIO.errorscCsdS)Nr:)rJr:r:r;line_buffering szTextIO.line_bufferingcCsdS)Nr:)rJr:r:r;newlinesszTextIO.newlinescCsdS)Nr:)rJr:r:r;r3szTextIO.__enter__N)r8rSr7rUrXrr6r9r]r:r;rr<rr=rr3r:r:r:r;r8s r8c@s7eZdZdZdddgZeZeZeZdS)ioz)Wrapper namespace for IO generic classes.rr8r6N)r8rSr7rU__all__rr8r6r:r:r:r;r>s r>z.ioPatterncCs|jS)N)pattern)rr:r:r;&srCMatchcCs |jjS)N)rerB)mr:r:r;rC(sc@s.eZdZdZddgZeZeZdS)rEz&Wrapper namespace for re type aliases.r@rDN)r8rSr7rUr?r@rDr:r:r:r;rE+s  rEz.re)|abcrrr contextlibrrEZ stdlib_rer5rcollections.abcr ImportErrorr?r<r}r=rWrYrurRrrPrnrBrrr rrrrrrrrr]r*rr rrrrrrrrrABCMetarrr+rr,r.r/rr0rrrhasattrr rrrrr"r!rrr r#rrrr'r rrrrrrrregister memoryviewrr&rr rr rrrrrrrrmr$rr%r)Z_G_base GeneratorTyperr r(r-r1r2rr6r8r>r8modulesr^r@matchrDr:r:r:r;sl          ) =M     " "^   u"9 " X" ["   ! )   = &###& #! #. )!! ### #   &  ## )#   ' #  `