+ &j,^RIHt^RIHt^RIHtHtHtHtH t H t H t RR/RRllt RRRR/R R llt RR R lltR RltRRltRRltR#)) defaultdict) zip_longest)AnyCallableDictListOptionalTupleUnionis_leafNc jV^8dQhR\R\R\R\\,R\/#)fntreerestr returnrrr )formats"a/Users/jameslopez/projects/CWCArchive/cwc-podcast/.venv/lib/python3.14/site-packages/mlx/utils.py __annotate__rs93333$'32:82D33c aaaaSeS!V4'd S!V.SO5!#\V\\34'dC\V4pVVV3Rl\ V44p\ VR4'dV!V!#V!V4#\V\ 4'd@VP4UaUu/uF!wopS\SV.V3RlS4O5RS/bK# upp#S!V.SO5!#uuppi)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``. c3`<a"TF"wop\SV.V3RlS4O5RS/xK$ R#5i)c34<"TF qS,xK R#5iN.0ris& r %tree_map...1s!51A$$r N)tree_map)rchildr rr rs& @rr!tree_map..0s3 +5 R G!5!5 Gw G+s*._fieldsc34<"TF qS,xK R#5irrrrks& rr!r&7s$84aqTT4r#r ) isinstancelisttupletype enumeratehasattrdictitemsr$)rrr rTreeTypesubtreesr*r%sf&dj ` rr$r$sHwt}}$ D4- ( (: %dO '.dI&>&>x"VHXDVV D$  !JJL (5 xEJ$84$8J'J J(  $  s)'Cpathc V^8dQhR\R\R\R\\,R\\,R\/#)rrrrr r5rr)rs"rrr>sM5%5%5% 5% 5%h  5% 3- 5%  5%rc aaaaaSeS!V4'd S!W1.SO5!#\V\\34'd9V'dV R2MRo\V4pV!VVVV3Rl\ V444#\V\ 4'dUV'dV R2MRoVP 4UaUu/uF'wopS\SV.V3RlS4O5RSRS S 2/bK) upp#S!W1.SO5!#uuppi)aApplies ``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 .c 3l<a"TF(wop\SV.V3RlS4O5RSRS S 2/xK* R#5i)c34<"TF qS,xK R#5irrrs& rr!/tree_map_with_path...f04aqTT4r#r r5N)tree_map_with_path)rr%r rr prefixrs& @rr!%tree_map_with_path..dsQ ,5 E 040 :A KQ(STRU ,s04c34<"TF qS,xK R#5irrr)s& rr!r@nr=r#r r5)r+r,r-r.r/r1r2r>) rrr r5rr3r*r%r?s f&d$j ` @rr>r>>s Bwt}}$$t$$ D4- ( (#D6: &dO    D$  #D6 !JJL  )5 !E040:AKQ(STRU )   $$t$$ s/-C*cxV^8dQhR\R\R\\,R\\\ \ \\3,,\\\3,3,,R\\ \ \\3,,\\\3,3,/#)rrr?r destinationr)rstrr rr rr r)rs"rrrvsII I Ih I%U38_ 5tCH~ EFG I  4c3h $sCx. 01 Irc.Vf.p\V\4'dVPpM.\V\4'dVPpM \ R4hVe#V!V4'dV!VR,V3.4V#\V\\ 34'd(\V4FwrV\Wa RV 2W#4K V#\V\4'd-VP4Fwrx\W RV 2W#4K V#V!VR,V3.4V#)aFlattens 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. z;Destination should be either a list or a dictionary or None:NNr8) r+r,extendr1update ValueErrorr-r/ tree_flattenr2) rr?r rC_add_to_destinationr itemkeyvalues &&&& rrJrJvsP +t$$)00 K & &)00VWWwt}}fRj$/01$u && GA 1# E'$**,JC (!C5 17 H'&*d+,- rcV^8dQhR\\\\\3,,\ \\3,3,R\/#)rrr)r rr rDrr)rs"rrrs=/C/CtE#s(O4d38nDE/C#/Crc  \V\4'dVP4MTp\V4^8Xd \ \ V44wr#VR8XdV#\ \4pVFDwr#VPR^R7vrVV'gRMV^,pWE,PWc34KF \RVP444p.pVF_wrTP\V \V4, 4U u.uFp /NK up 4VP\WJ,44Ka V#uup i \d9TP4U U u/uFwrT \T 4bK Muup p iup p u#i;i)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. r9r8)maxsplitc3<"TFp\V4V3xK R#5ir)int)ridxs& rr!!tree_unflatten..sA#s3xos)r+r1r2lennextiterrr,splitappendsortedkeysrGrangetree_unflattenrI) rr2rMrNchildren current_idxnext_idxr\lr r*_vs & rr^r^sG,'tT22DJJLE 5zQ$u+&  "9L4 H !$3!; %28A;$$h%67 CAAA DA HH%CF "34"3Qb"34 5 HH^HK0 15 C191AB1A>!$$1ABBCs12AE D; ,E;EFE65 FFc>VeV!V4'dVfV#V!W!4#Tp\V\\34'dVFp\WWC4pK V#\V\4'd&VP 4Fp\WWC4pK V#VfV#V!WA4#)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_reducer1values)rr initializerr accumulatorrLs&&&& rrfrfs2wt}}"*tE;0EEK$u &&D%b EK  D$  KKMD%b EK" #*tE;0EErc *a\V\\\34'd\ V4^8XdRp\V\\\34'd\ V4^8XdRpVfVeV#VeVfV#\V\\34'dC\V\\34'd'\ V4pV!V3Rl\ W444#\V\4'd\V\4'dt\VP44\VP44,Uu/uF1pV\VPVR4VPVR4S4bK3 up#Sf \R4hS!W4#uupi)adMerge 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``. Nc3@<"TFwr\WS4xK R#5ir) tree_merge)rabmerge_fns& rr!tree_merge..6s! 3N41JqX & &3NszOTrees contain elements at the same locations but no merge function was provided) r+r1r,r-rVr.rsetr\rlgetrI)tree_atree_bror3r*s&&f rrlrls\&4u-..3v;!3C&4u-..3v;!3C ~&,  fn &4-((Zu -N-N< 3>v3N    FD ! !j&>&>'#fkkm*<< < z&**Q-vzz!T/BHM M<   ,  '' s?7F)r9NN)NNr) collectionsr itertoolsrtypingrrrrr r r r$r>rJr^rfrlrrrrxsW$!DDD3GK3l5%#' 5%  5%pIX/Cd'T((r