From 9d0d2e144ecba8a11df0c41125b489108487f544 Mon Sep 17 00:00:00 2001 From: Arjun Suresh Date: Sat, 26 Jul 2025 17:06:53 +0530 Subject: [PATCH 1/6] Added initial version of help.py --- automation/script/help.py | 183 ++++++++++++++++++++++++++++++++++++ automation/script/module.py | 38 ++++++-- 2 files changed, 214 insertions(+), 7 deletions(-) create mode 100644 automation/script/help.py diff --git a/automation/script/help.py b/automation/script/help.py new file mode 100644 index 000000000..1eb5b19c9 --- /dev/null +++ b/automation/script/help.py @@ -0,0 +1,183 @@ +import os +from mlc import utils +from utils import * +import os +from collections import defaultdict + +def display_help(self_module, input_params): + """ + Generates the documentation of MLC scripts. + + Args: + self_module: Reference to the current module for internal calls. + input_params: Dictionary containing input parameters. + + Returns: + Dictionary with the result of the operation. Keys: + - 'return': 0 on success, >0 on error. + - 'error': Error message (if any). + """ + + # Extract and handle basic inputs + quiet = input_params.get('quiet', False) + logger = self_module.logger + env = input_params.get('env', {}) + generic_inputs = self_module.input_flags_converted_to_env + + # Step 2: Search for scripts + search_result = self_module.search(input_params.copy()) + if search_result['return'] > 0: + return search_result + + scripts_list = search_result['list'] + if not scripts_list: + return {'return': 1, 'error': 'No scripts were found'} + + # Step 4: Iterate over scripts and generate help output + for script in sorted(scripts_list, key=lambda x: x.meta.get('alias', '')): + metadata = script.meta + print_script_help(metadata) + + return {'return': 0} + +def print_script_help(metadata): + print(f"Script Name: {metadata.get('alias', metadata['uid'])}") + print(f"Tags: {', '.join(metadata.get('tags', []))}") + # Print the run commands + print_run_commands(metadata) + print("") + print("Script Inputs:") + print("") + + input_mapping = metadata.get('input_mapping', {}) + input_description = metadata.get('input_description', {}) + default_env = metadata.get('default_env', {}) + + reverse_map = defaultdict(list) + for k, v in input_mapping.items(): + reverse_map[v].append(k) + + if input_description: + for i in input_description: + if i in input_mapping and input_mapping[i] in default_env: + input_description[i]['default'] = default_env[input_mapping[i]] + + # Add alias entries + for mapped_env, keys in reverse_map.items(): + if len(keys) > 1: + canonical = keys[0] + for alias in keys[1:]: + if alias in input_description: + input_description[alias] = {} + input_description[alias]['alias'] = canonical + input_description[alias]['desc'] = f"""Alias for {canonical}""" + + + for key, value in input_mapping.items(): + desc = input_description.get(key, {}).get('desc', 'No description available') + default = input_description.get(key, {}).get('default', 'None') + # Use .ljust(15) to ensure the key occupies 15 characters minimum + print(f" --{key.ljust(26)} : maps to --env.{value}\n{' '.ljust(35)}{desc}\n{' '.ljust(35)}Default: {default}\n") + + variations = metadata.get('variations', {}) + + if variations: + print_variations_help(variations) + else: + print(" - No variations.") + + print("\n" + "=" * 40 + "\n") # Separator for clarity + + +def print_variations_help(variations): + # Data structures + aliases = {} + alias_reverse = defaultdict(list) + bases = defaultdict(list) + variation_groups = {} + main_variations = {} + + # First pass: classify and build maps + for name, attrs in variations.items(): + if "," in name: + continue # Skip composite variations + if not isinstance(attrs, dict): + main_variations[name] = {} + continue + if "alias" in attrs: + aliases[name] = attrs["alias"] + alias_reverse[attrs["alias"]].append(name) + else: + main_variations[name] = attrs + # Group + group = attrs.get("group", "ungrouped") + if isinstance(group, list): + group = group[0] if group else "ungrouped" + variation_groups[name] = group + # Base + base = attrs.get("base", []) + if isinstance(base, str): + base = [base] + bases[name] = base + + # Build grouped output in a simpler format + grouped_output = defaultdict(list) + + for var in sorted(main_variations.keys()): + group = variation_groups.get(var, "ungrouped") + output = f"{var}" + + if var.endswith(".#"): + output += " (dynamic substitution allowed)" + + if alias_reverse.get(var): + alias_str = ", ".join(sorted(alias_reverse[var])) + output += f" [Alias: {alias_str}]" + + if bases.get(var): + base_str = ", ".join(bases[var]) + output += f" [Base: {base_str}]" + + if group != "ungrouped" and main_variations[var].get("default", False): + output += " [Default]" + + grouped_output[group].append(output) + + # Console output structure + print("\nVariations:\n") + for group in sorted(grouped_output): + print(f"\t{group.capitalize()} Variations:") + for line in grouped_output[group]: + print(f"\t - {line}") + print("") # Blank line between groups + + + +def print_run_commands(metadata): + tags = ','.join(metadata.get('tags', [])) + input_mapping = metadata.get('input_mapping', {}) + + # Build the command using the extracted tags + command = f"mlcr {tags}" + print("\nRun Commands:\n") + print(f" $ {command}") + + print("") + print(f""" + * Inputs can be appended to the run command directly or as their --env.key mapping. + * --env.key is useful to modify the input of a dependent script for which direct input may not be there in the main script. + * --adr. can be used to modify the dependency(ies) with the name dep_name. + For example, --adr.compiler.tags=gcc adds the tags 'gcc' to any dependency under the name compiler. + """) + + + +def infer_type(field): + if "dtype" in field: + return field["dtype"] + elif "default" in field: + return type(field["default"]).__name__ + else: + return "str" + + diff --git a/automation/script/module.py b/automation/script/module.py index 6c15f76c5..0868845db 100644 --- a/automation/script/module.py +++ b/automation/script/module.py @@ -529,11 +529,6 @@ def _run(self, i): if i.get(key): ii[key] = i[key] - # if cm run script without tags/artifact and with --help - if len(ii.get('parsed_artifact', [])) == 0 and ii.get( - 'tags', '') == '' and i.get('help', False): - return utils.call_internal_module( - self, __file__, 'module_help', 'print_help', {'meta': {}, 'path': ''}) r = self.search(ii) if r['return'] > 0: @@ -791,8 +786,7 @@ def _run(self, i): # Check if has --help if i.get('help', False): - return utils.call_internal_module(self, __file__, 'module_help', 'print_help', { - 'meta': meta, 'path': path}) + return self.help(i) run_state['script_id'] = meta['alias'] + "," + meta['uid'] run_state['script_tags'] = script_tags @@ -4531,6 +4525,36 @@ def doc(self, i): ############################################################ + def help(self, i): + """ + Document MLC script. + + Args: + (MLC input dict): + + (out) (str): if 'con', output to console + + parsed_artifact (list): prepared in MLC CLI or MLC access function + [ (artifact alias, artifact UID) ] or + [ (artifact alias, artifact UID), (artifact repo alias, artifact repo UID) ] + + (repos) (str): list of repositories to search for automations + + (output_dir) (str): output directory (../docs by default) + + Returns: + (MLC return dict): + + * return (int): return code == 0 if no error and >0 if error + * (error) (str): error string if return>0 + + """ + + from script.help import display_help + return display_help(self, i) + + ############################################################ + def lint(self, i): from script.lint import lint_meta return lint_meta(self, i) From 9a4fe75ab89f11b03520169b7dd3bb1905d4e67a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 26 Jul 2025 11:37:09 +0000 Subject: [PATCH 2/6] [Automated Commit] Format Codebase [skip ci] --- automation/script/help.py | 13 ++++++------- automation/script/module.py | 1 - 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/automation/script/help.py b/automation/script/help.py index 1eb5b19c9..c62fc790b 100644 --- a/automation/script/help.py +++ b/automation/script/help.py @@ -4,6 +4,7 @@ import os from collections import defaultdict + def display_help(self_module, input_params): """ Generates the documentation of MLC scripts. @@ -40,6 +41,7 @@ def display_help(self_module, input_params): return {'return': 0} + def print_script_help(metadata): print(f"Script Name: {metadata.get('alias', metadata['uid'])}") print(f"Tags: {', '.join(metadata.get('tags', []))}") @@ -72,12 +74,13 @@ def print_script_help(metadata): input_description[alias]['alias'] = canonical input_description[alias]['desc'] = f"""Alias for {canonical}""" - for key, value in input_mapping.items(): - desc = input_description.get(key, {}).get('desc', 'No description available') + desc = input_description.get(key, {}).get( + 'desc', 'No description available') default = input_description.get(key, {}).get('default', 'None') # Use .ljust(15) to ensure the key occupies 15 characters minimum - print(f" --{key.ljust(26)} : maps to --env.{value}\n{' '.ljust(35)}{desc}\n{' '.ljust(35)}Default: {default}\n") + print( + f" --{key.ljust(26)} : maps to --env.{value}\n{' '.ljust(35)}{desc}\n{' '.ljust(35)}Default: {default}\n") variations = metadata.get('variations', {}) @@ -152,7 +155,6 @@ def print_variations_help(variations): print("") # Blank line between groups - def print_run_commands(metadata): tags = ','.join(metadata.get('tags', [])) input_mapping = metadata.get('input_mapping', {}) @@ -171,7 +173,6 @@ def print_run_commands(metadata): """) - def infer_type(field): if "dtype" in field: return field["dtype"] @@ -179,5 +180,3 @@ def infer_type(field): return type(field["default"]).__name__ else: return "str" - - diff --git a/automation/script/module.py b/automation/script/module.py index 0868845db..5adf05d67 100644 --- a/automation/script/module.py +++ b/automation/script/module.py @@ -529,7 +529,6 @@ def _run(self, i): if i.get(key): ii[key] = i[key] - r = self.search(ii) if r['return'] > 0: return r From 8bf0693ae916b0952b2279d1e8ac514b65e86b87 Mon Sep 17 00:00:00 2001 From: Arjun Suresh Date: Sat, 26 Jul 2025 19:55:21 +0530 Subject: [PATCH 3/6] Added generic-script-inputs in help --- automation/script/help.py | 69 ++++++++++++++++++++++++++------------- 1 file changed, 47 insertions(+), 22 deletions(-) diff --git a/automation/script/help.py b/automation/script/help.py index c62fc790b..bcd172331 100644 --- a/automation/script/help.py +++ b/automation/script/help.py @@ -34,15 +34,17 @@ def display_help(self_module, input_params): if not scripts_list: return {'return': 1, 'error': 'No scripts were found'} + generic_inputs = self_module.input_flags_converted_to_env + # Step 4: Iterate over scripts and generate help output for script in sorted(scripts_list, key=lambda x: x.meta.get('alias', '')): metadata = script.meta - print_script_help(metadata) + print_script_help(metadata, generic_inputs) return {'return': 0} - -def print_script_help(metadata): +def print_script_help(metadata, generic_inputs): + print("") print(f"Script Name: {metadata.get('alias', metadata['uid'])}") print(f"Tags: {', '.join(metadata.get('tags', []))}") # Print the run commands @@ -55,11 +57,37 @@ def print_script_help(metadata): input_description = metadata.get('input_description', {}) default_env = metadata.get('default_env', {}) - reverse_map = defaultdict(list) - for k, v in input_mapping.items(): - reverse_map[v].append(k) + print_input_details(input_mapping, input_description, default_env) + + print("") + print("Generic Inputs for all Scripts:") + print("") + print_input_descriptions(generic_inputs) + + variations = metadata.get('variations', {}) + + if variations: + print_variations_help(variations) + else: + print(" - No variations.") + + print("\n" + "=" * 40 + "\n") # Separator for clarity + + +def print_input_details(input_mapping, input_description, default_env): + + + for i in input_mapping: + if i not in input_description or input_description[i].get('env','') != input_mapping[i]: + if i not in input_description: + input_description[i] = {} + input_description[i]['env_key'] = input_mapping[i] if input_description: + reverse_map = defaultdict(list) + for k, v in input_mapping.items(): + reverse_map[v].append(k) + for i in input_description: if i in input_mapping and input_mapping[i] in default_env: input_description[i]['default'] = default_env[input_mapping[i]] @@ -74,22 +102,17 @@ def print_script_help(metadata): input_description[alias]['alias'] = canonical input_description[alias]['desc'] = f"""Alias for {canonical}""" - for key, value in input_mapping.items(): - desc = input_description.get(key, {}).get( - 'desc', 'No description available') - default = input_description.get(key, {}).get('default', 'None') - # Use .ljust(15) to ensure the key occupies 15 characters minimum - print( - f" --{key.ljust(26)} : maps to --env.{value}\n{' '.ljust(35)}{desc}\n{' '.ljust(35)}Default: {default}\n") - - variations = metadata.get('variations', {}) + print_input_descriptions(input_description) - if variations: - print_variations_help(variations) - else: - print(" - No variations.") + return - print("\n" + "=" * 40 + "\n") # Separator for clarity +def print_input_descriptions(input_descriptions): + for key in input_descriptions: + env_key = input_descriptions.get(key, {}).get('env_key', f"""MLC_TMP_{key.upper()}""") + desc = input_descriptions.get(key, {}).get('desc', 'No description available') + default = input_descriptions.get(key, {}).get('default', 'None') + # Use .ljust(15) to ensure the key occupies 15 characters minimum + print(f" --{key.ljust(26)} : maps to --env.{env_key}\n{' '.ljust(35)}{desc}\n{' '.ljust(35)}Default: {default}\n") def print_variations_help(variations): @@ -166,10 +189,12 @@ def print_run_commands(metadata): print("") print(f""" - * Inputs can be appended to the run command directly or as their --env.key mapping. + * Any input can be appended to the run command directly or using its --env.key mapping. * --env.key is useful to modify the input of a dependent script for which direct input may not be there in the main script. + * Any variation can be selected by adding it to the tags using the _ prefix. + For example, mlcr get,generic-python-lib,_panda turns on the panda variation for the get-generic-python-lib script. * --adr. can be used to modify the dependency(ies) with the name dep_name. - For example, --adr.compiler.tags=gcc adds the tags 'gcc' to any dependency under the name compiler. + For example, --adr.compiler.tags=gcc adds the tag 'gcc' to any dependency with the name compiler. """) From c7f5eb3d99cd60d5eaca4531d80ec274e7b99a92 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 26 Jul 2025 14:27:06 +0000 Subject: [PATCH 4/6] [Automated Commit] Format Codebase [skip ci] --- automation/script/help.py | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/automation/script/help.py b/automation/script/help.py index bcd172331..d6f2cc02d 100644 --- a/automation/script/help.py +++ b/automation/script/help.py @@ -43,6 +43,7 @@ def display_help(self_module, input_params): return {'return': 0} + def print_script_help(metadata, generic_inputs): print("") print(f"Script Name: {metadata.get('alias', metadata['uid'])}") @@ -73,12 +74,12 @@ def print_script_help(metadata, generic_inputs): print("\n" + "=" * 40 + "\n") # Separator for clarity - -def print_input_details(input_mapping, input_description, default_env): +def print_input_details(input_mapping, input_description, default_env): for i in input_mapping: - if i not in input_description or input_description[i].get('env','') != input_mapping[i]: + if i not in input_description or input_description[i].get( + 'env', '') != input_mapping[i]: if i not in input_description: input_description[i] = {} input_description[i]['env_key'] = input_mapping[i] @@ -87,7 +88,7 @@ def print_input_details(input_mapping, input_description, default_env): reverse_map = defaultdict(list) for k, v in input_mapping.items(): reverse_map[v].append(k) - + for i in input_description: if i in input_mapping and input_mapping[i] in default_env: input_description[i]['default'] = default_env[input_mapping[i]] @@ -106,13 +107,18 @@ def print_input_details(input_mapping, input_description, default_env): return + def print_input_descriptions(input_descriptions): for key in input_descriptions: - env_key = input_descriptions.get(key, {}).get('env_key', f"""MLC_TMP_{key.upper()}""") - desc = input_descriptions.get(key, {}).get('desc', 'No description available') + env_key = input_descriptions.get(key, {}).get( + 'env_key', f"""MLC_TMP_{key.upper()}""") + desc = input_descriptions.get( + key, {}).get( + 'desc', 'No description available') default = input_descriptions.get(key, {}).get('default', 'None') # Use .ljust(15) to ensure the key occupies 15 characters minimum - print(f" --{key.ljust(26)} : maps to --env.{env_key}\n{' '.ljust(35)}{desc}\n{' '.ljust(35)}Default: {default}\n") + print( + f" --{key.ljust(26)} : maps to --env.{env_key}\n{' '.ljust(35)}{desc}\n{' '.ljust(35)}Default: {default}\n") def print_variations_help(variations): @@ -191,7 +197,7 @@ def print_run_commands(metadata): print(f""" * Any input can be appended to the run command directly or using its --env.key mapping. * --env.key is useful to modify the input of a dependent script for which direct input may not be there in the main script. - * Any variation can be selected by adding it to the tags using the _ prefix. + * Any variation can be selected by adding it to the tags using the _ prefix. For example, mlcr get,generic-python-lib,_panda turns on the panda variation for the get-generic-python-lib script. * --adr. can be used to modify the dependency(ies) with the name dep_name. For example, --adr.compiler.tags=gcc adds the tag 'gcc' to any dependency with the name compiler. From a52221cce33dc30bd4027780beba9bd5b3eb2d42 Mon Sep 17 00:00:00 2001 From: Arjun Suresh Date: Sun, 27 Jul 2025 04:36:56 +0530 Subject: [PATCH 5/6] Improvements for script help --- automation/script/help.py | 58 ++++++++++++++++++++++++++++--------- automation/script/module.py | 3 ++ 2 files changed, 47 insertions(+), 14 deletions(-) diff --git a/automation/script/help.py b/automation/script/help.py index d6f2cc02d..7b15ef31e 100644 --- a/automation/script/help.py +++ b/automation/script/help.py @@ -39,12 +39,12 @@ def display_help(self_module, input_params): # Step 4: Iterate over scripts and generate help output for script in sorted(scripts_list, key=lambda x: x.meta.get('alias', '')): metadata = script.meta - print_script_help(metadata, generic_inputs) + script_path = script.path + print_script_help(metadata, script_path, generic_inputs, env, self_module) return {'return': 0} - -def print_script_help(metadata, generic_inputs): +def print_script_help(metadata, script_path, generic_inputs, env, self_module): print("") print(f"Script Name: {metadata.get('alias', metadata['uid'])}") print(f"Tags: {', '.join(metadata.get('tags', []))}") @@ -72,7 +72,21 @@ def print_script_help(metadata, generic_inputs): else: print(" - No variations.") - print("\n" + "=" * 40 + "\n") # Separator for clarity + print("\n" + "=" * 60 + "\n") # Separator for clarity + + print(f"""Script meta file path: {os.path.join(script_path, "meta.yaml")}""") + customize_path = os.path.join(script_path, "customize.py") + if os.path.exists(customize_path): + print(f"""Script customize file path: {customize_path}""") + else: + print(f"""Script customize file can be created at: {customize_path}""") + + run_script_name = self_module._get_script_name(env, script_path) + run_script_path = os.path.join(script_path, run_script_name) + if os.path.exists(run_script_path): + print(f"""Script run file path: {run_script_path}""") + + print("\n" + "=" * 60 + "\n") # Separator for clarity def print_input_details(input_mapping, input_description, default_env): @@ -84,6 +98,10 @@ def print_input_details(input_mapping, input_description, default_env): input_description[i] = {} input_description[i]['env_key'] = input_mapping[i] + keys_to_delete = [key for key in input_description if key not in input_mapping and "." not in key] + for key in keys_to_delete: + del input_description[key] + if input_description: reverse_map = defaultdict(list) for k, v in input_mapping.items(): @@ -101,7 +119,8 @@ def print_input_details(input_mapping, input_description, default_env): if alias in input_description: input_description[alias] = {} input_description[alias]['alias'] = canonical - input_description[alias]['desc'] = f"""Alias for {canonical}""" + input_description[alias]['desc'] = f"""Alias for --{canonical}""" + input_description[alias]['env_key'] = mapped_env print_input_descriptions(input_description) @@ -109,16 +128,27 @@ def print_input_details(input_mapping, input_description, default_env): def print_input_descriptions(input_descriptions): + + if not input_descriptions: + print("\tNo inputs") + for key in input_descriptions: - env_key = input_descriptions.get(key, {}).get( - 'env_key', f"""MLC_TMP_{key.upper()}""") - desc = input_descriptions.get( - key, {}).get( - 'desc', 'No description available') - default = input_descriptions.get(key, {}).get('default', 'None') + field = input_descriptions[key] + env_key = field.get('env_key', f"""MLC_TMP_{key.upper()}""") + desc = field.get('desc') + default = field.get('default', 'None') + choices = field.get("choices", "") + dtype = infer_type(field) # Use .ljust(15) to ensure the key occupies 15 characters minimum - print( - f" --{key.ljust(26)} : maps to --env.{env_key}\n{' '.ljust(35)}{desc}\n{' '.ljust(35)}Default: {default}\n") + print(f"\t--{key.ljust(26)}: maps to --env.{env_key}") + if desc: + print(f"\t{' '.ljust(30)}Desc: {desc}") + print(f"\t{' '.ljust(30)}Default: {default}") + if choices: + print(f"\t{' '.ljust(30)}Choices: {choices}") + if dtype: + print(f"\t{' '.ljust(30)}Type: {dtype}") + print("") def print_variations_help(variations): @@ -168,7 +198,7 @@ def print_variations_help(variations): if bases.get(var): base_str = ", ".join(bases[var]) - output += f" [Base: {base_str}]" + output += f" [base: {base_str}]" if group != "ungrouped" and main_variations[var].get("default", False): output += " [Default]" diff --git a/automation/script/module.py b/automation/script/module.py index 5adf05d67..0c19c1bc6 100644 --- a/automation/script/module.py +++ b/automation/script/module.py @@ -4631,6 +4631,9 @@ def clean_some_tmp_files(self, i): return {'return': 0} + def _get_script_name(self, env, path, filename="run"): + return get_script_name(env, path, filename) + def get_version_tag_from_version(version, cached_tags): tags_to_add = [] if version != '': From 0006c435e4fd73277124fb1e623dedf080799d6f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 26 Jul 2025 23:08:34 +0000 Subject: [PATCH 6/6] [Automated Commit] Format Codebase [skip ci] --- automation/script/help.py | 18 +++++++++++++----- automation/script/module.py | 2 +- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/automation/script/help.py b/automation/script/help.py index 7b15ef31e..9c2212931 100644 --- a/automation/script/help.py +++ b/automation/script/help.py @@ -40,10 +40,16 @@ def display_help(self_module, input_params): for script in sorted(scripts_list, key=lambda x: x.meta.get('alias', '')): metadata = script.meta script_path = script.path - print_script_help(metadata, script_path, generic_inputs, env, self_module) + print_script_help( + metadata, + script_path, + generic_inputs, + env, + self_module) return {'return': 0} + def print_script_help(metadata, script_path, generic_inputs, env, self_module): print("") print(f"Script Name: {metadata.get('alias', metadata['uid'])}") @@ -74,18 +80,19 @@ def print_script_help(metadata, script_path, generic_inputs, env, self_module): print("\n" + "=" * 60 + "\n") # Separator for clarity - print(f"""Script meta file path: {os.path.join(script_path, "meta.yaml")}""") + print( + f"""Script meta file path: {os.path.join(script_path, "meta.yaml")}""") customize_path = os.path.join(script_path, "customize.py") if os.path.exists(customize_path): print(f"""Script customize file path: {customize_path}""") else: print(f"""Script customize file can be created at: {customize_path}""") - + run_script_name = self_module._get_script_name(env, script_path) run_script_path = os.path.join(script_path, run_script_name) if os.path.exists(run_script_path): print(f"""Script run file path: {run_script_path}""") - + print("\n" + "=" * 60 + "\n") # Separator for clarity @@ -98,7 +105,8 @@ def print_input_details(input_mapping, input_description, default_env): input_description[i] = {} input_description[i]['env_key'] = input_mapping[i] - keys_to_delete = [key for key in input_description if key not in input_mapping and "." not in key] + keys_to_delete = [ + key for key in input_description if key not in input_mapping and "." not in key] for key in keys_to_delete: del input_description[key] diff --git a/automation/script/module.py b/automation/script/module.py index 0c19c1bc6..bad6a68e9 100644 --- a/automation/script/module.py +++ b/automation/script/module.py @@ -4630,10 +4630,10 @@ def clean_some_tmp_files(self, i): return {'return': 0} - def _get_script_name(self, env, path, filename="run"): return get_script_name(env, path, filename) + def get_version_tag_from_version(version, cached_tags): tags_to_add = [] if version != '':