mlcflow 1.2.0__tar.gz → 1.2.2__tar.gz

{mlcflow-1.2.0 → mlcflow-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlcflow
-Version: 1.2.0
+Version: 1.2.2
 Summary: An automation interface tailored for CPU/GPU benchmarking
 Author-email: MLCommons <systems@mlcommons.org>
 License: 

mlcflow-1.2.2/mlc/__init__.py

@@ -0,0 +1,44 @@
+from .action import access
+import os
+import subprocess
+
+
+def _get_version():
+    """Read version from VERSION file or package metadata, and append git commit hash if available."""
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    root_dir = os.path.dirname(pkg_dir)
+
+    # Read VERSION file (works in dev/source tree)
+    version = None
+    for vpath in [os.path.join(root_dir, "VERSION"),
+                  os.path.join(pkg_dir, "VERSION")]:
+        if os.path.isfile(vpath):
+            with open(vpath) as f:
+                version = f.read().strip()
+            break
+
+    # Fall back to installed package metadata
+    if not version:
+        try:
+            from importlib.metadata import version as pkg_version
+            version = pkg_version("mlcflow")
+        except Exception:
+            version = "0.0.0"
+
+    # Append git short commit hash if in a git repo
+    try:
+        commit = subprocess.check_output(
+            ["git", "-C", root_dir, "rev-parse", "--short", "HEAD"],
+            stderr=subprocess.DEVNULL, text=True
+        ).strip()
+        if commit:
+            version = f"{version}+{commit}"
+    except Exception:
+        pass
+
+    return version
+
+
+__version__ = _get_version()
+
+__all__ = ['access']

{mlcflow-1.2.0 → mlcflow-1.2.2}/mlc/index.py

@@ -347,20 +347,21 @@ class Index:
                 logger.debug(
                     f"Removed {removed_count} item(s) from {ft} index")
 
-    def _delete_by_uid(self, folder_type, uid, alias):
+    def _delete_index_entries(self, folder_type, key, value):
         """
-        Delete old index entry using UID (prevents duplicates).
+        Remove index entries matching for the same path or same UID.
         """
-        # logger.debug(f"Deleting and updating index entry for the script {alias} with UID {uid}")
+        # logger.debug(f"Deleting index entries in {folder_type} where {key} == {value}")
         self.indices[folder_type] = [
             item for item in self.indices[folder_type]
-            if item["uid"] != uid
+            if item.get(key) != value
         ]
 
     def _process_config_file(
             self, config_file, folder_type, folder_path, repo):
         """
-        Process a single configuration file (meta.json or meta.yaml) and add its data to the corresponding index.
+        Process a single configuration file (meta.json or meta.yaml) and
+        add its data to the corresponding index when the configuration file appears to be changed.
 
         Args:
             config_file (str): Path to the configuration file.
@@ -410,8 +411,13 @@ class Index:
                     raise ValueError(
                         f"Meta validation failed for {config_file}. Fix the above error(s) and try again.")
 
-            # Validate and add to indices
-            self._delete_by_uid(folder_type, unique_id, alias)
+            # Remove stale entry for the same meta file path if exists
+            self._delete_index_entries(folder_type, "path", folder_path)
+
+            # Remove index entry with the same UID for other meta file if
+            # exists
+            self._delete_index_entries(folder_type, "uid", unique_id)
+
             self.indices[folder_type].append({
                 "uid": unique_id,
                 "tags": tags,

{mlcflow-1.2.0 → mlcflow-1.2.2}/mlc/main.py

@@ -78,6 +78,127 @@ class Automation:
 
 
 mlc_run_cmd = None
+_current_target = None
+
+
+def get_version_info():
+    """Return mlcflow version string with commit hash."""
+    try:
+        from . import __version__
+        return f"mlcflow {__version__}"
+    except ImportError:
+        pass
+    try:
+        from importlib.metadata import version
+        return f"mlcflow {version('mlcflow')}"
+    except Exception:
+        return "mlcflow (unknown version)"
+
+
+def _get_repo_hashes():
+    """Get git info for all repos. Returns list of (alias, branch, hash, has_local_changes)."""
+    import subprocess
+    if default_parent is None:
+        return []
+    results = []
+    for repo in default_parent.repos:
+        alias = os.path.basename(repo.path)
+        git_dir = os.path.join(repo.path, '.git')
+        if not os.path.isdir(git_dir):
+            continue
+        try:
+            commit = subprocess.check_output(
+                ["git", "-C", repo.path, "rev-parse", "--short", "HEAD"],
+                stderr=subprocess.DEVNULL, text=True
+            ).strip()
+            branch = subprocess.check_output(
+                ["git", "-C", repo.path, "rev-parse", "--abbrev-ref", "HEAD"],
+                stderr=subprocess.DEVNULL, text=True
+            ).strip()
+            # Only tracked file changes (ignore untracked files)
+            dirty = subprocess.check_output(
+                ["git", "-C", repo.path, "status", "--porcelain", "-uno"],
+                stderr=subprocess.DEVNULL, text=True
+            ).strip()
+            results.append((alias, branch, commit, bool(dirty)))
+        except Exception:
+            pass
+    return results
+
+
+def _report_error(e):
+    import traceback
+    from .script_action import ScriptExecutionError
+
+    # Log the error with target context
+    etype = type(e).__name__ if not isinstance(e, ScriptExecutionError) else ''
+    prefix = f'{etype}: ' if etype else ''
+    if _current_target:
+        logger.error(f"Error during '{_current_target}' action: {prefix}{e}")
+    else:
+        logger.error(f"{prefix}{e}")
+
+    # Show the last traceback frame from outside the mlcflow package
+    tb = traceback.extract_tb(e.__traceback__)
+    if tb:
+        _mlc_pkg_dir = os.path.dirname(os.path.abspath(__file__))
+        # Prefer the last frame outside the mlcflow package
+        last = tb[-1]
+        for frame in reversed(tb):
+            if not os.path.abspath(frame.filename).startswith(_mlc_pkg_dir):
+                last = frame
+                break
+        logger.error(f"  at {last.filename}:{last.lineno} in {last.name}")
+
+    # For script execution errors, show actionable info
+    if isinstance(e, ScriptExecutionError):
+        script_name = e.script_name
+        repo_alias = e.repo_alias
+        run_args = e.run_args
+
+        if script_name:
+            # Build rerun command with user-facing inputs only
+            rerun_parts = ["mlcr", script_name]
+            _skip_keys = {
+                'mlc_run_cmd', 'tags', 'details', 'path_only', 'p',
+                'action', 'target', 'rebuild', 'env', 'script_tags',
+                'run_cmd', 'run_final_cmds', 'skip_run_cmd', 'run_cmd_prefix',
+                'add_deps_recursive', 'add_deps', 'file_path',
+                'quiet', 'real_run', 'fake_run_deps', 'keep_detached',
+                'pass_user_group', 'use_host_group_id', 'use_host_user_id',
+                'extra_run_args', 'port_maps', 'mounts', 'pre_run_cmds',
+                'docker_run_deps',
+            }
+            for k, v in run_args.items():
+                if k in _skip_keys:
+                    continue
+                if isinstance(v, (dict, list)):
+                    continue
+                if k.startswith('MLC_') or k.startswith('mlc_'):
+                    continue
+                rerun_parts.append(f"--{k}={v}")
+            rerun_cmd = " ".join(rerun_parts)
+            logger.error(f"Failed script: {script_name}")
+            logger.error(f"To rerun just the failed part: {rerun_cmd}")
+
+        if e.version_info_file:
+            logger.error(f"Dependency versions: {e.version_info_file}")
+
+        # Derive issues URL from repo alias
+        issues_url = 'https://github.com/mlcommons/mlperf-automations/issues'
+        if repo_alias and '@' in repo_alias:
+            issues_url = 'https://github.com/' + \
+                repo_alias.replace('@', '/') + '/issues'
+        logger.error(
+            f"Please file an issue at {issues_url} with the full console log.")
+
+    # Show version and repo commit hashes for debugging
+    logger.error(f"{get_version_info()}")
+    repo_hashes = _get_repo_hashes()
+    if repo_hashes:
+        for alias, branch, commit, dirty in repo_hashes:
+            marker = " (local changes)" if dirty else ""
+            logger.error(f"  {alias}: {branch} {commit}{marker}")
 
 
 def mlc_expand_short(action, target="script"):
@@ -90,17 +211,13 @@ def mlc_expand_short(action, target="script"):
     # Call the main function
     try:
         main()
+    except KeyboardInterrupt:
+        print("\nInterrupted.")
+        sys.exit(1)
     except SystemExit:
         raise
     except Exception as e:
-        import traceback
-        tb = traceback.extract_tb(e.__traceback__)
-        if tb:
-            last = tb[-1]
-            logger.error(f"{e}")
-            logger.error(f"  at {last.filename}:{last.lineno} in {last.name}")
-        else:
-            logger.error(f"{e}")
+        _report_error(e)
         sys.exit(1)
 
 
@@ -112,14 +229,22 @@ def mlcd():
     mlc_expand_short("docker")
 
 
-def mlcdr():
-    mlc_expand_short("docker")
+def mlca():
+    mlc_expand_short("apptainer")
 
 
 def mlcrr():
     mlc_expand_short("remote-run")
 
 
+def mlcre():
+    mlc_expand_short("remote-experiment")
+
+
+def mlcrd():
+    mlc_expand_short("remote-docker")
+
+
 def mlce():
     mlc_expand_short("experiment")
 
@@ -142,6 +267,13 @@ def process_console_output(res, target, action, run_args):
             if not run_args.get('path_only'):
                 logger.warning(
                     f"""No {target} entry found for the specified input: {run_args}!""")
+                logger.info(
+                    "Tip: Run 'mlc pull repo' to fetch the latest upstream changes.")
+                repo_hashes = _get_repo_hashes()
+                for alias, branch, commit, dirty in repo_hashes:
+                    if dirty:
+                        logger.warning(
+                            f"Repo '{alias}' ({branch}) has local changes - 'mlc pull repo' may fail. Commit or stash changes first.")
         else:
             for item in res['list']:
                 if run_args.get('path_only'):
@@ -245,8 +377,9 @@ def build_parser(pre_args):
     reindex_parser.add_argument('extra', nargs=argparse.REMAINDER)
 
     # Script-only
-    for action in ['docker', 'docker-run',
-                   'experiment', 'remote-run', 'doc', 'lint']:
+    for action in ['docker', 'docker-run', 'apptainer',
+                   'experiment', 'remote-run', 'remote-experiment',
+                   'remote-docker', 'doc', 'lint']:
         p = subparsers.add_parser(action, add_help=False)
         p.add_argument('target', choices=['script', 'run'])
         p.add_argument(
@@ -286,8 +419,9 @@ def build_run_args(args):
     if args.command in ['pull', 'rm', 'add', 'find'] and args.target == "repo":
         run_args['repo'] = args.details
 
-    if args.command in ['docker', 'docker-run', 'experiment',
-                        'remote-run', 'doc', 'lint'] and args.target == "run":
+    if args.command in ['docker', 'docker-run', 'apptainer', 'experiment',
+                        'remote-run', 'remote-experiment',
+                        'remote-docker', 'doc', 'lint'] and args.target == "run":
         # run_args['target'] = 'script' #dont modify this as script might have
         # target as in input
         args.target = "script"
@@ -386,6 +520,12 @@ def main():
     check_raw_arguments_for_non_ascii()
     convert_hyphen_to_underscore_in_args()
 
+    # Handle version before argparse to avoid --version conflicting with
+    # script arguments like --version=3.4
+    if len(sys.argv) >= 2 and sys.argv[1] in ('--version', '-V', 'version'):
+        print(get_version_info())
+        sys.exit(0)
+
     pre_parser = build_pre_parser()
     pre_args, remaining_args = pre_parser.parse_known_args()
 
@@ -404,7 +544,8 @@ def main():
     if pre_args.help and not "tags" in run_args:
         help_text = ""
         if pre_args.target == "run":
-            if pre_args.action.startswith("docker"):
+            if pre_args.action.startswith(
+                    "docker") or pre_args.action == "apptainer":
                 pre_args.target = "script"
             else:
                 logger.error(
@@ -456,6 +597,9 @@ def main():
         logging.error("Error: No command specified.")
         sys.exit(1)
 
+    global _current_target
+    _current_target = args.target
+
     action = get_action(args.target, default_parent)
 
     if not action or not hasattr(action, args.command):
@@ -477,15 +621,11 @@ def main():
 if __name__ == '__main__':
     try:
         main()
+    except KeyboardInterrupt:
+        print("\nInterrupted.")
+        sys.exit(1)
     except SystemExit:
         raise
     except Exception as e:
-        import traceback
-        tb = traceback.extract_tb(e.__traceback__)
-        if tb:
-            last = tb[-1]
-            logger.error(f"{e}")
-            logger.error(f"  at {last.filename}:{last.lineno} in {last.name}")
-        else:
-            logger.error(f"{e}")
+        _report_error(e)
         sys.exit(1)

{mlcflow-1.2.0 → mlcflow-1.2.2}/mlc/repo_action.py

@@ -425,9 +425,14 @@ class RepoAction(Action):
                     f"meta.yaml not found in {repo_path}. Repo pulled but not registered in MLC repos. Skipping...")
                 return {"return": 0}
 
-            with open(meta_file_path, 'r') as meta_file:
-                meta_data = yaml.safe_load(meta_file)
-                meta_data["path"] = repo_path
+            try:
+                with open(meta_file_path, 'r') as meta_file:
+                    meta_data = yaml.safe_load(meta_file)
+                    meta_data["path"] = repo_path
+            except yaml.YAMLError as e:
+                logger.error(f"Error loading YAML configuration: {e}")
+                return {"return": 1,
+                        "error": f"Syntax error in {meta_file_path}: {e}"}
 
             r = self.register_repo(repo_path, meta_data, ignore_on_conflict)
             if r['return'] > 0:

{mlcflow-1.2.0 → mlcflow-1.2.2}/mlc/script_action.py

@@ -1,3 +1,4 @@
+import re
 from .action import Action
 import os
 import sys
@@ -8,6 +9,7 @@ from .index import Index
 from . import utils
 from .logger import logger
 
+
 class ScriptAction(Action):
     """
     ####################################################################################################################
@@ -35,6 +37,7 @@ class ScriptAction(Action):
 
     """
     parent = None
+
     def __init__(self, parent=None):
         self.parent = parent
         self.__dict__.update(vars(parent))
@@ -59,7 +62,7 @@ class ScriptAction(Action):
         return res
 
     find = search
-        
+
     def rm(self, i):
         """
     ####################################################################################################################
@@ -67,7 +70,7 @@ class ScriptAction(Action):
     Action: Remove(rm)
     ####################################################################################################################
 
-    The `remove` (`rm`) action deletes one or more scripts from MLC repositories.  
+    The `remove` (`rm`) action deletes one or more scripts from MLC repositories.
 
     Example Command:
 
@@ -86,14 +89,14 @@ class ScriptAction(Action):
     Action: Show
     ####################################################################################################################
 
-    The `show` action retrieves the path and metadata of the searched script in MLC repositories.  
+    The `show` action retrieves the path and metadata of the searched script in MLC repositories.
 
     Example Command:
 
     mlc show script --tags=detect,os
 
     Example Output:
-          
+
       arjun@intel-spr-i9:~$ mlc show script --tags=detect,os
       [2025-02-14 02:56:16,604 main.py:1404 INFO] - Showing script with tags: detect,os
       Location: /home/arjun/MLC/repos/gateoverflow@mlperf-automations/script/detect-os:
@@ -102,7 +105,7 @@ class ScriptAction(Action):
         alias: detect-os
         description: Detects the operating system and platform information
         tags: ['detect-os', 'detect', 'os', 'info']
-        new_env_keys: ['MLC_HOST_OS_*', '+MLC_HOST_OS_*', 'MLC_HOST_PLATFORM_*', 'MLC_HOST_PYTHON_*', 'MLC_HOST_SYSTEM_NAME', 
+        new_env_keys: ['MLC_HOST_OS_*', '+MLC_HOST_OS_*', 'MLC_HOST_PLATFORM_*', 'MLC_HOST_PYTHON_*', 'MLC_HOST_SYSTEM_NAME',
                        'MLC_RUN_STATE_DOCKER', '+PATH']
         new_state_keys: ['os_uname_*']
       ......................................................
@@ -117,7 +120,14 @@ class ScriptAction(Action):
         if res['return'] > 0:
             return res
         logger.info(f"Showing script with tags: {run_args.get('tags')}")
-        script_meta_keys_to_show = ["uid", "alias", "description", "tags", "new_env_keys", "new_state_keys", "cache"]
+        script_meta_keys_to_show = [
+            "uid",
+            "alias",
+            "description",
+            "tags",
+            "new_env_keys",
+            "new_state_keys",
+            "cache"]
         for item in res['list']:
             print(f"""Location: {item.path}:
 Main Script Meta:""")
@@ -128,9 +138,10 @@ Main Script Meta:""")
                 print("    Input mapping:")
                 utils.printd(item.meta["input_mapping"], begin_spaces=8)
             print("......................................................")
-            print(f"""For full script meta, see meta file at {os.path.join(item.path, "meta.yaml")}""")
+            print(
+                f"""For full script meta, see meta file at {os.path.join(item.path, "meta.yaml")}""")
             print("")
-            
+
         return {'return': 0}
 
     def add(self, i):
@@ -140,17 +151,17 @@ Main Script Meta:""")
     Action: Add
     ####################################################################################################################
 
-    The `add` action creates a new script in a registered MLC repository.  
+    The `add` action creates a new script in a registered MLC repository.
 
     Syntax:
 
     mlc add script <user@repo>:new_script --tags=benchmark
 
     Options:
-        --template_tags: A comma-separated list of tags to create a new MLC script based on existing templates.  
+        --template_tags: A comma-separated list of tags to create a new MLC script based on existing templates.
 
     Example Output:
-          
+
       arjun@intel-spr-i9:~$ mlc add script gateoverflow@mlperf-automations --tags=benchmark --template_tags=app,mlperf,inference
       More than one script found for None:
       1. /home/arjun/MLC/repos/gateoverflow@mlperf-automations/script/app-mlperf-inference-mlcommons-python
@@ -188,7 +199,7 @@ Main Script Meta:""")
         ii['src_tags'] = i.get("template_tags", "template,generic")
         ii['dest'] = item
         ii['tags'] = i.get('tags', [])
-        res =  self.cp(ii)
+        res = self.cp(ii)
 
         return res
 
@@ -208,7 +219,8 @@ Main Script Meta:""")
         module_name = os.path.splitext(os.path.basename(script_path))[0]
         spec = importlib.util.spec_from_file_location(module_name, script_path)
         if spec is None or spec.loader is None:
