j,ddlmZddlmZddlmZmZmZmZm Z m Z m Z dddededed e ed ef d Z ddd dededed e ed e ed ef dZ ddeded e ede e ee eefeeeffd e ee eefeeefff dZde ee eefeeeffd efdZddZddZdS)) defaultdict) zip_longest)AnyCallableDictListOptionalTupleUnionN)is_leaffntreerestr returnc|r |gRSt|ttfrLt|}fdt |D}t |dr||n ||St|t r"fd|DS|gRS)aApplies ``fn`` to the leaves of the Python tree ``tree`` and returns a new collection with the results. If ``rest`` is provided, every item is assumed to be a superset of ``tree`` and the corresponding leaves are provided as extra positional arguments to ``fn``. In that respect, :meth:`tree_map` is closer to :func:`itertools.starmap` than to :func:`map`. The keyword argument ``is_leaf`` decides what constitutes a leaf from ``tree`` similar to :func:`tree_flatten`. .. code-block:: python import mlx.nn as nn from mlx.utils import tree_map model = nn.Linear(10, 10) print(model.parameters().keys()) # dict_keys(['weight', 'bias']) # square the parameters model.update(tree_map(lambda x: x*x, model.parameters())) Args: fn (callable): The function that processes the leaves of the tree. tree (Any): The main Python tree that will be iterated upon. rest (tuple[Any]): Extra trees to be iterated together with ``tree``. is_leaf (callable, optional): An optional callable that returns ``True`` if the passed object is considered a leaf or ``False`` otherwise. Returns: A Python tree with the new values returned by ``fn``. Nc3ZK|]$\}t|gfdDRdiV%dS)c3(K|] }|V dSN.0ris S/lsinfo/ai/hellotax_ai/base_platform/venv/lib/python3.11/site-packages/mlx/utils.py z%tree_map...0s'!5!51!A$!5!5!5!5!5!5r Ntree_map)rchildrr r rs @rrztree_map../sk  5 R G!5!5!5!5!5!5!5 G G Gw G G      r_fieldscTi|]#\}t|gfdDRdi$S)c3(K|] }|V dSrrrrks rrz&tree_map...6s'$8$8aQqT$8$8$8$8$8$8rr r)rrr$r r rs @r ztree_map..5s_   5 xEJ$8$8$8$84$8$8$8JJJ'JJ   r) isinstancelisttupletype enumeratehasattrdictitems)r rr rTreeTypesubtreess` `` rrrsHwwt}}r$ D4- ( ( ::      %dOO   '.dI&>&>Vxx""HHXDVDVV D$         JJLL    r$rr pathr1c|r ||gRSt|ttfr?|r|dndt|}|fdt |DSt|t r,|r|dndfd|DS||gRS)a7Applies ``fn`` to the path and leaves of the Python tree ``tree`` and returns a new collection with the results. This function is the same :func:`tree_map` but the ``fn`` takes the path as the first argument followed by the remaining tree nodes. Args: fn (callable): The function that processes the leaves of the tree. tree (Any): The main Python tree that will be iterated upon. rest (tuple[Any]): Extra trees to be iterated together with ``tree``. is_leaf (Optional[Callable]): An optional callable that returns ``True`` if the passed object is considered a leaf or ``False`` otherwise. path (Optional[Any]): Prefix will be added to the result. Returns: A Python tree with the new values returned by ``fn``. Example: >>> from mlx.utils import tree_map_with_path >>> tree = {"model": [{"w": 0, "b": 1}, {"w": 0, "b": 1}]} >>> new_tree = tree_map_with_path(lambda path, _: print(path), tree) model.0.w model.0.b model.1.w model.1.b N.c3dK|])\}t|gfdDRdV*dS)c3(K|] }|V dSrrrs rrz/tree_map_with_path...e'00aQqT000000rr0Ntree_map_with_path)rrrr r prefixrs @rrz%tree_map_with_path..cs  5 E 00004000  :A6ST         rc ^i|](\}t|gfdDRd)S)c3(K|] }|V dSrrr#s rrz0tree_map_with_path...mr7rr0r8)rrr$r r r:rs @rr%z&tree_map_with_path..ks{   5 !E00004000:A6ST   r)r&r'r(r)r*r,r-)r rr r1rr.r:s` ` ` @rr9r9=sDBwwt}}r$$t$$$$ D4- ( (%#+D::x       &dOO       D$   %#+D       !JJLL     r$$t$$$$rr4r: destinationc:|g}t|tr|j}n,t|tr|j}nt d|#||r||dd|fg|St|tt fr.t|D]\}}t||d||||St|tr3| D]\}}t||d||||S||dd|fg|S)anFlattens a Python tree to a list of key, value tuples. The keys are using the dot notation to define trees of arbitrary depth and complexity. .. code-block:: python from mlx.utils import tree_flatten print(tree_flatten([[[0]]])) # [("0.0.0", 0)] print(tree_flatten([[[0]]], prefix=".hello")) # [("hello.0.0.0", 0)] tree_flatten({"a": {"b": 1}}, destination={}) {"a.b": 1} .. note:: Dictionaries should have keys that are valid Python identifiers. Args: tree (Any): The Python tree to be flattened. prefix (str): A prefix to use for the keys. The first character is always discarded. is_leaf (callable): An optional callable that returns True if the passed object is considered a leaf or False otherwise. destination (list or dict, optional): A list or dictionary to store the flattened tree. If None an empty list will be used. Default: ``None``. Returns: Union[List[Tuple[str, Any]], Dict[str, Any]]: The flat representation of the Python tree. Nz;Destination should be either a list or a dictionary or Noner3) r&r'extendr,update ValueErrorr(r* tree_flattenr-) rr:r r=_add_to_destinationritemkeyvalues rrCrCuszP +t$$X)0 K & &X)0VWWWwwt}}fQRRj$/0111$u &&  F FGAt &1 E E E E$**,, I IJC 6 1 1C 1 17K H H H H&*d+,--- rc t|tr|n|}t|dkr't t |\}}|dkr|St t}|D]G\}}|dd^}}|sdn|d}|| ||fH td| D}g}|D]i\} } | dt| t|z D| t|| j|S#t$r!d|DcYSwxYw) aRecreate a Python tree from its flat representation. .. code-block:: python from mlx.utils import tree_unflatten d = tree_unflatten([("hello.world", 42)]) print(d) # {"hello": {"world": 42}} d = tree_unflatten({"hello.world": 42}) print(d) # {"hello": {"world": 42}} Args: tree (list[tuple[str, Any]] or dict[str, Any]): The flat representation of a Python tree. For instance as returned by :meth:`tree_flatten`. Returns: A Python tree. r?r4r3)maxsplitrc38K|]}t||fVdSr)int)ridxs rrz!tree_unflatten..s,AA#s3xxoAAAAAArcg|]}iSrr)r_s r z"tree_unflatten..s444Qb444rc4i|]\}}|t|Sr)tree_unflatten)rr$vs rr%z"tree_unflatten..s&BBBA>!$$BBBr)r&r,r-lennextiterrr'splitappendsortedkeysr@rangerQrB) rr-rFrGchildren current_idxnext_idxrYlrr$s rrQrQs,'tT22 >> from mlx.utils import tree_reduce >>> tree = {"a": [1, 2, 3], "b": [4, 5]} >>> tree_reduce(lambda acc, x: acc + x, tree, 0) 15 Args: fn (callable): The reducer function that takes two arguments (accumulator, current value) and returns the updated accumulator. tree (Any): The Python tree to reduce. It can be any nested combination of lists, tuples, or dictionaries. initializer (Any, optional): The initial value to start the reduction. If not provided, the first leaf value is used. is_leaf (callable, optional): A function to determine if an object is a leaf, returning ``True`` for leaf nodes and ``False`` otherwise. Returns: Any: The accumulated value. )r&r'r( tree_reducer,values)r r initializerr accumulatorrEs rr`r`s2wwt}}"*tt;0E0EEK$u &&F F FD%b$ WEEKK F D$  FKKMM F FD%b$ WEEKK F#*tt;0E0EE rcttttfrt dkrdttttfrt dkrdSStttfrPtttfr4t }|fdt DSttrfttrQfdttzDStdS)aMerge two Python trees in one containing the values of both. It can be thought of as a deep dict.update method. Args: tree_a (Any): The first Python tree. tree_b (Any): The second Python tree. merge_fn (callable, optional): A function to merge leaves. Returns: The Python tree containing the values of both ``tree_a`` and ``tree_b``. rNc3@K|]\}}t||VdSr) tree_merge)rabmerge_fns rrztree_merge..5sD  +/1aJq!X & &      rc i|]<}|t|d|d=Sr)rfget)rr$ritree_atree_bs rr%ztree_merge..9sS    z&**Q--vzz!T/B/BHMM   rzOTrees contain elements at the same locations but no merge function was provided) r&r,r'r(rSr)rsetrYrB)rlrmrir.s``` rrfrfs&4u-..3v;;!3C3C&4u-..3v;;!3C3C ~&,  fn &4-(((Zu -N-N(<<x    3>vv3N3N       FD ! ! (j&>&> (      ''#fkkmm*<*<<     ,  x'''r)r4NN)NNr) collectionsr itertoolsrtypingrrrrr r r rr9strrCrQr`rfrrrrss:######!!!!!!DDDDDDDDDDDDDDDDDDHL33333$'32:82D33333t#' 5%5%5%5% 5% 5%h  5% 3- 5%  5%5%5%5%t"&JN II I Ih I%U38_ 5tCH~ EFG I  4c3h $sCx. 01 IIIIX/CtE#s(O4d38nDE/C#/C/C/C/Cd''''T((((((((((((r