nextmv 0.37.0__tar.gz → 0.37.2__tar.gz

{nextmv-0.37.0 → nextmv-0.37.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 0.37.0
+Version: 0.37.2
 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/
@@ -224,7 +224,6 @@ Requires-Dist: requests>=2.31.0
 Requires-Dist: urllib3>=2.1.0
 Provides-Extra: all
 Requires-Dist: folium>=0.20.0; extra == 'all'
-Requires-Dist: mlflow>=2.17.2; extra == 'all'
 Requires-Dist: plotly>=6.0.1; extra == 'all'
 Provides-Extra: dev
 Requires-Dist: build>=1.0.3; extra == 'dev'
@@ -240,6 +239,8 @@ Requires-Dist: requests>=2.31.0; extra == 'dev'
 Requires-Dist: ruff>=0.1.7; extra == 'dev'
 Requires-Dist: twine>=4.0.2; extra == 'dev'
 Requires-Dist: urllib3>=2.1.0; extra == 'dev'
+Provides-Extra: notebook
+Requires-Dist: mlflow>=2.19.0; extra == 'notebook'
 Description-Content-Type: text/markdown
 
 # Nextmv Python SDK

nextmv-0.37.2/nextmv/__about__.py

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

{nextmv-0.37.0 → nextmv-0.37.2}/nextmv/cloud/__init__.py

@@ -74,6 +74,10 @@ from .input_set import InputSet as InputSet
 from .input_set import ManagedInput as ManagedInput
 from .instance import Instance as Instance
 from .instance import InstanceConfiguration as InstanceConfiguration
+from .integration import Integration as Integration
+from .integration import IntegrationProvider as IntegrationProvider
+from .integration import IntegrationType as IntegrationType
+from .integration import list_integrations as list_integrations
 from .scenario import Scenario as Scenario
 from .scenario import ScenarioConfiguration as ScenarioConfiguration
 from .scenario import ScenarioInput as ScenarioInput

{nextmv-0.37.0 → nextmv-0.37.2}/nextmv/cloud/application.py

@@ -3215,7 +3215,7 @@ class Application:
         name: str | None = None,
         version_id: str | None = None,
         description: str | None = None,
-        configuration: InstanceConfiguration | None = None,
+        configuration: InstanceConfiguration | dict[str, Any] | None = None,
     ) -> Instance:
         """
         Update an instance.
@@ -3230,7 +3230,7 @@ class Application:
             Optional ID of the version to associate the instance with.
         description : Optional[str], default=None
             Optional description of the instance.
-        configuration : Optional[InstanceConfiguration], default=None
+        configuration : Optional[InstanceConfiguration | dict[str, Any]], default=None
             Optional configuration to use for the instance.
 
         Returns
@@ -3247,13 +3247,7 @@ class Application:
         # Get the instance as it currently exsits.
         instance = self.instance(id)
         instance_dict = instance.to_dict()
-
-        payload = {
-            "name": instance_dict["name"],
-            "version_id": instance_dict["version_id"],
-            "description": instance_dict["description"],
-            "configuration": instance_dict["configuration"],
-        }
+        payload = instance_dict
 
         if name is not None:
             payload["name"] = name
@@ -3262,7 +3256,14 @@ class Application:
         if description is not None:
             payload["description"] = description
         if configuration is not None:
-            payload["configuration"] = configuration.to_dict()
+            if isinstance(configuration, dict):
+                config_dict = configuration
+            elif isinstance(configuration, InstanceConfiguration):
+                config_dict = configuration.to_dict()
+            else:
+                raise TypeError("configuration must be either a dict or InstanceConfiguration object")
+
+            payload["configuration"] = config_dict
 
         response = self.client.request(
             method="PUT",
@@ -3303,11 +3304,7 @@ class Application:
 
         managed_input = self.managed_input(managed_input_id)
         managed_input_dict = managed_input.to_dict()
-
-        payload = {
-            "name": managed_input_dict["name"],
-            "description": managed_input_dict["description"],
-        }
+        payload = managed_input_dict
 
         if name is not None:
             payload["name"] = name
@@ -3376,7 +3373,7 @@ class Application:
         secrets_collection_id: str,
         name: str | None = None,
         description: str | None = None,
-        secrets: list[Secret] | None = None,
+        secrets: list[Secret | dict[str, Any]] | None = None,
     ) -> SecretsCollectionSummary:
         """
         Update a secrets collection.
