o ,wiJ@sdZddlZddlZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZddlmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZddlZ ej!d dGdddZ"de e"de#de e#fddZ$de e"de e#fddZ%     dLdej&dede#de#de ej'de d f d!d"Z(de#de#d#e e j)d$e*de j+f d%d&Z,eege j)fZ-d'eed(e e#d)e-de e j)fd*d+Z.de#d,e ej/e#fd)e-de e j)fd-d.Z0dej&de ej/fd/d0Z1d1e ej/d2efd3d4Z2e eej/e ej3fZ4dej&de4fd5d6Z5dej&de#d,e ej/e#fd)e-de e j)f d7d8Z6d9e j)d:ej7d)e-de j)fd;d<Z8d=e#d>ej/d)e-fd?d@Z9d=e#de#fdAdBZ:dCede#fdDdEZ;d>ej/de#fdFdGZdS)Mz6Library for converting generating fiddlers from diffs.N)AnyCallableDictListLiteralOptionalSetTuple)daglish)diffing)config)mutate_buildable)taggingimport_manager namespace)py_val_to_cst_converter)daglish_legacyT)frozenc@s(eZdZUeed<ejed<ddZdS) ObjectToNameprefixpathcCst|SN)id)selfr]/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/fiddle/_src/codegen/codegen_diff.py__hash__*szObjectToName.__hash__N)__name__ __module__ __qualname__str__annotations__r Pathrrrrrr%s   r all_to_name param_namereturncsfdd|DS).Returns suggested names for a list of objects.cs$g|]}|jdt|jqS)_)r _path_to_namer.0to_namer&rr 2sz)assign_explicit_names..r)r%r&rr.rassign_explicit_names.s r0csi}|D]}|jdd}||jt|g|qi|D]&\}}t|dkr3||d<q"|D]}|jdd}|jt||<q5q"fdd|DS)r(Nrcsg|]}|qSrrr+result_as_dictrrr/Isz&assign_short_names..)r setdefaultrr*appenditemslen)r% name_to_pathsr-sub_pathnamegrouprr4rassign_short_names8s   r>fiddlercfgexplicitdiffold func_namervariable_naming)rAshortc s|durt||t}n |j||t|}g}|durctdd|jDt |t |t j dD]t fddttdDra|tdqEnt |t j dD] |td qj|d krt||}nt|}fd d t||D} fd d|jD} tjdddtjt|ddtjtjdtjt|| | ddg} tjtj| d} g} | t|j| | 7} | t || | 7} | t!||| | 7} t"||| t#|j$}t%j&|'|gd}|S)asReturns the CST for a fiddler function that applies the changes in `diff`. The returned `cst.Module` consists of a set of `import` statements for any necessary imports, followed by a function definition for a function whose name is `func_name`, which takes a single parameter named `param_name` containing a `fdl.Config` (or other `Buildable` or structure), and mutates that `Config` in-place as described by `diff`. The body of the returned function has three sections: * The first section creates variables for any new shared values that are added by the diff (i.e., values in `diff.new_shared_values`). * The second section creates variables to act as aliases for values in the in the input `Config`. This ensures that we can still reference those values even after we've made mutations to the `Config` that might make them unreachable from their original location. * The final section modifies the `Config` in-place, as described by `diff.changes`. Changes are grouped by the parent object that they modify. This section contains one statement for each change. Args: diff: A `fdl.Diff` describing the change that should be made by the fiddler function. old: The original config that is transformed by `diff`. If specified, then this is used when creating aliases for values in the input `Config` to determine which paths need to have aliases created. (In particular, it is used to determine which paths are aliases for one another.) If not specified, then pessimistically assume that aliases must be created for all referenced paths. func_name: The name for the fiddler function. param_name: The name for the parameter to the fiddler function. import_manager: Existing import manager. Usually set to None, but if you are integrating this with other code generation tasks, it can be nice to share. variable_naming: Whether to create intermediate variables with long, explicit names, or just capture the last elements of a path. Returns: An `cst.Module` object. You can convert this to a string using `result.code`. NcSsg|]}|jqSrtargetr,changerrrr/z%fiddler_from_diff..keyc3s |] }d|vVqdSrr)r,i)modified_pathsrrr sz$fiddler_from_diff..r2moved_ original_rAcs"i|] \}}|jj|ddqS))r)r get_new_name)r,r-r<rrr sz%fiddler_from_diff..csg|] }t|dqS)shared_)rT_name_for_value)r,valuerrrr/scSs t|tjSr) isinstancetypes ModuleTyperXrrrs z#fiddler_from_diff..r)matcherpriority converter)r&moved_value_namesnew_shared_value_names)additional_converters)body)( namespace_lib Namespaceaddimport_manager_lib ImportManagerr_find_used_pathssetchanges_add_path_aliasessortedr path_stranyranger9r7rr0r>zipnew_shared_valuesrValueConverter functoolspartial_convert_moduler Reference_convert_referenceconvert_py_val_to_cst#_cst_for_new_shared_value_variables_cst_for_moved_value_variables_cst_for_changes_cst_for_fiddlerboolimports_by_full_namecstModulesorted_import_lines)rBrCrDr&rrE used_pathsmoved_values_to_name initial_namesrbrcvalue_converters pyval_to_cstrer?resultr)rOrrrfiddler_from_diffLs1      $   rreadd_leading_blank_linecCsJtjt|tjtjt|ddgdt||r!tgdSgdS)aReturns an `cst.FunctionDef` for the fiddler function. Args: func_name: The name of the fiddler function. param_name: The name of the fiddler function's parameter. body: The body of the fiddler function. add_leading_blank_line: If true, add a leading blank line. rS)r<star)params)r<rre leading_lines)r FunctionDefName ParametersParam IndentedBlock EmptyLine)rDr&rerrrrrs  rvaluesnamesrcCsZg}tt||dddD]\}}|tjtjt|dg||dq dd|DS)zEReturns a list of `CSTNode`s for creating new shared value variables.cSs|dS)Nr2ritemrrrr]sz5_cst_for_new_shared_value_variables..rLrGtargetsrXcSg|]}t|gqSrrSimpleStatementLiner,stmtrrrr/z7_cst_for_new_shared_value_variables..)rorsr7rAssign AssignTargetr)rrr statementsrXr<rrrr|sr|rbc Cs`g}t|ddd}|D]\}}|tjtjt|dgt|||dqdd|DS)zFReturns a list of `CSTNode`s for creating moved value alias variables.cSt|dSNrr rprrrrr]z0_cst_for_moved_value_variables..rLrGrcSrrrrrrrr/rz2_cst_for_moved_value_variables..)ror8r7rrrr _cst_for_path)r&rbrrsorted_moved_value_namesrr<rrrr}s   r}cs^tdd|jDfdd}|jD]}t|tjtjfr%t||jqt||j S)aReturns a list of paths referenced in `diff`. This list includes paths for any values we might need to create aliases for, if that value moved. In particular, it includes the parent path for each change in `diff.changes`, plus the target path for any `diff.Reference` in `diff` whose root is `'old'`. Args: diff: The `fdl.Diff` that should be scanned for used paths. css|] }|jddVqdS)Nr1rGrIrrrrPsz#_find_used_paths..c3s8~dVt|tjr|jdkr|jdSdSdS)NrC)rYr ryrootrhrH)rnoderrrcollect_ref_targetss z-_find_used_paths..collect_ref_targets) rlrmrYr SetValue ModifyValuertraverse_with_path new_valuert)rBrrJrrrrks  rkpaths structurecCsTtj|dd}tj|dd}t|D]}||d}|dur'||t|qdS)aUpdate `paths` to include any other paths that reach the same objects. If any value `v` reachable by a path `p` in `paths` is also reachable by one or more other paths, then add those paths to `paths`. E.g., if a shared object is reachable by paths `.x.y` and `.x.z', and `paths` includes only `.x.y`, then this will add `.x.z` to `paths`. Args: paths: A set of paths to values in `structure`. structure: The structure used to determine the paths for shared values. T)memoizable_onlyN)rcollect_value_by_pathcollect_paths_by_idlistgetupdater)rr path_to_value id_to_pathsrrXrrrrn s   rncCsRtt}|jD]}|j}|std||dd|qt|dddS)zDReturns a sorted list of changes in `diff`, grouped by their parent.z)Changing the root object is not supportedNr1cSrrrrrrrr]Frz*_group_changes_by_parent..rL) collections defaultdictrrmrH ValueErrorr7ror8)rBchanges_by_parentrJrrrr_group_changes_by_parent:s   rcCs g}t|D]\}}||vrt||}nt|||}g}d} g} |D]} | jd} t|| |} t| tjrat| t j s@J| dusFJ|| j }t tj |tjt|t|gd} q%t| t jrq|tj| dq%t| t jr| jdj}|t tj |tjt|t||t|| jgdq%t| t jt j fr|| j }| tjt| g|dq%t| t jr| jdj}| tj tj |tjt|t||t|| jgddq%tdt| | || dur|| | | qdd |DS) aReturns a list of CST nodes that apply the changes described in `diff`. Args: diff: The `fdl.Diff` whose changes should be applied. param_name: The name of the parameter to the fiddler function. moved_value_names: Dictionary mapping any paths that might become unreachable once the config is mutated to alias variables that can be used to reach those values. pyval_to_cst: A function used to convert Python values to CST. Nr1)funcargsrGrr\zUnsupported DiffOperation cSrrrrrrrr/rz$_cst_for_changes..)!rrrrrH_cst_for_childrYr BuildableFnOrClsr rrExprCallr update_callableArg DeleteValuer7Del RemoveTagr<r remove_tagtagrrrAddTagadd_tagrtypeextend)rBr&rbrre parent_pathrm parent_cstdeletesrassignsrJchild_path_elt child_cst new_value_cstarg_namerrrr~Is|                    r~rrcCst|tjrtj|t|jdSt|tjr+||j}tj |tj t|dgdSt|tj rE||j }tj |tj t|dgdSt dt|)aReturns a CST expression that can be used to access a child of a parent. Args: parent_cst: CST expression for the parent object. child_path_elt: A PathElement specifying a child of the parent. pyval_to_cst: A function used to convert Python values to CST. )rXattr)slice)rXrzUnsupported PathElement )rYr Attrr Attributerr<Indexindex SubscriptSubscriptElementKeyrMrr)rrr index_cstkey_cstrrrrs     rr<rcCs$t|}|D]}t|||}q|S)z9Converts a `daglish.Path` to an `cst.CSTNode` expression.)rrr)r<rrrpath_eltrrrrs rcCstddd|S)z:Converts a camel or studly-caps name to a snake_case name.z (?<=.)([A-Z])cSsd|dS)Nr)r)r=lower)mrrrr]rKz!_camel_to_snake..)resubr)r<rrr_camel_to_snakes rrXcCs*t|tjrtt|jStt|jS)z.Returns a name for a value, based on its type.)rY config_lib Buildabler get_callablerrr\rrrrWs rWcCs&t|}tdd|}|dS)z#Converts a path to a variable name.z[^a-zA-Z_0-9]+r))r rprrstripr)rr<rrrr*s r*cCsn|jdkr|j|vrt||jSt||j|St|jdtjs$J||jdj}t||jdd|S)z+Converts a `Reference` to a CST expression.rCrr2N) rrHrrrrYr rr)rX convert_childr&rbrcvar_namerrrrzs  rzcCs~||j}t|S)z1Converts a Module to CST, using an ImportManager.) add_by_namerrdotted_name_to_cst)rXrrr<rrrrxs  rx)Nr?r@NrA)?__doc__r dataclassesrvrrZtypingrrrrrrrr fiddler r fiddle._srcr rr rfiddle._src.codegenrrirrfrfiddle._src.experimentalrlibcstr dataclassrr"r0r>DiffrjrCSTNoderrrPyValToCstFuncr|r$r}rkrn DiffOperationChangesByParentrr~ PathElementrrrrWr*rzrxrrrrs(                     a