o 2hN@sUdZddlmZddlZddlZddlZddlZddlZddlZddlTddl m Z m Z m Z m Z mZmZmZddlmZe rEddlmZgejZdZd Zd ed <ed Zed ZededZed d dd dejddddLdd Zed d dd dejddddMd#d Zed d dd dejddddNd%d Zejejd d dd dejddd& dOd'd Zed d d d(d(d(d d(d(d(d) dPd4d5Zed d d d(d(d(d d(d(d(d) dQd7d5Zeefd8 dRd d d d(d(d(d d(d(d(d) dSd;d5ZGddd d d d(d(d(d d(d(d(dejd?dTdJdKZ!dS)UaPyTree 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_nodedefaultrrr bool | Nonerrdict[Any, Any] | Noner#bool | Literal[dataclasses.MISSING]r str | Nonerreturnc CdSN) rrrrrrrrrr%r%M/var/www/html/chatgem/venv/lib/python3.10/site-packages/optree/dataclasses.pyfield\ r'default_factoryCallable[[], _T]c Cr#r$r%) r)rrrrrrrrr%r%r&r'kr(rcCr#r$r%rr%r%r&r'zs ) rr)rrrrrrrrc Cs|pi}| dur|dt} | |d<|||||||d} tjdkr(|| d<n |tjur1tdtjdkr;|| d<n|durCtd |sO| rOtd td tj 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'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') rr)rrrrrrrrkwargsr%r%r&r's6 &     F rreqorder unsafe_hashfrozen match_argsrslots weakref_slotr;r<r=r>r?r@rA namespacestrCallable[[_TypeT], _TypeT]c Cr#r$r%) rrr;r<r=r>r?rr@rArBr%r%r& dataclasssrEclsc Cr#r$r%) rFrrr;r<r=r>r?rr@rArBr%r%r&rE)field_specifiers _TypeT | None#_TypeT | Callable[[_TypeT], _TypeT]c s ddlm} ||||||dtjdkr!|d<|d<| d<n|dur)td |d ur1td | d ur9td tjd krC| d<n| d urKtddurYd/fdd } | Stsitdtddtj vrztdtdjd| urt t stdddkr| t j fii}it D]&}|jdtr|jstd|jdtd |||j<q|jr||j<qt|t|}ttt|fd0fd$d% }d1fd*d+ }dd,lm}dd-lm}||||d.S)2aDataclass 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, rAz=dataclass() got an unexpected keyword argument 'weakref_slot'NrFrr"cst|fdiS)NrB)rE)rF)r9rBr%r& decorator-szdataclass..decorator@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 `r0objrCtuple[tuple[_U, ...], tuple[tuple[str, Any], ...], tuple[str, ...]]cs6tfddD}tfddD}||fS)Nc3s|]}t|VqdSr$getattr.0namerUr%r& Ysz2dataclass..flatten_func..c3s|] }|t|fVqdSr$rWrYr\r%r&r]Zs)tuple)rUchildrenr)children_field_namesmetadata_fieldsr\r& flatten_funcQs zdataclass..flatten_funcrtuple[tuple[str, Any], ...]r_tuple[_U, ...]cs&tt|}||di|S)Nr%)dictzipupdate)rr_r9)r`rFr%r&unflatten_func^s z!dataclass..unflatten_func)DataclassEntry)register_pytree_node)path_entry_typerB)rFrr"r)rUrr"rV)rrcr_rdr"r)optree.registryrLr3r4r7inspectisclassr8_FIELDS__dict__ isinstancerCr5rEfieldsrr2rrr[r^typesMappingProxyTypesetattroptree.accessorsrirj)rFrrr;r<r=r>r?rr@rArBGLOBAL_NAMESPACErPchildren_fieldsfrbrhrirjr%)r`rFr9rarBr&rEs              c @s.eZdZddddddddddd dddZdS)_DataclassDecoratorTFr:rFrrrrr;r<r=r>r?rr@rAr"c Cstr$)NotImplementedError) selfrFrrr;r<r=r>r?rr@rAr%r%r&__call__prGz_DataclassDecorator.__call__N)rFrrrrrr;rr<rr=rr>rr?rrrr@rrArr"r)r8 __module__ __qualname__r}r%r%r%r&rzosrzr%)basesnsrrr;r<r=r>r?rr@rAmodulerPcls_namerr6Iterable[str | tuple[str, Any] | tuple[str, Any, Any]]rtuple[type, ...]rdict[str, Any] | NonerrP_DataclassDecorator[_TypeT]c Cs>ddlm}t|ts|dur&||ust|tr||}}n|dur&td||ur7t|ts7td|d|dkr=|}|||||| d}||d }tjd kr]| |d <| |d <| |d <n| duretd| durmtd| durutdtjdkr| |d<n| durtdtjdkr|durz tdpd}Wn)t yt t t t djdd}Wdn1swYYnw||d<n|durtdd}tjdkr|tjtfvrtjt|d}d}||d<n |tjurtdtj|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. rrKNz?make_dataclass() missing 1 required keyword-only argument: 'ns'rSrRrTrM)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'rNrAzBmake_dataclass() got an unexpected keyword argument 'weakref_slot')r, __main__r8rzr?rr@rArrPrBrwdataclass_kwargsmake_dataclass_kwargsregistered_by_decoratorrFr%r%r&rs 0              r)rrrrrrrrrrrrrr rr!rrr"r)r)r*rrrrrrrrrrrr rr!rrr"r)rrrrrrrrrrrr rr!rrr"r)rrr)rrrrrrrrrrrrr rr!rrr"r)rrrrr;rr<rr=rr>rr?rrrr@rrArrBrCr"rD)rFrrrrrr;rr<rr=rr>rr?rrrr@rrArrBrCr"rr$)rFrIrrrrr;rr<rr=rr>rr?rrrr@rrArrBrCr"rJ)$rrCrrrrrrrrrrrr;rr<rr=rr>rr?rrrr@rrArrr!rPrrBrCr"r)"__doc__ __future__rrr5rrmr3rstypingrrrrrr r typing_extensionsr collections.abcr __all__ror__annotations__rrtyperr6r'rErzrr%r%r%r&s .$     H z