nextmv 0.29.3__tar.gz → 0.29.4.dev0__tar.gz

{nextmv-0.29.3 → nextmv-0.29.4.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 0.29.3
+Version: 0.29.4.dev0
 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.4.dev0/nextmv/__about__.py

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

{nextmv-0.29.3 → nextmv-0.29.4.dev0}/nextmv/cloud/application.py

@@ -29,6 +29,7 @@ import shutil
 import tarfile
 import tempfile
 import time
+import uuid
 from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime
@@ -45,6 +46,7 @@ from nextmv.cloud.batch_experiment import (
     BatchExperimentInformation,
     BatchExperimentMetadata,
     BatchExperimentRun,
+    to_runs,
 )
 from nextmv.cloud.client import Client, get_size
 from nextmv.cloud.input_set import InputSet, ManagedInput
@@ -273,7 +275,7 @@ class Application:
         Client to use for interacting with the Nextmv Cloud API.
     id : str
         ID of the application.
-    default_instance_id : str, default="devint"
+    default_instance_id : str, default=None
         Default instance ID to use for submitting runs.
     endpoint : str, default="v1/applications/{id}"
         Base endpoint for the application.
@@ -294,13 +296,22 @@ class Application:
     id: str
     """ID of the application."""
 
-    default_instance_id: str = "devint"
+    default_instance_id: str = None
     """Default instance ID to use for submitting runs."""
     endpoint: str = "v1/applications/{id}"
     """Base endpoint for the application."""
     experiments_endpoint: str = "{base}/experiments"
     """Base endpoint for the experiments in the application."""
 
+    # Local experience parameters.
+    src: Optional[str] = None
+    """
+    Source of the application, if initialized locally. This is the path
+    to the application's source code.
+    """
+    description: Optional[str] = None
+    """Description of the application."""
+
     def __post_init__(self):
         """Initialize the endpoint and experiments_endpoint attributes.
 
@@ -310,6 +321,158 @@ class Application:
         self.endpoint = self.endpoint.format(id=self.id)
         self.experiments_endpoint = self.experiments_endpoint.format(base=self.endpoint)
 
+    @classmethod
+    def initialize(
+        cls,
+        name: str,
+        id: Optional[str] = None,
+        description: Optional[str] = None,
+        destination: Optional[str] = None,
+        client: Optional[Client] = None,
+    ) -> "Application":
+        """
+        Initialize a Nextmv application, locally.
+
+        This method will create a new application in the local file system. The
+        application is a folder with the name given by `name`, under the
+        location given by `destination`. If the `destination` parameter is not
+        specified, the current working directory is used as default. This
+        method will scaffold the application with the necessary files and
+        directories to have an opinionated structure for your decision model.
+        Once the application is initialized, you are encouraged to complete it
+        with the decision model itself, so that the application can be run,
+        locally or remotely.
+
+        This method differs from the `Application.new` method in that it
+        creates the application locally rather than in the Cloud.
+
+        Although not required, you are encouraged to specify the `client`
+        parameter, so that the application can be pushed and synced remotely,
+        with the Nextmv Cloud. If you don't specify the `client`, and intend to
+        interact with the Nextmv Cloud, you will encounter an error. Make sure
+        you set the `client` parameter on the `Application` instance after
+        initialization, if you don't provide it here.
+
+        Use the `destination` parameter to specify where you want the app to be
+        initialized, using the current working directory by default.
+
+        Parameters
+        ----------
+        name : str
+            Name of the application.
+        id : str, optional
+            ID of the application. Will be generated if not provided.
+        description : str, optional
+            Description of the application.
+        destination : str, optional
+            Destination directory where the application will be initialized. If
+            not provided, the current working directory will be used.
+        client : Client, optional
+            Client to use for interacting with the Nextmv Cloud API.
+
+        Returns
+        -------
+        Application
+            The initialized application instance.
+        """
+
+        destination_dir = os.getcwd() if destination is None else destination
+        app_id = id if id is not None else str(uuid.uuid4())
+
+        # Create the new directory with the given name.
+        src = os.path.join(destination_dir, name)
+        os.makedirs(src, exist_ok=True)
+
+        # Get the path to the initial app structure template.
+        current_file_dir = os.path.dirname(os.path.abspath(__file__))
+        initial_app_structure_path = os.path.join(current_file_dir, "..", "default_app")
+        initial_app_structure_path = os.path.normpath(initial_app_structure_path)
+
+        # Copy everything from initial_app_structure to the new directory.
+        if os.path.exists(initial_app_structure_path):
+            for item in os.listdir(initial_app_structure_path):
+                source_path = os.path.join(initial_app_structure_path, item)
+                dest_path = os.path.join(src, item)
+
+                if os.path.isdir(source_path):
+                    shutil.copytree(source_path, dest_path, dirs_exist_ok=True)
+                    continue
+
+                shutil.copy2(source_path, dest_path)
+
+        return cls(
+            id=app_id,
+            client=client,
+            src=src,
+            description=description,
+        )
+
+    @classmethod
+    def new(
+        cls,
+        client: Client,
+        name: str,
+        id: Optional[str] = None,
+        description: Optional[str] = None,
+        is_workflow: Optional[bool] = None,
+        exist_ok: bool = False,
+    ) -> "Application":
+        """
+        Create a new application directly in Nextmv Cloud.
+
+        The application is created as an empty shell, and executable code must
+        be pushed to the app before running it remotely.
+
+        Parameters
+        ----------
+        client : Client
+            Client to use for interacting with the Nextmv Cloud API.
+        name : str
+            Name of the application.
+        id : str, optional
+            ID of the application. Will be generated if not provided.
+        description : str, optional
+            Description of the application.
+        is_workflow : bool, optional
+            Whether the application is a Decision Workflow.
+        exist_ok : bool, default=False
+            If True and an application with the same ID already exists,
+            return the existing application instead of creating a new one.
+
+        Returns
+        -------
+        Application
+            The newly created (or existing) application.
+
+        Examples
+        --------
+        >>> from nextmv.cloud import Client
+        >>> client = Client(api_key="your-api-key")
+        >>> app = Application.new(client=client, name="My New App", id="my-app")
+        """
+
+        if exist_ok and cls.exists(client=client, id=id):
+            return Application(client=client, id=id)
+
+        payload = {
+            "name": name,
+        }
+
+        if description is not None:
+            payload["description"] = description
+        if id is not None:
+            payload["id"] = id
+        if is_workflow is not None:
+            payload["is_pipeline"] = is_workflow
+
+        response = client.request(
+            method="POST",
+            endpoint="v1/applications",
+            payload=payload,
+        )
+
+        return cls(client=client, id=response.json()["id"])
+
     def acceptance_test(self, acceptance_test_id: str) -> AcceptanceTest:
         """
         Retrieve details of an acceptance test.
@@ -901,69 +1064,6 @@ class Application:
 
         return ManagedInput.from_dict(response.json())
 
-    @classmethod
-    def new(
-        cls,
-        client: Client,
-        name: str,
-        id: Optional[str] = None,
-        description: Optional[str] = None,
-        is_workflow: Optional[bool] = None,
-        exist_ok: bool = False,
-    ) -> "Application":
-        """
-        Create a new application.
-
-        Parameters
-        ----------
-        client : Client
-            Client to use for interacting with the Nextmv Cloud API.
-        name : str
-            Name of the application.
-        id : str, optional
-            ID of the application. Will be generated if not provided.
-        description : str, optional
-            Description of the application.
-        is_workflow : bool, optional
-            Whether the application is a Decision Workflow.
-        exist_ok : bool, default=False
-            If True and an application with the same ID already exists,
-            return the existing application instead of creating a new one.
-
-        Returns
-        -------
-        Application
-            The newly created (or existing) application.
-
-        Examples
-        --------
-        >>> from nextmv.cloud import Client
-        >>> client = Client(api_key="your-api-key")
-        >>> app = Application.new(client=client, name="My New App", id="my-app")
-        """
-
-        if exist_ok and cls.exists(client=client, id=id):
-            return Application(client=client, id=id)
-
-        payload = {
-            "name": name,
-        }
-
-        if description is not None:
-            payload["description"] = description
-        if id is not None:
-            payload["id"] = id
-        if is_workflow is not None:
-            payload["is_pipeline"] = is_workflow
-
-        response = client.request(
-            method="POST",
-            endpoint="v1/applications",
-            payload=payload,
-        )
-
-        return cls(client=client, id=response.json()["id"])
-
     def new_acceptance_test(
         self,
         candidate_instance_id: str,
@@ -1027,12 +1127,21 @@ 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,
+                ),
+            ]
             batch_experiment_id = self.new_batch_experiment(
                 name=name,
-                input_set_id=input_set_id,
-                instance_ids=[candidate_instance_id, baseline_instance_id],
                 description=description,
                 id=id,
+                runs=runs,
             )
 
         if batch_experiment_id != id:
