Ë
|
@ñúh3 ã óf d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZ d dl
|
Z
|
d dl Z g d¢Z dZ eZej dk\ Z G d d« Z e« Zej dk\ rd Znej d k\ rd
|
Znd Ze
|
j* Z e
|
j, d « Z e
|
j, d « Z e
|
j, d« Z e
|
j, dd¬« Z e
|
j, dd¬« Zej dk\ rd dl
|
m Z n G d de« Z G d de ¬« Z e
|
j< Z G d de
|
j> d¬ « Z e
|
jB Z!ej dk\ r e
|
jD Z"nd Z"d Z#ej d k\ r e
|
jH Z$n3d Z%d! Z& G d" d#e
|
jN d¬ « Z( G d$ d%e d¬ « Z) e)d&¬'« Z$e
|
jT Z* e+e
|
d(« r%e
|
jX Z,e
|
jZ Z-e
|
j\ Z.n6 ej^ ej` ej^ e1« « Z2d) Z,d* Z-d+ Z.e
|
jf Z3e
|
jh Z4e
|
jj Z5e
|
jl Z6e
|
jn Z7e
|
jp Z8e
|
jr Z9e
|
jt Z:e
|
jv Z;e
|
jx Z<e
|
jz Z=e
|
j| Z>ej dk\ r d d,l
|
m?Z?m@Z@mAZAmBZB nµd- ZC eDe
|
d.e
|
jN « ZE G d/ d.eEd¬ « ZF ed« ZG eFej j d0eGeGf¬1« ZB eFej j d2eGf¬1« Z@ eFej d2d3e
|
j eJ f¬4« ZA eFej d2d5e
|
j eJ f¬4« Z?g d6¢d7d8gd9gd:ZL eMe
|
j « h d;£z ZOd< ZPdúd=ZQej d>k\ r e
|
j¤ ZRnDdûd?ZSd@ ZTdA ZU G dB dC ee
|
j¤ « « ZVeWdD « ZX G dE dFe
|
j² eV¬« ZRej d>k\ r e
|
j´ ZZndG ZZeZZ[ej dHk\ rUe
|
j¸ Z\e
|
jº Z]e
|
j¼ Z^e
|
j¾ Z_e
|
jÀ Z`e
|
j Zae
|
jÄ ZbnveZ G dI dJeR« « Z\eZ G dK dLeR« « Z]eZ G dM dNeR« « Z^eZ G dO dPeR« « Z_eZ G dQ dReR« « Z`eZ G dS dTeRe « « ZaeZ G dU dVeRe « « ZbdW ZcdXZdedr%e
|
jÊ Zee
|
jÌ Zfe
|
jÎ Zgn}dY ejÐ e
|
jÒ « jÔ v ZkdZ Zl G d[ d\e« ZfejÛ efd]d^i « Zn ecd_ « efddXd`da« Ze e+e
|
d\« re
|
jÌ effZoneffZodb Zg e+e
|
dc« r e
|
jà Zpndd Zp e+e
|
de« r e
|
jâ Zqndf ZrdüdgZq e+e
|
dh« re
|
jæ Zse
|
jè Ztn! G di dje
|
jN d¬ « Zt G dk dh« Zsej dd2 dk\ re
|
jê Zue
|
jì Zvn d dll
|
mwZw d dml
|
myZz dn Zudo Zv e+e
|
dp« r e
|
jö Z{n%ej dd2 d k\ r e dq « Z{n
|
e dpdr¬'« Z{ e+e
|
ds« r e
|
jø Z|n G dt due« Z} G dv dwe}¬« Z~ e~« Z|[~[}dx Zdy Z G dz d{« Z G d| d}e« Zerd d~l
|
mZ n G d de¬« Z e+e
|
d« re
|
j Ze
|
j Zn G d d« Z
G d de
« Z G d
de
« Zerd dl
|
mZ n" e+e
|
d« r G d de¬« Zn G d dee« Z e+e
|
d« s G d de« Ze
|
j d « Z e+e
|
d« re
|
j Ze
|
j Zn2ej dd2 d k\ r e d « Zn G d de d¬ « Z edd¬'« Z e+e
|
d« re
|
j Zn2ej dd2 d k\ r e d « Zn G d de d¬ « Z edd¬'« Z e+e
|
d« re
|
j Zn2ej dd2 d k\ r e d « Zn G d de d¬ « Z edd¬'« Z G d de
|
j" d¬ « Z e+e
|
d« re
|
j$ Zne d « Z e+e
|
d¡« re
|
j& Zne d¢ « Z e+e
|
d£« re
|
j( Zne d¤ « Z e+e
|
d¥« re
|
j* Ze
|
j, ZnDej dd2 d k\ re d¦ « Ze d§ « Zn! G d¨ d©e d¬ « Z ed¥dª¬'« Z ed«d¬¬'« Z e+e
|
de« re
|
j0 Zn2ej dd2 d k\ r e d « Zn G d® d¯e d¬ « Z eded°¬'« Zd±Zej dHk\ re
|
j6 Zd² Znsej dd2 d k\ r0 G d³ d´e d¬ « Z G dµ d¶e
|
jN d¬ « Zed· « Zd¸ Zn1 G d¹ d¶e
|
jN d¬ « Z G dº d»e d¬ « Z ed¼e¬'« Zd½ Zerd d¾l
|
m Z n$ e+e
|
d¿« rdÀ Z¡ G dÁ d¿e¬« Z n G d d¿e« Z e+e
|
dë re
|
jD Z¢ndÄedÅefdÆZ¢ e+e
|
dǫ re
|
jF Z£ndÈZ£ e+e
|
dɫ re
|
jH Z¤ndÊedÅefdËZ¤ej dHk\ re
|
jJ Z¥n
ddXdXdXd^dÌdÍeJdÎeJdÏeJdÐeJdÑe
|
jL e
|
jN e
|
jf e
|
j8 e
|
jP dÒe
|
j8 f f dÒf dÓe
|
j8 dÅe
|
jP egef fdÔZ¥ e+e
|
dÕ« re
|
jR Z©n6 e
|
j, dÖe
|
jP dÒe
|
j8 f ¬×« ZªdÊeªdÅeªfdØZ© e+e dÙ« re jV Z«n e
|
j, dÚ« Z¬ G dÛ dÙ« Z« e+e
|
d¿« sefdÜZndÝ Zesee
|
_ dÅeJfdÞZ®e eDe
|
d¿d« hZ¯dÅeJfdßZ° e+e
|
dà« r dýdáZ±e±e
|
_± n dâ Z²ese²e
|
_² ej d>k\ re
|
jf Z³nMdþdãZ´e
|
jj Z¶ eMh d䣫 Z· G då dæe« Z¸ejÛ e¸dçd^i « Z¹dè Zº eceº« efdé« Z³ e+ej d9« rej jv Z»nL G dê d9e jx « Z»e»j{ e¾« e»j{ e¿« e»j{ eÀ« e+e dë« re j ZÁndì ZÁej dk\ re
|
j ZÂn
|
G dí dî« ZÂ e+e
|
dï« re
|
j ZÃn dð ZÄ G dñ dï« ZÃ e+e
|
dò« re
|
j ZÅe
|
j ZÆn dóedÅeJfdôZÅdóedÅe
|
j eÈ fdõZÆ e+e
|
dö« re
|
j ZÉn
|
G d÷ dö« ZÉ eDe død« ZÊeÊ d dlËZË eDeËdùd« ZÌeÌ eeÌ« ZÊ eÊeÊZÍe j dø« e
|
j ZÏe
|
j ZÐe
|
j¢ ZÑe
|
jP Z¨e
|
j¤ ZÒe
|
j¦ ZÓe
|
j¨ ZÔe
|
jª ZÕe
|
j ZÇe
|
j² ZYe
|
j¬ ZÖe
|
j® Z×e
|
j° ZØe
|
j² ZÙe
|
j´ ZÚe
|
j¶ ZÛe
|
j¸ ZÜe
|
jº ZÝe
|
j¼ ZÞe
|
j¾ Zße
|
jÀ Zàe
|
j Záe
|
jÄ Zâe
|
j ZIe
|
jÆ Zãe
|
jÈ Zäe
|
jÊ Zåe
|
jÌ Zæe
|
jÎ Zçe
|
jÐ Zèe
|
jL Z¦e
|
jN Z§e
|
jÒ Zée
|
jÔ Zêe
|
jÖ Zëe
|
jØ Zìy# ex$ r e
|
jN ZwY w xY w# ex$ r e
|
jN ZzY ¾w xY w# ex$ r Y !w xY w)ÿé N)mÚAnyÚClassVarÚ ConcatenateÚFinalÚ LiteralStringÚ ParamSpecÚ ParamSpecArgsÚParamSpecKwargsÚSelfÚTypeÚTypeVarÚ TypeVarTupleÚUnpackÚ AwaitableÚ AsyncIteratorÚ AsyncIterableÚ CoroutineÚAsyncGeneratorÚAsyncContextManagerÚBufferÚChainMapÚContextManagerÚCounterÚDequeÚ DefaultDictÚ
|
NamedTupleÚ OrderedDictÚ TypedDictÚ SupportsAbsÚ SupportsBytesÚSupportsComplexÚ SupportsFloatÚ SupportsIndexÚ SupportsIntÚ SupportsRoundÚ AnnotatedÚ assert_neverÚ assert_typeÚclear_overloadsÚdataclass_transformÚ
|
deprecatedÚDocÚ get_overloadsÚfinalÚget_argsÚ
|
get_originÚget_original_basesÚget_protocol_membersÚget_type_hintsÚIntVarÚ is_protocolÚ is_typeddictÚLiteralÚNewTypeÚoverloadÚoverrideÚProtocolÚ reveal_typeÚruntimeÚruntime_checkableÚTextÚ TypeAliasÚ TypeAliasTypeÚ TypeGuardÚTypeIsÚ TYPE_CHECKINGÚNeverÚNoReturnÚReadOnlyÚRequiredÚ NotRequiredÚ AbstractSetÚAnyStrÚBinaryIOÚCallableÚ
|
CollectionÚ ContainerÚDictÚ
|
ForwardRefÚ FrozenSetÚ GeneratorÚGenericÚHashableÚIOÚ ItemsViewÚIterableÚIteratorÚKeysViewÚListÚMappingÚ MappingViewÚMatchÚMutableMappingÚMutableSequenceÚ
|
MutableSetÚ NoDefaultÚOptionalÚPatternÚ
|
ReversibleÚSequenceÚSetÚSizedÚTextIOÚTupleÚUnionÚ
|
ValuesViewÚcastÚ no_type_checkÚno_type_check_decoratorT)é é r Úbetac ó e Zd Zd Zy)Ú _Sentinelc ó y)Nz
|
<sentinel>© ©Úselfs úWH:\Change_password\venv_build\Lib\site-packages\setuptools/_vendor/typing_extensions.pyÚ__repr__z_Sentinel.__repr__ s Øó N©Ú__name__Ú
|
__module__Ú __qualname__rz rv r{ ry rt rt s ó r{ rt ©rp é
|
c ót t | t j t j t j
|
f« S ©N)Ú
|
isinstanceÚtypingÚ _GenericAliasÚ_typesÚ GenericAliasÚ UnionType©Úts ry Ú _should_collect_from_parametersr s- ÜØ ×$Ñ$¤f×&9Ñ&9¼6×;KÑ;KÐLó
|
ð
|
r{ ©rp é c óV t | t j t j f« S r )r r
r r r r s ry r r s Ü!f× 2Ñ 2´F×4GÑ4GÐ HÓIÐIr{ c óT t | t j « xr | j S r )r r
r Ú_specialr s ry r r ¢ s Ü!V× 1Ñ 1Ó2ÒE¸1¿:¹:°~ÐEr{ ÚTÚKTÚVTÚT_co)Ú covariantÚT_contra)Ú contravariant)rp é )r c ó( e Zd Z fdZ fdZ xZS )Ú_AnyMetac óH | t u r t d« t | |« S )Nz6typing_extensions.Any cannot be used with isinstance())r Ú TypeErrorÚsuperÚ__instancecheck__)rx ÚobjÚ __class__s ry r z_AnyMeta.__instancecheck__¶ s& ø Øs{Ü Ð XÓYÐYÜ7Ñ,¨SÓ1Ð 1r{ c ó2 | t u ryt | « S )Nztyping_extensions.Any)r r rz )rx r¡ s ry rz z_AnyMeta.__repr__» s ø Øs{Ø.Ü7Ñ#Ó%Ð %r{ )r} r~ r r rz Ú __classcell__©r¡ s @ry r r µ s ø ô 2÷
|
&ð &r{ r c ó" e Zd ZdZ fdZ xZS )r aq 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
|
checks.
|
c óP | t u r t d« t | | g|¢i |¤S )NzAny cannot be instantiated)r r r Ú__new__©ÚclsÚargsÚkwargsr¡ s ry r§ z Any.__new__É s/ ø ØczÜ Ð <Ó=Ð=Ü7? 3Ð8¨Ò8°Ñ8Ð 8r{ )r} r~ r Ú__doc__r§ r£ r¤ s @ry r r À s ø ñ ÷ 9ð 9r{ r )Ú metaclassc ó e Zd Zd Zy)Ú_ExtensionsSpecialFormc ó d| j z S ©Nztyping_extensions.©Ú_namerw s ry rz z _ExtensionsSpecialForm.__repr__Ó s Ø# d§j¡jÑ0Ð0r{ Nr| rv r{ ry r¯ r¯ Ò s ó1r{ r¯ )Ú_rootc óB d| _ | S # t t f$ r Y | S w xY w)aø This decorator can be used to indicate to type checkers that
|
the decorated method cannot be overridden, and decorated class
|
cannot be subclassed. For example:
|
|
class Base:
|
@final
|
def done(self) -> None:
|
...
|
class Sub(Base):
|
def done(self) -> None: # Error reported by type checker
|
...
|
@final
|
class Leaf:
|
...
|
class Other(Leaf): # Error reported by type checker
|
...
|
|
There is no runtime checking of these properties. The decorator
|
sets the ``__final__`` attribute to ``True`` on the decorated object
|
to allow runtime introspection.
|
T)Ú __final__ÚAttributeErrorr )Úfs ry r. r. ß s5 ð, Ø AKð øô ¤ Ð*ò ð Øð úó c ó, t j | « S r )r
r )Únames ry r4 r4 ÿ s Ü >>$Ó Ð r{ )rp r é c ó¤ g }| D ]? }t |t « r |j |j « /|j |« A t |« S )zJAn internal helper for Literal creation: flatten Literals among parameters)r Ú_LiteralGenericAliasÚextendÚ__args__ÚappendÚtuple)Ú
|
parametersÚparamsÚps ry Ú_flatten_literal_paramsrÆ sI àØò !AÜ!Ô 1Ô2Ø ajjÕ)à aÕ ð !ô
|
V}Ð r{ c # ó8 K | D ] }|t |« f y wr )Útype)rÄ rÅ s ry Ú_value_and_type_iterrÉ s# è ø Øò AØT!W*Ó ñ ùs c ó e Zd Zd Zd Zy)r¾ c ó° t |t « st S t t | j
|
« « }t t |j
|
« « }||k( S r )r r¾ ÚNotImplementedÚsetrÉ rÀ )rx ÚotherÚthese_args_dedupedÚother_args_dedupeds ry Ú__eq__z_LiteralGenericAlias.__eq__ sI Ü eÔ%9Ô:Ü%Ð%Ü!$Ô%9¸$¿-¹-Ó%HÓ!IÐ Ü!$Ô%9¸%¿.¹.Ó%IÓ!JÐ Ø%Ð);Ñ;Ð ;r{ c óP t t t | j « « « S r )ÚhashÚ frozensetrÉ rÀ rw s ry Ú__hash__z _LiteralGenericAlias.__hash__ s Ü Ô"6°t·}±}Ó"EÓFÓGÐ Gr{ N)r} r~ r rÑ rÕ rv r{ ry r¾ r¾ s ò <ó Hr{ r¾ c ó e Zd ZdefdZd Zy)Ú _LiteralFormÚdocc ó. d| _ |x| _ | _ y )Nr7 )r³ Ú_docr¬ )rx rØ s ry Ú__init__z_LiteralForm.__init__! s Ø"DJØ'*Ð *DI r{ c ór t |t « s|f}t |« }t t |« « } t |« }t |« t |« k rHg }|D ], }||v s|j |d « |j |« . |rJ |« t |« } t | |« S # t $ r Y w xY w©Nr ) r r rÆ ÚlistrÉ rÍ ÚlenrÁ Úremover r¾ )rx rà Úval_type_pairsÚ deduped_pairsÚnew_parametersÚpairs ry Ú __getitem__z_LiteralForm.__getitem__% sÇ Ü j¬%Ô0Ø (]
|
ä0°Ó<Jä !Ô"6°zÓ"BÓ CNð 7Ü # NÓ 3 ô }Ó%¬¨NÓ(;Ò;Ø%'NØ .ò 7Ø =Ò0Ø *× 1Ñ 1°$°q±'Ô :Ø )× 0Ñ 0°Õ 6ð7ñ -Ð;¨mÓ;Ð,Ü!& ~Ó!6Jä'¨¨jÓ9Ð 9øô ò áð ús ´ B* Â* B6Â5B6N)r} r~ r ÚstrrÛ rå rv r{ ry r× r× s ð + ó +ó :r{ r× a A type that can be used to indicate to type checkers
|
that the corresponding value has a value literally equivalent
|
to the provided parameter. For example:
|
|
var: Literal[4] = 4
|
|
The type checker understands that 'var' is literally equal to
|
the value 4 and no other value.
|
|
Literal[...] cannot be subclassed. There is no runtime
|
checking verifying that the parameter is actually a value
|
instead of a type.)rØ r- c óÀ t | d| « } | t |j |j |j j
|
< t S # t $ r Y t S w xY w)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
|
|
The overloads for a function can be retrieved at runtime using the
|
get_overloads() function.
|
Ú__func__)ÚgetattrÚ_overload_registryr~ r Ú__code__Úco_firstlinenor· Ú_overload_dummy)Úfuncr¸ s ry r9 r9 Z sg ô< D* dÓ +ð ð ô q||Ñ ,¨Q¯^©^Ñ <Ø
|
|
×)Ñ)ñ ô Ð øô ò à Ü Ð ð ús 7A Á A Á A c óÖ t | d| « }|j t vrg S t |j }|j |vrg S t ||j j « « S )z6Return all defined overloads for *func* as a sequence.rè )ré r~ rê r rÞ Úvalues)rî r¸ Úmod_dicts ry r- r- s` ô D* dÓ +Ø <<Ô 1Ñ 1ØIÜ% a§l¡lÑ3Ø >> Ñ )ØIÜHQ^^Ñ,×3Ñ3Ó5Ó6Ð6r{ c ó, t j « y)z$Clear all overloads in the registry.N)rê Úclearrv r{ ry r) r) s ä× Ñ Õ"r{ )r r r rS c óJ | j d« xr | j d« S )NÚ__)Ú
|
startswithÚendswith)Úattrs ry Ú
|
_is_dunderrù § s ØtÓ$Ò<¨¯ © °tÓ)<Ð<r{ Ú_SpecialGenericAliasc óR e Zd Zdddd fd
|
Zd Zej d « Z xZS )rú TNrv )Úinstr» Údefaultsc óº t t j u r*|| _ || _ t
|
| ||d||¬« || _ y t
|
| ||||¬« || _ y )NT)Úspecialrü r» )rü r» )Ú_special_generic_alias_baser
r Ú
|
__origin__Ú_nparamsr rÛ Ú _defaults)rx ÚoriginÚnparamsrü r» rý r¡ s ry rÛ z _SpecialGenericAlias.__init__° s` ø Ü*¬f×.BÑ.BÑBà"(Ø ' ÜÑ ¨¸$ÀTÐPTÐ ÔUð &DNô Ñ ¨°tÀ$Ð ÔGØ %DNr{ c óÖ h d£}t t j u r|j d« t |« s||v rt
|
j | ||« y t | j ||« y )N> Ú_instr³ r r r ) r r
r Úaddrù ÚobjectÚ __setattr__Úsetattrr )rx rø ÚvalÚ allowed_attrss ry r
|
z _SpecialGenericAlias.__setattr__» sT Ú GMÜ*¬f×.BÑ.BÑBà ×!Ñ! ,Ô/Ü$Ô 4¨=Ñ#8Ü×"Ñ" 4¨¨sÕ3䨨sÕ3r{ c
|
ó¶ t |t « s|f}dt fd|D « « }| j rpt |« | j k rXt |« t | j « z | j k\ r*g |¢| j t |« | j z
|
d ¢}t |« }|| j k7 r| j r&d| j t | j « z
|
}nt | j « }| j st | d« t d|| j kD rdnd d| d | d
|
| « | j |« S ) Nz*Parameters to generic types must be types.c 3 óJ K | ] }t j |« y wr ©r
Ú _type_check©Ú.0rÅ Úmsgs ry ú <genexpr>z3_SpecialGenericAlias.__getitem__.<locals>.<genexpr>Ê s øè ø ÒF¸!6×-Ñ-¨a°×5ÑFùó #ú at least ú is not a generic classúToo ÚmanyÚfewú arguments for ú ; actual ú , expected )r r r rß r ræ r Ú copy_with)rx rÄ Ú
|
actual_lenÚexpectedr s @ry rå z _SpecialGenericAlias.__getitem__Å s9 ø ä f¤eÔ,Ø Ø>CÜÓF¸vÔFÓFFàÜK $§-¡-Ò/ÜK¤# d§n¡nÓ"5Ñ5¸¿ ¹ ÒFàQ6ÐQ D§N¡N´3°v³;ÀÇ Á Ñ3NÐ3OÐ$PÑQÜ VJàT]]Ò*Ø>>Ø!*¨4¯=©=¼3¸t¿~¹~Ó;NÑ+NÐ*OÐ PHä " 4§=¡=Ó 1HØ}}Ü# t fÐ,CÐ$DÓEÐEÜ Ø Z°$·-±-Ò%?6ÀUÐKØ% d Vð , Ø )l¨+°h°ZðAóð ð
|
>> &Ó)Ð )r{ ) r} r~ r rÛ r
|
r
Ú _tp_cacherå r£ r¤ s @ry rú rú ¯ s. ø Ø48¸tÈbö &ò 4ð
|
× Ñ ñ *ó
|
ô *r{ rp )rý é r )r» rý r ) rM r rX rY r rU rh rO rN re r ÚAbstractContextManagerÚAbstractAsyncContextManagerr )zcollections.abcÚ
|
contextlibÚtyping_extensions> r¶ Ú__match_args__Ú__protocol_attrs__Ú __non_callable_proto_members__c óþ t « }| j d d D ]` }|j dv rt |di « }g |j ¢|¢D ]. }|j d« r|t vs |j |« 0 b |S )Néÿÿÿÿ> rT r; Ú__annotations__Ú_abc_)rÍ Ú__mro__r} ré Ú__dict__rö Ú_EXCLUDED_ATTRSr )r© ÚattrsÚbaseÚ annotationsrø s ry Ú_get_protocol_attrsr5 s Ü EEØ CRÐ ò Ø ==Ð 3Ñ 3Ø Ü dÐ$5°rÓ: Ø2dmmÐ2 kÑ2ò DØOO GÕ,°¼_Ò1LØ $ñ ð ð Lr{ c ó t j | « j j dd« S # t t
|
f$ r Y y w xY w)Nr} Ú__main__)ÚsysÚ _getframeÚ f_globalsÚgetr· Ú
|
ValueError©Údepths ry Ú_callerr? s@ ðÜ}}UÓ#×-Ñ-×1Ñ1°*¸jÓIÐIøÜ JÐ 'ò Ùðús .1 ±AÁA©rp rq c ó t | « dv S )zåAllow instance and class checks for special stdlib modules.
|
The abc and functools modules indiscriminately call isinstance() and
|
issubclass() on the whole MRO of a user class, which may contain protocols.
|
> NÚabcÚ functools)r? r= s ry Ú _allow_reckless_class_checksrD s ô
|
u~Ð!;Ð;Ð;r{ c óD t | « j r t d« y )Nz Protocols cannot be instantiated)rÈ Ú _is_protocolr ©rx rª r« s ry Ú_no_initrH % s Ü :× "Ò "ÜÐ >Ó?Ð ?ð #r{ c ó: t | t « s t d« y)aû Raise TypeError if `arg` is not an instance of `type`
|
in `issubclass(arg, <protocol>)`.
|
|
In most cases, this is verified by type.__subclasscheck__.
|
Checking it again unnecessarily would slow down issubclass() checks,
|
so, we don't perform this check unless we absolutely have to.
|
|
For various error paths, however,
|
we want to ensure that *this* error message is shown to the user
|
where relevant, rather than a typing.py-specific error message.
|
z"issubclass() arg 1 must be a classN)r rÈ r ©Úargs ry Ú _type_check_issubclass_arg_1rL ) s ô #tÔ$äÐ @ÓAÐ Að %r{ c ó6 e Zd Zd Zd Zd Zd Zd ZdefdZ y) Ú _ProtocolMetac ó¨ |dk( rt |« dk rnt t j ht |« z rz|D ]u }|t t j
|
t t j hv r0|j t j |j g « v r]t |« rit d|« t j j | |||fi |¤S )Nr; r# z5Protocols can only inherit from other protocols, got )rß r; r
rÍ r rT r} Ú_PROTO_ALLOWLISTr; r~ r5 r rB ÚABCMetar§ )Úmclsr» ÚbasesÚ namespacer« r3 s ry r§ z_ProtocolMeta.__new__C s¹ ØzÒ!¤c¨%£j°1¢nØÜFOOÐ,¬s°5«zÒ9Ø !ò Dà ¤¬¯ © ¼Ä6Ç?Á?Ð SÒSØ ==Ô,<×,@Ñ,@ÀÇ Á ÐRTÓ,UÒUÜ& tÕ,ä 'ð #Ø#' (ð ,ó ð ð ô ;;×&Ñ& t¨T°5¸)ÑNÀvÑNÐ Nr{ c ó t j j | g|¢i |¤ t | dd« rt | « | _ y y )NrF F)rB rQ rÛ ré r5 r) ©r© rª r« s ry rÛ z_ProtocolMeta.__init__S s< Ü KK× Ñ Ð 6 tÒ 6¨vÒ 6ÜsN¨EÔ2Ü)<¸SÓ)AÕ&ð 3r{ c ó | t u rt j | |« S t | dd« rt « st | dd« st |« t d« | j r\| j j d« t u r;t |« t | j « }t dt |« dd d « t j j | |« S )
|
NrF FÚ_is_runtime_protocolúLInstance and class checks can only be used with @runtime_checkable protocolsÚ__subclasshook__zRProtocols with non-method members don't support issubclass(). Non-method members: r¼ r, ú.)r; rÈ Ú__subclasscheck__ré rD rL r r* r0 r; Ú _proto_hookÚsortedræ rB rQ )r© rÎ Únon_method_attrss ry r\ z _ProtocolMeta.__subclasscheck__X s× ØhÜ×-Ñ-¨c°5Ó9Ð9ä^¨UÔ3Ü4Ô6ä sÐ$:¸EÔBÜ0°Ô7Ü#ð7óð ð ×6Ò6Ø ×(Ñ(Ð);Ó<Ä ÑKä0°Ô7Ü'-¨c×.PÑ.PÓ'QÐ$Ü#ð0Ü03Ð4DÓ0EÀaÈÐ0KÐ/LÈAðOóð ô ;;×0Ñ0°°eÓ<Ð <r{ c ó¶ | t u rt j | |« S t | dd« s t j
|
j | |« S t | dd« st « s t d« t j
|
j | |« ry| j D ], } t j ||« }| || j vs, y y# t $ r Y yw xY w)NrF FrX rY T) r; rÈ r ré rB rQ rD r r) ÚinspectÚgetattr_staticr· r* )r© Úinstancerø r s ry r z _ProtocolMeta.__instancecheck__r sê ð hÜ×-Ñ-¨c°8Ó<Ð<Ü3 °Ô6ä{{×4Ñ4°S¸(ÓCÐCô CÐ!7¸Ô?Ü0Ô2ä ð !@ó Að Aô {{×,Ñ,¨S°(Ô;Øà×.Ñ.ò ðÜ!×0Ñ0°¸4Ó@Cð ; 4¨s×/QÑ/QÒ#QØð ð ð øô &ò Ùð ðús  C à CÃCc ó t j j | |« du ry| t u xr |t j u S )NT)rB rQ rÑ r; r
©r© rÎ s ry rÑ z_ProtocolMeta.__eq__ s8 ô {{×!Ñ! # uÓ-°Ñ5ØØ(?Ò? u´·±Ð'?Ð ?r{ Úreturnc ó, t j | « S r )rÈ rÕ ©r© s ry rÕ z_ProtocolMeta.__hash__ s Ü== Ó%Ð %r{ N)
|
r} r~ r r§ rÛ r\ r rÑ ÚintrÕ rv r{ ry rN rN < s+ ò Oò Bò
|
=ò4 ò@ @ð &Sô &r{ rN c ót | j j dd« st S | j D ] }|j D ]o }||j v r|j |
|
t c c S ;t |di « }t |t j j « s^||v sct |« so t c S y)NrF Fr- T) r0 r; rÌ r) r/ ré r Ú collectionsrB r\ r5 )r© rÎ rø r3 r4 s ry r] r] s à||× Ñ °Ô6Ü!Ð !à×*Ñ*ò &DØ ò &à4==Ñ(Ø}} TÑ*Ð2Ü -Ô-Ùô & dÐ,=¸rÓ B ä {¬K¯O©O×,CÑ,CÕDØ Ò+Ü# EÕ*áð &ô &Ò%ð# &ð$ r{ c óV e Zd Zej j
|
ZdZdZdZ fdZ xZ
|
S )r; rv TFc ó: t | |i |¤ | j j dd« s!t d | j
|
D « « | _ d| j vr t | _ | j r)| j t j u r t | _ y y y )NrF Fc 3 ó, K | ] }|t u y wr )r; ©r Úbs ry r z-Protocol.__init_subclass__.<locals>.<genexpr>Ä s è ø Ò&L¸ q¬H¤}Ñ&Lùs rZ ) r Ú__init_subclass__r0 r; ÚanyÚ __bases__rF r] rZ rÛ r; rH r¨ s ry rq zProtocol.__init_subclass__¿ s ø Ü GÑ % tÐ 6¨vÒ 6ð <<×#Ñ# N°EÔ:Ü#&Ñ&L¸c¿m¹mÔ&LÓ#LÔ ð "¨¯ © Ñ5Ü'2Ô$ð × Ò C§L¡L´H×4EÑ4EÑ$EÜ ' ð %FÐ r{ ) r} r~ r r
r; r¬ Ú __slots__rF rX rq r£ r¤ s @ry r; r; ¹ s, ø Ø//×)Ñ)Ø Ø Ø $Ð ÷ (ð (r{ r; c ó° t | t j « r t | dd« st d| « d| _ t | t « st j dk\ rUt « | _ | j D ]7 } t t | |d« « }|r | j j |« 9 | S # t $ r}t d|d« |d}~ww xY w) aj Mark a protocol class as a runtime protocol.
|
|
Such protocol can be used with isinstance() and issubclass().
|
Raise TypeError if applied to a non-protocol class.
|
This allows a simple-minded structural check very similar to
|
one trick ponies in collections.abc such as Iterable.
|
|
For example::
|
|
@runtime_checkable
|
class Closable(Protocol):
|
def close(self): ...
|
|
assert isinstance(open('/some/file'), Closable)
|
|
Warning: this will check only the presence of the required methods,
|
not their type signatures!
|
rF Fz@@runtime_checkable can be only applied to protocol classes, got T)rp é r# Nz,Failed to determine whether protocol member z is a method member)Ú
|
issubclassr
rT ré r rX r rN r8 Ú version_inforÍ r* r) Úcallabler Ú Exception)r© rø Ú is_callableÚes ry r> r> Ò sí ô& #v~~Ô.´g¸cÀ>ÐSXÔ6YÜð $Ø$' 7ð ,ó -ð -à#'Ô ô c=Ô )¬S×-=Ñ-=ÀÒ-Kô
|
25³CÔ .Ø×.Ñ.ò
|
Eð EÜ"*¬7°3¸¸dÓ+CÓ"DKò 'Ø×:Ñ:×>Ñ>¸tÕDð
|
Eð
|
øô !ò Ü#ØFÀtÀhð O-ð -óð ð ûð ús Á?B7Â7 CÃ CÃC©rp rv c ó> e Zd ZdZdZej defd« Zy)r$ z(An ABC with one abstract method __int__.rv rf c ó y r rv rw s ry Ú__int__zSupportsInt.__int__ ó à r{ N) r} r~ r r¬ rt rB Úabstractmethodri r rv r{ ry r$ r$ s) á6Ø à × Ñ ð Sò ó
|
ñ r{ r$ c ó> e Zd ZdZdZej defd« Zy)r" z*An ABC with one abstract method __float__.rv rf c ó y r rv rw s ry Ú __float__zSupportsFloat.__float__" r r{ N) r} r~ r r¬ rt rB r Úfloatr
rv r{ ry r" r" ó) á8Ø à × Ñ ð uò ó
|
ñ r{ r" c ó> e Zd ZdZdZej defd« Zy)r! z,An ABC with one abstract method __complex__.rv rf c ó y r rv rw s ry Ú __complex__zSupportsComplex.__complex__+ r r{ N) r} r~ r r¬ rt rB r Úcomplexr rv r{ ry r! r! & s) á:Ø à × Ñ ð ò ó
|
ñ r{ r! c ó> e Zd ZdZdZej defd« Zy)r z*An ABC with one abstract method __bytes__.rv rf c ó y r rv rw s ry Ú __bytes__zSupportsBytes.__bytes__4 r r{ N) r} r~ r r¬ rt rB r Úbytesr rv r{ ry r r / r r{ r c ó: e Zd ZdZej
|
defd« Zy)r# rv rf c ó y r rv rw s ry Ú __index__zSupportsIndex.__index__< r r{ N)r} r~ r rt rB r ri r rv r{ ry r# r# 8 s& à à × Ñ ð sò ó
|
ñ r{ r# c ó> e Zd ZdZdZej defd« Zy)r z_
|
An ABC with one abstract method __abs__ that is covariant in its return type.
|
rv rf c ó y r rv rw s ry Ú__abs__zSupportsAbs.__abs__G r r{ N) r} r~ r r¬ rt rB r r r rv r{ ry r r @ s- ñ ð à × Ñ ð Tò ó
|
ñ r{ r c óD e Zd ZdZdZej ddedefd« Z y)r% za
|
An ABC with one abstract method __round__ that is covariant in its return type.
|
rv Úndigitsrf c ó y r rv )rx r s ry Ú __round__zSupportsRound.__round__R r r{ N)r )
|
r} r~ r r¬ rt rB r ri r r rv r{ ry r% r% K s4 ñ ð à × Ñ ñ Sð °ò ó
|
ñ r{ r% c ó fd}|S )Nc ó t j j dk( r\t j dk rIt | « t « d}t | j d|« }t j |« | « S | _ | S )NÚpypyr )Ú__call__Ú__mro_entries__rv )
|
r8 Úimplementationr» rx Ú staticmethodrÈ r} rC Úupdate_wrapperr )rî Úcls_dictr Ú mro_entriess ry Úinnerz#_ensure_subclassable.<locals>.innerX sq ø Ü × Ñ × "Ñ " fÒ ,´×1AÑ1AÀFÒ1Jä (¨Ó .Ü#/° Ó#<ñHô T]] B¨Ó1AÜ ×+Ñ+©A«C°Ó6Ð 6à#.DÔ ØKr{ rv )r£ r¤ s ` ry Ú_ensure_subclassabler¥ W s ø ô
|
ð Lr{ FÚmodulec # ó K t | « }|t u rt | « }|r|d } n\y |t u rt t | « \ } n=|t u rt t | « \ } n |t
|
u rt
|
t | « \ } ny wrÝ )r0 r& r/ rH rI rG )Úannotation_typeÚannotation_originÚannotation_argss ry Ú_get_typeddict_qualifiersr« ~ s è ø ØÜ *¨?Ó ;Ð Ø ¤IÑ-Ü"*¨?Ó";Ù"Ø&5°aÑ&8OàØ"¤hÑ.Ü Ü#+¨OÓ#<Ñ Ø"¤kÑ1Ü!Ò!Ü#+¨OÓ#<Ñ Ø"¤hÑ.Ü Ü#+¨OÓ#<Ñ àð% ùs BBc ó( e Zd ZddddZeZd ZeZy)Ú_TypedDictMetaTF©ÚtotalÚclosedc
|
ó |D ]1 }t |« t us|t j us(t d« t d |D « « rt j f}nd}t j t dg |¢t |« }||_ |j dk( r||_ t |d« s||_ i } d|v r|d }
|
nd|v r |d d« }
|
ni }
|
d } t rD|
|
j « D ci c]( \ } } | t j | | |j ¬
|
« * }
|
} } n7|
|
j « D ci c] \ } } | t j | | « }
|
} } t! « }t! « }t! « }t! « }d }|D ]Ê }|j" }| j% |j' di « « |j% |j' d d« « |j% |j' d d« « |j% |j' dd« « |j% |j' dd« « |j' dd « }|É|}Ì |r|t( }|rQd|
|
v rM|
|
j+ d« }t! t- |« « }t. |v r t d« t0 |v r t d« |}| j% |
|
« |
|
j « D ]¿ \ }}t! t- |« « }t. |v r|j3 |« n?t0 |v r|j3 |« n%|r|j3 |« n|j3 |« t4 |v r#|j7 |« |j3 |« |j3 |« |j7 |« Á | |_ t; |« |_ t; |« |_ t; |« |_ t; |« |_! t |d« s||_" ||_# ||_$ |S c c} } w c c} } w )aI Create new typed dict class object.
|
|
This method is called when TypedDict is subclassed,
|
or when TypedDict is instantiated. This way
|
TypedDict supports all three syntax forms described in its docstring.
|
Subclasses and instances of TypedDict return actual dictionaries.
|
zHcannot inherit from both a TypedDict type and a non-TypedDict base classc 3 óP K | ] }t |t j « y wr )rw r
rT ro s ry r z)_TypedDictMeta.__new__.<locals>.<genexpr>¡ s è ø Ò@°Q:a¤§ ¡ ×0Ñ@ùs $&rv r; Ú__orig_bases__r- Ú __annotate__r¼ z?TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type©r¦ NÚ__required_keys__Ú__optional_keys__Ú__readonly_keys__Ú__mutable_keys__Ú__extra_items__z5Special key __extra_items__ does not support Requiredz8Special key __extra_items__ does not support NotRequiredÚ __total__)%rÈ r r
rT r rr r§ Údictr} r Úhasattrr³ Ú _TAKES_MODULEÚitemsr r~ rÍ r0 Úupdater; rE Úpopr« rH rI r rG Údiscardr- rÔ r¶ r· r¸ r¹ r» Ú
|
__closed__rº )r© r» rS Únsr¯ r° r3 Ú generic_baseÚtp_dictr4 Úown_annotationsr ÚnÚtpÚ required_keysÚ optional_keysÚ readonly_keysÚ mutable_keysÚextra_items_typeÚ base_dictÚbase_extra_items_typer¨ Ú
|
qualifiersÚannotation_keys ry r§ z_TypedDictMeta.__new__ s ð ò FÜ:¤^Ò3¸ÄFÇNÁNÒ8RÜ#ð %Eó Fð Fð Fô
|
Ñ@¸%Ô@Ô@Ü &§¡Ð 0 à ! ô ll¤>°:Ð?TÀ Ð?TÌtÑ?TÐVXÓYGØ #GÔ Ø×#Ñ# zÒ1Ø'+Ô$ä7Ð$4Ô5Ø).Ô&à KØ BÑ&Ø"$Ð%6Ñ"7Ø 2Ñ%à"4 " ^Ñ"4°QÓ"7à"$ØSCÝ ð "1×!6Ñ!6Ó!8÷#á 2ð v×)Ñ)¨"¨c¸'×:LÑ:LÔMÑMð#ò #ð "1×!6Ñ!6Ó!8÷#á 2ð v×)Ñ)¨"¨cÓ2Ñ2ð#ñ #ô EMÜ EMÜ EMÜ 5LØ #Ð à ò
|
=Ø MM à×"Ñ" 9§=¡=Ð1BÀBÓ#GÔHØ ×$Ñ$ Y§]¡]Ð3FÈÓ%KÔLØ ×$Ñ$ Y§]¡]Ð3FÈÓ%KÔLØ ×$Ñ$ Y§]¡]Ð3FÈÓ%KÔLØ ×#Ñ# I§M¡MÐ2DÀbÓ$IÔJØ(1¯ © Ð6GÈÓ(NÐ%Ø(Ñ4Ø'<Ñ$ð
|
=ñ Ð*Ð2Ü#(Ð ÙÐ+¨Ñ>Ø"1×"5Ñ"5Ð6GÓ"HÜ Ô!:¸?Ó!KÓ L
|
ÜzÑ)Ü#ð#óð ô *Ñ,Ü#ð&óð ð $3Ð à × Ñ Ô /Ø3B×3HÑ3HÓ3Jò :Ñ/ Ü Ô!:¸?Ó!KÓ L
|
äzÑ)Ø!×%Ñ% nÕ5Ü JÑ.Ø!×%Ñ% nÕ5ÙØ!×%Ñ% nÕ5à!×%Ñ% nÔ5ÜzÑ)Ø ×(Ñ(¨ Ô8Ø!×%Ñ% nÕ5à ×$Ñ$ ^Ô4Ø!×)Ñ)¨.Õ9ð! :ð$ '2GÔ #Ü(1°-Ó(@GÔ %Ü(1°-Ó(@GÔ %Ü(1°-Ó(@GÔ %Ü'0° Ó'>GÔ $Ü7 KÔ0Ø$)Ô!Ø!'GÔ Ø&6GÔ #ØNùóQ#ùó
|
#s Ã+-O6Ä/!O<c ó t d« )Nz4TypedDict does not support instance and class checks©r re s ry r\ z _TypedDictMeta.__subclasscheck__ s äÐ RÓSÐ Sr{ N)r} r~ r r§ r¼ r r\ r rv r{ ry r r s# Ø37Àô n ð` ò Tð .Ñr{ r r rv c ó t fS r )Ú
|
_TypedDict©rS s ry ú<lambda>rØ s ¬¨ r{ r® c ó¾ |t u s|O|t u rd}nd}d| d| d}| d|z dz }t j |t d¬ « |d
|
ur |d ur||d < d
|
}|}n |r t d « |r:t
|
j dk\ r t d« t j dt d¬ « dt |« i}t « } | | |d< t | d|||¬« }
|
t f|
|
_ |
|
S )aq A simple typed namespace. At runtime it is equivalent to a plain dict.
|
|
TypedDict creates a dictionary type such that a type checker will expect all
|
instances to have a certain set of keys, where each key is
|
associated with a value of a consistent type. This expectation
|
is not checked at runtime.
|
|
Usage::
|
|
class Point2D(TypedDict):
|
x: int
|
y: int
|
label: str
|
|
a: Point2D = {'x': 1, 'y': 2, 'label': 'good'} # OK
|
b: Point2D = {'z': 3, 'label': 'bad'} # Fails type check
|
|
assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
|
|
The type info can be accessed via the Point2D.__annotations__ dict, and
|
the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
|
TypedDict supports an additional equivalent form::
|
|
Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
|
|
By default, all keys must be present in a TypedDict. It is possible
|
to override this by specifying totality::
|
|
class Point2D(TypedDict, total=False):
|
x: int
|
y: int
|
|
This means that a Point2D TypedDict can have any of the keys omitted. A type
|
checker is only expected to support a literal False or True as the value of
|
the total argument. True is the default, and makes all items defined in the
|
class body be required.
|
|
The Required and NotRequired special forms can also be used to mark
|
individual keys as being required or not required::
|
|
class Point2D(TypedDict):
|
x: int # the "x" key must always be present (Required is the default)
|
y: NotRequired[int] # the "y" key can be omitted
|
|
See PEP 655 for more details on Required and NotRequired.
|
ú2Failing to pass a value for the 'fields' parameterú(Passing `None` as the 'fields' parameterú`z = TypedDict(z, {})`z is deprecated and will be disallowed in Python 3.15. To create a TypedDict class with 0 fields using the functional syntax, pass an empty dictionary, e.g. r[ r# ©Ú
|
stacklevelFTr° z@TypedDict takes either a dict or keyword arguments, but not bothr@ z$TypedDict takes no keyword argumentsz§The kwargs-based syntax for TypedDict definitions is deprecated in Python 3.11, will be removed in Python 3.13, and may not be understood by third-party type checkers.r- r~ rv r® ) Ú_markerÚwarningsÚwarnÚDeprecationWarningr r8 rx r¼ r? r r r³ ) ÚtypenameÚfieldsr¯ r° r« Údeprecated_thingÚexampleÚdeprecation_msgrÄ r¦ Útds ry r r s* ð` WÑ ØÑ Ø#WÑ à#MÐ à( =°° ¸HÐEGà#Ð$ð %Oð Oð ñ ð ñ Oô
|
MM/Ô+=È!Õ LØUÑ" v°TÑ'9Ø#)xÑ Ø ØFÙ Üð ,ó -ð -á Ü× Ñ 7Ò*Ü Ð FÓGÐGÜ MMð;ô #Ø õ ð ¤ f£ Ð .ÜØ Ð à %B|Ñ ä H b¨"°EÀ&Ô IÜ &LÔØ r{ c óh t t d« r| t j u ryt | t « S )a Check if an annotation is a TypedDict class
|
|
For example::
|
class Film(TypedDict):
|
title: str
|
year: int
|
|
is_typeddict(Film) # => True
|
is_typeddict(Union[list, str]) # => False
|
r F)r½ r
r r Ú_TYPEDDICT_TYPES©rÉ s ry r6 r6 l s, ô 6;Ô '¨B´&×2BÑ2BÑ,BØÜ"Ô .Ó/Ð/r{ r( c ó | S )aÊ Assert (to the type checker) that the value is of the given type.
|
|
When the type checker encounters a call to assert_type(), it
|
emits an error if the value is not of the specified type::
|
|
def greet(name: str) -> None:
|
assert_type(name, str) # ok
|
assert_type(name, int) # type checker error
|
|
At runtime this returns the first argument unchanged and otherwise
|
does nothing.
|
rv )r Útyps ry r( r( s ð
|
r{ rG c óf t | t « rt | j « S t | d« r5| j t
|
t t fv rt | j d « S t | t j « r>t d | j D « « }|| j k( r| S | j |« S t t d« rgt | t j « rMt d | j D « « }|| j k( r| S t j | j |« S t t d« rkt | t j « rQt d | j D « « }|| j k( r| S t! j" t$ j& |« S | S )z=Strips Annotated, Required and NotRequired from a given type.r r c 3 ó2 K | ] }t |« y wr ©Ú _strip_extras©r Úas ry r z _strip_extras.<locals>.<genexpr> ó è ø Ò!G°q¤-°×"2Ñ!Gùó r c 3 ó2 K | ] }t |« y wr rð rò s ry r z _strip_extras.<locals>.<genexpr>¡ rô rõ r c 3 ó2 K | ] }t |« y wr rð rò s ry r z _strip_extras.<locals>.<genexpr>¦ rô rõ )r Ú_AnnotatedAliasrñ r r½ rH rI rG rÀ r
r r r r r r rC ÚreduceÚoperatorÚor_)r Ú stripped_argss ry rñ rñ s> ä a Ô )Ü § ¡ Ó.Ð .Ü 1lÔ #¨¯ © ¼Ä;ÔPXÐ8YÑ(YÜ §¡¨A¡ Ó/Ð /Ü a×-Ñ-Ô .Ü !Ñ!G¸A¿J¹JÔ!GÓ GMØ §
|
¡
|
Ò*ØØ;;}Ó-Ð -Ü 6>Ô *¬z¸!¼V×=PÑ=PÔ/QÜ !Ñ!G¸A¿J¹JÔ!GÓ GMØ §
|
¡
|
Ò*ØÜ×&Ñ& q§|¡|°]ÓCÐ CÜ 6;Ô '¬J°q¼&×:JÑ:JÔ,KÜ !Ñ!G¸A¿J¹JÔ!GÓ GMØ §
|
¡
|
Ò*ØÜ ×#Ñ#¤H§L¡L°-Ó@Ð @àr{ c óô t t d« rt j | ||d¬« }nt j | ||¬« }|r|S |j « D ci c] \ }}|t |« c}}S c c}}w )a Return type hints for an object.
|
|
This is often the same as obj.__annotations__, but it handles
|
forward references encoded as string literals, adds Optional[t] if a
|
default value equal to None is set and recursively replaces all
|
'Annotated[T, ...]', 'Required[T]' or 'NotRequired[T]' with 'T'
|
(unless 'include_extras=True').
|
|
The argument may be a module, class, method, or function. The annotations
|
are returned as a dictionary. For classes, annotations include also
|
inherited members.
|
|
TypeError is raised if the argument is not of a type that can contain
|
annotations, and an empty dictionary is returned if no annotations are
|
present.
|
|
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 (or the respective module's globals for classes),
|
and these are also used as the locals. If the object does not appear
|
to have globals, an empty dictionary is used.
|
|
- 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.
|
r& T)ÚglobalnsÚlocalnsÚinclude_extras)rþ rÿ )r½ r
r3 r¿ rñ )r rþ rÿ r ÚhintÚkr s ry r3 r3 sn ô@ 6;Ô 'Ü×(Ñ(Øh°ÈôDô ×(Ñ(¨°xÈÔQDÙ ØKØ04·
|
±
|
³ ×=©¨¨1= Ó#Ñ#Ó=Ð=ùÓ=s ÁA4r& c ó@ e Zd ZdZ fdZd Zd Zd Zd Zd Z xZ
|
S )rø aK Runtime representation of an annotated type.
|
|
At its core 'Annotated[t, dec1, dec2, ...]' is an alias for the type 't'
|
with extra annotations. The alias behaves like a normal typing alias,
|
instantiating is the same as instantiating the underlying type, binding
|
it to types is also the same.
|
c ó t |t « r|j |z }|j }t | ||« || _ y r )r rø Ú __metadata__r r rÛ )rx r Úmetadatar¡ s ry rÛ z_AnnotatedAlias.__init__è s? ø Ü&¤/Ô2Ø!×.Ñ.°Ñ9Ø ×*Ñ*Ü GÑ V VÔ ,Ø (DÕ r{ c óX t |« dk( sJ |d }t || j « S )Nr¼ r )rß rø r )rx rÄ Únew_types ry r z_AnnotatedAlias.copy_withï s0 Üv; !Ò#Ð #Ð#Ø ayHÜ" 8¨T×->Ñ->Ó?Ð ?r{ c ó dt j | j « ddj d | j D « « dS )Nz typing_extensions.Annotated[ú, c 3 ó2 K | ] }t |« y wr )Úreprrò s ry r z+_AnnotatedAlias.__repr__.<locals>.<genexpr>ö s è ø Ò D¨Q¤ a§Ñ Dùrõ ú])r
Ú
|
_type_reprr Újoinr rw s ry rz z_AnnotatedAlias.__repr__ô sE Ø2´6×3DÑ3DÀTÇ_Á_Ó3UÐ2VÐVXØyyÑ D°$×2CÑ2CÔ DÓDÐEÀQðHð Ir{ c ób t j t | j g| j ¢ffS r )rú Úgetitemr& r r rw s ry Ú
|
__reduce__z_AnnotatedAlias.__reduce__ø s1 Ü×#Ñ#ÜDOOÐ@¨d×.?Ñ.?Ñ@ð&ð ð r{ c ó t |t « st S | j |j k7 ry| j |j k( S )NF)r rø rÌ r r ©rx rÎ s ry rÑ z_AnnotatedAlias.__eq__ý s> Ü e¤_Ô5Ü%Ð%Ø %×"2Ñ"2Ò2Ø Ø×$Ñ$¨×(:Ñ(:Ñ:Ð :r{ c óD t | j | j f« S r )rÓ r r rw s ry rÕ z_AnnotatedAlias.__hash__ s Ü ¨$×*;Ñ*;Ð<Ó=Ð =r{ ) r} r~ r r¬ rÛ r rz r rÑ rÕ r£ r¤ s @ry rø rø à s( ø ñ ô )ò @ò
|
Iò ò
|
;ö >r{ rø c óD e Zd ZdZdZd Zej d « Zd Z y)r& a¡ Add context specific metadata to a type.
|
|
Example: Annotated[int, runtime_check.Unsigned] indicates to the
|
hypothetical runtime_check module that this type is an unsigned int.
|
Every other consumer of this type can ignore this metadata and treat
|
this type as int.
|
|
The first argument to Annotated must be a valid type (and will be in
|
the __origin__ field), the remaining arguments are kept as a tuple in
|
the __extra__ field.
|
|
Details:
|
|
- It's an error to call `Annotated` with less than two arguments.
|
- Nested Annotated are flattened::
|
|
Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3]
|
|
- Instantiating an annotated type is equivalent to instantiating the
|
underlying type::
|
|
Annotated[C, Ann1](5) == C(5)
|
|
- Annotated can be used as a generic type alias::
|
|
Optimized = Annotated[T, runtime.Optimize()]
|
Optimized[int] == Annotated[int, runtime.Optimize()]
|
|
OptimizedList = Annotated[List[T], runtime.Optimize()]
|
OptimizedList[int] == Annotated[List[int], runtime.Optimize()]
|
rv c ó t d« )Nz&Type Annotated cannot be instantiated.rÔ rV s ry r§ zAnnotated.__new__* ó ÜÐ DÓEÐ Er{ c ó t |t « rt |« dk r t d« t t
|
f}t |d « |v r|d }nd}t j |d |« }t |dd « }t ||« S )Nr# zUAnnotated[...] should be used with at least two arguments (a type and an annotation).r z$Annotated[t, ...]: t must be a type.r¼ )
|
r r rß r r r r0 r
r rø )r© rÄ Úallowed_special_formsr r r s ry Ú__class_getitem__zAnnotated.__class_getitem__- s ä f¤eÔ,´°F³ ¸a²Ü ð !/ó 0ð 0ô &.¬uÐ$5Ð !Ü& )Ó$Ð(=Ñ=Ø à<Ü ×+Ñ+¨F°1©I°sÓ;Ü V A BZÓ(HÜ" 6¨8Ó4Ð 4r{ c ó4 t d| j d« )NúCannot subclass z
|
.Annotated)r r~ rV s ry rq zAnnotated.__init_subclass__< s ÜØ" 3§>¡>Ð"2°*Ð=óð r{ N)
|
r} r~ r r¬ rt r§ r
r" r rq rv r{ ry r& r& s4 ñ ð@ ò Fð
|
× Ñ ñ 5ó
|
ð 5ó r{ )Ú_BaseGenericAlias)r c óê t | t « rt S t | t j t
|
t t t f« r | j S | t j u rt j S y)a6 Get the unsubscripted version of a type.
|
|
This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar
|
and Annotated. Return None for unsupported types. Examples::
|
|
get_origin(Literal[42]) is Literal
|
get_origin(int) is None
|
get_origin(ClassVar[int]) is ClassVar
|
get_origin(Generic) is Generic
|
get_origin(Generic[T]) is Generic
|
get_origin(Union[T, int]) is Union
|
get_origin(List[Tuple[T, T]][int]) == list
|
get_origin(P.args) is P
|
N) r rø r& r
r Ú_typing_GenericAliasr r r
|
r rT rë s ry r0 r0 T sY ô b/Ô *Ü Ð Ü b6×/Ñ/Ô1EÔGXÜ(¬/ð;ô <à==Ð Ø Ñ Ü>>Ð !Ør{ c óV t | t « r| j g| j ¢S t | t j
|
t f« r_t | dd« ry| j }t | « t j j u r |d t urt |dd « |d f}|S y)aÆ Get type arguments with all substitutions performed.
|
|
For unions, basic simplifications used by Union constructor are performed.
|
Examples::
|
get_args(Dict[str, int]) == (str, int)
|
get_args(int) == ()
|
get_args(Union[int, Union[T, int], str][int]) == (int, str)
|
get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
|
get_args(Callable[[], T][int]) == ([], int)
|
r Frv r Nr, )r rø r r r
r r ré rÀ r0 rk rB rM ÚEllipsisrÞ )rÉ Úress ry r/ r/ l s ô b/Ô *ØMMÐ4 B§O¡OÑ4Ð 4Ü b6×/Ñ/Ô1EÐFÔ GÜr: uÔ-ØØ++CÜ"~¤§ ¡ ×!9Ñ!9Ñ9¸cÀ!¹fÌHÑ>TÜC H~ s¨2¡wÐ/ØJØr{ r@ c ó t | d« )a& Special marker indicating that an assignment should
|
be recognized as a proper type alias definition by type
|
checkers.
|
|
For example::
|
|
Predicate: TypeAlias = Callable[..., bool]
|
|
It's invalid when used anywhere except as in the example above.
|
ú is not subscriptablerÔ ©rx rà s ry r@ r@ s ô 4&Ð 5Ð6Ó7Ð7r{ a% Special marker indicating that an assignment should
|
be recognized as a proper type alias definition by type
|
checkers.
|
|
For example::
|
|
Predicate: TypeAlias = Callable[..., bool]
|
|
It's invalid when used anywhere except as in the example
|
above.rb c ó e Zd Zd Zy)ÚNoDefaultTypeMetac ó8 t d|d| j « )Nz cannot set z attribute of immutable type ©r r} )r© rø Úvalues ry r
|
z NoDefaultTypeMeta.__setattr__ª s% äØ dXÐ%BÀ3Ç<Á<ÐBRÐSóð r{ N)r} r~ r r
|
rv r{ ry r( r( © s ó r{ r( c ó& e Zd ZdZdZd Zd Zd Zy)Ú NoDefaultTypez$The type of the NoDefault singleton.rv c ób t « j d« xs t j | « S ©Nrb )Úglobalsr; r r§ rh s ry r§ zNoDefaultType.__new__µ s! Ü9== Ó-ÒD´· ± ÀÓ1DÐ Dr{ c ó y)Nztyping_extensions.NoDefaultrv rw s ry rz zNoDefaultType.__repr__¸ s Ø0r{ c ó yr/ rv rw s ry r zNoDefaultType.__reduce__» s Ø r{ N)r} r~ r r¬ rt r§ rz r rv r{ ry r- r- ° s Ù2à ò Eò 1ó r{ r- c ó( fd| _ | _ y )Nc ó t uS r )rb ©Údefaults ry rØ z _set_default.<locals>.<lambda>Ã s ø W´IÐ%= r{ )Ú has_defaultÚ __default__)Ú
|
type_paramr6 s `ry Ú _set_defaultr:  s ø Û =JÔØ $JÕr{ c ó6 t d¬« }|dk7 r|| _ y y )Nrp r= r' )r? r~ )Ú typevarlikeÚdef_mods ry Ú _set_moduler> Ç s" äAÔ GØÐ%Ò%Ø!( Õ ð &r{ c ó e Zd ZdZdZeZy)Ú _DefaultMixinz Mixin for TypeVarLike defaults.rv N)r} r~ r r¬ rt r: rÛ rv r{ ry r@ r@ Î s Ù)àIØHr{ r@ c ó e Zd ZdedefdZy)Ú_TypeVarLikeMetaÚ_TypeVarLikeMeta__instancerf c ó. t || j « S r )r Ú_backported_typevarlike)r© rC s ry r z"_TypeVarLikeMeta.__instancecheck__× s Ü* c×&AÑ&AÓBÐBr{ N)r} r~ r r Úboolr rv r{ ry rB rB Ö s ðC¨3ð C°4ô Cr{ rB )r c óD e Zd ZdZej
|
ZdddedddZddZ y)r zType variable.NF)Úboundr r r6 Úinfer_variancec ó t t d« r t j |g|¢||||d n3t j |g|¢|||d |r|s|r t d« | _ t |« t « fd}| _ S )NrA ©rH r r rI ©rH r r z1Variance cannot be specified with infer_variance.c ó j « r7| j j « t |« k( r|j fz }|S r )r7 Ú__parameters__Úindexrß r8 )Úaliasrª Útypevars ry Ú_tvar_prepare_substz,TypeVar.__new__.<locals>._tvar_prepare_substö sD ø à×'Ñ'Ô)Ø ×,Ñ,×2Ñ2°7Ó;¼sÀ4»yÒHàW× 0Ñ 0Ð 2Ñ2DØ r{ )r½ r
r r< Ú__infer_variance__r: r> Ú__typing_prepare_subst__)
|
r© r» rH r r r6 rI Ú constraintsrR rQ s
|
@ry r§ zTypeVar.__new__ä s¢ ø ô vÔ/ä ..¨ð H° ñ HÀ5Ø3<ÈMØ8FòHô !..¨ð [° ñ [À5Ø3<ÈMò[á!¡y±MÜ$Ð%XÓYÐYØ-;Ô*ä 'Ô *Ü Ô ô ð 0CGÔ ,ØNr{ c ó( t dt d« )Nútype 'z(.TypeVar' is not an acceptable base typer* rh s ry rq zTypeVar.__init_subclass__ s Üf¤X JÐ.VÐ WÓXÐ Xr{ ©rf N)
|
r} r~ r r¬ r
r rE rb r§ rq rv r{ ry r r ß s' Ù à"(§.¡.Ð à37Ø #°5Ø %°eô ô: Yr{ r r c ó e Zd ZdZdZd Zd Zy)Ú
|
_Immutablez3Mixin to indicate that object should not be copied.rv c ó | S r rv rw s ry Ú__copy__z_Immutable.__copy__ ó ØKr{ c ó | S r rv )rx Úmemos ry Ú __deepcopy__z_Immutable.__deepcopy__ r] r{ N)r} r~ r r¬ rt r\ r` rv r{ ry rZ rZ s ÙAØ ò ó r{ rZ c ó" e Zd ZdZd Zd Zd Zy)r aQ The args for a ParamSpec object.
|
|
Given a ParamSpec object P, P.args is an instance of ParamSpecArgs.
|
|
ParamSpecArgs objects have a reference back to their ParamSpec:
|
|
P.args.__origin__ is P
|
|
This type is meant for runtime introspection and has no special meaning to
|
static type checkers.
|
c ó || _ y r ©r ©rx r s ry rÛ zParamSpecArgs.__init__! ó Ø $DOr{ c ó4 | j j dS )Nz.args©r r} rw s ry rz zParamSpecArgs.__repr__$ s Øoo×.Ñ.Ð/¨uÐ5Ð 5r{ c ó` t |t « st S | j |j k( S r )r r rÌ r r s ry rÑ zParamSpecArgs.__eq__' s' Ü e¤]Ô3Ü%Ð%Ø?? e×&6Ñ&6Ñ6Ð 6r{ N©r} r~ r r¬ rÛ rz rÑ rv r{ ry r r s ñ
|
ò %ò 6ó 7r{ c ó" e Zd ZdZd Zd Zd Zy)r
|
a[ The kwargs for a ParamSpec object.
|
|
Given a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs.
|
|
ParamSpecKwargs objects have a reference back to their ParamSpec:
|
|
P.kwargs.__origin__ is P
|
|
This type is meant for runtime introspection and has no special meaning to
|
static type checkers.
|
c ó || _ y r rc rd s ry rÛ zParamSpecKwargs.__init__8 re r{ c ó4 | j j dS )Nz.kwargsrg rw s ry rz zParamSpecKwargs.__repr__; s Øoo×.Ñ.Ð/¨wÐ7Ð 7r{ c ó` t |t « st S | j |j k( S r )r r
|
rÌ r r s ry rÑ zParamSpecKwargs.__eq__> s' Ü e¤_Ô5Ü%Ð%Ø?? e×&6Ñ&6Ñ6Ð 6r{ Nri rv r{ ry r
|
r
|
, s ñ
|
ò %ò 8ó 7r{ r
|
)r r c óD e Zd ZdZej
|
ZddddeddZddZ y)r zParameter specification.NF©rH r r rI r6 c óä t t d« rt j |||||¬« n t j ||||¬« |_ t |« t « fd}|_ S )NrA rK rL c ó | j }|j « }|t |« k( r j « rg |¢j }|t |« k\ rt d| « t |« dk( r$t j |d « s |dk( sJ |f}|S t || t « r g |d | ¢t || « ||dz d ¢}|S )NúToo few arguments for r¼ r ) rN rO rß r7 r8 r r
Ú_is_param_exprr rÞ r )rP rª rÄ ÚiÚ paramspecs ry Ú_paramspec_prepare_substz3ParamSpec.__new__.<locals>._paramspec_prepare_substb sÜ ø Ø ×-Ñ-ØLL Ó+ØD > i×&;Ñ&;Ô&=Ø9TÐ9 9×#8Ñ#8Ð9DØD >Ü#Ð&<¸U¸GÐ$DÓEÐEäv; !Ò#¬F×,AÑ,AÀ$ÀqÁ'Ô,JØ 6M6Ø 7Dð ô Q¡¬Ô.ØET " 1XÐE¤u¨T°!©W£~ÐE¸¸QÀ¹U¸V¸ ÑEDØ r{ )r½ r
r rS r: r> rT ) r© r» rH r r rI r6 rv ru s @ry r§ zParamSpec.__new__P s| ø ô vÔ/ä "× ,Ñ ,¨T¸Ø7@Ø;HØ<Jô L ô
|
#× ,Ñ ,¨T¸Ø7@Ø;Hô J ð 0> Ô,ä GÔ ,Ü Ô "ô ð 2JIÔ .Ø Ð r{ c ó( t dt d« )NrW z*.ParamSpec' is not an acceptable base typer* rh s ry rq zParamSpec.__init_subclass__u s Üf¤X JÐ.XÐ YÓZÐ Zr{ rX )
|
r} r~ r r¬ r
r rE rb r§ rq rv r{ ry r r K s* Ù&à"(×"2Ñ"2Ð à(,Ø #°5Ø#(°)ô# ôJ [r{ c óz e Zd ZdZej
|
Zed « Zed « Z dddde
|
ddZ d Z d Z d
|
Zd Zd Zy) r a' Parameter specification variable.
|
|
Usage::
|
|
P = ParamSpec('P')
|
|
Parameter specification variables exist primarily for the benefit of static
|
type checkers. They are used to forward the parameter types of one
|
callable to another callable, a pattern commonly found in higher order
|
functions and decorators. They are only valid when used in ``Concatenate``,
|
or s the first argument to ``Callable``. In Python 3.10 and higher,
|
they are also supported in user-defined Generics at runtime.
|
See class Generic for more information on generic types. An
|
example for annotating a decorator::
|
|
T = TypeVar('T')
|
P = ParamSpec('P')
|
|
def add_logging(f: Callable[P, T]) -> Callable[P, T]:
|
'''A type-safe decorator to add logging to a function.'''
|
def inner(*args: P.args, **kwargs: P.kwargs) -> T:
|
logging.info(f'{f.__name__} was called')
|
return f(*args, **kwargs)
|
return inner
|
|
@add_logging
|
def add_two(x: float, y: float) -> float:
|
'''Add two numbers together.'''
|
return x + y
|
|
Parameter specification variables defined with covariant=True or
|
contravariant=True can be used to declare covariant or contravariant
|
generic types. These keyword arguments are valid, but their actual semantics
|
are yet to be decided. See PEP 612 for details.
|
|
Parameter specification variables can be introspected. e.g.:
|
|
P.__name__ == 'T'
|
P.__bound__ == None
|
P.__covariant__ == False
|
P.__contravariant__ == False
|
|
Note that only parameter specification variables defined in global scope can
|
be pickled.
|
c ó t | « S r )r rw s ry rª zParamSpec.args® s ä Ó&Ð &r{ c ó t | « S r )r
|
rw s ry r« zParamSpec.kwargs² s ä" 4Ó(Ð (r{ NFro c óD t j | | g« || _ t |« | _ t |« | _ t |« | _ |r t j |d« | _ nd | _ t j | |« t « }|dk7 r|| _ y y )NzBound must be a type.r' ) rÞ rÛ r} rF Ú __covariant__Ú__contravariant__rS r
r Ú __bound__r@ r? r~ )rx r» rH r r rI r6 r= s ry rÛ zParamSpec.__init__¶ s ä MM$ Ô 'Ø DMÜ!% i£ DÔ Ü%)¨-Ó%8DÔ "Ü&*¨>Ó&:DÔ #ÙÜ!'×!3Ñ!3°EÐ;RÓ!Sà!%Ü × "Ñ " 4¨Ô 1ô iGØÐ-Ò-Ø")ð .r{ c ó~ | j rd}n | j rd}n| j rd}nd}|| j z S )NÚ ú+ú-ú~)rS r| r} r} )rx Úprefixs ry rz zParamSpec.__repr__È s@ Ø×&Ò&ØØ×#Ò#Ø Ø×'Ò'Ø à ØDMMÑ)Ð )r{ c ó, t j | « S r ©r rÕ rw s ry rÕ zParamSpec.__hash__Ó ó Ü?? 4Ó(Ð (r{ c ó
|
| |u S r rv r s ry rÑ zParamSpec.__eq__Ö ó Ø5=Ð r{ c ó | j S r ©r} rw s ry r zParamSpec.__reduce__Ù ó Ø==Ð r{ c ó y r rv rG s ry r zParamSpec.__call__Ý ó Ø r{ )r} r~ r r¬ r
r r¡ Úpropertyrª r« rb rÛ rz rÕ rÑ r r rv r{ ry r r | se ñ, ð^ NN à ñ 'ó
|
ð 'ð
|
ñ )ó
|
ð )ð +/¸%ÈuØ$)°9ô *ò$ *ò )ò !ò !ó r{ r c ó\ e Zd Zej ZdZ fdZd Zd Z d Z
|
e d « Z xZ S )Ú_ConcatenateGenericAliasFc ó@ t | |« || _ || _ y r )r rÛ r rÀ )rx r rª r¡ s ry rÛ z!_ConcatenateGenericAlias.__init__ì s ø Ü GÑ TÔ "Ø $DOØ DMr{ c ó t j | j « ddj fd| j D « « dS )Nú[r
|
c 3 ó. K | ] } |« y wr rv )r rK r s ry r z4_ConcatenateGenericAlias.__repr__.<locals>.<genexpr>ô s øè ø Ò!K°c¡*¨S§/Ñ!Kùs r )r
r r r rÀ )rx r s @ry rz z!_ConcatenateGenericAlias.__repr__ñ sF ø Ü ×*Ñ*JÙ! $§/¡/Ó2Ð3Ø Ó!K¸T¿]¹]Ô!KÓKÐLÈAðOð Pr{ c óD t | j | j f« S r )rÓ r rÀ rw s ry rÕ z!_ConcatenateGenericAlias.__hash__ö s Ü ¨$¯-©-Ð8Ó9Ð 9r{ c ó y r rv rG s ry r z!_ConcatenateGenericAlias.__call__ú r r{ c ó: t d | j D « « S )Nc 3 ób K | ]' }t |t j t f« s$| ) y wr )r r
r r )r rÉ s ry r z:_ConcatenateGenericAlias.__parameters__.<locals>.<genexpr>ÿ s' è ø ò جj¸¼f¿n¹nÌiÐ=XÕ.Yñùs %/¨/)r rÀ rw s ry rN z'_ConcatenateGenericAlias.__parameters__ý s äñ Ø !]]ôó ð r{ )r} r~ r r
r r¡ r rÛ rz rÕ r r rN r£ r¤ s @ry r r ä s@ ø ð ×(Ñ( ð ô !ò
|
Pò
|
:ò ð
|
ñ ó
|
ô r{ r c óÊ |dk( r t d« t |t « s|f}t |d t « s t d« dt fd|D « « }t | |« S )Nrv z&Cannot take a Concatenate of no types.r, zAThe last parameter to Concatenate should be a ParamSpec variable.z/Concatenate[arg, ...]: each arg must be a type.c 3 óJ K | ] }t j |« y wr r r s ry r z'_concatenate_getitem.<locals>.<genexpr> s øè ø ÒF°av×)Ñ)¨!¨S×1ÑFùr )r r r r r )rx rà r s @ry Ú_concatenate_getitemr sj ø àRÒÜÐ@ÓAÐAÜ j¤%Ô (Ø ]
|
Ü j n¤iÔ 0Üð .ó /ð /à
|
;CÜÓF¸:ÔFÓFJÜ # D¨*Ó 5Ð5r{ c ó t | |« S )á& Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
|
higher order function which adds, removes or transforms parameters of a
|
callable.
|
|
For example::
|
|
Callable[Concatenate[int, P], int]
|
|
See PEP 612 for detailed information.
|
©r r& s ry r r s ô $ D¨*Ó5Ð5r{ c ó e Zd Zd Zy)Ú_ConcatenateFormc ó t | |« S r r r& s ry rå z _ConcatenateForm.__getitem__) s Ü'¨¨jÓ9Ð 9r{ N©r} r~ r rå rv r{ ry r¡ r¡ ( s ó :r{ r¡ r rB c ób t j || d« }t j | |f« S )á Special typing form used to annotate the return type of a user-defined
|
type guard function. ``TypeGuard`` only accepts a single type argument.
|
At runtime, functions marked this way should return a boolean.
|
|
``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
|
type checkers to determine a more precise type of an expression within a
|
program's code flow. Usually type narrowing is done by analyzing
|
conditional code flow and applying the narrowing to a block of code. The
|
conditional expression here is sometimes referred to as a "type guard".
|
|
Sometimes it would be convenient to use a user-defined boolean function
|
as a type guard. Such a function should use ``TypeGuard[...]`` as its
|
return type to alert static type checkers to this intention.
|
|
Using ``-> TypeGuard`` tells the static type checker that for a given
|
function:
|
|
1. The return value is a boolean.
|
2. If the return value is ``True``, the type of its argument
|
is the type inside ``TypeGuard``.
|
|
For example::
|
|
def is_str(val: Union[str, float]):
|
# "isinstance" type guard
|
if isinstance(val, str):
|
# Type of ``val`` is narrowed to ``str``
|
...
|
else:
|
# Else, type of ``val`` is narrowed to ``float``.
|
...
|
|
Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
|
form of ``TypeA`` (it can even be a wider form) and this may lead to
|
type-unsafe results. The main reason is to allow for things like
|
narrowing ``List[object]`` to ``List[str]`` even though the latter is not
|
a subtype of the former, since ``List`` is invariant. The responsibility of
|
writing type-safe type guards is left to the user.
|
|
``TypeGuard`` also works with type variables. For more information, see
|
PEP 647 (User-Defined Type Guards).
|
ú accepts only a single type.©r
r r ©rx rà Úitems ry rB rB > s4 ôX ×!Ñ! *°°Ð6RÐ.SÓTÜ×#Ñ# D¨4¨'Ó2Ð2r{ c ó e Zd Zd Zy)Ú_TypeGuardFormc óv t j || j d« }t j | |f« S ©Nz accepts only a single type©r
r r³ r r¨ s ry rå z_TypeGuardForm.__getitem__o ó9 Ü×%Ñ% jØ)-¯©¨ Ð4OÐ&PóRDä×'Ñ'¨¨t¨gÓ6Ð 6r{ Nr£ rv r{ ry r« r« n ó ó 7r{ r« r¥ rC c ób t j || d« }t j | |f« S )áz Special typing form used to annotate the return type of a user-defined
|
type narrower function. ``TypeIs`` only accepts a single type argument.
|
At runtime, functions marked this way should return a boolean.
|
|
``TypeIs`` aims to benefit *type narrowing* -- a technique used by static
|
type checkers to determine a more precise type of an expression within a
|
program's code flow. Usually type narrowing is done by analyzing
|
conditional code flow and applying the narrowing to a block of code. The
|
conditional expression here is sometimes referred to as a "type guard".
|
|
Sometimes it would be convenient to use a user-defined boolean function
|
as a type guard. Such a function should use ``TypeIs[...]`` as its
|
return type to alert static type checkers to this intention.
|
|
Using ``-> TypeIs`` tells the static type checker that for a given
|
function:
|
|
1. The return value is a boolean.
|
2. If the return value is ``True``, the type of its argument
|
is the intersection of the type inside ``TypeGuard`` and the argument's
|
previously known type.
|
|
For example::
|
|
def is_awaitable(val: object) -> TypeIs[Awaitable[Any]]:
|
return hasattr(val, '__await__')
|
|
def f(val: Union[int, Awaitable[int]]) -> int:
|
if is_awaitable(val):
|
assert_type(val, Awaitable[int])
|
else:
|
assert_type(val, int)
|
|
``TypeIs`` also works with type variables. For more information, see
|
PEP 742 (Narrowing types with TypeIs).
|
r¦ r§ r¨ s ry rC rC ¦ s4 ôL ×!Ñ! *°°Ð6RÐ.SÓTÜ×#Ñ# D¨4¨'Ó2Ð2r{ c ó e Zd Zd Zy)Ú _TypeIsFormc óv t j || j d« }t j | |f« S r r® r¨ s ry rå z_TypeIsForm.__getitem__Ñ r¯ r{ Nr£ rv r{ ry r´ r´ Ð r° r{ r´ r² c óp e Zd ZdZd Zd Zd Zd Zd Zd Z d Z
|
d Z d
|
Z d Z ej d « Zy )Ú _SpecialForm)r³ r¬ Ú_getitemc óV || _ |j | _ |j | _ y r )r¸ r} r³ r¬ )rx r s ry rÛ z_SpecialForm.__init__ s! Ø Ø ×%Ñ%
|
Ø r{ c ó8 |dv r | j S t |« )N> r} r )r³ r· )rx r© s ry Ú __getattr__z_SpecialForm.__getattr__ s Ø Ð/Ñ /Ø::Ð ä TÓ"Ð"r{ c ó t d| « )Nr rÔ )rx rS s ry r z _SpecialForm.__mro_entries__ s ÜÐ*¨4¨(Ð3Ó4Ð4r{ c ó d| j S r± r² rw s ry rz z_SpecialForm.__repr__ s Ø# D§J¡J <Ð0Ð0r{ c ó | j S r r² rw s ry r z_SpecialForm.__reduce__ s ØzzÐr{ c ó t d| « )NzCannot instantiate rÔ ©rx rª Úkwdss ry r z_SpecialForm.__call__ s ÜÐ-¨d¨XÐ6Ó7Ð7r{ c ó, t j | |f S r ©r
rk r s ry Ú__or__z_SpecialForm.__or__ s Ü||D %KÑ(Ð(r{ c ó, t j || f S r rà r s ry Ú__ror__z_SpecialForm.__ror__ s Ü||E 4KÑ(Ð(r{ c ó t | d« )Nz! cannot be used with isinstance()rÔ ©rx r s ry r z _SpecialForm.__instancecheck__ ó Ü4&Ð AÐBÓCÐCr{ c ó t | d« )Nz! cannot be used with issubclass()rÔ )rx r© s ry r\ z _SpecialForm.__subclasscheck__" rÉ r{ c ó& | j | |« S r )r¸ r& s ry rå z_SpecialForm.__getitem__% s à}}T :Ó.Ð.r{ N)r} r~ r rt rÛ r» r rz r r rÄ rÆ r r\ r
r" rå rv r{ ry r· r· ÿ sU Ø0Iò'ò
|
#ò 5ò1òò8ò)ò)òDòDð ×Ññ/ó ñ/r{ r· r c ó t | d« )aD Represents an arbitrary literal string.
|
|
Example::
|
|
from typing_extensions import LiteralString
|
|
def query(sql: LiteralString) -> ...:
|
...
|
|
query("SELECT * FROM table") # ok
|
query(f"SELECT * FROM {input()}") # not ok
|
|
See PEP 675 for details.
|
|
r% rÔ ©rx rÄ s ry r r - s ô" 4&Ð 5Ð6Ó7Ð7r{ r c ó t | d« )zòUsed to spell the type of "self" in classes.
|
|
Example::
|
|
from typing import Self
|
|
class ReturnsSelf:
|
def parse(self, data: bytes) -> Self:
|
...
|
return self
|
|
r% rÔ rÍ s ry r r D s ô 4&Ð 5Ð6Ó7Ð7r{ rE c ó t | d« )a¬ The bottom type, a type that has no members.
|
|
This can be used to define a function that should never be
|
called, or a function that never returns::
|
|
from typing_extensions import Never
|
|
def never_call_me(arg: Never) -> None:
|
pass
|
|
def int_or_str(arg: int | str) -> None:
|
never_call_me(arg) # type checker error
|
match arg:
|
case int():
|
print("It's an int")
|
case str():
|
print("It's a str")
|
case _:
|
never_call_me(arg) # ok, arg is of type Never
|
|
r% rÔ rÍ s ry rE rE Y s ô0 4&Ð 5Ð6Ó7Ð7r{ rH c óv t j || j d« }t j | |f« S )áê A special typing construct to mark a key of a total=False TypedDict
|
as required. For example:
|
|
class Movie(TypedDict, total=False):
|
title: Required[str]
|
year: int
|
|
m = Movie(
|
title='The Matrix', # typechecker error if key is omitted
|
year=1999,
|
)
|
|
There is no runtime checking that a required key is actually provided
|
when instantiating a related TypedDict.
|
r¦ r® r¨ s ry rH rH x s7 ô" ×!Ñ! *°·±° Ð<XÐ.YÓZÜ×#Ñ# D¨4¨'Ó2Ð2r{ c óv t j || j d« }t j | |f« S )á` A special typing construct to mark a key of a TypedDict as
|
potentially missing. For example:
|
|
class Movie(TypedDict):
|
title: str
|
year: NotRequired[int]
|
|
m = Movie(
|
title='The Matrix', # typechecker error if key is omitted
|
year=1999,
|
)
|
r¦ r® r¨ s ry rI rI s7 ô ×!Ñ! *°·±° Ð<XÐ.YÓZÜ×#Ñ# D¨4¨'Ó2Ð2r{ c ó e Zd Zd Zy)Ú _RequiredFormc óv t j || j d« }t j | |f« S ©Nr¦ r® r¨ s ry rå z_RequiredForm.__getitem__ ó9 Ü×%Ñ% jØ)-¯©¨ Ð4PÐ&QóSDä×'Ñ'¨¨t¨gÓ6Ð 6r{ Nr£ rv r{ ry rÕ rÕ r° r{ rÕ rÑ rI rÓ c óv t j || j d« }t j | |f« S )a A special typing construct to mark an item of a TypedDict as read-only.
|
|
For example:
|
|
class Movie(TypedDict):
|
title: ReadOnly[str]
|
year: int
|
|
def mutate_movie(m: Movie) -> None:
|
m["year"] = 1992 # allowed
|
m["title"] = "The Matrix" # typechecker error
|
|
There is no runtime checking for this property.
|
r¦ r® r¨ s ry rG rG È s7 ô ×!Ñ! *°·±° Ð<XÐ.YÓZÜ×#Ñ# D¨4¨'Ó2Ð2r{ c ó e Zd Zd Zy)Ú _ReadOnlyFormc óv t j || j d« }t j | |f« S r× r® r¨ s ry rå z_ReadOnlyForm.__getitem__Ý rØ r{ Nr£ rv r{ ry rÛ rÛ Ü r° r{ rÛ a A special typing construct to mark a key of a TypedDict as read-only.
|
|
For example:
|
|
class Movie(TypedDict):
|
title: ReadOnly[str]
|
year: int
|
|
def mutate_movie(m: Movie) -> None:
|
m["year"] = 1992 # allowed
|
m["title"] = "The Matrix" # typechecker error
|
|
There is no runtime checking for this propery.
|
aÜ Type unpack operator.
|
|
The type unpack operator takes the child types from some container type,
|
such as `tuple[int, str]` or a `TypeVarTuple`, and 'pulls them out'. For
|
example:
|
|
# For some generic class `Foo`:
|
Foo[Unpack[tuple[int, str]]] # Equivalent to Foo[int, str]
|
|
Ts = TypeVarTuple('Ts')
|
# Specifies that `Bar` is generic in an arbitrary number of types.
|
# (Think of `Ts` as a tuple of an arbitrary number of individual
|
# `TypeVar`s, which the `Unpack` is 'pulling out' directly into the
|
# `Generic[]`.)
|
class Bar(Generic[Unpack[Ts]]): ...
|
Bar[int] # Valid
|
Bar[int, str] # Also valid
|
|
From Python 3.11, this can also be done using the `*` operator:
|
|
Foo[*tuple[int, str]]
|
class Bar(Generic[*Ts]): ...
|
|
The operator can also be used along with a `TypedDict` to annotate
|
`**kwargs` in a function signature. For instance:
|
|
class Movie(TypedDict):
|
name: str
|
year: int
|
|
# This function expects two keyword arguments - *name* of type `str` and
|
# *year* of type `int`.
|
def foo(**kwargs: Unpack[Movie]): ...
|
|
Note that there is only some runtime checking of this operator. Not
|
everything the runtime allows may be accepted by static type checkers.
|
|
For more information, see PEP 646 and PEP 692.
|
c ó$ t | « t u S r )r0 r ©r s ry Ú
|
_is_unpackrß ! s Ü#¤&Ð(Ð(r{ c ó e Zd Z fdZ xZS )Ú_UnpackSpecialFormc ó: t | |« t | _ y r )r rÛ Ú _UNPACK_DOCr¬ )rx r r¡ s ry rÛ z_UnpackSpecialForm.__init__& s ø Ü GÑ WÔ %Ü&DLr{ )r} r~ r rÛ r£ r¤ s @ry rá rá % s ø ÷ 'ð 'r{ rá c ó4 e Zd Zej Zed « Zy)Ú _UnpackAliasc ó" | j t u sJ t | j « dk( sJ | j \ }t |t
|
j t j f« r)|j t ur t d« |j S y )Nr¼ z*Unpack[...] must be used with a tuple type) r r rß rÀ r r
r r r r r )rx rK s ry Ú __typing_unpacked_tuple_args__z+_UnpackAlias.__typing_unpacked_tuple_args__- sv à??¤fÑ,Ð ,Ð,Üt}}Ó%¨Ò*Ð *Ð*Ø==DCÜ#¤× 4Ñ 4´f×6IÑ6IÐ JÔKØ>>¬Ñ.Ü#Ð$PÓQÐQØ||Ð#Ør{ N)r} r~ r r
r r¡ r rç rv r{ ry rå rå * s ØNN à ñ ó
|
ñ r{ rå c ób t j || j d« }t | |f« S r× ©r
r r³ rå r¨ s ry r r 8 s/ ä×!Ñ! *°·±° Ð<XÐ.YÓZÜD 4 'Ó*Ð*r{ c ó" t | t « S r ©r rå rÞ s ry rß rß = ó Ü#|Ó,Ð,r{ c ó$ e Zd Zej Zy)rå N)r} r~ r r
r r¡ rv r{ ry rå rå A s ØNN r{ c ó e Zd Zd Zy)Ú _UnpackFormc ób t j || j d« }t | |f« S r× ré r¨ s ry rå z_UnpackForm.__getitem__E s3 Ü×%Ñ% jØ)-¯©¨ Ð4PÐ&QóSDä t gÓ.Ð .r{ Nr£ rv r{ ry rï rï D s ó /r{ rï r c ó" t | t « S r rë rÞ s ry rß rß L rì r{ )r r c ó g }| D ]= }t |dd « }||r|d du s|j |« -|j |« ? |S )Nrç r, .)ré r¿ rÁ )rª ÚnewargsrK Úsubargss ry Ú _unpack_argsrõ U sW ØØò $CÜ cÐ#CÀTÓJGØÐ"©G¸À¹ ÀsÑ8JØwÕ'àsÕ#ð $ð r{ c ó: e Zd ZdZej
|
ZeddZd Z y)r zType variable tuple.r5 c óx t j |« t |« t « fd}|_ S )Nc óà | j }|j « }||dz d D ] }t |t « st d| « t |« }t |« }|}||z
|
dz
|
}d } d }
|
t |« D ]Q \ } } t | t « rt | dd « } | s't | « dk( s6| d du s>| t d« | } | d }
|
S | t || « }t ||| z
|
dz
|
« }n ||z |kD rt d | d
|
| d |dz
|
« |||z
|
k( r&j « rt j « }n||||z
|
}g |d | ¢|
|
g||z
|
z ¢||
|
g||z
|
|z
|
|z
|
dz
|
z ¢|||z
|
d ¢S ) Nr¼ z(More than one TypeVarTuple parameter in rç r# r, .z6More than one unpacked arbitrary-length tuple argumentr rr r z, expected at least ) rN rO r r r rß Ú enumeraterÈ ré Úminr7 rõ r8 )rP rª rÄ Útypevartuple_indexÚparamÚalenÚplenÚleftÚrightÚvar_tuple_indexÚfillargr rK rô Ú replacementÚtvts ry Ú_typevartuple_prepare_substz9TypeVarTuple.__new__.<locals>._typevartuple_prepare_substj s ø Ø ×-Ñ-Ø%+§\¡\°#Ó%6Ð"Ø #Ð$6¸Ñ$:Ð$;Ð <ò EÜ! %¬ Õ6Ü 'Ø FÀuÀgÐ Nó ð ðô 4yÜ6{Ø)Ø Ð 1Ñ1°AÑ5Ø"&Ø Ü '¨oò
|
1FAsÜ% c¬4Õ0Ü")¨#Ð/OÐQUÓ"VÚ"¤s¨7£|°qÓ'8¸WÀR¹[ÈCÒ=OØ .Ð :Ü&/ð%Fó'"ð !"ð /0OØ&-¨a¡jGð
|
1ð #Ð.Ü t _Ó5DÜ t¨oÑ'=ÀÑ'AÓ BEØE\ DÒ(Ü#Ð&<¸U¸Gð D/Ø/3¨fÐ4HÈÐPQÉÈ
|
ð%Tó Uð Uà4 %<Ò'¨C¯O©OÔ,=Ü".¨s¯©Ó"?Kà"& t¨T°E©\Ð":KðØ%4[ðà iÐ#5¸Ñ#<Ñ=ðð ðð i 4¨%¡<°$Ñ#6Ð9KÑ#KÈaÑ#OÑPð ð
|
$ ,-Ð(ñ ð r{ )r
r r: r> rT )r© r» r6 r r s @ry r§ zTypeVarTuple.__new__e s; ø Ü×%Ñ% dÓ+CÜ gÔ &Ü Ô ô+ ðZ ,GCÔ (ØJr{ c ó t d« )Nú&Cannot subclass special typing classesrÔ rÀ s ry rq z TypeVarTuple.__init_subclass__ r r{ N)
|
r} r~ r r¬ r
r rE rb r§ rq rv r{ ry r r ` s Ù"à"(×"5Ñ"5Ð à*3ô 3 ój Fr{ c óX e Zd ZdZej
|
Zd ZeddZ d Z
|
d Z d Z d Z d Zy
|
) r aÅ Type variable tuple.
|
|
Usage::
|
|
Ts = TypeVarTuple('Ts')
|
|
In the same way that a normal type variable is a stand-in for a single
|
type such as ``int``, a type variable *tuple* is a stand-in for a *tuple*
|
type such as ``Tuple[int, str]``.
|
|
Type variable tuples can be used in ``Generic`` declarations.
|
Consider the following example::
|
|
class Array(Generic[*Ts]): ...
|
|
The ``Ts`` type variable tuple here behaves like ``tuple[T1, T2]``,
|
where ``T1`` and ``T2`` are type variables. To use these type variables
|
as type parameters of ``Array``, we must *unpack* the type variable tuple using
|
the star operator: ``*Ts``. The signature of ``Array`` then behaves
|
as if we had simply written ``class Array(Generic[T1, T2]): ...``.
|
In contrast to ``Generic[T1, T2]``, however, ``Generic[*Shape]`` allows
|
us to parameterise the class with an *arbitrary* number of type parameters.
|
|
Type variable tuples can be used anywhere a normal ``TypeVar`` can.
|
This includes class definitions, as shown above, as well as function
|
signatures and variable annotations::
|
|
class Array(Generic[*Ts]):
|
|
def __init__(self, shape: Tuple[*Ts]):
|
self._shape: Tuple[*Ts] = shape
|
|
def get_shape(self) -> Tuple[*Ts]:
|
return self._shape
|
|
shape = (Height(480), Width(640))
|
x: Array[Height, Width] = Array(shape)
|
y = abs(x) # Inferred type is Array[Height, Width]
|
z = x + x # ... is Array[Height, Width]
|
x.get_shape() # ... is tuple[Height, Width]
|
|
c # ó( K | j y wr )Ú __unpacked__rw s ry Ú__iter__zTypeVarTuple.__iter__Í s è ø Ø×#Ñ#Ó #ùs r5 c ó || _ t j | |« t « }|dk7 r|| _ t
|
| | _ y )Nr' )r} r@ rÛ r? r~ r r
|
)rx r» r6 r= s ry rÛ zTypeVarTuple.__init__Ð s> Ø DMÜ × "Ñ " 4¨Ô 1ô iGØÐ-Ò-Ø")ä & t¡ DÕ r{ c ó | j S r r rw s ry rz zTypeVarTuple.__repr__Û r r{ c ó, t j | « S r r rw s ry rÕ zTypeVarTuple.__hash__Þ r r{ c ó
|
| |u S r rv r s ry rÑ zTypeVarTuple.__eq__á r r{ c ó | j S r r rw s ry r zTypeVarTuple.__reduce__ä r r{ c ó" d|vr t d« y )Nr´ r rÔ rÀ s ry rq z TypeVarTuple.__init_subclass__ç s ØdÑ"Ü Ð HÓIÐIð #r{ N)r} r~ r r¬ r
r r¡ r rb rÛ rz rÕ rÑ r rq rv r{ ry r r s< ñ) ðX NN ò $ð -6ô -ò !ò )ò !ò !ó Jr{ r< r rf c óh t dt | « j t j ¬« | S )aç Reveal the inferred type of a variable.
|
|
When a static type checker encounters a call to ``reveal_type()``,
|
it will emit the inferred type of the argument::
|
|
x: int = 1
|
reveal_type(x)
|
|
Running a static type checker (e.g., ``mypy``) on this example
|
will produce output similar to 'Revealed type is "builtins.int"'.
|
|
At runtime, the function prints the runtime type of the
|
argument and returns it unchanged.
|
|
zRuntime type is )Úfile)ÚprintrÈ r} r8 ÚstderrrÞ s ry r< r< ï s* ô Ð ¤ c£×!3Ñ!3Ð 6Ð7¼c¿j¹jÕIØ
|
r{ Ú _ASSERT_NEVER_REPR_MAX_LENGTHéd r' rK c óp t | « }t |« t kD r |dt dz }t d| « )a1 Assert to the type checker that a line of code is unreachable.
|
|
Example::
|
|
def int_or_str(arg: int | str) -> None:
|
match arg:
|
case int():
|
print("It's an int")
|
case str():
|
print("It's a str")
|
case _:
|
assert_never(arg)
|
|
If a type checker finds that a call to assert_never() is
|
reachable, it will emit an error.
|
|
At runtime, this throws an exception when called.
|
|
Nz...z*Expected code to be unreachable, but got: )r rß r ÚAssertionError)rK r+ s ry r' r'
|
s@ ô( S Ü u:Ô5Ò 5ØÐ8Ô8Ð9¸EÑAEÜ Ð IÈ%ÈÐ QÓRÐRr{ )Ú
|
eq_defaultÚ order_defaultÚkw_only_defaultÚfrozen_defaultÚfield_specifiersr r r r r .r« c ó& fd}|S )a¥ Decorator that marks a function, class, or metaclass as providing
|
dataclass-like behavior.
|
|
Example:
|
|
from typing_extensions import dataclass_transform
|
|
_T = TypeVar("_T")
|
|
# Used on a decorator function
|
@dataclass_transform()
|
def create_model(cls: type[_T]) -> type[_T]:
|
...
|
return cls
|
|
@create_model
|
class CustomerModel:
|
id: int
|
name: str
|
|
# Used on a base class
|
@dataclass_transform()
|
class ModelBase: ...
|
|
class CustomerModel(ModelBase):
|
id: int
|
name: str
|
|
# Used on a metaclass
|
@dataclass_transform()
|
class ModelMeta(type): ...
|
|
class ModelBase(metaclass=ModelMeta): ...
|
|
class CustomerModel(ModelBase):
|
id: int
|
name: str
|
|
Each of the ``CustomerModel`` classes defined in this example will now
|
behave similarly to a dataclass created with the ``@dataclasses.dataclass``
|
decorator. For example, the type checker will synthesize an ``__init__``
|
method.
|
|
The arguments to this decorator can be used to customize this behavior:
|
- ``eq_default`` indicates whether the ``eq`` parameter is assumed to be
|
True or False if it is omitted by the caller.
|
- ``order_default`` indicates whether the ``order`` parameter is
|
assumed to be True or False if it is omitted by the caller.
|
- ``kw_only_default`` indicates whether the ``kw_only`` parameter is
|
assumed to be True or False if it is omitted by the caller.
|
- ``frozen_default`` indicates whether the ``frozen`` parameter is
|
assumed to be True or False if it is omitted by the caller.
|
- ``field_specifiers`` specifies a static list of supported classes
|
or functions that describe fields, similar to ``dataclasses.field()``.
|
|
At runtime, this decorator records its arguments in the
|
``__dataclass_transform__`` attribute on the decorated object.
|
|
See PEP 681 for details.
|
|
c ó$ d| _ | S )N)r r r r r r« )Ú__dataclass_transform__)Ú cls_or_fnr r r r r« r s ry Ú decoratorz&dataclass_transform.<locals>.decorators
|
s' ø à (Ø!.Ø#2Ø"0Ø$4Ø ñ 1IÔ -ð Ð r{ rv )r r r r r r« r# s `````` ry r* r* *
|
s ý ÷R ñ ð Ðr{ r: Ú_F)rH c óB d| _ | S # t t f$ r Y | S w xY w)aH Indicate that a method is intended to override a method in a base class.
|
|
Usage:
|
|
class Base:
|
def method(self) -> None:
|
pass
|
|
class Child(Base):
|
@override
|
def method(self) -> None:
|
super().method()
|
|
When this decorator is applied to a method, the type checker will
|
validate that it overrides a method with the same name on a base class.
|
This helps prevent bugs that may occur when a base class is changed
|
without an equivalent change to a child class.
|
|
There is no runtime checking of these properties. The decorator
|
sets the ``__override__`` attribute to ``True`` on the decorated object
|
to allow runtime introspection.
|
|
See PEP 698 for details.
|
|
T)Ú __override__r· r rJ s ry r: r:
|
s6 ð4 Ø #CÔ ð
|
øô ¤ Ð*ò ð Ø
|
ð úr¹ r+ Ú_Tc ót e Zd ZdZedddedej ej e de
|
ddfd Z d
|
e de fd Z y) r+ a Indicate that a class, function or overload is deprecated.
|
|
When this decorator is applied to an object, the type checker
|
will generate a diagnostic on usage of the deprecated object.
|
|
Usage:
|
|
@deprecated("Use B instead")
|
class A:
|
pass
|
|
@deprecated("Use g instead")
|
def f():
|
pass
|
|
@overload
|
@deprecated("int support is deprecated")
|
def g(x: int) -> int: ...
|
@overload
|
def g(x: str) -> int: ...
|
|
The warning specified by *category* will be emitted at runtime
|
on use of deprecated objects. For functions, that happens on calls;
|
for classes, on instantiation and on creation of subclasses.
|
If the *category* is ``None``, no warning is emitted at runtime.
|
The *stacklevel* determines where the
|
warning is emitted. If it is ``1`` (the default), the warning
|
is emitted at the direct caller of the deprecated object; if it
|
is higher, it is emitted further up the stack.
|
Static type checker behavior is not affected by the *category*
|
and *stacklevel* arguments.
|
|
The deprecation message passed to the decorator is saved in the
|
``__deprecated__`` attribute on the decorated object.
|
If applied to an overload, the decorator
|
must be after the ``@overload`` decorator for the attribute to
|
exist on the overload as returned by ``get_overloads()``.
|
|
See PEP 702 for details.
|
|
r¼ ©ÚcategoryrÞ Úmessager* rÞ rf Nc ó t |t « s!t dt |« j « || _ || _ || _ y )Nz2Expected an object of type str for 'message', not )r ræ r rÈ r} r+ r* rÞ )rx r+ r* rÞ s ry rÛ zdeprecated.__init__Ø
|
sJ ô g¤sÔ+Ü ØHÜG}×-Ñ-Ð0ð2óð ð #DLØ $DMØ (DOr{ rK c óÂ
|
| j | j | j _ S t t
|
« rÑdd l}ddlm} j
|
|j
|
«
|
fd« }t |« _ j t |« r: j |j « fd« }t |« _ n$ |j « fd« }|_ x_ |_ |_ S t « r1dd l} |j « fd« }x_ |_ |S t! d« )Nr )Ú
|
MethodTypec óþ | u rt j dz ¬« t j ur | g|¢i |¤S | j t j u r |s|rt | j d« | « S )Nr¼ r) z() takes no arguments)rà rá r r§ rÛ r r} )r© rª r« rK r* r Ú original_newrÞ s ry r§ z$deprecated.__call__.<locals>.__new__ø
|
sv ø àczÜ c°HÈÐVWÉ ÕXØ#¬6¯>©>Ñ9Ù +¨CÐ A°$Ò A¸&Ñ AÐAà ¬¯ © Ñ8¹dÁfÜ '¨3¯<©<¨.Ð8MÐ(NÓ OÐOá +¨CÓ 0Ð0r{ c óJ t j dz ¬« | i |¤S ©Nr¼ r) ©rà rá ©rª r« r* r Úoriginal_init_subclassrÞ s ry rq z.deprecated.__call__.<locals>.__init_subclass__ ó( ø ä c°HÈÐVWÉ ÕXÙ 5°tÐ F¸vÑ FÐFr{ c óJ t j dz ¬« | i |¤S r2 r3 r4 s ry rq z.deprecated.__call__.<locals>.__init_subclass__ r6 r{ c óJ t j dz ¬« | i |¤S r2 r3 )rª r« rK r* r rÞ s ry Úwrapperz$deprecated.__call__.<locals>.wrapper" s( ø ä MM #°ÀZÐRSÁ^ÕTÙ Ð/¨Ñ/Ð/r{ zY@deprecated decorator with non-None category must be applied to a class or callable, not )r+ r* rÞ Ú__deprecated__r rÈ rC Útypesr. r§ Úwrapsr rq rè Ú classmethodry r ) rx rK rC r. r§ rq r9 r* r r5 r0 rÞ s ` @@@@@ry r zdeprecated.__call__é
|
sq ý ð ,,CØ}}HØ JØÐ Ø%(Ô"Ø
|
ÜC¤Ô&Û Ý,à "{{ à Ó.÷ 1ó /ð 1ô +¨7Ó 3 à),×)>Ñ)>Ð&ô Ð 4°jÔAØ-C×-LÑ-LÐ*à$Y__Ð%;Ó<öGó =ðGô -8Ð8IÓ,JCÕ)ð %Y__Ð%;Ó<öGó =ðGð ->CÔ)à>AÐAÔ" WÔ%;Ø36Ð!Ô0Ø
|
Ü# Û à Ó%ö0ó &ð0ð ?BÐAÔ" WÔ%;Ø ä ð0Ø03¨wð8óð r{ )r} r~ r r¬ râ ræ r
rc r ÚWarningri rÛ r' r rv r{ ry r+ r+ ®
|
sd ñ( ð\ ?QØ ò )àð )ð
|
oo f§k¡k°'Ñ&:Ñ;ð )ð ð )ð ó )ð"D ð D ¨"ô D r{ c ób |st | d« |t u r;t | d« r | j st | d« t | j « }t |« }||k7 rÇ|}t | d« r| j D cg c] }t |« r| }}t d |D « « }|dkD r |||z
|
k\ ry||k r7t || dt « t uryt d |D « « }||z }d| }t j d k\ rd
|
nd }t d ||kD rd nd d| d| d| d|
|
« yc c}w )úCheck correct count for parameters of a generic cls (internal helper).
|
|
This gives a nice error message in case of count mismatch.
|
r rN c 3 ó< K | ] }t |t « y wr )r r ©r rÅ s ry r z!_check_generic.<locals>.<genexpr>H s è ø Ò#TÀA¤J¨q´,×$?Ñ#Tùó r Nr8 c 3 óJ K | ] }t |d t « t u yw©r8 N©ré rb rB s ry r z!_check_generic.<locals>.<genexpr>W ó+ è ø ò )OØ>?ô *1°°MÄ9Ó)MÜ09ô*:ñ )Oùó !#r r Ú argumentsrà r r r ú z for r r ) r rß r½ rN rß rß Úsumré rb r8 rx ) r© rà Úelenrý Ú
|
expect_valrÅ Ú num_tv_tuplesÚnum_default_tvÚthingss ry Ú_check_genericrQ 8 st ñ
|
ÜseÐ#:Ð ;Ó<Ð <Ø 7?Ü3Ð 0Ô1¸×9KÒ9KÜ 3 %Ð'>Ð ?Ó@Ð@Üs×)Ñ)Ó*DÜ:Ø 4<Ø JÜsÐ ,Ô-Ø),×);Ñ);Ö Q AÄ:ÈaÅ=aÐ Q
|
Ð QÜ #Ñ#TÈÔ#TÓ T Ø! AÒ%¨D°D¸=Ñ4HÒ,HØð $;ô
|
¨4Ñ 0°-ÄÓKÜ (ñ)ð ä%(ñ )OØCMô)Oó &ONð NÑ*Dà#,¨T¨FÐ!3Jä$'×$4Ñ$4¸Ò$?[À\FÜd¨T°Dª[¡6¸eÐ"DÀAÀfÀXØ # C 5¨ °$°°{À:À,ð Pó Qð Qð7 ùò Rs  D,ÂD,c
|
óh |st | d« t |« }||k7 r|}t | d« ra| j D cg c] }t |« r| }}||k r7t || dt « t uryt d |D « « }||z }d| }t d||kD rdnd d
|
| d | d | « yc c}w ) r@ r rN r8 Nc 3 óJ K | ] }t |d t « t u ywrE rF rB s ry r z!_check_generic.<locals>.<genexpr>| rG rH r r r r r r r )r rß r½ rN rß ré rb rK )r© rà rL rý rM rÅ rO s ry rQ rQ d sú ñ
|
ÜseÐ#:Ð ;Ó<Ð <Ü:Ø 4<Ø JÜsÐ ,Ô-Ø),×);Ñ);Ö Q AÄ:ÈaÅ=aÐ Q
|
Ð Qð $;ô
|
¨4Ñ 0°-ÄÓKÜ (ñ)ð ä%(ñ )OØCMô)Oó &ONð NÑ*Dà#,¨T¨FÐ!3Jäd¨T°Dª[¡6¸eÐ"Dð E$Ø$' 5¨ °$°°{À:À,ð Pó Qð Qð/ ùò Rs ½B/ÁB/c ó, t j d« } | j j d« dk7 ry| j j d« }|t
|
j u xs |t u xs |t
|
j u S # t t f$ r Y yw xY w)Nr# r} r
Fr )
|
r8 r9 r: r; Úf_localsr
rT r; r· r< )Úframer s ry Ú"_has_generic_or_protocol_as_originrW s ð[Ü aÓ ð ??× Ñ zÓ *¨hÒ 6ØØ ×#Ñ# HÓ-ð Ð'ÒZ¨6´XÐ+=ÒZÀÌ6Ï?É?ÐAZÐZøô JÐ 'ò Ùðús B ÂBÂBc ó t | « t uryt | « }t |« xr$ t |« dk( xr t |d « t v S )NFr¼ r )r0 r r/ rF rß rÈ Ú_TYPEVARTUPLE_TYPES)Úxrª s ry Ú_is_unpacked_typevartupler[ sL Ü!}FÑ"ØÜ A;Dä T
|
ò 1Ü INò 1ä aMÔ 0Ð 0ðr{ Ú_collect_type_varsc ó¾ |t j }g }t « }d}d}| D ]§ }t |« rd}n]t ||« rQ||vrM|r:t |dt « t u}|r|r t d« d}n|rt d|d« |j |« t |« sz|j |j D cg c] }||vs| c}« © t |« S c c}w )zºCollect all type variable contained in types in order of
|
first appearance (lexicographic order). For example::
|
|
_collect_type_vars((T, List[S, T])) == (T, S)
|
FTr8 ú2Type parameter with a default follows TypeVarTupleúType parameter ú8 without a default follows type parameter with a default) r
r rW r[ r ré rb r rÁ r r¿ rN r )r; Ú typevar_typesÚtvarsÚenforce_default_orderingÚdefault_encounteredÚtype_var_tuple_encounteredr r7 s ry r\ r\ s ð Ð Ü "NNMØô $FÓ#GÐ Ø #Ðð &+Ð"àò NAÜ(¨Ô+Ø-1Ñ*ÜA}Ô-°!¸5±.Ù+Ü")¨!¨]¼IÓ"FÌiÐ"WKÙ"Ù5Ü"+ð -Dó #Eð Eà.2Ñ+Ù,Ü '¨/¸!¸ð ?Qð )Qó Rð Rð QÜ.¨qÕ1Ø ¨×)9Ñ)9Ö L A¸QÀeº^aÒ LÕMð# Nô$ U|Ðùò Ms Â8 C
|
ÃC
|
c ó g }t « }d}d}| D ]è }t |t « rt |t « r/|D ]) }t |g« D ] }||vs|j |« + St |d« rU||vsd|r<t |dt « t u}|r |r t d« |rd}n|rt d|d« |j |« ´t |« rd}t |dd « D ] }||vs|j |« ê t |« S )
|
zâCollect all type variables and parameter specifications in args
|
in order of first appearance (lexicographic order).
|
|
For example::
|
|
assert _collect_parameters((T, Callable[P, T])) == (T, P)
|
FÚ__typing_subst__r8 r^ Tr_ r` rN rv ) rW r rÈ r Ú_collect_parametersrÁ r½ ré rb r r[ ) rª rà rc rd re r rZ Ú collectedr7 s ry rh rh Õ s\ ð
|
ô $FÓ#GÐ Ø #Ðð &+Ð"àò " -AÜ!TÔ"àÜAuÔ%ð ò 9AÜ%8¸!¸Ó%=ò 9 Ø$¨JÒ6Ø &× -Ñ -¨iÕ 8ñ9ñ9ô Ð .Ô/ØJÒ&Ù/ä # A }´iÓ @Ì Ð Qð $ñ 6¹+Ü"+ð -Dó #Eð Eñ 'Ø26Ñ /Ù 0Ü"+¨o¸a¸Uð CUð -Uó #Vð Vð ×%Ñ% aÕ(ä,¨QÔ/Ø15Ð.Ü Ð$4°bÓ9ò -AØ
|
Ò*Ø"×)Ñ)¨!Õ,ñ-ðA" -ôH ZÓ Ð r{ c ó6 |D cg c] \ }}| }}}|D ci c] \ }}|t j |d| d« " }}}t j | |||¬« }|x|_ |j
|
_ t j dk r||_ |S c c}}w c c}}w )Nzfield z annotation must be a type©rý r¦ r ) r
r rk Ú
|
namedtupler- r§ r8 rx Ú _field_types) r» r; r¦ rý rÈ r rä r4 Únm_tpls ry Ú _make_nmtuplero s« Ø %×&1!Ð&Ñ&à#(÷*Ù 1að &×,Ñ,¨Q°&¸¸Ð;UÐ0VÓWÑWð * ñ *ä ×'Ñ'¨¨fØ19À&ôJàBMÐMÔ § ¡ Ô!?ô × Ñ fÒ $Ø"-FÔ Ø ùó 'ùó*s
|
B%B> r} r~ r- c ó e Zd Zd Zy)Ú_NamedTupleMetac óê t |v sJ |D ]( }|t us |t j us t d« t d |D « « }d|v r|d }nd|v r |d d« }ni }g }|D ]M }||v r|j |« |s t d| dt |« dkD rdnd d
|
d j |« « t ||j « |D cg c] }|| c}|d ¬ « } || _
|
t j |v rct t d« r t t j « | _ n4t j j j }
|
t |
|
« | _ |j « D ]c \ } } | t v rt# d| z « | t$ vs%| | j& vrt) | | || « t+ | « j, } | | | | « e t j |v r| j; « | S c c}w # t. $ rT}dt+ | « j0 d| d|}t2 j4 dk\ r|j7 |« t9 |« |d }~ww xY w# t" $ r Y úw xY w)Nz3can only inherit from a NamedTuple type and Genericc 3 ó< K | ] }|t u rt n| y wr )Ú _NamedTupler )r r3 s ry r z*_NamedTupleMeta.__new__.<locals>.<genexpr>/ s è ø ÒSÀT 4¬;Ñ#6%¸DÓ@ÑSùrC r- r´ r¼ z Non-default namedtuple field z cannot follow default fieldÚsr rJ r
|
r~ rk Ú_generic_class_getitemz&Cannot overwrite NamedTuple attribute z Error calling __set_name__ on z
|
instance z in r} ) rt r
rT r r rÁ rß r ro r¿ rs r½ r= rv r rè Ú _prohibited_namedtuple_fieldsr· Ú_special_namedtuple_fieldsÚ_fieldsr rÈ Ú __set_name__Ú BaseExceptionr} r8 rx Úadd_noteÚ RuntimeErrorrq )r© rã rS rÄ r3 r; Ú default_namesÚ
|
field_namerÈ rn Ú class_getitemÚkeyr Úset_namer| r s ry r§ z_NamedTupleMeta.__new__) s¨ Ü %Ñ'Ð 'Ð'Ø ò OØ{Ò*¨t¼6¿>¹>Ò/IÜ#ØMóOð Oð Oô ÑSÈUÔSÓSEØ BÑ&ØÐ,Ñ-Ø 2Ñ%à*>Ñ*¨1Ó-àØ MØ #ò C
|
Ø Ñ#Ø!×(Ñ(¨Õ4Ú"Ü#Ð&CÀJÀ<ð PBä.1°-Ó.@À1Ò.D¡sÈ"Ð&MÈQØ'+§y¡y° Ó'?Ð&@ð%Bó Cð Cð Cô #Ø%++-Ø)6Ö7 A"Q%Ò7Ø,Ñ'ôFð
|
%FÔ Ü~~ Ñ&Ü6Ð#;Ô<Ü/:¼6×;XÑ;XÓ/YFÕ,ä$*§N¡N×$DÑ$D×$MÑ$MMÜ/:¸=Ó/IFÔ,à HHJò ?SØÔ7Ñ7Ü(Ð)QÐTWÑ)WÓXÐXØÔ :Ò:Ø &§.¡.Ñ0Ü ¨¨R°©WÔ5ð?Ü#'¨£9×#9Ñ#9ð?Ù $ S¨&°#Õ 6ð ?ô: ~~ Ñ&Ø×(Ñ(Ô*ØMùòU 8øô0 -ò ?à"@ÄÀcÃ×ASÑASÐ@Vð W,Ø,/¨7°$°x°lð!Dð ô #× /Ñ /°7Ò :Ø !§
|
¡
|
¨3¤Ø %ä&2°3Ó&7¸QÐ >ûð ?ûô *ò Ù ð ús1 à H Æ;I&Ç
|
HÈ I#ÈAI É I#É& I2É1I2N)r} r~ r r§ rv r{ ry rq rq ( s óC r{ rq r c ó$ t | v sJ t fS r )r rt r× s ry Ú_namedtuple_mro_entriesr p s ÜUÑ"Ð"Ð"Ü~Ð r{ c ó~ |t u r|rd}d}nDd}d| d| d}d|z dz }n0|!|r t d « d
|
}d| d| d}d|z dz }n |r t d « |t u s|=t j j d ¬ « t
|
d¬« |j « }t | |t « ¬« }t f|_
|
|S )ao Typed version of namedtuple.
|
|
Usage::
|
|
class Employee(NamedTuple):
|
name: str
|
id: int
|
|
This is equivalent to::
|
|
Employee = collections.namedtuple('Employee', ['name', 'id'])
|
|
The resulting class has an extra __annotations__ attribute, giving a
|
dict that maps field names to types. (The field names are also in
|
the _fields attribute, which is part of the namedtuple API.)
|
An alternative equivalent functional syntax is also accepted::
|
|
Employee = NamedTuple('Employee', [('name', str), ('id', int)])
|
z3Creating NamedTuple classes using keyword argumentszq{name} is deprecated and will be disallowed in Python {remove}. Use the class-based or functional syntax instead.rÚ rÜ z = NamedTuple(z, [])`z¡{name} is deprecated and will be disallowed in Python {remove}. To create a NamedTuple class with 0 fields using the functional syntax, pass an empty list, e.g. r[ z\Cannot pass `None` as the 'fields' parameter and also specify fields using keyword argumentsrÛ zIEither list of fields or keywords can be provided to NamedTuple, not bothz3.15)r» rà r# rÝ rµ ) rß r rà rá Úformatrâ r¿ ro r? r r³ )rã rä r« rå rç ræ Únts ry r r t s% ð* WÑ ÙØ#XÐ ðHñ ð
|
$XÐ Ø hZ ~°h°\ÀÐHð0ð ñ # ð
|
"ñ #"ð ^ÙÜ ðFóð ð
|
$NÐ Ø hZ ~°h°\ÀÐHð0ð ñ # ð
|
"ñ #"ñ Üð Gó Hð Hà WÑ Ü MMØ ×&Ñ&Ð,<ÀVÐ&ÓLÜ"Ø õ ð
|
\\^FÜ 8 V´G³IÔ >Ü 'MÔØ r{ c ó e Zd ZdZy)r a§ Base class for classes that implement the buffer protocol.
|
|
The buffer protocol allows Python objects to expose a low-level
|
memory buffer interface. Before Python 3.12, it is not possible
|
to implement the buffer protocol in pure Python code, or even
|
to check whether a class implements the buffer protocol. In
|
Python 3.12 and higher, the ``__buffer__`` method allows access
|
to the buffer protocol from Python code, and the
|
``collections.abc.Buffer`` ABC allows checking whether a class
|
implements the buffer protocol.
|
|
To indicate support for the buffer protocol in earlier versions,
|
inherit from this ABC, either in a stub file or at runtime,
|
or use ABC registration. This ABC provides no methods, because
|
there is no Python-accessible methods shared by pre-3.12 buffer
|
classes. It is useful primarily for static checks.
|
|
N)r} r~ r r¬ rv r{ ry r r º s ò r{ r1 c ó® | j j d| j « S # t $ r# t dt | « j « dw xY w)a Return the class's "original" bases prior to modification by `__mro_entries__`.
|
|
Examples::
|
|
from typing import TypeVar, Generic
|
from typing_extensions import NamedTuple, TypedDict
|
|
T = TypeVar("T")
|
class Foo(Generic[T]): ...
|
class Bar(Foo[int], float): ...
|
class Baz(list[str]): ...
|
Eggs = NamedTuple("Eggs", [("a", int), ("b", str)])
|
Spam = TypedDict("Spam", {"a": int, "b": str})
|
|
assert get_original_bases(Bar) == (Foo[int], float)
|
assert get_original_bases(Baz) == (list[str],)
|
assert get_original_bases(Eggs) == (NamedTuple,)
|
assert get_original_bases(Spam) == (TypedDict,)
|
assert get_original_bases(int) == (object,)
|
r³ z"Expected an instance of type, not N)r0 r; rs r· r rÈ r} rh s ry r1 r1 Ø sW ð* Ø<<×#Ñ#Ð$4°c·m±mÓDÐ DøÜ ò ÜØ4´T¸#³Y×5GÑ5GÐ4JÐKóàð ð ús %( ¨,Ac óZ e Zd ZdZd Zd Zd Zd Zd Ze j dk\ rd Z d Z y
|
y
|
) r8 aL 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 callable 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 ó |S r rv rÈ s ry r zNewType.__call__ s ØJr{ c ó || _ d|v r|j d« d }|| _ || _ t « }|dk7 r|| _ y y )Nr[ r, r' )r Ú
|
rpartitionr} Ú __supertype__r? r~ )rx r» rÉ r= s ry rÛ zNewType.__init__ sO Ø $DÔ Ød{Ø sÓ+¨BÑ/Ø DMØ!#DÔ Ü iGØÐ-Ò-Ø")ð .r{ c ó: | j G fdd« }|fS )Nc ó e Zd Z fdZy)ú&NewType.__mro_entries__.<locals>.Dummyc óF | j }t d| d|d d« )NzGCannot subclass an instance of NewType. Perhaps you were looking for: `z = NewType(r
|
z)`)r} r )r© Ú subcls_nameÚ supercls_names ry rq z8NewType.__mro_entries__.<locals>.Dummy.__init_subclass__ s8 ø Ø"%§,¡,KÜ#ð à '=¨ °K°?À"À]ÀOÐSUðWóð r{ N)r} r~ r rq )r s ry ÚDummyr s ø õr{ r r )rx rS r r s @ry r zNewType.__mro_entries__ s! ø ð !MMM÷ ó ð 8Or{ c ó8 | j d| j S )Nr[ )r~ r rw s ry rz zNewType.__repr__% s ØooÐ& a¨×(9Ñ(9Ð':Ð;Ð ;r{ c ó | j S r )r rw s ry r zNewType.__reduce__( s Ø×$Ñ$Ð $r{ r c ó, t j | |f S r rà r s ry rÄ zNewType.__or__/ s Ü || D¨% KÑ0Ð0r{ c ó, t j || f S r rà r s ry rÆ zNewType.__ror__2 s Ü || E¨4 KÑ0Ð0r{ N) r} r~ r r¬ r rÛ r rz r r8 rx rÄ rÆ rv r{ ry r8 r8 ú s? ñ ò ò *ò ò <ò %ð × Ñ wÒ &ò 1ó 1ð 'r{ r8 rA c óv | du xs4 t | t t j t j t
|
f« S )z:Corresponds to is_unionable() in unionobject.c in CPython.N)r rÈ r r r rA rÞ s ry Ú _is_unionabler 9 s9 àd{ò j¨Ü Ü × Ñ Ü × Ñ Ü ð /
|
ó ð r{ c ó¸ e Zd ZdZdddefdZdededdf fd Zdedefd
|
Z dedefd Z
|
defd Z d Z d Z d Zd Zej" dk\ r
|
d Zd Z xZS xZS )rA aü Create named, parameterized type aliases.
|
|
This provides a backport of the new `type` statement in Python 3.12:
|
|
type ListOrSet[T] = list[T] | set[T]
|
|
is equivalent to:
|
|
T = TypeVar("T")
|
ListOrSet = TypeAliasType("ListOrSet", list[T] | set[T], type_params=(T,))
|
|
The name ListOrSet can then be used as an alias for the type it refers to.
|
|
The type_params argument should contain all the type parameters used
|
in the value of the type alias. If the alias is not generic, this
|
argument is omitted.
|
|
Static type checkers should only support type aliases declared using
|
TypeAliasType that follow these rules:
|
|
- The first argument (the name) must be a string literal.
|
- The TypeAliasType instance must be immediately assigned to a variable
|
of the same name. (For example, 'X = TypeAliasType("Y", int)' is invalid,
|
as is 'X, Y = TypeAliasType("X", int), TypeAliasType("Y", int)').
|
|
rv )Ú type_paramsr» c ó( t |t « s t d« || _ || _ g }|D ]5 }t |t
|
« r|j |« %|j |« 7 t |« | _ t « }|dk7 r|| _ || _ y )Nz#TypeAliasType name must be a stringr' ) r ræ r Ú __value__Ú__type_params__r r¿ rÁ r rN r? r~ r} )rx r» r+ r rà r9 r= s ry rÛ zTypeAliasType.__init__^ s Ü d¤CÔ(Ü Ð EÓFÐFØ "DNØ#.DÔ àJØ )ò 2
|
Ü j¬,Ô7Ø ×%Ñ% jÕ1à ×%Ñ% jÕ1ð 2ô
|
#(¨
|
Ó"3DÔ Ü iGØÐ-Ò-Ø")à DMr{ r+ rf Nc ó` t | d« r| j |« t | ||« y )Nr} )r½ Ú_raise_attribute_errorr r
|
)rx r» r+ r¡ s ry r
|
zTypeAliasType.__setattr__q s* ø ÜtZÔ(Ø×+Ñ+¨DÔ1Ü GÑ eÕ ,r{ c ó& | j |« y r )r¢ ©rx r» s ry Ú __delattr__zTypeAliasType.__delattr__v s Ø × 'Ñ '¨Õ -r{ c óf |dk( r t d« |dv rt d| d« t d| d« )Nr} zreadonly attribute> r r~ rN r z attribute 'z3' of 'typing.TypeAliasType' objects is not writablez0'typing.TypeAliasType' object has no attribute 'ú')r· r¤ s ry r¢ z$TypeAliasType._raise_attribute_errory sX àzÒ!Ü$Ð%9Ó:Ð:ØÐYÑYÜ$Ø! $ ð (&ð &óð ô
|
%ØFÀtÀfÈAÐNóð r{ c ó | j S r r rw s ry rz zTypeAliasType.__repr__ r r{ c óÒ t |t « s|f}|D cg c]& }t j |d| j d« ( }}t j
|
| t |« « S c c}w )Nz Subscripting z requires a type.)r r r
r r} r r¨ s ry rå zTypeAliasType.__getitem__ sq Ü j¬%Ô0Ø (]
|
ð
|
'ö ð ô ×"Ñ"ØM¨$¯-©-¨ Ð8IÐJõðJð ô ×'Ñ'¨¬e°JÓ.?Ó@Ð @ùò s +A$c ó | j S r r rw s ry r zTypeAliasType.__reduce__ r r{ c ó t d« )NzEtype 'typing_extensions.TypeAliasType' is not an acceptable base typerÔ rV s ry rq z TypeAliasType.__init_subclass__ s ÜØWóð r{ c ó t d« )NzType alias is not callablerÔ rw s ry r zTypeAliasType.__call__ s ÜÐ 8Ó9Ð 9r{ r c óN t |« st S t j | |f S r ©r rÌ r
rk )rx r s ry rÄ zTypeAliasType.__or__£ s% ô % UÔ+Ü)Ð)Ü || D¨% KÑ0Ð0r{ c óN t |« st S t j || f S r r® )rx rÿ s ry rÆ zTypeAliasType.__ror__ª s# Ü$ TÔ*Ü)Ð)Ü || D¨$ JÑ/Ð/r{ )r} r~ r r¬ ræ rÛ r r
|
rE r¥ r¢ rz rå r rq r r8 rx rÄ rÆ r£ r¤ s @ry rA rA B s ø ñ ð6 =?ò ! ó !ð& - Cð -°ð -¸dõ -ð
|
. Cð .¨uó .ð ¨sð °uó ð !có !ò Aò !ò ò :ð × Ñ wÒ &ò 1ö 0ó 'r{ r5 rÉ c ó| t | t « xr+ t | dd« xr | t uxr | t j uS )aZ Return True if the given type is a Protocol.
|
|
Example::
|
|
>>> from typing_extensions import Protocol, is_protocol
|
>>> class P(Protocol):
|
... def a(self) -> str: ...
|
... b: int
|
>>> is_protocol(P)
|
True
|
>>> is_protocol(int)
|
False
|
rF F)r rÈ ré r; r
rë s ry r5 r5 ´ sD ô r4Ó ò *ÜN¨EÓ2ò *à(Ð"ò *ð &//Ð)ð
|
r{ c ó t | « st | d« t | d« rt | j « S t t | « « S )a Return the set of members defined in a Protocol.
|
|
Example::
|
|
>>> from typing_extensions import Protocol, get_protocol_members
|
>>> class P(Protocol):
|
... def a(self) -> str: ...
|
... b: int
|
>>> get_protocol_members(P)
|
frozenset({'a', 'b'})
|
|
Raise a TypeError for arguments that are not Protocols.
|
z is not a Protocolr) )r5 r r½ rÔ r) r5 rë s ry r2 r2 É sK ô 2ÜrfÐ$6Ð 7Ó8Ð 8Ü 2Ð+Ô ,Ü R× 2Ñ 2Ó3Ð 3ÜÔ,¨RÓ0Ó1Ð1r{ r, c óH e Zd ZdZdeddfdZdefdZdefdZde de
|
fd Z y)
|
r, af Define the documentation of a type annotation using ``Annotated``, to be
|
used in class attributes, function and method parameters, return values,
|
and variables.
|
|
The value should be a positional-only string literal to allow static tools
|
like editors and documentation generators to use it.
|
|
This complements docstrings.
|
|
The string value passed is available in the attribute ``documentation``.
|
|
Example::
|
|
>>> from typing_extensions import Annotated, Doc
|
>>> def hi(to: Annotated[str, Doc("Who to say hi to")]) -> None: ...
|
Ú documentationrf Nc ó || _ y r ©r³ )rx r³ s ry rÛ z Doc.__init__ò s
|
Ø!.DÕ r{ c ó" d| j dS )NzDoc(ú)rµ rw s ry rz z Doc.__repr__õ s Ø$×,Ñ,Ð/¨qÐ1Ð 1r{ c ó, t | j « S r )rÓ r³ rw s ry rÕ z Doc.__hash__ø s Ü×*Ñ*Ó+Ð +r{ rÎ c ó` t |t « st S | j |j k( S r )r r, rÌ r³ r s ry rÑ z
|
Doc.__eq__û s) Ü e¤SÔ)Ü%Ð%Ø×%Ñ%¨×)<Ñ)<Ñ<Ð <r{ ) r} r~ r r¬ ræ rÛ rz ri rÕ r rF rÑ rv r{ ry r, r, á sE ñ ð /¨#ð /°Tó /ð 2có 2ð ,có ,ð = ð =¨4ô =r{ Ú CapsuleTypeÚCAPI)r# )rp )NNFr )rv )írB rk Úcollections.abcr& rC ra rú r8 r; r r
rà Ú__all__ÚPEP_560rÈ Ú GenericMetarx Ú_PEP_696_IMPLEMENTEDrt rß r rF r r r r r r r r r r· r¯ r r. r4 r7 rÆ rÉ r r¾ r× rí r½ r9 r- r) Ú defaultdictÚpartialr¼ rê r r r r r r r r r r r? rD r r r rS rù ré r rú Ú _NoneTyper$ rc rF r% rP rÔ ÚEXCLUDED_ATTRIBUTESr1 r5 r? r; rD rH rL rN r= r] rT r> r= r$ r" r! r r# r r% r¥ Ú_PEP_728_IMPLEMENTEDr r r6 Ú signaturer rà r¾ r« r§ rÖ rê r( r3 rñ r& rø r0 r/ r Ú ImportErrorr r r@ rb r( r- r: r> r@ rB r r
|
rZ r rÞ r r" r r r¡ rB r« rC r´ Ú_Finalr r rE rH rI rÕ rG rÛ rã r rß rá rå rï r rõ r< r r' r* rj rk rM r: r$ r+ r' rQ rW rY r[ r\ rh r ro Ú _prohibitedrw rx rq rt r r ÚABCÚregisterÚ
|
memoryviewÚ bytearrayr r1 r8 rA r r5 r2 rR ræ r, Ú _CapsuleTypeÚ_socketÚ_CAPIrº rÁ rJ rK rL rN rO rP rQ rU rV rW rX rY rZ r[ r\ r] r^ r_ r` ra rd re rf rg rh ri rl rm rn ro rv r{ ry ú<module>rÑ sH ðÛ
|
Û Û Û Û Û Û Û
|
Û Û Û òy ðx Ø Ø×'Ñ'Ð+=Ñ=Ð ÷ ñ ñ
|
+ð ×ÑwÒ ó
|
ð ×ÑÒ óJòFð ??ð FNN3ÓØV^^DÓØV^^DÓØv~~f¨Ô-Ø 6>>*°DÔ 9ð ×ÑwÒ Þô &4ô &ô 9õ 9ð ??ô1V× 0Ñ 0¸õ 1ð
|
à×ÑwÒ Ø LLEò
|
ò@ ð
|
×ÑzÒ!ØnnGò ò ô Hv× 3Ñ 3¸4õ Hô :Ð-°Tõ :ñ< ð 1ô 2Gð ×(Ñ(ñ 6?Ô#ØHØ×(Ñ(MØ ×,Ñ,Oð 1×0Ñ0Ø ×Ñ+×1Ñ1°4Ó8óÐò& òP 7ò#ð {{ð × Ñ Ø × Ñ Ø×$Ñ$ Ø×$Ñ$ Ø Ø× Ñ Ø× Ñ Ø
|
..Ø ??Ø {{Ø×$Ñ$ ð ×ÑÐ)Ò)ßUÔUò=ñ #*ØÐ&¨×(<Ñ(<ó#Ð ô0*Ð :À$õ 0*ñd T
|
IÙ$Ø×!Ñ! 1° ¸9Ð/EôIñ *Ø×&Ñ&¨°Y°LôNñ *Ø×)Ñ)Ø Ø Ø// $Ñ'Ð)ô Nñ /Ø×.Ñ.Ø Ø "Ø// $Ñ'Ð)ô Ðòð ,Ð-JÐKØ"ñ Ð ñ F× 6Ñ 6Ó7ò ;ñ ò óð ×ÑwÒ ØHó<ò@òBô&b&V__Ó-ô b&ðH ñó ðô0(6>>¨]õ (ð, ×ÑwÒ Ø ×0Ñ0Ñò1ðj ð ×ÑwÒ Ø×$Ñ$KØ×(Ñ(MØ ×,Ñ,OØ×(Ñ(MØ×(Ñ(MØ×$Ñ$KØ×(Ñ(Màôhó ó ðð ôó ó ðð ô(ó ó ðð ôó ó ðð ôó ó ðð ôhtnó ó ðð ô ó ó ðò ð" Ð áð × Ñ IØ×*Ñ*NØ×&Ñ&Lð Ð 1 × 1Ñ 1°&×2DÑ2DÓ E× PÑ PÐPMòô*w.ô w.ðr n¨k¸2¸rÓBJáÑ5Ó6Ø#*ð V¸ÀUó Vó 7ðVñp vÐ'Ô(Ø "× 1Ñ 1°>ÐBÑà *Ð,Ðò0ñ" 6=Ô!Ø×$Ñ$Kò ñ 6:Ô Ø×*Ñ*Nòó0(>ñX 6;Ô Ø× Ñ Ið ×,Ñ,Oô%>&×.Ñ.°dõ %>÷N8ñ 8ðz ×ÑBQÐ7Ò"Ø×"Ñ"JØHð1å,ð4å?òò0ñ0 6;Ô Ø× Ñ Ià×ÑbqÐVÒ#Øñ 8ó ñ 8ñ 'Øð ô Iñ 6;Ô Ø× Ñ IôDô ô Ð"3õ ñ IØÐ(ò%ò
|
)÷ ñ ôCtô Cñ
|
Þ ô#YÐ ,õ #YñN 6?Ô#Ø×(Ò(MØ ×,Ò,O÷ñ ô7
|
ô 7ô.7*ô 7ñ0 Þ ñ V[Ô!ô+[Ð .ö +[ôbbD-ô bñL v}Ô%ô 4ô ðB ×Òñ
|
6ó ð
|
6ñ 6=Ô!Ø×$Ò$KØ %× >Ò >Ñ à×ÑbqÐVÒ#Øñ 6ó ñ 6ô :Ð1¸õ :ñ #Øð ô Kñ 6;Ô Ø× Ò Ià×ÑbqÐVÒ#Øñ,3ó ñ,3ô^7Ð/°tõ 7ñ Øð) ô+ Iñ\ 68Ô Ø ]]Fà×ÑbqÐVÒ#Øñ&3ó ñ&3ôR7Ð,°Dõ 7ñ Øð# ô% FôR(/6==¨õ (/ñV 6?Ô#Ø×(Ò(Màñ8ó ð8ñ& 66ÔØ ;;Dàñ8ó ð8ñ" 67ÔØ LLEàñ8ó ð8ñ4 6:Ô ØHØ×$Ò$KØ×ÑbqÐVÒ#Øñ3ó ð3ð& ñ3ó ñ3ô"7Ð.°dõ 7ñ Øð ô Hñ" Øð ô Kñ 6:Ô ØHØ×ÑbqÐVÒ#Øñ3ó ñ3ô&7Ð.°dõ 7ñ Øð ô Hð$' ðT ×ÑwÒ Ø ]]Fó)ð ×ÑbqÐVÒ#ô'Ð 3¸4õ 'ô
|
v×+Ñ+°4õ ð ñ+ó ð+ó-ô#v×+Ñ+°4õ #ô/Ð,°Dõ /ñ {Ô 3Fò-ñ Þ#á V^Ô$òô;FÐ!1ö ;Fô|KJ}ô KJñ\ 6=Ô!Ø×$Ò$Kðð !ó ñ( 6Ð2Ô3Ø$*×$HÒ$HÑ!à$'Ð!ñ 6>Ô"Ø×&Ò&LðS%ð S uó Sð4 ×ÑwÒ à ×4Ò4Ñð Ø #Ø %Ø $ð òSàðSð ðSð ð Sð
|
ð Sð !,,Ø LL V§Z¡ZÑ0°&·/²/À#ÀvÇzÁzÀ/Ñ2RÐRÑ SØ ð ñ
|
ð Sð **ðSð
|
!aÑ óSñl 6:Ô ØHà F§O¢O°C¸¿¹°OÑ$DÔ EBð!bð ! ó !ñH 8\Ô"Ø×$Ò$Jà Ó B÷ñ ñR v~Ô&Ø-4ô (QòX QñD Ø *FÔð[¨Dó [ð& $¡W¨V°^ÀTÓ%JÐKÐ ð Dó ñ 6Ð'Ô(ó$ ðL !3FÕ ò6!ñp Ø%8Ô"ð ×ÑwÒ Ø×"Ò"Jó ð %+×$6Ò$6Ð!Ù!*Ò+XÓ!YÐ ôD$ô DðL ,,° ¸bÀ"ÓEKò ñ Ð1Ó2Ø$+ò ?ó 3ð?ñD ;??HÔ%Ø __× #Ò #Fô ô ð* OOJÔ Ø
|
OOIÔ Ø
|
OOEÔñ 6Ð'Ô(Ø ×2Ò2Ñòð> ×ÑwÒ ØnnG÷91ñ 91ñx 6?Ô#Ø×(Ò(Mò ÷k0ñ k0ñ\ 6=Ô!Ø×$Ò$KØ!×6Ò6Ñð
|
ð
|
Dó
|
ð*2 ð 2¨V×-=Ò-=¸cÑ-Bó 2ñ* 65ÔØ
|
**C÷ =ñ =ñ@ v}¨dÓ3 àÐð'Ûñ ¨Ó.Ø Ð Ù ;LàÐØ KØ NN=Ô!ð × Ò Ø Ø ??Ø ??Ø × Ò
|
Ø × Ò Ø {{Ø × Ò
|
Ø × Ò Ø
|
..Ø ??Ø YYØ × Ò Ø ??Ø ??Ø ??Ø {{Ø
|
..Ø× Ò Ø Ø×&Ò&Ø×(Ò(Ø × Ò
|
Ø ??Ø
|
..Ø × Ò
|
Ø ??Ø jjØ Ø Ø Ø Ø × Ò
|
Ø {{Ø×$Ò$ Ø ×8Ò8Ñ øð[G ò 1Ø "× 0Ñ 0Óð1ûð
|
ò 4Ø %× 3Ñ 3Ó ð4ûðjE ò Ú ð úsC Ù7 Ù A@ ÷5A@' ÿ7A@ Á@ A@ Á@A@$Á@#A@$Á@'A@0Á@/A@0
|
