mlcflow 1.2.6__tar.gz → 1.2.8__tar.gz

{mlcflow-1.2.6 → mlcflow-1.2.8}/PKG-INFO

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

{mlcflow-1.2.6 → mlcflow-1.2.8}/mlc/action.py

@@ -5,6 +5,7 @@ import yaml
 import logging
 import re
 import shutil
+import sys
 from pathlib import Path
 
 from .logger import logger, setup_logging
@@ -483,6 +484,7 @@ class Action:
         target_name = i.get('target_name', i.get('target', "cache"))
         i['target_name'] = target_name
         ii = i.copy()
+        quiet = ii.get('quiet', sys.stdin.isatty())
 
         if i.get('search_tags'):
             ii['tags'] = ",".join(i['search_tags'])
@@ -504,9 +506,12 @@ class Action:
 
         new_tags = set(search_tags)
         if len(found_items) > 1:
-            # Step 3: Ask user for confirmation if multiple items are found
-            user_input = input(
-                f"{len(found_items)} items found. Do you want to update all? (yes/no): ").strip().lower()
+            if quiet:
+                user_input = 'yes'
+            else:
+                # Step 3: Ask user for confirmation if multiple items are found
+                user_input = input(
+                    f"{len(found_items)} items found. Do you want to update all? (yes/no): ").strip().lower()
             if user_input not in ['yes', 'y']:
                 return {'return': 0,
                         'message': 'Update operation canceled by the user.'}

{mlcflow-1.2.6 → mlcflow-1.2.8}/mlc/main.py

@@ -576,7 +576,7 @@ def main():
             else:
                 pre_args.target, pre_args.action = pre_args.action, None
             actions = get_action(pre_args.target, default_parent)
-            help_text += actions.__doc__
+            help_text += actions.__doc__ or ""
             # iterate through every method
             for method_name, method in inspect.getmembers(
                     actions.__class__, inspect.isfunction):
@@ -588,7 +588,7 @@ def main():
             action_name = pre_args.action.replace("-", "_")
             try:
                 method = getattr(actions, action_name)
-                help_text += actions.__doc__
+                help_text += actions.__doc__ or ""
                 if method.__doc__:
                     help_text += method.__doc__
             except AttributeError:

{mlcflow-1.2.6 → mlcflow-1.2.8}/mlc/repo_action.py