@@ -1175,6 +1284,7 @@ class Application:
             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]
@@ -1207,7 +1317,10 @@ class Application:
         if input_set_id is not None:
             payload["input_set_id"] = input_set_id
         if instance_ids is not None:
-            payload["instance_ids"] = instance_ids
+            input_set = self.input_set(input_set_id)
+            runs = to_runs(instance_ids, input_set)
+            payload_runs = [run.to_dict() for run in runs]
+            payload["runs"] = payload_runs
         if description is not None:
             payload["description"] = description
         if id is not None:
@@ -1675,9 +1788,9 @@ class Application:
             )
             payload["result"] = external_dict
 
-        query_params = {
-            "instance_id": instance_id if instance_id is not None else self.default_instance_id,
-        }
+        query_params = {}
+        if instance_id is not None or self.default_instance_id is not None:
+            query_params["instance_id"] = instance_id if instance_id is not None else self.default_instance_id
         response = self.client.request(
             method="POST",
             endpoint=f"{self.endpoint}/runs",
@@ -1996,8 +2109,16 @@ class Application:
         >>> # Create a new secrets collection with API keys
         >>> from nextmv.cloud import Secret
         >>> secrets = [
-        ...     Secret(key="API_KEY", value="your-api-key"),
-        ...     Secret(key="DATABASE_URL", value="your-database-url")
+        ...     Secret(
+        ...          location="API_KEY",
+        ...          value="your-api-key",
+        ...          secret_type=SecretType.ENV,
+        ...     ),
+        ...     Secret(
+        ...          location="DATABASE_URL",
+        ...          value="your-database-url",
+        ...          secret_type=SecretType.ENV,
+        ...     ),
         ... ]
         >>> collection = app.new_secrets_collection(
         ...     secrets=secrets,
@@ -3219,7 +3340,7 @@ class Application:
                     {
                         "app_id": self.id,
                         "endpoint": self.client.url,
-                        "instance_url": f"{self.endpoint}/runs?instance_id=devint",
+                        "instance_url": f"{self.endpoint}/runs?instance_id=latest",
                     },
                     indent=2,
                 )

{nextmv-0.29.3 → nextmv-0.29.4.dev0}/nextmv/cloud/batch_experiment.py

@@ -17,6 +17,7 @@ from datetime import datetime
 from typing import Any, Optional
 
 from nextmv.base_model import BaseModel
+from nextmv.cloud.input_set import InputSet
 
 
 class BatchExperimentInformation(BaseModel):
@@ -143,10 +144,10 @@ class BatchExperimentRun(BaseModel):
 
     Parameters
     ----------
-    option_set : str
-        Option set used for the experiment.
     input_id : str
         ID of the input used for the experiment.
+    option_set : str
+        Option set used for the experiment. Defaults to None.
     instance_id : str, optional
         ID of the instance used for the experiment. Defaults to None.
     version_id : str, optional
@@ -162,11 +163,11 @@ class BatchExperimentRun(BaseModel):
         Run number of the experiment. Defaults to None.
     """
 
-    option_set: str
-    """Option set used for the experiment."""
     input_id: str
     """ID of the input used for the experiment."""
 
+    option_set: Optional[str] = None
+    """Option set used for the experiment."""
     instance_id: Optional[str] = None
     """ID of the instance used for the experiment."""
     version_id: Optional[str] = None
@@ -177,8 +178,6 @@ class BatchExperimentRun(BaseModel):
     """If the batch experiment is a scenario test, this is the ID of that test."""
     repetition: Optional[int] = None
     """Repetition number of the experiment."""
-    run_number: Optional[str] = None
-    """Run number of the experiment."""
 
     def __post_init_post_parse__(self):
         """
@@ -215,3 +214,37 @@ class BatchExperimentMetadata(BatchExperimentInformation):
 
     app_id: Optional[str] = None
     """ID of the application used for the batch experiment."""
+
+
+def to_runs(instance_ids: list[str], input_set: InputSet) -> list[BatchExperimentRun]:
+    """
+    Translate a legacy batch experiment list of instance ids to runs.
+
+    Parameters
+    ----------
+    instance_ids : list[str]
+        List of instance IDs to be converted into runs.
+    input_set : InputSet
+        Input set associated with the runs.
+
+    Returns
+    -------
+    list[BatchExperimentRun]
+        A list of `BatchExperimentRun` objects created from the instance IDs.
+    """
+
+    input_ids = input_set.input_ids
+    if len(input_set.input_ids) == 0:
+        input_ids = [i.id for i in input_set.inputs]
+
+    runs = []
+    for instance_id in instance_ids:
+        for input_id in input_ids:
+            run = BatchExperimentRun(
+                input_id=input_id,
+                instance_id=instance_id,
+                input_set_id=input_set.id,
+            )
+            runs.append(run)
+
+    return runs

{nextmv-0.29.3 → nextmv-0.29.4.dev0}/nextmv/cloud/manifest.py

@@ -322,6 +322,7 @@ class ManifestPython(BaseModel):
     from the app bundle.
     """
 
+
 class ManifestOptionUI(BaseModel):
     """
     UI attributes for an option in the manifest.
@@ -360,6 +361,7 @@ class ManifestOptionUI(BaseModel):
     hidden_from: Optional[list[str]] = None
     """A list of team roles for which this option will be hidden in the UI."""
 
+
 class ManifestOption(BaseModel):
     """
     An option for the decision model that is recorded in the manifest.
@@ -429,7 +431,6 @@ class ManifestOption(BaseModel):
     ui: Optional[ManifestOptionUI] = None
     """Optional UI attributes for the option."""
 
-
     @classmethod
     def from_option(cls, option: Option) -> "ManifestOption":
         """
@@ -483,7 +484,9 @@ class ManifestOption(BaseModel):
             ui=ManifestOptionUI(
                 control_type=option.control_type,
                 hidden_from=option.hidden_from,
-            ) if option.control_type or option.hidden_from else None,
+            )
+            if option.control_type or option.hidden_from
+            else None,
         )
 
     def to_option(self) -> Option:
