✨ Implement WebServer RPC Client and subclients for projects, licenses, and functions

Author: pcrespov

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/webserver/v1/__init__.py

@@ -0,0 +1,16 @@
+"""WebServer RPC Client Package
+
+Provides a class-based, modular RPC client for webserver services.
+"""
+
+from .client import WebServerRpcClient
+from .functions import FunctionsRpcApi
+from .licenses import LicensesRpcApi
+from .projects import ProjectsRpcApi
+
+__all__: tuple[str, ...] = (
+    "WebServerRpcClient",
+    "ProjectsRpcApi",
+    "LicensesRpcApi",
+    "FunctionsRpcApi",
+)

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/webserver/v1/_base.py

@@ -0,0 +1,32 @@
+"""Base classes and shared functionality for RPC subclients."""
+
+from typing import Any
+
+from models_library.products import ProductName
+from models_library.rabbitmq_basic_types import RPCMethodName, RPCNamespace
+from models_library.users import UserID
+from servicelib.rabbitmq import RabbitMQRPCClient
+
+
+class BaseRpcApi:
+    """Base class for all RPC API subclients."""
+
+    def __init__(self, rpc_client: RabbitMQRPCClient, namespace: RPCNamespace):
+        self._rpc_client = rpc_client
+        self._namespace = namespace
+
+    async def _request(
+        self,
+        method_name: RPCMethodName,
+        *,
+        product_name: ProductName,
+        user_id: UserID,
+        **kwargs: Any
+    ) -> Any:
+        return await self._rpc_client.request(
+            self._namespace,
+            method_name,
+            product_name=product_name,
+            user_id=user_id,
+            **kwargs
+        )

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/webserver/v1/client.py

@@ -0,0 +1,36 @@
+"""Main WebServer RPC Client."""
+
+from models_library.rabbitmq_basic_types import RPCNamespace
+from models_library.rpc.webserver import WEBSERVER_RPC_NAMESPACE
+from servicelib.rabbitmq import RabbitMQRPCClient
+
+from .functions import FunctionsRpcApi
+from .licenses import LicensesRpcApi
+from .projects import ProjectsRpcApi
+
+
+class WebServerRpcClient:
+    """Main RPC client for webserver services."""
+
+    def __init__(
+        self,
+        rpc_client: RabbitMQRPCClient,
+        namespace: RPCNamespace = WEBSERVER_RPC_NAMESPACE,
+    ):
+        self._rpc_client = rpc_client
+        self._namespace = namespace
+
+        # Initialize subclients
+        self.projects = ProjectsRpcApi(rpc_client, namespace)
+        self.licenses = LicensesRpcApi(rpc_client, namespace)
+        self.functions = FunctionsRpcApi(rpc_client, namespace)
+
+    @property
+    def namespace(self) -> RPCNamespace:
+        return self._namespace
+
+    async def close(self) -> None:
+        """Close the underlying RPC client connection."""
+        # Delegate to the underlying client if it has a close method
+        if hasattr(self._rpc_client, "close"):
+            await self._rpc_client.close()

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/webserver/v1/functions.py

