U <cN>@sddlZddlZddlZddlZddlmZmZddlmZm Z m Z m Z m Z m Z mZmZmZmZddlmZmZmZmZddlmZddlmZddlmZGdd d eZGd d d ejZGd d d ejZeeeee ej!e"ej#e$e e%e e&e e'ede(di Z)d#ddZ*d$ddZ+d%ddZ,ddZ-GdddZ.edddZ/e.e e/Z0GdddeZ1Gddde1Z2dd Z3d!d"Z4dS)&N) hook_iterator_SnapshotState) AnyDictIteratorGenericListSetTupleTypeVarUnionget_type_hints) _eval_type _tp_cache _type_check _type_repr) ForwardRef)ABCMeta) _GenericAliasc@s eZdZdS) GenericMetaN__name__ __module__ __qualname__rrF/tmp/pip-unpacked-wheel-gikjz4vx/torch/utils/data/datapipes/_typing.pyrsrc@s eZdZdS)IntegerNrrrrrrsrc@s eZdZdS)BooleanNrrrrrrsrTcst||}t||}|tks(||kr,dSt|trJt|ddtkrJdS|tdkrZdSt|t dksvtkrzdS|tkrdSt|}t |dkrdSt fdd|DS)a Check if the left-side type is a subtype of the right-side type. If any of type is a composite type like `Union` and `TypeVar` with bounds, it would be expanded into a list of types and check all of left-side types are subtypes of either one from right-side types. T __origin__NFrc3s|]}t|VqdSN_issubtype_with_constraints).0variant constraints recursiverr Wszissubtype..) TYPE2ABCgetr isinstancergetattrrtype_decompose_typelenall)leftrightr&variantsrr$r issubtype3s$     r3cCsjt|tr*|jdk r|jg}qTt|j}n*t|drF|jtkrF|j}n|sNdS|g}tdd|D}|S)Nrcss|]}t||VqdSr)r(r))r"Z_trrrr'hsz"_decompose_type..) r*r __bound__list__constraints__hasattrrr __args__)tto_listtsrrrr-Zs    r-c sB|kr dSt|dd}|dk r8tfdd|DSt|dr`|jdk r`|j}t|dd}n|}d}D]}t|dd}|dk rt||rdSqlt|dr.|jdk r.|j}||kr<sdSt|dd} | dkst| d krdS|dk r.rr8rcss|]\}}t||VqdSr)r3)r"Zv_argZc_argrrrr's)r-r/r7rr+r!r.zip) r#r%r&vsZv_originZv_args constraintcsZc_originZc_argsrr$rr!ls<     r!cstt||ddsdSt|dd}t|trp|dks@t|dkrDdSt|t|krXdStddt||DSt|tt fr|dkst|dkrdS|dtfdd|DSt|t r|dkst|dkrdS|\tfd d| DSdS) NF)r&r8rTcss|]\}}t||VqdSr issubinstance)r"dr9rrrr'sz issubinstance..c3s|]}t|VqdSrrA)r"rC)r9rrr'sc3s&|]\}}t|ot|VqdSrrA)r"kr<)ktvtrrr's) r3r,r+r*tupler.r/r=r5setdictitems)data data_typeZdt_argsr)rEr9rFrrBs(   rBc@s@eZdZdZddZddZddZdd Zd d Zd d Z dS) _DataPipeTypez) Save type annotation in `param` cCs ||_dSr)param)selfrNrrr__init__sz_DataPipeType.__init__cCs t|jSr)rrNrOrrr__repr__sz_DataPipeType.__repr__cCst|tr|j|jkStSr)r*rMrNNotImplementedrOotherrrr__eq__s  z_DataPipeType.__eq__cCs t|jSr)hashrNrQrrr__hash__sz_DataPipeType.__hash__cCsft|jtr"t|jddtkr"dSt|tr:t|j|jSt|trPt|j|Std t|dS)NrTz0Expected '_DataPipeType' or 'type', but found {}) r*rNrr+rrMr3r, TypeErrorformatrTrrrr3s    z_DataPipeType.issubtypecCs t||jSr)rBrNrTrrrissubtype_of_instancesz#_DataPipeType.issubtype_of_instanceN) rrr__doc__rPrRrVrXr3r[rrrrrMs rMT_co) covariantcsReZdZUdZeed<fddZfddZeddZ d d Z d d Z Z S) _DataPipeMetaz Metaclass for `DataPipe`. Add `type` attribute and `__init_subclass__` based on the type, and validate the return hint of `__iter__`. Note that there is subclass `_IterDataPipeMeta` specifically for `IterDataPipe`. r,c srtj||||f|Sd|d<|D](}t|tr"tj||||f|Sq"|ttdtj||||f|S)Nr,F__type_class__)r,__init_subclass__)super__new__rr*r_update _DEFAULT_TYPE_dp_init_subclass)clsnamebases namespacekwargsbase __class__rrrcs z_DataPipeMeta.__new__c stj|||f|dSr)rbrP)rOrhrirjrkrmrrrPsz_DataPipeMeta.__init__cs|dkrtd|jt|tr*t|}t|ts:|f}d|jtfdd|D}t|jjt rt |jjdd}t|tr|t k r|jj|}t |}t t|jd}|jd| }|dt|d}|f|j}|||t|d d St |d krtd |t |t |d }||jsFtd||j|j|krV|S|jdt|d}|f|j}|||td |dS)Nz{}[t]: t can not be Nonez{}[t]: t must be a typec3s|]}t|VqdSr)r)r"pmsgrrr'!sz*_DataPipeMeta._getitem_..r[]T)rar,r`z0Too many parameters for {} actual {}, expected 1rz1Can not subclass a DataPipe[{}] from DataPipe[{}])rar`r,)rYrZrr*strrrGr,rNrr+rrMr. __bases__rnrfr3)rOparamsorigror9lrhrirrpr _getitem_sR        z_DataPipeMeta._getitem_cCsBt|tstS|jdks"|jdkr*||kS|j|jko@|j|jkSr)r*r_rSrr,rTrrr_eq_Gs   z_DataPipeMeta._eq_cCst|j|jfSr)rWrr,rQrrr_hash_Psz_DataPipeMeta._hash_) rrrr\rM__annotations__rcrPrr{r|r} __classcell__rrrmrr_s    / r_cs eZdZdZfddZZS)_IterDataPipeMetaz Metaclass for `IterDataPipe` and inherits from `_DataPipeMeta`. Aad various functions for behaviors specific to `IterDataPipe`. c s\d|kr.|dtfdd}||d<d|krFt|d|tj||||f|S)Nresetcs<|d}|jtjtjfkr0d|_d|_||tj|_dS)z Only execute DataPipe's `reset()` method if `_SnapshotState` is `Iterating` or `NotStarted`. This allows recently restored DataPipe to preserve its restored state during the initial `__iter__` call. rN)Z_snapshot_staterZ IteratingZ NotStartedZ_number_of_samples_yieldedZ_fast_forward_iterator)argsrkZdatapipeZ reset_funcrrconditional_reset_s  z4_IterDataPipeMeta.__new__..conditional_reset__iter__zenumerate(DataPipe)#{}) functoolswrapsrrZrbrc)rgrhrirjrkrrmrrrcZsz_IterDataPipeMeta.__new__)rrrr\rcrrrrmrrTsrc Os>t|_t|ddrdSt|jjtrtj|jj }zt |jj|t }||j_Wn8t k r}zt d |jjj|W5d}~XYnXd|j kr:|j d}t|}d|kr:|d}|tkrdSt|dr|jtks|jtjjkst d |jt|d|jd} t| |jjs:t d |jt| |jdS) Nr`Fz${} is not supported by Python typingrreturnrzOExpected 'Iterator' as the return annotation for `__iter__` of {}, but found {}rzJExpected return type of '__iter__' as a subtype of {}, but found {} for {})reinforce_typer+r*r,rNrsysmodulesr__dict__rlocalsrYrZ__forward_arg__r rr7r collectionsabcrrr8r3) Zsub_clsrrk base_globalsrNeZiter_fnhintsZ return_hintrLrrrrfusJ         rfcCsPt|trt|}t|ddt||jjsBtd|jt |t ||_|S)z Reinforce the type for DataPipe instance. And the 'expected_type' is required to be a subtype of the original type hint to restrict the type requirement of DataPipe instance. z'expected_type' must be a typerpz7Expected 'expected_type' as subtype of {}, but found {}) r*rGr rr3r,rNrYrZrrM)rOZ expected_typerrrrs   r)T)T)T)5rrZnumbersrZ)torch.utils.data.datapipes._hook_iteratorrrtypingrrrrrr r r r r rrrrrrrrrIntegralrrboolintfloatRealcomplexComplexrIr5rHrGr,r(r3r-r!rBrMr]rer_rrfrrrrrsT0     '  D""  \!(