@@ -534,6 +537,7 @@ class ManifestOption(BaseModel):
             hidden_from=self.ui.hidden_from if self.ui else None,
         )
 
+
 class ManifestValidation(BaseModel):
     """
     Validation rules for options in the manifest.
@@ -569,6 +573,7 @@ class ManifestValidation(BaseModel):
     created if any of the rules of the options are violated.
     """
 
+
 class ManifestOptions(BaseModel):
     """
     Options for the decision model.
@@ -649,9 +654,10 @@ class ManifestOptions(BaseModel):
         return cls(
             strict=validation.strict if validation else False,
             validation=ManifestValidation(enforce="all" if validation and validation.validation_enforce else "none"),
-            items=items
+            items=items,
         )
 
+
 class ManifestConfiguration(BaseModel):
     """
     Configuration for the decision model.
@@ -749,14 +755,17 @@ class Manifest(BaseModel):
     """The files to include (or exclude) in the app. This is mandatory."""
 
     runtime: ManifestRuntime = ManifestRuntime.PYTHON
-    """The runtime to use for the app.
-
-    It provides the environment in which the app runs. This is mandatory.
+    """
+    The runtime to use for the app. It provides the environment in which the
+    app runs. This is mandatory.
     """
     type: ManifestType = ManifestType.PYTHON
-    """Type of application, based on the programming language. This is mandatory."""
+    """
+    Type of application, based on the programming language. This is mandatory.
+    """
     build: Optional[ManifestBuild] = None
-    """Build-specific attributes.
+    """
+    Build-specific attributes.
 
     The `build.command` to run to build the app. This command will be executed
     without a shell, i.e., directly. The command must exit with a status of 0
@@ -770,7 +779,8 @@ class Manifest(BaseModel):
         validation_alias=AliasChoices("pre-push", "pre_push"),
         default=None,
     )
-    """A command to run before the app is pushed to the Nextmv Cloud.
+    """
+    A command to run before the app is pushed to the Nextmv Cloud.
 
     This command can be used to compile a binary, run tests or similar tasks.
     One difference with what is specified under build, is that the command will
@@ -780,15 +790,14 @@ class Manifest(BaseModel):
     pushed (after the build command).
     """
     python: Optional[ManifestPython] = None
