mlcflow 1.3.2__tar.gz → 1.3.3__tar.gz

{mlcflow-1.3.2 → mlcflow-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlcflow
-Version: 1.3.2
+Version: 1.3.3
 Summary: An automation interface tailored for CPU/GPU benchmarking
 Author-email: MLCommons <systems@mlcommons.org>
 License: 
@@ -206,10 +206,10 @@ Dynamic: license-file
 [![License](https://img.shields.io/badge/License-Apache%202.0-green)](https://github.com/mlcommons/mlcflow/blob/main/LICENSE.md)
 [![Downloads](https://static.pepy.tech/badge/mlcflow)](https://pepy.tech/project/mlcflow)
 
-[![MLC core actions test](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml/badge.svg?branch=dev)](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml)
-[![MLC script automation features test](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml/badge.svg?branch=dev)](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml)
-[![MLPerf inference resnet50](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml/badge.svg?branch=dev)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml)
-[![MLPerf inference bert (deepsparse, tf, onnxruntime, pytorch)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-bert.yml/badge.svg?branch=dev)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-bert.yml)
+[![MLC core actions test](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml/badge.svg?branch=main)](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml)
+[![MLC script automation features test](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml/badge.svg?branch=main)](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml)
+[![MLPerf inference resnet50](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml/badge.svg?branch=main)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml)
+
 
 
 MLCFlow is a versatile CLI and Python interface developed by MLCommons in collaboration with a dedicated team of volunteers (see [Contributors](https://github.com/mlcommons/mlcflow/blob/main/CONTRIBUTORS.md)). It serves as a streamlined replacement for the [CMind](https://github.com/mlcommons/ck/tree/master/cm) tool, designed to drive the automation workflows of MLPerf benchmarks more efficiently. You can use this tool for any of your workflow automation tasks. 

{mlcflow-1.3.2 → mlcflow-1.3.3}/README.md

@@ -4,10 +4,10 @@
 [![License](https://img.shields.io/badge/License-Apache%202.0-green)](https://github.com/mlcommons/mlcflow/blob/main/LICENSE.md)
 [![Downloads](https://static.pepy.tech/badge/mlcflow)](https://pepy.tech/project/mlcflow)
 
-[![MLC core actions test](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml/badge.svg?branch=dev)](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml)
-[![MLC script automation features test](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml/badge.svg?branch=dev)](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml)
-[![MLPerf inference resnet50](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml/badge.svg?branch=dev)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml)
-[![MLPerf inference bert (deepsparse, tf, onnxruntime, pytorch)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-bert.yml/badge.svg?branch=dev)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-bert.yml)
+[![MLC core actions test](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml/badge.svg?branch=main)](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml)
+[![MLC script automation features test](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml/badge.svg?branch=main)](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml)
+[![MLPerf inference resnet50](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml/badge.svg?branch=main)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml)
+
 
 
 MLCFlow is a versatile CLI and Python interface developed by MLCommons in collaboration with a dedicated team of volunteers (see [Contributors](https://github.com/mlcommons/mlcflow/blob/main/CONTRIBUTORS.md)). It serves as a streamlined replacement for the [CMind](https://github.com/mlcommons/ck/tree/master/cm) tool, designed to drive the automation workflows of MLPerf benchmarks more efficiently. You can use this tool for any of your workflow automation tasks. 

mlcflow-1.3.3/VERSION

@@ -0,0 +1 @@
+1.3.3

{mlcflow-1.3.2 → mlcflow-1.3.3}/automation/script/lint.py

@@ -98,7 +98,6 @@ TOP_LEVEL_KEY_ORDER = [
     "tags",
     "tags_help",
     "private",
-    "min_mlc_version",
     "mlc_compat",
 
     # Cache
@@ -174,7 +173,6 @@ SECTION_GROUPS = [
       "tags",
       "tags_help",
       "private",
-      "min_mlc_version",
       "mlc_compat"]),
     ("# Cache",
      ["cache",

{mlcflow-1.3.2 → mlcflow-1.3.3}/automation/script/meta_schema.py

@@ -40,7 +40,6 @@ TOP_LEVEL_SCHEMA = {
     "sort": INT,
     "category_sort": INT,
     "private": BOOL,
-    "min_mlc_version": STR,
 
     # Environment
     "env": DICT,        # dict[str, str]

{mlcflow-1.3.2 → mlcflow-1.3.3}/automation/script/module.py

@@ -611,9 +611,8 @@ class ScriptAutomation(Automation):
         meta = script_item.meta
         path = script_item.path
 
-        # Check mlcflow version requirements
-        # mlc_compat (new): multi-entry, per-entry messages, warn or block
-        # min_mlc_version (legacy): single threshold, always blocks
+        # Check mlcflow version requirements (mlc_compat: multi-entry,
+        # per-entry messages, warn or block)
         script_alias = meta.get('alias', '')
         try:
             from script.compat import get_installed_version, check_mlc_compat, format_compat_notice
@@ -635,18 +634,6 @@ class ScriptAutomation(Automation):
                         )}
                     else:
                         self.logger.warning(notice)
-            else:
-                # Fall back to legacy min_mlc_version (single threshold, always
-                # blocks)
-                min_mlc_version = meta.get('min_mlc_version', '').strip()
-                if min_mlc_version and current_mlc_version:
-                    if utils.compare_versions(
-                            current_mlc_version, min_mlc_version) < 0:
-                        return {'return': 1, 'error': (
-                            'This script requires mlcflow >= {} (installed: {}) '
-                            '— please upgrade: pip install --upgrade mlcflow'.format(
-                                min_mlc_version, current_mlc_version)
-                        )}
         except Exception as e:
             # Never let a compat-check failure block script execution
             self.logger.debug('mlc_compat check skipped: {}'.format(e))
@@ -4539,6 +4526,38 @@ pip install mlcflow
         from script.remote_run import remote_run
         return remote_run(self, i)
 
+    ############################################################
+    def slurm_run(self, i):
+        from script.slurm_run import slurm_run
+        return slurm_run(self, i)
+
+    ############################################################
+    def slurm_docker(self, i):
+        from script.slurm_run import slurm_docker
+        return slurm_docker(self, i)
+
+    ############################################################
+    def slurm_apptainer(self, i):
+        from script.slurm_run import slurm_apptainer
+        return slurm_apptainer(self, i)
+
+    ############################################################
+    def slurm_experiment(self, i):
+        from script.slurm_run import slurm_experiment
+        return slurm_experiment(self, i)
+
+    ############################################################
+    def remote_slurm(self, i):
+        from script.remote_run import remote_run
+        i['remote_action'] = 'slurm-run'
+        return remote_run(self, i)
+
+    ############################################################
+    def remote_slurm_experiment(self, i):
+        from script.remote_run import remote_run
+        i['remote_action'] = 'slurm-experiment'
+        return remote_run(self, i)
+
     ##########################################################################
 
     def _available_variations(self, i):

{mlcflow-1.3.2 → mlcflow-1.3.3}/automation/script/remote_run.py

@@ -320,8 +320,15 @@ def regenerate_script_cmd(i):
     # docker_run_cmd_prefix = i.get('docker_run_cmd_prefix', '')
 
     # Regenerate command from dictionary input
-    run_cmd = 'mlcd' if remote_action == 'docker' else (
-        'mlce' if remote_action == 'experiment' else 'mlcr')
+    _remote_action_cmd = {
+        'docker': 'mlcd',
+        'experiment': 'mlce',
+        'slurm-run': 'mlcsr',
+        'slurm-experiment': 'mlcse',
+        'slurm-docker': 'mlcsd',
+        'slurm-apptainer': 'mlcsa',
+    }
+    run_cmd = _remote_action_cmd.get(remote_action, 'mlcr')
 
     skip_input_for_fake_run = remote_run_settings.get(
         'skip_input_for_fake_run', [])

mlcflow-1.3.3/automation/script/slurm_run.py

@@ -0,0 +1,284 @@
+import os
+import shlex
+import shutil
+import subprocess
+import copy
+from utils import is_true, prune_input
+from script.script_utils import *
+
+
+def slurm_run(self_module, i, slurm_action='run'):
+    """
+    Run MLC scripts on a SLURM cluster node via srun.
+
+    Args:
+        self_module: Reference to the current module for internal calls.
+        i: Dictionary containing input parameters for the slurm execution.
+        slurm_action: The MLC action to use on the node ('run', 'docker',
+            'apptainer', 'experiment'). Defaults to 'run'.
+
+    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 = i.get('quiet', False)
+    logger = self_module.logger
+    env = i.get('env', {})
+
+    # SLURM-specific options with reasonable defaults
+    slurm_partition = i.get('slurm_partition', '')
+    slurm_nodes = i.get('slurm_nodes', '1')
+    slurm_ntasks = i.get('slurm_ntasks', '1')
+    slurm_ntasks_per_node = i.get('slurm_ntasks_per_node', '')
+    slurm_cpus_per_task = i.get('slurm_cpus_per_task', '')
+    slurm_gpus = i.get('slurm_gpus', '')
+    slurm_gpus_per_node = i.get('slurm_gpus_per_node', '')
+    slurm_gpus_per_task = i.get('slurm_gpus_per_task', '')
+    slurm_mem = i.get('slurm_mem', '')
+    slurm_mem_per_cpu = i.get('slurm_mem_per_cpu', '')
+    slurm_mem_per_gpu = i.get('slurm_mem_per_gpu', '')
+    slurm_time = i.get('slurm_time', '')
+    slurm_job_name = i.get('slurm_job_name', '')
+    slurm_output = i.get('slurm_output', '')
+    slurm_error = i.get('slurm_error', '')
+    slurm_account = i.get('slurm_account', '')
+    slurm_qos = i.get('slurm_qos', '')
+    slurm_constraint = i.get('slurm_constraint', '')
+    slurm_exclusive = i.get('slurm_exclusive', False)
+    slurm_export = i.get('slurm_export', 'ALL')
+    slurm_srun_extra_args = i.get('slurm_srun_extra_args', '')
+    slurm_python_venv = i.get('slurm_python_venv', 'mlcflow')
+    slurm_pull_mlc_repos = i.get('slurm_pull_mlc_repos', False)
+    slurm_pre_run_cmds = i.get('slurm_pre_run_cmds', [])
+    slurm_post_run_cmds = i.get('slurm_post_run_cmds', [])
+
+    # Normalize str → list so a single command string doesn't get iterated
+    # char-by-char
+    if isinstance(slurm_pre_run_cmds, str):
+        slurm_pre_run_cmds = [slurm_pre_run_cmds] if slurm_pre_run_cmds else []
+    if isinstance(slurm_post_run_cmds, str):
+        slurm_post_run_cmds = [
+            slurm_post_run_cmds] if slurm_post_run_cmds else []
+
+    # Check that srun is available before proceeding
+    if not shutil.which('srun'):
+        return {
+            'return': 1,
+            'error': "srun not found in PATH -- are you on a SLURM login node?"
+        }
+
+    # Validate and normalize integer SLURM parameters
+    int_params = {
+        'slurm_nodes': slurm_nodes,
+        'slurm_ntasks': slurm_ntasks,
+        'slurm_ntasks_per_node': slurm_ntasks_per_node,
+        'slurm_cpus_per_task': slurm_cpus_per_task,
+    }
+    for param_name, param_val in int_params.items():
+        if param_val != '':
+            try:
+                int(param_val)
+            except (ValueError, TypeError):
+                return {
+                    'return': 1,
+                    'error': f'Invalid value for {param_name}: {param_val!r} (must be an integer)'
+                }
+    slurm_nodes = str(int(slurm_nodes)) if slurm_nodes else ''
+    slurm_ntasks = str(int(slurm_ntasks)) if slurm_ntasks else ''
+    slurm_ntasks_per_node = str(
+        int(slurm_ntasks_per_node)) if slurm_ntasks_per_node else ''
+    slurm_cpus_per_task = str(
+        int(slurm_cpus_per_task)) if slurm_cpus_per_task else ''
+
+    prune_result = prune_input(
+        {'input': i, 'extra_keys_starts_with': ['slurm_']})
+    if prune_result['return'] > 0:
+        return prune_result
+
+    run_input = prune_result['new_input']
+
+    cur_dir = os.getcwd()
+
+    r = self_module._select_script(i)
+    if r['return'] > 0:
+        return r
+
+    script = r['script']
+
+    meta, script_path = script.meta, script.path
+    tags, script_alias, script_uid = meta.get(
+        "tags", []), meta.get(
+        'alias', ''), meta.get(
+        'uid', '')
+
+    r = self_module.update_run_state_for_selected_script_and_variations(
+        script, i)
+    if r['return'] > 0:
+        return r
+
+    run_state = self_module.run_state
+
+    env = self_module.env
+    state = self_module.state
+
+    i_copy = copy.deepcopy(i)
+    i_copy['run_cmd'] = run_input
+    i_copy['slurm_action'] = slurm_action
+
+    r = regenerate_script_cmd(i_copy)
+    if r['return'] > 0:
+        return r
+
+    script_run_cmd = r['run_cmd_string']
+
+    if quiet:
+        script_run_cmd += ' --quiet'
+
+    # Build the commands to run inside srun
+    run_cmds = []
+
+    # Bootstrap mlcflow on the node
+    quoted_venv = shlex.quote(slurm_python_venv)
+    run_cmds.append(
+        f'curl -sSL https://raw.githubusercontent.com/mlcommons/mlcflow/refs/heads/dev/docs/install/mlcflow_unix_installer.sh | bash -s -- --yes --venv-dir {quoted_venv}')
+    run_cmds.append(f'. {quoted_venv}/bin/activate')
+
+    if is_true(slurm_pull_mlc_repos):
+        run_cmds.append('mlc pull repo')
+
+    # Pre-run commands (after mlcflow is available)
+    run_cmds.extend(slurm_pre_run_cmds)
+
+    # The actual script command
+    run_cmds.append(script_run_cmd)
+
+    # Post-run commands
+    run_cmds.extend(slurm_post_run_cmds)
+
+    # Join all commands with && so failure stops execution
+    combined_cmd = ' && '.join(run_cmds)
+
+    # Build srun command
+    srun_args = []
+    srun_args.append('srun')
+
+    if slurm_partition:
+        srun_args.extend(['--partition', slurm_partition])
+    if slurm_nodes:
+        srun_args.extend(['--nodes', str(slurm_nodes)])
+    if slurm_ntasks:
+        srun_args.extend(['--ntasks', str(slurm_ntasks)])
+    if slurm_ntasks_per_node:
+        srun_args.extend(['--ntasks-per-node', str(slurm_ntasks_per_node)])
+    if slurm_cpus_per_task:
+        srun_args.extend(['--cpus-per-task', str(slurm_cpus_per_task)])
+    if slurm_gpus:
+        srun_args.extend(['--gpus', str(slurm_gpus)])
+    if slurm_gpus_per_node:
+        srun_args.extend(['--gpus-per-node', str(slurm_gpus_per_node)])
+    if slurm_gpus_per_task:
+        srun_args.extend(['--gpus-per-task', str(slurm_gpus_per_task)])
+    if slurm_mem:
+        srun_args.extend(['--mem', str(slurm_mem)])
+    if slurm_mem_per_cpu:
+        srun_args.extend(['--mem-per-cpu', str(slurm_mem_per_cpu)])
+    if slurm_mem_per_gpu:
+        srun_args.extend(['--mem-per-gpu', str(slurm_mem_per_gpu)])
+    if slurm_time:
+        srun_args.extend(['--time', str(slurm_time)])
+    if slurm_job_name:
+        srun_args.extend(['--job-name', slurm_job_name])
+    if slurm_output:
+        srun_args.extend(['--output', slurm_output])
+    if slurm_error:
+        srun_args.extend(['--error', slurm_error])
+    if slurm_account:
+        srun_args.extend(['--account', slurm_account])
+    if slurm_qos:
+        srun_args.extend(['--qos', slurm_qos])
+    if slurm_constraint:
+        srun_args.extend(['--constraint', slurm_constraint])
+    if is_true(slurm_exclusive):
+        srun_args.append('--exclusive')
+    if slurm_export:
+        srun_args.extend(['--export', slurm_export])
+
+    # Append any extra srun arguments the user provided
+    if slurm_srun_extra_args:
+        srun_args.extend(shlex.split(slurm_srun_extra_args))
+
+    # Wrap the combined command in bash -c for srun
+    srun_args.extend(['bash', '-c', combined_cmd])
+
+    logger.info(f'Running on SLURM: {shlex.join(srun_args)}')
+
+    rc = subprocess.call(srun_args)
+
+    if rc != 0:
+        return {'return': 1,
+                'error': f'srun exited with return code {rc}'}
+
+    return {'return': 0}
+
+
+def regenerate_script_cmd(i):
+    """
+    Rebuild the mlcr/mlcd/mlce/mlca command string from the pruned input dict.
+    """
+
+    i_run_cmd = i['run_cmd']
+    slurm_action = i.get('slurm_action', 'run')
+
+    action_to_cmd = {
+        'run': 'mlcr',
+        'docker': 'mlcd',
+        'apptainer': 'mlca',
+        'experiment': 'mlce',
+    }
+    run_cmd = action_to_cmd.get(slurm_action, 'mlcr')
+
+    def rebuild_flags(command_dict, prefix):
+        command_line = ""
+        keys = sorted(command_dict.keys(), key=lambda x: x != "tags")
+
+        for key in keys:
+            full_key = f"{prefix}.{key}" if prefix else key
+            value = command_dict[key]
+
+            if isinstance(value, dict):
+                if value:
+                    command_line += rebuild_flags(value, full_key)
+            elif isinstance(value, list):
+                if value:
+                    list_values = ",".join(
+                        shlex.quote(str(item)) for item in value)
+                    command_line += f" --{full_key},={list_values}"
+            else:
+                if full_key in ['s', 'v']:
+                    command_line += f" -{full_key}"
+                else:
+                    command_line += f" --{full_key}={shlex.quote(str(value))}"
+
+        return command_line
+
+    run_cmd += rebuild_flags(i_run_cmd, "")
+
+    return {'return': 0, 'run_cmd_string': run_cmd}
+
+
+def slurm_docker(self_module, i):
+    """Run an MLC docker script on a SLURM cluster node via srun."""
+    return slurm_run(self_module, i, slurm_action='docker')
+
+
+def slurm_apptainer(self_module, i):
+    """Run an MLC apptainer script on a SLURM cluster node via srun."""
+    return slurm_run(self_module, i, slurm_action='apptainer')
+
+
+def slurm_experiment(self_module, i):
+    """Run an MLC experiment on a SLURM cluster node via srun."""
+    return slurm_run(self_module, i, slurm_action='experiment')

{mlcflow-1.3.2 → mlcflow-1.3.3}/mlc/main.py

@@ -240,6 +240,34 @@ def mlcrd():
     mlc_expand_short("remote-docker")
 
 
+def mlcsr():
+    mlc_expand_short("slurm-run")
+
+
+def mlcse():
+    mlc_expand_short("slurm-experiment")
+
+
+def mlcsd():
+    mlc_expand_short("slurm-docker")
+
+
+def mlcsa():
+    mlc_expand_short("slurm-apptainer")
+
+
+def mlcrs():
+    mlc_expand_short("remote-slurm")
+
+
+def mlcres():
+    mlc_expand_short("remote-slurm-experiment")
+
+
+def mlcrse():
+    mlc_expand_short("remote-slurm-experiment")
+
+
 def mlce():
     mlc_expand_short("experiment")
 
@@ -374,7 +402,10 @@ def build_parser(pre_args):
     # Script-only
     for action in ['docker', 'docker-run', 'apptainer', 'apptainer-run',
                    'experiment', 'remote-run', 'remote-experiment',
-                   'remote-docker', 'doc', 'lint']:
+                   'remote-docker', 'remote-slurm', 'remote-slurm-experiment',
+                   'slurm-run',
+                   'slurm-docker', 'slurm-apptainer', 'slurm-experiment',
+                   'doc', 'lint']:
         p = subparsers.add_parser(action, add_help=False)
         p.add_argument('target', choices=['script', 'run'])
         p.add_argument(
@@ -416,7 +447,10 @@ def build_run_args(args):
 
     if args.command in ['docker', 'docker-run', 'apptainer', 'apptainer-run',
                         'experiment', 'remote-run', 'remote-experiment',
-                        'remote-docker', 'doc', 'lint'] and args.target == "run":
+                        'remote-docker', 'remote-slurm', 'remote-slurm-experiment',
+                        'slurm-run',
+                        'slurm-docker', 'slurm-apptainer', 'slurm-experiment',
+                        'doc', 'lint'] and args.target == "run":
         # run_args['target'] = 'script' #dont modify this as script might have
         # target as in input
         args.target = "script"
@@ -552,7 +586,19 @@ def main():
         if not pre_args.action and not pre_args.target:
             help_text += main.__doc__
         elif pre_args.action and not pre_args.target:
-            if pre_args.action not in ['script', 'cache', 'repo']:
+            script_only_actions = {
+                a.replace("-", "_")
+                for a in [
+                    'docker', 'docker-run', 'apptainer', 'apptainer-run',
+                    'experiment', 'remote-run', 'remote-experiment',
+                    'remote-docker', 'remote-slurm', 'remote-slurm-experiment',
+                    'slurm-run', 'slurm-docker', 'slurm-apptainer', 'slurm-experiment',
+                    'doc', 'lint',
+                ]
+            }
+            if pre_args.action in script_only_actions:
+                pre_args.target = 'script'
+            elif pre_args.action not in ['script', 'cache', 'repo']:
                 logger.error(f"Invalid target {pre_args.action}")
                 raise Exception(f"""Invalid target {pre_args.action}""")
             else:

{mlcflow-1.3.2 → mlcflow-1.3.3}/mlc/meta_schema.py

@@ -40,7 +40,6 @@ TOP_LEVEL_SCHEMA = {
     "sort": INT,
     "category_sort": INT,
     "private": BOOL,
-    "min_mlc_version": STR,
 
     # Environment
     "env": DICT,        # dict[str, str]

{mlcflow-1.3.2 → mlcflow-1.3.3}/mlc/script_action.py

@@ -300,36 +300,17 @@ Main Script Meta:""")
                     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 == "apptainer":
-                    result = automation_instance.apptainer(
-                        run_args)  # Pass args to the apptainer 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:
+                method = getattr(automation_instance, function_name, None)
+                if method is None:
                     return {
-                        'return': 1, 'error': f'Function {function_name} is not supported'}
+                        'return': 1,
+                        'error': (
+                            f"Action '{function_name}' is not supported by the loaded "
+                            f"automation engine at '{module_path}'. "
+                            "You may need a newer version of mlcflow."
+                        )
+                    }
+                result = method(run_args)
             except ScriptExecutionError:
                 raise
             except Exception as exc:
@@ -734,6 +715,169 @@ Main Script Meta:""")
         run_args["remote_action"] = "docker"
         return self.call_script_module_function("remote_run", run_args)
 
+    def slurm_run(self, run_args):
+        """
+    ################################################################################
+    Target: Script
+    Action: slurm-run
+    ################################################################################
+
+    The `slurm-run` action runs an MLC script on a SLURM cluster node via srun.
+
+    Flags Available:
+
+    1. --slurm_partition:
+        SLURM partition to submit to
+    2. --slurm_nodes:
+        Number of nodes (default: 1)
+    3. --slurm_ntasks:
+        Number of tasks (default: 1)
+    4. --slurm_ntasks_per_node:
+        Number of tasks per node
+    5. --slurm_cpus_per_task:
+        Number of CPUs per task
+    6. --slurm_gpus:
+        Total number of GPUs
+    7. --slurm_gpus_per_node:
+        Number of GPUs per node
+    8. --slurm_gpus_per_task:
+        Number of GPUs per task
+    9. --slurm_mem:
+        Total memory (e.g., 16G)
+    10. --slurm_mem_per_cpu:
+        Memory per CPU (e.g., 4G)
+    11. --slurm_mem_per_gpu:
+        Memory per GPU (e.g., 8G)
+    12. --slurm_time:
+        Time limit (e.g., 01:00:00)
+    13. --slurm_job_name:
+        Job name
+    14. --slurm_output:
+        Output file pattern (e.g., slurm-%j.out)
+    15. --slurm_error:
+        Error file pattern (e.g., slurm-%j.err)
+    16. --slurm_account:
+        Account to charge
+    17. --slurm_qos:
+        Quality of service
+    18. --slurm_constraint:
+        Node feature constraint
+    19. --slurm_exclusive:
+        Request exclusive node access (default: False)
+    20. --slurm_export:
+        Environment export mode (default: ALL)
+    21. --slurm_srun_extra_args:
+        Additional arguments to pass directly to srun
+    22. --slurm_python_venv:
+        Python virtual environment name on the node (default: mlcflow)
+    23. --slurm_pull_mlc_repos:
+        Pull MLC repos on the node before running
+    24. --slurm_pre_run_cmds:
+        Commands to run on the node before the main script
+    25. --slurm_post_run_cmds:
+        Commands to run on the node after the main script
+
+    Example Command:
+
+    mlc slurm-run script --tags=detect,os
+    mlcsr detect,os --slurm_partition=gpu --slurm_gpus=1 --slurm_time=01:00:00
+
+        """
+        return self.call_script_module_function("slurm_run", run_args)
+
+    def slurm_docker(self, run_args):
+        """
+    ################################################################################
+    Target: Script
+    Action: slurm-docker
+    ################################################################################
+
+    The `slurm-docker` action runs an MLC docker script on a SLURM cluster node
+    via srun.  Accepts the same --slurm_* flags as slurm-run.
+
+    Example Command:
+
+    mlc slurm-docker script --tags=detect,os
+    mlcsd detect,os --slurm_partition=gpu --slurm_gpus=1
+
+        """
+        return self.call_script_module_function("slurm_docker", run_args)
+
+    def slurm_apptainer(self, run_args):
+        """
+    ################################################################################
+    Target: Script
+    Action: slurm-apptainer
+    ################################################################################
+
+    The `slurm-apptainer` action runs an MLC apptainer script on a SLURM cluster
+    node via srun.  Accepts the same --slurm_* flags as slurm-run.
+
+    Example Command:
+
+    mlc slurm-apptainer script --tags=detect,os
+    mlcsa detect,os --slurm_partition=gpu --slurm_gpus=1
+
+        """
+        return self.call_script_module_function("slurm_apptainer", run_args)
+
+    def slurm_experiment(self, run_args):
+        """
+    ################################################################################
+    Target: Script
+    Action: slurm-experiment
+    ################################################################################
+
+    The `slurm-experiment` action runs an MLC experiment on a SLURM cluster node
+    via srun.  Accepts the same --slurm_* flags as slurm-run.
+
+    Example Command:
+
+    mlc slurm-experiment script --tags=detect,os
+    mlcse detect,os --slurm_partition=gpu
+
+        """
+        return self.call_script_module_function("slurm_experiment", run_args)
+
+    def remote_slurm(self, run_args):
+        """
+    ################################################################################
+    Target: Script
+    Action: remote-slurm
+    ################################################################################
+
+    The `remote-slurm` action connects to a remote machine via SSH and runs an
+    MLC slurm-run script there.  Accepts all --remote_* flags from remote-run as
+    well as all --slurm_* flags from slurm-run.
+
+    Example Command:
+
+    mlc remote-slurm script --tags=detect,os --remote_host=mycluster.example.com
+    mlcrs detect,os --remote_host=mycluster.example.com --slurm_partition=gpu
+
+        """
+        return self.call_script_module_function("remote_slurm", run_args)
+
+    def remote_slurm_experiment(self, run_args):
+        """
+    ################################################################################
+    Target: Script
+    Action: remote-slurm-experiment
+    ################################################################################
+
+    The `remote-slurm-experiment` action connects to a remote machine via SSH
+    and runs an MLC slurm-experiment script there.  Accepts all --remote_* flags
+    from remote-run as well as all --slurm_* flags from slurm-run.
+
+    Example Command:
+
+    mlc remote-slurm-experiment script --tags=detect,os --remote_host=mycluster.example.com
+    mlcres detect,os --remote_host=mycluster.example.com --slurm_partition=gpu
+
+        """
+        return self.call_script_module_function(
+            "remote_slurm_experiment", run_args)
+
 
 class ScriptExecutionError(Exception):
     def __init__(self, message, script_name=None, repo_alias=None,

{mlcflow-1.3.2 → mlcflow-1.3.3}/mlcflow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlcflow
-Version: 1.3.2
+Version: 1.3.3
 Summary: An automation interface tailored for CPU/GPU benchmarking
 Author-email: MLCommons <systems@mlcommons.org>
 License: 
@@ -206,10 +206,10 @@ Dynamic: license-file
 [![License](https://img.shields.io/badge/License-Apache%202.0-green)](https://github.com/mlcommons/mlcflow/blob/main/LICENSE.md)
 [![Downloads](https://static.pepy.tech/badge/mlcflow)](https://pepy.tech/project/mlcflow)
 
-[![MLC core actions test](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml/badge.svg?branch=dev)](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml)
-[![MLC script automation features test](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml/badge.svg?branch=dev)](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml)
-[![MLPerf inference resnet50](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml/badge.svg?branch=dev)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml)
-[![MLPerf inference bert (deepsparse, tf, onnxruntime, pytorch)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-bert.yml/badge.svg?branch=dev)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-bert.yml)
+[![MLC core actions test](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml/badge.svg?branch=main)](https://github.com/mlcommons/mlcflow/actions/workflows/test-mlc-core-actions.yaml)
+[![MLC script automation features test](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml/badge.svg?branch=main)](https://github.com/mlcommons/mlperf-automations/actions/workflows/test-mlc-script-features.yml)
+[![MLPerf inference resnet50](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml/badge.svg?branch=main)](https://github.com/mlcommons/mlcflow/actions/workflows/mlperf-inference-resnet50.yml)
+
 
 
 MLCFlow is a versatile CLI and Python interface developed by MLCommons in collaboration with a dedicated team of volunteers (see [Contributors](https://github.com/mlcommons/mlcflow/blob/main/CONTRIBUTORS.md)). It serves as a streamlined replacement for the [CMind](https://github.com/mlcommons/ck/tree/master/cm) tool, designed to drive the automation workflows of MLPerf benchmarks more efficiently. You can use this tool for any of your workflow automation tasks. 

{mlcflow-1.3.2 → mlcflow-1.3.3}/mlcflow.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ automation/script/meta_schema.py
 automation/script/module.py
 automation/script/remote_run.py
 automation/script/script_utils.py
+automation/script/slurm_run.py
 automation/script/validate.py
 mlc/__init__.py
 mlc/__main__.py
@@ -50,4 +51,5 @@ tests/test_cache_mark_tmp.py
 tests/test_mlcflow_unix_installer.py
 tests/test_repo_action_extra_git_args.py
 tests/test_script_action_apptainer.py
+tests/test_slurm_run.py
 tests/test_unix_installer_venv.py

{mlcflow-1.3.2 → mlcflow-1.3.3}/mlcflow.egg-info/entry_points.txt

@@ -8,5 +8,12 @@ mlcp = mlc.main:mlcp
 mlcr = mlc.main:mlcr
 mlcrd = mlc.main:mlcrd
 mlcre = mlc.main:mlcre
+mlcres = mlc.main:mlcres
 mlcrr = mlc.main:mlcrr
+mlcrs = mlc.main:mlcrs
+mlcrse = mlc.main:mlcrse
+mlcsa = mlc.main:mlcsa
+mlcsd = mlc.main:mlcsd
+mlcse = mlc.main:mlcse
+mlcsr = mlc.main:mlcsr
 mlct = mlc.main:mlct

{mlcflow-1.3.2 → mlcflow-1.3.3}/pyproject.toml

@@ -59,3 +59,10 @@ mlct = "mlc.main:mlct"
 mlcp = "mlc.main:mlcp"
 mlcre = "mlc.main:mlcre"
 mlcrd = "mlc.main:mlcrd"
+mlcsr = "mlc.main:mlcsr"
+mlcse = "mlc.main:mlcse"
+mlcsd = "mlc.main:mlcsd"
+mlcsa = "mlc.main:mlcsa"
+mlcrs = "mlc.main:mlcrs"
+mlcres = "mlc.main:mlcres"
+mlcrse = "mlc.main:mlcrse"

mlcflow-1.3.3/tests/test_slurm_run.py

@@ -0,0 +1,158 @@
+"""
+Unit tests for slurm_run.py command construction and remote_run.py mapping.
+"""
+import sys
+import os
+import unittest
+
+# Ensure the automation directory is on sys.path so slurm_run / remote_run
+# can be imported without a full mlcflow install.
+_automation_dir = os.path.join(
+    os.path.dirname(__file__), '..', 'automation'
+)
+_automation_dir = os.path.abspath(_automation_dir)
+if _automation_dir not in sys.path:
+    sys.path.insert(0, _automation_dir)
+
+
+# ---------------------------------------------------------------------------
+# remote_run.regenerate_script_cmd — remote_action → mlc command mapping
+# ---------------------------------------------------------------------------
+class TestRemoteRunMapping(unittest.TestCase):
+    def _regenerate(self, remote_action, run_cmd=None):
+        from script.remote_run import regenerate_script_cmd
+        i = {
+            'remote_action': remote_action,
+            'run_cmd': run_cmd or {'tags': 'detect,os'},
+            'remote_run_settings': {},
+            'fake_run': False,
+        }
+        result = regenerate_script_cmd(i)
+        self.assertEqual(result['return'], 0)
+        return result['run_cmd_string']
+
+    def test_docker_maps_to_mlcd(self):
+        self.assertTrue(self._regenerate('docker').startswith('mlcd'))
+
+    def test_experiment_maps_to_mlce(self):
+        self.assertTrue(self._regenerate('experiment').startswith('mlce'))
+
+    def test_slurm_run_maps_to_mlcsr(self):
+        self.assertTrue(self._regenerate('slurm-run').startswith('mlcsr'))
+
+    def test_slurm_experiment_maps_to_mlcse(self):
+        # Regression test for blocker #1: was falling through to 'mlcr'
+        self.assertTrue(self._regenerate(
+            'slurm-experiment').startswith('mlcse'))
+
+    def test_slurm_docker_maps_to_mlcsd(self):
+        self.assertTrue(self._regenerate('slurm-docker').startswith('mlcsd'))
+
+    def test_slurm_apptainer_maps_to_mlcsa(self):
+        self.assertTrue(self._regenerate(
+            'slurm-apptainer').startswith('mlcsa'))
+
+    def test_unknown_action_defaults_to_mlcr(self):
+        self.assertTrue(self._regenerate('unknown-action').startswith('mlcr'))
+
+    def test_run_action_defaults_to_mlcr(self):
+        self.assertTrue(self._regenerate('run').startswith('mlcr'))
+
+
+# ---------------------------------------------------------------------------
+# slurm_run.regenerate_script_cmd — slurm_action → mlc command mapping
+# ---------------------------------------------------------------------------
+class TestSlurmRunCmdGeneration(unittest.TestCase):
+    def _regenerate(self, slurm_action, run_cmd=None):
+        from script.slurm_run import regenerate_script_cmd
+        i = {
+            'slurm_action': slurm_action,
+            'run_cmd': run_cmd or {'tags': 'detect,os'},
+        }
+        result = regenerate_script_cmd(i)
+        self.assertEqual(result['return'], 0)
+        return result['run_cmd_string']
+
+    def test_run_maps_to_mlcr(self):
+        self.assertTrue(self._regenerate('run').startswith('mlcr'))
+
+    def test_docker_maps_to_mlcd(self):
+        self.assertTrue(self._regenerate('docker').startswith('mlcd'))
+
+    def test_apptainer_maps_to_mlca(self):
+        self.assertTrue(self._regenerate('apptainer').startswith('mlca'))
+
+    def test_experiment_maps_to_mlce(self):
+        self.assertTrue(self._regenerate('experiment').startswith('mlce'))
+
+    def test_unknown_defaults_to_mlcr(self):
+        self.assertTrue(self._regenerate('unknown').startswith('mlcr'))
+
+    def test_tags_included_in_output(self):
+        cmd = self._regenerate('run', run_cmd={'tags': 'detect,os'})
+        self.assertIn('detect,os', cmd)
+
+    def test_flag_included_in_output(self):
+        cmd = self._regenerate(
+            'run',
+            run_cmd={
+                'tags': 'detect,os',
+                'verbose': True})
+        self.assertIn('--verbose', cmd)
+
+
+# ---------------------------------------------------------------------------
+# slurm_run string normalization (pre/post run cmds)
+# ---------------------------------------------------------------------------
+class TestSlurmRunInputNormalization(unittest.TestCase):
+    """
+    Test that str slurm_pre_run_cmds / slurm_post_run_cmds are wrapped in a
+    list instead of being iterated character-by-character.
+    The easiest way to test this is to call slurm_run with a mock that
+    immediately returns, and inspect the srun_args built.
+    """
+
+    def test_pre_run_cmds_str_is_normalized(self):
+        """A single str command must not be extended char-by-char."""
+        import shutil
+        from unittest.mock import patch, MagicMock
+
+        mock_self = MagicMock()
+        mock_self._select_script.return_value = {
+            'return': 0,
+            'script': MagicMock(
+                meta={'tags': [], 'alias': 'detect-os', 'uid': '0' * 16},
+                path='/fake/path'
+            )
+        }
+        mock_self.update_run_state_for_selected_script_and_variations.return_value = {
+            'return': 0}
+        mock_self.run_state = {}
+        mock_self.env = {}
+        mock_self.state = {}
+        mock_self.logger = MagicMock()
+
+        captured_args = []
+
+        def fake_call(args):
+            captured_args.extend(args)
+            return 0
+
+        with patch('script.slurm_run.shutil.which', return_value='/usr/bin/srun'), \
+                patch('script.slurm_run.subprocess.call', side_effect=fake_call):
+            from script.slurm_run import slurm_run
+            result = slurm_run(mock_self, {
+                'tags': 'detect,os',
+                'slurm_pre_run_cmds': 'module load cuda',
+                'env': {},
+            })
+
+        # The bash -c combined_cmd should contain 'module load cuda' as a
+        # complete token, not individual characters.
+        bash_c_cmd = captured_args[-1]  # last element after 'bash', '-c'
+        self.assertIn('module load cuda', bash_c_cmd,
+                      "Pre-run command string was expanded char-by-char instead of as a whole")
+
+
+if __name__ == '__main__':
+    unittest.main()

mlcflow-1.3.2/VERSION

@@ -1 +0,0 @@
-1.3.2