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

nextmv/cloud/client.py

@@ -16,7 +16,7 @@ get_size(obj)
 
 import os
 from dataclasses import dataclass, field
-from typing import IO, Any, Optional, Union
+from typing import IO, Any
 from urllib.parse import urljoin
 
 import requests
@@ -98,7 +98,7 @@ class Client:
     >>> print(response.json())
     """
 
-    api_key: Optional[str] = None
+    api_key: str | None = None
     """API key to use for authenticating with the Nextmv Cloud API. If not
     provided, the client will look for the NEXTMV_API_KEY environment
     variable."""
@@ -117,7 +117,7 @@ class Client:
     seconds."""
     configuration_file: str = "~/.nextmv/config.yaml"
     """Path to the configuration file used by the Nextmv CLI."""
-    headers: Optional[dict[str, str]] = None
+    headers: dict[str, str] | None = None
     """Headers to use for requests to the Nextmv Cloud API."""
     max_retries: int = 10
     """Maximum number of retries to use for requests to the Nextmv Cloud
@@ -196,11 +196,11 @@ class Client:
         self,
         method: str,
         endpoint: str,
-        data: Optional[Any] = None,
-        headers: Optional[dict[str, str]] = None,
-        payload: Optional[dict[str, Any]] = None,
-        query_params: Optional[dict[str, Any]] = None,
-        json_configurations: Optional[dict[str, Any]] = None,
+        data: Any | None = None,
+        headers: dict[str, str] | None = None,
+        payload: dict[str, Any] | None = None,
+        query_params: dict[str, Any] | None = None,
+        json_configurations: dict[str, Any] | None = None,
     ) -> requests.Response:
         """
         Makes a request to the Nextmv Cloud API.
@@ -324,10 +324,10 @@ class Client:
 
     def upload_to_presigned_url(
         self,
-        data: Optional[Union[dict[str, Any], str]],
+        data: dict[str, Any] | str | None,
         url: str,
-        json_configurations: Optional[dict[str, Any]] = None,
-        tar_file: Optional[str] = None,
+        json_configurations: dict[str, Any] | None = None,
+        tar_file: str | None = None,
     ) -> None:
         """
         Uploads data to a presigned URL.
@@ -369,7 +369,7 @@ class Client:
         >>> client.upload_to_presigned_url(data=input_data, url="PRE_SIGNED_URL") # doctest: +SKIP
         """
 
-        upload_data: Optional[str] = None
+        upload_data: str | None = None
         if data is not None:
             if isinstance(data, dict):
                 upload_data = deflated_serialize_json(data, json_configurations=json_configurations)
@@ -433,7 +433,7 @@ class Client:
         }
 
 
-def get_size(obj: Union[dict[str, Any], IO[bytes], str], json_configurations: Optional[dict[str, Any]] = None) -> int:
+def get_size(obj: dict[str, Any] | IO[bytes] | str, json_configurations: dict[str, Any] | None = None) -> int:
     """
     Finds the size of an object in bytes.
 

nextmv/cloud/ensemble.py

@@ -22,7 +22,6 @@ EnsembleDefinition
 
 from datetime import datetime
 from enum import Enum
-from typing import Optional
 
 from nextmv.base_model import BaseModel
 
@@ -56,9 +55,9 @@ class RunGroup(BaseModel):
     """The unique identifier of the run group."""
     instance_id: str
     """ID of the app instance that this run group executes on."""
-    options: Optional[dict] = None
+    options: dict | None = None
     """Runtime options/parameters for the application."""
-    repetitions: Optional[int] = None
+    repetitions: int | None = None
     """The number of times the run is to be repeated on the instance and with
     the options defined in the run group"""
 

nextmv/cloud/input_set.py

@@ -11,7 +11,6 @@ InputSet
 """
 
 from datetime import datetime
-from typing import Optional
 
 from nextmv.base_model import BaseModel
 from nextmv.run import Format
@@ -59,19 +58,19 @@ class ManagedInput(BaseModel):
     id: str
     """ID of the input."""
 
-    name: Optional[str] = None
+    name: str | None = None
     """Name of the input."""
-    description: Optional[str] = None
+    description: str | None = None
     """Description of the input."""
-    run_id: Optional[str] = None
+    run_id: str | None = None
     """ID of the run that created the input."""
-    upload_id: Optional[str] = None
+    upload_id: str | None = None
     """ID of the upload that created the input."""
-    format: Optional[Format] = None
+    format: Format | None = None
     """Format of the input."""
-    created_at: Optional[datetime] = None
+    created_at: datetime | None = None
     """Creation time of the input."""
-    updated_at: Optional[datetime] = None
+    updated_at: datetime | None = None
     """Last update time of the input."""
 
 

nextmv/cloud/instance.py