-    """Python-specific attributes.
-
-    Only for Python apps. Contains further Python-specific attributes.
+    """
+    Python-specific attributes. Only for Python apps. Contains further
+    Python-specific attributes.
     """
     configuration: Optional[ManifestConfiguration] = None
-    """Configuration for the decision model.
-
-    A list of options for the decision model. An option is a parameter that
-    configures the decision model.
+    """
+    Configuration for the decision model. A list of options for the decision
+    model. An option is a parameter that configures the decision model.
     """
 
     @classmethod
@@ -1041,11 +1050,8 @@ class Manifest(BaseModel):
             type=ManifestType.PYTHON,
             python=ManifestPython(pip_requirements="requirements.txt"),
             configuration=ManifestConfiguration(
-                options= ManifestOptions.from_options(
-                    options=options,
-                    validation=validation
-                ),
-            )
+                options=ManifestOptions.from_options(options=options, validation=validation),
+            ),
         )
 
         return manifest

nextmv-0.29.4.dev0/nextmv/default_app/README.md

@@ -0,0 +1,17 @@
+# Nextmv Application
+
+This is the basic structure of a Nextmv application.
+
+```text
+├── app.yaml
+├── README.md
+├── requirements.txt
+└── src
+```
+
+* `app.yaml`: App manifest, containing the configuration to run the app
+  remotely on Nextmv Cloud.
+* `README.md`: Description of the app.
+* `requirements.txt`: Python dependencies for the app.
+* `src/`: Source code for the app. The `main.py` file is the entry point for
+  the app.

