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

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.

nextmv/manifest.py

@@ -53,7 +53,7 @@ MANIFEST_FILE_NAME
 
 import os
 from enum import Enum
-from typing import Any
+from typing import Any, Optional, Union
 
 import yaml
 from pydantic import AliasChoices, Field, field_validator
@@ -244,14 +244,14 @@ class ManifestBuild(BaseModel):
     'make build'
     """
 
-    command: str | None = None
+    command: Optional[str] = None
     """The command to run to build the app.
 
     This command will be executed without a shell, i.e., directly. The command
     must exit with a status of 0 to continue the push process of the app to
     Nextmv Cloud. This command is executed prior to the pre-push command.
     """
-    environment: dict[str, Any] | None = None
+    environment: Optional[dict[str, Any]] = None
     """Environment variables to set when running the build command.
 
     Given as key-value pairs.
@@ -317,7 +317,7 @@ class ManifestPythonModel(BaseModel):
 
     name: str
     """The name of the decision model."""
-    options: list[dict[str, Any]] | None = None
+    options: Optional[list[dict[str, Any]]] = None
     """
     Options for the decision model. This is a data representation of the
     `nextmv.Options` class. It consists of a list of dicts. Each dict
@@ -359,7 +359,7 @@ class ManifestPython(BaseModel):
     'requirements.txt'
     """
 
-    pip_requirements: str | list[str] | None = Field(
+    pip_requirements: Optional[Union[str, list[str]]] = Field(
         serialization_alias="pip-requirements",
         validation_alias=AliasChoices("pip-requirements", "pip_requirements"),
         default=None,
@@ -371,16 +371,16 @@ class ManifestPython(BaseModel):
     app. Can be either a string path to a requirements.txt file or a list
     of package specifications.
     """
-    arch: ManifestPythonArch | None = None
+    arch: Optional[ManifestPythonArch] = None
     """
     The architecture this model is meant to run on. One of "arm64" or "amd64". Uses
     "arm64" if not specified.
     """
-    version: str | float | None = None
+    version: Optional[Union[str, float]] = None
     """
     The Python version this model is meant to run with. Uses "3.11" if not specified.
     """
-    model: ManifestPythonModel | None = None
+    model: Optional[ManifestPythonModel] = None
     """
     Information about an encoded decision model.
 
@@ -390,7 +390,7 @@ class ManifestPython(BaseModel):
 
     @field_validator("version", mode="before")
     @classmethod
-    def validate_version(cls, v: str | float | None) -> str | None:
+    def validate_version(cls, v: Optional[Union[str, float]]) -> Optional[str]:
         """
         Validate and convert the Python version field to a string.
 
@@ -461,11 +461,11 @@ class ManifestOptionUI(BaseModel):
     'input'
     """
 
-    control_type: str | None = None
+    control_type: Optional[str] = None
     """The type of control to use for the option in the Nextmv Cloud UI."""
-    hidden_from: list[str] | None = None
+    hidden_from: Optional[list[str]] = None
     """A list of team roles for which this option will be hidden in the UI."""
-    display_name: str | None = None
+    display_name: Optional[str] = None
     """An optional display name for the option. This is useful for making
     the option more user-friendly in the UI.
     """
@@ -529,15 +529,15 @@ class ManifestOption(BaseModel):
     )
     """The type of the option (e.g., "string", "int", "bool", "float)."""
 
-    default: Any | None = None
+    default: Optional[Any] = None
     """The default value of the option"""
-    description: str | None = ""
+    description: Optional[str] = ""
     """The description of the option"""
     required: bool = False
     """Whether the option is required or not"""
-    additional_attributes: dict[str, Any] | None = None
+    additional_attributes: Optional[dict[str, Any]] = None
     """Optional additional attributes for the option."""
-    ui: ManifestOptionUI | None = None
+    ui: Optional[ManifestOptionUI] = None
     """Optional UI attributes for the option."""
 
     @classmethod
@@ -727,16 +727,16 @@ class ManifestOptions(BaseModel):
     2
     """
 
-    strict: bool | None = False
+    strict: Optional[bool] = False
     """If strict is set to `True`, only the listed options will be allowed."""
-    validation: ManifestValidation | None = None
+    validation: Optional[ManifestValidation] = None
     """Optional validation rules for all options."""
-    items: list[ManifestOption] | None = None
+    items: Optional[list[ManifestOption]] = None
     """The actual list of options for the decision model.
 
     An option is a parameter that configures the decision model.
     """
-    format: list[str] | None = None
+    format: Optional[list[str]] = None
     """A list of strings that define how options are transformed into command line arguments.
 
     Use `{{name}}` to refer to the option name and `{{value}}` to refer to the option value.
@@ -749,7 +749,7 @@ class ManifestOptions(BaseModel):
         cls,
         options: Options,
         validation: OptionsEnforcement = None,
-        format: list[str] | None = None,
+        format: Optional[list[str]] = None,
     ) -> "ManifestOptions":
         """
         Create a `ManifestOptions` from a `nextmv.Options`.
@@ -853,11 +853,11 @@ class ManifestContentMultiFileOutput(BaseModel):
     'my-outputs/statistics.json'
     """
 