-            raise ImportError(f"Cannot create a module spec for: {script_path}")
+            raise ImportError(
+                f"Cannot create a module spec for: {script_path}")
 
         module = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(module)
@@ -219,11 +231,12 @@ Main Script Meta:""")
         self.action_type = "script"
         repos_folder = self.repos_path
 
-        # Import script submodule 
+        # Import script submodule
         script_path = self.find_target_folder("script")
         if not script_path:
-            logger.warning("Script automation not found. Automatically pulling mlcommons@mlperf-automations repository...")
-            
+            logger.warning(
+                "Script automation not found. Automatically pulling mlcommons@mlperf-automations repository...")
+
             # Use the access method to pull the required repository
             result = self.access({
                 "automation": "repo",
@@ -239,11 +252,15 @@ Main Script Meta:""")
                 # Try to find the script path again after pulling
                 script_path = self.find_target_folder("script")
                 if not script_path:
-                    return {'return': 1, 'error': f"""Script automation still not found after pulling mlcommons@mlperf-automations --branch=dev."""}
+                    return {
+                        'return': 1, 'error': f"""Script automation still not found after pulling mlcommons@mlperf-automations --branch=dev."""}
             else:
-                # If pull failed, return the original error with additional info
-                logger.error(f"Failed to pull mlcommons@mlperf-automations repository: {result.get('error', 'Unknown error')}")
-                return {'return': 1, 'error': f"""Script automation not found and failed to automatically pull mlcommons@mlperf-automations --branch=dev. Please run "mlc pull repo mlcommons@mlperf-automations --branch=dev" manually: {result.get('error', 'Unknown error')}"""}
+                # If pull failed, return the original error with additional
+                # info
+                logger.error(
+                    f"Failed to pull mlcommons@mlperf-automations repository: {result.get('error', 'Unknown error')}")
+                return {
+                    'return': 1, 'error': f"""Script automation not found and failed to automatically pull mlcommons@mlperf-automations --branch=dev. Please run "mlc pull repo mlcommons@mlperf-automations --branch=dev" manually: {result.get('error', 'Unknown error')}"""}
 
         module_path = os.path.join(script_path, "module.py")
         module = self.dynamic_import_module(module_path)
