nextmv 1.7.1__tar.gz → 1.7.2.dev0__tar.gz

{nextmv-1.7.1 → nextmv-1.7.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 1.7.1
+Version: 1.7.2.dev0
 Summary: The all-purpose Python SDK for Nextmv
 Project-URL: Homepage, https://www.nextmv.io
 Project-URL: Documentation, https://nextmv-py.docs.nextmv.io/en/latest/nextmv/

nextmv-1.7.2.dev0/nextmv/__about__.py

@@ -0,0 +1 @@
+__version__ = "v1.7.2.dev0"

{nextmv-1.7.1 → nextmv-1.7.2.dev0}/nextmv/cli/main.py

@@ -13,7 +13,9 @@ about the features used here. An example of Rich markup can be found in the
 epilog of the Typer application defined below.
 """
 
+import io
 import os
+import runpy
 import sys
 from typing import Annotated
 
@@ -32,6 +34,7 @@ from nextmv.cli.message import confirmation, error, info, success, warning
 from nextmv.cli.version import app as version_app
 from nextmv.cli.version import version_callback
 from nextmv.cloud.client import retrieve_endpoint_from_config, retrieve_key_from_config
+from nextmv.local.uv_handler import _find_uv_binary
 
 # Disable dim text for the extended help of commands.
 rich_utils.STYLE_HELPTEXT = ""
@@ -261,6 +264,38 @@ def _remove_go_cli() -> None:
         success(f"Deleted [italic red]deprecated[/italic red] [magenta]{GO_CLI_PATH}[/magenta].")
 
 
+def setup_encoding() -> None:
+    """
+    Configure UTF-8 encoding for Windows platforms to make sure emojis and rich text do
+    not cause encoding errors.
+    """
+    # Only force UTF-8 encoding on Windows where the default encoding is not already UTF-8
+    # and where sys.stdout has a buffer attribute (indicating it's a real stream and not a
+    # mock).
+    if (
+        sys.platform == "win32"
+        and getattr(sys.stdout, "encoding", "").lower() != "utf-8"
+        and hasattr(sys.stdout, "buffer")
+    ):
+        try:
+            sys.stdout = io.TextIOWrapper(
+                sys.stdout.buffer,
+                encoding="utf-8",
+                errors="replace",  # Don't crash on bad chars
+                line_buffering=True,
+            )
+            sys.stderr = io.TextIOWrapper(
+                sys.stderr.buffer,
+                encoding="utf-8",
+                errors="replace",
+                line_buffering=True,
+            )
+        except Exception:
+            # If wrapping fails (e.g. in some CI environments),
+            # fall back to the original stream rather than crashing.
+            pass
+
+
 def main() -> None:
     """
     Entry point for the CLI with global exception handling.
@@ -269,6 +304,28 @@ def main() -> None:
     own exit codes) and displays a clean error message instead of a traceback.
     """
 
+    # Improve compatibility with Windows terminals.
+    setup_encoding()
+
+    # Handle --run-script and --run-uv for running scripts with the bundled Python
+    # interpreter or via uv. These are used internally in case of frozen PyInstaller
+    # distributions.
+    if len(sys.argv) > 1 and sys.argv[1] == "--run-script":
+        if len(sys.argv) < 3:
+            rich.print("[red]Error:[/red] --run-script requires a script path.", file=sys.stderr)
+            sys.exit(1)
+        script_path = sys.argv[2]
+        sys.argv = sys.argv[2:]  # script becomes argv[0]; its own args follow
+        runpy.run_path(script_path, run_name="__main__")
+        sys.exit(0)
+    elif len(sys.argv) > 1 and sys.argv[1] == "--run-uv":
+        if len(sys.argv) < 3:
+            rich.print("[red]Error:[/red] --run-uv requires arguments for 'uv run'.", file=sys.stderr)
+            sys.exit(1)
+        uv_bin = _find_uv_binary()
+        uv_args = [uv_bin, "run"] + sys.argv[2:]
+        os.execv(uv_bin, uv_args)
+
     try:
         app()
     except (typer.Exit, typer.Abort, SystemExit):

{nextmv-1.7.1 → nextmv-1.7.2.dev0}/nextmv/local/executor.py

@@ -418,11 +418,6 @@ def process_run_output(
     temp_run_outputs_dir = os.path.join(temp_src, OUTPUTS_KEY)
 
     output_format = manifest.configuration.content.format
-    _process_run_information(
-        run_id=run_id,
-        run_dir=run_dir,
-        result=result,
-    )
     _process_run_metrics(
         temp_run_outputs_dir=temp_run_outputs_dir,
         outputs_dir=outputs_dir,
@@ -459,6 +454,16 @@ def process_run_output(
         run_dir=run_dir,
         outputs_dir=outputs_dir,
     )
+    # NOTE: _process_run_information must be called last. It sets status_v2 to "succeeded"
+    # or "failed", which signals to pollers that the run is complete. format.output
+    # (written by _process_run_solutions) must already be on disk before that status
+    # transition is visible, otherwise a poller can observe status=succeeded with
+    # format_output=None and crash.
+    _process_run_information(
+        run_id=run_id,
+        run_dir=run_dir,
+        result=result,
+    )
 
 
 def _process_run_information(run_id: str, run_dir: str, result: subprocess.CompletedProcess[str]) -> None:
@@ -1073,6 +1078,12 @@ def __determine_command(manifest: Manifest) -> list[str]:
     """
     Returns the command to execute based on the application type.
 
