ij@[UdZddlmZddlZddlZddlZddlZddlZddlZddlddl m Z ddl m Z m Z mZmZmZmZmZddlmZddlmZe rdd lmZd d gej2Zd Zd Zded<edZedZedeZ ed d dd dejBddd d)dZ"ed d dd dejBddd d*dZ"ed d dd dejBddd d+dZ"ejBejBd d dd dejBddd d,dZ"ed d d dddd dddd d-dZ#ed d d dddd dddd d.dZ#ee"f d/d d d dddd dddd d0dZ#Gd d!ee Z$d"dd d d dddd ddddejFd# d1d$Z%e d/dd% d2d&Z&e d3d'Z& d/dd% d4d(Z&y)5aPyTree integration with :mod:`dataclasses`. This module implements PyTree integration with :mod:`dataclasses` by redefining the :func:`field`, :func:`dataclass`, and :func:`make_dataclass` functions. The :func:`register_node` function allows registering existing :func:`dataclasses.dataclass`-decorated classes as pytree nodes. Other APIs are re-exported from the original :mod:`dataclasses` module. The PyTree integration allows dataclasses to be flattened and unflattened recursively. The fields are stored in a special attribute named ``__optree_dataclass_fields__`` in the dataclass. >>> 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)*)MappingProxyType) TYPE_CHECKINGAnyCallableLiteralProtocolTypeVaroverload)dataclass_transform)DataclassEntry)Iterabler register_node__optree_dataclass_fields__Tbool_PYTREE_NODE_DEFAULT_T_U_TypeT)boundinitreprhashcomparemetadatakw_onlydoc pytree_nodec yN) defaultrrrrrrrr s g/var/www/html/emotional.easysim.app/public_html/venv/lib/python3.12/site-packages/optree/dataclasses.pyfieldr&d c yr"r#) default_factoryrrrrrrrr s r%r&r&sr'r(cyr"r#rs r%r&r&s r() r$r*rrrrrrrr c |xsij}| |jdt} | |d<|||||||d} tjdk\r|| d<n|t j ur tdtjdk\r|| d<n | td|s| rtd td t jd 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. r )r$r*rrrrr rz4field() got an unexpected keyword argument 'kw_only'r.rz0field() 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&) r$r*rrrrrrrr kwargss r%r&r&sLB$$&Hll=2FG )H]*F 7"#y  ++ +NOO 7"u JKK K &&.Z/V X     &v &&r(F rreqorder unsafe_hashfrozen match_argsrslots weakref_slotc yr"r#) rrr=r>r?r@rArrBrC namespaces r% dataclassrFs"%r(c yr"r#) clsrrr=r>r?r@rArrBrCrEs r%rFrFs r()field_specifiersc ~ ddlm} ||||||dtjdk\r|d<|d<| d<n-|dur t d |d ur t d | d ur t d tjd k\r| d<n| d ur t d| d fd } | St j |st dtd|dt|jvr t dtd|jd | urt tst d d dk(r| tj|fi}t| 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=r>r?r@r-rArrBTz;dataclass() got an unexpected keyword argument 'match_args'Fz8dataclass() got an unexpected keyword argument 'kw_only'z6dataclass() got an unexpected keyword argument 'slots'r. rCz=dataclass() got an unexpected keyword argument 'weakref_slot'c t|fdiS)NrE)rF)rHr;rEs r% decoratorzdataclass..decorator5sS@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 rErHrreturnr)optree.registryrLr5r6r9inspectisclassr:_FIELDS__dict__ isinstancestrr7rFr)rHrrr=r>r?r@rArrBrCrEGLOBAL_NAMESPACErQr;s ` @r%rFrFs~8G" F 7")|#yw 4 UVV  RSS e PQQ 7"!-~ U "WXX { A ??3 !H:%UVYU\\]^__#,,z;CLL>IY Z  ((Is1K>ym1MNNB$    .v .C  22r(c ZeZdZddddddddddd ddZy)_DataclassDecoratorTFr<c tr")NotImplementedError) selfrHrrr=r>r?r@rArrBrCs r%__call__z_DataclassDecorator.__call__Js "!r(N)rHrrrrrr=rr>rr?rr@rrArrrrBrrCrrXr)r: __module__ __qualname__rfr#r(r%rbrbIs !"" "  "  " """""""" "r(rbr#)basesnsrrr=r>r?r@rArrBrCmodulerQcxddlm}t|ts|&||ust|tr||}}n | t d||urt|tst d|d|dk(r|}|||||| d}||d }t jd k\r| |d <| |d <| |d <n-| dur t d| dur t d| dur t dt jdk\r| |d<n| dur t dt jdk\r"| t jdxsd}||d<n | t dd}t jdk\r;|t j"t"fvrt%j&t"|}d}||d<n|t j"ur t dt!j(|fd |i||}|s t+||}|S#t$rgtjtt5t jdjjdd}dddn #1swYnxYwYwxYw)!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. rrKNz?make_dataclass() missing 1 required keyword-only argument: 'ns'rTrSrUrM)rirEr-rArrBTz@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'rNrCzBmake_dataclass() got an unexpected keyword argument 'weakref_slot')r. __main__r:rkzr?r@rArrBrCrkrQrEr`dataclass_kwargsmake_dataclass_kwargsregistered_by_decoratorrHs r%r{r{^s`G)T"i&7 ! !ZC%8%r B Z]^ ^((Is1K>ym1MNNB$ "   7")3&&-#$)! 4 Z[[  WXX e UVV 7"+7( U "\]] 7" > T003Az +1h'  VWW# 7" .. : :!)))yII&* #-6k* +// /YZZ,,  C #C95 J3" T((DT ]]1-77;;J SFTTT Ts*G 'H900H) H9)H2 .H98H9rVcyr"r#rHrEs r%rrs "%r(cyr"r#rs r%rrs r(c` ddlm}|usttr" t ddk(r t ddc t ddfd }|St j std d tjstd tjvrtd jd |urttstdd dk(r|jjs1tj djdtdt"di}i tj$D]z}|j&j)dt*r<|js td|j,dtd|||j,<_|jsl| |j,<|t/| t1|}t1 }t3t||f d fd }d fd } ddlm} | || t6S)a+Register an existing dataclass as a pytree node. This function takes an existing :func:`dataclasses.dataclass`-decorated class and registers it as a pytree node. It can be used as a direct function call or as a decorator. Fields with ``metadata['pytree_node']`` set to :data:`True` (or not set, defaulting to :data:`True`) are treated as children, while init fields with ``metadata['pytree_node']`` set to :data:`False` are treated as metadata. Usage:: # Direct function call register_node(Point, namespace='my-namespace') # As a decorator @register_node(namespace='my-namespace') @dataclasses.dataclass class Point: x: float y: float Args: cls (type, optional): An existing dataclass. If :data:`None`, return a decorator. namespace (str): The registry namespace used for the PyTree registration. Returns: type or callable: The same class, now registered as a pytree node, or a decorator function. .. versionadded:: 0.20.0 rrKNz?Cannot specify `namespace` when the first argument is a string.rUz(The namespace cannot be an empty string.z.decorators  : :r(zExpected a class, got rSz is not a dataclass.zCannot register z! as a pytree node more than once.rTz Dataclass zE was defined with `init=False`. `tree_unflatten()` may fail because `z>.register_node()` reconstructs instances with `cls(**kwargs)`.) stacklevelr zPyTree node field z> must be included in `__init__()`. Or you can explicitly set `r2c`tfdD}tfdD}||fS)Nc36K|]}t|ywr"getattr.0nameobjs r% z6register_node..flatten_func..QsMd+Msc3:K|]}|t|fywr"rrs r%rz6register_node..flatten_func..RsP$T 23Ps)tuple)rchildrenrchildren_field_namesmetadata_fieldss` r% flatten_funcz#register_node..flatten_funcIs4M8LMMPPP#777r(c`tt|}|j|di|S)Nr#)rqzipupdate)rrr;rrHs r%unflatten_funcz%register_node..unflatten_funcVs-c.9: h}V}r()register_pytree_node)path_entry_typerErW)rrrXzCtuple[tuple[_U, ...], tuple[tuple[str, Any], ...], tuple[str, ...]])rztuple[tuple[str, Any], ...]rztuple[_U, ...]rXr)rYrLr^r_rvrZr[r9r7 is_dataclassr\r]r:__dataclass_params__rwarningswarn UserWarningrprr4rrrrsetattrrr) rHrEr`rQchildren_fieldsfchildren_fields_proxymetadata_fields_proxyrrrrrs `` @@r%rrsXJG *S#"6  ^_ _ "9GH HsYWXX { ; ??3 0q9::  # #C (3'!5677#,,s||n,M N  ((Is1K>ym1MNNB$  # # ( ( ()zW Y   OO    $ ( ::>>-)= >66( 322:;bd'(OAFF # VV&'OAFF # (!1,_=,_= C02GHI 8  8  8 5 &  Jr()r$rrrrrr bool | Nonerrrdict[Any, Any] | Noner#bool | Literal[dataclasses.MISSING]r str | Noner rrXr)r*zCallable[[], _T]rrrrrrrrrrrrrrr rrXr)rrrrrrrrrrrrrrr rrXr)r$rr*rrrrrrrrrrrrrrrr rrXr)rrrrr=rr>rr?rr@rrArrrrBrrCrrEr_rXCallable[[_TypeT], _TypeT])rHrrrrrr=rr>rr?rr@rrArrrrBrrCrrEr_rXrr")rHz _TypeT | Nonerrrrr=rr>rr?rr@rrArrrrBrrCrrEr_rX#_TypeT | Callable[[_TypeT], _TypeT])$r|r_rpz6Iterable[str | tuple[str, Any] | tuple[str, Any, Any]]riztuple[type, ...]rjzdict[str, Any] | Nonerrrrr=rr>rr?rr@rrArrrrBrrCrrkrrQz_DataclassDecorator[_TypeT]rEr_rXr)rHrrErrXr)rHrrEr_rXr)rHz_TypeT | str | NonerErrXr)'__doc__ __future__rrtr7ryrZr5rtypesrtypingrrrr r r r typing_extensionsr optree.accessorsrcollections.abcr__all__r\r__annotations__rrtyperr8r&rFrbr{rr#r(r%rs+^# "UUU1+(     (!d! T] T]  & &*3>3F3F#              $  1             &*3>3F3F#  %            $  1             &*3>3F3F#          $ 1        &&&..&*3>3F3F#E' E'E'  E'  E'  E'E'$E'1E' E'E' E'P  %  %  % %  %  %  % % %  % % %  %  %             $uh/I3I3 I3  I3  I3 I3 I3I3 I3I3I3 I3I3I3)I30I3X"(6*"4! $-8-B-B%ww Cw  w  w w w w ww www w !w" #w$+%w&'w( )wt %! % % %  % %       $z! z z z ) zr(