GJj,XddlmZddlmZddlmZmZmZmZm 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 efdZddZddZy)) defaultdict) zip_longest)AnyCallableDictListOptionalTupleUnionN)is_leaffntreerestr returnc |r |gSt|ttfr:t|}fdt |D}t |dr||S||St|t r<|jDcic]\}t|gfdDdi!c}}S|gScc}}w)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``. c3XK|] \}t|gfdDdi"yw)c3(K|] }| ywN.0ris S/Users/ahmed/devFolder/claude-voice/.venv/lib/python3.12/site-packages/mlx/utils.py z%tree_map...1s!51!A$r N)tree_map)rchildrr r rs @rrztree_map..0s4 +5 R G!5!5 Gw G+s&*_fieldsc3(K|] }| ywrrrrks rrztree_map..7s$84aQqT4rr ) isinstancelisttupletype enumeratehasattrdictitemsr)r rr rTreeTypesubtreesr"rs` `` ` rrrsHwt}$ D4- (: %dO '.dI&>x"VHXDVV D$ !JJL (5 xEJ$84$8J'J J(  $  s $B=r pathr.c |r ||gSt|ttfr1|r|dndt|}|fdt |DSt|t rJ|r|dnd|j Dcic]$\}t|gfdDd&c}}S||gScc}}w)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 .c3bK|]%\}t|gfdDd'yw)c3(K|] }| ywrrrs rrz/tree_map_with_path...f04aQqT4rr-N)tree_map_with_path)rrrr r prefixrs @rrz%tree_map_with_path..dsL ,5 E 040 :A6(STRU ,s+/c3(K|] }| ywrrr!s rrz%tree_map_with_path..nr4rr-)r#r$r%r&r'r)r*r5) r rr r.rr+r"rr6s ` ` ` ` @rr5r5>sBwt}$$t$$ D4- (#D6: &dO    D$ #D6 !JJL  )5 !E040:A6(STRU )   $$t$$ s)Cr6 destinationc|g}t|tr |j}n(t|tr |j}n t d|||r||dd|fg|St|tt fr(t|D]\}}t||d||||St|tr-|jD]\}}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 Noner0) r#r$extendr)update ValueErrorr%r' tree_flattenr*) rr6r r8_add_to_destinationritemkeyvalues rr>r>vsP +t$)00 K &)00VWWwt}fQRj$/01$u & GAt &1# E'$**,JC 6(!C5 17K H'&*d+,- c t|tr|jn|}t|dk(rt t |\}}|dk(r|St t}|D]9\}}|jdd^}}|sdn|d}||j||f; td|jD}g}|D]V\} } |jt| t|z D cgc]} ic} |jt|| X|Scc} w#t$r7|jD cic]\} } | t| ncc} } wc} } cYSwxYw)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:r1r0)maxsplitrc36K|]}t||fywr)int)ridxs rrz!tree_unflatten..sA#s3xos)r#r)r*lennextiterrr$splitappendsortedkeysr;rangetree_unflattenr=) rr*rArBchildren current_idxnext_idxrOlrr"_vs rrQrQsT,'tT2DJJLE 5zQ$u+& U "9L4 H U!$3!; h%28A;$$h%67 CAAA DAq HH%CF "34"3Qb"34 5 HH^HQK0 15 C191AB1AA>!$$1ABBCs1AD!+ D 4'D!D!!E!=E E! E!c|||r ||S|||S|}t|ttfr|D]}t||||}|St|tr%|j D]}t||||}|S||S|||S)aApplies a reduction to the leaves of a Python tree. This function reduces Python trees into an accumulated result by applying the provided function ``fn`` to the leaves of the tree. Example: >>> 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 accumulatorr@s rrYrYs2wt}"*tE;0EEK$u &D%b$ WEK  D$ KKMD%b$ WEK" #*tE;0EErCc t|tttfrt |dk(rd}t|tttfrt |dk(rd}|||S|||St|ttfrK|]\}}t||ywr) tree_merge)rabmerge_fns rrztree_merge..6s# 3N41aJq!X &3NszOTrees contain elements at the same locations but no merge function was provided) r#r)r$r%rIr&rsetrOr_getr=)tree_atree_brbr+r"s ` rr_r_sN&4u-.3v;!3C&4u-.3v;!3C ~&,  fn &4-(Zu -N< 3>vv3N    FD !j&>'#fkkm*<< < z&**Q-vzz!T/BHM M<   ,  '' s 5E)r1NN)NNr) collectionsr itertoolsrtypingrrrrr r r rr5strr>rQrYr_rrCrrksm$!DDDHL333$'32:82D33t#' 5%5% 5% 5%h  5% 3- 5%  5%t"&JN I I Ih I%U38_ 5tCH~ EFG I  4c3h $sCx. 01 IX/CtE#s(O4d38nDE/C#/Cd'T((rC