mlcflow 1.2.7__tar.gz → 1.2.9__tar.gz

{mlcflow-1.2.7 → mlcflow-1.2.9}/PKG-INFO

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

{mlcflow-1.2.7 → mlcflow-1.2.9}/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', not 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.7 → mlcflow-1.2.9}/mlc/repo_action.py

@@ -40,6 +40,8 @@ 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"
 
@@ -183,9 +185,19 @@ class RepoAction(Action):
 
     @staticmethod
     def _subprocess_error_message(error):
-        """Return the most helpful message from a subprocess-related 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):
         """
     ####################################################################################################################
@@ -521,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."}
@@ -532,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):

{mlcflow-1.2.7 → mlcflow-1.2.9}/mlcflow.egg-info/PKG-INFO

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

{mlcflow-1.2.7 → mlcflow-1.2.9}/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.7 → mlcflow-1.2.9}/pyproject.toml

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

mlcflow-1.2.9/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.9/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.9/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.7/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