@@ -254,45 +271,89 @@ Main Script Meta:""")
             params = inspect.signature(ctor).parameters
 
             if 'run_args' in params:
-                automation_instance = module.ScriptAutomation(self, module_path, run_args)
-            else:
-                automation_instance = module.ScriptAutomation(self, module_path)
-
-            if function_name == "run":
-                result = automation_instance.run(run_args)  # Pass args to the run method
-            elif function_name == "docker":
-                result = automation_instance.docker(run_args)  # Pass args to the run method
-            elif function_name == "test":
-                result = automation_instance.test(run_args)  # Pass args to the run method
-            elif function_name == "experiment":
-                result = automation_instance.experiment(run_args)  # Pass args to the experiment method
-            elif function_name == "remote_run":
-                result = automation_instance.remote_run(run_args)  # Pass args to the experiment method
-            elif function_name == "help":
-                result = automation_instance.help(run_args)  # Pass args to the help method
-            elif function_name == "doc":
-                result = automation_instance.doc(run_args)  # Pass args to the doc method
-            elif function_name == "lint":
-                result = automation_instance.lint(run_args)  # Pass args to the lint method
+                automation_instance = module.ScriptAutomation(
+                    self, module_path, run_args)
             else:
-                return {'return': 1, 'error': f'Function {function_name} is not supported'}
-            
+                automation_instance = module.ScriptAutomation(
+                    self, module_path)
+
+            try:
+                if function_name == "run":
+                    result = automation_instance.run(
+                        run_args)  # Pass args to the run method
+                elif function_name == "docker":
+                    result = automation_instance.docker(
+                        run_args)  # Pass args to the run method
+                elif function_name == "test":
+                    result = automation_instance.test(
+                        run_args)  # Pass args to the run method
+                elif function_name == "experiment":
+                    result = automation_instance.experiment(
+                        run_args)  # Pass args to the experiment method
+                elif function_name == "remote_run":
+                    result = automation_instance.remote_run(
+                        run_args)  # Pass args to the experiment method
+                elif function_name == "help":
+                    result = automation_instance.help(
+                        run_args)  # Pass args to the help method
+                elif function_name == "doc":
+                    result = automation_instance.doc(
+                        run_args)  # Pass args to the doc method
+                elif function_name == "lint":
+                    result = automation_instance.lint(
+                        run_args)  # Pass args to the lint method
+                else:
+                    return {
+                        'return': 1, 'error': f'Function {function_name} is not supported'}
+            except ScriptExecutionError:
+                raise
+            except Exception as exc:
+                _repo_match = re.search(r'/repos/([^/]+)/', module_path)
+                _repo_alias = _repo_match.group(1) if _repo_match else None
+                _script_name = run_args.get('tags', run_args.get('details'))
+                raise ScriptExecutionError(
+                    f"Script {function_name} execution failed in {module_path}." +
+                    "\nError : " + f"{type(exc).__name__}: {exc}",
+                    script_name=_script_name, repo_alias=_repo_alias, module_path=module_path,
+                    run_args=run_args) from exc
+
             if result['return'] > 0:
                 error = result.get('error', "")
-                raise ScriptExecutionError(f"Script {function_name} execution failed in {module_path}. \nError : {error}")
-
-            if str(run_args.get("mlc_output")).lower() in ["on", "true", "yes", "1"]:
+                _name_match = re.search(r'name\s*=\s*([^,)]+)', error)
+                _script_name = _name_match.group(1).strip() if _name_match else run_args.get(
+                    'tags', run_args.get('details'))
+                _repo_match = re.search(r'/repos/([^/]+)/', module_path)
+                _repo_alias = _repo_match.group(1) if _repo_match else None
+                # Dump dependency version info to file for debugging
+                _version_info_file = None
+                _version_info = result.get('version_info', [])
+                if _version_info:
+                    _version_info_file = os.path.join(
+                        os.getcwd(), 'mlc-error-version-info.json')
+                    try:
+                        with open(_version_info_file, 'w') as _vf:
+                            json.dump(_version_info, _vf, indent=2)
+                    except Exception:
+                        _version_info_file = None
+                raise ScriptExecutionError(
+                    f"Script {function_name} execution failed in {module_path}. \nError : {error}",
+                    script_name=_script_name, repo_alias=_repo_alias, module_path=module_path,
+                    run_args=run_args, version_info_file=_version_info_file)
+
+            if str(run_args.get("mlc_output")).lower() in [
+                    "on", "true", "yes", "1"]:
                 with open("tmp-state.json", "w") as f:
                     json.dump(result['new_state'], f, indent=2)
 
                 with open("tmp-run-env.out", "w") as f:
-                    for key,val in result['new_env'].items():
+                    for key, val in result['new_env'].items():
                         f.write(f"""{key}="{val}"\n""")
 
             return result
         else:
             logger.info("ScriptAutomation class not found in the script.")
-            return {'return': 1, 'error': 'ScriptAutomation class not found in the script.'}
+            return {'return': 1,
+                    'error': 'ScriptAutomation class not found in the script.'}
 
     def docker(self, run_args):
         return self.docker_run(run_args)
@@ -304,13 +365,13 @@ Main Script Meta:""")
     Action: Docker
     ####################################################################################################################
 
