o 2h^L@sUdZddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddlmZddlmZdd lmZdd lmZmZmZmZmZmZmZmZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3dd l4m5Z5ddl6m7Z7ddl6m8Z8m9Z9ddl:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEgdZFe9ZGdeHd<e(dZIe(dZJe(dZKe(dZLe(dZMe0dZNe(de!de fdZOeeIZPdeHd<e&eZQdeHd<e,Gddde'eIZReSe)eTeUfZVzdd lmWZWWneXydWd$d%ZWYnwGd&d'd'e%eIZYGd(d)d)ZZGd*d+d+e'eIZ[Gd,d-d-e'eIZ\dXd0d1Z]e]e7j^dYd5d6Z^e]e7j_dZd8d9Z_e]e7j`d[d.innerrfrgrhrirPrB) functools lru_cachewraps)rdrprSrnrVrcs rcc@seZdZUdZdZded<eZded<e Z ded<e d;d dZ dddZd?ddZd@d!d"ZdAd$d%ZdBd'd(ZdCd)d*ZdCd+d,ZdDdEd0d1ZdFd3d4ZdGd6d7ZdHd9d:Zd-S)Ir3aGeneric PyTree type. >>> import torch >>> TensorTree = PyTree[torch.Tensor] >>> TensorTree # doctest: +IGNORE_WHITESPACE typing.Union[torch.Tensor, tuple[ForwardRef('PyTree[torch.Tensor]'), ...], list[ForwardRef('PyTree[torch.Tensor]')], dict[typing.Any, ForwardRef('PyTree[torch.Tensor]')], collections.deque[ForwardRef('PyTree[torch.Tensor]')], optree.typing.CustomTreeNode[ForwardRef('PyTree[torch.Tensor]')]] rSClassVar[tuple[()]] __slots__zSClassVar[WeakKeyDictionary[TypeAliasType, tuple[type | TypeAliasType, str | None]]] __instances__zClassVar[threading.Lock]__instance_lock__itemetype[T] | TypeAliasType | tuple[type[T] | TypeAliasType] | tuple[type[T] | TypeAliasType, str | None]rPr#c Cst|ts |df}t|dkr|ddf}nt|dkr't|jd|d|\}}|dur?t|ts?t|jd|dt|trxt|turx|j #z||j vr^|WWdSWn tyhYnwWdn1sswY|durt |}nUt|t rt |jd|jd}nCt|t r|jd kr|j}nz |jd|j}Wnty|jd|j}Ynwt |jd|d}n t |jd|d}t|t|d ft|tt|ft|t|f}|j ||f|j |<Wd|S1swY|S) z.Instantiate a PyTree type with the given type.NrzS[...] only supports a tuple of 2 items, a parameter and a string of type name, got .[]builtins.) isinstancerlenrlr^str _UnionTyperrrxrwrrtyper_r`AttributeErrorrIrJrKrrMr5)r\ryparamname recurse_reftypename pytree_aliasrSrSrV__class_getitem__st              zPyTree.__class_getitem__rcCtd)zProhibit instantiation.z*Cannot instantiate special typing classes.rkr\rSrSrV__new__zPyTree.__new__rfrrhcOrProhibit subclassing.z'Cannot subclass special typing classes.rkr\rfrhrSrSrV__init_subclass__rzPyTree.__init_subclass__key PyTree[T] | TcCtz!Emulate collection-like behavior.NotImplementedErrorrUrrSrSrV __getitem__zPyTree.__getitem__rrcCr)z Emulate dataclass-like behavior.r)rUrrSrSrV __getattr__!rzPyTree.__getattr__Any | TboolcCrrrrrSrSrV __contains__%rzPyTree.__contains__intcCrrrrTrSrSrV__len__)rzPyTree.__len__Iterator[PyTree[T] | T | Any]cCrrrrTrSrSrV__iter__-rzPyTree.__iter__cCrzEmulate sequence-like behavior.rrrSrSrVindex1rz PyTree.indexcCrrrrrSrSrVcount5rz PyTree.countNdefaultT | NonecCrzEmulate mapping-like behavior.r)rUrrrSrSrVget9rz PyTree.get KeysView[Any]cCrrrrTrSrSrVkeys=rz PyTree.keysValuesView[PyTree[T] | T]cCrrrrTrSrSrVvaluesArz PyTree.valuesItemsView[Any, PyTree[T] | T]cCrrrrTrSrSrVitemsErz PyTree.items)ryrzrPr#rPrrfrrhrrPr)rrrPr)rrrPr)rrrPr)rPr)rPr)rrrPrrj)rrrrrPr)rPr)rPr)rPr)r^r_r`rarv__annotations__r$rw threadingLockrxrcrrrrrrrrrrrrrrrSrSrSrVr3s*     ?           r3c@s(eZdZdZeddd ZdddZdS)r4aType variable for PyTree. >>> import torch >>> TensorTree = PyTreeTypeVar('TensorTree', torch.Tensor) >>> TensorTree # doctest: +IGNORE_WHITESPACE typing.Union[torch.Tensor, tuple[ForwardRef('TensorTree'), ...], list[ForwardRef('TensorTree')], dict[typing.Any, ForwardRef('TensorTree')], collections.deque[ForwardRef('TensorTree')], optree.typing.CustomTreeNode[ForwardRef('TensorTree')]] rrrtype | TypeAliasTyperPr#cCs,t|tst|jd|dt||fS)zEInstantiate a PyTree type variable with the given name and parameter.z* only supports a string of type name, got r})rrrlr^r3)r\rrrSrSrVrYs  zPyTreeTypeVar.__new__rfrrhrcOrrrkrrSrSrVr`rzPyTreeTypeVar.__init_subclass__N)rrrrrPr#r)r^r_r`rarcrrrSrSrSrVr4Ks  r4c@s eZdZdZejd ddZdS) r8z*The type stub class for flatten functions. container Collection[T]rPrQcCrR)z1Flatten the container into children and metadata.NrS)rUrrSrSrV__call__hrXzFlattenFunc.__call__N)rrrPrQr^r_r`raabcabstractmethodrrSrSrSrVr8er8c@s eZdZdZejd dd Zd S) r9z,The type stub class for unflatten functions.rYr7rZr[rPrcCrR)z>> @_override_with_(any) ... def my_any(iterable): ... for elem in iterable: ... if elem: ... return True ... return False ... >>> my_any([False, False, True, False, False, True]) # run at C speed True python_implementationrerPcs(t|d fdd }|_||_|S) NrfrgrhrirPrBcs|i|SrjrSrmrrSrVwrappedsz1_override_with_..wrapper..wrappedrq)rrrt__cxx_implementation____python_implementation__)rrrrSrVwrappers z _override_with_..wrapperN)rrerPrerS)rrrSrrV_override_with_ys robj object | typercCt|tr|nt|}t|S)zSReturn whether the object is an instance of namedtuple or a subclass of namedtuple.)rrr;rr\rSrSrVr:r:objectcC tt|S)z7Return whether the object is an instance of namedtuple.)r;rrrSrSrVr< r<r\rcCsZt|to,t|to,tt|ddto,tdd|jDo,tt|ddo,tt|ddS)z5Return whether the class is a subclass of namedtuple._fieldsNcss|] }t|tuVqdSrj)rr).0fieldrSrSrV sz&is_namedtuple_class.._make_asdict)rr issubclassrgetattrallrcallablerrSrSrVr;s r;tuple | type[tuple]tuple[str, ...]cCsRt|tr|}t|std|d|jSt|}t|s&td|d|jS)z'Return the field names of a namedtuple.z,Expected a collections.namedtuple type, got r}z9Expected an instance of collections.namedtuple type, got )rrr;rlrrrSrSrVr=s r=_T_coT) covariantc@s$eZdZdZd ddZdd d Zd S)StructSequenceMetaz-The metaclass for PyStructSequence stub type.subclassrrPrcCt|S)adReturn whether the class is a PyStructSequence type. >>> import time >>> issubclass(time.struct_time, StructSequence) True >>> class MyTuple(tuple): ... n_fields = 2 ... n_sequence_fields = 2 ... n_unnamed_fields = 0 >>> issubclass(MyTuple, StructSequence) False )r?)r\rrSrSrV__subclasscheck__s z$StructSequenceMeta.__subclasscheck__instancercCr)zReturn whether the object is a PyStructSequence instance. >>> import sys >>> isinstance(sys.float_info, StructSequence) True >>> isinstance((1, 2), StructSequence) False )r@)r\rrSrSrV__instancecheck__s z$StructSequenceMeta.__instancecheck__N)rrrPr)rrrPr)r^r_r`rarrrSrSrSrVrs rc@sLeZdZUdZdZded<ded<ded<ded<dd d ZddddZdS)rNzrr>cCr)z=Return whether the object is an instance of PyStructSequence.)r?rrrSrSrVr@rr@rPy_TPFLAGS_BASETYPEc Cst|trL|jtfkrLtt|ddtrLtt|ddtrLtt|ddtrLtdkrDz tj d|fdWd St t fyCYdSwt |j t@ Sd S) z8Return whether the class is a class of PyStructSequence.rNrrPyPyr)basesTF)rr __bases__rrrplatformrtypes new_classAssertionErrorrlr __flags__rrrSrSrVr?s$  r?z type[types.MemberDescriptorType]StructSequenceFieldTypecCst|tr|}t|std|dnt|}t|s$td|dtdkr=ddt|D}t||j d}n dd t|D}t |d |j S) z-Return the field names of a PyStructSequence.z&Expected a PyStructSequence type, got r}z3Expected an instance of PyStructSequence type, got rcSs"i|] \}}t|tr||jqSrS)rrrrrmemberrSrSrV 7s z$structseq_fields..)rcSsg|] \}}t|tr|qSrS)rrrrSrSrV >s z$structseq_fields..N) rrr?rlrrvarsrsortedrrr)rr\indices_by_namefieldsrSrSrVrA*s"    rA)rdrerPre)rrerPr)rrrPr)rrrPr)r\rrPr)rrrPr)nra __future__rrrrrsysrrrrrKrrJrrI collectionsrrrLrrMcollections.abcr r r r r rrrtypingrrrrrrrrrrrrrtyping_extensionsrrr r!r"r#weakrefr$ optree._C_Cr%r&optree.accessorsr'r(r)r*r+r,r-r.r/r0r1__all__r2rrBrCrDrErFrGrHr6r7r5rrrrrc ImportErrorr3r4r8r9rr:r<r;r=rrrNrr>r@rr? version_infomajorrrArSrSrSrVs       (<   4 2      "