-    statistics: str | None = ""
+    statistics: Optional[str] = ""
     """The path to the statistics file."""
-    assets: str | None = ""
+    assets: Optional[str] = ""
     """The path to the assets file."""
-    solutions: str | None = ""
+    solutions: Optional[str] = ""
     """The path to the solutions directory."""
 
 
@@ -942,7 +942,7 @@ class ManifestContent(BaseModel):
     The format of the content. Can only be `InputFormat.JSON`,
     `InputFormat.MULTI_FILE`, or `InputFormat.CSV_ARCHIVE`.
     """
-    multi_file: ManifestContentMultiFile | None = Field(
+    multi_file: Optional[ManifestContentMultiFile] = Field(
         serialization_alias="multi-file",
         validation_alias=AliasChoices("multi-file", "multi_file"),
         default=None,
@@ -1001,46 +1001,12 @@ class ManifestConfiguration(BaseModel):
     'debug_mode'
     """
 
-    options: ManifestOptions | None = None
+    options: Optional[ManifestOptions] = None
     """Options for the decision model."""
-    content: ManifestContent | None = None
+    content: Optional[ManifestContent] = None
     """Content configuration for specifying how the app input/output is handled."""
 
 
-class ManifestExecution(BaseModel):
-    """
-    Execution configuration for the decision model.
-
-    You can import the `ManifestExecution` class directly from `nextmv`:
-
-    ```python
-    from nextmv import ManifestExecution
-    ```
-
-    Parameters
-    ----------
-    entrypoint : Optional[str], default=None
-        The entrypoint for the decision model, e.g.: `./app.py`.
-    cwd : Optional[str], default=None
-        The working directory to set when running the app, e.g.: `./src/`.
-
-    Examples
-    --------
-    >>> from nextmv import ManifestExecution
-    >>> exec_config = ManifestExecution(
-    ...     entrypoint="./app.py",
-    ...     cwd="./src/"
-    ... )
-    >>> exec_config.entrypoint
-    './app.py'
-    """
-
-    entrypoint: str | None = None
-    """The entrypoint for the decision model, e.g.: `./app.py`."""
-    cwd: str | None = None
-    """The working directory to set when running the app, e.g.: `./src/`."""
-
-
 class Manifest(BaseModel):
     """
     Represents an app manifest (`app.yaml`) for Nextmv Cloud.
@@ -1118,7 +1084,7 @@ class Manifest(BaseModel):
     The runtime to use for the app. It provides the environment in which the
     app runs. This is mandatory.
     """