-    The `docker` action runs scripts inside a containerized environment.  
+    The `docker` action runs scripts inside a containerized environment.
 
     An MLCFlow script can be executed inside a Docker container using either of the following syntaxes:
 
-    1. Docker Run: mlc docker run --tags=<script tags> <run flags> (e.g., mlc docker run --tags=detect,os --docker_dt 
+    1. Docker Run: mlc docker run --tags=<script tags> <run flags> (e.g., mlc docker run --tags=detect,os --docker_dt
                        --docker_cache=no)
-    2. Docker Script: mlc docker script --tags=<script tags> <run flags> (e.g., mlc docker script --tags=detect,os 
+    2. Docker Script: mlc docker script --tags=<script tags> <run flags> (e.g., mlc docker script --tags=detect,os
                           --docker_dt --docker_cache=no)
 
     Flags Available:
@@ -342,7 +403,7 @@ Main Script Meta:""")
     Action: remote-run
     ####################################################################################################################
 
-    The `remote-run` action runs a shell command on a remote machine via ssh connection.  
+    The `remote-run` action runs a shell command on a remote machine via ssh connection.
 
 
     Flags Available:
@@ -359,7 +420,6 @@ Main Script Meta:""")
         """
         return self.call_script_module_function("remote_run", run_args)
 
-
     def run(self, run_args):
         """
     ####################################################################################################################
@@ -367,7 +427,7 @@ Main Script Meta:""")
     Action: Run
     ####################################################################################################################
 
-    The `run` action executes a script from an MLC repository.  
+    The `run` action executes a script from an MLC repository.
 
     Example Command:
 
@@ -378,14 +438,13 @@ Main Script Meta:""")
 
     1. -j: Displays the output in JSON format.
     2. Instead of using `mlc run script --tags=`, you can simply use `mlcr`.
