nextmv 0.35.0__py3-none-any.whl → 0.35.0.dev0__py3-none-any.whl

nextmv/local/application.py

@@ -17,7 +17,7 @@ import tempfile
 import webbrowser
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Any
+from typing import Any, Optional, Union
 
 from nextmv import cloud
 from nextmv._serialization import deflated_serialize_json
@@ -92,9 +92,9 @@ class Application:
     manifest.
     """
 
-    description: str | None = None
+    description: Optional[str] = None
     """Description of the application."""
-    manifest: Manifest | None = None
+    manifest: Optional[Manifest] = None
     """
     Manifest of the application. A manifest is a file named `app.yaml` that
     must be present at the root of the application's `src` directory. If the
@@ -131,9 +131,9 @@ class Application:
     @classmethod
     def initialize(
         cls,
-        src: str | None = None,
-        description: str | None = None,
-        destination: str | None = None,
+        src: Optional[str] = None,
+        description: Optional[str] = None,
+        destination: Optional[str] = None,
     ) -> "Application":
         """
         Initialize a sample Nextmv application, locally.
@@ -224,13 +224,13 @@ class Application:
 
     def new_run(
         self,
-        input: Input | dict[str, Any] | BaseModel | str = None,
-        name: str | None = None,
-        description: str | None = None,
-        options: Options | dict[str, str] | None = None,
-        configuration: RunConfiguration | dict[str, Any] | None = None,
-        json_configurations: dict[str, Any] | None = None,
-        input_dir_path: str | None = None,
+        input: Union[Input, dict[str, Any], BaseModel, str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        options: Optional[Union[Options, dict[str, str]]] = None,
+        configuration: Optional[Union[RunConfiguration, dict[str, Any]]] = None,
+        json_configurations: Optional[dict[str, Any]] = None,
+        input_dir_path: Optional[str] = None,
     ) -> str:
         """
         Run the application locally with the provided input.
@@ -361,15 +361,15 @@ class Application:
 
     def new_run_with_result(
         self,
-        input: Input | dict[str, Any] | BaseModel | str = None,
-        name: str | None = None,
-        description: str | None = None,
-        run_options: Options | dict[str, str] | None = None,
+        input: Union[Input, dict[str, Any], BaseModel, str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        run_options: Optional[Union[Options, dict[str, str]]] = None,
         polling_options: PollingOptions = DEFAULT_POLLING_OPTIONS,
-        configuration: RunConfiguration | dict[str, Any] | None = None,
-        json_configurations: dict[str, Any] | None = None,
-        input_dir_path: str | None = None,
-        output_dir_path: str | None = ".",
+        configuration: Optional[Union[RunConfiguration, dict[str, Any]]] = None,
+        json_configurations: Optional[dict[str, Any]] = None,
+        input_dir_path: Optional[str] = None,
+        output_dir_path: Optional[str] = ".",
     ) -> RunResult:
         """
         Submit an input to start a new local run of the application and poll
@@ -526,7 +526,7 @@ class Application:
         if not os.path.exists(run_dir):
             raise ValueError(f"`{run_id}` run dir does not exist at: {runs_dir}")
 
-        logs_dir = os.path.join(run_dir, LOGS_KEY)
+        logs_dir = os.path.join(runs_dir, LOGS_KEY)
         if not os.path.exists(logs_dir):
             return ""
 
@@ -594,7 +594,7 @@ class Application:
 
         return info
 
-    def run_result(self, run_id: str, output_dir_path: str | None = ".") -> RunResult:
+    def run_result(self, run_id: str, output_dir_path: Optional[str] = ".") -> RunResult:
         """
         Get the local result of a run.
 
@@ -644,7 +644,7 @@ class Application:
         self,
         run_id: str,
         polling_options: PollingOptions = DEFAULT_POLLING_OPTIONS,
-        output_dir_path: str | None = ".",
+        output_dir_path: Optional[str] = ".",
     ) -> RunResult:
         """
         Get the result of a local run with polling.
@@ -761,9 +761,9 @@ class Application:
     def sync(  # noqa: C901
         self,
         target: cloud.Application,
-        run_ids: list[str] | None = None,
-        instance_id: str | None = None,
-        verbose: bool | None = False,
+        run_ids: Optional[list[str]] = None,
+        instance_id: Optional[str] = None,
+        verbose: Optional[bool] = False,
     ) -> None:
         """
         Sync the local application to a Nextmv Cloud application target.
@@ -867,7 +867,7 @@ class Application:
         self,
         run_id: str,
         run_information: RunInformation,
-        output_dir_path: str | None = ".",
+        output_dir_path: Optional[str] = ".",
     ) -> RunResult:
         """
         Get the result of a local run.
@@ -931,8 +931,8 @@ class Application:
 
     def __validate_input_dir_path_and_configuration(
         self,
-        input_dir_path: str | None,
-        configuration: RunConfiguration | dict[str, Any] | None,
+        input_dir_path: Optional[str],
+        configuration: Optional[Union[RunConfiguration, dict[str, Any]]],
     ) -> RunConfiguration:
         """
         Auxiliary function to validate the directory path and configuration.
