o qoiM'@sdZddlmZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZddlmZddlmZddlmZe dZeed efe efZejd d Gd d d Zd&ddZd'ddZd(ddZd)d d!ZGd"d#d#e eejeZGd$d%d%e eejeZdS)*zHDefines the `Partial` and `ArgFactory` classes and associated functions.) annotationsN)AnyCallableDictGenericTupleTypeTypeVarUnion) arg_factory)config)daglishT.T)frozenc@seZdZUdZded<dS)_BuiltArgFactoryzThe result of building an ``ArgFactory``. This wrapper is returned by ``ArgFactory.__build__``, and then consumed by the ``__build__`` method of the containing ``Partial`` or ``ArgFactory`` object. Callable[..., Any]factoryN)__name__ __module__ __qualname____doc____annotations__rrG/home/ubuntu/.local/lib/python3.10/site-packages/fiddle/_src/partial.pyr"s  rvaluerreturnboolcCddd}tj||S)zFReturns true if ``value`` contains any ``_BuiltArgFactory`` instances.state daglish.StatecSs*t|trdS||rt||SdS)NTF) isinstanceris_traversableanyyield_map_child_values)noderrrrvisit0s  z$_contains_arg_factory..visitNrrr MemoizedTraversalrunrr%rrr_contains_arg_factory-s r+cCr)aMakes a copy of value with any _BuiltArgFactory ``f`` replaced by ``f()``. The copy is "shallow" in the sense that only containers that (directly or indirectly) contain _BuiltArgFactories are replaced. E.g.: >>> x = [] >>> value = [[], _BuiltArgFactory(list)] >>> result = _invoke_arg_factories(value) >>> assert value[0] is result[0] # not replaced Args: value: The structured value containing _BuiltArgFactories. Returns: A copy of ``value``. rrcSsdt|tr |S||r0||}|j|\}}tddt||j D}|r,|S| S|S)NcSsg|]\}}||uqSrr).0oldnewrrr Tsz8_invoke_arg_factories..visit..) r rrr!flattened_map_childrennode_traverserflattenallzipvalues unflatten)r$r subtraversalold_vals_no_child_changedrrrr%Ms   z$_invoke_arg_factories..visitNr&r'r*rrr_invoke_arg_factories;s  r;argcCs&t|ts t|s |Sttt|S)aConverts a structure-of-ArgFactory's to an ArgFactory-of-structure. If `arg` is a `_BuiltArgFactory`, or is a nested structure that doesn't contain any `_BuiltArgFactory`s, then return it as-is. Othewise, return a new `_BuiltArgFactory` whose factory returns a copy of `arg` with any `_BuiltArgFactory` `f` replaced by `f()`. Args: arg: The argument value to convert. Returns: `arg`; or a `_BuiltArgFactory` whose factory returns a copy of `arg` with any `_BuiltArgFactory` `f` replaced by `f()`. )r rr+ functoolspartialr;)r<rrr_promote_arg_factory]sr?fnrargs Tuple[Any]kwargsDict[str, Any]functools.partialcsdddd|D}dd|D}fdd|D}dd|D}|}t|D]*\}}|rLd d|D}tj|g|Ri|}i}q0tj|g|Ri|}i}q0|rftj|fi|}tj|fi|S) agReturns `functools.partial` or `arg_factory.partial` for `fn`. If `args` or `kwargs` contain any `ArgFactory` instances, then return `arg_factory.partial(fn, *args, **kwargs)`. Otherwise, return `functools.partial(fn, *args, **kwargs)`. If any `args` or `kwargs` are nested structures that contain one or more `ArgFactory`s, then convert them to an `ArgFactory` that returns a copy of that structure with the nested `ArgFactory`s invoked. Args: fn: The function argument for the partial. args: The positional arguments for the partial. kwargs: The keyword arguments for the partial. cSs t|tSNr r)rrrris_arg_factorys z&_build_partial..is_arg_factorycSsg|]}t|qSrr?r,r<rrrr/sz"_build_partial..cSsi|] \}}|t|qSrrIr,namer<rrr sz"_build_partial..cs i|] \}}|r||jqSrrrKrHrrrMs  cSs i|] \}}t|ts||qSrrGrKrrrrMs cSsg|]}|jqSrrNrJrrrr/s)items itertoolsgroupbyr r>r=)r@rArCarg_factory_kwargsfunctool_kwargsresult is_factory arg_valuesrrOr_build_partialss(  rXc@"eZdZUdZded<ddZdS)PartialaA ``Partial`` config creates a partial function or class when built. In some cases, it may be desired to leave a function or class uninvoked, and instead output a corresponding ``functools.partial`` object. Where the ``Config`` base class calls its underlying ``__fn_or_cls__`` when built, this ``Partial`` instead results in a partially bound function or class:: partial_config = Partial(SampleClass) partial_config.arg = 1 partial_config.kwarg = 'kwarg' partial_class = build(partial_config) instance = partial_class(arg=2) # Keyword arguments can be overridden. assert instance.arg == 2 assert instance.kwarg == 'kwarg' A ``Partial`` can also be created from an existing ``Config``, by using the ``fdl.cast()`` function. This results in a shallow copy that is decoupled from the ``Config`` used to create it. In the example below, any further changes to ``partial_config`` are not reflected by ``class_config`` (and vice versa):: partial_config = fdl.cast(Partial, class_config) class_config.arg = 'new value' # Further modification to `class_config`. partial_class = build(partial_config) instance = partial_class() assert instance.arg == 'arg' # The instance config is still 'arg'. ``Partial`` also supports configuring function/class with positional arguments. Please see docstring of ``Config`` class for details. TypeOrCallableProducingT[T] __fn_or_cls__cOst|j||S)a%Builds this ``Partial`` for the given ``args`` and ``kwargs``. This method is called during ``build`` to get the output for this ``Partial``. Args: *args: Positional arguments to partially bind to ``self.__fn_or_cls__``. **kwargs: Keyword arguments to partially bind to ``self.__fn_or_cls__``. Returns: A partial object (``functools.partial`` or ``arg_factory.partial``) for the callable ``self.__fn_or_cls__``, which binds the positional arguments ``args`` and the keyword arguments ``kwargs``. )rXr\selfrArCrrr __build__szPartial.__build__Nrrrrrr_rrrrrZs  rZc@rY) ArgFactoryaA configuration that creates an argument factory when built. When an ``ArgFactory`` is used as a parameter for a ``fdl.Partial``, the partial function built from that ``fdl.Partial`` will construct a new value for the parameter each time it is called. For example: >>> def f(x, noise): return x + noise >>> cfg = fdl.Partial(f, noise=fdl.ArgFactory(random.random)) >>> p = fdl.build(cfg) >>> p(5) == p(5) # noise has a different value for each call to `p`. False In contrast, if we replaced ``fdl.ArgFactory`` with ``fdl.Config`` in the above example, then the same noise value would be added each time ``p`` is called, since ``random.random`` would be called when ``fdl.build(cfg)`` is called. ``ArgFactory``'s can also be nested inside containers that are parameter values for a ``Partial``. In this case, the partial function will construct the parameter value by copying the containers and replacing any ``ArgFactory`` with the result of calling its factory. Only the containers that (directly or indirectly) contain ``ArgFactory``'s are copied; any elements of the containers that do not contain ``ArgFactory``'s are not copied. ``ArgFactory`` can also be used as the parameter for another ``ArgFactory``, in which case a new value will be constructed for the child argument each time the parent argument is created. ``ArgFactory`` should *not* be used as a top-level configuration object, or as the argument to a ``fdl.Config``. r[r\cOs$|s|r tt|j||St|jSrF)rrXr\r]rrrr_s zArgFactory.__build__Nr`rrrrras $ ra)rrrr)rrrr)r<rrr)r@rrArBrCrDrrE)r __future__r dataclassesr=rQtypingrrrrrrr r fiddle._srcr r r rTypeOrCallableProducingT dataclassrr+r;r?rX BuildablerZrarrrrs& (      " 9 4