$ShNUdZddlmZddlZddlZddlZddlZddlZddlZddlTddl m Z m Z m Z m Z mZmZmZddlmZe rddlmZgejZdZd Zd ed <ed Zed ZedeZed d dd dejddddIdZed d dd dejddddJd"Zed d dd dejddddKd$Zejejd d dd dejddd% dLd&Zed d d d'd'd'd d'd'd'd( dMd3Zed d d d'd'd'd d'd'd'd( dNd5Zeef6 dOd d d d'd'd'd d'd'd'd( dPd9ZGd:d;eeZ d>> import math ... import optree ... >>> @optree.dataclasses.dataclass(namespace='my_module') ... class Point: ... x: float ... y: float ... z: float = 0.0 ... norm: float = optree.dataclasses.field(init=False, pytree_node=False) ... ... def __post_init__(self) -> None: ... self.norm = math.hypot(self.x, self.y, self.z) ... >>> point = Point(2.0, 6.0, 3.0) >>> point Point(x=2.0, y=6.0, z=3.0, norm=7.0) >>> # Flatten without specifying the namespace >>> optree.tree_flatten(point) # `Point`s are leaf nodes ([Point(x=2.0, y=6.0, z=3.0, norm=7.0)], PyTreeSpec(*)) >>> # Flatten with the namespace >>> accessors, leaves, treespec = optree.tree_flatten_with_accessor(point, namespace='my_module') >>> accessors, leaves, treespec # doctest: +IGNORE_WHITESPACE,ELLIPSIS ( [ PyTreeAccessor(*.x, (DataclassEntry(field='x', type=),)), PyTreeAccessor(*.y, (DataclassEntry(field='y', type=),)), PyTreeAccessor(*.z, (DataclassEntry(field='z', type=),)) ], [2.0, 6.0, 3.0], PyTreeSpec(CustomTreeNode(Point[()], [*, *, *]), namespace='my_module') ) >>> point == optree.tree_unflatten(treespec, leaves) True ) annotationsN)*) TYPE_CHECKINGAnyCallableLiteralProtocolTypeVaroverload)dataclass_transform)Iterable__optree_dataclass_fields__Tbool_PYTREE_NODE_DEFAULT_T_U_TypeT)boundinitreprhashcomparemetadatakw_onlydoc pytree_nodedefaultrrr bool | Nonerrdict[Any, Any] | Noner#bool | Literal[dataclasses.MISSING]r str | Nonerreturnc dSN) rrrrrrrrrs X/var/www/html/movieo_spanner_bot/venv/lib/python3.11/site-packages/optree/dataclasses.pyfieldr(\  default_factoryCallable[[], _T]c dSr%r&) r+rrrrrrrrs r'r(r(kr)r*rcdSr%r&rs r'r(r(zs  #r*) rr+rrrrrrrrc |pi}| |dt} | |d<|||||||d} tjdkr|| d<n|t jurtdtjdkr|| d<n|td |s| rtd td t j d i| S) a*Field factory for :func:`dataclass`. This factory function is used to define the fields in a dataclass. It is similar to the field factory :func:`dataclasses.field`, but with an additional ``pytree_node`` parameter. If ``pytree_node`` is :data:`True` (default), the field will be considered a child node in the PyTree structure which can be recursively flattened and unflattened. Otherwise, the field will be considered as PyTree metadata. Setting ``pytree_node`` in the field factory is equivalent to setting a key ``'pytree_node'`` in ``metadata`` in the original field factory. The ``pytree_node`` value can be accessed using ``field.metadata['pytree_node']``. If ``pytree_node`` is :data:`None`, the value ``metadata.get('pytree_node', True)`` will be used. .. note:: If a field is considered a child node, it must be included in the argument list of the :meth:`__init__` method, i.e., passes ``init=True`` in the field factory. Args: pytree_node (bool or None, optional): Whether the field is a PyTree node. **kwargs (optional): Optional keyword arguments passed to :func:`dataclasses.field`. Returns: dataclasses.Field: The field defined using the provided arguments with ``field.metadata['pytree_node']`` set. Nr)rr+rrrrr rz4field() got an unexpected keyword argument 'kw_only'r1rz0field() got an unexpected keyword argument 'doc'zN`pytree_node=True` is not allowed for non-init fields. Please explicitly set `'.field(init=False, pytree_node=False)`.r&) copygetrsys version_info dataclassesMISSING TypeError__name__r() rr+rrrrrrrrkwargss r'r(r(sLB$$&&Hll=2FGG )H]*F 7""#y  + + +NOOO 7""u JKKK  K  X&. X X X     & &v & &&r*F rreqorder unsafe_hashfrozen match_argsrslots weakref_slotr@rArBrCrDrErF namespacestrCallable[[_TypeT], _TypeT]c dSr%r&) rrr@rArBrCrDrrErFrGs r' dataclassrKs "%r*clsc dSr%r&) rLrrr@rArBrCrDrrErFrGs r'rKrKs Sr*)field_specifiers _TypeT | None#_TypeT | Callable[[_TypeT], _TypeT]c x ddlm} ||||||dtjdkr|d<|d<| d<n9|durt d |d urt d | d urt d tjd kr| d<n| d urt d d, fd } | St jst dtddtj vr t dtdjd | ur(t tst d d dkr| tj fii}itjD]e}|jdt"r2|js t d|jdtd|||j<T|jr ||j<ft)|t+j|}t+jt/t|fd-fd# }d.fd( }dd)lm}dd*lm}|||| +S)/aDataclass decorator with PyTree integration. Args: cls (type or None, optional): The class to decorate. If :data:`None`, return a decorator. namespace (str): The registry namespace used for the PyTree registration. **kwargs (optional): Optional keyword arguments passed to :func:`dataclasses.dataclass`. Returns: type or callable: The decorated class with PyTree integration or decorator function. r__GLOBAL_NAMESPACErrr@rArBrCr0rDrrETz;dataclass() got an unexpected keyword argument 'match_args'Fz8dataclass() got an unexpected keyword argument 'kw_only'z6dataclass() got an unexpected keyword argument 'slots'r1 rFz=dataclass() got an unexpected keyword argument 'weakref_slot'NrLrr#c"t|fdiS)NrG)rK)rLr>rGs r' decoratorzdataclass..decorator-sS@@I@@@ @r*@z0.dataclass() can only be used with classes, not .z".dataclass() cannot be applied to z more than once.$The namespace must be a string, got rzPyTree node field z> must be included in `__init__()`. Or you can explicitly set `r5objrCtuple[tuple[_U, ...], tuple[tuple[str, Any], ...], tuple[str, ...]]c|tfdD}tfdD}||fS)Nc38K|]}t|VdSr%getattr.0namer]s r' z2dataclass..flatten_func..Ys-MMd++MMMMMMr*c3<K|]}|t|fVdSr%rarcs r'rfz2dataclass..flatten_func..Zs2PP$T 2 23PPPPPPr*)tuple)r]childrenrchildren_field_namesmetadata_fieldss` r' flatten_funczdataclass..flatten_funcQsYMMMM8LMMMMMPPPPPPPPP#777r*rtuple[tuple[str, Any], ...]rituple[_U, ...]cxtt|}||di|S)Nr&)dictzipupdate)rrir>rjrLs r'unflatten_funcz!dataclass..unflatten_func^s?c.99:: hs}}V}}r*)DataclassEntry)register_pytree_node)path_entry_typerG)rLrr#r)r]rr#r^)rrmrirnr#r)optree.registryrSr8r9r<inspectisclassr=_FIELDS__dict__ isinstancerHr:rKfieldsrr7rrrerhtypesMappingProxyTypesetattroptree.accessorsrtru)rLrrr@rArBrCrDrrErFrGGLOBAL_NAMESPACErXchildren_fieldsfrlrsrtrurjr>rks` ` @@@r'rKrKsu8GFFFFF" F 7"")|#yw 4  UVVV   RSSS e  PQQQ 7""!-~ U " "WXXX { A A A A A A A ?3  `^H^^VY^^^___#, Z Z ZCL Z Z Z   (((Is1K1K(MyMMMNNNB$   . .v . .COO   $ $ ( ( :>>-)= > > (6 ddd2:ddd'(OAF # # V (&'OAF # 11,_==O,_==O C?O<=== 8 8 8 8 8 8 8 0/////444444   &    r*c .eZdZddddddddddd ddZdS)_DataclassDecoratorTFr?rLrrrrr@rArBrCrDrrErFr#c tr%)NotImplementedError) selfrLrrr@rArBrCrDrrErFs r'__call__z_DataclassDecorator.__call__ps "!r*N)rLrrrrrr@rrArrBrrCrrDrrrrErrFrr#r)r= __module__ __qualname__rr&r*r'rrosR !"""""""""r*rr&)basesnsrrr@rArBrCrDrrErFmodulerXcls_namer}6Iterable[str | tuple[str, Any] | tuple[str, Any, Any]]rtuple[type, ...]rdict[str, Any] | NonerrX_DataclassDecorator[_TypeT]cddlm}t|ts|/||ust|tr||}}n|t d||ur(t|tst d|d|dkr|}|||||| d}||d }t jd kr| |d <| |d <| |d <n9| durt d| durt d| durt dt jdkr| |d<n| durt dt jdkr| t jdpd}nt#t$rgtj tt5t j djdd}dddn #1swxYwYYnwxYw||d<n|t dd}t jdkr8|t jt"fvrt%jt"|}d}||d<n|t jurt dt!j|fd |i||}|s=|d d|ddt#|fi|d!|i}|S)"aMake a new dynamically created dataclass with PyTree integration. The dataclass name will be ``cls_name``. ``fields`` is an iterable of either (name), (name, type), or (name, type, Field) objects. If type is omitted, use the string :data:`typing.Any`. Field objects are created by the equivalent of calling :func:`field` (name, type [, Field-info]). The ``namespace`` parameter is the PyTree registration namespace which should be a string. The ``namespace`` in the original :func:`dataclasses.make_dataclass` function is renamed to ``ns`` to avoid conflicts. The remaining parameters are passed to :func:`dataclasses.make_dataclass`. See :func:`dataclasses.make_dataclass` for more information. Args: cls_name: The name of the dataclass. fields (Iterable[str | tuple[str, Any] | tuple[str, Any, Any]]): An iterable of either (name), (name, type), or (name, type, Field) objects. namespace (str): The registry namespace used for the PyTree registration. ns (dict or None, optional): The namespace used in dynamic type creation. See :func:`dataclasses.make_dataclass` and the builtin :func:`type` function for more information. **kwargs (optional): Optional keyword arguments passed to :func:`dataclasses.make_dataclass`. Returns: type: The dynamically created dataclass with PyTree integration. rrRNz?make_dataclass() missing 1 required keyword-only argument: 'ns'r[rZr\rT)rrGr0rDrrETz@make_dataclass() got an unexpected keyword argument 'match_args'Fz=make_dataclass() got an unexpected keyword argument 'kw_only'z;make_dataclass() got an unexpected keyword argument 'slots'rUrFzBmake_dataclass() got an unexpected keyword argument 'weakref_slot')r1 __main__r=rz T033Az! T T T(DDTT ]1--7;;J SSFTTTTTTTTTTTTTTT T+1h''  VWWW# 7"" . : : :!))yIIII&* #-6k** +/ / /YZZZ,  C #FWd+++^T222EE/EE9EEE Js6$D;;)F,$.F F,F" "F,%F" &F,+F,)rrrrrrrrrrrr rr!rr"rrr#r)r+r,rrrrrrrrrr rr!rr"rrr#r)rrrrrrrrrr rr!rr"rrr#r)rrr+rrrrrrrrrrr rr!rr"rrr#r)rrrrr@rrArrBrrCrrDrrrrErrFrrGrHr#rI)rLrrrrrr@rrArrBrrCrrDrrrrErrFrrGrHr#rr%)rLrOrrrrr@rrArrBrrCrrDrrrrErrFrrGrHr#rP)$rrHr}rrrrrrrrrr@rrArrBrrCrrDrrrrErrFrrr"rXrrGrHr#r)"__doc__ __future__rrr:rrxr8r~typingrrrrr r r typing_extensionsr collections.abcr __all__rzr__annotations__rrtyperr;r(rKrrr&r*r'rs***\#""""" UUUUUUUUUUUUUUUUUU111111)(((((( !K   (!!!!! WT]] WT]]  & & & &*3>3F#          &*3>3F#          &*3>3F#       &&.&*3>3F#E'E'E'E'E'E'P  % % % % %  %   $uh///wwwwww0/wt"""""(6*"""4! $-8-B%yyyyyyyyr*