nextmv-0.29.4.dev0/nextmv/default_app/app.yaml

@@ -0,0 +1,11 @@
+# This manifest holds the information the app needs to run on the Nextmv Cloud.
+type: python
+runtime: ghcr.io/nextmv-io/runtime/python:3.11
+python:
+  # All listed packages will get bundled with the app.
+  pip-requirements: requirements.txt
+
+# List all files/directories that should be included in the app. Globbing
+# (e.g.: configs/*.json) is supported.
+files:
+  - src/

nextmv-0.29.4.dev0/nextmv/default_app/requirements.txt

@@ -0,0 +1,2 @@
+nextmv>=0.29.3
+plotly>=6.2.0

nextmv-0.29.4.dev0/nextmv/default_app/src/main.py

@@ -0,0 +1,36 @@
+from visuals import create_visuals
+
+import nextmv
+
+# Read the input from stdin.
+input = nextmv.load()
+name = input.data["name"]
+
+options = nextmv.Options(
+    nextmv.Option("details", bool, True, "Print details to logs. Default true.", False),
+)
+
+##### Insert model here
+
+# Print logs that render in the run view in Nextmv Console.
+message = f"Hello, {name}"
+nextmv.log(message)
+
+if options.details:
+    detail = f"You are {input.data['distance']} million km from the sun"
+    nextmv.log(detail)
+
+assets = create_visuals(name, input.data["radius"], input.data["distance"])
+
+# Write output and statistics.
+output = nextmv.Output(
+    solution=None,
+    statistics=nextmv.Statistics(
+        result=nextmv.ResultStatistics(
+            value=1.23,
+            custom={"message": message},
+        ),
+    ),
+    assets=assets,
+)
+nextmv.write(output)

nextmv-0.29.4.dev0/nextmv/default_app/src/visuals.py

