0VhNVUdZddlmZddlZddlZddlZddlZddlZddlZddlddl m Z m Z m Z m Z mZmZmZddlmZe rddlmZgej*ZdZd Zd ed <ed Zed ZedeZed d dd dej:ddd d!dZed d dd dej:ddd d"dZed d dd dej:ddd d#dZej:ej:d d dd dej:ddd d$dZed d d dddd dddd d%dZed d d dddd dddd d&dZeef d'd d d dddd dddd d(dZGddeeZ ddd d d dddd ddddej>d d)d Z!y)*aPyTree integration with :mod:`dataclasses`. This module implements PyTree integration with :mod:`dataclasses` by redefining the :func:`field`, :func:`dataclass`, and :func:`make_dataclass` functions. 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)*) TYPE_CHECKINGAnyCallableLiteralProtocolTypeVaroverload)dataclass_transform)Iterable__optree_dataclass_fields__Tbool_PYTREE_NODE_DEFAULT_T_U_TypeT)boundinitreprhashcomparemetadatakw_onlydoc pytree_nodec yN) defaultrrrrrrrrs B/home/dcms/DCMS/lib/python3.12/site-packages/optree/dataclasses.pyfieldr#\ c yrr ) default_factoryrrrrrrrrs r"r#r#kr$r%cyrr rs r"r#r#zs r%) r!r'rrrrrrrrc |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'rrrrrrrrkwargss 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 yrr ) rrr:r;r<r=r>rr?r@ namespaces r" dataclassrCs"%r%c yrr ) clsrrr:r;r<r=r>rr?r@rBs r"rCrCs 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 dtddtjvr t dtdjd | urt tst d d dk(r| tjfii}itjD]z}|jj!dt"r<|j$s t d|j&dtd|||j&<_|j$sl||j&<|t)|t+j,|}t+j,t/t|f d"fd }d#fd }ddlm}ddlm}|||| 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*r>rr?Tz;dataclass() got an unexpected keyword argument 'match_args'Fz8dataclass() got an unexpected keyword argument 'kw_only'z6dataclass() got an unexpected keyword argument 'slots'r+ r@z=dataclass() got an unexpected keyword argument 'weakref_slot'c t|fdiS)NrB)rC)rEr8rBs 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 `r/c`tfdD}tfdD}||fS)Nc36K|]}t|ywrgetattr.0nameobjs r" z2dataclass..flatten_func..YsMd+Msc3:K|]}|t|fywrrUrWs r"r[z2dataclass..flatten_func..ZsP$T 23Ps)tuple)rZchildrenrchildren_field_namesmetadata_fieldss` r" flatten_funczdataclass..flatten_funcQs4M8LMMPPP#777r%c`tt|}|j|di|S)Nr )dictzipupdate)rr^r8r_rEs r"unflatten_funcz!dataclass..unflatten_func^s-c.9: h}V}r%)DataclassEntry)register_pytree_node)path_entry_typerB)rErreturnr)rZrrjzCtuple[tuple[_U, ...], tuple[tuple[str, Any], ...], tuple[str, ...]])rztuple[tuple[str, Any], ...]r^ztuple[_U, ...]rjr)optree.registryrIr2r3r6inspectisclassr7_FIELDS__dict__ isinstancestrr4rCfieldsrr1rrrYr]typesMappingProxyTypesetattroptree.accessorsrgrh)rErrr:r;r<r=r>rr?r@rBGLOBAL_NAMESPACErNchildren_fieldsfrarfrgrhr_r8r`s` ` @@@r"rCrCs}8G" F 7")|#yw 4 UVV  RSS e PQQ 7"!-~ U "WXX { A ??3 !H:%UVYU\\]^__#,,z;CLL>IY Z  ((Is1K>ym1MNNB$    .v .COO    $ ( ::>>-)= >66( 322:;bd'(OAFF # VV&'OAFF # (!1,,_=O,,_=O C?O<= 8  8  8 04  &  r%c ZeZdZddddddddddd ddZy)_DataclassDecoratorTFr9c tr)NotImplementedError) selfrErrr:r;r<r=r>rr?r@s r"__call__z_DataclassDecorator.__call__ps "!r%N)rErrrrrr:rr;rr<rr=rr>rrrr?rr@rrjr)r7 __module__ __qualname__rr r%r"r{r{os !"" "  "  " """""""" "r%r{r )basesnsrrr:r;r<r=r>rr?r@modulerNcddlm}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||}|s4|j+d d|j+ddt#|fi|d!|i}|S#t$rgtjtt5t jdjjdd}dddn #1swYnxYwYAwxYw)"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. rrHNz?make_dataclass() missing 1 required keyword-only argument: 'ns'rQrPrRrJ)rrBr*r>rr?Tz@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'rKr@zBmake_dataclass() got an unexpected keyword argument 'weakref_slot')r+ __main__r7rzrr?r@rrNrBrwdataclass_kwargsmake_dataclass_kwargsregistered_by_decoratorrEs r"rrs`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 #Wd+^T2E/E9E J7" T((DT ]]1-77;;J SFTTT Ts*G00'I 0I I I I I )r!rrrrrr bool | Nonerrrdict[Any, Any] | Noner#bool | Literal[dataclasses.MISSING]r str | Nonerrrjr)r'zCallable[[], _T]rrrrrrrrrrrrrrrrrjr)rrrrrrrrrrrrrrrrrjr)r!rr'rrrrrrrrrrrrrrrrrrjr)rrrrr:rr;rr<rr=rr>rrrr?rr@rrBrqrjzCallable[[_TypeT], _TypeT])rErrrrrr:rr;rr<rr=rr>rrrr?rr@rrBrqrjrr)rEz _TypeT | Nonerrrrr:rr;rr<rr=rr>rrrr?rr@rrBrqrjz#_TypeT | Callable[[_TypeT], _TypeT])$rrqrrz6Iterable[str | tuple[str, Any] | tuple[str, Any, Any]]rztuple[type, ...]rzdict[str, Any] | Nonerrrrr:rr;rr<rr=rr>rrrr?rr@rrrrNz_DataclassDecorator[_TypeT]rBrqrjr)"__doc__ __future__rrr4rrlr2rstypingrrrrr r r typing_extensionsr collections.abcr __all__rnr__annotations__rrtyperr5r#rCr{rr r%r"rs%*\# UUU1( !K    (!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/ww w  w  w w ww www www)w0wt"(6*"4! $-8-B-B%yy Cy  y  y y y y yy yyy y !y" #y$+%y&'y( )yr%