+    When running Python apps as a frozen PyInstaller single binary, ``sys.executable``
+    points to the binary itself rather than a Python interpreter, so the normal
+    ``[sys.executable, "-m", "uv", "run", ...]`` invocation cannot work. Instead, we use a
+    special ``[sys.executable, "--run-uv", ...]`` invocation that signals to our own
+    binary to re-execute and pass to the bundled uv binary.
+
     Parameters
     ----------
     manifest : Manifest
@@ -1084,26 +1095,23 @@ def __determine_command(manifest: Manifest) -> list[str]:
         The command prefix to use for execution. Empty list for binary executables.
     """
     if manifest.type == ManifestType.PYTHON:
+        is_frozen = getattr(sys, "frozen", False)
+        entry_point = [sys.executable, "-m", "uv", "run"] if not is_frozen else [sys.executable, "--run-uv"]
+
         if manifest.python and manifest.python.pip_requirements:
             if isinstance(manifest.python.pip_requirements, list):
                 return [
-                    sys.executable,
-                    "-m",
-                    "uv",
-                    "run",
+                    *entry_point,
                     "--with",
                     ",".join(manifest.python.pip_requirements),
                 ]
             elif isinstance(manifest.python.pip_requirements, str):
                 return [
-                    sys.executable,
-                    "-m",
-                    "uv",
-                    "run",
+                    *entry_point,
                     "--with-requirements",
                     manifest.python.pip_requirements,
                 ]
-        return [sys.executable, "-m", "uv", "run"]
+        return [*entry_point]
     elif manifest.type == ManifestType.GO:
         return []
     elif manifest.type == ManifestType.BINARY:

{nextmv-1.7.1 → nextmv-1.7.2.dev0}/nextmv/local/runner.py

@@ -122,7 +122,18 @@ def run(
             "options": options,
         }
     )
-    args = [sys.executable, "executor.py"]
+    # When frozen as a single binary (PyInstaller), sys.executable points to
+    # the binary itself rather than a Python interpreter, so we use the
+    # --run-script mechanism to run executor.py with the bundled interpreter.
+    # In a normal Python package install, sys.executable is a real interpreter
+    # and executor.py can be launched directly.
+    # We always use the absolute path to executor.py so it can be resolved
+    # regardless of the working directory the binary was invoked from.
+    executor_path = os.path.join(os.path.dirname(__file__), "executor.py")
+    if getattr(sys, "frozen", False):
+        args = [sys.executable, "--run-script", executor_path]
+    else:
+        args = [sys.executable, executor_path]
     process = subprocess.Popen(
         args,
         env=os.environ,
@@ -130,8 +141,8 @@ def run(
         stdin=subprocess.PIPE,
         stdout=subprocess.DEVNULL,
         stderr=subprocess.DEVNULL,
-        cwd=os.path.dirname(__file__),
-        start_new_session=True,  # Detach from parent process
+        cwd=os.path.dirname(executor_path),
+        start_new_session=True,
     )
     process.stdin.write(stdin_input)
     process.stdin.close()

nextmv-1.7.2.dev0/nextmv/local/uv_handler.py

@@ -0,0 +1,58 @@
+import os
+import platform
+import sys
+
+
+def _find_uv_binary() -> str:
+    """
+    Locate the uv binary at runtime.
+
+    Resolves the binary in this order:
+    1. If running in a PyInstaller bundle, the uv binary is expected to be bundled under
+       `sys._MEIPASS/uv_bin/`.
+    2. Otherwise, check whether uv module is installed and use its helper function to find
+        the binary.
+    3. Finally, check if uv is available on the system PATH.
+
+    Returns
+    -------
+    str
+        Absolute path to the uv binary.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the uv binary cannot be located.
+    """
+
+    # 1. Check for PyInstaller bundled uv binary.
+    if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
+        # In case of single binary PyInstaller distribution, the uv binary is bundled
+        # under sys._MEIPASS/uv_bin/.
+        exe_suffix = ".exe" if platform.system() == "Windows" else ""
+        uv_path = os.path.join(sys._MEIPASS, "uv_bin", f"uv{exe_suffix}")
+        if not os.path.isfile(uv_path):
+            raise FileNotFoundError(
+                f"Bundled uv binary not found at {uv_path}, please ensure proper installation of the Nextmv CLI."
+            )
+        return uv_path
+
+    # 2. Fall back to finding uv via the installed module (if available).
+    try:
+        from uv import find_uv_bin  # type: ignore[import]
+
+        return find_uv_bin()
+    except (ImportError, AttributeError):
+        pass
+
+    # 3. Finally, check if uv is available on the system PATH.
+    from shutil import which
+
+    uv_path = which("uv")
+    if uv_path:
+        return uv_path
+
+    raise FileNotFoundError(
+        "uv binary not found. Please ensure that uv is installed and available "
+        + "on your system (via PATH or as module in Python)."
+    )

{nextmv-1.7.1 → nextmv-1.7.2.dev0}/pyproject.toml

@@ -55,7 +55,6 @@ Homepage = "https://www.nextmv.io"
 Documentation = "https://nextmv-py.docs.nextmv.io/en/latest/nextmv/"
 Repository = "https://github.com/nextmv-io/nextmv-py"
 
-# TODO: Uncomment when CLI is ready for general rollout.
 [project.scripts]
 nextmv = "nextmv.cli.main:main"
 

nextmv-1.7.2.dev0/tests/cli/test_main.py

@@ -0,0 +1,176 @@
+"""
+Unit tests for the nextmv CLI main module.
+"""
+
+import os
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from nextmv.cli.main import app, main
+from typer.testing import CliRunner
+
+
+class TestCallback(unittest.TestCase):
+    """Tests for the CLI callback behavior."""
+
+    def setUp(self):
+        self.runner = CliRunner()
+        self.app = app
+
+    @patch("nextmv.cli.main._go_cli_exists")
+    @patch("nextmv.cli.main.load_config")
+    def test_callback_skips_config_check_for_configure(self, mock_load_config, mock_go_cli_exists):
+        """Test that the callback skips config check when running configuration."""
+        mock_load_config.return_value = {}
+        mock_go_cli_exists.return_value = False
+
+        # Running configuration should not trigger the error even with empty config
+        result = self.runner.invoke(self.app, ["configuration", "--help"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Configure the CLI", result.output)
+
+    @patch("nextmv.cli.main._go_cli_exists")
+    @patch("nextmv.cli.main.load_config")
+    def test_callback_shows_error_when_no_config(self, mock_load_config, mock_go_cli_exists):
+        """Test that the callback shows error when no config exists for other commands."""
+        mock_load_config.return_value = {}
+        mock_go_cli_exists.return_value = False
+
+        result = self.runner.invoke(self.app, ["version"])
+        self.assertEqual(result.exit_code, 0)
+
+    @patch("nextmv.cli.main._go_cli_exists")
+    @patch("nextmv.cli.main.load_config")
+    def test_callback_allows_command_when_config_exists(self, mock_load_config, mock_go_cli_exists):
+        """Test that the callback allows commands when config exists."""
+        mock_load_config.return_value = {"api_key": "test_key"}
+        mock_go_cli_exists.return_value = False
+
+        result = self.runner.invoke(self.app, ["version"])
+        self.assertEqual(result.exit_code, 0)
+
+
+class TestHandleGoCli(unittest.TestCase):
+    """Tests for the Go CLI handling behavior."""
+
+    def setUp(self):
+        self.runner = CliRunner()
+        self.app = app
+
+    @patch("nextmv.cli.main._go_cli_exists")
+    @patch("nextmv.cli.main.load_config")
+    def test_no_prompt_when_go_cli_not_exists(self, mock_load_config, mock_go_cli_exists):
+        """Test that no prompt is shown when Go CLI does not exist."""
+        mock_go_cli_exists.return_value = False
+        mock_load_config.return_value = {"api_key": "test_key"}
+
+        result = self.runner.invoke(self.app, ["version"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertNotIn("deprecated", result.output)
+
+
+class TestRunScript(unittest.TestCase):
+    """Tests for the --run-script hidden flag."""
+
+    def _write_script(self, content: str) -> str:
+        """Write content to a temporary script file and return its path."""
+        fd, path = tempfile.mkstemp(suffix=".py")
+        with os.fdopen(fd, "w") as f:
+            f.write(content)
+        return path
+
+    def test_run_script_executes_script(self):
+        """Test that --run-script runs the given script."""
+        script = self._write_script("import sys; sys.exit(42)\n")
+        try:
+            with patch.object(sys, "argv", ["nextmv", "--run-script", script]):
+                with self.assertRaises(SystemExit) as cm:
+                    main()
+            self.assertEqual(cm.exception.code, 42)
+        finally:
+            os.unlink(script)
+
+    def test_run_script_forwards_trailing_args(self):
+        """Test that trailing arguments are visible to the script as sys.argv."""
+        # The script writes its own argv to a temp file so we can inspect it.
+        fd, result_file = tempfile.mkstemp(suffix=".txt")
+        os.close(fd)
+        script = self._write_script(f"import sys\nopen({result_file!r}, 'w').write(','.join(sys.argv))\n")
+        try:
+            with patch.object(sys, "argv", ["nextmv", "--run-script", script, "arg1", "arg2"]):
+                with self.assertRaises(SystemExit) as cm:
+                    main()
+            self.assertEqual(cm.exception.code, 0)
+            with open(result_file) as f:
+                recorded = f.read().split(",")
+            # The script sees itself as argv[0] and its own trailing args after.
+            self.assertEqual(recorded[0], script)
+            self.assertEqual(recorded[1], "arg1")
+            self.assertEqual(recorded[2], "arg2")
+        finally:
+            os.unlink(script)
+            if os.path.exists(result_file):
+                os.unlink(result_file)
+
+    def test_run_script_missing_path_exits_with_error(self):
+        """Test that omitting the script path prints an error and exits 1."""
+        with patch.object(sys, "argv", ["nextmv", "--run-script"]):
+            with self.assertRaises(SystemExit) as cm:
+                main()
+        self.assertEqual(cm.exception.code, 1)
+
+
+class TestRunUv(unittest.TestCase):
+    """Tests for the --run-uv hidden flag."""
+
+    def test_run_uv_missing_args_exits_with_error(self):
+        """--run-uv with no further arguments prints an error and exits 1."""
+        with patch.object(sys, "argv", ["nextmv", "--run-uv"]):
+            with self.assertRaises(SystemExit) as cm:
+                main()
+        self.assertEqual(cm.exception.code, 1)
+
+    @patch("nextmv.cli.main._find_uv_binary")
+    @patch("os.execv")
+    def test_run_uv_calls_execv_with_correct_args(self, mock_execv, mock_find_uv):
+        """--run-uv resolves the uv binary and calls os.execv with 'uv run <args>'."""
+        mock_find_uv.return_value = "/usr/bin/uv"
+        # os.execv normally replaces the process and never returns; raise SystemExit
+        # so that main() stops at that point rather than falling through to app().
+        mock_execv.side_effect = SystemExit(0)
+
+        with patch.object(sys, "argv", ["nextmv", "--run-uv", "script.py", "--option", "val"]):
+            with self.assertRaises(SystemExit) as cm:
+                main()
+        self.assertEqual(cm.exception.code, 0)
+
+        mock_find_uv.assert_called_once()
+        mock_execv.assert_called_once_with(
+            "/usr/bin/uv",
+            ["/usr/bin/uv", "run", "script.py", "--option", "val"],
+        )
+
+    @patch("nextmv.cli.main._find_uv_binary")
+    @patch("os.execv")
+    def test_run_uv_single_extra_arg(self, mock_execv, mock_find_uv):
+        """--run-uv works with a single extra argument."""
+        mock_find_uv.return_value = "/opt/uv/uv"
+        mock_execv.side_effect = SystemExit(0)
+
+        with patch.object(sys, "argv", ["nextmv", "--run-uv", "app.py"]):
+            with self.assertRaises(SystemExit):
+                main()
+
+        mock_execv.assert_called_once_with(
+            "/opt/uv/uv",
+            ["/opt/uv/uv", "run", "app.py"],
+        )
+
+    @patch("nextmv.cli.main._find_uv_binary", side_effect=FileNotFoundError("uv not found"))
+    def test_run_uv_uv_binary_not_found_raises(self, mock_find_uv):
+        """--run-uv propagates FileNotFoundError when the uv binary cannot be located."""
+        with patch.object(sys, "argv", ["nextmv", "--run-uv", "script.py"]):
+            with self.assertRaises(FileNotFoundError):
+                main()

{nextmv-1.7.1 → nextmv-1.7.2.dev0}/tests/local/test_runner.py

@@ -10,10 +10,13 @@ import tempfile
 import unittest
 from unittest.mock import Mock, patch
 
+import nextmv.local.runner as runner_module
 from nextmv.local.local import NEXTMV_DIR, RUNS_KEY
 from nextmv.local.runner import new_run, record_input, run
 from nextmv.manifest import Manifest, ManifestRuntime
 
+EXECUTOR_PATH = os.path.join(os.path.dirname(runner_module.__file__), "executor.py")
+
 
 class TestLocalRunner(unittest.TestCase):
     """Test cases for the local runner module."""
@@ -268,8 +271,8 @@ print(json.dumps(output))
         mock_popen.assert_called_once()
         popen_args = mock_popen.call_args
 
-        # Check the command
-        self.assertEqual(popen_args[0][0], [sys.executable, "executor.py"])
+        # Check the command (normal Python install, not frozen)
+        self.assertEqual(popen_args[0][0], [sys.executable, EXECUTOR_PATH])
 
         # Check that stdin was written to
         mock_process.stdin.write.assert_called_once()
@@ -296,6 +299,35 @@ print(json.dumps(output))
         self.assertEqual(stdin_json["options"], options)
         self.assertEqual(stdin_json["run_config"], run_config)
 
+    @patch("nextmv.local.runner.subprocess.Popen")
+    @patch("nextmv.local.runner.safe_id")
+    def test_run_function_execution_frozen(self, mock_safe_id, mock_popen):
+        """Test that --run-script is used when running as a frozen PyInstaller binary."""
+        mock_safe_id.return_value = "test-run-id"
+        mock_process = Mock()
+        mock_process.stdin = Mock()
+        mock_popen.return_value = mock_process
+
+        manifest = Manifest(
+            files=["main.py"],
+            runtime=ManifestRuntime.PYTHON,
+        )
+
+        run_config = {"format": {"input": {"type": "json"}, "output": {"type": "json"}}}
+
+        with patch.object(sys, "frozen", True, create=True):
+            run(
+                app_id="sample-app",
+                src=self.test_src,
+                manifest=manifest,
+                run_config=run_config,
+                input_data={},
+                options={},
+            )
+
+        popen_args = mock_popen.call_args
+        self.assertEqual(popen_args[0][0], [sys.executable, "--run-script", EXECUTOR_PATH])
+
     @patch("nextmv.local.runner.subprocess.Popen")
     @patch("nextmv.local.runner.safe_id")
     def test_run_with_inputs_dir_path(self, mock_safe_id, mock_popen):

nextmv-1.7.2.dev0/tests/local/test_uv_handler.py

@@ -0,0 +1,164 @@
+"""
+Unit tests for the _find_uv_binary() function in nextmv.local.uv_handler.
+"""
+
+import os
+import sys
+import tempfile
+import unittest
+from unittest.mock import MagicMock, patch
+
+from nextmv.local.uv_handler import _find_uv_binary
+
+
+class TestFindUvBinary(unittest.TestCase):
+    """Tests for _find_uv_binary()."""
+
+    # ------------------------------------------------------------------
+    # PyInstaller (frozen) branch
+    # ------------------------------------------------------------------
+
+    def test_frozen_returns_bundled_path(self):
+        """When running as a frozen bundle the path inside _MEIPASS is returned."""
+        with tempfile.TemporaryDirectory() as tmp:
+            uv_bin_dir = os.path.join(tmp, "uv_bin")
+            os.makedirs(uv_bin_dir)
+            fake_uv = os.path.join(uv_bin_dir, "uv")
+            open(fake_uv, "w").close()  # create the file
+
+            with (
+                patch.object(sys, "frozen", True, create=True),
+                patch.object(sys, "_MEIPASS", tmp, create=True),
+                patch("platform.system", return_value="Linux"),
+            ):
+                result = _find_uv_binary()
+
+        self.assertEqual(result, fake_uv)
+
+    def test_frozen_windows_uses_exe_suffix(self):
+        """On Windows the bundled binary name ends with .exe."""
+        with tempfile.TemporaryDirectory() as tmp:
+            uv_bin_dir = os.path.join(tmp, "uv_bin")
+            os.makedirs(uv_bin_dir)
+            fake_uv = os.path.join(uv_bin_dir, "uv.exe")
+            open(fake_uv, "w").close()
+
+            with (
+                patch.object(sys, "frozen", True, create=True),
+                patch.object(sys, "_MEIPASS", tmp, create=True),
+                patch("platform.system", return_value="Windows"),
+            ):
+                result = _find_uv_binary()
+
+        self.assertEqual(result, fake_uv)
+
+    def test_frozen_missing_binary_raises(self):
+        """FileNotFoundError is raised when the bundled binary is absent."""
+        with tempfile.TemporaryDirectory() as tmp:
+            # uv_bin directory exists but the binary itself is missing
+            os.makedirs(os.path.join(tmp, "uv_bin"))
+
+            with (
+                patch.object(sys, "frozen", True, create=True),
+                patch.object(sys, "_MEIPASS", tmp, create=True),
+                patch("platform.system", return_value="Linux"),
+            ):
+                with self.assertRaises(FileNotFoundError):
+                    _find_uv_binary()
+
+    def test_frozen_missing_uv_bin_dir_raises(self):
+        """FileNotFoundError is raised when the entire uv_bin directory is missing."""
+        with tempfile.TemporaryDirectory() as tmp:
+            with (
+                patch.object(sys, "frozen", True, create=True),
+                patch.object(sys, "_MEIPASS", tmp, create=True),
+                patch("platform.system", return_value="Linux"),
+            ):
+                with self.assertRaises(FileNotFoundError):
+                    _find_uv_binary()
+
+    # ------------------------------------------------------------------
+    # uv module branch
+    # ------------------------------------------------------------------
+
+    def test_uv_module_used_when_available(self):
+        """find_uv_bin() from the uv module is used when import succeeds."""
+        fake_module = MagicMock()
+        fake_module.find_uv_bin.return_value = "/usr/local/bin/uv"
+
+        # Ensure we are NOT in a frozen bundle.
+        with patch.object(sys, "frozen", False, create=True), patch.dict("sys.modules", {"uv": fake_module}):
+            result = _find_uv_binary()
+
+        self.assertEqual(result, "/usr/local/bin/uv")
+        fake_module.find_uv_bin.assert_called_once()
+
+    def test_uv_module_import_error_falls_through(self):
+        """An ImportError from the uv module causes fallback to PATH lookup."""
+        with (
+            patch.object(sys, "frozen", False, create=True),
+            patch.dict("sys.modules", {"uv": None}),
+            patch("shutil.which", return_value="/opt/bin/uv"),
+        ):
+            result = _find_uv_binary()
+
+        self.assertEqual(result, "/opt/bin/uv")
+
+    def test_uv_module_attribute_error_falls_through(self):
+        """An AttributeError (missing find_uv_bin attr) causes fallback to PATH lookup."""
+        bad_module = MagicMock(spec=[])  # no find_uv_bin attribute
+
+        with (
+            patch.object(sys, "frozen", False, create=True),
+            patch.dict("sys.modules", {"uv": bad_module}),
+            patch("shutil.which", return_value="/opt/bin/uv"),
+        ):
+            result = _find_uv_binary()
+
+        self.assertEqual(result, "/opt/bin/uv")
+
+    # ------------------------------------------------------------------
+    # PATH branch
+    # ------------------------------------------------------------------
+
+    def test_path_lookup_used_as_last_resort(self):
+        """shutil.which is used as the last fallback when the uv module is absent."""
+        with (
+            patch.object(sys, "frozen", False, create=True),
+            patch.dict("sys.modules", {"uv": None}),
+            patch("shutil.which", return_value="/usr/bin/uv") as mock_which,
+        ):
+            result = _find_uv_binary()
+
+        self.assertEqual(result, "/usr/bin/uv")
+        mock_which.assert_called_once_with("uv")
+
+    def test_raises_when_nothing_found(self):
+        """FileNotFoundError is raised when neither the module nor PATH provide uv."""
+        with (
+            patch.object(sys, "frozen", False, create=True),
+            patch.dict("sys.modules", {"uv": None}),
+            patch("shutil.which", return_value=None),
+        ):
+            with self.assertRaises(FileNotFoundError) as ctx:
+                _find_uv_binary()
+
+        self.assertIn("uv binary not found", str(ctx.exception))
+
+    def test_error_message_mentions_path_and_module(self):
+        """The FileNotFoundError message hints at both PATH and module installation."""
+        with (
+            patch.object(sys, "frozen", False, create=True),
+            patch.dict("sys.modules", {"uv": None}),
+            patch("shutil.which", return_value=None),
+        ):
+            with self.assertRaises(FileNotFoundError) as ctx:
+                _find_uv_binary()
+
+        msg = str(ctx.exception)
+        self.assertIn("PATH", msg)
+        self.assertIn("module", msg)
+
+
+if __name__ == "__main__":
+    unittest.main()

nextmv-1.7.1/nextmv/__about__.py

@@ -1 +0,0 @@
-__version__ = "v1.7.1"