@@ -0,0 +1,48 @@
+"""Functions RPC API subclient."""
+
+from typing import Any
+
+from ._base import BaseRpcApi
+
+
+class FunctionsRpcApi(BaseRpcApi):
+    """RPC client for function-related operations."""
+
+    async def get_function(self, user_id: int, function_id: str) -> dict[str, Any]:
+        """Get a function by ID."""
+        return await self._request(
+            "get_function", user_id=user_id, function_id=function_id
+        )
+
+    async def list_functions(
+        self, user_id: int, *, limit: int | None = None, offset: int = 0
+    ) -> list[dict[str, Any]]:
+        """List available functions."""
+        return await self._request(
+            "list_functions", user_id=user_id, limit=limit, offset=offset
+        )
+
+    async def create_function(
+        self, user_id: int, function_data: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Create a new function."""
+        return await self._request(
+            "create_function", user_id=user_id, function_data=function_data
+        )
+
+    async def update_function(
+        self, user_id: int, function_id: str, function_patch: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Update an existing function."""
+        return await self._request(
+            "update_function",
+            user_id=user_id,
+            function_id=function_id,
+            function_patch=function_patch,
+        )
+
+    async def delete_function(self, user_id: int, function_id: str) -> None:
+        """Delete a function."""
+        return await self._request(
+            "delete_function", user_id=user_id, function_id=function_id
+        )

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/webserver/v1/licenses.py

@@ -0,0 +1,67 @@
+"""Licenses RPC API subclient."""
+
+from typing import Any
+
+from ._base import BaseRpcApi
+
+
+class LicensesRpcApi(BaseRpcApi):
+    """RPC client for license-related operations."""
+
+    async def get_licensed_items_for_wallet(
+        self, user_id: int, product_name: str, wallet_id: int | None = None
+    ) -> list[dict[str, Any]]:
+        """Get licensed items for a wallet."""
+        return await self._request(
+            "get_licensed_items_for_wallet",
+            user_id=user_id,
+            product_name=product_name,
+            wallet_id=wallet_id,
+        )
+
+    async def get_licensed_items_checkouts_for_wallet(
+        self, user_id: int, product_name: str, wallet_id: int | None = None
+    ) -> list[dict[str, Any]]:
+        """Get licensed items checkouts for a wallet."""
+        return await self._request(
+            "get_licensed_items_checkouts_for_wallet",
+            user_id=user_id,
+            product_name=product_name,
+            wallet_id=wallet_id,
+        )
+
+    async def checkout_licensed_item_for_wallet(
+        self,
+        user_id: int,
+        product_name: str,
+        licensed_item_id: str,
+        wallet_id: int,
+        num_of_seats: int,
+        service_run_id: str,
+    ) -> dict[str, Any]:
+        """Checkout a licensed item for a wallet."""
+        return await self._request(
+            "checkout_licensed_item_for_wallet",
+            user_id=user_id,
+            product_name=product_name,
+            licensed_item_id=licensed_item_id,
+            wallet_id=wallet_id,
+            num_of_seats=num_of_seats,
+            service_run_id=service_run_id,
+        )
+
+    async def release_licensed_item_for_wallet(
+        self,
+        user_id: int,
+        product_name: str,
+        licensed_item_checkout_id: str,
+        wallet_id: int,
+    ) -> None:
+        """Release a licensed item checkout for a wallet."""
+        return await self._request(
+            "release_licensed_item_for_wallet",
+            user_id=user_id,
+            product_name=product_name,
+            licensed_item_checkout_id=licensed_item_checkout_id,
+            wallet_id=wallet_id,
+        )

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/webserver/v1/projects.py

@@ -0,0 +1,77 @@
+"""Projects RPC API subclient."""
+
+from typing import Any
+from uuid import UUID
+
+from ._base import BaseRpcApi
+
+
+class ProjectsRpcApi(BaseRpcApi):
+    """RPC client for project-related operations."""
+
+    async def get_project(
+        self, user_id: int, project_uuid: UUID, *, include: list[str] | None = None
+    ) -> dict[str, Any]:
+        """Get a project by UUID."""
+        return await self._request(
+            "get_project",
+            user_id=user_id,
+            project_uuid=project_uuid,
+            include=include or [],
+        )
+
+    async def list_projects(
+        self,
+        user_id: int,
+        *,
+        filter_by_services: list[str] | None = None,
+        filter_by_study_services: list[str] | None = None,
+        offset: int = 0,
+        limit: int | None = None,
+        order_by: dict[str, str] | None = None,
+        search: str | None = None
+    ) -> dict[str, Any]:
+        """List projects for a user."""
+        return await self._request(
+            "list_projects",
+            user_id=user_id,
+            filter_by_services=filter_by_services or [],
+            filter_by_study_services=filter_by_study_services or [],
+            offset=offset,
+            limit=limit,
+            order_by=order_by or {},
+            search=search,
+        )
+
+    async def create_project(
+        self, user_id: int, project: dict[str, Any], *, as_template: bool = False
+    ) -> dict[str, Any]:
+        """Create a new project."""
+        return await self._request(
+            "create_project", user_id=user_id, project=project, as_template=as_template
+        )
+
+    async def update_project(
+        self, user_id: int, project_uuid: UUID, project_patch: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Update an existing project."""
+        return await self._request(
+            "update_project",
+            user_id=user_id,
+            project_uuid=project_uuid,
+            project_patch=project_patch,
+        )
+
+    async def delete_project(self, user_id: int, project_uuid: UUID) -> None:
+        """Delete a project."""
+        return await self._request(
+            "delete_project", user_id=user_id, project_uuid=project_uuid
+        )
+
+    async def clone_project(
+        self, user_id: int, project_uuid: UUID, *, hidden: bool = False
+    ) -> dict[str, Any]:
+        """Clone an existing project."""
+        return await self._request(
+            "clone_project", user_id=user_id, project_uuid=project_uuid, hidden=hidden
+        )