o ,wim@sdZddlZddlZddlZddlmZmZmZmZm Z m Z m Z m Z m Z ddlmZddlmZddlmZddlmZddlmZdd lmZGd d d eZejd d GdddeZGdddejdZejd d GdddZejd d GdddeZejd d GdddeZ ejd d GdddeZ!ejd d GdddeZ"ejd d GdddeZ#ejd d Gdd d Z$ejd d Gd!d"d"Z%Gd#d$d$Z&dZd%ed&efd'd(Z'dZd%ed&efd)d*Z(d+d,Z)d-d.Z*Gd/d0d0Z+d1e&d2efd3d4Z,d%ed&ed2efd5d6Z-d7d8Z.d9ed:ed2dfd;d<Z/d=e ed>fd:efd?d@Z0d=e ed>fdAeej1effdBdCZ2dDej3dEefdFdGZ4dEedDej3fdHdIZ5ejd d GdJdKdKZ6GdLdMdMe6Z7GdNdOdOe8Z9ej:e9dPdQdRdQdSdQdTd9efdUdVZ;d[dXdYZLibrary for finding differences between Fiddle configurations.N) AnyCallableDictIterableListMappingSequenceTupleUnion)config)daglish)mutate_buildable)tag_type)tagging)daglish_legacyc@seZdZdZdS)AlignmentErrorz,Indicates that two values cannot be aligned.N)__name__ __module__ __qualname____doc__rrP/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/fiddle/_src/diffing.pyrsrT)frozenc@s,eZdZUdZeed<ejed<ddZdS) Referencez1Symbolic reference to an object in a `Buildable`.roottargetcCsd|jt|jdS)Nz )rr path_strrselfrrr__repr__)szReference.__repr__N) rrrrstr__annotations__r Pathr rrrrr#s   rc@s6eZdZUdZejed<ejde dej fddZ dS) DiffOperationzpBase class for diff operations. Each `DiffOperation` describes a single change to a target `daglish.Path`. rparentchildcCst)z:Applies this operation to the specified child of `parent`.)NotImplementedErrorrr%r&rrrapply4zDiffOperation.applyN) rrrrr r#r"abcabstractmethodr PathElementr)rrrrr$-s  r$) metaclassc@sveZdZUdZeedfed<dZeedfed<ddZ dd Z d e ege fd dfd d Z eejfdddZdS)DiffaDescribes a set of changes to a `Buildable` (or structure). Attributes: changes: A set of `DiffOperation`s describing individual modifications. new_shared_values: A list of new shared values that can be pointed to using `Reference` objects in `changes`. .changesrnew_shared_valuescCs,t|jts tdt|jtstddS)NzExpected changes to be a tuplez(Expected new_shared_values to be a tuple) isinstancer0tuple ValueErrorr1rrrr __post_init__Fs  zDiff.__post_init__cCs8dddd|jDdddd|jDdS)NzDiff(changes=(  cs|] }d|dVqdSz ,Nr.0changerrr NzDiff.__str__..z" ), new_shared_values=( csr7r8r)r;valrrrr=Pr>z )))joinr0r1rrrr__str__Lsz Diff.__str__ ignore_fnreturncs$tfdd|jD}t||jS)aICreates a new `Diff` without changes that satisfy a predicate. Args: ignore_fn: A function that accepts a `DiffOperation` and returns `True` if this diff should be ignored (i.e. excluded from the returned `Diff`). Returns: A new `Diff` without changes for which the `ignore_fn` returned `True`. c3s|] }|s|VqdSNrr:rBrrr=^s  z(Diff.ignoring_changes..)r3r0r/r1)rrB new_changesrrErignoring_changesSs  zDiff.ignoring_changescs$tdtffdd }||S)aCreates a new `Diff` without changes involving the given `paths`. Args: paths: an `Iterable` of `daglish.Path` objects that should be ignored in the returned `Diff`. Returns: A new `Diff` without changes that relate to the given `paths`. r<cstfddDS)Nc3s|] }t|jVqdSrD)r is_prefixr)r; target_pathr<rrr=qs  z:Diff.ignoring_paths.._ignore_fn..)anyrJpathsrJr _ignore_fnps z'Diff.ignoring_paths.._ignore_fn)setr$rG)rrMrNrrLrignoring_pathsds  zDiff.ignoring_pathsN)rCr/)rrrrr r$r"r1rr5rArboolrGrr r#rPrrrrr/:s  r/c@@eZdZUdZejed<eee fed<de dej fddZ dS) SetValuezChanges the target to new_value; fails if the target already has a value. The target's parent may not be a sequence (list or tuple). r new_valuer%r&cCsLt|tjrt||j|jdSt|tjr|j||j<dStd|d)z.Sets `child.follow(parent)` to self.new_value.zSetValue does not support .N) r2r AttrsetattrnamerTKeykeyr4r(rrrr)s  zSetValue.applyN rrrrr r#r"r rrr-r)rrrrrSx  rSc@rR) ModifyValuezvChanges the target to new_value; fails if the target has no prior value. The target's parent may not be a tuple. rrTr%r&cCst|tjrt||jdSt|tjrt||j|jdSt|tj r-|j||j <dSt|tj r;|j||j <dSt d|d)z4Replaces `child.follow(parent)` with self.new_value.zModifyValue does not support rUN)r2r BuildableFnOrClsr update_callablerTrVrWrXIndexindexrYrZr4r(rrrr)s    zModifyValue.applyNr[rrrrr]r\r]c@s0eZdZUdZejed<dedejfddZ dS) DeleteValuezRemoves the target from its parent; fails if the target has no prior value. The target's parent may not be a sequence (list or tuple). rr%r&cCsDt|tjrt||jdSt|tjr||j=dStd|d)zDeletes `child.follow(parent)`.DeleteValue does not support rUN)r2r rVdelattrrXrYrZr4r(rrrr)s   zDeleteValue.applyN) rrrrr r#r"rr-r)rrrrrbs  rbc@:eZdZUdZejed<ejed<de dej fddZ dS) AddTagzXAdds a tag to a Buildable argument. The target's parent must be a `fdl.Buildable`. rtagr%r&cC2t|tjrt||j|jdStd|dNrcrU)r2r rVradd_tagrXrgr4r(rrrr) z AddTag.applyN rrrrr r#r"rTagTyperr-r)rrrrrf   rfc@re) RemoveTagz]Removes a tag from a Buildable argument. The target's parent must be a `fdl.Buildable`. rrgr%r&cCrhri)r2r rVr remove_tagrXrgr4r(rrrr)rkzRemoveTag.applyNrlrrrrrornroc@"eZdZUdZeed<eed<dS) AlignedValueszA pair of aligned values. old_valuerTN)rrrrrr"rrrrrr  rrc@rq)AlignedValueIdsz#A pair of `id`s for aligned values. old_value_id new_value_idN)rrrrintr"rrrrrurtruc @seZdZdZ  d*dedededefddZedefd d Zedefd d Z edefd dZ edefddZ ddZ ddZ ddZddZdeefddZdeefddZdedefdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)S)+ DiffAlignmenta Alignment between two structures, named `old` and `new`. `DiffAlignment` is a partial bidirectional mapping between nested objects in two structures (`old` and `new`). When building diffs, this alignment is used to decide which objects in `old` should be mutated to become objects in `new`. This class places the following restrictions on when objects in `old` and `new` may be aligned: * Each `old_value` may be aligned with at most one `new_value` (and vice versa). * `type(new_value)` must be equal to `type(old_value)`. * If `isinstance(old_value, Sequence)`, then `len(new_value)` must be equal to `len(old_value)`. * If `old_value` and `new_value` are aligned, then it must be possible to mutate `old_value` to become `new_value` using `DiffOperation`s. * Alignments may not create cycles. E.g., `old_value` may not be aligned with `new_value` if some value contained in `old_value` is aligned with a value that contains `new_value`. * Aligned values must be "memoizable" (as defined by `daglish.is_memoizable`). These restrictions help ensure that a `Diff` can be built from the alignment. Note: `DiffAlignment` is not guaranteed to catch all violations of these restrictions, since some are difficult or expensive to detect. oldnewold_namenew_namecCs(||_||_||_||_i|_i|_dS)aCreates an empty alignment between objects in `old` and `new`. In the new alignment, no objects in `old` are aligned with any objects in `new` (including the root objects `old` and `new` themselves). Call `DiffAlignment.align` to add alignments. Args: old: The root object of the `old` structure. new: The root object of the `new` structure. old_name: A name for the `old` structure (used to print alignments). new_name: A name for the `new` structure (used to print alignments). N)_old_new _old_name _new_name_new_by_old_id_old_by_new_id)rrzr{r|r}rrr__init__s  zDiffAlignment.__init__rCcC|jS)z:The root object of the `old` structure for this alignment.)r~rrrrrzr*zDiffAlignment.oldcCr)z:The root object of the `new` structure for this alignment.)rrrrrr{r*zDiffAlignment.newcCr)z3The name of the `old` structure for this alignment.)rrrrrr| r*zDiffAlignment.old_namecCr)z3The name of the `new` structure for this alignment.)rrrrrr}%r*zDiffAlignment.new_namecCt||jvS)z6Returns true if `old_value` is aligned with any value.)idrrrsrrris_old_value_aligned*z"DiffAlignment.is_old_value_alignedcCr)z6Returns true if `new_value` is aligned with any value.)rrrrTrrris_new_value_aligned.rz"DiffAlignment.is_new_value_alignedcC|jt|S)z=Returns the object in `new` that is aligned with `old_value`.)rrrrrr new_from_old2rzDiffAlignment.new_from_oldcCr)z=Returns the object in `old` that is aligned with `new_value`.)rrrrrr old_from_new6rzDiffAlignment.old_from_newcsfddjDS)zBReturns a list of `(old_value, new_value)` for all aligned values.cs$g|]\}}tjt||qSr)rrrrr;old_idrTrrr <sz0DiffAlignment.aligned_values..ritemsrrrraligned_values:s zDiffAlignment.aligned_valuescCsdd|jDS)zFReturns a list of `(id(old_val), id(new_val))` for all aligned values.cSsg|] \}}t|t|qSr)rurrrrrrCs z3DiffAlignment.aligned_value_ids..rrrrraligned_value_idsAszDiffAlignment.aligned_value_idsrsrTcCs,|||||jt|<||jt|<dS)aAligns `old_value` with `new_value`. Assumes that `old_value` is contained in `self.old`, and that `new_value` is contained in `self.new`. Args: old_value: The value in `old` that should be aligned with `new_value.` new_value: The value in `new` that should be aligned with `old_value.` Raises: AlignmentError: If `old_value` and `new_value` can not be aligned. For example, this can happen if either value is already aligned, or if the values are incompatible. See the docstring for `DiffAlignment` for a full list of restrictions. Note: the `align` method is not guaranteed to catch all violations of these restrictions, since some are difficult or expensive to detect. N)_validate_alignmentrrrrrsrTrrralignHs zDiffAlignment.aligncCst|sdSt|sdS||rdS||rdSt|t|ur&dSt|tr5t|t|kr5dSt|tt t t j fsE||krEdSdS)z>Returns true if `old_value` could be aligned with `new_value`.FT) r is_memoizablerrtyper2rlenlistr3dict config_lib Buildablerrrr can_align^s    zDiffAlignment.can_aligncCst|s td|dt|std|d||r(tdd|||r6tdd|t|t|urMtdt|dt|d t|trit|t|kritd t|dt|d t|t t t t j fs||krtd t|d |d |d dSdS)zERaises AlignmentError if old_value can not be aligned with new_value.z old_value=z1 may not be aligned because it is not memoizable.z new_value=z(An alignment has already been added for z old value z new value zBAligning objects of different types is not currently supported. (z vs )zHAligning sequences with different lengths is not currently supported. (zValues of type z* may only be aligned if they are equal. (z != N)r rrrrrr2rrrr3rrrrrrrrqsP      z!DiffAlignment._validate_alignmentcCs&d|jd|jdt|jdS)Nz)rrrrrrrrr s zDiffAlignment.__repr__csftjjddtjjddfddD}fdd|D}|s,|ddd|S) NTmemoizable_onlycs(g|]}|jd|jdfqS)r)rvrw)r; aligned_ids)id_to_new_pathid_to_old_pathrrrs  z)DiffAlignment.__str__..c s8g|]\}}djt|djt|qS)z z -> )r|r rr})r;old_pathnew_pathrrrrsz (no objects aligned)zDiffAlignment: r6)rcollect_paths_by_idrzr{rappendr@)rold_to_new_pathslinesr)rrrrrAs   zDiffAlignment.__str__Nrzr{)rrrrrr!rpropertyrzr{r|r}rrrrrrrrrurrrrr rArrrrrys@  ryrzr{c CsTt||||}tj|dd}tj|dd}|D]\}}||vr'|||q|S)a Aligns any memoizable object that is contained in both `old` and `new`. Returns a `DiffAlignment` that aligns any memoizable object that can be reached by traversing both `old` and `new`. (It must be the same object, as defined by `is`; not just an equal object.) I.e., if `old_values` is the list of all memoizable objects reachable from `old`, and `new_values` is the list of all memoizable objects reachable from `new`, then this will call `alignment.align(v, v)` for any `v` that is in both `old_values` and `new_values`. Args: old: The root object of the `old` structure. new: The root object of the `new` structure. old_name: A name for the `old` structure. new_name: A name for the `new` structure. Returns: A `DiffAlignment`. Tr)ryrcollect_value_by_idrr) rzr{r|r} alignment old_by_id new_by_idvalue_idvaluerrr align_by_ids rcCst||||}|||tj|dd}tj|dd}|D]\}}t|s7||vr7|||r7|||qtj|dd} tj|dd} | D]\} } | | vrb|| | | rb|| | | qJ|D]%} |D]} t | t | ur| | krt | r|| | r|| | qmqg|S)aReturns an alignment between `old` and `new`, based on heuristics. These heuristics may be changed or improved over time, and are not guaranteed to stay the same for different versions of Fiddle. The current implementation makes three passes over the structures: * The first pass aligns any memoizable object that can be reached by traversing both `old` and `new`. (It must be the same object, as defined by `is`; not just an equal object.) * The second pass aligns any memoizable objects in `old` and `new` that can be reached using the same path. * The third pass aligns any memoizable objects in `old` and `new` that have equal values. Note: this takes `O(size(old) * size(new))` time. Values that are "too simple" (e.g., empty lists) are never aligned this pass. Args: old: The root object of the `old` structure. new: The root object of the `new` structure. old_name: A name for the `old` structure. new_name: A name for the `new` structure. Returns: A `DiffAlignment`. Tr) ryrrrr_is_small_containerrcollect_value_by_pathvaluesr_should_align_by_equality)rzr{r|r}rrrrr path_to_old path_to_newpathrsrTrrralign_heuristicallys4       rcCs&t|ttfrtt|dkrdSdS)z0Returns if value is a small Sequence or Mapping.PTFr2rrrreprrrrrrsrcCs.t|ttfr |s dStt|dkrdSdS)aOReturns true if two equal copies of `value` should be aligned. Generally, we should avoid aligning "small" values by equality, since they might be unrelated, and just happen to be equal. This function uses several heuristics to decide whether the value should be aligned. Args: value: The value that might be aligned. F Trrrrrrs  rc @s(eZdZUdZeed<eeed<eeed<e e ee j fed<defddZ defd d Zd e jd efd dZde j dejd ejdejfddZde j dejd ejfddZde j de eefd e eefde eeffddZde j deed eedeefddZded edefddZdS)_DiffFromAlignmentBuilderzClass used to build a `Diff` from a `DiffAlignment`. This private class is used to implement `build_diff_from_alignment`. rr0r1paths_by_old_idcCsNg|_g|_||_tj|jdd|_||jr!||j|j us%t ddS)NTrzAThe root objects alignment.old and alignment.new must be aligned.) r0r1rrrrzrrrr{r4)rrrrrr#s z"_DiffFromAlignmentBuilder.__init__rCcCs<|js|jr tdt|j|jjtt |jt |jS)z=Returns a `Diff` between `alignment.old` and `alignment.new`.z)build_diff should be called at most once.) r0r1r4rmemoized_traverse record_diffsrr{r/r3rrrr build_diff1s z$_DiffFromAlignmentBuilder.build_diff new_pathsrTccsdV}|j|s,t|dkst|s|St|j}|j|tdt|fdS|j |}|j t |d}t |t jrJ|||||nt |trX|||||n t |tre|||||td|dS)aDaglish traversal function that records diffs to generate `new_value`. If `new_value` is not aligned with any `old_value`, and `new_value` can be reached by a single path, returns `new_value` as-is. If `new_value` is not aligned with any `old_value`, and `new_value` can be reached by multiple paths, then adds `new_value` to `self.new_shared_values`, and returns a reference to the new shared value. If `new_value` is aligned with any `old_value`, then updates `self.changes` with any changes necessary to mutate `old_value` into `new_value`. Returns a copy of `new_value`, or a `Reference` pointing at a shared copy of `new_value` or an `old_value` that will be transformed into `new_value`. Args: new_paths: The paths to a value reachable from `alignment.new`. new_value: The value reachable from `alignment.new`. Yields: None Nr1)rrrrz)rrrr rr1rrr`rrrr2rrrecord_buildable_diffsrrecord_dict_diffsrrecord_sequence_diffs)rrrT diff_valuerarsrrrrr8s&         z&_DiffFromAlignmentBuilder.record_diffsrrsrc Cst|t|kr|tf}|jt|t||j|jkr*|||||j D]4}t ||}|t |f}||j vrYt ||} | || sX|jt|t ||q-|jt |q-|j D]}||j vr|t |f}|jt|t ||qedS)zFRecords changes needed to turn Buildable `old_value` into `new_value`.N)r get_callabler r^r0rr]__argument_tags__record_tag_diffs __arguments__getattrrValigned_or_equalrbrS) rrrsrTrold_callable_pathrX old_childold_child_path new_childrrrrjs0        z0_DiffFromAlignmentBuilder.record_buildable_diffscCs|j}|j}tg}dd}tt|t|BD]>}|t|f} |||} |||} t| | |dD] } |jt| | q6t| | |dD] } |jt | | qJqdS)zsz<_DiffFromAlignmentBuilder.record_tag_diffs..)rZN) rrOsortedr rVgetr0rrorf)rrrsrT old_arg_tags new_arg_tags empty_settag_namearg_namerold_tagsnew_tags removed_tag added_tagrrrrs  z*_DiffFromAlignmentBuilder.record_tag_diffscCs|D],\}}|t|f}||vr(||||s'|jt|||q|jt|q|D]}||vrL|t|f}|jt|||q3dS)z@Records changes needed to turn dict `old_value` into `new_value.N) rr rYrr0rr]rbrS)rrrsrTrrZrrrrrrsz+_DiffFromAlignmentBuilder.record_dict_diffscCsLt|D]\}}|t|f}||||s#|jt|||qdS)zDRecords changes needed to turn sequence `old_value` into `new_value.N) enumerater r`rr0rr])rrrsrTrrarrrrrrs z/_DiffFromAlignmentBuilder.record_sequence_diffscCsXt|s t|r|j|o|j||uS||urdSt|t|ur(dS||kS)akReturns true if `old_value` and `new_value` are aligned or equal. * If either `old_value` or `new_value` is memoizable, then returns True if they are aligned. * Otherwise, then returns True if they are equal. Args: old_value: A value reachable from `self.alignment.old`. new_value: A value reachable from `self.alignment.new`. TF)r rrrrrrrrrrs z*_DiffFromAlignmentBuilder.aligned_or_equalN)rrrrryr"rr$rrrxr r#rr/rPathsrrrrrrrrrQrrrrrrsD   2       rrrCcCs t|S)aReturns a `Diff` with the changes from `alignment.old` to `alignment.new`. Args: alignment: The `DiffAlignment` between two structures (`old` and `new`). Returns: A `Diff` describing the changes needed to transform `old` into `new`. For values in `new` that are aligned with values in `old`, the diff describes how to modify `old_value` in place to become `new_value`. Values in `new` that are not aligned are added by the diff as new values. )rr)rrrrbuild_diff_from_alignments rcCst||}t|S)zBuilds a diff between `old` and `new` using heuristic alignment. Args: old: The root object of the `old` structure. new: The root object of the `new` structure. Returns: A `Diff` describing the changes between `old` and `new`. )rr)rzr{rrrrrs rcs~ifddtj}g}jD] }t|ttfr2t|j}|t j ||dq||qt t ||S)aReturns a copy of `diff` with references resolved. I.e., each `Reference` in `diff` is replaced with the object it points to. * References with root `"old"` will be replaced with objects in `old_root`. * References with root `"new_shared_values"` will be replaced with objects in `result.new_shared_values` (i.e., in the copy of the diff that is returned -- *not* in the original diff). Args: diff: The `Diff` that should be copied with references resolved. old_root: The root of the structure used to replace any references where `Reference.target == "old"`. Raises: ValueError: If any reference in `diff` can not be resolved (e.g., if a reference whose root is `"old"` has a path that does not exist in `old_root`). c3s~t|s |St|vrt|St|tsdV}n)|jdkr+t|j}n|jdkr?tj|j}t |}nt d|j|t|<|S)Nrzr1zUnexpected Reference.root ) r rrr2rr follow_pathrr1rtraverse_with_pathr4)roriginal_diff_valuetransformed_diff_valueoriginal_targetdiffold_root"original_to_transformed_diff_valuereplace_referencesrrrs6       z3resolve_diff_references..replace_references)rT) rrr1r0r2r]rSrTr dataclassesreplacer/r3)rrr1r0r<rTrrrresolve_diff_referencess%  rr structurecCs$t|}t||}t|j|dS)aNApply `diff` to `structure`, modifying it in-place. Args: diff: A `Diff` describing a set of changes to apply. structure: The structure that should be modified. Raises: ValueError: If `diff` is incompatible with `structure`. If an error is raised, then `structure` may be left in a partially updated state. N)copydeepcopyr_apply_changesr0)rrrrr apply_diff0s  rr0.cCshtj|dd}t||tttttfD]}|D]}t||r0||j dd}| ||j dqqdS)aGApplies `changes` to `structure` (modifying it in-place). For each `(path, diff_op)` in `changes`, modifies the value at `follow_path(structure, path)` as specified by `diff_op`. Args: changes: Dictionary mapping target to `DiffOperation`, specifying the changes that should be made. The `DiffOperation`s may not contain `Reference`s -- use `resolve_diff_references` to resolve them before calling this function. structure: The structure that should be modified in-place. Raises: ValueError: If `changes` is incompatible with `structure`. TrN) rr_validate_changesrbror]rSrfr2rr))r0r path_to_valueop_typediff_opr%rrrrGs  rrcCsg}|D]}t|tttttfstdt||j}|s$| dq| |dd}|durC| dt |d|ddqt |d|sb| dt |d|dd t|d qt||d}t|tr|s| dt |d|dd qt|tr|s| dt |d|dd qt|tr|r| dt |d|dd qqt|dkrtd|d|rtddddt|DdS)zRaises ValueError if any change is incompatible with `path_to_value`. Args: changes: Dictionary mapping target to `DiffOperation`. path_to_value: Dictionary mapping `daglihs.Path` to the value at each path. zUnsupported DiffOperation type z6Modifying the root `structure` object is not supportedNrz For =rzparent does not exist.zparent has unexpected type rUzvalue not found.z1value not found; use SetValue to add a new value.z2already has a value; use ModifyValue to overwrite.rzUnable to apply diff: rzUnable to apply diff:css|]}d|VqdS)z * Nr)r;errrrrr=z$_validate_changes..)r2rbror]rSrfr4rrrrr r_path_element_is_compatible_child_has_valuerr@r)r0rerrorsrrr% has_valuerrrrlsZ   rr&r%cCsJt|tjr t|tp$t|tjot|tp$t|tjtjfo$t|tj S)z;Returns True if `child` could describe a child of `parent`.) r2r r`rrYrrVr^rr)r&r%rrrrs  rcCsft|tjr |jt|kSt|tjr|j|vSt|tjr dSt|tjr,|j |j vSt d|)z.Returns true if the parent[child] has a value.TzUnsupported PathElement: ) r2r r`rarrYrZr^rVrXrr4)r%r&rrrrs      rc@eZdZdZddZdS)AnyValuez?Object used by `skeleton_from_diff` to encode an unknown value.cCsdS)N*rrrrrr szAnyValue.__repr__Nrrrrr rrrrr s r c@seZdZdZdZddZdS) AnyCallablezBObject used by `skeleton_from_diff` to encode an unknown callable.r cKstd)Nz!AnyCallable should not be called.)r4)rkwargsrrr__call__szAnyCallable.__call__N)rrrrrrrrrr s r c@r) ListPrefixaObject used by `skeleton_from_diff` to encode lists. This is used to indicate that the list may contain additional elements. In particular, if the diff used to create a skeleton accesses a list using `Index[i]`, then we know that the list has at least `i` elements. cCsdddd|DS)Nz[%s...]rcss|]}|dVqdS)z, Nr)r;r&rrrr=rz&ListPrefix.__repr__..)r@rrrrr szListPrefix.__repr__Nr rrrrrs rcCs t|dfSrD)r3xrrrrs rcCst|SrD)r)r_rrrrscCstddtt|DS)Ncss|]}t|VqdSrD)r r`)r;irrrr=rz..)r3rangerrrrrrs) flatten_fn unflatten_fnpath_elements_fnc stfdd}|jD]?}t|tpt|jdtj}t|j|t|ttfr1t ||j t|t rKt t|jdd|jdj|jq t ||jS)aReturns a minimal object that can be used as the target for the `diff`. Finds the set of `old` paths that occur in `diff`, and returns a minimal "skeleton" object that makes those paths valid. I.e. `daglish.follow_path(skeleton, path)` is valid for each `old` path. The leaves of the skeleton are `AnyValue` objects, and any `Config`s in the skeleton use `AnyCallable` as their callable. Both `AnyValue` and `AnyCallable` will render as "*" in graphviz. List values will have an Ellipsis object just past the last referenced value, to indicate that the diff allows for additional elements. Args: diff: The `Diff` object used to search for paths. c3s*~t|tr|jdkrt|jdVS)Nrz)r2rr_add_path_to_skeletonr)rrrrradd_reference_targets  z0skeleton_from_diff..add_reference_targetrN)r r0r2rSrr r^rr]rrrTrorrjrrXrgr1)rrr< skip_leafrrrskeleton_from_diffs(     rFcCs|s|St|tr1t|dtjtjfrtt}nt|dtjr't }n t|dtj r1i}t |dkr;|r;|St|dtjr^t|tjsKJ|dj |j vr]t||dj tnPt|dtjrt|t smJ|djt |kr|ddt|djdt |D7}n#t|dtj rt|tsJ||djtn td|dt|d||dd|}t|dtjrt|tjsJt||dj ||St|dtjrt|t sJ|||dj<|St|dtj rt|tsJ|||dj<|S)zReturns a copy of `skeleton`, updated to make `path` valid. Args: skeleton: A skeleton structure built by `skeleton_from_diff`. path: A path that should be made valid. skip_leaf: If true, then don't add the leaf value of the path. rrcSsg|]}tqSr)r )r;rrrrrsz)_add_path_to_skeleton..zUnuspported PathElement N)r2r r rVr^rConfigr r`rrYrrXrrWrarr setdefaultrZr4rfollow)skeletonrrr&rrrrsL (rr)F)=rr+rrtypingrrrrrrrr r fiddle._srcr rr r rrfiddle._src.experimentalrr4r dataclassobjectrABCMetar$r/rSr]rbrfrorrruryrrrrrrrrrrr#rr-rrr r rrregister_node_traverserrrrrrrsz,         =      D</L%  .  ,