o ,wi@sdZddlmZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZddlmZddlmZddlmZddlmZed Zee d efeefZej Z ej!Z!e"Z#ej$d d Z%Gd dde"Z& dFdGddZ' dFdHddZ(dIddZ)dFdJd"d#Z*Gd$d%d%eZ+Gd&ddeeej,d'Z-Gd(d)d)eee-eZ. dKdLd.d/Z/Gd0d1d1eee.eZ0dMd6d7Z1ed8e-d9Z2dNddOdDdEZ4dS)PzCDefines the `Config` class and associated subclasses and functions.) annotationsN)AnyCallable CollectionDict FrozenSetGenericIterableMapping NamedTupleOptionalSetTupleTypeTypeVarUnion)daglish)history) signatures)tag_typeT.T) use_fallbackc@s eZdZdZddZddZdS) _Placeholderz2A Placeholder class to represent config arguments.cCs ||_dSNindex)selfrrO/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/fiddle/_src/config.py__init__7s z_Placeholder.__init__cCs |j|jkSrrrotherrrr__eq__: z_Placeholder.__eq__N)__name__ __module__ __qualname____doc__rr"rrrrr4s rF buildable Buildableinclude_defaultsboolreturn2Tuple[Tuple[Any, ...], BuildableTraverserMetadata]cCsft||d}t|}t|}dd|jD}dd|jD}t|j|||d}||fS)z'Implement Buildable.__flatten__ method.r*cSsi|] \}}|r|t|qSr) frozenset.0nametagsrrr Es z&_buildable_flatten..cSi|] \}}|t|qSr)tupler1r2entriesrrrr4Js) fn_or_clsargument_names argument_tagsargument_history) ordered_argumentsr6keysvalues__argument_tags__items__argument_history__BuildableTraverserMetadata __fn_or_cls__)r(r* argumentsr>r?r;r<metadatarrr_buildable_flatten>s   rGTuple[daglish.PathElement]cCstddt||dDS)z-Implement Buildable.__path_elements__ method.css.|]}t|trt|nt|VqdSr) isinstancestrrAttrIndexr1r2rrr [s  z+_buildable_path_elements..r.)r6r=r>)r(r*rrr_buildable_path_elementsWs rOclsType[Buildable]cCs,tj|tjtdd|jtjtddddS)zERegisters defaults aware traversal routines for buildable subclasses.Tr. flatten_fn unflatten_fnpath_elements_fnN)"_defaults_aware_traverser_registryregister_node_traverser functoolspartialrG __unflatten__rOrPrrr-_register_buildable_defaults_aware_traverserscs  r\xy check_dagc szt|tsJt|t|urdS|j|jkrdS|jj|jjks%Jdtdfd d }t|jt|jBD]<}|||}|||}|urO|urOJ|usW|urZdSt|trnt|trnt ||dd sndS||krudSq9|rt t j |d dt d }t t j |d dt d }tdd|D} tdd|D} t| t| krdSt| | D] \} } | | krdSqd S)z=Compare if two Buildables are equal, including DAG structure.Fz`Internal invariant violated: has_var_keyword should be the same if __fn_or_cls__'s are the same.keyUnion[str, int]r(r)r,rcs(|j|}|ur|j|}|Sr) __arguments__get__signature_info__ get_default)r`r(valuemissingrrget_value_or_defaultsz0_compare_buildable..get_value_or_defaultr_T)memoizedmemoize_internablesregistrycSg|]}|dqSrr1eltrrr z&_compare_buildable..cSrnrorrqrrrrsrtN)r`rar(r)r,r)rIr)typerDrdhas_var_keywordobjectsetrb_compare_buildablelistriteraterVsortedlenzip) r]r^r_rir`v1v2 x_elements y_elementsx_pathsy_pathsx_pathy_pathrrgrryosd    ryc@sdeZdZUdZded<ded<ded<eiZded <dd d ZdddZ dddZ dddZ dS)rCzOMetadata for a Buildable. This separate class is used for DAG traversals. zCallable[..., Any]r9zTuple[Union[str, int], ...]r:z&Dict[str, FrozenSet[tag_type.TagType]]r;z.Mapping[str, Tuple[history.HistoryEntry, ...]]r<r,cCs |jidS)N)r<)_replacerrrrwithout_historyr#z*BuildableTraverserMetadata.without_historyr? Iterable[Any]Dict[str, Any]cCstt|j|S)zGReturns a dictionary combining ``self.argument_names`` with ``values``.)dictr~r:)rr?rrrrEsz$BuildableTraverserMetadata.arguments Dict[str, set[tag_type.TagType]]cCsttdd|jDS)NcSr5r)rxr0rrrr4z3BuildableTraverserMetadata.tags..) collections defaultdictrxr;rArrrrr3szBuildableTraverserMetadata.tagshistory.HistorycCstdd|jDS)NcSr5r)rzr7rrrr4rz6BuildableTraverserMetadata.history..)rHistoryr<rArrrrrsz"BuildableTraverserMetadata.historyN)r,rC)r?rr,r)r,r)r,r) r$r%r&r'__annotations__typesMappingProxyTyper<rrEr3rrrrrrCs    rCcs6eZdZUdZded<ded<ded<ded <d ed <dRfdd ZdSfdd ZddZej ddZ dTddZ e dUdd Z dVd"d#ZdWd&d'ZdXd,d-ZdYd.d/ZdZd0d1Zd2d3Zd[d4d5Zd[d6d7Zd\d9d:Zd]d=d>Zd^d?d@Zd_dBdCZdDdEZdFdGZd`dJdKZdLdMZdNdOZdafdPdQ ZZ S)br)aBase class for buildable types (``Config`` and ``Partial``). Buildable types implement a ``__build__`` method that is called during ``fdl.build()`` with arguments set on the ``Buildable`` to get output for the corresponding instance. Arguments are stored in the `__arguments__` dict with the following "canonical storage format": Positional-only and variadic-positional arguments use the position index of the argument as a key (of type int); all other arguments use the name of the argument as a key (of type str). TypeOrCallableProducingT[T]rDzDict[Union[str, int], Any]rbrrBz,Dict[Union[str, int], Set[tag_type.TagType]]r@signatures.SignatureInfordr92Union['Buildable[T]', TypeOrCallableProducingT[T]]c s||t}|d|td|tdttt j j |g|Ri|}| D]\}}t |ttfrC|||q1td|t| D]\}} |j|| |j||j|qQdS)awInitialize for ``fn_or_cls``, optionally specifying parameters. Args: fn_or_cls: A callable to configure. The signature of this callable will determine the parameters this ``Buidlable`` can be used to configure. *args: Any positional arguments to configure for ``fn_or_cls``. **kwargs: Any keyword arguments to configure for ``fn_or_cls``. rDrBr@z0Unexpected type received for the argument name: N)__init_callable__rr add_new_valuesuper __setattr__rrrxr SignatureInfosignature_bindingrArIrJint_arguments_set_value ValueErrorrfind_tags_from_annotationsr@updaterBadd_updated_tags) rr9argskwargs arg_historyrEr`rfr2r3 __class__rrrs0   zBuildable.__init__r,NonecsRt|tr tdtd|tdit|}tdtj|ddS)z3Save information on `fn_or_cls` to the `Buildable`.zUsing the Buildable constructor to convert a buildable to a new type or to override arguments is forbidden; please use either `fdl.cast(new_type, buildable)` (for casting) or `fdl.copy_with(buildable, **kwargs)` (for overriding arguments).rDrbrd signatureN)rIr)rrrr get_signaturer)rr9rrrrrs    zBuildable.__init_callable__cCs(tj|dd|jdddt|dS)NcS|Sr) __flatten__r]rrr,z-Buildable.__init_subclass__..cSrr)__path_elements__rrrrr.rrR)rrWrZr\r[rrr__init_subclass__)s zBuildable.__init_subclass__cOst)z.N)rdrrrbvar_positional_startrIsliceindicesr}rzrangecopy index_to_keyrrr) rr`rrrrold_placeholdersnew_placeholdersrk new_valuerrr __delitem__s@          zBuildable.__delitem__rcCsx|j||j}|jj}|durt|jj}|jjr|d8}t|tr4||kr4||jvr4t d|d| ||dS)"Set positional arguments by index.Nrpz*Cannot set positional argument with index z (index out of range).) rdrrbrr}rvar_keyword_namerIr IndexErrorr)rr`rfpositional_numrrr_set_item_by_indexs   zBuildable._set_item_by_index slice_keyrcCs^|jj|jddd\}}|jj}|t|}|dus!|d|krCt|}t|t|kr1tdt||D] \}} | || q6dSddtt|D} | } || |<t|t| D]*}|t| kr| |} t | t r{| | |kruq]|j| j } ||| q]||q]t| } t| }t| |D]}| |} t | t r|j| j } ||| qdS)z"Set positional arguments by slice.TrNraCannot modify the total length of full positional arguments list with __setitem__ when the slice key spans over non-variadic positional arguments. To remove values, use `del config[key]`. To append values to variadic positional arguments, you can use config[fdl.VARARGS:] = value.cSrrrrrrrrsrz0Buildable._set_item_by_slice..)rdrrbrrr}rrr~rrrIrrrr)rrrfrrr index_rangerrvrrrlen_oldlen_newrrr_set_item_by_slicesL         zBuildable._set_item_by_slicecCsD|j|}t|tr|||dSt|tr |||dSdS)rN)rdrrIrrrr)rr`rfrrr __setitem__s   zBuildable.__setitem__Collection[str]cCs$|j}t|jj}||}|S)aProvide a useful list of attribute names, optimized for Jupyter/Colab. ``__dir__`` is often implicitly called by tooling such as Jupyter/Colab to provide autocomplete suggestions. This implementation of ``__dir__`` makes it easy to see what are valid attributes to get, set, or delete. Returns: A list of useful attribute names corresponding to set or unset parameters. )rbr>rxrdvalid_param_namesunion)rset_argument_namesr all_namesrrr__dir__s  zBuildable.__dir__c s4tjdr jj}ntj}g}tjjfddjD}|D]>}j |d}j |t }|s:|t urbt|}|rR|dd t dd|Dd 7}|t ur]|d |7}| |q$tj}d |}t|t|t|d krd d d fdd|D}n|}d|d|d|dS)Nr&csg|] }|jjvr|qSr)rdrrMrrrrs1s  z&Buildable.__repr__..r[z, css|]}t|VqdSr)rJ)r1tagrrrrN=sz%Buildable.__repr__..]=PcSsddd|dDS)N cSsg|]}d|qS)z rr1r]rrrrsNrtz6Buildable.__repr__..indent..)joinsplit)srrrindentMsz"Buildable.__repr__..indent,csg|]}d|qS)r rr )rrrrsPs<(z)]>)rrDr&rJrzrdrrbr@rcrr r|appendrur$r}) rformatted_fn_or_clsformatted_params param_namesr2r3rf param_strformatted_params_no_linebreakr)rrr__repr__)s>    $   zBuildable.__repr__cCs|j|S)akShallowly copies this ``Buildable`` instance. This copy implementation ensures that setting parameters on a copy of a ``Buildable`` won't affect the original instance. However, the copy is shallow, so parameter values will still refer to the same instances of objects after the copy. Returns: A shallow copy of this ``Buildable``. )rZrrrrr__copy__Vs zBuildable.__copy__memoDict[int, Any]cCs<|jj|t|jj<tt|}|jt |j||S)zFDeepcopies this Buildable, skipping copying of ``__signature_info__``.) rdridrwrru__dict__rrdeepcopy)rrresultrrr __deepcopy__ds zBuildable.__deepcopy__cCst||ddS)a9Returns true iff self and other contain the same argument values. This compares the specific types of ``self`` and ``other``, the function or class being configured, and then checks for equality in the configured arguments. Default argument values are considered in this comparison: If one ``Buildable`` has an argument explicitly set to its default value while another does not, the two will still be considered equal (motivated by the fact that calls to the function or class being configured will be the same). Argument history is not compared (i.e., it doesn't matter how the ``Buildable``'s being compared reached their current state). Args: other: The other value to compare ``self`` to. Returns: ``True`` if ``self`` equals ``other``, ``False`` if not. Trj)ryr rrrr"oszBuildable.__eq__cCst|j}d|d<|S)a Gets pickle serialization state, removing some fields. For now, we discard the ``__signature_info__.signature`` (which can be recalculated), because these tend to contain values which cannot be serialized. Returns: Dict of serialized state. Nrd)rr)rrrrr __getstate__s zBuildable.__getstate__cs@|j||jdurt|j}tdtj|ddSdS)zLoads pickle serialization state. This re-derives the signature if not present. Args: state: State dictionary, from ``__getstate__``. Nrdr) rrrdrrrDrrr)rstaterrrr __setstate__s    zBuildable.__setstate__)r9r)r9rr,r)r,r-)r?rrFrC)r,rH)r2rJ)r`rrfr)r`r)r2rJrfr)r`r)r`rrfr)rrrfr)r`rrfr)r,r)rr)r,r)!r$r%r&r'rrrrabcabstractmethodrr classmethodrZrrrrrrrrrrrrrrr r"r!r# __classcell__rrrrr)sB %     '     '  1 -  ) metaclassc@s*eZdZUdZded<ded<ddZdS) Configa A mutable representation of a function or class's parameters. This class represents the configuration for a given function or class, exposing configured parameters as mutable attributes. For example, given a class:: class SampleClass: '''Example class for demonstration purposes.''' def __init__(self, arg, kwarg=None): self.arg = arg self.kwarg = kwarg a configuration may (for instance) be accomplished via:: class_config = Config(SampleClass, 1, kwarg='kwarg') or via:: class_config = Config(SampleClass) class_config.arg = 1 class_config.kwarg = 'kwarg' A function can be configured in the same ways:: def test_function(arg, kwarg=None): return arg, kwarg fn_config = Config(test_function, 1) fn_config.kwarg = 'kwarg' If the class/function has positional arguments, they can be accessed through the `[]` syntax:: def test_function(a, b, /, c, *args): return locals() fn_config = Config(test_function, 1, 2, 3, 4, 5) # Read assert fn_config[0] == 1 assert fn_config[:] == [1, 2, 3, 4, 5] # Modify fn_config[0] = 'a' fn_config.c = 'c' # `fdl.VARARGS` represents the start of variadic positional args (*args) fn_config[fdl.VARARGS:] = ['x', 'y'] assert fn_config[:] == [1, 2, 3, 'x', 'y'] # Delete del fn_config[0] del fn_config[fdl.VARARGS:] assert fn_config[:] == [fdl.NO_VALUE, 2, 3] NOTE: Directly calling `list` methods like `append` and `extend` is not supported, and will not mutate the config. Like with Python lists, slice operations on Configs effectively create a copy of the underlying sequence. NOTE: If using `slice` as key for modifying the config, and the `slice` spans over positional-only or positional-or-keyword arguments, the provided value must have the same length as that of the slice range. fn_config[2:4] = ['a', 'b'] # OK fn_config[2:4] = ['m'] # Not OK. Will raise an error! A ``Config`` instance may be transformed into instances and function outputs by passing it to the ``build`` function. The ``build`` function invokes each function or class in the configuration tree (appropriately propagating the built outputs from nested ``Config``'s). For example, using the ``SampleClass`` config from above:: instance = build(class_config) assert instance.arg == 1 assert instance.kwarg == 'kwarg' If the same ``Config`` instance is used in multiple places within the configuration tree, its function or class is invoked only once during ``build``, and the result shared across all occurrences of the ``Config`` instance. (See ``build`` documentation for further details.) To create a new instance of a ``Config`` with the same parameter settings that will yield a separate instance during ``build``, ``copy.copy()`` or ``copy.deepcopy()`` may be used. rrDrrdcOs|j|i|S)aBuilds this ``Config`` for the given ``args`` and ``kwargs``. This method is called during `build` to get the output for this `Config`. Args: *args: Positional arguments to pass to ``self.__fn_or_cls__``. **kwargs: Keyword arguments to pass to ``self.__fn_or_cls__`. Returns: The result of calling ``self.__fn_or_cls__`` with the given ``args`` and ``kwargs``. rDrrrrrs zConfig.__build__N)r$r%r&r'rrrrrrr)s W r)rfUnion[T, NoValue]r3Optional[Set[tag_type.TagType]]cCs.|turd}|r|dt|7}t||S)aIdentity function to return value if set, and raise an error if not. Args: value: The value to return. tags: The tags associated with the value. (Used in generating error messages if `value` is not set.) Returns: The value `value` passed to it. z[Expected all `TaggedValue`s to be replaced via fdl.set_tagged() calls, but one was not set.z Unset tags: )rrJrTaggedValueNotFilledError)rfr3rrrrtagged_value_fns  r.c@s8eZdZUdZded<ded<eddZdd dZdS)ra,Placeholder class for TaggedValue instances. Instances of this class are generally transitory; when passed as an argument of a Fiddle Buildable, will be expanded into that argument's values and tags. However, they may survive as stand-alone objects within tuples, lists, and dictionaries. rrDrrdcCs |jdS)Nrf)r@rrrrr37s zTaggedValueCls.tagsrrrr,rcOs0|jtur td|j|j|d|ji|S)Nz2Unexpected __fn_or_cls__ in TaggedValueCls; found:r3)rDr. RuntimeErrorr3rrrrr;s zTaggedValueCls.__build__N)rrrrr,r)r$r%r&r'rpropertyr3rrrrrr*s   rdataclass_type Type[Any] field_namerJcCs.t|D]}|j|kr|jtjkSqdS)zEReturns true if . uses a default_factory.F)rfieldsr2default_factoryMISSING)r1r3fieldrrrrDs  r BuildableT)bound Buildable[T] Union[Callable[..., T], Type[T]]cCs|jS)z$Returns the callable of a Buildable.r*)r(rrr get_callableOsr<)include_var_keywordr* include_unsetinclude_positionalinclude_equal_to_defaultr=r>r?r@Dict[Union[int, str], Any]c Csv|s|rtdi}t}t|jjD]w\}\} } | j| j| jfvrq|} | |j vs6||j vrG| j| j krG| |j vrA|j | } n|j |} n| j | j urS|rR| j } n|rWt } | |urq|sb| | j krq| j| j krm| ||<n| || <| j| jkr||j vr|j |||<|d7}||j vs|q|r|j D]\} } |jj| } | dus| j| jkr| || <q|sdd|D}|S)aYReturns arguments of a Buildable, ordered by the signature. Args: buildable: The buildable whose arguments should be returned. include_var_keyword: If True, then include arguments that will be consumed by the buildable's callable's `VAR_KEYWORD` parameter (e.g. `**kwargs`). include_defaults: If True, then include arguments that have not been explicitly set, but that have a default value. Can not be combined with `include_equal_to_default=False`. include_unset: If True, then include arguments that have not been explicitly set, that don't have a default value. The value for these parameters will be `fdl.NO_VALUE`. include_positional: If False, positional-only and variadic positional arguments will be excluded from the output. include_equal_to_default: If False, then exclude arguments that are equal to their default value (using `==`). Can not be combined with `include_defaults=True`. Returns: A dictionary mapping argument keys to values or `fdl.NO_VALUE`. Argument keys are either positional indices or names. zEExclude_equal_to_default and include_defaults are mutually exclusive.rpNcSs i|] \}}t|tr||qSr)rIrJ)r1rrrrrr4s z%ordered_arguments..)rrwrrdrrArr VAR_KEYWORDrbrrrrrc) r(r=r*r>r?r@runsetrr2rrfrrrr=TsV             r=)F)r(r)r*r+r,r-)r(r)r*r+r,rH)rPrQ)r]r)r^r)r_r+r)rfr+r3r,r,r)r1r2r3rJ)r(r:r,r;)r(r)r=r+r*r+r>r+r?r+r@r+r,rA)5r' __future__rr$rrrrXrtypingrrrrrrr r r r r rrrr fiddle._srcrrrrrTypeOrCallableProducingTNoValuerrwrNodeTraverserRegistryrVrrGrOr\ryrCABCMetar)r)r.rrr8r<r=rrrrs\ D      FVl