nextmv 1.2.3.dev2__tar.gz → 1.2.3.dev4__tar.gz

{nextmv-1.2.3.dev2 → nextmv-1.2.3.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 1.2.3.dev2
+Version: 1.2.3.dev4
 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.2.3.dev4/nextmv/__about__.py

@@ -0,0 +1 @@
+__version__ = "v1.2.3.dev4"

{nextmv-1.2.3.dev2 → nextmv-1.2.3.dev4}/nextmv/cli/mcp/tools/_helpers.py

@@ -73,6 +73,24 @@ def _get_local_app(app_dir: str, app_id: str | None = None) -> local.Application
     return app
 
 
+def _build_run_configuration(content_format: str | None):
+    """Build a RunConfiguration for the given content format string, or None."""
+
+    if content_format is None:
+        return None
+
+    from nextmv.input import InputFormat
+    from nextmv.run import Format, FormatInput, RunConfiguration
+
+    config = RunConfiguration()
+    config.format = Format(
+        format_input=FormatInput(
+            input_type=InputFormat(content_format),
+        ),
+    )
+    return config
+
+
 def _save_to_file(data: Any, prefix: str) -> str:
     """Serialize data to a temp JSON file and return a message with the path.
 

{nextmv-1.2.3.dev2 → nextmv-1.2.3.dev4}/nextmv/cli/mcp/tools/local.py

@@ -1,9 +1,6 @@
 """MCP tools for local application management."""
 
-import json
 import os
-import subprocess
-import tempfile
 from typing import Any
 
 from mcp.server.fastmcp import FastMCP
@@ -20,103 +17,6 @@ def _local_run_dir(app_dir: str, run_id: str) -> str:
     return os.path.join(app_dir, NEXTMV_DIR, RUNS_KEY, run_id)
 
 
-def _run_via_cli(
-    app_dir: str,
-    input_data: dict[str, Any],
-    run_options: dict[str, str] | None = None,
-    wait: bool = False,
-) -> str:
-    """Execute a local run via ``uv run nextmv local run create``.
-
-    This invokes the Nextmv CLI through ``uv``, which ensures that
-    the application's ``requirements.txt`` dependencies are installed
-    and available at runtime (unlike calling the SDK directly with
-    ``sys.executable``).
-
-    Args:
-        app_dir: Absolute path to the local application directory.
-        input_data: The input data (JSON object) for the run.
-        run_options: Optional solver options passed as ``--options key=value``.
-        wait: If True, blocks until the run completes (``--wait``).
-
-    Returns:
-        The run ID (parsed from the CLI's JSON stdout output).
-
-    Raises:
-        RuntimeError: If the CLI process exits with a non-zero return code.
-    """
-
-    # Write input to a temp file so the CLI can read it via --input.
-    fd, input_path = tempfile.mkstemp(suffix=".json", prefix="mcp_local_input_")
-    try:
-        with os.fdopen(fd, "w") as fh:
-            json.dump(input_data, fh)
-
-        cmd: list[str] = [
-            "uv", "run", "nextmv",
-            "local", "run", "create",
-            "--app-src", os.path.abspath(app_dir),
-            "--input", input_path,
-        ]
-
-        if run_options:
-            for key, value in run_options.items():
-                cmd.extend(["--options", f"{key}={value}"])
-
-        if wait:
-            cmd.append("--wait")
-
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            check=False,
-            env=os.environ,
-        )
-
-        if result.returncode != 0:
-            stderr = result.stderr.strip()
-            raise RuntimeError(
-                f"nextmv local run create failed (exit {result.returncode}): {stderr}"
-            )
-
-        # The CLI prints JSON with a "run_id" key to stdout when not
-        # waiting, or the full result when waiting.
-        stdout = result.stdout.strip()
-        try:
-            parsed = json.loads(stdout)
-            if isinstance(parsed, dict) and "run_id" in parsed:
-                return parsed["run_id"]
-        except json.JSONDecodeError:
-            pass
-
-        # When --wait is used the CLI may print the run_id via a
-        # success message to stderr. Fall back to extracting the
-        # run_id from the run directory listing.
-        from nextmv.local.local import NEXTMV_DIR, RUNS_KEY
-
-        runs_dir = os.path.join(
-            os.path.abspath(app_dir), NEXTMV_DIR, RUNS_KEY,
-        )
-        if os.path.isdir(runs_dir):
-            entries = sorted(
-                os.listdir(runs_dir),
-                key=lambda d: os.path.getmtime(
-                    os.path.join(runs_dir, d)
-                ),
-            )
-            if entries:
-                return entries[-1]
-
-        raise RuntimeError(
-            f"Could not determine run_id from CLI output: {stdout}"
-        )
-    finally:
-        # Clean up the temp input file.
-        if os.path.exists(input_path):
-            os.unlink(input_path)
-
-
 def _local_run_input_impl(
     app_dir: str,
     run_id: str,
@@ -155,30 +55,47 @@ def _local_run_logs_impl(
 
 def local_run(
     app_dir: str,
-    input: dict[str, Any],
+    input: dict[str, Any] | None = None,
+    input_dir_path: str | None = None,
+    content_format: str | None = None,
     run_options: dict[str, str] | None = None,
 ) -> str:
     """Run a local Nextmv application and wait for the result.
 
-    Executes the application via ``uv run nextmv local run create
-    --wait``, which handles dependency installation (e.g.
-    requirements.txt) automatically. The result is stored in the
-    local run directory at ``{app_dir}/.nextmv/runs/{run_id}/``.
-    Use file-reading tools to inspect the result file.
+    Executes the application using the Nextmv SDK and polls until the
+    run completes. The result is stored in the local run directory at
+    ``{app_dir}/.nextmv/runs/{run_id}/``. Use file-reading tools to
+    inspect the result file.
+
+    For JSON apps, provide ``input`` as a JSON object. For multi-file
+    or CSV archive apps, provide ``input_dir_path`` pointing to a
+    directory of input files and set ``content_format`` accordingly
+    (e.g. ``"multi-file"`` or ``"csv-archive"``).
 
     Args:
         app_dir: Absolute path to the local application directory
             containing an app.yaml manifest.
-        input: The input data (JSON object) for the optimization run.
+        input: The input data (JSON object) for the run. Used for
+            JSON apps. Ignored when ``input_dir_path`` is provided.
+        input_dir_path: Path to a directory containing input files.
+            Use for multi-file or CSV archive apps. When provided,
+            ``content_format`` must also be set.
+        content_format: Content format of the input. Required when
+            ``input_dir_path`` is set. Allowed values:
+            ``"multi-file"``, ``"csv-archive"``, ``"json"``.
         run_options: Optional solver options passed to the application,
             e.g. ``{"solve.duration": "10s"}``.
     """
 
-    run_id = _run_via_cli(
-        app_dir=app_dir,
-        input_data=input,
-        run_options=run_options,
-        wait=True,
+    app = _helpers._get_local_app(app_dir=app_dir)
+    config = _helpers._build_run_configuration(content_format)
+    if input_dir_path is not None:
+        run_id = app.new_run(input_dir_path=input_dir_path, options=run_options, configuration=config)
+    else:
+        run_id = app.new_run(input=input, options=run_options, configuration=config)
+    app.run_result_with_polling(
+        run_id=run_id,
+        polling_options=default_polling_options(),
     )
     run_dir = _local_run_dir(app_dir, run_id)
     result_path = os.path.join(run_dir, f"{run_id}.json")
@@ -190,30 +107,42 @@ def local_run(
 
 def local_run_submit(
     app_dir: str,
-    input: dict[str, Any],
+    input: dict[str, Any] | None = None,
+    input_dir_path: str | None = None,
+    content_format: str | None = None,
     run_options: dict[str, str] | None = None,
 ) -> str:
     """Submit a local run without waiting for completion.
 
-    Executes the application via ``uv run nextmv local run create``
-    (non-blocking). Returns the run ID immediately. Use
-    ``local_run_poll_result`` or ``local_run_status`` to check on
-    the run later.
+    Executes the application using the Nextmv SDK and returns the run
+    ID immediately. Use ``local_run_poll_result`` or
+    ``local_run_status`` to check on the run later.
+
+    For JSON apps, provide ``input`` as a JSON object. For multi-file
+    or CSV archive apps, provide ``input_dir_path`` pointing to a
+    directory of input files and set ``content_format`` accordingly
+    (e.g. ``"multi-file"`` or ``"csv-archive"``).
 
     Args:
         app_dir: Absolute path to the local application directory
             containing an app.yaml manifest.
-        input: The input data (JSON object) for the run.
+        input: The input data (JSON object) for the run. Used for
+            JSON apps. Ignored when ``input_dir_path`` is provided.
+        input_dir_path: Path to a directory containing input files.
+            Use for multi-file or CSV archive apps. When provided,
+            ``content_format`` must also be set.
+        content_format: Content format of the input. Required when
+            ``input_dir_path`` is set. Allowed values:
+            ``"multi-file"``, ``"csv-archive"``, ``"json"``.
         run_options: Optional solver options passed to the application,
             e.g. ``{"solve.duration": "10s"}``.
     """
 
-    return _run_via_cli(
-        app_dir=app_dir,
-        input_data=input,
-        run_options=run_options,
-        wait=False,
-    )
+    app = _helpers._get_local_app(app_dir=app_dir)
+    config = _helpers._build_run_configuration(content_format)
+    if input_dir_path is not None:
+        return app.new_run(input_dir_path=input_dir_path, options=run_options, configuration=config)
+    return app.new_run(input=input, options=run_options, configuration=config)
 
 
 def local_run_status(

{nextmv-1.2.3.dev2 → nextmv-1.2.3.dev4}/nextmv/cli/mcp/tools/run.py

@@ -45,7 +45,9 @@ def register(mcp: FastMCP) -> None:
     @mcp.tool()
     def cloud_run(
         app_id: str,
-        input: dict[str, Any],
+        input: dict[str, Any] | None = None,
+        input_dir_path: str | None = None,
+        content_format: str | None = None,
         instance_id: str | None = None,
         run_options: dict[str, str] | None = None,
         managed_input_id: str | None = None,
@@ -57,10 +59,22 @@ def register(mcp: FastMCP) -> None:
         statistics) to a local temp file. Use file-reading tools to
         inspect the contents.
 
+        For JSON apps, provide ``input`` as a JSON object. For
+        multi-file or CSV archive apps, provide ``input_dir_path``
+        pointing to a local directory of input files and set
+        ``content_format`` accordingly (e.g. ``"multi-file"``).
+
         Args:
             app_id: The application ID.
-            input: The input data (JSON object) for the optimization
-                run. Ignored when ``managed_input_id`` is provided.
+            input: The input data (JSON object) for the run. Used for
+                JSON apps. Ignored when ``input_dir_path`` or
+                ``managed_input_id`` is provided.
+            input_dir_path: Path to a local directory containing input
+                files. Use for multi-file or CSV archive apps. When
+                provided, ``content_format`` must also be set.
+            content_format: Content format of the input. Required when
+                ``input_dir_path`` is set. Allowed values:
+                ``"multi-file"``, ``"csv-archive"``, ``"json"``.
             instance_id: Instance to run against. Uses the application's
                 default instance if omitted.
             run_options: Solver options passed to the application, e.g.
@@ -70,8 +84,11 @@ def register(mcp: FastMCP) -> None:
         """
 
         app = _helpers._get_app(app_id)
+        config = _helpers._build_run_configuration(content_format)
         result = app.new_run_with_result(
             input=input,
+            input_dir_path=input_dir_path,
+            configuration=config,
             instance_id=instance_id,
             run_options=run_options or {},
             polling_options=default_polling_options(),
@@ -82,7 +99,9 @@ def register(mcp: FastMCP) -> None:
     @mcp.tool()
     def cloud_run_submit(
         app_id: str,
-        input: dict[str, Any],
+        input: dict[str, Any] | None = None,
+        input_dir_path: str | None = None,
+        content_format: str | None = None,
         instance_id: str | None = None,
         run_options: dict[str, str] | None = None,
         managed_input_id: str | None = None,
@@ -92,10 +111,22 @@ def register(mcp: FastMCP) -> None:
         Returns the run ID immediately. Use ``cloud_run_status`` or
         ``cloud_run_result`` to check on the run later.
 
+        For JSON apps, provide ``input`` as a JSON object. For
+        multi-file or CSV archive apps, provide ``input_dir_path``
+        pointing to a local directory of input files and set
+        ``content_format`` accordingly (e.g. ``"multi-file"``).
+
         Args:
             app_id: The application ID.
-            input: The input data (JSON object) for the run. Ignored
-                when ``managed_input_id`` is provided.
+            input: The input data (JSON object) for the run. Used for
+                JSON apps. Ignored when ``input_dir_path`` or
+                ``managed_input_id`` is provided.
+            input_dir_path: Path to a local directory containing input
+                files. Use for multi-file or CSV archive apps. When
+                provided, ``content_format`` must also be set.
+            content_format: Content format of the input. Required when
+                ``input_dir_path`` is set. Allowed values:
+                ``"multi-file"``, ``"csv-archive"``, ``"json"``.
             instance_id: Instance to run against. Uses the application's
                 default instance if omitted.
             run_options: Solver options passed to the application, e.g.
@@ -105,13 +136,15 @@ def register(mcp: FastMCP) -> None:
         """
 
         app = _helpers._get_app(app_id)
-        run_id = app.new_run(
+        config = _helpers._build_run_configuration(content_format)
+        return app.new_run(
             input=input,
+            input_dir_path=input_dir_path,
+            configuration=config,
             instance_id=instance_id,
             options=run_options or {},
             managed_input_id=managed_input_id,
         )
-        return run_id
 
     @mcp.tool()
     def cloud_run_status(app_id: str, run_id: str) -> dict[str, Any]:

{nextmv-1.2.3.dev2 → nextmv-1.2.3.dev4}/tests/cli/test_mcp.py

@@ -931,3 +931,115 @@ class TestBugFixes(unittest.TestCase):
         run_numbers = [r["run_number"] for r in runs]
         self.assertEqual(run_numbers, ["1", "2"])
 
+
+class TestMultiFileRunSupport(unittest.TestCase):
+    """Tests for multi-file run support in local and cloud run tools."""
+
+    def test_build_run_configuration_none(self):
+        """_build_run_configuration returns None when content_format is None."""
+        from nextmv.cli.mcp.tools._helpers import _build_run_configuration
+
+        self.assertIsNone(_build_run_configuration(None))
+
+    def test_build_run_configuration_multi_file(self):
+        """_build_run_configuration builds a RunConfiguration for 'multi-file'."""
+        from nextmv.cli.mcp.tools._helpers import _build_run_configuration
+        from nextmv.input import InputFormat
+
+        config = _build_run_configuration("multi-file")
+        self.assertIsNotNone(config)
+        self.assertEqual(
+            config.format.format_input.input_type,
+            InputFormat.MULTI_FILE,
+        )
+
+    @patch("nextmv.cli.mcp.tools._helpers._get_local_app")
+    def test_local_run_submit_json_input(self, mock_get_local_app):
+        """local_run_submit passes input dict to new_run for JSON apps."""
+        from nextmv.cli.mcp.server import create_server
+
+        mock_app = MagicMock()
+        mock_app.new_run.return_value = "run-123"
+        mock_get_local_app.return_value = mock_app
+
+        server = create_server()
+        tool = server._tool_manager._tools["local_run_submit"]
+        asyncio.run(tool.run({
+            "app_dir": "/some/app",
+            "input": {"stops": []},
+        }))
+        mock_app.new_run.assert_called_once()
+        call_kwargs = mock_app.new_run.call_args[1]
+        self.assertEqual(call_kwargs["input"], {"stops": []})
+        self.assertIsNone(call_kwargs.get("input_dir_path"))
+        self.assertIsNone(call_kwargs.get("configuration"))
+
+    @patch("nextmv.cli.mcp.tools._helpers._get_local_app")
+    def test_local_run_submit_multifile_input(self, mock_get_local_app):
+        """local_run_submit passes input_dir_path + configuration for multi-file apps."""
+        from nextmv.cli.mcp.server import create_server
+        from nextmv.input import InputFormat
+
+        mock_app = MagicMock()
+        mock_app.new_run.return_value = "run-456"
+        mock_get_local_app.return_value = mock_app
+
+        server = create_server()
+        tool = server._tool_manager._tools["local_run_submit"]
+        asyncio.run(tool.run({
+            "app_dir": "/some/app",
+            "input_dir_path": "/some/input-dir",
+            "content_format": "multi-file",
+        }))
+        mock_app.new_run.assert_called_once()
+        call_kwargs = mock_app.new_run.call_args[1]
+        self.assertEqual(call_kwargs["input_dir_path"], "/some/input-dir")
+        config = call_kwargs.get("configuration")
+        self.assertIsNotNone(config)
+        self.assertEqual(config.format.format_input.input_type, InputFormat.MULTI_FILE)
+
+    @patch("nextmv.cli.mcp.tools._helpers._get_app")
+    def test_cloud_run_submit_json_input(self, mock_get_app):
+        """cloud_run_submit passes input dict to new_run for JSON apps."""
+        from nextmv.cli.mcp.server import create_server
+
+        mock_app = MagicMock()
+        mock_app.new_run.return_value = "run-789"
+        mock_get_app.return_value = mock_app
+
+        server = create_server()
+        tool = server._tool_manager._tools["cloud_run_submit"]
+        asyncio.run(tool.run({
+            "app_id": "my-app",
+            "input": {"stops": []},
+        }))
+        mock_app.new_run.assert_called_once()
+        call_kwargs = mock_app.new_run.call_args[1]
+        self.assertEqual(call_kwargs["input"], {"stops": []})
+        self.assertIsNone(call_kwargs.get("input_dir_path"))
+        self.assertIsNone(call_kwargs.get("configuration"))
+
+    @patch("nextmv.cli.mcp.tools._helpers._get_app")
+    def test_cloud_run_submit_multifile_input(self, mock_get_app):
+        """cloud_run_submit passes input_dir_path + configuration for multi-file apps."""
+        from nextmv.cli.mcp.server import create_server
+        from nextmv.input import InputFormat
+
+        mock_app = MagicMock()
+        mock_app.new_run.return_value = "run-mf-1"
+        mock_get_app.return_value = mock_app
+
+        server = create_server()
+        tool = server._tool_manager._tools["cloud_run_submit"]
+        asyncio.run(tool.run({
+            "app_id": "my-app",
+            "input_dir_path": "/some/input-dir",
+            "content_format": "multi-file",
+        }))
+        mock_app.new_run.assert_called_once()
+        call_kwargs = mock_app.new_run.call_args[1]
+        self.assertEqual(call_kwargs["input_dir_path"], "/some/input-dir")
+        config = call_kwargs.get("configuration")
+        self.assertIsNotNone(config)
+        self.assertEqual(config.format.format_input.input_type, InputFormat.MULTI_FILE)
+

nextmv-1.2.3.dev2/nextmv/__about__.py

@@ -1 +0,0 @@
-__version__ = "v1.2.3.dev2"