@@ -40,11 +40,164 @@ class RepoAction(Action):
 
     """
 
+    # These phrases come from git's current stderr output and may vary by
+    # version or locale, so keep the matching logic narrowly scoped.
+    GIT_MISSING_BRANCH_PHRASE = "did not match any file(s) known to git"
+    GIT_FAST_FORWARD_FAILURE_PHRASE = "not possible to fast-forward"
+
     def __init__(self, parent=None):
         # super().__init__(parent)
         self.parent = parent
         self.__dict__.update(vars(parent))
 
+    def _build_pull_command(self, repo_path, branch=None, clone_depth=None,
+                            fast_forward_only=False):
+        pull_command = ['git', '-C', repo_path, 'pull']
+        if fast_forward_only:
+            pull_command.append('--ff-only')
+        if clone_depth is not None:
+            if self._is_shallow_repo(repo_path):
+                pull_command.extend(['--depth', str(clone_depth)])
+            else:
+                logger.warning(
+                    f"--depth/--shallow ignored for pull on non-shallow repo {repo_path}. "
+                    "Re-clone with --shallow to create a shallow copy."
+                )
+        # Preserve the historical existing-repo behavior of a plain
+        # `git pull` by default. The branch argument is only forwarded to
+        # `git pull` when the internal strict path explicitly opts into
+        # fast-forward-only updates.
+        if branch and fast_forward_only:
+            pull_command.extend(['origin', branch])
+        return pull_command
+
+    def _checkout_pull_branch(self, repo_path, branch):
+        """Ensure *branch* is checked out locally before a strict pull.
+
+        First tries to checkout an existing local branch. If that fails, fetches
+        the branch from origin and creates a new tracking branch. Raises
+        RuntimeError with contextual guidance when the branch cannot be prepared.
+
+        Args:
+            repo_path: Local repository path.
+            branch: Branch name to prepare before pulling.
+
+        Raises:
+            RuntimeError: If the branch cannot be fetched or checked out.
+        """
+        try:
+            subprocess.run(
+                ['git', '-C', repo_path, 'checkout', branch],
+                capture_output=True,
+                text=True,
+                check=True)
+        except subprocess.CalledProcessError as checkout_error:
+            checkout_error_text = self._subprocess_error_message(
+                checkout_error)
+            lowered_checkout_error = checkout_error_text.lower()
+            # Git uses the same exit code for many checkout failures, so we
+            # only fall back to fetch+track when stderr includes both
+            # "pathspec" and Git's usual missing-ref phrase
+            # "did not match any file(s) known to git".
+            missing_local_branch = (
+                "pathspec" in lowered_checkout_error
+                and self.GIT_MISSING_BRANCH_PHRASE in lowered_checkout_error
+            )
+            if not missing_local_branch:
+                raise RuntimeError(
+                    f"Cannot switch to branch '{branch}' in {repo_path}: "
+                    f"{checkout_error_text}"
+                ) from checkout_error
+            try:
+                subprocess.run(
+                    ['git', '-C', repo_path, 'fetch', 'origin', branch],
+                    capture_output=True,
+                    text=True,
+                    check=True)
+            except subprocess.CalledProcessError as fetch_error:
+                raise RuntimeError(
+                    f"Failed to fetch branch '{branch}' in {repo_path}: "
+                    f"{self._subprocess_error_message(fetch_error)}. "
+                    "Ensure the branch exists on origin and that the repository is reachable."
+                ) from fetch_error
+
+            try:
+                subprocess.run(
+                    ['git', '-C', repo_path, 'checkout', '-b',
+                        branch, '--track', f'origin/{branch}'],
+                    capture_output=True,
+                    text=True,
+                    check=True)
+            except subprocess.CalledProcessError as tracking_error:
+                raise RuntimeError(
+                    f"Initial checkout of '{branch}' failed in {repo_path}. "
+                    "After fetching from origin, creating a tracking branch also failed. "
+                    f"Initial error: {checkout_error_text}. "
+                    f"Tracking branch error: {self._subprocess_error_message(tracking_error)}. "
+                    "Check that the branch name is correct and that your local checkout can track origin."
+                ) from tracking_error
+
+    @staticmethod
+    def _format_stash_restore_guidance(repo_path):
+        return (
+            f"Local changes remain in stash. Please run `git -C {repo_path} stash apply` "
+            "after resolving pull issues."
+        )
+
+    def _format_pull_error(self, repo_path, error_message, stash_created=False,
+                           force=False, failure_phase="git pull"):
+        """Format a pull failure message.
+
+        Args:
+            repo_path: Repository path being updated.
+            error_message: Original stderr/stdout-derived git failure text.
+            stash_created: Whether local changes were stashed for a force pull.
+            force: Whether the failure happened on a force-pull path.
+            failure_phase: Phase label such as ``git pull`` or
+                ``branch checkout``.
+
+        Returns:
+            A user-facing error string with optional recovery guidance.
+        """
+        prefix = "Force pull failed" if force else "Pull failed"
+        if failure_phase:
+            prefix = f"{prefix} during {failure_phase}"
+
+        resolution = ""
+        lowered_error = error_message.lower()
+        # Git reports ff-only failures via stderr text instead of a distinct
+        # exit code, so use this case-insensitive substring from the standard
+        # "Not possible to fast-forward, aborting." message to add guidance.
+        if self.GIT_FAST_FORWARD_FAILURE_PHRASE in lowered_error:
+            resolution = (
+                " Check whether the local and remote branches have diverged "
+                "and reconcile them manually before retrying."
+            )
+
+        if stash_created:
+            return (
+                f"{prefix} for {repo_path}. "
+                f"{self._format_stash_restore_guidance(repo_path)} "
+                f"Details: {error_message}{resolution}"
+            )
+
+        return f"{prefix} for {repo_path}: {error_message}{resolution}"
+
+    @staticmethod
+    def _subprocess_error_message(error):
+        """Return stderr, then stdout, then str(error), whichever is populated first."""
+        return (error.stderr or error.stdout or str(error)).strip()
+
+    @staticmethod
+    def _validate_extra_git_args(extra_args):
+        disallowed_pattern = re.compile(r"[\r\n]")
+        for arg in extra_args:
+            if disallowed_pattern.search(arg):
+                return (
+                    "--extra_git_args may not include carriage returns or newlines."
+                )
+        return None
+
     def add(self, run_args):
         """
     ####################################################################################################################
@@ -337,7 +490,7 @@ class RepoAction(Action):
 
     def pull_repo(self, repo_url, branch=None, checkout=None, tag=None,
                   pat=None, ssh=None, ignore_on_conflict=False, repo_path=None, force=False,
-                  shallow=False, depth=None, extra_git_args=None):
+                  shallow=False, depth=None, extra_git_args=None, fast_forward_only=False):
 
         # Determine the checkout path from environment or default
         repo_base_path = self.repos_path  # either the value will be from 'MLC_REPOS'
