nextmv 0.29.5.dev0__py3-none-any.whl → 0.30.0__py3-none-any.whl

nextmv/__about__.py

@@ -1 +1 @@
-__version__ = "v0.29.5.dev.0"
+__version__ = "v0.30.0"

nextmv/cloud/__init__.py

@@ -6,7 +6,6 @@ from .acceptance_test import Comparison as Comparison
 from .acceptance_test import ComparisonInstance as ComparisonInstance
 from .acceptance_test import DistributionPercentiles as DistributionPercentiles
 from .acceptance_test import DistributionSummaryStatistics as DistributionSummaryStatistics
-from .acceptance_test import ExperimentStatus as ExperimentStatus
 from .acceptance_test import Metric as Metric
 from .acceptance_test import MetricParams as MetricParams
 from .acceptance_test import MetricResult as MetricResult
@@ -28,6 +27,7 @@ from .batch_experiment import BatchExperiment as BatchExperiment
 from .batch_experiment import BatchExperimentInformation as BatchExperimentInformation
 from .batch_experiment import BatchExperimentMetadata as BatchExperimentMetadata
 from .batch_experiment import BatchExperimentRun as BatchExperimentRun
+from .batch_experiment import ExperimentStatus as ExperimentStatus
 from .client import Client as Client
 from .client import get_size as get_size
 from .input_set import InputSet as InputSet
@@ -37,6 +37,10 @@ from .instance import InstanceConfiguration as InstanceConfiguration
 from .manifest import MANIFEST_FILE_NAME as MANIFEST_FILE_NAME
 from .manifest import Manifest as Manifest
 from .manifest import ManifestBuild as ManifestBuild
+from .manifest import ManifestContent as ManifestContent
+from .manifest import ManifestContentMultiFile as ManifestContentMultiFile
+from .manifest import ManifestContentMultiFileInput as ManifestContentMultiFileInput
+from .manifest import ManifestContentMultiFileOutput as ManifestContentMultiFileOutput
 from .manifest import ManifestOption as ManifestOption
 from .manifest import ManifestPython as ManifestPython
 from .manifest import ManifestPythonModel as ManifestPythonModel

nextmv/cloud/acceptance_test.py

@@ -46,6 +46,7 @@ from enum import Enum
 from typing import Optional
 
 from nextmv.base_model import BaseModel
+from nextmv.cloud.batch_experiment import ExperimentStatus
 
 
 class MetricType(str, Enum):
@@ -249,56 +250,6 @@ class ToleranceType(str, Enum):
     """Relative tolerance type."""
 
 
-class ExperimentStatus(str, Enum):
-    """
-    Status of an acceptance test experiment.
-
-    You can import the `ExperimentStatus` class directly from `cloud`:
-
-    ```python
-    from nextmv.cloud import ExperimentStatus
-    ```
-
-    This enumeration defines the different possible statuses of an experiment
-    underlying an acceptance test.
-
-    Attributes
-    ----------
-    started : str
-        The experiment has started.
-    completed : str
-        The experiment was completed successfully.
-    failed : str
-        The experiment failed.
-    draft : str
-        The experiment is a draft.
-    canceled : str
-        The experiment was canceled.
-    unknown : str
-        The experiment status is unknown.
-
-    Examples
-    --------
-    >>> from nextmv.cloud import ExperimentStatus
-    >>> status = ExperimentStatus.completed
-    >>> status
-    <ExperimentStatus.completed: 'completed'>
-    """
-
-    started = "started"
-    """The experiment has started."""
-    completed = "completed"
-    """The experiment was completed."""
-    failed = "failed"
-    """The experiment failed."""
-    draft = "draft"
-    """The experiment is a draft."""
-    canceled = "canceled"
-    """The experiment was canceled."""
-    unknown = "unknown"
-    """The experiment status is unknown."""
-
-
 class MetricTolerance(BaseModel):
     """
     Tolerance used for a metric in an acceptance test.
@@ -942,7 +893,7 @@ class AcceptanceTest(BaseModel):
     """Creation date of the acceptance test."""
     updated_at: datetime
     """Last update date of the acceptance test."""
-    status: Optional[ExperimentStatus] = ExperimentStatus.unknown
+    status: Optional[ExperimentStatus] = ExperimentStatus.UNKNOWN
     """Status of the acceptance test."""
     results: Optional[AcceptanceTestResults] = None
     """Results of the acceptance test."""

nextmv/cloud/application.py

@@ -40,12 +40,13 @@ import requests
 from nextmv._serialization import deflated_serialize_json
 from nextmv.base_model import BaseModel
 from nextmv.cloud import package
-from nextmv.cloud.acceptance_test import AcceptanceTest, ExperimentStatus, Metric
+from nextmv.cloud.acceptance_test import AcceptanceTest, Metric
 from nextmv.cloud.batch_experiment import (
     BatchExperiment,
     BatchExperimentInformation,
     BatchExperimentMetadata,
     BatchExperimentRun,
+    ExperimentStatus,
     to_runs,
 )
 from nextmv.cloud.client import Client, get_size
@@ -506,6 +507,57 @@ class Application:
 
         return AcceptanceTest.from_dict(response.json())
 
+    def acceptance_test_with_polling(
+        self,
+        acceptance_test_id: str,
+        polling_options: PollingOptions = _DEFAULT_POLLING_OPTIONS,
+    ) -> AcceptanceTest:
+        """
+        Retrieve details of an acceptance test using polling.
+
+        Retrieves the result of an acceptance test. This method polls for the
+        result until the test finishes executing or the polling strategy is
+        exhausted.
+
+        Parameters
+        ----------
+        acceptance_test_id : str
+            ID of the acceptance test to retrieve.
+
+        Returns
+        -------
+        AcceptanceTest
+            The requested acceptance test details.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> test = app.acceptance_test_with_polling("test-123")
+        >>> print(test.name)
+        'My Test'
+        """
+
+        def polling_func() -> tuple[Any, bool]:
+            acceptance_test_result = self.acceptance_test(acceptance_test_id=acceptance_test_id)
+            if acceptance_test_result.status in {
+                ExperimentStatus.COMPLETED,
+                ExperimentStatus.FAILED,
+                ExperimentStatus.DRAFT,
+                ExperimentStatus.CANCELED,
+                ExperimentStatus.DELETE_FAILED,
+            }:
+                return acceptance_test_result, True
+
+            return None, False
+
+        acceptance_test = poll(polling_options=polling_options, polling_func=polling_func)
+
+        return self.acceptance_test(acceptance_test_id=acceptance_test.id)
+
     def batch_experiment(self, batch_id: str) -> BatchExperiment:
         """
         Get a batch experiment.
