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

nextmv/manifest.py

@@ -53,7 +53,7 @@ MANIFEST_FILE_NAME
 
 import os
 from enum import Enum
-from typing import Any, Optional, Union
+from typing import Any
 
 import yaml
 from pydantic import AliasChoices, Field, field_validator
@@ -158,25 +158,17 @@ class ManifestRuntime(str, Enum):
     """
 
     DEFAULT = "ghcr.io/nextmv-io/runtime/default:latest"
-    """This runtime is used to run compiled applications such as Go binaries."""
+    """A runtime used to run compiled applications such as Go binaries."""
     PYTHON = "ghcr.io/nextmv-io/runtime/python:3.11"
-    """
-    This runtime is used as the basis for all other Python runtimes and Python
-    applications.
-    """
+    """A runtime used to run standard Python applications."""
     JAVA = "ghcr.io/nextmv-io/runtime/java:latest"
-    """This runtime is used to run Java applications."""
+    """A runtime used to run Java applications."""
     PYOMO = "ghcr.io/nextmv-io/runtime/pyomo:latest"
-    """This runtime provisions Python packages to run Pyomo applications."""
-    HEXALY = "ghcr.io/nextmv-io/runtime/hexaly:latest"
-    """
-    Based on the python runtime, it provisions (pre-installs) the Hexaly solver
-    to run Python applications.
-    """
+    """A runtime provisioning Python packages to run Pyomo applications."""
     CUOPT = "ghcr.io/nextmv-io/runtime/cuopt:latest"
-    """
-    A runtime providing the NVIDIA cuOpt solver.
-    """
+    """A runtime providing the NVIDIA cuOpt solver."""
+    GAMSPY = "ghcr.io/nextmv-io/runtime/gamspy:latest"
+    """A runtime provisioning the GAMS Python API and supported solvers."""
 
 
 class ManifestPythonArch(str, Enum):
@@ -244,14 +236,14 @@ class ManifestBuild(BaseModel):
     'make build'
     """
 
-    command: Optional[str] = None
+    command: str | None = 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: Optional[dict[str, Any]] = None
+    environment: dict[str, Any] | None = None
     """Environment variables to set when running the build command.
 
     Given as key-value pairs.
@@ -317,7 +309,7 @@ class ManifestPythonModel(BaseModel):
 
     name: str
     """The name of the decision model."""
-    options: Optional[list[dict[str, Any]]] = None
+    options: list[dict[str, Any]] | None = 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 +351,7 @@ class ManifestPython(BaseModel):
     'requirements.txt'
     """
 