@@ -380,7 +533,7 @@ class RepoAction(Action):
                     clone_depth = int(depth)
                 except (TypeError, ValueError):
                     return {
-                        "return": 1, "error": f"Invalid value for --depth: {depth!r}. Must be a positive integer."}
+                        "return": 1, "error": f"Invalid value for --depth: {depth}. Must be a positive integer."}
                 if clone_depth < 1:
                     return {
                         "return": 1, "error": f"Invalid value for --depth: {clone_depth}. Must be a positive integer."}
@@ -391,9 +544,23 @@ class RepoAction(Action):
             extra_args = []
             if extra_git_args:
                 if isinstance(extra_git_args, list):
+                    if not all(isinstance(arg, str) for arg in extra_git_args):
+                        return {
+                            "return": 1,
+                            "error": "--extra_git_args list entries must all be strings."
+                        }
                     extra_args = extra_git_args
+                elif isinstance(extra_git_args, str):
+                    extra_args = shlex.split(extra_git_args)
                 else:
-                    extra_args = shlex.split(str(extra_git_args))
+                    return {
+                        "return": 1,
+                        "error": "--extra_git_args must be provided as a string or list of strings."
+                    }
+                extra_git_args_error = self._validate_extra_git_args(
+                    extra_args)
+                if extra_git_args_error:
+                    return {"return": 1, "error": extra_git_args_error}
 
             # If the directory doesn't exist, clone it
             if not os.path.exists(repo_path):
@@ -468,30 +635,33 @@ class RepoAction(Action):
                     logger.info(
                         "Pulling latest changes...")
                     try:
-                        pull_command = ['git', '-C', repo_path, 'pull']
-                        if clone_depth is not None:
-                            if self._is_shallow_repo(repo_path):
-                                pull_command += ['--depth', str(clone_depth)]
-                            else:
-                                logger.warning(
-                                    f"--depth/--shallow ignored for pull on non-shallow repo {repo_path}. "
-                                    "Re-clone with --shallow to create a shallow copy."
-                                )
+                        if fast_forward_only and branch:
+                            self._checkout_pull_branch(repo_path, branch)
                         subprocess.run(
-                            pull_command,
+                            self._build_pull_command(
+                                repo_path, branch, clone_depth, fast_forward_only),
                             capture_output=True,
                             text=True,
                             check=True)
+                    except RuntimeError as e:
+                        return {
+                            "return": 1,
+                            "error": self._format_pull_error(
+                                repo_path,
+                                str(e),
+                                stash_created=stash_created,
+                                force=True,
+                                failure_phase="branch checkout")
+                        }
                     except subprocess.CalledProcessError as e:
-                        pull_error = (e.stderr or e.stdout or str(e)).strip()
-                        if stash_created:
-                            return {
-                                "return": 1,
-                                "error": f"Force pull failed during git pull for {repo_path}. Local changes remain in stash. Please run `git -C {repo_path} stash apply` after resolving pull issues. Details: {pull_error}"
-                            }
+                        pull_error = self._subprocess_error_message(e)
                         return {
                             "return": 1,
-                            "error": f"Force pull failed during git pull for {repo_path}: {pull_error}"
+                            "error": self._format_pull_error(
+                                repo_path,
+                                pull_error,
+                                stash_created=stash_created,
+                                force=True)
                         }
                     logger.info("Repository successfully pulled.")
 
@@ -536,16 +706,28 @@ class RepoAction(Action):
                 else:
                     logger.info(
                         "No local changes detected. Pulling latest changes...")
-                    pull_command = ['git', '-C', repo_path, 'pull']
-                    if clone_depth is not None:
-                        if self._is_shallow_repo(repo_path):
-                            pull_command += ['--depth', str(clone_depth)]
-                        else:
-                            logger.warning(
-                                f"--depth/--shallow ignored for pull on non-shallow repo {repo_path}. "
-                                "Re-clone with --shallow to create a shallow copy."
-                            )
-                    subprocess.run(pull_command, check=True)
+                    try:
+                        if fast_forward_only and branch:
+                            self._checkout_pull_branch(repo_path, branch)
+                        subprocess.run(
+                            self._build_pull_command(
+                                repo_path, branch, clone_depth, fast_forward_only),
+                            capture_output=True,
+                            text=True,
+                            check=True)
+                    except RuntimeError as e:
+                        return {
+                            "return": 1,
+                            "error": self._format_pull_error(
+                                repo_path, str(e), failure_phase="branch checkout")
+                        }
+                    except subprocess.CalledProcessError as e:
+                        pull_error = self._subprocess_error_message(e)
+                        return {
+                            "return": 1,
+                            "error": self._format_pull_error(
+                                repo_path, pull_error)
+                        }
                     logger.info("Repository successfully pulled.")
 
             if tag:
@@ -585,6 +767,8 @@ class RepoAction(Action):
 
             return {"return": 0}
 
+        except RuntimeError as e:
+            return {'return': 1, 'error': str(e)}
         except subprocess.CalledProcessError as e:
             return {'return': 1, 'error': f"Git command failed: {e}"}
         except Exception as e:
@@ -610,7 +794,7 @@ class RepoAction(Action):
 
 
     - `--checkout <commit_sha>`: Checks out a specific commit after cloning (applicable when the repository exists locally).
-    - `--branch <branch_name>`: Checks out a specific branch **while cloning** a new repository.
+    - `--branch <branch_name>`: Checks out a specific branch while cloning a new repository. When strict fast-forward-only pulls are requested for an existing checkout, it also selects the local branch to switch to before pulling `origin/<branch>`.
     - `--tag <release_tag>`: Checks out a particular release tag.
     - `--pat <access_token>` or `--ssh`: Clones a private repository using a personal access token or SSH.
     - `--force`: For existing repositories with local tracked changes, stashes changes before pull and reapplies them after pull.
@@ -651,7 +835,8 @@ class RepoAction(Action):
                             'force'),
                         shallow=run_args.get('shallow', False),
                         depth=run_args.get('depth'),
-                        extra_git_args=run_args.get('extra_git_args'))
+                        extra_git_args=run_args.get('extra_git_args'),
+                        fast_forward_only=run_args.get('fast_forward_only', False))
                     if res['return'] > 0:
                         return res
         else:
@@ -666,6 +851,7 @@ class RepoAction(Action):
             shallow = run_args.get('shallow', False)
             depth = run_args.get('depth')
             extra_git_args = run_args.get('extra_git_args')
+            fast_forward_only = run_args.get('fast_forward_only', False)
 
             if sum(bool(var) for var in [branch, checkout, tag]) > 1:
                 return {
@@ -682,7 +868,8 @@ class RepoAction(Action):
                 force=force,
                 shallow=shallow,
                 depth=depth,
-                extra_git_args=extra_git_args)
+                extra_git_args=extra_git_args,
+                fast_forward_only=fast_forward_only)
             if res['return'] > 0:
                 return res
 

{mlcflow-1.2.6 → mlcflow-1.2.8}/mlc/script_action.py