@@ -539,6 +591,90 @@ class Application:
 
         return BatchExperiment.from_dict(response.json())
 
+    def batch_experiment_metadata(self, batch_id: str) -> BatchExperimentMetadata:
+        """
+        Get metadata for a batch experiment.
+
+        Parameters
+        ----------
+        batch_id : str
+            ID of the batch experiment.
+
+        Returns
+        -------
+        BatchExperimentMetadata
+            The requested batch experiment metadata.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> metadata = app.batch_experiment_metadata("batch-123")
+        >>> print(metadata.name)
+        'My Batch Experiment'
+        """
+
+        response = self.client.request(
+            method="GET",
+            endpoint=f"{self.experiments_endpoint}/batch/{batch_id}/metadata",
+        )
+
+        return BatchExperimentMetadata.from_dict(response.json())
+
+    def batch_experiment_with_polling(
+        self,
+        batch_id: str,
+        polling_options: PollingOptions = _DEFAULT_POLLING_OPTIONS,
+    ) -> BatchExperiment:
+        """
+        Get a batch experiment with polling.
+
+        Retrieves the result of an experiment. This method polls for the result
+        until the experiment finishes executing or the polling strategy is
+        exhausted.
+
+        Parameters
+        ----------
+        batch_id : str
+            ID of the batch experiment.
+
+        Returns
+        -------
+        BatchExperiment
+            The requested batch experiment details.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> batch_exp = app.batch_experiment_with_polling("batch-123")
+        >>> print(batch_exp.name)
+        'My Batch Experiment'
+        """
+
+        def polling_func() -> tuple[Any, bool]:
+            batch_metadata = self.batch_experiment_metadata(batch_id=batch_id)
+            if batch_metadata.status in {
+                ExperimentStatus.COMPLETED,
+                ExperimentStatus.FAILED,
+                ExperimentStatus.DRAFT,
+                ExperimentStatus.CANCELED,
+                ExperimentStatus.DELETE_FAILED,
+            }:
+                return batch_metadata, True
+
+            return None, False
+
+        batch_information = poll(polling_options=polling_options, polling_func=polling_func)
+
+        return self.batch_experiment(batch_id=batch_information.id)
+
     def cancel_run(self, run_id: str) -> None:
         """
         Cancel a run.
@@ -1128,16 +1264,26 @@ class Application:
                     f"batch experiment {id} does not exist, input_set_id must be defined to create a new one"
                 ) from e
         else:
-            runs = [
-                BatchExperimentRun(
-                    instance_id=candidate_instance_id,
-                    input_set_id=input_set_id,
-                ),
-                BatchExperimentRun(
-                    instance_id=baseline_instance_id,
-                    input_set_id=input_set_id,
-                ),
-            ]
+            # Get all input IDs from the input set.
+            input_set = self.input_set(input_set_id=input_set_id)
+            if not input_set.input_ids:
+                raise ValueError(f"input set {input_set_id} does not contain any inputs")
+            runs = []
+            for input_id in input_set.input_ids:
+                runs.append(
+                    BatchExperimentRun(
+                        instance_id=candidate_instance_id,
+                        input_set_id=input_set_id,
+                        input_id=input_id,
+                    )
+                )
+                runs.append(
+                    BatchExperimentRun(
+                        instance_id=baseline_instance_id,
+                        input_set_id=input_set_id,
+                        input_id=input_id,
+                    )
+                )
             batch_experiment_id = self.new_batch_experiment(
                 name=name,
                 description=description,
@@ -1238,7 +1384,8 @@ class Application:
         >>> print(test.status)
         'completed'
         """