-    pip_requirements: Optional[Union[str, list[str]]] = Field(
+    pip_requirements: str | list[str] | None = Field(
         serialization_alias="pip-requirements",
         validation_alias=AliasChoices("pip-requirements", "pip_requirements"),
         default=None,
@@ -371,16 +363,16 @@ class ManifestPython(BaseModel):
     app. Can be either a string path to a requirements.txt file or a list
     of package specifications.
     """
-    arch: Optional[ManifestPythonArch] = None
+    arch: ManifestPythonArch | None = None
     """
     The architecture this model is meant to run on. One of "arm64" or "amd64". Uses
     "arm64" if not specified.
     """
-    version: Optional[Union[str, float]] = None
+    version: str | float | None = None
     """
     The Python version this model is meant to run with. Uses "3.11" if not specified.
     """
-    model: Optional[ManifestPythonModel] = None
+    model: ManifestPythonModel | None = None
     """
     Information about an encoded decision model.
 
@@ -390,7 +382,7 @@ class ManifestPython(BaseModel):
 
     @field_validator("version", mode="before")
     @classmethod
-    def validate_version(cls, v: Optional[Union[str, float]]) -> Optional[str]:
+    def validate_version(cls, v: str | float | None) -> str | None:
         """
         Validate and convert the Python version field to a string.
 
@@ -461,11 +453,11 @@ class ManifestOptionUI(BaseModel):
     'input'
     """
 
-    control_type: Optional[str] = None
+    control_type: str | None = None
     """The type of control to use for the option in the Nextmv Cloud UI."""
-    hidden_from: Optional[list[str]] = None
+    hidden_from: list[str] | None = None
     """A list of team roles for which this option will be hidden in the UI."""
-    display_name: Optional[str] = None
+    display_name: str | None = None
     """An optional display name for the option. This is useful for making
     the option more user-friendly in the UI.
     """
@@ -529,15 +521,15 @@ class ManifestOption(BaseModel):
     )
     """The type of the option (e.g., "string", "int", "bool", "float)."""
 
-    default: Optional[Any] = None
+    default: Any | None = None
     """The default value of the option"""
-    description: Optional[str] = ""
+    description: str | None = ""
     """The description of the option"""
     required: bool = False
     """Whether the option is required or not"""
-    additional_attributes: Optional[dict[str, Any]] = None
+    additional_attributes: dict[str, Any] | None = None
     """Optional additional attributes for the option."""
-    ui: Optional[ManifestOptionUI] = None
+    ui: ManifestOptionUI | None = None
     """Optional UI attributes for the option."""
 
     @classmethod
@@ -727,16 +719,16 @@ class ManifestOptions(BaseModel):
     2
     """
 
-    strict: Optional[bool] = False
+    strict: bool | None = False
     """If strict is set to `True`, only the listed options will be allowed."""
-    validation: Optional[ManifestValidation] = None
+    validation: ManifestValidation | None = None
     """Optional validation rules for all options."""
-    items: Optional[list[ManifestOption]] = None
+    items: list[ManifestOption] | None = None
     """The actual list of options for the decision model.
 
     An option is a parameter that configures the decision model.
     """
-    format: Optional[list[str]] = None
+    format: list[str] | None = 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 +741,7 @@ class ManifestOptions(BaseModel):
         cls,
         options: Options,
         validation: OptionsEnforcement = None,
-        format: Optional[list[str]] = None,
+        format: list[str] | None = None,
     ) -> "ManifestOptions":
         """
         Create a `ManifestOptions` from a `nextmv.Options`.
@@ -853,11 +845,11 @@ class ManifestContentMultiFileOutput(BaseModel):
     'my-outputs/statistics.json'
     """
 
-    statistics: Optional[str] = ""
+    statistics: str | None = ""
     """The path to the statistics file."""
-    assets: Optional[str] = ""
+    assets: str | None = ""
     """The path to the assets file."""
-    solutions: Optional[str] = ""
+    solutions: str | None = ""
     """The path to the solutions directory."""
 
 
@@ -942,7 +934,7 @@ class ManifestContent(BaseModel):
     The format of the content. Can only be `InputFormat.JSON`,
     `InputFormat.MULTI_FILE`, or `InputFormat.CSV_ARCHIVE`.
     """
-    multi_file: Optional[ManifestContentMultiFile] = Field(
+    multi_file: ManifestContentMultiFile | None = Field(
         serialization_alias="multi-file",
         validation_alias=AliasChoices("multi-file", "multi_file"),
         default=None,
@@ -1001,12 +993,46 @@ class ManifestConfiguration(BaseModel):
     'debug_mode'
     """
 
-    options: Optional[ManifestOptions] = None
+    options: ManifestOptions | None = None
     """Options for the decision model."""
-    content: Optional[ManifestContent] = None
+    content: ManifestContent | None = 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.
@@ -1084,7 +1110,7 @@ class Manifest(BaseModel):
     The runtime to use for the app. It provides the environment in which the
     app runs. This is mandatory.
     """
-    python: Optional[ManifestPython] = None
+    python: ManifestPython | None = None
     """
     Python-specific attributes. Only for Python apps. Contains further
     Python-specific attributes.
@@ -1093,12 +1119,12 @@ class Manifest(BaseModel):
         default_factory=list,
     )
     """The files to include (or exclude) in the app. This is mandatory."""
-    configuration: Optional[ManifestConfiguration] = None
+    configuration: ManifestConfiguration | None = 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: Optional[ManifestBuild] = None
+    build: ManifestBuild | None = None
     """
     Build-specific attributes.
 
@@ -1109,7 +1135,7 @@ class Manifest(BaseModel):
     set environment variables when running the build command given as key-value
     pairs.
     """
-    pre_push: Optional[str] = Field(
+    pre_push: str | None = Field(
         serialization_alias="pre-push",
         validation_alias=AliasChoices("pre-push", "pre_push"),
         default=None,
@@ -1124,55 +1150,12 @@ class Manifest(BaseModel):
     process. This command is executed just before the app gets bundled and
     pushed (after the build command).
     """
-    entrypoint: Optional[str] = None
+    execution: ManifestExecution | None = None
     """
-    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`
+    Optional execution configuration for the decision model. Allows configuration of
+    entrypoint and more.
     """
 
-    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":
         """
@@ -1256,7 +1239,7 @@ class Manifest(BaseModel):
                 width=120,
             )
 
-    def extract_options(self, should_parse: bool = True) -> Optional[Options]:
+    def extract_options(self, should_parse: bool = True) -> Options | None:
         """
         Convert the manifest options to a `nextmv.Options` object.
 
@@ -1477,6 +1460,5 @@ 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, Optional
+from typing import Any
 
 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: Optional[list[str]] = None
+    requirements: list[str] | None = None
     """A list of Python dependencies that the decision model requires."""
-    options: Optional[Options] = None
+    options: Options | None = None
     """Options that the decision model requires."""
-    options_enforcement: Optional[OptionsEnforcement] = None
+    options_enforcement: OptionsEnforcement | None = None
     """Enforcement of options for the model."""
 
 
@@ -308,7 +308,7 @@ class Model:
                 self,
                 context,
                 model_input,
-                params: Optional[dict[str, Any]] = None,
+                params: dict[str, Any] | None = 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: Optional[ModelConfiguration] = None,
+    model_configuration: ModelConfiguration | None = 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, Optional, Union
+from typing import Any
 
 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: Optional[Any] = None
+    default: Any | None = None
     """The default value of the parameter. Even though this is optional, it is
     recommended to provide a default value for all parameters."""
-    description: Optional[str] = None
+    description: str | None = 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[Optional[Any]] = None
+    choices: list[Any | None] = 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: Optional[Any] = None
+    default: Any | None = None
     """
     The default value of the option. Even though this is optional, it is
     recommended to provide a default value for all options.
     """
-    description: Optional[str] = None
+    description: str | None = 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: Optional[list[Any]] = None
+    choices: list[Any] | None = None
     """Limits values to a specific set of choices."""
-    additional_attributes: Optional[dict[str, Any]] = None
+    additional_attributes: dict[str, Any] | None = 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: Optional[str] = None
+    control_type: str | None = 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: Optional[list[str]] = None
+    hidden_from: list[str] | None = 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: Optional[str] = None
+    display_name: str | None = 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: Union[Option, Parameter]) -> type:
+    def _option_type(option: Option | Parameter) -> type:
         """
         Get the type of an option.