-    3. *<Individual script inputs>: The `mlcr` command can accept additional inputs defined in the script's `input_mappings` metadata.  
+    3. *<Individual script inputs>: The `mlcr` command can accept additional inputs defined in the script's `input_mappings` metadata.
 
         """
         if not run_args.get('tags') and not run_args.get('details'):
             return self.call_script_module_function("help", run_args)
         return self.call_script_module_function("run", run_args)
 
-
     def test(self, run_args):
         """
     ####################################################################################################################
@@ -393,7 +452,7 @@ Main Script Meta:""")
     Action: test
     ####################################################################################################################
 
-    The `test` action validates scripts that are configured with a `tests` section in `meta.yaml`.  
+    The `test` action validates scripts that are configured with a `tests` section in `meta.yaml`.
 
     Example Command:
 
@@ -402,7 +461,6 @@ Main Script Meta:""")
         """
         return self.call_script_module_function("test", run_args)
 
-
     def doc(self, run_args):
         """
     ####################################################################################################################
@@ -410,7 +468,7 @@ Main Script Meta:""")
     Action: doc
     ####################################################################################################################
 
-    The `doc` action creates automatic README for scripts from the contents in `meta.yaml`.  
+    The `doc` action creates automatic README for scripts from the contents in `meta.yaml`.
 
     Example Command:
 
@@ -426,7 +484,7 @@ Main Script Meta:""")
     Action: lint
     ####################################################################################################################
 