-        _ = self.new_acceptance_test(
+
+        acceptance_test = self.new_acceptance_test(
             candidate_instance_id=candidate_instance_id,
             baseline_instance_id=baseline_instance_id,
             id=id,
@@ -1248,20 +1395,10 @@ class Application:
             description=description,
         )
 
-        def polling_func() -> tuple[AcceptanceTest, bool]:
-            test_information = self.acceptance_test(acceptance_test_id=id)
-            if test_information.status in [
-                ExperimentStatus.completed,
-                ExperimentStatus.failed,
-                ExperimentStatus.canceled,
-            ]:
-                return test_information, True
-
-            return None, False
-
-        test_information = poll(polling_options=polling_options, polling_func=polling_func)
-
-        return test_information
+        return self.acceptance_test_with_polling(
+            acceptance_test_id=acceptance_test.id,
+            polling_options=polling_options,
+        )
 
     def new_batch_experiment(
         self,
@@ -1344,6 +1481,76 @@ class Application:
 
         return response.json()["id"]
 
+    def new_batch_experiment_with_result(
+        self,
+        name: str,
+        input_set_id: Optional[str] = None,
+        instance_ids: Optional[list[str]] = None,
+        description: Optional[str] = None,
+        id: Optional[str] = None,
+        option_sets: Optional[dict[str, dict[str, str]]] = None,
+        runs: Optional[list[Union[BatchExperimentRun, dict[str, Any]]]] = None,
+        type: Optional[str] = "batch",
+        polling_options: PollingOptions = _DEFAULT_POLLING_OPTIONS,
+    ) -> BatchExperiment:
+        """
+        Convenience method to create a new batch experiment and poll for the
+        result.
+
+        This method combines the `new_batch_experiment` and
+        `batch_experiment_with_polling` methods, applying polling logic to
+        check when the experiment succeeded.
+
+        Parameters
+        ----------
+        name: str
+            Name of the batch experiment.
+        input_set_id: str
+            ID of the input set to use for the batch experiment.
+        instance_ids: list[str]
+            List of instance IDs to use for the batch experiment. This argument
+            is deprecated, use `runs` instead.
+        description: Optional[str]
+            Optional description of the batch experiment.
+        id: Optional[str]
+            ID of the batch experiment. Will be generated if not provided.
+        option_sets: Optional[dict[str, dict[str, str]]]
+            Option sets to use for the batch experiment. This is a dictionary
+            where the keys are option set IDs and the values are dictionaries
+            with the actual options.
+        runs: Optional[list[BatchExperimentRun]]
+            List of runs to use for the batch experiment.
+        type: Optional[str]
+            Type of the batch experiment. This is used to determine the
+            experiment type. The default value is "batch". If you want to
+            create a scenario test, set this to "scenario".
+        polling_options : PollingOptions, default=_DEFAULT_POLLING_OPTIONS
+            Options to use when polling for the batch experiment result.
+
+        Returns
+        -------
+        BatchExperiment
+            The completed batch experiment with results.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        """
+
+        batch_id = self.new_batch_experiment(
+            name=name,
+            input_set_id=input_set_id,
+            instance_ids=instance_ids,
+            description=description,
+            id=id,
+            option_sets=option_sets,
+            runs=runs,
+            type=type,
+        )
+
+        return self.batch_experiment_with_polling(batch_id=batch_id, polling_options=polling_options)
+
     def new_input_set(
         self,
         id: str,
@@ -1712,7 +1919,7 @@ class Application:
             not `JSON`. If the final `options` are not of type `dict[str,str]`.
         """
 
-        self.__validate_dir_path_and_configuration(input_dir_path, configuration)
+        self.__validate_input_dir_path_and_configuration(input_dir_path, configuration)
 
         tar_file = ""
         if input_dir_path is not None and input_dir_path != "":
@@ -2075,6 +2282,69 @@ class Application:
             runs=runs,
         )
 
+    def new_scenario_test_with_result(
+        self,
+        id: str,
+        name: str,
+        scenarios: list[Scenario],
+        description: Optional[str] = None,
+        repetitions: Optional[int] = 0,
+        polling_options: PollingOptions = _DEFAULT_POLLING_OPTIONS,
+    ) -> BatchExperiment:
+        """
+        Convenience method to create a new scenario test and poll for the
+        result.
+
+        This method combines the `new_scenario_test` and
+        `scenario_test_with_polling` methods, applying polling logic to
+        check when the test succeeded.
+
+        The scenario tests uses the batch experiments API under the hood.
+
+        Parameters
+        ----------
+        id: str
+            ID of the scenario test.
+        name: str
+            Name of the scenario test.
+        scenarios: list[Scenario]
+            List of scenarios to use for the scenario test. At least one
+            scenario should be provided.
+        description: Optional[str]
+            Optional description of the scenario test.
+        repetitions: Optional[int]
+            Number of repetitions to use for the scenario test. 0
+            repetitions means that the tests will be executed once. 1
+            repetition means that the test will be repeated once, i.e.: it
+            will be executed twice. 2 repetitions equals 3 executions, so on,
+            and so forth.
+
+        Returns
+        -------
+        BatchExperiment
+            The completed scenario test as a BatchExperiment.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        ValueError
+            If no scenarios are provided.
+        """
+
+        test_id = self.new_scenario_test(
+            id=id,
+            name=name,
+            scenarios=scenarios,
+            description=description,
+            repetitions=repetitions,
+        )
+
+        return self.scenario_test_with_polling(
+            scenario_test_id=test_id,
+            polling_options=polling_options,
+        )
+
     def new_secrets_collection(
         self,
         secrets: list[Secret],
@@ -2628,9 +2898,9 @@ class Application:
         """
         Get a scenario test.
 
-        Retrieves a scenario test by ID. Scenario tests are based on batch experiments,
-        so this function returns the corresponding batch experiment associated with
-        the scenario test.
+        Retrieves a scenario test by ID. Scenario tests are based on batch
+        experiments, so this function returns the corresponding batch
+        experiment associated with the scenario test.
 
         Parameters
         ----------
@@ -2658,6 +2928,82 @@ class Application:
 
         return self.batch_experiment(batch_id=scenario_test_id)
 
+    def scenario_test_metadata(self, scenario_test_id: str) -> BatchExperimentMetadata:
+        """
+        Get the metadata for a scenario test, given its ID.
+
+        Scenario tests are based on batch experiments, so this function returns
+        the corresponding batch experiment metadata associated with the
+        scenario test.
+
+        Parameters
+        ----------
+        scenario_test_id : str
+            ID of the scenario test to retrieve.
+
+        Returns
+        -------
+        BatchExperimentMetadata
+            The scenario test metadata as a batch experiment.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> metadata = app.scenario_test_metadata("scenario-123")
+        >>> print(metadata.name)
+        'My Scenario Test'
+        >>> print(metadata.type)
+        'scenario'
+        """
+
+        return self.batch_experiment_metadata(batch_id=scenario_test_id)
+
+    def scenario_test_with_polling(
+        self,
+        scenario_test_id: str,
+        polling_options: PollingOptions = _DEFAULT_POLLING_OPTIONS,
+    ) -> BatchExperiment:
+        """
+        Get a scenario test with polling.
+
+        Retrieves the result of a scenario test. This method polls for the
+        result until the test finishes executing or the polling strategy is
+        exhausted.
+
+        The scenario tests uses the batch experiments API under the hood.
+
+        Parameters
+        ----------
+        scenario_test_id : str
+            ID of the scenario test to retrieve.
+        polling_options : PollingOptions, default=_DEFAULT_POLLING_OPTIONS
+            Options to use when polling for the scenario test result.
+
+        Returns
+        -------
+        BatchExperiment
+            The scenario test details as a batch experiment.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> test = app.scenario_test_with_polling("scenario-123")
+        >>> print(test.name)
+        'My Scenario Test'
+        >>> print(test.type)
+        'scenario'
+        """
+
+        return self.batch_experiment_with_polling(batch_id=scenario_test_id, polling_options=polling_options)
+
     def track_run(self, tracked_run: TrackedRun, instance_id: Optional[str] = None) -> str:
         """
         Track an external run.
@@ -3383,6 +3729,47 @@ class Application:
 
         return result
 
+    @staticmethod
+    def __convert_manifest_to_payload(manifest: Manifest) -> dict[str, Any]:
+        """Converts a manifest to a payload dictionary for the API."""
+
+        activation_request = {
+            "requirements": {
+                "executable_type": manifest.type,
+                "runtime": manifest.runtime,
+            },
+        }
+
+        if manifest.configuration is not None and manifest.configuration.content is not None:
+            content = manifest.configuration.content
+            io_config = {
+                "format": content.format,
+            }
+            if content.multi_file is not None:
+                multi_config = io_config["multi_file"] = {}
+                if content.multi_file.input is not None:
+                    multi_config["input_path"] = content.multi_file.input.path
+                if content.multi_file.output is not None:
+                    output_config = multi_config["output_configuration"] = {}
+                    if content.multi_file.output.statistics:
+                        output_config["statistics_path"] = content.multi_file.output.statistics
+                    if content.multi_file.output.assets:
+                        output_config["assets_path"] = content.multi_file.output.assets
+                    if content.multi_file.output.solutions:
+                        output_config["solutions_path"] = content.multi_file.output.solutions
+            activation_request["requirements"]["io_configuration"] = io_config
+
+        if manifest.configuration is not None and manifest.configuration.options is not None:
+            options = manifest.configuration.options.to_dict()
+            if "format" in options and isinstance(options["format"], list):
+                # the endpoint expects a dictionary with a template key having a list of strings
+                # the app.yaml however defines format as a list of strings, so we need to convert it here
+                options["format"] = {
+                    "template": options["format"],
+                }
+            activation_request["requirements"]["options"] = options
+        return activation_request
+
     def __update_app_binary(
         self,
         tar_file: str,
@@ -3409,27 +3796,10 @@ class Application:
                 headers={"Content-Type": "application/octet-stream"},
             )
 
-        activation_request = {
-            "requirements": {
-                "executable_type": manifest.type,
-                "runtime": manifest.runtime,
-            },
-        }
-
-        if manifest.configuration is not None and manifest.configuration.options is not None:
-            options = manifest.configuration.options.to_dict()
-            if "format" in options and isinstance(options["format"], list):
-                # the endpoint expects a dictionary with a template key having a list of strings
-                # the app.yaml however defines format as a list of strings, so we need to convert it here
-                options["format"] = {
-                    "template": options["format"],
-                }
-            activation_request["requirements"]["options"] = options
-
         response = self.client.request(
             method="PUT",
             endpoint=endpoint,
-            payload=activation_request,
+            payload=Application.__convert_manifest_to_payload(manifest=manifest),
         )
 
         if verbose:
@@ -3500,37 +3870,29 @@ class Application:
 
         raise ValueError(f"Unknown scenario input type: {scenario.scenario_input.scenario_input_type}")
 
-    def __validate_dir_path_and_configuration(
+    def __validate_input_dir_path_and_configuration(
         self,
-        dir_path: Optional[str],
+        input_dir_path: Optional[str],
         configuration: Optional[RunConfiguration],
     ) -> None:
         """
         Auxiliary function to validate the directory path and configuration.
         """
-        if dir_path is None or dir_path == "":
+        if (
+            configuration is None
+            or configuration.format is None
+            or configuration.format.format_input is None
+            or configuration.format.format_input.input_type is None
+        ):
+            # No explicit input type set, so we cannot confirm it.
             return
 
-        if configuration is None:
-            raise ValueError(
-                "If dir_path is provided, a RunConfiguration must also be provided.",
-            )
-
-        if configuration.format is None:
-            raise ValueError(
-                "If dir_path is provided, RunConfiguration.format must also be provided.",
-            )
-
-        if configuration.format.format_input is None:
-            raise ValueError(
-                "If dir_path is provided, RunConfiguration.format.format_input must also be provided.",
-            )
-
         input_type = configuration.format.format_input.input_type
-        if input_type is None or input_type in (InputFormat.JSON, InputFormat.TEXT):
+        dir_types = (InputFormat.MULTI_FILE, InputFormat.CSV_ARCHIVE)
+        if input_type in dir_types and not input_dir_path:
             raise ValueError(
-                "If dir_path is provided, RunConfiguration.format.format_input.input_type must be set to a valid type."
-                f"Valid types are: {[InputFormat.CSV_ARCHIVE, InputFormat.MULTI_FILE]}",
+                f"If RunConfiguration.format.format_input.input_type is set to {input_type}, "
+                "then input_dir_path must be provided.",
             )
 
     def __package_inputs(self, dir_path: str) -> str:

nextmv/cloud/batch_experiment.py

@@ -3,6 +3,8 @@ This module contains definitions for batch experiments.
 
 Classes
 -------
+ExperimentStatus
+    Enum representing the status of an experiment.
 BatchExperimentInformation
     Base class for all batch experiment models containing common information.
 BatchExperiment
@@ -14,12 +16,82 @@ BatchExperimentMetadata
 """
 
 from datetime import datetime
+from enum import Enum
 from typing import Any, Optional
 
 from nextmv.base_model import BaseModel
 from nextmv.cloud.input_set import InputSet
 
 
+class ExperimentStatus(str, Enum):
+    """
+    Status of an experiment.
+
+    You can import the `ExperimentStatus` class directly from `cloud`:
+
+    ```python from nextmv.cloud import ExperimentStatus ```
+
+    This enum represents the comprehensive set of possible states for an
+    experiment in Nextmv Cloud.
+
+    Attributes
+    ----------
+    STARTED : str
+        Experiment started.
+    COMPLETED : str
+        Experiment completed.
+    FAILED : str
+        Experiment failed.
+    DRAFT : str
+        Experiment is a draft.
+    CANCELED : str
+        Experiment was canceled.
+    STOPPING : str
+        Experiment is stopping.
+    DELETING : str
+        Experiment is being deleted.
+    DELETE_FAILED : str
+        Experiment deletion failed.
+    UNKNOWN : str
+        Experiment status is unknown.
+
+    Examples
+    --------
+    >>> from nextmv.cloud import ExperimentStatus
+    >>> status = ExperimentStatus.STARTED
+    >>> print(f"The status is: {status.value}")
+    The status is: started
+
+    >>> if status == ExperimentStatus.COMPLETED:
+    ...     print("Processing complete.")
+    ... elif status in [ExperimentStatus.STARTED, ExperimentStatus.STOPPING]:
+    ...     print("Processing in progress.")
+    ... else:
+    ...     print("Processing has not started or has ended with issues.")
+    Processing in progress.
+
+    """
+
+    STARTED = "started"
+    """Experiment started."""
+    COMPLETED = "completed"
+    """Experiment completed."""
+    FAILED = "failed"
+    """Experiment failed."""
+    DRAFT = "draft"
+    """Experiment is a draft."""
+    CANCELED = "canceled"
+    """Experiment was canceled."""
+    STOPPING = "stopping"
+    """Experiment is stopping."""
+    DELETING = "deleting"
+    """Experiment is being deleted."""
+    DELETE_FAILED = "delete-failed"
+    """Experiment deletion failed."""
+    UNKNOWN = "unknown"
+    """Experiment status is unknown."""
+
+
 class BatchExperimentInformation(BaseModel):
     """Information about a batch experiment.
 
@@ -83,7 +155,7 @@ class BatchExperimentInformation(BaseModel):
     updated_at: datetime
     """Last update date of the batch experiment."""
 
-    status: Optional[str] = None
+    status: Optional[ExperimentStatus] = None
     """Status of the batch experiment."""
     description: Optional[str] = None
     """Description of the batch experiment."""

nextmv/cloud/manifest.py

@@ -43,6 +43,7 @@ import yaml
 from pydantic import AliasChoices, Field
 
 from nextmv.base_model import BaseModel
+from nextmv.input import InputFormat
 from nextmv.model import _REQUIREMENTS_FILE, ModelConfiguration
 from nextmv.options import Option, Options, OptionsEnforcement
 
@@ -692,6 +693,166 @@ class ManifestOptions(BaseModel):
         )
 
 
+class ManifestContentMultiFileInput(BaseModel):
+    """
+    Configuration for multi-file content format input.
+
+    You can import the `ManifestContentMultiFileInput` class directly from `cloud`:
+
+    ```python
+    from nextmv.cloud import ManifestContentMultiFileInput
+    ```
+
+    Parameters
+    ----------
+    path : str
+        The path to the input file or directory.
+
+
+    Examples
+    --------
+    >>> from nextmv.cloud import ManifestContentMultiFileInput
+    >>> input_config = ManifestContentMultiFileInput(path="data/input/")
+    >>> input_config.path
+    'data/input/'
+    """
+
+    path: str
+    """The path to the input file or directory."""
+
+
+class ManifestContentMultiFileOutput(BaseModel):
+    """
+    Configuration for multi-file content format output.
+
+    You can import the `ManifestContentMultiFileOutput` class directly from `cloud`:
+
+    ```python
+    from nextmv.cloud import ManifestContentMultiFileOutput
+    ```
+
+    Parameters
+    ----------
+    statistics : Optional[str], default=""
+        The path to the statistics file.
+    assets : Optional[str], default=""
+        The path to the assets file.
+    solutions : Optional[str], default=""
+        The path to the solutions directory.
+
+    Examples
+    --------
+    >>> from nextmv.cloud import ManifestContentMultiFileOutput
+    >>> output_config = ManifestContentMultiFileOutput(
+    ...     statistics="my-outputs/statistics.json",
+    ...     assets="my-outputs/assets.json",
+    ...     solutions="my-outputs/solutions/"
+    ... )
+    >>> output_config.statistics
+    'my-outputs/statistics.json'
+    """
+
+    statistics: Optional[str] = ""
+    """The path to the statistics file."""
+    assets: Optional[str] = ""
+    """The path to the assets file."""
+    solutions: Optional[str] = ""
+    """The path to the solutions directory."""
+
+
+class ManifestContentMultiFile(BaseModel):
+    """
+    Configuration for multi-file content format.
+
+    You can import the `ManifestContentMultiFile` class directly from `cloud`:
+
+    ```python
+    from nextmv.cloud import ManifestContentMultiFile
+    ```
+
+    Parameters
+    ----------
+    input : ManifestContentMultiFileInput
+        Configuration for multi-file content format input.
+    output : ManifestContentMultiFileOutput
+        Configuration for multi-file content format output.
+
+    Examples
+    --------
+    >>> from nextmv.cloud import ManifestContentMultiFile, ManifestContentMultiFileInput, ManifestContentMultiFileOutput
+    >>> multi_file_config = ManifestContentMultiFile(
+    ...     input=ManifestContentMultiFileInput(path="data/input/"),
+    ...     output=ManifestContentMultiFileOutput(
+    ...         statistics="my-outputs/statistics.json",
+    ...         assets="my-outputs/assets.json",
+    ...         solutions="my-outputs/solutions/"
+    ...     )
+    ... )
+    >>> multi_file_config.input.path
+    'data/input/'
+
+    """
+
+    input: ManifestContentMultiFileInput
+    """Configuration for multi-file content format input."""
+    output: ManifestContentMultiFileOutput
+    """Configuration for multi-file content format output."""
+
+
+class ManifestContent(BaseModel):
+    """
+    Content configuration for specifying how the app input/output is handled.
+
+    You can import the `ManifestContent` class directly from `cloud`:
+
+    ```python
+    from nextmv.cloud import ManifestContent
+    ```
+
+    Parameters
+    ----------
+    format : str
+        The format of the content. Must be one of "json", "multi-file", or "csv-archive".
+    multi_file : Optional[ManifestContentMultiFile], default=None
+        Configuration for multi-file content format.
+
+    Examples
+    --------
+    >>> from nextmv.cloud import ManifestContent
+    >>> content_config = ManifestContent(
+    ...     format="multi-file",
+    ...     multi_file=ManifestContentMultiFile(
+    ...         input=ManifestContentMultiFileInput(path="data/input/"),
+    ...         output=ManifestContentMultiFileOutput(
+    ...             statistics="my-outputs/statistics.json",
+    ...             assets="my-outputs/assets.json",
+    ...             solutions="my-outputs/solutions/"
+    ...         )
+    ...     )
+    ... )
+    >>> content_config.format
+    'multi-file'
+    >>> content_config.multi_file.input.path
+    'data/input/'
+    """
+
+    format: str
+    """The format of the content. Must be one of "json", "multi-file",
+    or "csv-archive"."""
+    multi_file: Optional[ManifestContentMultiFile] = Field(
+        serialization_alias="multi-file",
+        validation_alias=AliasChoices("multi-file", "multi_file"),
+        default=None,
+    )
+    """Configuration for multi-file content format."""
+
+    def __post_init__(self):
+        """Post-initialization to validate fields."""
+        acceptable_formats = [InputFormat.JSON, InputFormat.MULTI_FILE, InputFormat.CSV_ARCHIVE]
+        if self.format not in acceptable_formats:
+            raise ValueError(f"Invalid format: {self.format}. Must be one of {acceptable_formats}.")
+
+
 class ManifestConfiguration(BaseModel):
     """
     Configuration for the decision model.
@@ -719,8 +880,10 @@ class ManifestConfiguration(BaseModel):
     'debug_mode'
     """
 
-    options: ManifestOptions
+    options: Optional[ManifestOptions] = None
     """Options for the decision model."""
+    content: Optional[ManifestContent] = None
+    """Content configuration for specifying how the app input/output is handled."""
 
 
 class Manifest(BaseModel):

{nextmv-0.29.5.dev0.dist-info → nextmv-0.30.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 0.29.5.dev0
+Version: 0.30.0
 Summary: The all-purpose Python SDK for Nextmv
 Project-URL: Homepage, https://www.nextmv.io
 Project-URL: Documentation, https://nextmv-py.docs.nextmv.io/en/latest/nextmv/

{nextmv-0.29.5.dev0.dist-info → nextmv-0.30.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-nextmv/__about__.py,sha256=fH2N4VgXGHNLupMl8aEtSxm93zKJU7HumfTMlmPMKeE,30
+nextmv/__about__.py,sha256=H8hgPHcuzgkrGO2GGQ5Y3l4LsP7LZV6CTj_oh10CuwM,24
 nextmv/__entrypoint__.py,sha256=dA0iwwHtrq6Z9w9FxmxKLoBGLyhe7jWtUAU-Y3PEgHg,1094
 nextmv/__init__.py,sha256=FsF0pEkOSBuPY5EKu7NsBxro7jswGmOmaw61kZEudXY,1930
 nextmv/_serialization.py,sha256=JlSl6BL0M2Esf7F89GsGIZ__Pp8RnFRNM0UxYhuuYU4,2853
@@ -9,15 +9,15 @@ nextmv/logger.py,sha256=kNIbu46MisrzYe4T0hNMpWfRTKKacDVvbtQcNys_c_E,2513
 nextmv/model.py,sha256=vI3pSV3iTwjRPflar7nAg-6h98XRUyi9II5O2J06-Kc,15018
 nextmv/options.py,sha256=yPJu5lYMbV6YioMwAXv7ctpZUggLXKlZc9CqIbUFvE4,37895
 nextmv/output.py,sha256=vcBqtP1hJLYyUvfk_vl1Ejbk3q5KxOmlTz4Lnqqnyd0,54141
-nextmv/cloud/__init__.py,sha256=cGRkIcn1evTdgw7lEH2k4MPTZnq37XIF3ovbuDjUWGI,3914
-nextmv/cloud/acceptance_test.py,sha256=Bcfdmh2fkPeBx8FDCngeUo2fjV_LhsUdygnzDQCDbYY,26898
+nextmv/cloud/__init__.py,sha256=R3jlvQiSbtEP26VdfLdHfvwoaXzT7HaiAs1BG_jJKi4,4219
+nextmv/cloud/acceptance_test.py,sha256=1IQ2w7Imu_NAKknLQYNIIV9i_XIf8tmNHVTAOBEtsU8,25675
 nextmv/cloud/account.py,sha256=eukiYQha4U2fkIjg4SgdoawKE1kU5G7GPyDJVrn8hHA,6064
-nextmv/cloud/application.py,sha256=P5LYXNYlaJYTZiCbJxxG3pvT6KLHS8ZK8HO1R46Lju4,130127
-nextmv/cloud/batch_experiment.py,sha256=Rmcwe1uAVz2kRrAMQqLYC5d__L_IqPXbF__RE3uQTAY,8196
+nextmv/cloud/application.py,sha256=wjZoc7wcKdVJG0trNvAnK49oKyZu0vUw4d4hxzsSEJg,142433
+nextmv/cloud/batch_experiment.py,sha256=UQBPX9YwPlaNh8wnI-HTj5VVwK164bfPTElTRy3fdng,10182
 nextmv/cloud/client.py,sha256=E0DiUb377jvEnpXlRnfT1PGCI0Jm0lTUoX5VqeU91lk,18165
 nextmv/cloud/input_set.py,sha256=2dqmf5z-rZjTKwtBRvnUdfPfKv28It5uTCX0C70uP4Y,4242
 nextmv/cloud/instance.py,sha256=SS4tbp0LQMWDaeYpwcNxJei82oi_Hozv1t5i3QGjASY,4024
-nextmv/cloud/manifest.py,sha256=5FqXtT1q7qmyQxqB5rG33y97WFZ6erL1f9kRel575RQ,37456
+nextmv/cloud/manifest.py,sha256=vHJupSW_yIng3xmc8gbB5kdAN-YQz_lcRW9JvnP5IIo,42604
 nextmv/cloud/package.py,sha256=f0OjdlIOsI2LpmgSxdFf6YaA8Ucs9yAm_3bO0Cp8LH4,13027
 nextmv/cloud/run.py,sha256=-I1S5fLIFLH1P9xViv5bOS2LbO9-w6tnB8cBGU0_yTo,22743
 nextmv/cloud/safe.py,sha256=hWh_quD2KSazTV5SOAddOsFLsY4oWBzajOUcCeHOjc8,3180
@@ -31,7 +31,7 @@ nextmv/default_app/requirements.txt,sha256=wRE_HkYYWzCGnYZ2NuatHXul4gCHvU3iUAdsx
 nextmv/default_app/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nextmv/default_app/src/main.py,sha256=HlO8UwZbZYiAQyrZDSR_T4NBcwP1gIjdTdwkJP_dn8I,847
 nextmv/default_app/src/visuals.py,sha256=WYK_YBnLmYo3TpVev1CpoNCuW5R7hk9QIkeCmvMn1Fs,1014
-nextmv-0.29.5.dev0.dist-info/METADATA,sha256=JOL30ADklPJ0SrmbxPzQvq1J8x15ETOJJU1H5J6amHg,15831
-nextmv-0.29.5.dev0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nextmv-0.29.5.dev0.dist-info/licenses/LICENSE,sha256=ZIbK-sSWA-OZprjNbmJAglYRtl5_K4l9UwAV3PGJAPc,11349
-nextmv-0.29.5.dev0.dist-info/RECORD,,
+nextmv-0.30.0.dist-info/METADATA,sha256=fpdXuFMp9Xw36D5Cnn0CwMjRWEWSCa2KR_QMhsz7d0E,15826
+nextmv-0.30.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nextmv-0.30.0.dist-info/licenses/LICENSE,sha256=ZIbK-sSWA-OZprjNbmJAglYRtl5_K4l9UwAV3PGJAPc,11349
+nextmv-0.30.0.dist-info/RECORD,,