nextmv 1.7.0.dev0__tar.gz → 1.7.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 1.7.0.dev0
+Version: 1.7.2
 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/nextmv/__about__.py

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

{nextmv-1.7.0.dev0 → nextmv-1.7.2}/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.0.dev0 → nextmv-1.7.2}/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.0.dev0 → nextmv-1.7.2}/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/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.0.dev0 → nextmv-1.7.2}/nextmv/output.py

@@ -992,11 +992,10 @@ class Output:
     }
     ```
     """
-    output_format: ContentFormat | None = ContentFormat.JSON
+    output_format: ContentFormat | None = None
     """
-    Format of the output data. Default is `ContentFormat.JSON`. When set to
-    `ContentFormat.MULTI_FILE`, the `solution_files` field must be specified and
-    cannot be `None`.
+    Format of the output data. When set to `ContentFormat.MULTI_FILE`, the
+    `solution_files` field must be specified and cannot be `None`.
     """
     solution: dict[str, Any] | Any | dict[str, list[dict[str, Any]]] | None = None
     """
@@ -1066,7 +1065,7 @@ class Output:
     handle the serialization of the data.
     """
 
-    def __post_init__(self):
+    def __post_init__(self):  # noqa: C901
         """
         Initialize and validate the Output instance.
 
@@ -1085,7 +1084,7 @@ class Output:
         new_options = copy.deepcopy(init_options)
         self.options = new_options
 
-        if type(self.output_format) is OutputFormat:
+        if self.output_format is not None and type(self.output_format) is OutputFormat:
             deprecated(name="OutputFormat", reason="`OutputFormat` is deprecated, use `ContentFormat` instead")
             if self.output_format in {OutputFormat.TEXT, OutputFormat.CSV_ARCHIVE}:
                 deprecated(
@@ -1097,37 +1096,6 @@ class Output:
             else:
                 raise ValueError(f"unsupported output_format: {self.output_format}")
 
-        if self.solution is not None:
-            if self.output_format == ContentFormat.JSON:
-                try:
-                    _ = serialize_json(self.solution)
-                except (TypeError, OverflowError) as e:
-                    raise ValueError(
-                        f"Output has `output_format` `ContentFormat.JSON` and "
-                        f"`Output.solution` is of type {type(self.solution)}, which is not JSON serializable"
-                    ) from e
-
-            elif (
-                type(self.output_format) is OutputFormat
-                and self.output_format == OutputFormat.CSV_ARCHIVE
-                and not isinstance(self.solution, dict)
-            ):
-                raise ValueError(
-                    f"unsupported Output.solution type: {type(self.solution)} with "
-                    "output_format OutputFormat.CSV_ARCHIVE, supported type is `dict`"
-                )
-
-        if self.solution_files is not None and self.output_format != ContentFormat.MULTI_FILE:
-            raise ValueError(
-                f"`solution_files` are not `None`, but `output_format` is different from `ContentFormat.MULTI_FILE`: "
-                f"{self.output_format}. If you want to use `solution_files`, set `output_format` "
-                "to `ContentFormat.MULTI_FILE`."
-            )
-        elif self.solution_files is not None and not isinstance(self.solution_files, list):
-            raise TypeError(
-                f"unsupported `Output.solution_files` type: {type(self.solution_files)}, supported type is `list`"
-            )
-
     def to_dict(self) -> dict[str, Any]:  # noqa: C901
         """
         Convert the `Output` object to a dictionary.
@@ -1204,14 +1172,15 @@ class Output:
         # Add the auxiliary configurations to the output dictionary if they are
         # defined and not empty.
         if (
-            self.output_format == OutputFormat.CSV_ARCHIVE
+            self.output_format is not None
+            and self.output_format == OutputFormat.CSV_ARCHIVE
             and self.csv_configurations is not None
             and self.csv_configurations != {}
         ):
             output_dict["csv_configurations"] = self.csv_configurations
 
         if (
-            self.output_format == ContentFormat.JSON
+            (self.output_format is None or self.output_format == ContentFormat.JSON)
             and self.json_configurations is not None
             and self.json_configurations != {}
         ):
@@ -1505,9 +1474,9 @@ class LocalOutputWriter(OutputWriter):
         elif manifest is not None:
             resolved_content_format = manifest.configuration.content.format
         elif output is not None:
-            if isinstance(output, Output):
+            if isinstance(output, Output) and output.output_format is not None:
                 resolved_content_format = output.output_format
-            elif isinstance(output, dict) or isinstance(output, BaseModel):
+            elif isinstance(output, (Output, dict, BaseModel)):
                 resolved_content_format = ContentFormat.JSON
             else:
                 raise ValueError(

{nextmv-1.7.0.dev0 → nextmv-1.7.2}/nextmv/templates/python_json_class-assign/requirements.txt

@@ -1,3 +1,3 @@
-nextmv>=1.6.2
+nextmv>=1.7.0
 pyomo>=6.7.0
 highspy>=1.7.0

{nextmv-1.7.0.dev0 → nextmv-1.7.2}/nextmv/templates/python_json_demand-alloc/allocation/requirements.txt

@@ -1,4 +1,4 @@
-nextmv>=1.6.2
+nextmv>=1.7.0
 numpy>=2.2.0
 pyomo>=6.7.0
 highspy>=1.7.0

{nextmv-1.7.0.dev0 → nextmv-1.7.2}/nextmv/templates/python_json_demand-alloc/workflow/requirements.txt

@@ -1,4 +1,4 @@
-nextmv>=1.6.2
+nextmv>=1.7.0
 nextpipe>=0.6.1
 numpy>=2.2.0
 pandas>=2.2.3

{nextmv-1.7.0.dev0/nextmv/templates/python_multi-file_hello-world → nextmv-1.7.2/nextmv/templates/python_json_hello-world}/requirements.txt

@@ -1,2 +1,2 @@
-nextmv>=1.6.2
+nextmv>=1.7.0
 plotly>=6.5.2

{nextmv-1.7.0.dev0 → nextmv-1.7.2}/nextmv/templates/python_multi-file_class-assign/requirements.txt

@@ -1,3 +1,3 @@
-nextmv>=1.6.2
+nextmv>=1.7.0
 pyomo>=6.7.0
 highspy>=1.7.0

{nextmv-1.7.0.dev0 → nextmv-1.7.2}/nextmv/templates/python_multi-file_demand-alloc/allocation/requirements.txt

@@ -1,4 +1,4 @@
-nextmv>=1.6.2
+nextmv>=1.7.0
 numpy>=2.2.0
 pyomo>=6.7.0
 highspy>=1.7.0

{nextmv-1.7.0.dev0 → nextmv-1.7.2}/nextmv/templates/python_multi-file_demand-alloc/workflow/requirements.txt

@@ -1,4 +1,4 @@
-nextmv>=1.6.2
+nextmv>=1.7.0
 nextpipe>=0.6.1
 numpy>=2.2.0
 pandas>=2.2.3

{nextmv-1.7.0.dev0/nextmv/templates/python_json_hello-world → nextmv-1.7.2/nextmv/templates/python_multi-file_hello-world}/requirements.txt

@@ -1,2 +1,2 @@
-nextmv>=1.6.2
+nextmv>=1.7.0
 plotly>=6.5.2

{nextmv-1.7.0.dev0 → nextmv-1.7.2}/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/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.0.dev0 → nextmv-1.7.2}/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):