@@ -244,7 +244,8 @@ Main Script Meta:""")
                 "automation": "repo",
                 "action": "pull",
                 "repo": "mlcommons@mlperf-automations",
-                "branch": "dev"
+                "branch": "dev",
+                "fast_forward_only": True
             })
 
             if result['return'] == 0:

{mlcflow-1.2.6 → mlcflow-1.2.8}/mlcflow.egg-info/PKG-INFO

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

{mlcflow-1.2.6 → mlcflow-1.2.8}/mlcflow.egg-info/SOURCES.txt

@@ -27,4 +27,6 @@ mlcflow.egg-info/top_level.txt
 tests/test_action_invalid_meta_entries.py
 tests/test_cache_mark_tmp.py
 tests/test_mlcflow_unix_installer.py
-tests/test_script_action_apptainer.py
+tests/test_repo_action_extra_git_args.py
+tests/test_script_action_apptainer.py
+tests/test_unix_installer_venv.py

{mlcflow-1.2.6 → mlcflow-1.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mlcflow"
-version = "1.2.6"
+version = "1.2.8"
 
 description = "An automation interface tailored for CPU/GPU benchmarking"
 authors = [

mlcflow-1.2.8/tests/test_mlcflow_unix_installer.py

@@ -0,0 +1,137 @@
+import platform
+import subprocess
+import sys
+import tempfile
+import textwrap
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+INSTALLER_SCRIPT = REPO_ROOT / "docs" / "install" / "mlcflow_unix_installer.sh"
+
+
+def _resolve_venv_dir(tmp_path, setup_snippet):
+    default_dir = tmp_path / "mlcflow"
+    marker = "__RESULT__"
+    command = textwrap.dedent(
+        f"""
+        set -euo pipefail
+        source "{INSTALLER_SCRIPT}"
+        DEFAULT_VENV_DIR="{default_dir}"
+        VENV_DIR="$DEFAULT_VENV_DIR"
+        PY_MAJOR_MINOR="$(python3 -c 'import sys; print("{{}}.{{}}".format(*sys.version_info[:2]))')"
+        PY_ARCH="$(python3 -c 'import platform; print(platform.machine())')"
+        {setup_snippet}
+        resolve_default_venv_dir
+        echo "{marker}$VENV_DIR"
+        """
+    )
+    result = subprocess.run(
+        ["bash", "-lc", command],
+        text=True,
+        capture_output=True,
+        check=True,
+    )
+
+    for line in reversed(result.stdout.splitlines()):
+        if line.startswith(marker):
+            return line[len(marker):]
+
+    raise AssertionError(
+        f"Could not parse resolved venv path from output:\n{result.stdout}"
+    )
+
+
+def test_resolve_default_venv_dir_prefers_compatible_default(tmp_path):
+    setup_snippet = """
+    python3 -m venv "$DEFAULT_VENV_DIR"
+    """
+    resolved = _resolve_venv_dir(tmp_path, setup_snippet)
+    assert resolved == str(tmp_path / "mlcflow")
+
+
+def test_resolve_default_venv_dir_uses_suffix_for_incompatible_default(
+        tmp_path):
+    setup_snippet = """
+    mkdir -p "$DEFAULT_VENV_DIR"
+    """
+    resolved = _resolve_venv_dir(tmp_path, setup_snippet)
+    assert resolved.startswith(str(tmp_path / "mlcflow_"))
+    assert "_py" in resolved
+
+
+def test_resolve_default_venv_dir_removes_stale_shared_env_when_default_incompatible(
+    tmp_path,
+):
+    """Broken suffixed envs should be removed so setup_venv recreates them."""
+    setup_snippet = """
+    mkdir -p "$DEFAULT_VENV_DIR"
+    SHARED_VENV_DIR="${DEFAULT_VENV_DIR}_${PY_ARCH}_py${PY_MAJOR_MINOR}"
+    mkdir -p "$SHARED_VENV_DIR"
+    """
+    resolved = _resolve_venv_dir(tmp_path, setup_snippet)
+    expected_suffix = (
+        f"{tmp_path / 'mlcflow'}_{platform.machine()}"
+        f"_py{sys.version_info[0]}.{sys.version_info[1]}"
+    )
+    assert resolved == expected_suffix
+    assert not Path(expected_suffix).exists()
+
+
+def test_resolve_default_venv_dir_reuses_compatible_suffixed_env(tmp_path):
+    setup_snippet = """
+    SHARED_VENV_DIR="${DEFAULT_VENV_DIR}_${PY_ARCH}_py${PY_MAJOR_MINOR}"
+    python3 -m venv "$SHARED_VENV_DIR"
+    """
+    resolved = _resolve_venv_dir(tmp_path, setup_snippet)
+    expected = (
+        f"{tmp_path / 'mlcflow'}_{platform.machine()}"
+        f"_py{sys.version_info[0]}.{sys.version_info[1]}"
+    )
+    assert resolved == expected
+
+
+def test_get_venv_suffix_and_compatibility_signature_use_consistent_python_values():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        shim_path = Path(temp_dir) / "python-shim"
+        shim_path.write_text(
+            textwrap.dedent(
+                """\
+                #!/usr/bin/env python3
+                import os
+                import platform
+                import sys
+
+                machine = os.environ["FAKE_MACHINE"]
+                major = int(os.environ.get("FAKE_PY_MAJOR", "3"))
+                minor = int(os.environ.get("FAKE_PY_MINOR", "12"))
+                code = sys.argv[2]
+
+                platform.machine = lambda: machine
+                sys.version_info = (major, minor, 0, "final", 0)
+                exec(code, {"__name__": "__main__"})
+                """
+            ),
+            encoding="utf-8",
+        )
+        shim_path.chmod(0o755)
+
+        command = textwrap.dedent(
+            f"""
+            set -euo pipefail
+            source "{INSTALLER_SCRIPT}"
+            PYTHON_CMD="{shim_path}"
+            export FAKE_MACHINE=arm64
+            export FAKE_PY_MAJOR=3
+            export FAKE_PY_MINOR=12
+            printf '__RESULT__:%s:%s\\n' "$(get_venv_suffix)" "$(get_python_compatibility_signature "$PYTHON_CMD")"
+            """
+        )
+        result = subprocess.run(
+            ["bash", "-lc", command],
+            text=True,
+            capture_output=True,
+            check=True,
+        )
+
+    assert "__RESULT__:_arm64_py3.12:arm64|3.12" in result.stdout

mlcflow-1.2.8/tests/test_repo_action_extra_git_args.py

@@ -0,0 +1,20 @@
+from mlc.repo_action import RepoAction
+
+
+def test_validate_extra_git_args_allows_literal_shell_characters():
+    assert RepoAction._validate_extra_git_args(
+        [
+            "refs/pull/$PR/head",
+            "http.extraHeader=Authorization: ******",
+            "name-with|pipe",
+            "`literal-backticks`",
+        ]
+    ) is None
+
+
+def test_validate_extra_git_args_rejects_line_breaks():
+    error = RepoAction._validate_extra_git_args(["line1\nline2"])
+
+    assert error == (
+        "--extra_git_args may not include carriage returns or newlines."
+    )

mlcflow-1.2.8/tests/test_script_action_apptainer.py

@@ -0,0 +1,54 @@
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from mlc.script_action import ScriptAction
+
+
+class _Parent:
+    def __init__(self, repos_path=None):
+        self.repos_path = repos_path
+
+
+class ScriptActionApptainerTest(unittest.TestCase):
+    def test_apptainer_delegates_to_script_module(self):
+        action = ScriptAction(_Parent(tempfile.gettempdir()))
+        run_args = {"tags": "detect,os"}
+        expected = {"return": 0}
+
+        with patch.object(
+                ScriptAction,
+                "call_script_module_function",
+                return_value=expected) as call_script_module_function:
+            result = action.apptainer(run_args)
+
+        self.assertEqual(result, expected)
+        call_script_module_function.assert_called_once_with(
+            "apptainer", run_args)
+
+    def test_auto_pull_uses_fast_forward_only_for_mlperf_automations(self):
+        with tempfile.TemporaryDirectory() as repos_path:
+            action = ScriptAction(_Parent(repos_path))
+
+            with patch.object(
+                    ScriptAction,
+                    "find_target_folder",
+                    return_value=None), \
+                    patch.object(
+                        ScriptAction,
+                        "access",
+                        return_value={"return": 1, "error": "pull failed"}) as access:
+                result = action.call_script_module_function("run", {})
+
+            self.assertEqual(result["return"], 1)
+            access.assert_called_once_with({
+                "automation": "repo",
+                "action": "pull",
+                "repo": "mlcommons@mlperf-automations",
+                "branch": "dev",
+                "fast_forward_only": True
+            })
+
+
+if __name__ == "__main__":
+    unittest.main()

mlcflow-1.2.8/tests/test_unix_installer_venv.py

@@ -0,0 +1,224 @@
+import os
+import platform
+import shlex
+import subprocess
+import sys
+import tempfile
+import textwrap
+import unittest
+
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+INSTALLER_PATH = os.path.join(
+    REPO_ROOT,
+    "docs",
+    "install",
+    "mlcflow_unix_installer.sh")
+# Keep this in sync with docs/install/mlcflow_unix_installer.sh:
+# get_venv_suffix() and get_python_compatibility_signature().
+COMPATIBILITY_SIGNATURE_CODE = (
+    'import platform, sys; '
+    'print("{}|{}.{}".format(platform.machine(), sys.version_info[0], sys.version_info[1]))'
+)
+
+
+class UnixInstallerVenvTest(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp_dir.cleanup)
+
+    def _expected_suffix(self):
+        return (
+            f"_{platform.machine()}"
+            f"_py{sys.version_info[0]}.{sys.version_info[1]}"
+        )
+
+    def _run_setup_venv(self, venv_dir):
+        command = """
+set -euo pipefail
+source {installer}
+VENV_DIR={venv_dir}
+setup_venv
+printf '__RESULT__:%s:%s\\n' "$VENV_DIR" "${{VIRTUAL_ENV:-}}"
+""".format(
+            installer=shlex.quote(INSTALLER_PATH),
+            venv_dir=shlex.quote(venv_dir),
+        )
+
+        completed = subprocess.run(
+            ["bash", "-lc", command],
+            cwd=self.temp_dir.name,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        self.assertEqual(completed.returncode, 0, msg=completed.stderr)
+
+        result_lines = [
+            line for line in completed.stdout.splitlines()
+            if line.startswith("__RESULT__:")
+        ]
+        self.assertTrue(result_lines, msg=completed.stdout)
+        _, resolved_path, activated_path = result_lines[-1].split(":", 2)
+        return resolved_path, activated_path, completed.stdout
+
+    def _compatibility_signature(self, python_executable):
+        completed = subprocess.run(
+            [
+                python_executable,
+                "-c",
+                COMPATIBILITY_SIGNATURE_CODE,
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return completed.stdout.strip()
+
+    def _write_installer_with_stubbed_main_dependencies(self):
+        integration_installer_path = os.path.join(
+            self.temp_dir.name, "mlcflow_unix_installer_integration_test.sh"
+        )
+        stubbed_functions = textwrap.dedent("""
+            detect_os() {
+                OS_ID="ubuntu"
+                OS_VERSION="test"
+                PKG_MANAGER="apt"
+            }
+
+            check_missing_dependencies() {
+                MISSING_DEPS=()
+            }
+
+            ensure_python() {
+                :
+            }
+
+            install_mlcflow() {
+                :
+            }
+
+            prompt_repo_details() {
+                :
+            }
+
+            pull_repo() {
+                :
+            }
+            """).strip()
+        with open(INSTALLER_PATH, "r", encoding="utf-8") as installer_file:
+            installer_contents = installer_file.read().rstrip()
+        main_guard = textwrap.dedent(
+            """
+            if [[ "${BASH_SOURCE[0]:-$0}" == "$0" ]]; then
+                main
+            fi
+            """
+        ).strip()
+        replacement = (
+            stubbed_functions
+            + "\n\n"
+            + main_guard
+        )
+        self.assertIn(main_guard, installer_contents)
+        modified_contents = installer_contents.replace(main_guard, replacement)
+        self.assertIn(replacement, modified_contents)
+        with open(integration_installer_path, "w", encoding="utf-8") as installer_file:
+            installer_file.write(modified_contents)
+        return integration_installer_path
+
+    def test_installer_main_runs_setup_venv_with_stubbed_dependencies(self):
+        venv_dir = os.path.join(self.temp_dir.name, "mlcflow")
+        os.makedirs(venv_dir, exist_ok=True)
+        expected_path = venv_dir + self._expected_suffix()
+        installer_path = self._write_installer_with_stubbed_main_dependencies()
+
+        completed = subprocess.run(
+            ["bash", installer_path, "--yes", "--venv-dir", venv_dir],
+            cwd=self.temp_dir.name,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        self.assertEqual(completed.returncode, 0, msg=completed.stderr)
+        self.assertIn("Installation completed successfully.", completed.stdout)
+        self.assertIn(expected_path, completed.stdout)
+        self.assertTrue(
+            os.path.exists(
+                os.path.join(
+                    expected_path,
+                    "bin",
+                    "python")))
+        self.assertEqual(
+            self._compatibility_signature(
+                os.path.join(expected_path, "bin", "python")),
+            self._compatibility_signature(sys.executable),
+        )
+
+    def test_setup_venv_creates_requested_path_from_scratch(self):
+        venv_dir = os.path.join(self.temp_dir.name, "mlcflow")
+
+        resolved_path, activated_path, stdout = self._run_setup_venv(venv_dir)
+
+        self.assertEqual(resolved_path, venv_dir)
+        self.assertEqual(activated_path, venv_dir)
+        self.assertIn("Setting up virtual environment at", stdout)
+        self.assertTrue(
+            os.path.exists(
+                os.path.join(
+                    venv_dir,
+                    "bin",
+                    "python")))
+        self.assertEqual(
+            self._compatibility_signature(
+                os.path.join(venv_dir, "bin", "python")),
+            self._compatibility_signature(sys.executable),
+        )
+
+    def test_setup_venv_reuses_compatible_existing_venv(self):
+        venv_dir = os.path.join(self.temp_dir.name, "mlcflow")
+        subprocess.run(
+            [sys.executable, "-m", "venv", venv_dir],
+            check=True,
+            cwd=self.temp_dir.name,
+        )
+
+        resolved_path, activated_path, stdout = self._run_setup_venv(venv_dir)
+
+        self.assertEqual(resolved_path, venv_dir)
+        self.assertEqual(activated_path, venv_dir)
+        self.assertIn("Reusing existing virtual environment.", stdout)
+        self.assertEqual(
+            self._compatibility_signature(
+                os.path.join(venv_dir, "bin", "python")),
+            self._compatibility_signature(sys.executable),
+        )
+
+    def test_setup_venv_uses_arch_and_python_suffix_for_incompatible_dir(self):
+        venv_dir = os.path.join(self.temp_dir.name, "mlcflow")
+        os.makedirs(venv_dir, exist_ok=True)
+        expected_path = venv_dir + self._expected_suffix()
+
+        resolved_path, activated_path, stdout = self._run_setup_venv(venv_dir)
+
+        self.assertEqual(resolved_path, expected_path)
+        self.assertEqual(activated_path, expected_path)
+        self.assertIn(
+            "is incompatible with current Python/platform. Using",
+            stdout)
+        self.assertTrue(
+            os.path.exists(
+                os.path.join(
+                    expected_path,
+                    "bin",
+                    "python")))
+        self.assertEqual(
+            self._compatibility_signature(
+                os.path.join(expected_path, "bin", "python")),
+            self._compatibility_signature(sys.executable),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

mlcflow-1.2.6/tests/test_mlcflow_unix_installer.py

@@ -1,83 +0,0 @@
-import subprocess
-import platform
-import sys
-from pathlib import Path
-
-
-REPO_ROOT = Path(__file__).resolve().parents[1]
-INSTALLER_SCRIPT = REPO_ROOT / "docs" / "install" / "mlcflow_unix_installer.sh"
-
-
-def _resolve_venv_dir(tmp_path, setup_snippet):
-    default_dir = tmp_path / "mlcflow"
-    marker = "__RESULT__"
-    command = f"""
-set -euo pipefail
-source "{INSTALLER_SCRIPT}"
-DEFAULT_VENV_DIR="{default_dir}"
-VENV_DIR="$DEFAULT_VENV_DIR"
-PY_MAJOR_MINOR="$(python3 -c 'import sys; print("{{}}.{{}}".format(*sys.version_info[:2]))')"
-PY_ARCH="$(python3 -c 'import platform; print(platform.machine())')"
-{setup_snippet}
-resolve_default_venv_dir
-echo "{marker}$VENV_DIR"
-"""
-    result = subprocess.run(
-        ["bash", "-lc", command],
-        text=True,
-        capture_output=True,
-        check=True,
-    )
-
-    for line in reversed(result.stdout.splitlines()):
-        if line.startswith(marker):
-            return line[len(marker):]
-
-    raise AssertionError(
-        f"Could not parse resolved venv path from output:\n{result.stdout}")
-
-
-def test_resolve_default_venv_dir_prefers_compatible_default(tmp_path):
-    setup_snippet = """
-python3 -m venv "$DEFAULT_VENV_DIR"
-"""
-    resolved = _resolve_venv_dir(tmp_path, setup_snippet)
-    assert resolved == str(tmp_path / "mlcflow")
-
-
-def test_resolve_default_venv_dir_uses_suffix_for_incompatible_default(
-        tmp_path):
-    setup_snippet = """
-mkdir -p "$DEFAULT_VENV_DIR"
-"""
-    resolved = _resolve_venv_dir(tmp_path, setup_snippet)
-    assert resolved.startswith(str(tmp_path / "mlcflow_"))
-    assert "_py" in resolved
-
-
-def test_resolve_default_venv_dir_removes_stale_shared_env_when_default_incompatible(
-        tmp_path):
-    """When the default venv is incompatible and the suffixed venv already exists
-    but is itself stale/broken, the stale suffixed dir must be removed so that
-    setup_venv can create a fresh one rather than silently reusing a broken env."""
-    setup_snippet = """
-mkdir -p "$DEFAULT_VENV_DIR"
-SHARED_VENV_DIR="${DEFAULT_VENV_DIR}_${PY_ARCH}_py${PY_MAJOR_MINOR}"
-mkdir -p "$SHARED_VENV_DIR"
-"""
-    resolved = _resolve_venv_dir(tmp_path, setup_snippet)
-    expected_suffix = f"{tmp_path / 'mlcflow'}_{platform.machine()}_py{sys.version_info[0]}.{sys.version_info[1]}"
-    assert resolved == expected_suffix
-    # The stale shared dir should have been removed so setup_venv creates it
-    # fresh
-    assert not Path(expected_suffix).exists()
-
-
-def test_resolve_default_venv_dir_reuses_compatible_suffixed_env(tmp_path):
-    setup_snippet = """
-SHARED_VENV_DIR="${DEFAULT_VENV_DIR}_${PY_ARCH}_py${PY_MAJOR_MINOR}"
-python3 -m venv "$SHARED_VENV_DIR"
-"""
-    resolved = _resolve_venv_dir(tmp_path, setup_snippet)
-    expected = f"{tmp_path / 'mlcflow'}_{platform.machine()}_py{sys.version_info[0]}.{sys.version_info[1]}"
-    assert resolved == expected

mlcflow-1.2.6/tests/test_script_action_apptainer.py

@@ -1,29 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-from mlc.script_action import ScriptAction
-
-
-class _Parent:
-    pass
-
-
-class ScriptActionApptainerTest(unittest.TestCase):
-    def test_apptainer_delegates_to_script_module(self):
-        action = ScriptAction(_Parent())
-        run_args = {"tags": "detect,os"}
-        expected = {"return": 0}
-
-        with patch.object(
-                ScriptAction,
-                "call_script_module_function",
-                return_value=expected) as call_script_module_function:
-            result = action.apptainer(run_args)
-
-        self.assertEqual(result, expected)
-        call_script_module_function.assert_called_once_with(
-            "apptainer", run_args)
-
-
-if __name__ == "__main__":
-    unittest.main()