Fixed mypy using facade pattern on adapters level

Author: IgorChvyrov-sm

src/conductor/asyncio_client/adapters/api/group_resource_api.py

@@ -4,15 +4,24 @@
 
 from pydantic import Field, StrictFloat, StrictInt, StrictStr
 
+from conductor.asyncio_client.adapters.models.granted_access_response_adapter import (
+    GrantedAccessResponseAdapter,
+)
 from conductor.asyncio_client.adapters.models.group_adapter import GroupAdapter
 from conductor.asyncio_client.adapters.models.upsert_group_request_adapter import (
     UpsertGroupRequestAdapter,
 )
 from conductor.asyncio_client.http.api import GroupResourceApi
+from conductor.asyncio_client.adapters.utils import convert_list_to_adapter, convert_to_adapter
+
 
+class GroupResourceApiAdapter:
+    """Adapter for GroupResourceApi that converts between generated models and adapters."""
 
-class GroupResourceApiAdapter(GroupResourceApi):
-    async def list_groups(  # type: ignore[override]
+    def __init__(self, api_client):
+        self._api = GroupResourceApi(api_client)
+
+    async def list_groups(
         self,
         _request_timeout: Union[
             None,
@@ -24,14 +33,15 @@ async def list_groups(  # type: ignore[override]
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> List[GroupAdapter]:
-        result = await super().list_groups(
+        """List all groups, returning GroupAdapter instances."""
+        result = await self._api.list_groups(
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
             _host_index=_host_index,
         )
-        return result  # type: ignore[return-value]
+        return convert_list_to_adapter(result, GroupAdapter)
 
     async def get_group(
         self,
@@ -46,20 +56,21 @@ async def get_group(
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> GroupAdapter:
-        result = await super().get_group(
+        """Get a group by ID, returning a GroupAdapter instance."""
+        result = await self._api.get_group(
             id,
             _request_timeout=_request_timeout,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
             _host_index=_host_index,
         )
-        return result  # type: ignore[return-value]
+        return convert_to_adapter(result, GroupAdapter)
 
     async def upsert_group(
         self,
         id: StrictStr,
-        upsert_group_request: UpsertGroupRequestAdapter,  # type: ignore[override]
+        upsert_group_request: UpsertGroupRequestAdapter,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -70,7 +81,8 @@ async def upsert_group(
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> GroupAdapter:
-        result = await super().upsert_group(
+        """Create or update a group, returning a GroupAdapter instance."""
+        result = await self._api.upsert_group(
             id,
             upsert_group_request,
             _request_timeout=_request_timeout,
@@ -79,5 +91,174 @@ async def upsert_group(
             _headers=_headers,
             _host_index=_host_index,
         )
+        return convert_to_adapter(result, GroupAdapter)
+
+    async def delete_group(
+        self,
+        id: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> None:
+        """Delete a group by ID."""
+        await self._api.delete_group(
+            id,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
 
-        return result  # type: ignore[return-value]
+    async def add_user_to_group(
+        self,
+        group_id: StrictStr,
+        user_id: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> object:
+        """Add a user to a group."""
+        return await self._api.add_user_to_group(
+            group_id,
+            user_id,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    async def remove_user_from_group(
+        self,
+        group_id: StrictStr,
+        user_id: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> object:
+        """Remove a user from a group."""
+        return await self._api.remove_user_from_group(
+            group_id,
+            user_id,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    async def add_users_to_group(
+        self,
+        group_id: StrictStr,
+        request_body: List[StrictStr],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> None:
+        """Add multiple users to a group."""
+        await self._api.add_users_to_group(
+            group_id,
+            request_body,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    async def remove_users_from_group(
+        self,
+        group_id: StrictStr,
+        request_body: List[StrictStr],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> None:
+        """Remove multiple users from a group."""
+        await self._api.remove_users_from_group(
+            group_id,
+            request_body,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    async def get_users_in_group(
+        self,
+        id: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> object:
+        """Get users in a group."""
+        return await self._api.get_users_in_group(
+            id,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    async def get_granted_permissions1(
+        self,
+        group_id: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> GrantedAccessResponseAdapter:
+        """Get granted permissions for a group."""
+        result = await self._api.get_granted_permissions1(
+            group_id,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+        return convert_to_adapter(result, GrantedAccessResponseAdapter)

src/conductor/asyncio_client/adapters/utils.py

@@ -0,0 +1,36 @@
+"""
+Utility functions for converting between generated models and adapters.
+"""
+
+from typing import List, TypeVar, Type, Any
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+
+def convert_list_to_adapter(items: List[Any], adapter_class: Type[T]) -> List[T]:
+    """
+    Convert a list of generated models to a list of adapters.
+
+    Args:
+        items: List of generated model instances
+        adapter_class: The adapter class to convert to
+
+    Returns:
+        List of adapter instances
+    """
+    return [adapter_class.model_validate(item.model_dump()) for item in items]
+
+
+def convert_to_adapter(item: Any, adapter_class: Type[T]) -> T:
+    """
+    Convert a single generated model to an adapter.
+
+    Args:
+        item: Generated model instance
+        adapter_class: The adapter class to convert to
+
+    Returns:
+        Adapter instance
+    """
+    return adapter_class.model_validate(item.model_dump())

src/conductor/asyncio_client/orkes/orkes_authorization_client.py

@@ -18,6 +18,9 @@
 from conductor.asyncio_client.adapters.models.granted_access_adapter import (
     GrantedAccessAdapter as GrantedAccess,
 )
+from conductor.asyncio_client.adapters.models.granted_access_response_adapter import (
+    GrantedAccessResponseAdapter,
+)
 from conductor.asyncio_client.adapters.models.group_adapter import GroupAdapter
 from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter
 from conductor.asyncio_client.adapters.models.target_ref_adapter import (
@@ -169,7 +172,7 @@ async def get_permissions(self, entity_type: str, entity_id: str) -> object:
         """Get permissions for a specific entity (user, group, or application)"""
         return await self.authorization_api.get_permissions(type=entity_type, id=entity_id)
 
-    async def get_group_permissions(self, group_id: str) -> object:
+    async def get_group_permissions(self, group_id: str) -> GrantedAccessResponseAdapter:
         """Get permissions granted to a group"""
         return await self.group_api.get_granted_permissions1(group_id=group_id)