nextmv 0.18.0__py3-none-any.whl → 1.0.0.dev2__py3-none-any.whl

nextmv/cloud/application/_instance.py

@@ -0,0 +1,289 @@
+"""
+Application mixin for managing app instances.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+import requests
+
+from nextmv.cloud.application._utils import _is_not_exist_error
+from nextmv.cloud.instance import Instance, InstanceConfiguration
+from nextmv.safe import safe_id
+
+if TYPE_CHECKING:
+    from . import Application
+
+
+class ApplicationInstanceMixin:
+    """
+    Mixin class for managing app instances within an application.
+    """
+
+    def delete_instance(self: "Application", instance_id: str) -> None:
+        """
+        Delete an instance.
+
+        Permanently removes the specified instance from the application.
+
+        Parameters
+        ----------
+        instance_id : str
+            ID of the instance to delete.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> app.delete_instance("prod-instance")  # Permanently deletes the instance
+        """
+
+        _ = self.client.request(
+            method="DELETE",
+            endpoint=f"{self.endpoint}/instances/{instance_id}",
+        )
+
+    def instance(self: "Application", instance_id: str) -> Instance:
+        """
+        Get an instance.
+
+        Parameters
+        ----------
+        instance_id : str
+            ID of the instance to retrieve.
+
+        Returns
+        -------
+        Instance
+            The requested instance details.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> instance = app.instance("instance-123")
+        >>> print(instance.name)
+        'Production Instance'
+        """
+
+        response = self.client.request(
+            method="GET",
+            endpoint=f"{self.endpoint}/instances/{instance_id}",
+        )
+
+        return Instance.from_dict(response.json())
+
+    def instance_exists(self: "Application", instance_id: str) -> bool:
+        """
+        Check if an instance exists.
+
+        Parameters
+        ----------
+        instance_id : str
+            ID of the instance to check.
+
+        Returns
+        -------
+        bool
+            True if the instance exists, False otherwise.
+
+        Examples
+        --------
+        >>> app.instance_exists("instance-123")
+        True
+        """
+
+        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_instances(self: "Application") -> list[Instance]:
+        """
+        List all instances.
+
+        Returns
+        -------
+        list[Instance]
+            List of all instances associated with this application.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> instances = app.list_instances()
+        >>> for instance in instances:
+        ...     print(instance.name)
+        'Development Instance'
+        'Production Instance'
+        """
+
+        response = self.client.request(
+            method="GET",
+            endpoint=f"{self.endpoint}/instances",
+        )
+
+        return [Instance.from_dict(instance) for instance in response.json()]
+
+    def new_instance(
+        self: "Application",
+        version_id: str,
+        id: str | None = None,
+        name: str | None = None,
+        description: str | None = None,
+        configuration: InstanceConfiguration | None = None,
+        exist_ok: bool = False,
+    ) -> Instance:
+        """
+        Create a new instance and associate it with a version.
+
+        This method creates a new instance associated with a specific version
+        of the application. Instances are configurations of an application
+        version that can be executed.
+
+        Parameters
+        ----------
+        version_id : str
+            ID of the version to associate the instance with.
+        id : str | None, default=None
+            ID of the instance. Will be generated if not provided.
+        name : str | None, default=None
+            Name of the instance. Will be generated if not provided.
+        description : Optional[str], default=None
+            Description of the instance.
+        configuration : Optional[InstanceConfiguration], default=None
+            Configuration to use for the instance. This can include resources,
+            timeouts, and other execution parameters.
+        exist_ok : bool, default=False
+            If True and an instance with the same ID already exists,
+            return the existing instance instead of creating a new one.
+
+        Returns
+        -------
+        Instance
+            The newly created (or existing) instance.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        ValueError
+            If exist_ok is True and id is None.
+
+        Examples
+        --------
+        >>> # Create a new instance for a specific version
+        >>> instance = app.new_instance(
+        ...     version_id="version-123",
+        ...     id="prod-instance",
+        ...     name="Production Instance",
+        ...     description="Instance for production use"
+        ... )
+        >>> print(instance.name)
+        'Production Instance'
+        """
+
+        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)
+
+        if id is None:
+            id = safe_id(prefix="instance")
+        if name is None:
+            name = id
+
+        payload = {
+            "id": id,
+            "name": name,
+            "version_id": version_id,
+        }
+
+        if description is not None:
+            payload["description"] = description
+        if configuration is not None:
+            payload["configuration"] = configuration.to_dict()
+
+        response = self.client.request(
+            method="POST",
+            endpoint=f"{self.endpoint}/instances",
+            payload=payload,
+        )
+
+        return Instance.from_dict(response.json())
+
+    def update_instance(
+        self: "Application",
+        id: str,
+        name: str | None = None,
+        version_id: str | None = None,
+        description: str | None = None,
+        configuration: InstanceConfiguration | dict[str, Any] | None = None,
+    ) -> Instance:
+        """
+        Update an instance.
+
+        Parameters
+        ----------
+        id : str
+            ID of the instance to update.
+        name : Optional[str], default=None
+            Optional name of the instance.
+        version_id : Optional[str], default=None
+            Optional ID of the version to associate the instance with.
+        description : Optional[str], default=None
+            Optional description of the instance.
+        configuration : Optional[InstanceConfiguration | dict[str, Any]], default=None
+            Optional configuration to use for the instance.
+
+        Returns
+        -------
+        Instance
+            The updated instance.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        """
+
+        # Get the instance as it currently exsits.
+        instance = self.instance(id)
+        instance_dict = instance.to_dict()
+        payload = instance_dict.copy()
+
+        if name is not None:
+            payload["name"] = name
+        if version_id is not None:
+            payload["version_id"] = version_id
+        if description is not None:
+            payload["description"] = description
+        if configuration is not None:
+            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",
+            endpoint=f"{self.endpoint}/instances/{id}",
+            payload=payload,
+        )
+
+        return Instance.from_dict(response.json())

nextmv/cloud/application/_managed_input.py

@@ -0,0 +1,227 @@
+"""
+Application mixin for handling app managed inputs.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from nextmv.cloud.input_set import ManagedInput
+from nextmv.input import InputFormat
+from nextmv.output import OutputFormat
+from nextmv.run import Format, FormatInput, FormatOutput
+from nextmv.safe import safe_id
+
+if TYPE_CHECKING:
+    from . import Application
+
+
+class ApplicationManagedInputMixin:
+    """
+    Mixin class for handling app managed inputs within an application.
+    """
+
+    def delete_managed_input(self: "Application", managed_input_id: str) -> None:
+        """
+        Delete a managed input.
+
+        Permanently removes the specified managed input from the application.
+
+        Parameters
+        ----------
+        managed_input_id : str
+            ID of the managed input to delete.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+
+        Examples
+        --------
+        >>> app.delete_managed_input("inp_123456789")  # Permanently deletes the managed input
+        """
+
+        _ = self.client.request(
+            method="DELETE",
+            endpoint=f"{self.endpoint}/inputs/{managed_input_id}",
+        )
+
+    def list_managed_inputs(self: "Application") -> list[ManagedInput]:
+        """
+        List all managed inputs.
+
+        Returns
+        -------
+        list[ManagedInput]
+            List of managed inputs.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        """
+
+        response = self.client.request(
+            method="GET",
+            endpoint=f"{self.endpoint}/inputs",
+        )
+
+        return [ManagedInput.from_dict(managed_input) for managed_input in response.json()]
+
+    def managed_input(self: "Application", managed_input_id: str) -> ManagedInput:
+        """
+        Get a managed input.
+
+        Parameters
+        ----------
+        managed_input_id: str
+            ID of the managed input.
+
+        Returns
+        -------
+        ManagedInput
+            The managed input.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        """
+
+        response = self.client.request(
+            method="GET",
+            endpoint=f"{self.endpoint}/inputs/{managed_input_id}",
+        )
+
+        return ManagedInput.from_dict(response.json())
+
+    def new_managed_input(
+        self: "Application",
+        id: str | None = None,
+        name: str | None = None,
+        description: str | None = None,
+        upload_id: str | None = None,
+        run_id: str | None = None,
+        format: Format | dict[str, Any] | None = None,
+    ) -> ManagedInput:
+        """
+        Create a new managed input. There are two methods for creating a
+        managed input:
+
+        1. Specifying the `upload_id` parameter. You may use the `upload_url`
+           method to obtain the upload ID and the `upload_data` method
+           to upload the data to it.
+        2. Specifying the `run_id` parameter. The managed input will be
+           created from the run specified by the `run_id` parameter.
+
+        Either the `upload_id` or the `run_id` parameter must be specified.
+
+        Parameters
+        ----------
+        id: Optional[str], default=None
+            ID of the managed input. Will be generated if not provided.
+        name: Optional[str], default=None
+            Name of the managed input. Will be generated if not provided.
+        description: Optional[str], default=None
+            Optional description of the managed input.
+        upload_id: Optional[str], default=None
+            ID of the upload to use for the managed input.
+        run_id: Optional[str], default=None
+            ID of the run to use for the managed input.
+        format: Optional[Format], default=None
+            Format of the managed input. Default will be formatted as `JSON`.
+
+        Returns
+        -------
+        ManagedInput
+            The new managed input.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        ValueError
+            If neither the `upload_id` nor the `run_id` parameter is
+            specified.
+        """
+
+        if upload_id is None and run_id is None:
+            raise ValueError("Either upload_id or run_id must be specified")
+
+        if id is None:
+            id = safe_id(prefix="managed-input")
+        if name is None:
+            name = id
+
+        payload = {
+            "id": id,
+            "name": name,
+        }
+
+        if description is not None:
+            payload["description"] = description
+        if upload_id is not None:
+            payload["upload_id"] = upload_id
+        if run_id is not None:
+            payload["run_id"] = run_id
+
+        if format is not None:
+            payload["format"] = format.to_dict() if isinstance(format, Format) else format
+        else:
+            payload["format"] = Format(
+                format_input=FormatInput(input_type=InputFormat.JSON),
+                format_output=FormatOutput(output_type=OutputFormat.JSON),
+            ).to_dict()
+
+        response = self.client.request(
+            method="POST",
+            endpoint=f"{self.endpoint}/inputs",
+            payload=payload,
+        )
+
+        return ManagedInput.from_dict(response.json())
+
+    def update_managed_input(
+        self: "Application",
+        managed_input_id: str,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> ManagedInput:
+        """
+        Update a managed input.
+
+        Parameters
+        ----------
+        managed_input_id : str
+            ID of the managed input to update.
+        name : Optional[str], default=None
+            Optional new name for the managed input.
+        description : Optional[str], default=None
+            Optional new description for the managed input.
+
+        Returns
+        -------
+        ManagedInput
+            The updated managed input.
+
+        Raises
+        ------
+        requests.HTTPError
+            If the response status code is not 2xx.
+        """
+
+        managed_input = self.managed_input(managed_input_id)
+        managed_input_dict = managed_input.to_dict()
+        payload = managed_input_dict.copy()
+
+        if name is not None:
+            payload["name"] = name
+        if description is not None:
+            payload["description"] = description
+
+        response = self.client.request(
+            method="PUT",
+            endpoint=f"{self.endpoint}/inputs/{managed_input_id}",
+            payload=payload,
+        )
+
+        return ManagedInput.from_dict(response.json())