@@ -984,8 +984,8 @@ class Application:
 
     def __extract_input_data(
         self,
-        input: Input | dict[str, Any] | BaseModel | str = None,
-    ) -> dict[str, Any] | str | None:
+        input: Union[Input, dict[str, Any], BaseModel, str] = None,
+    ) -> Optional[Union[dict[str, Any], str]]:
         """
         Auxiliary function to extract the input data from the input, based on
         its type.
@@ -1003,8 +1003,8 @@ class Application:
 
     def __extract_options_dict(
         self,
-        options: Options | dict[str, str] | None = None,
-        json_configurations: dict[str, Any] | None = None,
+        options: Optional[Union[Options, dict[str, str]]] = None,
+        json_configurations: Optional[dict[str, Any]] = None,
     ) -> dict[str, str]:
         """
         Auxiliary function to extract the options that will be sent to the
@@ -1026,9 +1026,9 @@ class Application:
 
     def __extract_run_config(
         self,
-        input: Input | dict[str, Any] | BaseModel | str = None,
-        configuration: RunConfiguration | dict[str, Any] | None = None,
-        dir_path: str | None = None,
+        input: Union[Input, dict[str, Any], BaseModel, str] = None,
+        configuration: Optional[Union[RunConfiguration, dict[str, Any]]] = None,
+        dir_path: Optional[str] = None,
     ) -> dict[str, Any]:
         """
         Auxiliary function to extract the run configuration that will be sent
@@ -1053,8 +1053,8 @@ class Application:
         run_id: str,
         runs_dir: str,
         temp_dir: str,
-        instance_id: str | None = None,
-        verbose: bool | None = False,
+        instance_id: Optional[str] = None,
+        verbose: Optional[bool] = False,
     ) -> bool:
         """
         Syncs a local run to a Nextmv Cloud target application. Returns True if

nextmv/local/executor.py

@@ -43,7 +43,7 @@ import subprocess
 import sys
 import tempfile
 from datetime import datetime, timezone
-from typing import Any
+from typing import Any, Optional, Union
 
 from nextmv.input import INPUTS_KEY, InputFormat, load
 from nextmv.local.geojson_handler import handle_geojson_visual
@@ -56,7 +56,7 @@ from nextmv.local.local import (
     calculate_files_size,
 )
 from nextmv.local.plotly_handler import handle_plotly_visual
-from nextmv.manifest import Manifest, ManifestType
+from nextmv.manifest import Manifest
 from nextmv.output import ASSETS_KEY, OUTPUTS_KEY, SOLUTIONS_KEY, STATISTICS_KEY, Asset, OutputFormat, VisualSchema
 from nextmv.status import StatusV2
 
@@ -87,9 +87,9 @@ def execute_run(
     manifest_dict: dict[str, Any],
     run_dir: str,
     run_config: dict[str, Any],
-    inputs_dir_path: str | None = None,
-    options: dict[str, Any] | None = None,
-    input_data: dict[str, Any] | str | None = None,
+    inputs_dir_path: Optional[str] = None,
+    options: Optional[dict[str, Any]] = None,
+    input_data: Optional[Union[dict[str, Any], str]] = None,
 ) -> None:
     """
     Executes the decision model run using a subprocess to call the entrypoint
@@ -152,8 +152,7 @@ def execute_run(
             # Start a Python subprocess to execute the entrypoint. For now, we are
             # supporting a Python-first experience, so we are not summoning
             # applications that are not Python-based.
-            entrypoint = os.path.join(temp_src, __determine_entrypoint(manifest))
-            cwd = __determine_cwd(manifest, default=temp_src)
+            entrypoint = os.path.join(temp_src, manifest.entrypoint)
             args = [sys.executable, entrypoint] + options_args(options)
 
             result = subprocess.run(
@@ -163,7 +162,7 @@ def execute_run(
                 text=True,
                 capture_output=True,
                 input=stdin_input,
-                cwd=cwd,
+                cwd=temp_src,
             )
 
             process_run_output(
@@ -191,7 +190,7 @@ def execute_run(
             f.truncate()
 
 
-def options_args(options: dict[str, Any] | None = None) -> list[str]:
+def options_args(options: Optional[dict[str, Any]] = None) -> list[str]:
     """
     Converts options dictionary to a list of command-line arguments.
 
@@ -219,8 +218,8 @@ def process_run_input(
     temp_src: str,
     run_format: str,
     manifest: Manifest,
-    input_data: dict[str, Any] | str | None = None,
-    inputs_dir_path: str | None = None,
+    input_data: Optional[Union[dict[str, Any], str]] = None,
+    inputs_dir_path: Optional[str] = None,
 ) -> str:
     """
     In the temp source, writes the run input according to the run format. If
@@ -466,7 +465,7 @@ def process_run_logs(
     output_format: OutputFormat,
     run_dir: str,
     result: subprocess.CompletedProcess[str],
-    stdout_output: str | dict[str, Any],
+    stdout_output: Union[str, dict[str, Any]],
 ) -> None:
     """
     Processes the logs of the run. Writes the logs to a logs directory.