@@ -0,0 +1,36 @@
+import json
+
+import plotly.graph_objects as go
+
+import nextmv
+
+
+def create_visuals(name: str, radius: float, distance: float) -> list[nextmv.Asset]:
+    """Create a Plotly bar chart with radius and distance for a planet."""
+
+    fig = go.Figure()
+    fig.add_trace(
+        go.Bar(x=[name], y=[radius], name="Radius (km)", marker_color="red", opacity=0.5),
+    )
+    fig.add_trace(
+        go.Bar(x=[name], y=[distance], name="Distance (Millions km)", marker_color="blue", opacity=0.5),
+    )
+    fig.update_layout(
+        title="Radius and Distance by Planet", xaxis_title="Planet", yaxis_title="Values", barmode="group"
+    )
+    fig = fig.to_json()
+
+    assets = [
+        nextmv.Asset(
+            name="Plotly example",
+            content_type="json",
+            visual=nextmv.Visual(
+                visual_schema=nextmv.VisualSchema.PLOTLY,
+                visual_type="custom-tab",
+                label="Charts",
+            ),
+            content=[json.loads(fig)],
+        )
+    ]
+
+    return assets

nextmv-0.29.4.dev0/tests/cloud/test_application.py

@@ -0,0 +1,181 @@
+import os
+import tempfile
+import unittest
+from typing import Any
+from unittest.mock import Mock
+
+from nextmv.cloud.application import Application, PollingOptions, poll
+from nextmv.cloud.client import Client
+
+
+# This is a dummy function to avoid actually sleeping during tests.
+def no_sleep(value: float) -> None:
+    return
+
+
+class TestApplication(unittest.TestCase):
+    def test_poll(self):
+        counter = 0
+
+        def polling_func() -> tuple[Any, bool]:
+            nonlocal counter
+            counter += 1
+
+            if counter < 4:
+                return "result", False
+
+            return "result", True
+
+        polling_options = PollingOptions()
+
+        result = poll(polling_options, polling_func, no_sleep)
+
+        self.assertEqual(result, "result")
+
+    def test_initialize(self):
+        """Test the Application.initialize method."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            app_name = "test-app"
+            app_id = "test-app-id"
+            description = "Test application"
+
+            # Mock client
+            mock_client = Mock(spec=Client)
+
+            # Initialize the application
+            app = Application.initialize(
+                name=app_name,
+                id=app_id,
+                description=description,
+                destination=temp_dir,
+                client=mock_client,
+            )
+
+            # Verify the application object
+            self.assertEqual(app.id, app_id)
+            self.assertEqual(app.client, mock_client)
+            self.assertEqual(app.description, description)
+            self.assertEqual(app.src, os.path.join(temp_dir, app_name))
+
+            # Verify the directory structure was created
+            app_dir = os.path.join(temp_dir, app_name)
+            self.assertTrue(os.path.exists(app_dir))
+            self.assertTrue(os.path.isdir(app_dir))
+
+            # Verify app.yaml was copied
+            app_yaml_path = os.path.join(app_dir, "app.yaml")
+            self.assertTrue(os.path.exists(app_yaml_path))
+
+            # Verify requirements.txt was copied
+            requirements_path = os.path.join(app_dir, "requirements.txt")
+            self.assertTrue(os.path.exists(requirements_path))
+
+            # Verify README.md was copied
+            readme_path = os.path.join(app_dir, "README.md")
+            self.assertTrue(os.path.exists(readme_path))
+
+            # Verify src directory was copied
+            src_dir = os.path.join(app_dir, "src")
+            self.assertTrue(os.path.exists(src_dir))
+            self.assertTrue(os.path.isdir(src_dir))
+
+    def test_initialize_with_defaults(self):
+        """Test the Application.initialize method with default parameters."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Change to temp directory to test default destination
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(temp_dir)
+
+                app_name = "default-test-app"
+
+                # Initialize with minimal parameters
+                app = Application.initialize(name=app_name)
+
+                # Verify the application object has generated ID
+                self.assertIsNotNone(app.id)
+                self.assertIsNone(app.client)
+                self.assertIsNone(app.description)  # description should be None when not provided
+                # Use the current working directory for comparison since that's where the app is created
+                expected_src_path = os.path.join(os.getcwd(), app_name)
+                self.assertEqual(app.src, expected_src_path)
+
+                # Verify the directory structure was created in current directory
+                app_dir = os.path.join(temp_dir, app_name)
+                self.assertTrue(os.path.exists(app_dir))
+                self.assertTrue(os.path.isdir(app_dir))
+
+                # Verify basic structure exists
+                self.assertTrue(os.path.exists(os.path.join(app_dir, "app.yaml")))
+                self.assertTrue(os.path.exists(os.path.join(app_dir, "src")))
+
+            finally:
+                os.chdir(original_cwd)
+
+    def test_initialize_existing_directory(self):
+        """Test that initialize works when the directory already exists."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            app_name = "existing-app"
+            app_dir = os.path.join(temp_dir, app_name)
+
+            # Pre-create the directory
+            os.makedirs(app_dir, exist_ok=True)
+
+            # Initialize should still work
+            app = Application.initialize(
+                name=app_name,
+                destination=temp_dir,
+            )
+
+            # Verify the application was created successfully
+            self.assertIsNotNone(app.id)
+            self.assertIsNone(app.description)  # description should be None when not provided
+            self.assertEqual(app.src, app_dir)
+            self.assertTrue(os.path.exists(app_dir))
+            self.assertTrue(os.path.exists(os.path.join(app_dir, "app.yaml")))
+
+    def test_poll_stop_callback(self):
+        counter = 0
+
+        # The polling func would stop after 9 calls.
+        def polling_func() -> tuple[Any, bool]:
+            nonlocal counter
+            counter += 1
+
+            if counter < 10:
+                return "result", False
+
+            return "result", True
+
+        # The stop callback makes sure that the polling stops sooner, after 3
+        # calls.
+        def stop() -> bool:
+            if counter == 3:
+                return True
+
+        polling_options = PollingOptions(stop=stop)
+
+        result = poll(polling_options, polling_func, no_sleep)
+
+        self.assertIsNone(result)
+
+    def test_poll_long(self):
+        counter = 0
+        max_tries = 1000000
+
+        def polling_func() -> tuple[Any, bool]:
+            nonlocal counter
+            counter += 1
+
+            if counter < max_tries:
+                return "result", False
+
+            return "result", True
+
+        polling_options = PollingOptions(
+            max_tries=max_tries + 1,
+        )
+
+        result = poll(polling_options, polling_func, no_sleep)
+
+        self.assertEqual(result, "result")

nextmv-0.29.3/nextmv/__about__.py

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

nextmv-0.29.3/tests/cloud/test_application.py

@@ -1,75 +0,0 @@
-import unittest
-from typing import Any
-
-from nextmv.cloud.application import PollingOptions, poll
-
-
-# This is a dummy function to avoid actually sleeping during tests.
-def no_sleep(value: float) -> None:
-    return
-
-
-class TestApplication(unittest.TestCase):
-    def test_poll(self):
-        counter = 0
-
-        def polling_func() -> tuple[Any, bool]:
-            nonlocal counter
-            counter += 1
-
-            if counter < 4:
-                return "result", False
-
-            return "result", True
-
-        polling_options = PollingOptions()
-
-        result = poll(polling_options, polling_func, no_sleep)
-
-        self.assertEqual(result, "result")
-
-    def test_poll_stop_callback(self):
-        counter = 0
-
-        # The polling func would stop after 9 calls.
-        def polling_func() -> tuple[Any, bool]:
-            nonlocal counter
-            counter += 1
-
-            if counter < 10:
-                return "result", False
-
-            return "result", True
-
-        # The stop callback makes sure that the polling stops sooner, after 3
-        # calls.
-        def stop() -> bool:
-            if counter == 3:
-                return True
-
-        polling_options = PollingOptions(stop=stop)
-
-        result = poll(polling_options, polling_func, no_sleep)
-
-        self.assertIsNone(result)
-
-    def test_poll_long(self):
-        counter = 0
-        max_tries = 1000000
-
-        def polling_func() -> tuple[Any, bool]:
-            nonlocal counter
-            counter += 1
-
-            if counter < max_tries:
-                return "result", False
-
-            return "result", True
-
-        polling_options = PollingOptions(
-            max_tries=max_tries + 1,
-        )
-
-        result = poll(polling_options, polling_func, no_sleep)
-
-        self.assertEqual(result, "result")