nextmv 0.25.0__tar.gz → 0.26.1__tar.gz

{nextmv-0.25.0 → nextmv-0.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 0.25.0
+Version: 0.26.1
 Summary: The all-purpose Python SDK for Nextmv
 Project-URL: Homepage, https://www.nextmv.io
 Project-URL: Documentation, https://www.nextmv.io/docs/python-sdks/nextmv/installation

nextmv-0.26.1/nextmv/__about__.py

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

{nextmv-0.25.0 → nextmv-0.26.1}/nextmv/cloud/__init__.py

@@ -53,6 +53,7 @@ from .run import RunType as RunType
 from .run import RunTypeConfiguration as RunTypeConfiguration
 from .run import TrackedRun as TrackedRun
 from .run import TrackedRunStatus as TrackedRunStatus
+from .run import run_duration as run_duration
 from .scenario import Scenario as Scenario
 from .scenario import ScenarioConfiguration as ScenarioConfiguration
 from .scenario import ScenarioInput as ScenarioInput

{nextmv-0.25.0 → nextmv-0.26.1}/nextmv/cloud/application.py

@@ -14,7 +14,12 @@ import requests
 from nextmv.base_model import BaseModel
 from nextmv.cloud import package
 from nextmv.cloud.acceptance_test import AcceptanceTest, ExperimentStatus, Metric
-from nextmv.cloud.batch_experiment import BatchExperiment, BatchExperimentMetadata, BatchExperimentRun
+from nextmv.cloud.batch_experiment import (
+    BatchExperiment,
+    BatchExperimentInformation,
+    BatchExperimentMetadata,
+    BatchExperimentRun,
+)
 from nextmv.cloud.client import Client, get_size
 from nextmv.cloud.input_set import InputSet, ManagedInput
 from nextmv.cloud.instance import Instance, InstanceConfiguration
@@ -312,18 +317,7 @@ class Application:
             # If the request was successful, the application exists.
             return True
         except requests.HTTPError as e:
-            if (
-                # Check whether the error is caused by a 404 status code - meaning the app does not exist.
-                (hasattr(e, "response") and hasattr(e.response, "status_code") and e.response.status_code == 404)
-                or
-                # Check a possibly nested exception as well.
-                (
-                    hasattr(e, "__cause__")
-                    and hasattr(e.__cause__, "response")
-                    and hasattr(e.__cause__.response, "status_code")
-                    and e.__cause__.response.status_code == 404
-                )
-            ):
+            if _is_not_exist_error(e):
                 return False
             # Re-throw the exception if it is not the expected 404 error.
             raise e from None
@@ -370,6 +364,25 @@ class Application:
 
         return Instance.from_dict(response.json())
 
+    def instance_exists(self, instance_id: str) -> bool:
+        """
+        Check if an instance exists.
+
+        Args:
+            instance_id: ID of the instance.
+
+        Returns:
+            True if the instance exists, False otherwise.
+        """
+
+        try:
+            self.instance(instance_id=instance_id)
+            return True
+        except requests.HTTPError as e:
+            if _is_not_exist_error(e):
+                return False
+            raise e
+
     def list_acceptance_tests(self) -> list[AcceptanceTest]:
         """
         List all acceptance tests.
@@ -576,6 +589,8 @@ class Application:
             id: ID of the application. Will be generated if not provided.
             description: Description of the application.
             is_workflow: Whether the application is a Decision Workflow.
+            exist_ok: If True and an application with the same ID already exists,
+                return the existing application instead of creating a new one.
 
         Returns:
             The new application.
@@ -927,6 +942,7 @@ class Application:
         name: str,
         description: Optional[str] = None,
         configuration: Optional[InstanceConfiguration] = None,
+        exist_ok: bool = False,
     ) -> Instance:
         """
         Create a new instance and associate it with a version.
@@ -937,6 +953,8 @@ class Application:
             name: Name of the instance. Will be generated if not provided.
             description: Description of the instance. Will be generated if not provided.
             configuration: Configuration to use for the instance.
+            exist_ok: If True and an instance with the same ID already exists,
+                return the existing instance instead of creating a new one.
 
         Returns:
             Instance.
@@ -945,6 +963,12 @@ class Application:
             requests.HTTPError: If the response status code is not 2xx.
         """
 
+        if exist_ok and id is None:
+            raise ValueError("If exist_ok is True, id must be provided")
+
+        if exist_ok and self.instance_exists(instance_id=id):
+            return self.instance(instance_id=id)
+
         payload = {
             "version_id": version_id,
         }
@@ -1473,6 +1497,7 @@ class Application:
         id: Optional[str] = None,
         name: Optional[str] = None,
         description: Optional[str] = None,
+        exist_ok: bool = False,
     ) -> Version:
         """
         Create a new version using the current dev binary.
@@ -1481,6 +1506,8 @@ class Application:
             id: ID of the version. Will be generated if not provided.
             name: Name of the version. Will be generated if not provided.
             description: Description of the version. Will be generated if not provided.
+            exist_ok: If True and a version with the same ID already exists,
+                return the existing version instead of creating a new one.
 
         Returns:
             Version.
@@ -1489,6 +1516,12 @@ class Application:
             requests.HTTPError: If the response status code is not 2xx.
         """
 
+        if exist_ok and id is None:
+            raise ValueError("If exist_ok is True, id must be provided")
+
+        if exist_ok and self.version_exists(version_id=id):
+            return self.version(version_id=id)
+
         payload = {}
 
         if id is not None:
@@ -1955,6 +1988,47 @@ class Application:
 
         return Instance.from_dict(response.json())
 
+    def update_batch_experiment(
+        self,
+        batch_experiment_id: str,
+        name: str,
+        description: str,
+    ) -> BatchExperimentInformation:
+        """
+        Update a batch experiment.
+
+        Parameters
+        ----------
+        batch_experiment_id : str
+            ID of the batch experiment to update.
+        name : str
+            Name of the batch experiment.
+        description : str
+            Description of the batch experiment.
+
+        Returns
+        -------
+        BatchExperimentInformation
+            The information with the updated batch experiment.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        """
+
+        payload = {
+            "name": name,
+            "description": description,
+        }
+        response = self.client.request(
+            method="PATCH",
+            endpoint=f"{self.experiments_endpoint}/batch/{batch_experiment_id}",
+            payload=payload,
+        )
+
+        return BatchExperimentInformation.from_dict(response.json())
+
     def update_managed_input(
         self,
         managed_input_id: str,
@@ -1994,6 +2068,43 @@ class Application:
             payload=payload,
         )
 
+    def update_scenario_test(
+        self,
+        scenario_test_id: str,
+        name: str,
+        description: str,
+    ) -> BatchExperimentInformation:
+        """
+        Update a scenario test. Scenario tests use the batch experiments API,
+        so this method calls the `update_batch_experiment` method, and thus the
+        return type is the same.
+
+        Parameters
+        ----------
+        scenario_test_id : str
+            ID of the scenario test to update.
+        name : str
+            Name of the scenario test.
+        description : str
+            Description of the scenario test.
+
+        Returns
+        -------
+        BatchExperimentInformation
+            The information with the updated scenario test.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        """
+
+        return self.update_batch_experiment(
+            batch_experiment_id=scenario_test_id,
+            name=name,
+            description=description,
+        )
+
     def update_secrets_collection(
         self,
         secrets_collection_id: str,
@@ -2118,6 +2229,25 @@ class Application:
 
         return Version.from_dict(response.json())
 
+    def version_exists(self, version_id: str) -> bool:
+        """
+        Check if a version exists.
+
+        Args:
+            version_id: ID of the version.
+
+        Returns:
+            bool: True if the version exists, False otherwise.
+        """
+
+        try:
+            self.version(version_id=version_id)
+            return True
+        except requests.HTTPError as e:
+            if _is_not_exist_error(e):
+                return False
+            raise e
+
     def __run_result(
         self,
         run_id: str,
@@ -2353,3 +2483,29 @@ def poll(polling_options: PollingOptions, polling_func: Callable[[], tuple[any,
     raise RuntimeError(
         f"polling did not succeed after {polling_options.max_tries} tries",
     )
+
+
+def _is_not_exist_error(e: requests.HTTPError) -> bool:
+    """
+    Check if the error is a known 404 Not Found error.
+
+    Args:
+        e: HTTPError to check.
+
+    Returns:
+        True if the error is a 404 Not Found error, False otherwise.
+    """
+    if (
+        # Check whether the error is caused by a 404 status code - meaning the app does not exist.
+        (hasattr(e, "response") and hasattr(e.response, "status_code") and e.response.status_code == 404)
+        or
+        # Check a possibly nested exception as well.
+        (
+            hasattr(e, "__cause__")
+            and hasattr(e.__cause__, "response")
+            and hasattr(e.__cause__.response, "status_code")
+            and e.__cause__.response.status_code == 404
+        )
+    ):
+        return True
+    return False

{nextmv-0.25.0 → nextmv-0.26.1}/nextmv/cloud/batch_experiment.py

@@ -18,9 +18,9 @@ class BatchExperimentInformation(BaseModel):
     """Creation date of the batch experiment."""
     updated_at: datetime
     """Last update date of the batch experiment."""
-    status: str
-    """Status of the batch experiment."""
 
+    status: Optional[str] = None
+    """Status of the batch experiment."""
     description: Optional[str] = None
     """Description of the batch experiment."""
     number_of_requested_runs: Optional[int] = None
@@ -101,5 +101,5 @@ class BatchExperimentRun(BaseModel):
 class BatchExperimentMetadata(BatchExperimentInformation):
     """Metadata of a batch experiment."""
 
-    app_id: str
+    app_id: Optional[str] = None
     """ID of the application used for the batch experiment."""

{nextmv-0.25.0 → nextmv-0.26.1}/nextmv/cloud/run.py

@@ -14,6 +14,38 @@ from nextmv.input import Input, InputFormat
 from nextmv.output import Output, OutputFormat
 
 
+def run_duration(
+    start: Union[datetime, float],
+    end: Union[datetime, float],
+) -> int:
+    """
+    Calculate the duration of a run in milliseconds.
+
+    Parameters
+    ----------
+    start : Union[datetime, float]
+        The start time of the run. Can be a datetime object or a float
+        representing the start time in seconds since the epoch.
+    end : Union[datetime, float]
+        The end time of the run. Can be a datetime object or a float
+        representing the end time in seconds since the epoch.
+
+    Returns
+    -------
+    int
+        The duration of the run in milliseconds.
+    """
+    if isinstance(start, float) and isinstance(end, float):
+        if start > end:
+            raise ValueError("Start time must be before end time.")
+        return int(round((end - start) * 1000))
+    if isinstance(start, datetime) and isinstance(end, datetime):
+        if start > end:
+            raise ValueError("Start time must be before end time.")
+        return int(round((end - start).total_seconds() * 1000))
+    raise TypeError("Start and end must be either datetime or float.")
+
+
 class Metadata(BaseModel):
     """Metadata of a run, whether it was successful or not."""
 
@@ -181,7 +213,7 @@ class ExternalRunResult(BaseModel):
     error_message: Optional[str] = None
     """Error message of the run."""
     execution_duration: Optional[int] = None
-    """Duration of the run, in seconds."""
+    """Duration of the run, in milliseconds."""
 
     def __post_init_post_parse__(self):
         """Validations done after parsing the model."""
@@ -246,7 +278,7 @@ class TrackedRun:
     """The status of the run being tracked"""
 
     duration: Optional[int] = None
-    """The duration of the run being tracked, in seconds."""
+    """The duration of the run being tracked, in milliseconds."""
     error: Optional[str] = None
     """An error message if the run failed. You should only specify this if the
     run failed, otherwise an exception will be raised."""

{nextmv-0.25.0 → nextmv-0.26.1}/nextmv/logger.py

@@ -3,13 +3,17 @@
 import sys
 
 __original_stdout = None
+__stdout_redirected = False
 
 
 def redirect_stdout() -> None:
     """Redirect all messages written to stdout to stderr. When you do not want
     to redirect stdout anymore, call `reset_stdout`."""
 
-    global __original_stdout
+    global __original_stdout, __stdout_redirected
+    if __stdout_redirected:
+        return
+    __stdout_redirected = True
 
     __original_stdout = sys.stdout
     sys.stdout = sys.stderr
@@ -19,7 +23,10 @@ def reset_stdout() -> None:
     """Reset stdout to its original value. This function should always be
     called after `redirect_stdout` to avoid unexpected behavior."""
 
-    global __original_stdout
+    global __original_stdout, __stdout_redirected
+    if not __stdout_redirected:
+        return
+    __stdout_redirected = False
 
     if __original_stdout is None:
         sys.stdout = sys.__stdout__

{nextmv-0.25.0 → nextmv-0.26.1}/nextmv/output.py

@@ -349,7 +349,7 @@ class Output:
 class OutputWriter:
     """Base class for writing outputs."""
 
-    def write(self, output: Output, *args, **kwargs) -> None:
+    def write(self, output: Union[Output, dict[str, Any], BaseModel], *args, **kwargs) -> None:
         """
         Write the output data. This method should be implemented by subclasses.
         """
@@ -364,7 +364,7 @@ class LocalOutputWriter(OutputWriter):
     """
 
     def _write_json(
-        output: Union[Output, dict[str, Any]],
+        output: Union[Output, dict[str, Any], BaseModel],
         options: dict[str, Any],
         statistics: dict[str, Any],
         assets: list[dict[str, Any]],
@@ -372,6 +372,8 @@ class LocalOutputWriter(OutputWriter):
     ) -> None:
         if isinstance(output, dict):
             final_output = output
+        elif isinstance(output, BaseModel):
+            final_output = output.to_dict()
         else:
             solution = output.solution if output.solution is not None else {}
             final_output = {
@@ -447,7 +449,7 @@ class LocalOutputWriter(OutputWriter):
 
     def write(
         self,
-        output: Union[Output, dict[str, Any]],
+        output: Union[Output, dict[str, Any], BaseModel],
         path: Optional[str] = None,
         skip_stdout_reset: bool = False,
     ) -> None:
@@ -497,8 +499,12 @@ class LocalOutputWriter(OutputWriter):
             output_format = output.output_format
         elif isinstance(output, dict):
             output_format = OutputFormat.JSON
+        elif isinstance(output, BaseModel):
+            output_format = OutputFormat.JSON
         else:
-            raise TypeError(f"unsupported output type: {type(output)}, supported types are `Output` or `dict`")
+            raise TypeError(
+                f"unsupported output type: {type(output)}, supported types are `Output`, `dict`, `BaseModel`"
+            )
 
         statistics = self._extract_statistics(output)
         options = self._extract_options(output)
@@ -640,7 +646,7 @@ _LOCAL_OUTPUT_WRITER = LocalOutputWriter()
 
 
 def write(
-    output: Union[Output, dict[str, Any]],
+    output: Union[Output, dict[str, Any], BaseModel],
     path: Optional[str] = None,
     skip_stdout_reset: bool = False,
     writer: Optional[OutputWriter] = _LOCAL_OUTPUT_WRITER,

{nextmv-0.25.0 → nextmv-0.26.1}/tests/test_output.py

@@ -4,10 +4,11 @@ import os
 import shutil
 import unittest
 from io import StringIO
-from typing import Optional
+from typing import Any, Optional
 from unittest.mock import patch
 
 import nextmv
+from nextmv.base_model import BaseModel
 
 
 class TestOutput(unittest.TestCase):
@@ -294,6 +295,32 @@ class TestOutput(unittest.TestCase):
 
             self.assertDictEqual(got, expected)
 
+    def test_local_write_base_model(self):
+        class myClass(BaseModel):
+            output: dict[str, Any]
+
+        output = {
+            "i_am": "a_crazy_object",
+            "with": [
+                {"nested": "values"},
+                {"and": "more_craziness"},
+            ],
+        }
+        custom_class = myClass(output=output)
+
+        output_writer = nextmv.LocalOutputWriter()
+
+        with patch("sys.stdout", new=StringIO()) as mock_stdout:
+            output_writer.write(custom_class, skip_stdout_reset=True)
+
+            got = json.loads(mock_stdout.getvalue())
+
+            # We test that the `write` method calls the `.to_dict()` method if
+            # it detects the output type to be an instance of `BaseModel`.
+            expected = {"output": output}
+
+            self.assertDictEqual(got, expected)
+
     def test_local_write_empty_output(self):
         output = nextmv.Output()
 

nextmv-0.25.0/nextmv/__about__.py

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