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

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.