JThӒSrSSKrSSKrSSKrSSKJr SSKJrJrJ r J r J r J r SSK JrJr SSKrSSKJr \"\R&5\"S5:a\"S5eCSS KJr SSKJs Jr SS KJr /S Qr\R:"S S S9r\R?5 \ "S5r \ "S5r!\ "S5r"\ "S5r#\r$\r%\\%/\&\'\\$44r(\\\\$/\%4r)\\$\\/\%4r*\r+\\$/\+4r,\\+/\$4r-\&\S4r.\\%/\&\'\&\\4\44r/S\)S\*4Sjr0SSSSS.S\1\S\(S\)S\ \2S\ \,S\ \-S\ \/SS4Sjjr3\"S \4S!9SSSS".S\1\S\(S\)S\ \2S\ \,S\ \-SS4S#jj5r5SSSS".S\1\S\(S\)S\ \2S\ \,S\ \-SS4S$jjr6S%\S\\4S&jr7SlS'\%S(\ \\%/\84S\84S)jjr9SlS'\%S(\ \\%/\84S\&\'\\44S*jjr:S+\\S,\S\%4S-jr;SlS'\%S(\ \\%/\84S\\4S.jjr<SlS'\%S(\ \\%/\84S\'\4S/jjr=SlS'\%S(\ \\%/\84S\4S0jjr>SS1.S\S\4S'\%S2\%S(\ \\%/\84S\%4 S3jjr?SS1.S\S\4S'\%S2\%S(\ \\%/\84S\%4 S4jjr@\&\1\ \1\!4rA\&\1\ \1\!\1\"4rB\RS5:a\ \1\\&\1\S4\R4rEO\ \1\\&\1\S44rE\\ \ \!4/\#4rF\\ \ \!\"4/\#4rG\\ /\#4rH\\/\#4rI\\ /\\/\44rJ\ S6\1\ S\J\H\ \44S7j5rK\ S6\A\ \!4S\J\F\ \!\44S8j5rK\ S6\B\ \!\"4S\J\G\ \!\"\44S9j5rK\ S6\ES\J\I\4S:j5rK\ S6\\/\84S\J\I\4S;j5rKS6\ \E\\/\844S\J\I\4S<jrK\ SlS\H\ \4S'\%S(\ \\%/\84S6\1\ S\%4 S=jj5rL\ SlS\F\ \!\4S'\%S(\ \\%/\84S6\A\ \!4S\%4 S>jj5rL\ SlS\G\ \!\"\4S'\%S(\ \\%/\84S6\B\ \!\"4S\%4 S?jj5rL\ SlS\I\S'\%S(\ \\%/\84S6\ES\%4 S@jj5rL\ SlS\I\S'\%S(\ \\%/\84S6\\/\84S\%4 SAjj5rLSlS\I\S'\%S(\ \\%/\84S6\ \E\\/\844S\%4 SBjjrL\ SlS\H\ \4S'\%S(\ \\%/\84S6\1\ S\%4 SCjj5rM\ SlS\F\ \!\4S'\%S(\ \\%/\84S6\A\ \!4S\%4 SDjj5rM\ SlS\G\ \!\"\4S'\%S(\ \\%/\84S6\B\ \!\"4S\%4 SEjj5rM\ SlS\I\S'\%S(\ \\%/\84S6\ES\%4 SFjj5rM\ SlS\I\S'\%S(\ \\%/\84S6\\/\84S\%4 SGjj5rMSlS\I\S'\%S(\ \\%/\84S6\ \E\\/\844S\%4 SHjjrMSlSI\\/\84S'\%S(\ \\%/\84S\84SJjjrNSlSI\\/\84S'\%S(\ \\%/\84S\84SKjjrO\ SlSI\H\ \84S'\%S(\ \\%/\84SL\1\ S\84 SMjj5rP\ SlSI\F\ \!\84S'\%S(\ \\%/\84SL\A\ \!4S\84 SNjj5rP\ SlSI\G\ \!\"\84S'\%S(\ \\%/\84SL\B\ \!\"4S\84 SOjj5rPSlSI\I\8S'\%S(\ \\%/\84SL\ES\84 SPjjrP\ SlSI\H\ \84S'\%S(\ \\%/\84SL\1\ S\84 SQjj5rQ\ SlSI\F\ \!\84S'\%S(\ \\%/\84SL\A\ \!4S\84 SRjj5rQ\ SlSI\G\ \!\"\84S'\%S(\ \\%/\84SL\B\ \!\"4S\84 SSjj5rQSlSI\I\8S'\%S(\ \\%/\84SL\ES\84 STjjrQSlSU\%SV\%S(\ \\%/\84S\'\4SWjjrRSlS'\%S,\S(\ \\%/\84S\ \'\4SXjjrSSlS,\SY\ \TS\24SZjjrU\RS[\2S\4S\j5rW"S]S^5rXS,\S\24S_jrY"S`Sa\1"\55rZ"SbSc\\ZSd9r[SlS'\%S(\ \\%/\84S\&\'\&\.\4\44Sejjr\SlS'\%S(\ \\%/\84S\'\&\.\44Sfjjr]SS1.S\S\4S'\%S2\%S(\ \\%/\84S\%4 Sgjjr^Sh\.S\24Sijr_S%\Sh\.S\4Sjjr`\R S \lbSk0srcrd\RHurcrd\6"\c0\dD6 M \RR5 CcCdSSS5 g!,(df  g=f)ma Contains utility functions for working with nested python data structures. A *pytree* is Python nested data structure. It is a tree in the sense that nodes are Python collections (e.g., list, tuple, dict) and the leaves are Python values. Furthermore, a pytree should not contain reference cycles. pytrees are useful for working with nested collections of Tensors. For example, one can use `tree_map` to map a function over all Tensors inside some nested collection of Tensors and `tree_leaves` to get a flat list of all Tensors inside some nested collection. pytrees are helpful for implementing nested collection support for PyTorch APIs. N)Iterable)AnyCallableOptionaloverloadTypeVarUnion) deprecatedTypeIs)Versionz0.13.0ztorch.utils._cxx_pytree depends on optree, which is an optional dependency of PyTorch. To use it, please upgrade your optree package to >= 0.13.0) PyTreeSpec)KeyEntry)PyTreeContext FlattenFunc UnflattenFuncDumpableContextToDumpableContextFnFromDumpableContextFnTreeSpecLeafSpeckeystrkey_getregister_pytree_node tree_flattentree_flatten_with_pathtree_unflatten tree_iter tree_leavestree_leaves_with_pathtree_structuretree_maptree_map_with_path tree_map_ tree_map_onlytree_map_only_tree_alltree_any tree_all_only tree_any_onlytreespec_dumpstreespec_loadstreespec_pprintTtorch namespaceTSUR.funcreturncn^[R"T5S[S[S[4U4Sjj5nU$)Nargskwargsr6c&>T"[U50UD6$N)reversed)r8r9r5s O/var/www/auris/envauris/lib/python3.13/site-packages/torch/utils/_cxx_pytree.pywrapped_reverse_args..wrappedesXd^.v..) functoolswrapsr)r5r>s` r= _reverse_argsrCds:__T/s/c/c// Nr@)serialized_type_nameto_dumpable_contextfrom_dumpable_contextflatten_with_keys_fncls flatten_fn unflatten_fnrDrErFrGc nUb [S5e[UUUUUUS9 [R"UUUUUUS9 g)aRegister a container-like type as pytree node. Args: cls (type): A Python type to treat as an internal pytree node. flatten_fn (callable): A function to be used during flattening, taking an instance of ``cls`` and returning a pair, with (1) an iterable for the children to be flattened recursively, and (2) some hashable auxiliary data to be stored in the treespec and to be passed to the ``unflatten_fn``. unflatten_fn (callable): A function taking two arguments: the auxiliary data that was returned by ``flatten_fn`` and stored in the treespec, and the unflattened children. The function should return an instance of ``cls``. serialized_type_name (str, optional): A keyword argument used to specify the fully qualified name used when serializing the tree spec. to_dumpable_context (callable, optional): An optional keyword argument to custom specify how to convert the context of the pytree to a custom json dumpable representation. This is used for json serialization, which is being used in :mod:`torch.export` right now. from_dumpable_context (callable, optional): An optional keyword argument to custom specify how to convert the custom json dumpable representation of the context back to the original context. This is used for json deserialization, which is being used in :mod:`torch.export` right now. Example:: >>> # xdoctest: +SKIP >>> # Registry a Python type with lambda functions >>> register_pytree_node( ... set, ... lambda s: (sorted(s), None, None), ... lambda children, _: set(children), ... ) N-KeyPaths are not yet supported in cxx_pytree.rDrErF)NotImplementedError_private_register_pytree_node python_pytree)rHrIrJrDrErFrGs r=rrlsSR'!"QRR! 1/3 // 1/3 r@z`torch.utils._cxx_pytree._register_pytree_node` is deprecated. Please use `torch.utils._cxx_pytree.register_pytree_node` instead.)categoryrMc  [UUUUUUS9 g)a3Register a container-like type as pytree node for the C++ pytree only. The ``namespace`` argument is used to avoid collisions that occur when different libraries register the same Python type with different behaviors. It is recommended to add a unique prefix to the namespace to avoid conflicts with other libraries. Namespaces can also be used to specify the same class in different namespaces for different use cases. .. warning:: For safety reasons, a ``namespace`` must be specified while registering a custom type. It is used to isolate the behavior of flattening and unflattening a pytree node type. This is to prevent accidental collisions between different libraries that may register the same type. Args: cls (type): A Python type to treat as an internal pytree node. flatten_fn (callable): A function to be used during flattening, taking an instance of ``cls`` and returning a pair, with (1) an iterable for the children to be flattened recursively, and (2) some hashable auxiliary data to be stored in the treespec and to be passed to the ``unflatten_fn``. unflatten_fn (callable): A function taking two arguments: the auxiliary data that was returned by ``flatten_fn`` and stored in the treespec, and the unflattened children. The function should return an instance of ``cls``. serialized_type_name (str, optional): A keyword argument used to specify the fully qualified name used when serializing the tree spec. to_dumpable_context (callable, optional): An optional keyword argument to custom specify how to convert the context of the pytree to a custom json dumpable representation. This is used for json serialization, which is being used in :mod:`torch.export` right now. from_dumpable_context (callable, optional): An optional keyword argument to custom specify how to convert the custom json dumpable representation of the context back to the original context. This is used for json deserialization, which is being used in :mod:`torch.export` right now. rMN)rOrHrIrJrDrErFs r=_register_pytree_noderTs\" 1/3 r@c|[R"U5(d![R"UU[U5SS9 gg)zThis is an internal function that is used to register a pytree node type for the C++ pytree only. End-users should use :func:`register_pytree_node` instead. r.r/N)optreeis_structseq_classrrCrSs r=rOrOs9  $ $S ) )##   , '   *r@objc"[U[5$r;) isinstancer)rXs r=_is_pytreespec_instancer[s c8 $$r@treeis_leafc0[R"UUSSS9$)axCheck if a pytree is a leaf. >>> tree_is_leaf(1) True >>> tree_is_leaf(None) True >>> tree_is_leaf([1, 2, 3]) False >>> tree_is_leaf((1, 2, 3), is_leaf=lambda x: isinstance(x, tuple)) True >>> tree_is_leaf({'a': 1, 'b': 2, 'c': 3}) False >>> tree_is_leaf({'a': 1, 'b': 2, 'c': None}) False Args: tree (pytree): A pytree to check if it is a leaf node. is_leaf (callable, optional): An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A boolean indicating if the pytree is a leaf node. Tr.r] none_is_leafr0)rV tree_is_leafr\r]s r=raras#<      r@c0[R"UUSSS9$)aFlatten a pytree. See also :func:`tree_unflatten`. The flattening order (i.e., the order of elements in the output list) is deterministic, corresponding to a left-to-right depth-first tree traversal. >>> tree = {"b": (2, [3, 4]), "a": 1, "c": None, "d": 5} >>> tree_flatten(tree) ([2, 3, 4, 1, None, 5], PyTreeSpec({'b': (*, [*, *]), 'a': *, 'c': *, 'd': *}, NoneIsLeaf, namespace='torch')) >>> tree_flatten(1) ([1], PyTreeSpec(*, NoneIsLeaf, namespace='torch')) >>> tree_flatten(None) ([None], PyTreeSpec(*, NoneIsLeaf, namespace='torch')) >>> from collections import OrderedDict >>> tree = OrderedDict([("b", (2, [3, 4])), ("a", 1), ("c", None), ("d", 5)]) >>> tree_flatten(tree) ([2, 3, 4, 1, None, 5], PyTreeSpec(OrderedDict({'b': (*, [*, *]), 'a': *, 'c': *, 'd': *}), NoneIsLeaf, namespace='torch')) Args: tree (pytree): A pytree to flatten. is_leaf (callable, optional): An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A pair ``(leaves, treespec)`` where the first element is a list of leaf values and the second element is a treespec representing the structure of the pytree. Tr.r_)rVrrbs r=rr%s$F      r@leavestreespecc~[U5(d[S[U5S35e[R"X5$)a0Reconstruct a pytree from the treespec and the leaves. The inverse of :func:`tree_flatten`. >>> tree = {"b": (2, [3, 4]), "a": 1, "c": None, "d": 5} >>> leaves, treespec = tree_flatten(tree) >>> tree == tree_unflatten(leaves, treespec) True Args: leaves (iterable): The list of leaves to use for reconstruction. The list must match the number of leaves of the treespec. treespec (TreeSpec): The treespec to reconstruct. Returns: The reconstructed pytree, containing the ``leaves`` placed in the structure described by ``treespec``. zhtree_unflatten(leaves, treespec): Expected `treespec` to be instance of PyTreeSpec but got item of type .)r[ TypeErrortyperVr)rdres r=rrPsF& #8 , ,//3H~.>a A     22r@c0[R"UUSSS9$)a$Get an iterator over the leaves of a pytree. See also :func:`tree_flatten`. >>> tree = {"b": (2, [3, 4]), "a": 1, "c": None, "d": 5} >>> list(tree_iter(tree)) [2, 3, 4, 1, None, 5] >>> list(tree_iter(1)) [1] >>> list(tree_iter(None)) [None] Args: tree (pytree): A pytree to flatten. is_leaf (callable, optional): An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: An iterator over the leaf values. Tr.r_)rVrrbs r=rrks#6      r@c0[R"UUSSS9$)aGet the leaves of a pytree. See also :func:`tree_flatten`. >>> tree = {"b": (2, [3, 4]), "a": 1, "c": None, "d": 5} >>> tree_leaves(tree) [2, 3, 4, 1, None, 5] >>> tree_leaves(1) [1] >>> tree_leaves(None) [None] Args: tree (pytree): A pytree to flatten. is_leaf (callable, optional): An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A list of leaf values. Tr.r_)rVrrbs r=rrs#6      r@c0[R"UUSSS9$)aGet the treespec for a pytree. See also :func:`tree_flatten`. >>> tree = {"b": (2, [3, 4]), "a": 1, "c": None, "d": 5} >>> tree_structure(tree) PyTreeSpec({'b': (*, [*, *]), 'a': *, 'c': *, 'd': *}, NoneIsLeaf, namespace='torch') >>> tree_structure(1) PyTreeSpec(*, NoneIsLeaf, namespace='torch') >>> tree_structure(None) PyTreeSpec(*, NoneIsLeaf, namespace='torch') Args: tree (pytree): A pytree to flatten. is_leaf (callable, optional): An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A treespec object representing the structure of the pytree. Tr.r_)rVr!rbs r=r!r!s#6     r@r]restsc<[R"UU/UQ7USSS.6$)aMap a multi-input function over pytree args to produce a new pytree. See also :func:`tree_map_`. >>> tree_map(lambda x: x + 1, {"x": 7, "y": (42, 64)}) {'x': 8, 'y': (43, 65)} >>> tree_map(lambda x: x is None, {"x": 7, "y": (42, 64), "z": None}) {'x': False, 'y': (False, False), 'z': True} If multiple inputs are given, the structure of the tree is taken from the first input; subsequent inputs need only have ``tree`` as a prefix: >>> tree_map(lambda x, y: [x] + y, [5, 6], [[7, 9], [1, 2]]) [[5, 7, 9], [6, 1, 2]] Args: func (callable): A function that takes ``1 + len(rests)`` arguments, to be applied at the corresponding leaves of the pytrees. tree (pytree): A pytree to be mapped over, with each leaf providing the first positional argument to function ``func``. rests (tuple of pytree): A tuple of pytrees, each of which has the same structure as ``tree`` or has ``tree`` as a prefix. is_leaf (callable, optional): An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A new pytree with the same structure as ``tree`` but with the value at each leaf given by ``func(x, *xs)`` where ``x`` is the value at the corresponding leaf in ``tree`` and ``xs`` is the tuple of values at corresponding nodes in ``rests``. Tr.r_)rVr"r5r\r]rns r=r"r"s6N ??       r@c<[R"UU/UQ7USSS.6$)a Like :func:`tree_map`, but do an inplace call on each leaf and return the original tree. See also :func:`tree_map`. Args: func (callable): A function that takes ``1 + len(rests)`` arguments, to be applied at the corresponding leaves of the pytrees. tree (pytree): A pytree to be mapped over, with each leaf providing the first positional argument to function ``func``. rests (tuple of pytree): A tuple of pytrees, each of which has the same structure as ``tree`` or has ``tree`` as a prefix. is_leaf (callable, optional): An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: The original ``tree`` with the value at each leaf is given by the side-effect of function ``func(x, *xs)`` (not the return value) where ``x`` is the value at the corresponding leaf in ``tree`` and ``xs`` is the tuple of values at values at corresponding nodes in ``rests``. Tr.r_)rVr$rps r=r$r$s78          r@ type_or_types_or_predcgr;rus r=map_onlyry<r@cgr;rwrxs r=ryryArzr@cgr;rwrxs r=ryryFrzr@cgr;rwrxs r=ryryLrzr@cgr;rwrxs r=ryryQrzr@cl^^[T[[45(d3[RS:a4[T[ R 5(aS[S[4U4SjjmO[T5(aTmO [S5eS[[/[4S[[/[44U4SjjnU$)aw Suppose you are writing a tree_map over tensors, leaving everything else unchanged. Ordinarily you would have to write: def go(t): if isinstance(t, Tensor): return ... else: return t With this function, you only need to write: @map_only(Tensor) def go(t): return ... You can also directly use 'tree_map_only' rrxr6c>[UT5$r;rZ)rrus r=predmap_only..predpsa!67 7r@z9Argument must be a type, a tuple of types, or a callable.r5cf>^[R"T5S[S[4UU4Sjj5nU$)Nrr6c2>T"U5(aT"U5$U$r;rw)rr5rs r=r>*map_only..wrapper..wrappedysAwwAwHr@)rArBr1r)r5r>rs` r=wrappermap_only..wrapperxs3   q S    r@) rZrituplesys version_infotypes UnionTyperboolcallablerhrr1)rurrs` @r=ryryVs*'$77 G# ,eoo > > 8C 8D 8 8 ' ( ($STThsCx(XseSj-A Nr@cgr;rwrur5r\r]s r=r%r%r@cgr;rwrs r=r%r%rr@cgr;rwrs r=r%r%rr@cgr;rwrs r=r%r%rr@cgr;rwrs r=r%r%rr@c4[[U5"U5X#S9$Nrm)r"ryrs r=r%r%s H23D94 QQr@cgr;rwrs r=r&r&rr@cgr;rwrs r=r&r&rr@cgr;rwrs r=r&r&rr@cgr;rwrs r=r&r&rr@cgr;rwrs r=r&r&rr@c4[[U5"U5X#S9$r)r$ryrs r=r&r&s X34T:D RRr@rc<[XS9n[[X55$r)rallmaprr\r] flat_argss r=r'r' $0I s4# $$r@c<[XS9n[[X55$r)ranyrrs r=r(r(rr@ type_or_typescgr;rwrrr\r]s r=r)r)rr@cgr;rwrs r=r)r)#rr@cgr;rwrs r=r)r).rr@cD^^[X#S9n[UU4SjU55$)Nrmc3Z># UH n[UT5(dMT"U5v M" g7fr;r.0rrrs r= tree_all_only..A"J 1Z=-IwtAww ++)rrrrr\r]rs`` r=r)r)9 $0I J J JJr@cgr;rwrs r=r*r*Drr@cgr;rwrs r=r*r*Orr@cgr;rwrs r=r*r*Zrr@cD^^[X#S9n[UU4SjU55$)Nrmc3Z># UH n[UT5(dMT"U5v M" g7fr;rrs r=r tree_any_only..mrr)rrrs`` r=r*r*err@ prefix_tree full_treecT^^/mS[S[SS4UU4Sjjn[UUUTS9 T$)aReturn a list of broadcasted leaves in ``prefix_tree`` to match the number of leaves in ``full_tree``. If a ``prefix_tree`` is a prefix of a ``full_tree``, this means the ``full_tree`` can be constructed by replacing the leaves of ``prefix_tree`` with appropriate **subtrees**. This function returns a list of leaves with the same size as ``full_tree``. The leaves are replicated from ``prefix_tree``. The number of replicas is determined by the corresponding subtree in ``full_tree``. >>> broadcast_prefix(1, [1, 2, 3]) [1, 1, 1] >>> broadcast_prefix([1, 2, 3], [1, 2, 3]) [1, 2, 3] >>> broadcast_prefix([1, 2, 3], [1, 2, 3, 4]) Traceback (most recent call last): ... ValueError: list arity mismatch; expected: 3, got: 4; list: [1, 2, 3, 4]. >>> broadcast_prefix([1, 2, 3], [1, 2, (3, 4)]) [1, 2, 3, 3] >>> broadcast_prefix([1, 2, 3], [1, 2, {"a": 3, "b": 4, "c": (None, 5)}]) [1, 2, 3, 3, 3, 3] Args: prefix_tree (pytree): A pytree with the same structure as a prefix of ``full_tree``. full_tree (pytree): A pytree with the same structure as a suffix of ``prefix_tree``. is_leaf (callable, optional): An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A list of leaves in ``prefix_tree`` broadcasted to match the number of leaves in ``full_tree``. rsubtreer6NcX>[UTS9nTRU/UR-5 gr)r!extend num_leaves)rr subtreespecr]results r= add_leaves$broadcast_prefix..add_leavess($Wg>  qcK2223r@rm)rrr$)rrr]rrs ` @r=broadcast_prefixrpsGNF4c4F4t44  Mr@c[U5(de[S/UR-U5n[XUS9$![a gf=f)Nrrm)r[rrr ValueError)r\rer]rs r=_broadcast_to_and_flattenrsR #8 , ,, ,sX%8%88(CIAA s 8 AAprotocolc[U5(d[S[U5S35e[S/UR-U5n[ R "U5n[ R"X1S9$)z&Serialize a treespec to a JSON string.z`treespec_dumps(treespec): Expected `treespec` to be instance of PyTreeSpec but got item of type rgr)r)r[rhrirrrPr!r+)rer dummy_tree orig_treespecs r=r+r+sm "8 , ,//3H~.>a A   h&9&9 98DJ!00 bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A tuple where the first element is a list of (key path, leaf) pairs, and the second element is a :class:`TreeSpec` representing the structure of the flattened tree. rLrNrbs r=rrs( M NNr@c[S5e)aGets the leaves of a pytree like ``tree_leaves`` and returns each leaf's key path. Args: tree: a pytree. If it contains a custom type, that type must be registered with an appropriate `tree_flatten_with_path_fn` when registered with :func:`register_pytree_node`. is_leaf: An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A list of (key path, leaf) pairs. rLrrbs r=r r s$ M NNr@c[S5e)afLike :func:`tree_map`, but the provided callable takes an additional key path argument. Args: func: A function that takes ``2 + len(rests)`` arguments, to be applied at the corresponding leaves of the pytrees. The first positional argument to ``func`` is the key path of the leaf in question. The second positional argument is the value of the leaf. tree: A pytree to be mapped over, with each leaf providing the first positional argument to function ``func``. rests: A tuple of pytrees, each of which has the same structure as ``tree`` or has ``tree`` as a prefix. is_leaf: An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns A new pytree with the same structure as ``tree`` but with the value at each leaf given by ``func(keypath, x, *xs)`` where ``keypath`` is the key path at the corresponding leaf in ``tree``, ``x`` is the value at that leaf, and ``xs`` is the tuple of values at corresponding nodes in ``rests``. rLrrps r=r#r#s: M NNr@kpc[S5e)z9Given a key path, return a pretty-printed representation.rLr)rs r=rr7 M NNr@c[S5e)zAGiven an object and a key path, return the value at the key path.rLr)rXrs r=rr<rr@rwr;)g__doc__rArrcollections.abcrtypingrrrrrr typing_extensionsr r rVtorch._vendor.packaging.versionr __version__ ImportErrorr rtorch.utils._pytreeutils_pytreerPr__all__dict_insertion_ordered__TORCH_DICT_SESSION __enter__r1r2r3r4rrrlistrrOpTreeUnflattenFuncrrrKeyPathFlattenWithKeysFuncrCrirr FutureWarningrTrOr[rrarrrrr!r"r$Type2Type3rrTypeAnyFn2Fn3FnFnAny MapOnlyFnryr%r&r'r(r)r*rrintr+ lru_cacher,rr-rrrr r#rr_NODE_REGISTRY_LOCK_cxx_pytree_importedr8r9_cxx_pytree_pending_importsclearrwr@r=rsM  $DD0 3 6  !22  Q   *++4 F44TWM  CL CL CL CL  xtCy''9!::; (3-169: #7?@y/9: /!2G!;< # xtE(C-4H/I3/N)OOP *=+/9==A:>< c<< < #3- < ""56 <$$9:<##67< <~ I +/9==A0 c00 0 #3- 0 ""56 0$$9:0 0  0p+/9==A c    #3-  ""56  $$9:   0%%F8,<% 37# # hx~. /# #P37( ( hx~. /( 49h (V38C=3H33:37    hx~. / c] J37    hx~. /  #Y J37    hx~. /  N37 . 38 . . .hx~. / .  .j37 # 38 # # #hx~. / #  #L d1gtAw d1gtAwQ'(wDIuT#Y^4eooEFGDIuT#Y^445Gad }a aAg"# qc1f# aS(C5#:.. /  DG9R3Z3H  E!Q$KyQ3Y7P  E!Q'N)C1aQT DU:V   G9U3Z3H  HcUD[$95QT:AV + (C5$;*?!?@+uSz+\ 37  QV*   hx~. / 7    37  aCi.   hx~. /  A;    37  aAsl    hx~. /  Aq>    37  *   hx~. / "    37  *   hx~. / #SE4K0   37 R *R  R hx~. / R (C5$;*?!?@R  R 37  QV*   hx~. / 7    37  aCi.   hx~. /  A;    37  aAsl    hx~. /  Aq>    37  *   hx~. / "    37  *   hx~. / #SE4K0   37 S *S  S hx~. / S (C5$;*?!?@S  S37% C5$; % %hx~. /% %37% C5$; % %hx~. /% % 37  QW+   hx~. / 7    37  aDj/   hx~. / A;    37  aAtm    hx~. / Aq>   37 K +K  K hx~. / KK  K 37  QW+   hx~. / 7    37  aDj/   hx~. / A;    37  aAtm    hx~. / Aq>   37 K +K  K hx~. / KK  K37333hx~. /3 #Y 3B37    hx~. / d3i  JX J# J# J sx h3H4>H 7x<737O O hx~. /O 4gsl# $h ./O237O O hx~. /O % O237 O 38 O O Ohx~. / O  O@OwO3O OO'OcO &&)-M&rLD&%AA f%t6v6B--335 f '&&s Aa00 a>