ij9lUdZddlmZddlZddlZddlmZddlmZm Z m Z m Z m Z ddl Z ddl mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddl mZ ddl!m"Z"erdd lm#Z#gd Z$d Z%d Z&d e'd<e dZ(e dZ)e de*Z+Gdde"Z,d!dZ-e d"dZ.e d#dZ. d$ d%dZ.e d"dZ/e d#dZ/ d$ d%dZ/e.Z0 d&dZe d$dd d'dZ1e d(dZ1 d$dd d)d Z1y)*aIntegration with :mod:`attrs`. This module implements PyTree integration with :mod:`attrs` by providing :func:`field`, :func:`define`, :func:`frozen`, and :func:`register_node` functions. The :func:`field` and :func:`define` functions wrap the corresponding :mod:`attrs` functions with an additional ``pytree_node`` parameter for controlling which fields are tree children versus metadata. The :func:`register_node` function allows registering existing :mod:`attrs` classes as pytree nodes. The PyTree integration allows attrs classes to be flattened and unflattened recursively. The fields are stored in a special attribute named ``__optree_attrs_fields__`` in the attrs class. >>> import optree ... from optree.integrations import attrs ... >>> @attrs.define(namespace='my_module') ... class Point: ... x: float ... y: float ... z: float = 0.0 ... >>> point = Point(2.0, 6.0, 3.0) >>> point Point(x=2.0, y=6.0, z=3.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)], PyTreeSpec(*)) >>> # Flatten with the namespace >>> optree.tree_flatten(point, namespace='my_module') ([2.0, 6.0, 3.0], PyTreeSpec(CustomTreeNode(Point[()], [*, *, *]), namespace='my_module')) >>> treespec = optree.tree_structure(point, namespace='my_module') >>> point == optree.tree_unflatten(treespec, [2.0, 6.0, 3.0]) True .. versionadded:: 0.20.0 ) annotationsN)MappingProxyType) TYPE_CHECKINGAnyCallableTypeVaroverload)NOTHING AttributeFactoryasdictastuple cmp_using convertersevolve exceptionsfields fields_dictfiltershas resolve_typessettersvalidate validators) make_class) GetAttrEntry)ClassVar) AttrsEntryfielddefinefrozenmutabler register_noder r r r rrrrrrrrrrrrr__optree_attrs_fields__Tbool_PYTREE_NODE_DEFAULT_T_U_TypeT)boundczeZdZUdZdZded<ded<ed dZed dZedd Z edd Z dd Z y )rz%A path entry class for attrs classes.zClassVar[tuple[()]] __slots__z str | intentrycNtd|jjDS)zGet all field names.c34K|]}|jywN)name.0as n/var/www/html/emotional.easysim.app/public_html/venv/lib/python3.12/site-packages/optree/integrations/attrs.py z$AttrsEntry.fields..s?QVV?tupletype__attrs_attrs__selfs r6rzAttrsEntry.fieldss?TYY%>%>???cNtd|jjDS)zGet the init field names.c3NK|]}|js|jywr1)initr2r3s r6r7z)AttrsEntry.init_fields..sI!&&QVVIs%%r9r=s r6 init_fieldszAttrsEntry.init_fieldssITYY%>%>IIIr?ct|jtr|j|jS|jS)zGet the field name.) isinstancer.intrCr=s r6rzAttrsEntry.fields1 djj# &##DJJ/ /zzr?c|jS)zGet the attribute name.)rr=s r6r2zAttrsEntry.nameszzr?ch|jjd|jd|jdS)z)Get the representation of the path entry.z(field=z, type=)) __class____name__rr;r=s r6__repr__zAttrsEntry.__repr__s/..))*'$**wtyymSTUUr?N)returnztuple[str, ...])rMstr) rK __module__ __qualname____doc__r-__annotations__propertyrrCrr2rLr,r?r6rrsn/%'I"'  @@JJ Vr?rc |jdd}t|jddxsi}||jdt}||d<|jdd}|s|rt dt dt jdd|i|S) aField factory for :func:`define`. This factory function is used to define the fields in an attrs class. It is similar to :func:`attrs.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``. 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:`attrs.field`. Returns: The field defined using the provided arguments with ``metadata['pytree_node']`` set. .. versionadded:: 0.20.0 pytree_nodeNmetadatarBTzN`pytree_node=True` is not allowed for non-init fields. Please explicitly set `'.field(init=False, pytree_node=False)`.r,)popdictgetr& TypeErrorrKattrsr)kwargsrUrVrBs r6rrs6**]D1KFJJz406B7Hll=2FG )H] ::fd #D K &&.Z/V X  ;; 3 3F 33r?c yr1r, namespacer]s r6r r  "%r?c yr1r,clsr`r]s r6r r r?c | dfd }|Stj|stdtd|dt j |fi}t |S)a6Attrs class decorator with PyTree integration. This is a wrapper around :func:`attrs.define` that also registers the class as a pytree node. 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:`attrs.define`. Returns: type or callable: The decorated class with PyTree integration or decorator function. .. versionadded:: 0.20.0 c t|fdiS)Nr`)r )rdr]r`s r6 decoratorzdefine..decorators#==f= =r?@z-.define() can only be used with classes, not .r`rdr)rMr))inspectisclassr[rKr\r r#)rdr`r]rhs `` r6r r sa* { > ??3 !H:%RSVRYYZ[\\ ,,s %f %C  22r?c yr1r,r_s r6r!r!rar?c yr1r,rcs r6r!r! rer?c f|jdd|jddt|fd|i|S)a)Frozen attrs class decorator with PyTree integration. This is a convenience wrapper around :func:`define` with ``frozen=True``. 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:`attrs.define`. Returns: type or callable: The decorated class with PyTree integration or decorator function. .. versionadded:: 0.20.0 r!T on_setattrNr`) setdefaultr rcs r6r!r!s9* h% lD) # 5 5f 55r?c 6t||fi|}t||S)a^Create a new attrs class and register it as a pytree node. This is a wrapper around :func:`attrs.make_class` that also registers the class as a pytree node. Args: name (str): The name for the new class. attrs: A list of names or a dictionary of mappings of names to :func:`attrs.field` calls. namespace (str): The registry namespace used for the PyTree registration. **kwargs (optional): Optional keyword arguments passed to :func:`attrs.make_class`. Returns: type: A new attrs class registered as a pytree node. .. versionadded:: 0.20.0 rk)_attrs_make_classr#)r2r\r`r]rds r6rr3s"0 D% 26 2C  22r?rkcyr1r,rdr`s r6r#r#Os "%r?cyr1r,rws r6r#r#Xs r?c ddlm}|usttr" t ddk(r t ddc t dd fd }|St j std d tjstd tjvrtd jd |urttstdd dk(r|ttdddds1tjdjdtdt di}i tj"D]z}|j$j'dt(r<|j*s td|j,dtd|||j,<_|j*sl| |j,<|t/| t/d|j1D t3|}t3 }t5t||f d! fd }d" fd } ddlm} | || t8S)#a3Register an existing attrs class as a pytree node. This function takes an existing :func:`attrs.define`-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') @attrs.define class Point: x: float y: float Args: cls (type, optional): An existing attrs-decorated class. 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 r)__GLOBAL_NAMESPACENz?Cannot specify `namespace` when the first argument is a string.z(The namespace cannot be an empty string.z.decorators  : :r?zExpected a class, got rjz! is not an attrs-decorated class.zCannot register z! as a pytree node more than once.z$The namespace must be a string, got __attrs_props__ added_initTz Attrs class zn does not use an attrs-generated `__init__` (for example, `init=False`). `tree_unflatten()` may fail because `z>.register_node()` reconstructs instances with `cls(**kwargs)`.) stacklevelrUzPyTree node field z> must be included in `__init__()`. Or you can explicitly set `rWc34K|]}|jywr1)aliasr3s r6r7z register_node..sGQWWGr8c|tfdD}tfdjD}||fS)Nc36K|]}t|ywr1)getattr)r4r2objs r6r7z6register_node..flatten_func..sMd+Msc3bK|]&}|jt|jf(ywr1)rrr2)r4r5rs r6r7z6register_node..flatten_func..s%[Q!''73#78[s,/)r:values)rchildrenrVchildren_field_namesmetadata_fieldss` r6 flatten_funcz#register_node..flatten_funcs=M8LMM[/BXBXBZ[[#777r?c`tt|}|j|di|S)Nr,)rYzipupdate)rVrr]children_aliasesrds r6unflatten_funcz%register_node..unflatten_funcs-c*H56 h}V}r?)register_pytree_node)path_entry_typer`rl)rr'rMzCtuple[tuple[_U, ...], tuple[tuple[str, Any], ...], tuple[str, ...]])rVztuple[tuple[str, Any], ...]rztuple[_U, ...]rMr')optree.registryrzrErN ValueErrorrmrnr[r\r_FIELDS__dict__rKrwarningswarn UserWarningrrVrZr&rBr2r:rrsetattrrr)rdr`GLOBAL_NAMESPACErhchildren_fieldsr5children_fields_proxymetadata_fields_proxyrrrrrrs`` @@@r6r#r#asvLG *S#"6  ^_ _ "9GH HsYWXX { ; ??3 0q9:: 99S>3'!BCDD#,,s||n,M N  ((Is1K>ym1MNNB$ 73 148, M 3<<*+zW Y   OO \\#  ( ::>>-)= >66( 322:;bd'(OAFF # VV&'OAFF # (!1Go.D.D.FGG,_=,_= C02GHI 8  8  8 5 "  Jr?)r]rrMr)r`rNr]rrMCallable[[_TypeT], _TypeT])rdr)r`rNr]rrMr)r1)rdz _TypeT | Noner`rNr]rrM#_TypeT | Callable[[_TypeT], _TypeT]) r2rNr\rr`rNr]rrMr;)rd str | Noner`rrMr)rdr)r`rNrMr))rdz_TypeT | str | Noner`rrMr)2rQ __future__rrmrtypesrtypingrrrrr r\r r r r rrrrrrrrrrrrrrruoptree.accessorsrr__all__rr&rRr'r(r;r)rrr r!r"r#r,r?r6rs"N#"BB &2) < $!d! T] T]  &VVD(4V %%% % %         3  3 3  3 ) 3F %%% % %        6 6 6  6 ) 64 3 3 3  3  3 38 %! % % %  % %       $}! } } } ) }r?