-    python: ManifestPython | None = None
+    python: Optional[ManifestPython] = None
     """
     Python-specific attributes. Only for Python apps. Contains further
     Python-specific attributes.
@@ -1127,12 +1093,12 @@ class Manifest(BaseModel):
         default_factory=list,
     )
     """The files to include (or exclude) in the app. This is mandatory."""
-    configuration: ManifestConfiguration | None = None
+    configuration: Optional[ManifestConfiguration] = None
     """
     Configuration for the decision model. A list of options for the decision
     model. An option is a parameter that configures the decision model.
     """
-    build: ManifestBuild | None = None
+    build: Optional[ManifestBuild] = None
     """
     Build-specific attributes.
 
@@ -1143,7 +1109,7 @@ class Manifest(BaseModel):
     set environment variables when running the build command given as key-value
     pairs.
     """
-    pre_push: str | None = Field(
+    pre_push: Optional[str] = Field(
         serialization_alias="pre-push",
         validation_alias=AliasChoices("pre-push", "pre_push"),
         default=None,
@@ -1158,12 +1124,55 @@ class Manifest(BaseModel):
     process. This command is executed just before the app gets bundled and
     pushed (after the build command).
     """
-    execution: ManifestExecution | None = None
+    entrypoint: Optional[str] = None
     """
-    Optional execution configuration for the decision model. Allows configuration of
-    entrypoint and more.
+    Optional entrypoint for the decision model. When not specified, the
+    following default entrypoints are used, according to the `.runtime`:
+
+    - `ManifestRuntime.PYTHON`, `ManifestRuntime.HEXALY`, `ManifestRuntime.PYOMO`: `./main.py`
+    - `ManifestRuntime.DEFAULT`: `./main`
+    - Java: `./main.jar`
     """
 
+    def model_post_init(self, __context) -> None:
+        """
+        Post-initialization to set default entrypoint based on runtime if not specified.
+
+        This method is automatically called by Pydantic after the model is initialized.
+        If no entrypoint is provided, it sets a default entrypoint based on the runtime:
+        - Python runtimes (PYTHON, HEXALY, PYOMO, CUOPT): "./main.py"
+        - DEFAULT runtime: "./main"
+        - JAVA runtime: "./main.jar"
+
+        Parameters
+        ----------
+        __context : Any
+            Pydantic context (unused in this implementation).
+
+        Raises
+        ------
+        ValueError
+            If no entrypoint is provided and the runtime cannot be resolved to
+            establish a default entrypoint.
+        """
+        if self.entrypoint is None:
+            if self.runtime in (
+                ManifestRuntime.PYTHON,
+                ManifestRuntime.HEXALY,
+                ManifestRuntime.PYOMO,
+                ManifestRuntime.CUOPT,
+            ):
+                self.entrypoint = "./main.py"
+            elif self.runtime == ManifestRuntime.DEFAULT:
+                self.entrypoint = "./main"
+            elif self.runtime == ManifestRuntime.JAVA:
+                self.entrypoint = "./main.jar"
+            else:
+                raise ValueError(
+                    f'entrypoint is not provided but the runtime "{self.runtime}" could not '
+                    "be resolved to establish a default entrypoint"
+                )
+
     @classmethod
     def from_yaml(cls, dirpath: str) -> "Manifest":
         """
@@ -1247,7 +1256,7 @@ class Manifest(BaseModel):
                 width=120,
             )
 
-    def extract_options(self, should_parse: bool = True) -> Options | None:
+    def extract_options(self, should_parse: bool = True) -> Optional[Options]:
         """
         Convert the manifest options to a `nextmv.Options` object.
 
@@ -1468,5 +1477,6 @@ def default_python_manifest() -> Manifest:
         type=ManifestType.PYTHON,
         python=ManifestPython(pip_requirements="requirements.txt"),
     )
+    m.entrypoint = None  # TODO: change this when we are ready for the entrypoint.
 
     return m

nextmv/model.py

@@ -20,7 +20,7 @@ import os
 import shutil
 import warnings
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Optional
 
 from nextmv.input import Input
 from nextmv.logger import log
@@ -152,11 +152,11 @@ class ModelConfiguration:
 
     name: str
     """The name of the decision model."""