-    The `lint` action automatically formats the contents in `meta.yaml`.  
+    The `lint` action automatically formats the contents in `meta.yaml`.
 
     Example Command:
 
@@ -435,12 +493,11 @@ Main Script Meta:""")
         """
         return self.call_script_module_function("lint", run_args)
 
-
     def help(self, run_args):
-        # Internal function to call the help function in script automation module.py
+        # Internal function to call the help function in script automation
+        # module.py
         return self.call_script_module_function("help", run_args)
 
-
     def list(self, args):
         """
     ####################################################################################################################
@@ -448,7 +505,7 @@ Main Script Meta:""")
     Action: List
     ####################################################################################################################
 
-    The `list` action displays all scripts and their paths from repositories registered in MLC.  
+    The `list` action displays all scripts and their paths from repositories registered in MLC.
 
     Example Command:
 
@@ -456,16 +513,20 @@ Main Script Meta:""")
 
         """
         self.action_type = "script"
-        run_args = {"fetch_all": True}  # to fetch the details of all the scripts present in repos registered  in mlc
-        
+        # to fetch the details of all the scripts present in repos registered
+        # in mlc
+        run_args = {"fetch_all": True}
+
         res = self.search(run_args)
         if res['return'] > 0:
             return res
-        
-        logger.info(f"Listing all the scripts and their paths present in repos which are registered in MLC")
+
+        logger.info(
+            f"Listing all the scripts and their paths present in repos which are registered in MLC")
         print("......................................................")
         for item in res['list']:
-            print(f"alias: {item.meta['alias'] if item.meta.get('alias') else 'None'}")
+            print(
+                f"alias: {item.meta['alias'] if item.meta.get('alias') else 'None'}")
             print(f"Location: {item.path}")
             print("......................................................")
 
@@ -488,6 +549,63 @@ Main Script Meta:""")
         """
         return self.call_script_module_function("experiment", run_args)
 
+    def remote_experiment(self, run_args):
+        """
+    ################################################################################################################################################
+    Target: Script
+    Action: remote-experiment
+    ################################################################################################################################################
+
+    The `remote-experiment` action runs an experiment on a remote machine via ssh connection.
+
+    Flags Available:
+
+    1. --remote_host:
+        IP or hostname for the remote machine
+    2. --remote_port:
+        ssh port for the remote machine
+
+    Example Command:
+
+    mlc remote-experiment script --tags=detect,os -j
+    mlcre detect,os -j
+
+        """
+        run_args["remote_action"] = "experiment"
+        return self.call_script_module_function("remote_run", run_args)
+
+    def remote_docker(self, run_args):
+        """
+    ################################################################################################################################################
+    Target: Script
+    Action: remote-docker
+    ################################################################################################################################################
+
+    The `remote-docker` action runs a script inside a Docker container on a remote machine via ssh connection.
+
+    Flags Available:
+
+    1. --remote_host:
+        IP or hostname for the remote machine
+    2. --remote_port:
+        ssh port for the remote machine
+
+    Example Command:
+
+    mlc remote-docker script --tags=detect,os -j
+    mlcrd detect,os -j
+
+        """
+        run_args["remote_action"] = "docker"
+        return self.call_script_module_function("remote_run", run_args)
+
+
 class ScriptExecutionError(Exception):
