nextmv 0.29.5.dev1__tar.gz → 0.30.0__tar.gz

{nextmv-0.29.5.dev1 → nextmv-0.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 0.29.5.dev1
+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.30.0/nextmv/__about__.py

@@ -0,0 +1 @@
+__version__ = "v0.30.0"

{nextmv-0.29.5.dev1 → nextmv-0.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-0.29.5.dev1 → nextmv-0.30.0}/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-0.29.5.dev1 → nextmv-0.30.0}/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.
@@ -1130,7 +1266,7 @@ class Application:
         else:
             # Get all input IDs from the input set.
             input_set = self.input_set(input_set_id=input_set_id)
-            if len(input_set.input_ids) == 0:
+            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:
@@ -1248,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,
@@ -1258,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,
@@ -1354,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,
@@ -1722,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 != "":
@@ -2085,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],
@@ -2638,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
         ----------
@@ -2668,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.
@@ -3393,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,
@@ -3419,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:
@@ -3510,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-0.29.5.dev1 → nextmv-0.30.0}/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-0.29.5.dev1 → nextmv-0.30.0}/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.dev1 → nextmv-0.30.0}/tests/cloud/app.yaml

@@ -64,3 +64,12 @@ configuration:
           control_type: select
           hidden_from:
             - operator
+  content:
+    format: "multi-file"
+    multi-file:
+      input:
+        path: "my-inputs"
+      output:
+        statistics: "my-outputs/statistics.json"
+        assets: "my-outputs/assets.json"
+        solutions: "my-outputs/solutions"

{nextmv-0.29.5.dev1 → nextmv-0.30.0}/tests/cloud/test_manifest.py

@@ -2,6 +2,10 @@ import unittest
 
 from nextmv.cloud.manifest import (
     Manifest,
+    ManifestContent,
+    ManifestContentMultiFile,
+    ManifestContentMultiFileInput,
+    ManifestContentMultiFileOutput,
     ManifestOption,
     ManifestOptions,
     ManifestOptionUI,
@@ -154,6 +158,23 @@ class TestManifest(unittest.TestCase):
         )
         self.assertEqual(manifest.configuration.options.format, ["-{{name}}", "{{value}}"])
 
+        self.assertDictEqual(
+            manifest.configuration.content.to_dict(),
+            {
+                "format": "multi-file",
+                "multi-file": {
+                    "input": {
+                        "path": "my-inputs",
+                    },
+                    "output": {
+                        "statistics": "my-outputs/statistics.json",
+                        "assets": "my-outputs/assets.json",
+                        "solutions": "my-outputs/solutions",
+                    },
+                },
+            },
+        )
+
     def test_extract_options(self):
         manifest = Manifest.from_yaml("tests/cloud")
         options = manifest.extract_options()
@@ -243,6 +264,32 @@ class TestManifest(unittest.TestCase):
         self.assertEqual(manifest_options.format, ["-{{name}}", "{{value}}"])
         self.assertEqual(manifest_options.strict, False)
 
+    def test_manifest_content_from_dict(self):
+        manifest_content_dict = {
+            "format": "multi-file",
+            "multi-file": {
+                "input": {
+                    "path": "data/input_data",
+                },
+                "output": {
+                    "statistics": "data/output/stats.json",
+                    "assets": "data/output/assets.json",
+                    "solutions": "data/output/solutions",
+                },
+            },
+        }
+
+        manifest_content = ManifestContent.from_dict(manifest_content_dict)
+
+        self.assertEqual(manifest_content.format, "multi-file")
+        self.assertIsInstance(manifest_content.multi_file, ManifestContentMultiFile)
+        self.assertIsInstance(manifest_content.multi_file.input, ManifestContentMultiFileInput)
+        self.assertIsInstance(manifest_content.multi_file.output, ManifestContentMultiFileOutput)
+        self.assertEqual(manifest_content.multi_file.input.path, "data/input_data")
+        self.assertEqual(manifest_content.multi_file.output.statistics, "data/output/stats.json")
+        self.assertEqual(manifest_content.multi_file.output.assets, "data/output/assets.json")
+        self.assertEqual(manifest_content.multi_file.output.solutions, "data/output/solutions")
+
     def test_from_options_with_validation(self):
         options = Options(
             Option(

nextmv-0.29.5.dev1/nextmv/__about__.py

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