@@ -3393,7 +3390,7 @@ class Application:
             Optional new name for the secrets collection.
         description : Optional[str], default=None
             Optional new description for the secrets collection.
-        secrets : Optional[list[Secret]], default=None
+        secrets : Optional[list[Secret | dict[str, Any]]], default=None
             Optional list of secrets to update. Each secret should be an
             instance of the Secret class containing a key and value.
 
@@ -3429,19 +3426,23 @@ class Application:
 
         collection = self.secrets_collection(secrets_collection_id)
         collection_dict = collection.to_dict()
-
-        payload = {
-            "name": collection_dict["name"],
-            "description": collection_dict["description"],
-            "secrets": collection_dict["secrets"],
-        }
+        payload = collection_dict
 
         if name is not None:
             payload["name"] = name
         if description is not None:
             payload["description"] = description
         if secrets is not None and len(secrets) > 0:
-            payload["secrets"] = [secret.to_dict() for secret in secrets]
+            secrets_dicts = []
+            for ix, secret in enumerate(secrets):
+                if isinstance(secret, dict):
+                    secrets_dicts.append(secret)
+                elif isinstance(secret, Secret):
+                    secrets_dicts.append(secret.to_dict())
+                else:
+                    raise ValueError(f"secret at index {ix} must be either a Secret or dict object")
+
+            payload["secrets"] = secrets_dicts
 
         response = self.client.request(
             method="PUT",

nextmv-0.37.2/nextmv/cloud/integration.py

@@ -0,0 +1,533 @@
+"""
+Integration module for interacting with Nextmv Cloud integrations.
+
+This module provides functionality to interact with integrations in Nextmv
+Cloud, including integration management.
+
+Classes
+-------
+IntegrationType
+    Enum representing the type of an integration.
+IntegrationProvider
+    Enum representing the provider of an integration.
+Integration
+    Class representing an integration in Nextmv Cloud.
+
+Functions
+---------
+list_integrations
+    Function to list all integrations in Nextmv Cloud.
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+from pydantic import AliasChoices, Field
+
+from nextmv.base_model import BaseModel
+from nextmv.cloud.client import Client
+from nextmv.manifest import ManifestType
+from nextmv.safe import safe_id
+
+
+class IntegrationType(str, Enum):
+    """
+    The type of an integration.
+
+    You can import the `IntegrationType` class directly from `cloud`:
+
+    ```python
+    from nextmv.cloud import IntegrationType
+    ```
+
+    Attributes
+    ----------
+    RUNTIME : str
+        Indicates a runtime integration.
+    DATA : str
+        Indicates a data integration.
+    """
+
+    RUNTIME = "runtime"
+    """Indicates a runtime integration."""
+    DATA = "data"
+    """Indicates a data integration."""
+
+
+class IntegrationProvider(str, Enum):
+    """
+    The provider of an integration.
+
+    You can import the `IntegrationProvider` class directly from `cloud`:
+
+    ```python
+    from nextmv.cloud import IntegrationProvider
+    ```
+
+    Attributes
+    ----------
+    DBX : str
+        Indicates a Databricks integration.
+    UNKNOWN : str
+        Indicates an unknown integration provider.
+    """
+
+    DBX = "dbx"
+    """Indicates a Databricks integration."""
+    UNKNOWN = "unknown"
+    """Indicates an unknown integration provider."""
+
+
+class Integration(BaseModel):
+    """
+    Represents an integration in Nextmv Cloud. An integration allows Nextmv
+    Cloud to communicate with external systems or services.
+
+    You can import the `Integration` class directly from `cloud`:
+
+    ```python
+    from nextmv.cloud import Integration
+    ```
+
+    You can use the `Integration.get` class method to retrieve an existing
+    integration from Nextmv Cloud, to ensure that all fields are properly
+    populated.
+
+    Parameters
+    ----------
+    integration_id : str
+        The unique identifier of the integration.
+    client : Client
+        Client to use for interacting with the Nextmv Cloud API.
+    name : str, optional
+        The name of the integration.
+    description : str, optional
+        An optional description of the integration.
+    is_global : bool, optional
+        Indicates whether the integration is global (available to all
+        applications in the account).
+    application_ids : list[str], optional
+        List of application IDs that have access to this integration.
+    integration_type : IntegrationType, optional
+        The type of the integration (runtime or data).
+    exec_types : list[ManifestType], optional
+        List of execution types supported by the integration.
+    provider : IntegrationProvider, optional
+        The provider of the integration.
+    provider_config : dict[str, Any], optional
+        Configuration specific to the integration provider.
+    created_at : datetime, optional
+        The timestamp when the integration was created.
+    updated_at : datetime, optional
+        The timestamp when the integration was last updated.
+    """
+
+    integration_id: str = Field(
+        serialization_alias="id",
+        validation_alias=AliasChoices("id", "integration_id"),
+    )
+    """The unique identifier of the integration."""
+    client: Client = Field(exclude=True)
+    """Client to use for interacting with the Nextmv Cloud API."""
+
+    name: str | None = None
+    """The name of the integration."""
+    description: str | None = None
+    """An optional description of the integration."""
+    is_global: bool = Field(
+        serialization_alias="global",
+        validation_alias=AliasChoices("global", "is_global"),
+        default=False,
+    )
+    """
+    Indicates whether the integration is global (available to all
+    applications in the account).
+    """
+    application_ids: list[str] | None = None
+    """
+    List of application IDs that have access to this integration.
+    """
+    integration_type: IntegrationType | None = Field(
+        serialization_alias="type",
+        validation_alias=AliasChoices("type", "integration_type"),
+        default=None,
+    )
+    """The type of the integration (runtime or data)."""
+    exec_types: list[ManifestType] | None = None
+    """List of execution types supported by the integration."""
+    provider: IntegrationProvider | None = None
+    """The provider of the integration."""
+    provider_config: dict[str, Any] | None = None
+    """Configuration specific to the integration provider."""
+    created_at: datetime | None = None
+    """The timestamp when the integration was created."""
+    updated_at: datetime | None = None
+    """The timestamp when the integration was last updated."""
+    endpoint: str = Field(
+        exclude=True,
+        default="v1/integrations/{id}",
+    )
+    """Base endpoint for the integration."""
+
+    def model_post_init(self, __context) -> None:
+        """
+        Validations done after model initialization.
+        """
+
+        self.endpoint = self.endpoint.format(id=self.integration_id)
+
+    @classmethod
+    def get(cls, client: Client, integration_id: str) -> "Integration":
+        """
+        Retrieve an existing integration from Nextmv Cloud.
+
+        This method should be used for validating that the integration exists,
+        and not rely simply on instantiating the `Integration` class. Using
+        this method ensures that all the fields of the `Integration` class are
+        properly populated.
+
+        Parameters
+        ----------
+        client : Client
+            Client to use for interacting with the Nextmv Cloud API.
+        integration_id : str
+            The unique identifier of the integration to retrieve.
+
+        Returns
+        -------
+        Integration
+            The retrieved integration instance.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> from nextmv.cloud import Client, Integration
+        >>> client = Client(api_key="your_api_key")
+        >>> integration = Integration.get(client=client, integration_id="your_integration_id")
+        >>> print(integration.to_dict())
+        """
+
+        response = client.request(
+            method="GET",
+            endpoint=f"v1/integrations/{integration_id}",
+        )
+        response_dict = response.json()
+        response_dict["client"] = client
+
+        return cls.from_dict(response_dict)
+
+    @classmethod
+    def new(  # noqa: C901
+        cls,
+        client: Client,
+        name: str,
+        integration_type: IntegrationType | str,
+        exec_types: list[ManifestType | str],
+        provider: IntegrationProvider | str,
+        provider_config: dict[str, Any],
+        integration_id: str | None = None,
+        description: str | None = None,
+        is_global: bool = False,
+        application_ids: list[str] | None = None,
+        exist_ok: bool = False,
+    ) -> "Integration":
+        """
+        Create a new integration directly in Nextmv Cloud.
+
+        Parameters
+        ----------
+        client : Client
+            Client to use for interacting with the Nextmv Cloud API.
+        name : str
+            The name of the integration.
+        integration_type : IntegrationType | str
+            The type of the integration. Please refer to the `IntegrationType`
+            enum for possible values.
+        exec_types : list[ManifestType | str]
+            List of execution types supported by the integration. Please refer
+            to the `ManifestType` enum for possible values.
+        provider : IntegrationProvider | str
+            The provider of the integration. Please refer to the
+            `IntegrationProvider` enum for possible values.
+        provider_config : dict[str, Any]
+            Configuration specific to the integration provider.
+        integration_id : str, optional
+            The unique identifier of the integration. If not provided,
+            it will be generated automatically.
+        description : str, optional
+            An optional description of the integration.
+        is_global : bool, optional, default=False
+            Indicates whether the integration is global (available to all
+            applications in the account). Default is False.
+        application_ids : list[str], optional
+            List of application IDs that have access to this integration.
+        exist_ok : bool, default=False
+            If True and an integration with the same ID already exists,
+            return the existing integration instead of creating a new one.
+
+        Returns
+        -------
+        Integration
+            The created integration instance.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        ValueError
+            If both `is_global` is True and `application_ids` is provided.
+
+        Examples
+        --------
+        >>> from nextmv.cloud import Client, Integration, IntegrationType, IntegrationProvider, ManifestType
+        >>> client = Client(api_key="your_api_key")
+        >>> integration = Integration.new(
+        ...     client=client,
+        ...     name="my_integration",
+        ...     integration_type=IntegrationType.RUNTIME,
+        ...     exec_types=[ManifestType.PYTHON],
+        ...     provider=IntegrationProvider.DBX,
+        ...     provider_config={"config_key": "config_value"},
+        ... )
+        >>> print(integration.to_dict())
+        """
+
+        if is_global and application_ids is not None:
+            raise ValueError("An integration cannot be global and have specific application IDs.")
+        elif not is_global and application_ids is None:
+            raise ValueError("A non-global integration must have specific application IDs.")
+
+        if integration_id is None:
+            integration_id = safe_id("integration")
+
+        if exist_ok:
+            try:
+                integration = cls.get(client=client, integration_id=integration_id)
+                return integration
+            except Exception:
+                pass
+
+        if not isinstance(integration_type, IntegrationType):
+            integration_type = IntegrationType(integration_type)
+
+        if not all(isinstance(exec_type, ManifestType) for exec_type in exec_types):
+            exec_types = [ManifestType(exec_type) for exec_type in exec_types]
+
+        if not isinstance(provider, IntegrationProvider):
+            provider = IntegrationProvider(provider)
+
+        payload = {
+            "id": integration_id,
+            "name": name,
+            "global": is_global,
+            "type": integration_type.value,
+            "exec_types": [exec_type.value for exec_type in exec_types],
+            "provider": provider.value,
+            "provider_config": provider_config,
+        }
+
+        if description is not None:
+            payload["description"] = description
+
+        if application_ids is not None:
+            payload["application_ids"] = application_ids
+
+        response = client.request(
+            method="POST",
+            endpoint="v1/integrations",
+            payload=payload,
+        )
+        response_dict = response.json()
+        response_dict["client"] = client
+        integration = cls.from_dict(response_dict)
+
+        return integration
+
+    def delete(self) -> None:
+        """
+        Deletes the integration from Nextmv Cloud.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> from nextmv.cloud import Client, Integration
+        >>> client = Client(api_key="your_api_key")
+        >>> integration = Integration.get(client=client, integration_id="your_integration_id")
+        >>> integration.delete()
+        """
+
+        _ = self.client.request(
+            method="DELETE",
+            endpoint=self.endpoint,
+        )
+
+    def update(  # noqa: C901
+        self,
+        name: str | None = None,
+        integration_type: IntegrationType | str | None = None,
+        exec_types: list[ManifestType | str] | None = None,
+        provider: IntegrationProvider | str | None = None,
+        provider_config: dict[str, Any] | None = None,
+        description: str | None = None,
+        is_global: bool | None = None,
+        application_ids: list[str] | None = None,
+    ) -> "Integration":
+        """
+        Updates the integration in Nextmv Cloud.
+
+        Parameters
+        ----------
+        name : str, optional
+            The new name of the integration.
+        integration_type : IntegrationType | str, optional
+            The new type of the integration. Please refer to the `IntegrationType`
+            enum for possible values.
+        exec_types : list[ManifestType | str], optional
+            New list of execution types supported by the integration. Please refer
+            to the `ManifestType` enum for possible values.
+        provider : IntegrationProvider | str, optional
+            The new provider of the integration. Please refer to the
+            `IntegrationProvider` enum for possible values.
+        provider_config : dict[str, Any], optional
+            New configuration specific to the integration provider.
+        description : str, optional
+            The new description of the integration.
+        is_global : bool, optional
+            Indicates whether the integration is global (available to all
+            applications in the account). If not provided, the current value
+            is preserved.
+        application_ids : list[str], optional
+            New list of application IDs that have access to this integration.
+
+        Returns
+        -------
+        Integration
+            The updated integration instance.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> from nextmv.cloud import Client, Integration
+        >>> client = Client(api_key="your_api_key")
+        >>> integration = Integration.get(client=client, integration_id="your_integration_id")
+        >>> updated_integration = integration.update(name="new_name")
+        >>> print(updated_integration.to_dict())
+        """
+
+        integration = self.get(client=self.client, integration_id=self.integration_id)
+        integration_dict = integration.to_dict()
+        payload = integration_dict
+
+        if name is not None:
+            payload["name"] = name
+
+        if integration_type is not None:
+            if not isinstance(integration_type, IntegrationType):
+                integration_type = IntegrationType(integration_type)
+            payload["type"] = integration_type.value
+
+        if exec_types is not None:
+            if not all(isinstance(exec_type, ManifestType) for exec_type in exec_types):
+                exec_types = [ManifestType(exec_type) for exec_type in exec_types]
+            payload["exec_types"] = [exec_type.value for exec_type in exec_types]
+
+        if provider is not None:
+            if not isinstance(provider, IntegrationProvider):
+                provider = IntegrationProvider(provider)
+            payload["provider"] = provider.value
+
+        if provider_config is not None:
+            payload["provider_config"] = provider_config
+
+        if description is not None:
+            payload["description"] = description
+
+        if is_global is not None:
+            payload["global"] = is_global
+
+        if application_ids is not None:
+            payload["application_ids"] = application_ids
+
+        # Final validation: ensure invariants are met.
+        if payload["global"] is True and payload.get("application_ids"):
+            raise ValueError(
+                "An integration cannot be global and have application_ids. "
+                "To make an integration global, call update(is_global=True, application_ids=[])."
+            )
+        if payload["global"] is False and not payload.get("application_ids"):
+            raise ValueError(
+                "A non-global integration must have specific application IDs. "
+                "Provide application_ids with at least one ID, or set is_global=True."
+            )
+
+        response = self.client.request(
+            method="PUT",
+            endpoint=self.endpoint,
+            payload=payload,
+        )
+        response_dict = response.json()
+        response_dict["client"] = self.client
+        integration = self.from_dict(response_dict)
+
+        return integration
+
+
+def list_integrations(client: Client) -> list[Integration]:
+    """
+    List all integrations in Nextmv Cloud for the given client.
+
+    You can import the `list_integrations` method directly from `cloud`:
+
+    ```python
+    from nextmv.cloud import list_integrations
+    ```
+
+    Parameters
+    ----------
+    client : Client
+        Client to use for interacting with the Nextmv Cloud API.
+
+    Returns
+    -------
+    list[Integration]
+        List of integrations.
+
+    Raises
+    ------
+    requests.HTTPError
+        If the response status code is not 2xx.
+
+    Examples
+    --------
+    >>> from nextmv.cloud import Client, list_integrations
+    >>> client = Client(api_key="your_api_key")
+    >>> integrations = list_integrations(client=client)
+    >>> for integration in integrations:
+    ...     print(integration.to_dict())
+    """
+
+    response = client.request(
+        method="GET",
+        endpoint="v1/integrations",
+    )
+    response_dict = response.json()
+    integrations = []
+    for integration_data in response_dict.get("items", []):
+        integration_data["client"] = client
+        integration = Integration.from_dict(integration_data)
+        integrations.append(integration)
+
+    return integrations

{nextmv-0.37.0 → nextmv-0.37.2}/nextmv/cloud/package.py

@@ -330,12 +330,12 @@ def __install_dependencies(  # noqa: C901 # complexity
     result = subprocess.run(
         command,
         cwd=app_dir,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,  # Merge stderr into stdout
         text=True,
-        capture_output=True,
-        check=True,
     )
     if result.returncode != 0:
-        raise Exception(f"error installing dependencies: {result.stderr}")
+        raise Exception(f"error installing dependencies: {os.linesep}{result.stdout}")
 
 
 def __run_command(binary: str, dir: str, redirect_out_err: bool, *arguments: str) -> str:

{nextmv-0.37.0 → nextmv-0.37.2}/nextmv/default_app/README.md

@@ -1,4 +1,4 @@
-# Nextmv Application
+# Nextmv application
 
 This is the basic structure of a Nextmv application.
 

{nextmv-0.37.0 → nextmv-0.37.2}/nextmv/input.py

@@ -998,7 +998,7 @@ def load_local(
 
     deprecated(
         name="load_local",
-        reason="`load_local` is deprecated, use `load` instead.",
+        reason="`load_local` is deprecated, use `load` instead",
     )
 
     loader = LocalInputLoader()

{nextmv-0.37.0 → nextmv-0.37.2}/nextmv/local/application.py

@@ -7,7 +7,7 @@ including application management, running applications, and managing inputs.
 Classes
 -------
 Application
-    Class for interacting with local Nextmv Applications.
+    Class for interacting with local Nextmv applications.
 """
 
 import json

{nextmv-0.37.0 → nextmv-0.37.2}/nextmv/model.py

@@ -284,7 +284,7 @@ class Model:
             import mlflow as mlflow
         except ImportError as e:
             raise ImportError(
-                "mlflow is not installed. Please install optional dependencies with `pip install nextmv[all]`"
+                "mlflow is not installed. Please install optional dependencies with `pip install nextmv[notebook]`"
             ) from e
 
         finally:

{nextmv-0.37.0 → nextmv-0.37.2}/nextmv/output.py

@@ -1564,7 +1564,7 @@ def write_local(
 
     deprecated(
         name="write_local",
-        reason="`write_local` is deprecated, use `write` instead.",
+        reason="`write_local` is deprecated, use `write` instead",
     )
 
     writer = LocalOutputWriter()

{nextmv-0.37.0 → nextmv-0.37.2}/pyproject.toml

@@ -51,10 +51,12 @@ Repository = "https://github.com/nextmv-io/nextmv-py"
 
 [project.optional-dependencies]
 all = [
-    "mlflow>=2.17.2",
     "folium>=0.20.0",
     "plotly>=6.0.1",
 ]
+notebook = [
+    "mlflow>=2.19.0",
+]
 dev = [
     "build>=1.0.3",
     "pydantic>=2.5.2",

nextmv-0.37.0/nextmv/__about__.py

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