-    # """Custom error for configuration issues."""
-    pass
+    def __init__(self, message, script_name=None, repo_alias=None,
+                 module_path=None, run_args=None, version_info_file=None):
+        super().__init__(message)
+        self.script_name = script_name
+        self.repo_alias = repo_alias
+        self.module_path = module_path
+        self.run_args = run_args or {}
+        self.version_info_file = version_info_file

{mlcflow-1.2.0 → mlcflow-1.2.2}/mlc/utils.py

@@ -11,6 +11,8 @@ import uuid
 import shutil
 import tarfile
 import zipfile
+import logging
+logger = logging.getLogger("mlc")
 
 
 def generate_temp_file(i):

{mlcflow-1.2.0 → mlcflow-1.2.2}/mlcflow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlcflow
-Version: 1.2.0
+Version: 1.2.2
 Summary: An automation interface tailored for CPU/GPU benchmarking
 Author-email: MLCommons <systems@mlcommons.org>
 License: 

{mlcflow-1.2.0 → mlcflow-1.2.2}/mlcflow.egg-info/entry_points.txt

@@ -1,8 +1,12 @@
 [console_scripts]
 mlc = mlc.main:main
+mlca = mlc.main:mlca
 mlcd = mlc.main:mlcd
 mlce = mlc.main:mlce
+mlcflow = mlc.main:main
 mlcp = mlc.main:mlcp
 mlcr = mlc.main:mlcr
+mlcrd = mlc.main:mlcrd
+mlcre = mlc.main:mlcre
 mlcrr = mlc.main:mlcrr
 mlct = mlc.main:mlct

{mlcflow-1.2.0 → mlcflow-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mlcflow"
-version = "1.2.0"
+version = "1.2.2"
 
 description = "An automation interface tailored for CPU/GPU benchmarking"
 authors = [
@@ -45,9 +45,13 @@ py-modules = []
 
 [project.scripts]
 mlc = "mlc.main:main"
+mlcflow = "mlc.main:main"
 mlcr = "mlc.main:mlcr"
 mlcrr = "mlc.main:mlcrr"
 mlcd = "mlc.main:mlcd"
+mlca = "mlc.main:mlca"
 mlce = "mlc.main:mlce"
 mlct = "mlc.main:mlct"
 mlcp = "mlc.main:mlcp"
+mlcre = "mlc.main:mlcre"
+mlcrd = "mlc.main:mlcrd"

mlcflow-1.2.0/mlc/__init__.py

@@ -1,5 +0,0 @@
-__version__ = "0.1.0" 
-
-from .action import access
-
-__all__ = ['access']