@@ -13,7 +13,6 @@ Instance
 """
 
 from datetime import datetime
-from typing import Optional
 
 from nextmv.base_model import BaseModel
 
@@ -48,11 +47,11 @@ class InstanceConfiguration(BaseModel):
     ... )
     """
 
-    execution_class: Optional[str] = None
+    execution_class: str | None = None
     """Execution class for the instance."""
-    options: Optional[dict] = None
+    options: dict | None = None
     """Options of the app that the instance uses."""
-    secrets_collection_id: Optional[str] = None
+    secrets_collection_id: str | None = None
     """ID of the secrets collection that the instance uses."""
 
 

nextmv/cloud/package.py

@@ -8,7 +8,6 @@ import shutil
 import subprocess
 import tarfile
 import tempfile
-from typing import Optional
 
 from nextmv.logger import log
 from nextmv.manifest import MANIFEST_FILE_NAME, Manifest, ManifestBuild, ManifestType
@@ -24,8 +23,8 @@ _MANDATORY_FILES_PER_TYPE = {
 def _package(
     app_dir: str,
     manifest: Manifest,
-    model: Optional[Model] = None,
-    model_configuration: Optional[ModelConfiguration] = None,
+    model: Model | None = None,
+    model_configuration: ModelConfiguration | None = None,
     verbose: bool = False,
 ) -> tuple[str, str]:
     """Package the app into a tarball."""
@@ -75,7 +74,7 @@ def _package(
 
 def _run_build_command(
     app_dir: str,
-    manifest_build: Optional[ManifestBuild] = None,
+    manifest_build: ManifestBuild | None = None,
     verbose: bool = False,
 ) -> None:
     """Run the build command specified in the manifest."""
@@ -118,7 +117,7 @@ def _get_shell_command_elements(pre_push_command):
 
 def _run_pre_push_command(
     app_dir: str,
-    pre_push_command: Optional[str] = None,
+    pre_push_command: str | None = None,
     verbose: bool = False,
 ) -> None:
     """Run the pre-push command specified in the manifest."""
@@ -205,8 +204,15 @@ def __find_files(
 def __confirm_mandatory_files(manifest: Manifest, present_files: list[str]) -> None:
     """Confirm that all mandatory files are present in the given list of files."""
 
-    mandatory_files = _MANDATORY_FILES_PER_TYPE[manifest.type]
     found_files = {os.path.normpath(file): True for file in present_files}
+
+    # Check for mandatory files (if a custom execution config is provided we check the
+    # custom entrypoint instead)
+    mandatory_files = []
+    if manifest.execution is None or manifest.execution.entrypoint is None:
+        mandatory_files = _MANDATORY_FILES_PER_TYPE[manifest.type]
+    else:
+        mandatory_files.append(os.path.normpath(manifest.execution.entrypoint))
     missing_files = [file for file in mandatory_files if file not in found_files]
 
     if missing_files:
@@ -217,8 +223,8 @@ def __handle_python(
     app_dir: str,
     temp_dir: str,
     manifest: Manifest,
-    model: Optional[Model] = None,
-    model_configuration: Optional[ModelConfiguration] = None,
+    model: Model | None = None,
+    model_configuration: ModelConfiguration | None = None,
     verbose: bool = False,
 ) -> None:
     """Handles the Python-specific packaging logic."""
@@ -413,10 +419,10 @@ def __confirm_python_version(output: str) -> None:
         except ValueError:
             major, minor = map(int, version.split("."))
 
-        if major == 3 and minor >= 9:
+        if major == 3 and minor >= 10:
             return
 
-    raise Exception("python version 3.9 or higher is required")
+    raise Exception("python version 3.10 or higher is required")
 
 
 def __confirm_python_bundling_version(version: str) -> None:
@@ -425,9 +431,9 @@ def __confirm_python_bundling_version(version: str) -> None:
     match = re_version.fullmatch(version)
     if match:
         major, minor = int(match.group(1)), int(match.group(2))
-        if major == 3 and minor >= 9:
+        if major == 3 and minor >= 10:
             return
-    raise Exception(f"python version 3.9 or higher is required for bundling, got {version}")
+    raise Exception(f"python version 3.10 or higher is required for bundling, got {version}")
 
 
 def __compress_tar(source: str, target: str) -> tuple[str, int]:

nextmv/cloud/scenario.py

@@ -15,7 +15,7 @@ Scenario
 import itertools
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Optional, Union
+from typing import Any
 
 
 @dataclass
@@ -158,11 +158,7 @@ class ScenarioInput:
     Type of input for the scenario. This is used to determine how the input
     should be processed.
     """
-    scenario_input_data: Union[
-        str,  # Input set ID
-        list[str],  # List of Input IDs
-        list[dict[str, Any]],  # Raw data
-    ]
+    scenario_input_data: str | list[str] | list[dict[str, Any]]
     """
     Input data for the scenario. This can be a single input set ID (`str`), a
     list of input IDs (`list[str]`), or raw data (`list[dict[str, Any]]`).
@@ -252,12 +248,12 @@ class Scenario:
     instance_id: str
     """ID of the instance to be used for the scenario."""
 
-    scenario_id: Optional[str] = None
+    scenario_id: str | None = None
     """
     Optional ID of the scenario. The default value will be set as
     `scenario-<index>` if not set.
     """
-    configuration: Optional[list[ScenarioConfiguration]] = None
+    configuration: list[ScenarioConfiguration] | None = None
     """Optional configuration for the scenario. Use this attribute to configure
     variation of options for the scenario.
     """
@@ -300,8 +296,8 @@ class Scenario:
         if self.configuration is None or len(self.configuration) == 0:
             return [{}]
 
-        keys, value_lists = zip(*((config.name, config.values) for config in self.configuration))
-        combinations = [dict(zip(keys, values)) for values in itertools.product(*value_lists)]
+        keys, value_lists = zip(*((config.name, config.values) for config in self.configuration), strict=False)
+        combinations = [dict(zip(keys, values, strict=False)) for values in itertools.product(*value_lists)]
 
         return combinations
 

nextmv/default_app/README.md

@@ -22,11 +22,11 @@ A sample input file is also provided as `input.json`.
 1. Install packages.
 
     ```bash
-    pip3 install -r requirements.txt
+    pip install -r requirements.txt
     ```
 
 2. Run the app.
 
     ```bash
-    cat input.json | python3 main.py
+    cat input.json | python main.py
     ```

nextmv/input.py

@@ -35,7 +35,7 @@ import sys
 from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Optional, Union
+from typing import Any
 
 from nextmv._serialization import serialize_json
 from nextmv.deprecated import deprecated
@@ -155,17 +155,17 @@ class DataFile:
 
     The `loader` function should return the data that will be used in the model.
     """
-    loader_kwargs: Optional[dict[str, Any]] = None
+    loader_kwargs: dict[str, Any] | None = None
     """
     Optional keyword arguments to pass to the loader function. This can be used
     to customize the behavior of the loader.
     """
-    loader_args: Optional[list[Any]] = None
+    loader_args: list[Any] | None = None
     """
     Optional positional arguments to pass to the loader function. This can be
     used to customize the behavior of the loader.
     """
-    input_data_key: Optional[str] = None
+    input_data_key: str | None = None
     """
     Use this parameter to set a custom key to represent your file.
 
@@ -180,8 +180,8 @@ class DataFile:
 
 def json_data_file(
     name: str,
-    json_configurations: Optional[dict[str, Any]] = None,
-    input_data_key: Optional[str] = None,
+    json_configurations: dict[str, Any] | None = None,
+    input_data_key: str | None = None,
 ) -> DataFile:
     """
     This is a convenience function to create a `DataFile` that reads JSON data.
@@ -231,7 +231,7 @@ def json_data_file(
 
     json_configurations = json_configurations or {}
 
-    def loader(file_path: str) -> Union[dict[str, Any], Any]:
+    def loader(file_path: str) -> dict[str, Any] | Any:
         with open(file_path, encoding="utf-8") as f:
             return json.load(f, **json_configurations)
 
@@ -244,8 +244,8 @@ def json_data_file(
 
 def csv_data_file(
     name: str,
-    csv_configurations: Optional[dict[str, Any]] = None,
-    input_data_key: Optional[str] = None,
+    csv_configurations: dict[str, Any] | None = None,
+    input_data_key: str | None = None,
 ) -> DataFile:
     """
     This is a convenience function to create a `DataFile` that reads CSV data.
@@ -306,7 +306,7 @@ def csv_data_file(
     )
 
 
-def text_data_file(name: str, input_data_key: Optional[str] = None) -> DataFile:
+def text_data_file(name: str, input_data_key: str | None = None) -> DataFile:
     """
     This is a convenience function to create a `DataFile` that reads utf-8
     encoded text data.
@@ -408,13 +408,7 @@ class Input:
         If the `input_format` is not one of the supported formats.
     """
 
-    data: Union[
-        Union[dict[str, Any], Any],  # JSON
-        str,  # TEXT
-        list[dict[str, Any]],  # CSV
-        dict[str, list[dict[str, Any]]],  # CSV_ARCHIVE
-        dict[str, Any],  # MULTI_FILE
-    ]
+    data: dict[str, Any] | Any | str | list[dict[str, Any]] | dict[str, list[dict[str, Any]]] | dict[str, Any]
     """
     The actual data.
 
@@ -427,14 +421,14 @@ class Input:
     - For `MULTI_FILE`: `dict[str, Any]`
     """
 
-    input_format: Optional[InputFormat] = InputFormat.JSON
+    input_format: InputFormat | None = InputFormat.JSON
     """
     Format of the input data.
 
     Default is `InputFormat.JSON`.
     """
 
-    options: Optional[Options] = None
+    options: Options | None = None
     """
     Options that the `Input` was created with.
 
@@ -558,7 +552,7 @@ class InputLoader:
     def load(
         self,
         input_format: InputFormat = InputFormat.JSON,
-        options: Optional[Options] = None,
+        options: Options | None = None,
         *args,
         **kwargs,
     ) -> Input:
@@ -636,7 +630,7 @@ class LocalInputLoader(InputLoader):
         with open(path, encoding="utf-8") as f:
             return f.read().rstrip("\n")
 
-    def _read_csv(path: str, csv_configurations: Optional[dict[str, Any]]) -> list[dict[str, Any]]:
+    def _read_csv(path: str, csv_configurations: dict[str, Any] | None) -> list[dict[str, Any]]:
         """
         Read a CSV file and return its contents as a list of dictionaries.
 
@@ -655,7 +649,7 @@ class LocalInputLoader(InputLoader):
         with open(path, encoding="utf-8") as f:
             return list(csv.DictReader(f, **csv_configurations))
 
-    def _read_json(path: str, _) -> Union[dict[str, Any], Any]:
+    def _read_json(path: str, _) -> dict[str, Any] | Any:
         """
         Read a JSON file and return its parsed contents.
 
@@ -704,11 +698,11 @@ class LocalInputLoader(InputLoader):
 
     def load(
         self,
-        input_format: Optional[InputFormat] = InputFormat.JSON,
-        options: Optional[Options] = None,
-        path: Optional[str] = None,
-        csv_configurations: Optional[dict[str, Any]] = None,
-        data_files: Optional[list[DataFile]] = None,
+        input_format: InputFormat | None = InputFormat.JSON,
+        options: Options | None = None,
+        path: str | None = None,
+        csv_configurations: dict[str, Any] | None = None,
+        data_files: list[DataFile] | None = None,
     ) -> Input:
         """
         Load the input data. The input data can be in various formats. For
@@ -789,11 +783,11 @@ class LocalInputLoader(InputLoader):
 
     def _load_utf8_encoded(
         self,
-        csv_configurations: Optional[dict[str, Any]],
-        path: Optional[str] = None,
-        input_format: Optional[InputFormat] = InputFormat.JSON,
+        csv_configurations: dict[str, Any] | None,
+        path: str | None = None,
+        input_format: InputFormat | None = InputFormat.JSON,
         use_file_reader: bool = False,
-    ) -> Union[dict[str, Any], str, list[dict[str, Any]]]:
+    ) -> dict[str, Any] | str | list[dict[str, Any]]:
         """
         Load a utf-8 encoded file from stdin or filesystem.
 
@@ -831,8 +825,8 @@ class LocalInputLoader(InputLoader):
 
     def _load_archive(
         self,
-        csv_configurations: Optional[dict[str, Any]],
-        path: Optional[str] = None,
+        csv_configurations: dict[str, Any] | None,
+        path: str | None = None,
     ) -> dict[str, list[dict[str, Any]]]:
         """
         Load CSV files from a directory.
@@ -887,7 +881,7 @@ class LocalInputLoader(InputLoader):
     def _load_multi_file(
         self,
         data_files: list[DataFile],
-        path: Optional[str] = None,
+        path: str | None = None,
     ) -> dict[str, Any]:
         """
         Load multiple files from a directory.
@@ -961,10 +955,10 @@ class LocalInputLoader(InputLoader):
 
 
 def load_local(
-    input_format: Optional[InputFormat] = InputFormat.JSON,
-    options: Optional[Options] = None,
-    path: Optional[str] = None,
-    csv_configurations: Optional[dict[str, Any]] = None,
+    input_format: InputFormat | None = InputFormat.JSON,
+    options: Options | None = None,
+    path: str | None = None,
+    csv_configurations: dict[str, Any] | None = None,
 ) -> Input:
     """
     !!! warning
@@ -1016,12 +1010,12 @@ _LOCAL_INPUT_LOADER = LocalInputLoader()
 
 
 def load(
-    input_format: Optional[InputFormat] = InputFormat.JSON,
-    options: Optional[Options] = None,
-    path: Optional[str] = None,
-    csv_configurations: Optional[dict[str, Any]] = None,
-    loader: Optional[InputLoader] = _LOCAL_INPUT_LOADER,
-    data_files: Optional[list[DataFile]] = None,
+    input_format: InputFormat | None = InputFormat.JSON,
+    options: Options | None = None,
+    path: str | None = None,
+    csv_configurations: dict[str, Any] | None = None,
+    loader: InputLoader | None = _LOCAL_INPUT_LOADER,
+    data_files: list[DataFile] | None = None,
 ) -> Input:
     """
     Load input data using the specified loader.