ayon-python-api 1.2.0__tar.gz → 1.2.2__tar.gz

{ayon-python-api-1.2.0/ayon_python_api.egg-info → ayon_python_api-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: ayon-python-api
-Version: 1.2.0
+Name: ayon_python_api
+Version: 1.2.2
 Summary: AYON Python API
 Home-page: https://github.com/ynput/ayon-python-api
 Author: ynput.io

{ayon-python-api-1.2.0 → ayon_python_api-1.2.2}/ayon_api/__init__.py

@@ -80,6 +80,8 @@ from ._api import (
     get_default_fields_for_type,
     get_rest_entity_by_id,
     send_batch_operations,
+    send_background_batch_operations,
+    get_background_operations_status,
     get_installers,
     create_installer,
     update_installer,
@@ -347,6 +349,8 @@ __all__ = (
     "get_default_fields_for_type",
     "get_rest_entity_by_id",
     "send_batch_operations",
+    "send_background_batch_operations",
+    "get_background_operations_status",
     "get_installers",
     "create_installer",
     "update_installer",

{ayon-python-api-1.2.0 → ayon_python_api-1.2.2}/ayon_api/_api.py

@@ -48,6 +48,7 @@ if typing.TYPE_CHECKING:
         ActivityReferenceType,
         EntityListEntityType,
         EntityListItemMode,
+        BackgroundOperationTask,
         LinkDirection,
         EventFilter,
         EventStatus,
@@ -1253,6 +1254,80 @@ def send_batch_operations(
     )
 
 
+def send_background_batch_operations(
+    project_name: str,
+    operations: list[dict[str, Any]],
+    *,
+    can_fail: bool = False,
+    wait: bool = False,
+    raise_on_fail: bool = True,
+) -> BackgroundOperationTask:
+    """Post multiple CRUD operations to server.
+
+    When multiple changes should be made on server side this is the best
+    way to go. It is possible to pass multiple operations to process on a
+    server side and do the changes in a transaction.
+
+    Compared to 'send_batch_operations' this function creates a task on
+        server which then can be periodically checked for a status and
+        receive it's result.
+
+    When used with 'wait' set to 'True' this method blocks until task is
+        finished. Which makes it work as 'send_batch_operations'
+        but safer for large operations batch as is not bound to
+        response timeout.
+
+    Args:
+        project_name (str): On which project should be operations
+            processed.
+        operations (list[dict[str, Any]]): Operations to be processed.
+        can_fail (Optional[bool]): Server will try to process all
+            operations even if one of them fails.
+        wait (bool): Wait for operations to end.
+        raise_on_fail (Optional[bool]): Raise exception if an operation
+            fails. You can handle failed operations on your own
+            when set to 'False'. Used when 'wait' is enabled.
+
+    Raises:
+        ValueError: Operations can't be converted to json string.
+        FailedOperations: When output does not contain server operations
+            or 'raise_on_fail' is enabled and any operation fails.
+
+    Returns:
+        BackgroundOperationTask: Background operation.
+
+    """
+    con = get_server_api_connection()
+    return con.send_background_batch_operations(
+        project_name=project_name,
+        operations=operations,
+        can_fail=can_fail,
+        wait=wait,
+        raise_on_fail=raise_on_fail,
+    )
+
+
+def get_background_operations_status(
+    project_name: str,
+    task_id: str,
+) -> BackgroundOperationTask:
+    """Get status of background operations task.
+
+    Args:
+        project_name (str): Project name.
+        task_id (str): Backgorund operation task id.
+
+    Returns:
+        BackgroundOperationTask: Background operation.
+
+    """
+    con = get_server_api_connection()
+    return con.get_background_operations_status(
+        project_name=project_name,
+        task_id=task_id,
+    )
+
+
 def get_installers(
     version: Optional[str] = None,
     platform_name: Optional[str] = None,

ayon_python_api-1.2.2/ayon_api/_api_helpers/__init__.py

@@ -0,0 +1,42 @@
+from .base import BaseServerAPI
+from .installers import InstallersAPI
+from .dependency_packages import DependencyPackagesAPI
+from .secrets import SecretsAPI
+from .bundles_addons import BundlesAddonsAPI
+from .events import EventsAPI
+from .attributes import AttributesAPI
+from .projects import ProjectsAPI
+from .folders import FoldersAPI
+from .tasks import TasksAPI
+from .products import ProductsAPI
+from .versions import VersionsAPI
+from .representations import RepresentationsAPI
+from .workfiles import WorkfilesAPI
+from .thumbnails import ThumbnailsAPI
+from .activities import ActivitiesAPI
+from .actions import ActionsAPI
+from .links import LinksAPI
+from .lists import ListsAPI
+
+
+__all__ = (
+    "BaseServerAPI",
+    "InstallersAPI",
+    "DependencyPackagesAPI",
+    "SecretsAPI",
+    "BundlesAddonsAPI",
+    "EventsAPI",
+    "AttributesAPI",
+    "ProjectsAPI",
+    "FoldersAPI",
+    "TasksAPI",
+    "ProductsAPI",
+    "VersionsAPI",
+    "RepresentationsAPI",
+    "WorkfilesAPI",
+    "ThumbnailsAPI",
+    "ActivitiesAPI",
+    "ActionsAPI",
+    "LinksAPI",
+    "ListsAPI",
+)

ayon_python_api-1.2.2/ayon_api/_api_helpers/actions.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+import typing
+from typing import Optional, Any
+
+from ayon_api.utils import prepare_query_string
+
+from .base import BaseServerAPI
+
+if typing.TYPE_CHECKING:
+    from ayon_api.typing import (
+        ActionEntityTypes,
+        ActionManifestDict,
+        ActionTriggerResponse,
+        ActionTakeResponse,
+        ActionConfigResponse,
+        ActionModeType,
+    )
+
+
+class ActionsAPI(BaseServerAPI):
+    """Implementation of actions API for ServerAPI."""
+    def get_actions(
+        self,
+        project_name: Optional[str] = None,
+        entity_type: Optional[ActionEntityTypes] = None,
+        entity_ids: Optional[list[str]] = None,
+        entity_subtypes: Optional[list[str]] = None,
+        form_data: Optional[dict[str, Any]] = None,
+        *,
+        variant: Optional[str] = None,
+        mode: Optional[ActionModeType] = None,
+    ) -> list[ActionManifestDict]:
+        """Get actions for a context.
+
+        Args:
+            project_name (Optional[str]): Name of the project. None for global
+                actions.
+            entity_type (Optional[ActionEntityTypes]): Entity type where the
+                action is triggered. None for global actions.
+            entity_ids (Optional[list[str]]): list of entity ids where the
+                action is triggered. None for global actions.
+            entity_subtypes (Optional[list[str]]): list of entity subtypes
+                folder types for folder ids, task types for tasks ids.
+            form_data (Optional[dict[str, Any]]): Form data of the action.
+            variant (Optional[str]): Settings variant.
+            mode (Optional[ActionModeType]): Action modes.
+
+        Returns:
+            list[ActionManifestDict]: list of action manifests.
+
+        """
+        if variant is None:
+            variant = self.get_default_settings_variant()
+        query_data = {"variant": variant}
+        if mode:
+            query_data["mode"] = mode
+        query = prepare_query_string(query_data)
+        kwargs = {
+            key: value
+            for key, value in (
+                ("projectName", project_name),
+                ("entityType", entity_type),
+                ("entityIds", entity_ids),
+                ("entitySubtypes", entity_subtypes),
+                ("formData", form_data),
+            )
+            if value is not None
+        }
+        response = self.post(f"actions/list{query}", **kwargs)
+        response.raise_for_status()
+        return response.data["actions"]
+
+    def trigger_action(
+        self,
+        identifier: str,
+        addon_name: str,
+        addon_version: str,
+        project_name: Optional[str] = None,
+        entity_type: Optional[ActionEntityTypes] = None,
+        entity_ids: Optional[list[str]] = None,
+        entity_subtypes: Optional[list[str]] = None,
+        form_data: Optional[dict[str, Any]] = None,
+        *,
+        variant: Optional[str] = None,
+    ) -> ActionTriggerResponse:
+        """Trigger action.
+
+        Args:
+            identifier (str): Identifier of the action.
+            addon_name (str): Name of the addon.
+            addon_version (str): Version of the addon.
+            project_name (Optional[str]): Name of the project. None for global
+                actions.
+            entity_type (Optional[ActionEntityTypes]): Entity type where the
+                action is triggered. None for global actions.
+            entity_ids (Optional[list[str]]): list of entity ids where the
+                action is triggered. None for global actions.
+            entity_subtypes (Optional[list[str]]): list of entity subtypes
+                folder types for folder ids, task types for tasks ids.
+            form_data (Optional[dict[str, Any]]): Form data of the action.
+            variant (Optional[str]): Settings variant.
+
+        """
+        if variant is None:
+            variant = self.get_default_settings_variant()
+        query_data = {
+            "addonName": addon_name,
+            "addonVersion": addon_version,
+            "identifier": identifier,
+            "variant": variant,
+        }
+        query = prepare_query_string(query_data)
+
+        kwargs = {
+            key: value
+            for key, value in (
+                ("projectName", project_name),
+                ("entityType", entity_type),
+                ("entityIds", entity_ids),
+                ("entitySubtypes", entity_subtypes),
+                ("formData", form_data),
+            )
+            if value is not None
+        }
+
+        response = self.post(f"actions/execute{query}", **kwargs)
+        response.raise_for_status()
+        return response.data
+
+    def get_action_config(
+        self,
+        identifier: str,
+        addon_name: str,
+        addon_version: str,
+        project_name: Optional[str] = None,
+        entity_type: Optional[ActionEntityTypes] = None,
+        entity_ids: Optional[list[str]] = None,
+        entity_subtypes: Optional[list[str]] = None,
+        form_data: Optional[dict[str, Any]] = None,
+        *,
+        variant: Optional[str] = None,
+    ) -> ActionConfigResponse:
+        """Get action configuration.
+
+        Args:
+            identifier (str): Identifier of the action.
+            addon_name (str): Name of the addon.
+            addon_version (str): Version of the addon.
+            project_name (Optional[str]): Name of the project. None for global
+                actions.
+            entity_type (Optional[ActionEntityTypes]): Entity type where the
+                action is triggered. None for global actions.
+            entity_ids (Optional[list[str]]): list of entity ids where the
+                action is triggered. None for global actions.
+            entity_subtypes (Optional[list[str]]): list of entity subtypes
+                folder types for folder ids, task types for tasks ids.
+            form_data (Optional[dict[str, Any]]): Form data of the action.
+            variant (Optional[str]): Settings variant.
+
+        Returns:
+            ActionConfigResponse: Action configuration data.
+
+        """
+        return self._send_config_request(
+            identifier,
+            addon_name,
+            addon_version,
+            None,
+            project_name,
+            entity_type,
+            entity_ids,
+            entity_subtypes,
+            form_data,
+            variant,
+        )
+
+    def set_action_config(
+        self,
+        identifier: str,
+        addon_name: str,
+        addon_version: str,
+        value: dict[str, Any],
+        project_name: Optional[str] = None,
+        entity_type: Optional[ActionEntityTypes] = None,
+        entity_ids: Optional[list[str]] = None,
+        entity_subtypes: Optional[list[str]] = None,
+        form_data: Optional[dict[str, Any]] = None,
+        *,
+        variant: Optional[str] = None,
+    ) -> ActionConfigResponse:
+        """Set action configuration.
+
+        Args:
+            identifier (str): Identifier of the action.
+            addon_name (str): Name of the addon.
+            addon_version (str): Version of the addon.
+            value (Optional[dict[str, Any]]): Value of the action
+                configuration.
+            project_name (Optional[str]): Name of the project. None for global
+                actions.
+            entity_type (Optional[ActionEntityTypes]): Entity type where the
+                action is triggered. None for global actions.
+            entity_ids (Optional[list[str]]): list of entity ids where the
+                action is triggered. None for global actions.
+            entity_subtypes (Optional[list[str]]): list of entity subtypes
+                folder types for folder ids, task types for tasks ids.
+            form_data (Optional[dict[str, Any]]): Form data of the action.
+            variant (Optional[str]): Settings variant.
+
+        Returns:
+            ActionConfigResponse: New action configuration data.
+
+        """
+        return self._send_config_request(
+            identifier,
+            addon_name,
+            addon_version,
+            value,
+            project_name,
+            entity_type,
+            entity_ids,
+            entity_subtypes,
+            form_data,
+            variant,
+        )
+
+    def take_action(self, action_token: str) -> ActionTakeResponse:
+        """Take action metadata using an action token.
+
+        Args:
+            action_token (str): AYON launcher action token.
+
+        Returns:
+            ActionTakeResponse: Action metadata describing how to launch
+                action.
+
+        """
+        response = self.get(f"actions/abort/{action_token}")
+        response.raise_for_status()
+        return response.data
+
+    def abort_action(
+        self,
+        action_token: str,
+        message: Optional[str] = None,
+    ) -> None:
+        """Abort action using an action token.
+
+        Args:
+            action_token (str): AYON launcher action token.
+            message (Optional[str]): Message to display in the UI.
+
+        """
+        if message is None:
+            message = "Action aborted"
+        response = self.post(
+            f"actions/abort/{action_token}",
+            message=message,
+        )
+        response.raise_for_status()
+
+    def _send_config_request(
+        self,
+        identifier: str,
+        addon_name: str,
+        addon_version: str,
+        value: Optional[dict[str, Any]],
+        project_name: Optional[str],
+        entity_type: Optional[ActionEntityTypes],
+        entity_ids: Optional[list[str]],
+        entity_subtypes: Optional[list[str]],
+        form_data: Optional[dict[str, Any]],
+        variant: Optional[str],
+    ) -> ActionConfigResponse:
+        """Set and get action configuration."""
+        if variant is None:
+            variant = self.get_default_settings_variant()
+        query_data = {
+            "addonName": addon_name,
+            "addonVersion": addon_version,
+            "identifier": identifier,
+            "variant": variant,
+        }
+        query = prepare_query_string(query_data)
+
+        kwargs = {
+            query_key: query_value
+            for query_key, query_value in (
+                ("projectName", project_name),
+                ("entityType", entity_type),
+                ("entityIds", entity_ids),
+                ("entitySubtypes", entity_subtypes),
+                ("formData", form_data),
+            )
+            if query_value is not None
+        }
+        if value is not None:
+            kwargs["value"] = value
+
+        response = self.post(f"actions/config{query}", **kwargs)
+        response.raise_for_status()
+        return response.data