@@ -503,7 +502,7 @@ def process_run_logs(
 def process_run_statistics(
     temp_run_outputs_dir: str,
     outputs_dir: str,
-    stdout_output: str | dict[str, Any],
+    stdout_output: Union[str, dict[str, Any]],
     temp_src: str,
     manifest: Manifest,
 ) -> None:
@@ -564,7 +563,7 @@ def process_run_statistics(
 def process_run_assets(
     temp_run_outputs_dir: str,
     outputs_dir: str,
-    stdout_output: str | dict[str, Any],
+    stdout_output: Union[str, dict[str, Any]],
     temp_src: str,
     manifest: Manifest,
 ) -> None:
@@ -628,7 +627,7 @@ def process_run_solutions(
     temp_run_outputs_dir: str,
     temp_src: str,
     outputs_dir: str,
-    stdout_output: str | dict[str, Any],
+    stdout_output: Union[str, dict[str, Any]],
     output_format: OutputFormat,
     manifest: Manifest,
     src: str,
@@ -757,7 +756,7 @@ def process_run_visuals(run_dir: str, outputs_dir: str) -> None:
         # so we ignore it for now.
 
 
-def resolve_stdout(result: subprocess.CompletedProcess[str]) -> str | dict[str, Any]:
+def resolve_stdout(result: subprocess.CompletedProcess[str]) -> Union[str, dict[str, Any]]:
     """
     Resolves the stdout output of the subprocess run. If the stdout is valid
     JSON, it returns the parsed dictionary. Otherwise, it returns the raw
@@ -839,8 +838,8 @@ def _ignore_patterns(dir_path: str, names: list[str]) -> list[str]:
 def _copy_new_or_modified_files(  # noqa: C901
     runtime_dir: str,
     dst_dir: str,
-    original_src_dir: str | None = None,
-    exclusion_dirs: list[str] | None = None,
+    original_src_dir: Optional[str] = None,
+    exclusion_dirs: Optional[list[str]] = None,
 ) -> None:
     """
     Copy only new or modified files from runtime directory to destination directory.
@@ -1007,34 +1006,5 @@ def _calculate_file_checksum(file_path: str) -> str:
     return hash_md5.hexdigest()
 
 
-def __determine_entrypoint(manifest: Manifest) -> str:
-    """Returns the default entrypoint based on the runtime if not explicitly set."""
-    if manifest.execution is not None and manifest.execution.entrypoint is not None:
-        return manifest.execution.entrypoint
-
-    # Determine default entrypoint based on type
-    if manifest.type == ManifestType.PYTHON:
-        return "./main.py"
-    elif manifest.type == ManifestType.GO:
-        return "./main"
-    elif manifest.type == ManifestType.JAVA:
-        return "./main.jar"
-    else:
-        raise ValueError(
-            f'entrypoint is not provided but the app type "{manifest.type}" could not '
-            "be resolved to establish a default entrypoint"
-        )
-
-
-def __determine_cwd(manifest: Manifest, default: str) -> str:
-    """
-    Returns the working directory based on the manifest if set, otherwise the default.
-    """
-    if manifest.execution is not None and manifest.execution.cwd is not None:
-        return manifest.execution.cwd
-
-    return default
-
-
 if __name__ == "__main__":
     main()

nextmv/local/runner.py

@@ -20,7 +20,7 @@ import shutil
 import subprocess
 import sys
 from datetime import datetime, timezone
-from typing import Any
+from typing import Any, Optional, Union
 
 from nextmv.input import INPUTS_KEY
 from nextmv.local.local import DEFAULT_INPUT_JSON_FILE, NEXTMV_DIR, RUNS_KEY, calculate_files_size
@@ -34,11 +34,11 @@ def run(
     src: str,
     manifest: Manifest,
     run_config: dict[str, Any],
-    name: str | None = None,
-    description: str | None = None,
-    input_data: dict[str, Any] | str | None = None,
-    inputs_dir_path: str | None = None,
-    options: dict[str, Any] | None = None,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    input_data: Optional[Union[dict[str, Any], str]] = None,
+    inputs_dir_path: Optional[str] = None,
+    options: Optional[dict[str, Any]] = None,
 ) -> str:
     """
     Execute a local run.
@@ -145,8 +145,8 @@ def new_run(
     src: str,
     run_id: str,
     run_config: dict[str, Any],
-    name: str | None = None,
-    description: str | None = None,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
 ) -> str:
     """
     Initializes a new run.
@@ -223,8 +223,8 @@ def new_run(
 def record_input(
     run_dir: str,
     run_id: str,
-    input_data: dict[str, Any] | str | None = None,
-    inputs_dir_path: str | None = None,
+    input_data: Optional[Union[dict[str, Any], str]] = None,
+    inputs_dir_path: Optional[str] = None,
 ) -> None:
     """
     Writes the input to the appropriate location.