-    requirements: list[str] | None = None
+    requirements: Optional[list[str]] = None
     """A list of Python dependencies that the decision model requires."""
-    options: Options | None = None
+    options: Optional[Options] = None
     """Options that the decision model requires."""
-    options_enforcement: OptionsEnforcement | None = None
+    options_enforcement: Optional[OptionsEnforcement] = None
     """Enforcement of options for the model."""
 
 
@@ -308,7 +308,7 @@ class Model:
                 self,
                 context,
                 model_input,
-                params: dict[str, Any] | None = None,
+                params: Optional[dict[str, Any]] = None,
             ) -> Any:
                 """
                 MLflow-compliant prediction method that calls the Nextmv model's solve method.
@@ -376,7 +376,7 @@ class Model:
 
 def _cleanup_python_model(
     model_dir: str,
-    model_configuration: ModelConfiguration | None = None,
+    model_configuration: Optional[ModelConfiguration] = None,
     verbose: bool = False,
 ) -> None:
     """

nextmv/options.py

@@ -21,7 +21,7 @@ import copy
 import json
 import os
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Optional, Union
 
 from nextmv.base_model import BaseModel
 from nextmv.deprecated import deprecated
@@ -74,17 +74,17 @@ class Parameter:
     param_type: type
     """The type of the parameter."""
 
-    default: Any | None = None
+    default: Optional[Any] = None
     """The default value of the parameter. Even though this is optional, it is
     recommended to provide a default value for all parameters."""
-    description: str | None = None
+    description: Optional[str] = None
     """An optional description of the parameter. This is useful for generating
     help messages for the configuration."""
     required: bool = False
     """Whether the parameter is required. If a parameter is required, it will
     be an error to not provide a value for it, either trough a command-line
     argument, an environment variable or a default value."""
-    choices: list[Any | None] = None
+    choices: list[Optional[Any]] = None
     """Limits values to a specific set of choices."""
 
     def __post_init__(self):
@@ -246,12 +246,12 @@ class Option:
     option_type: type
     """The type of the option."""
 
-    default: Any | None = None
+    default: Optional[Any] = None
     """
     The default value of the option. Even though this is optional, it is
     recommended to provide a default value for all options.
     """
-    description: str | None = None
+    description: Optional[str] = None
     """
     An optional description of the option. This is useful for generating help
     messages for the `Options`.
@@ -262,16 +262,16 @@ class Option:
     error to not provide a value for it, either trough a command-line argument,
     an environment variable or a default value.
     """
-    choices: list[Any] | None = None
+    choices: Optional[list[Any]] = None
     """Limits values to a specific set of choices."""
-    additional_attributes: dict[str, Any] | None = None
+    additional_attributes: Optional[dict[str, Any]] = None
     """
     Optional additional attributes for the option. The Nextmv Cloud may
     perform validation on these attributes. For example, the maximum length of
     a string or the maximum value of an integer. These additional attributes
     will be shown in the help message of the `Options`.
     """
-    control_type: str | None = None
+    control_type: Optional[str] = None
     """
     The type of control to use for the option in the Nextmv Cloud UI. This is
     useful for defining how the option should be presented in the Nextmv
@@ -281,13 +281,13 @@ class Option:
     the option. This will be validated by the Nextmv Cloud, and availability
     is based on options_type.
     """
-    hidden_from: list[str] | None = None
+    hidden_from: Optional[list[str]] = None
     """
     A list of team roles for which this option will be hidden in the UI. For
     example, if you want to hide an option from the "operator" role, you can
     pass `hidden_from=["operator"]`.
     """
-    display_name: str | None = None
+    display_name: Optional[str] = None
     """
     An optional display name for the option. This is useful for making
     the option more user-friendly in the UI.
@@ -1032,7 +1032,7 @@ class Options:
         return False
 
     @staticmethod
-    def _option_type(option: Option | Parameter) -> type:
+    def _option_type(option: Union[Option, Parameter]) -> type:
         """
         Get the type of an option.