Synced async and sync clients

Author: IgorChvyrov-sm

src/conductor/asyncio_client/orkes/orkes_authorization_client.py

@@ -129,11 +129,11 @@ async def get_user_permissions(
     @deprecated("create_application is deprecated; use create_application_validated instead")
     @typing_deprecated("create_application is deprecated; use create_application_validated instead")
     async def create_application(
-        self, application: CreateOrUpdateApplicationRequestAdapter
+        self, create_or_update_application_request: CreateOrUpdateApplicationRequestAdapter
     ) -> object:
         """Create a new application"""
         result = await self._application_api.create_application(
-            create_or_update_application_request=application
+            create_or_update_application_request=create_or_update_application_request
         )
         return result
 
@@ -156,17 +156,20 @@ async def update_application(
         self, application_id: str, application: CreateOrUpdateApplicationRequestAdapter
     ) -> object:
         """Update an existing application"""
-        result = await self._application_api.update_application(
-            id=application_id, create_or_update_application_request=application
-        )
+        result = await self._application_api.update_application(application_id, application)
         return result
 
     async def update_application_validated(
-        self, application_id: str, application: CreateOrUpdateApplicationRequestAdapter, **kwargs
+        self,
+        application_id: str,
+        create_or_update_application_request: CreateOrUpdateApplicationRequestAdapter,
+        **kwargs,
     ) -> Optional[ExtendedConductorApplicationAdapter]:
         """Update an existing application and return a validated ExtendedConductorApplicationAdapter"""
         result = await self._application_api.update_application(
-            id=application_id, create_or_update_application_request=application, **kwargs
+            id=application_id,
+            create_or_update_application_request=create_or_update_application_request,
+            **kwargs,
         )
 
         result_dict = cast(Dict[str, Any], result)
@@ -363,11 +366,11 @@ async def get_permissions(self, entity_type: str, entity_id: str) -> object:
         return await self._authorization_api.get_permissions(type=entity_type, id=entity_id)
 
     async def get_permissions_validated(
-        self, entity_type: str, entity_id: str, **kwargs
+        self, target: TargetRefAdapter, **kwargs
     ) -> Dict[str, List[SubjectRefAdapter]]:
         """Get permissions for a specific entity (user, group, or application) and return a dictionary of access types and validated SubjectRefAdapters"""
         result = await self._authorization_api.get_permissions(
-            type=entity_type, id=entity_id, **kwargs
+            type=target.type, id=target.id, **kwargs
         )
 
         permissions = {}
@@ -408,15 +411,17 @@ async def upsert_group(
     async def set_application_tags(
         self, tags: List[TagAdapter], application_id: str, **kwargs
     ) -> None:
-        await self._application_api.put_tag_for_application(application_id, tags, **kwargs)
+        await self._application_api.put_tag_for_application(id=application_id, tag=tags, **kwargs)
 
     async def get_application_tags(self, application_id: str, **kwargs) -> List[TagAdapter]:
-        return await self._application_api.get_tags_for_application(application_id, **kwargs)
+        return await self._application_api.get_tags_for_application(id=application_id, **kwargs)
 
     async def delete_application_tags(
         self, tags: List[TagAdapter], application_id: str, **kwargs
     ) -> None:
-        await self._application_api.delete_tag_for_application(application_id, tags, **kwargs)
+        await self._application_api.delete_tag_for_application(
+            id=application_id, tag=tags, **kwargs
+        )
 
     @deprecated("create_access_key is deprecated; use create_access_key_validated instead")
     @typing_deprecated("create_access_key is deprecated; use create_access_key_validated instead")
@@ -428,7 +433,7 @@ async def create_access_key_validated(
         self, application_id: str, **kwargs
     ) -> CreatedAccessKeyAdapter:
         """Create an access key and return a validated CreatedAccessKeyAdapter"""
-        result = await self._application_api.create_access_key(application_id, **kwargs)
+        result = await self._application_api.create_access_key(id=application_id, **kwargs)
 
         result_dict = cast(Dict[str, Any], result)
         result_model = CreatedAccessKeyAdapter.from_dict(result_dict)
@@ -467,7 +472,7 @@ async def toggle_access_key_status_validated(
     ) -> AccessKeyAdapter:
         """Toggle the status of an access key and return a validated AccessKeyAdapter"""
         result = await self._application_api.toggle_access_key_status(
-            application_id, key_id, **kwargs
+            application_id=application_id, key_id=key_id, **kwargs
         )
 
         result_dict = cast(Dict[str, Any], result)
@@ -476,22 +481,26 @@ async def toggle_access_key_status_validated(
         return result_model
 
     async def delete_access_key(self, application_id: str, key_id: str, **kwargs) -> None:
-        await self._application_api.delete_access_key(application_id, key_id, **kwargs)
+        await self._application_api.delete_access_key(
+            application_id=application_id, key_id=key_id, **kwargs
+        )
 
     async def add_role_to_application_user(self, application_id: str, role: str, **kwargs) -> None:
-        await self._application_api.add_role_to_application_user(application_id, role, **kwargs)
+        await self._application_api.add_role_to_application_user(
+            application_id=application_id, role=role, **kwargs
+        )
 
     async def remove_role_from_application_user(
         self, application_id: str, role: str, **kwargs
     ) -> None:
         await self._application_api.remove_role_from_application_user(
-            application_id, role, **kwargs
+            application_id=application_id, role=role, **kwargs
         )
 
     async def get_granted_permissions_for_group(
         self, group_id: str, **kwargs
     ) -> List[GrantedAccessAdapter]:
-        granted_access_obj = await self.get_group_permissions(group_id, **kwargs)
+        granted_access_obj = await self.get_group_permissions(group_id=group_id, **kwargs)
 
         if not granted_access_obj.granted_access:
             return []
@@ -510,7 +519,7 @@ async def get_granted_permissions_for_group(
     async def get_granted_permissions_for_user(
         self, user_id: str, **kwargs
     ) -> List[GrantedAccessAdapter]:
-        granted_access_obj = await self.get_user_permissions(user_id, **kwargs)
+        granted_access_obj = await self.get_user_permissions(user_id=user_id, **kwargs)
 
         if not granted_access_obj.granted_access:
             return []
@@ -524,10 +533,10 @@ async def get_granted_permissions_for_user(
         return granted_permissions
 
     async def get_app_by_access_key_id(
-        self, access_key_id: str, *args, **kwargs
+        self, access_key_id: str, **kwargs
     ) -> Optional[ExtendedConductorApplicationAdapter]:
         result = await self._application_api.get_app_by_access_key_id(
-            access_key_id, *args, **kwargs
+            access_key_id=access_key_id, **kwargs
         )
 
         result_dict = cast(Dict[str, Any], result)
@@ -538,7 +547,7 @@ async def get_app_by_access_key_id(
     async def check_permissions(
         self, user_id: str, type: str, id: str, **kwargs
     ) -> Dict[str, bool]:
-        result = await self._user_api.check_permissions(user_id, type, id, **kwargs)
+        result = await self._user_api.check_permissions(user_id=user_id, type=type, id=id, **kwargs)
 
         result_dict = cast(Dict[str, Any], result)
         result_model = {k: v for k, v in result_dict.items() if isinstance(v, bool)}

src/conductor/asyncio_client/orkes/orkes_event_client.py

@@ -58,7 +58,7 @@ async def create_event_handler(
         await event_client.create_event_handler([event_handler])
         ```
         """
-        return await self._event_api.add_event_handler(event_handler, **kwargs)
+        return await self._event_api.add_event_handler(event_handler=event_handler, **kwargs)
 
     async def get_event_handler(self, name: str, **kwargs) -> EventHandlerAdapter:
         """Get event handler by name.
@@ -159,9 +159,9 @@ async def update_event_handler(self, event_handler: EventHandlerAdapter, **kwarg
         await event_client.update_event_handler(handler)
         ```
         """
-        return await self._event_api.update_event_handler(event_handler, **kwargs)
+        return await self._event_api.update_event_handler(event_handler=event_handler, **kwargs)
 
-    async def delete_event_handler(self, name: str) -> None:
+    async def delete_event_handler(self, name: str, **kwargs) -> None:
         """Delete an event handler by name.
 
         Permanently removes an event handler from the system.
@@ -179,7 +179,7 @@ async def delete_event_handler(self, name: str) -> None:
         print("Event handler deleted successfully")
         ```
         """
-        return await self._event_api.remove_event_handler_status(name=name)
+        return await self._event_api.remove_event_handler_status(name=name, **kwargs)
 
     # Event Handler Tag Operations
     async def get_event_handler_tags(self, name: str, **kwargs) -> List[TagAdapter]:

src/conductor/asyncio_client/orkes/orkes_integration_client.py

@@ -29,16 +29,20 @@ async def save_integration_provider(
         self, name: str, integration_update: IntegrationUpdateAdapter, **kwargs
     ) -> None:
         """Create or update an integration provider"""
-        await self._integration_api.save_integration_provider(name, integration_update, **kwargs)
+        await self._integration_api.save_integration_provider(
+            name=name, integration_update=integration_update, **kwargs
+        )
 
     async def save_integration(
-        self, integration_name, integration_details: IntegrationUpdateAdapter
+        self, integration_name, integration_details: IntegrationUpdateAdapter, **kwargs
     ) -> None:
-        await self._integration_api.save_integration_provider(integration_name, integration_details)
+        await self._integration_api.save_integration_provider(
+            name=integration_name, integration_update=integration_details, **kwargs
+        )
 
     async def get_integration_provider(self, name: str, **kwargs) -> IntegrationAdapter:
         """Get integration provider by name"""
-        return await self._integration_api.get_integration_provider(name, **kwargs)
+        return await self._integration_api.get_integration_provider(name=name, **kwargs)
 
     async def get_integration(self, integration_name: str) -> Optional[IntegrationAdapter]:
         try:
@@ -48,7 +52,7 @@ async def get_integration(self, integration_name: str) -> Optional[IntegrationAd
 
     async def delete_integration_provider(self, name: str, **kwargs) -> None:
         """Delete an integration provider"""
-        await self._integration_api.delete_integration_provider(name, **kwargs)
+        await self._integration_api.delete_integration_provider(name=name, **kwargs)
 
     async def get_integration_providers(
         self, category: Optional[str] = None, active_only: Optional[bool] = None, **kwargs
@@ -72,33 +76,40 @@ async def save_integration_api(
     ) -> None:
         """Create or update an integration API"""
         await self._integration_api.save_integration_api(
-            name, integration_name, integration_api_update, **kwargs
+            name=name,
+            integration_name=integration_name,
+            integration_api_update=integration_api_update,
+            **kwargs,
         )
 
     async def get_integration_api(
         self, name: str, integration_name: str, **kwargs
     ) -> IntegrationApiAdapter:
         """Get integration API by name and integration name"""
-        return await self._integration_api.get_integration_api(name, integration_name, **kwargs)
+        return await self._integration_api.get_integration_api(
+            name=name, integration_name=integration_name, **kwargs
+        )
 
     async def delete_integration_api(self, name: str, integration_name: str, **kwargs) -> None:
         """Delete an integration API"""
-        await self._integration_api.delete_integration_api(name, integration_name, **kwargs)
+        await self._integration_api.delete_integration_api(
+            name=name, integration_name=integration_name, **kwargs
+        )
 
     async def get_integration_apis(
         self, integration_name: str, **kwargs
     ) -> List[IntegrationApiAdapter]:
         """Get all APIs for a specific integration"""
-        return await self._integration_api.get_integration_apis(integration_name, **kwargs)
+        return await self._integration_api.get_integration_apis(name=integration_name, **kwargs)
 
     async def get_integration_available_apis(self, name: str, **kwargs) -> List[str]:
         """Get available APIs for an integration"""
-        return await self._integration_api.get_integration_available_apis(name, **kwargs)
+        return await self._integration_api.get_integration_available_apis(name=name, **kwargs)
 
     # Integration Operations
     async def save_all_integrations(self, request_body: List[IntegrationAdapter], **kwargs) -> None:
         """Save all integrations"""
-        await self._integration_api.save_all_integrations(request_body, **kwargs)
+        await self._integration_api.save_all_integrations(integration=request_body, **kwargs)
 
     async def get_all_integrations(
         self, category: Optional[str] = None, active_only: Optional[bool] = None, **kwargs
@@ -145,52 +156,61 @@ async def put_tag_for_integration_provider(
         self, body: List[TagAdapter], name: str, **kwargs
     ) -> None:
         """Add tags to an integration provider"""
-        await self._integration_api.put_tag_for_integration_provider(name, body, **kwargs)
+        await self._integration_api.put_tag_for_integration_provider(name=name, tag=body, **kwargs)
 
     async def get_tags_for_integration_provider(self, name: str, **kwargs) -> List[TagAdapter]:
         """Get tags for an integration provider"""
-        return await self._integration_api.get_tags_for_integration_provider(name, **kwargs)
+        return await self._integration_api.get_tags_for_integration_provider(name=name, **kwargs)
 
     async def delete_tag_for_integration_provider(
         self, body: List[TagAdapter], name: str, **kwargs
     ) -> None:
         """Delete tags from an integration provider"""
-        await self._integration_api.delete_tag_for_integration_provider(name, body, **kwargs)
+        await self._integration_api.delete_tag_for_integration_provider(
+            name=name, tag=body, **kwargs
+        )
 
     # Token Usage Operations
     async def get_token_usage_for_integration(
         self, name: str, integration_name: str, **kwargs
     ) -> int:
         """Get token usage for a specific integration"""
         return await self._integration_api.get_token_usage_for_integration(
-            name, integration_name, **kwargs
+            name=name, integration_name=integration_name, **kwargs
         )
 
     async def get_token_usage_for_integration_provider(self, name: str, **kwargs) -> Dict[str, str]:
         """Get token usage for an integration provider"""
-        return await self._integration_api.get_token_usage_for_integration_provider(name, **kwargs)
+        return await self._integration_api.get_token_usage_for_integration_provider(
+            name=name, **kwargs
+        )
 
     async def register_token_usage(
         self, name: str, integration_name: str, tokens: int, **kwargs
     ) -> None:
         """Register token usage for an integration"""
-        await self._integration_api.register_token_usage(name, integration_name, tokens, **kwargs)
+        await self._integration_api.register_token_usage(
+            name=name, integration_name=integration_name, body=tokens, **kwargs
+        )
 
     # Prompt Integration Operations
     async def associate_prompt_with_integration(
         self, ai_prompt: str, integration_provider: str, integration_name: str, **kwargs
     ) -> None:
         """Associate a prompt with an integration"""
         await self._integration_api.associate_prompt_with_integration(
-            ai_prompt, integration_provider, integration_name, **kwargs
+            integration_provider=integration_provider,
+            integration_name=integration_name,
+            prompt_name=ai_prompt,
+            **kwargs,
         )
 
     async def get_prompts_with_integration(
         self, integration_provider: str, integration_name: str, **kwargs
     ) -> List[MessageTemplateAdapter]:
         """Get prompts associated with an integration"""
         return await self._integration_api.get_prompts_with_integration(
-            integration_provider, integration_name, **kwargs
+            integration_provider=integration_provider, integration_name=integration_name, **kwargs
         )
 
     # Event and Statistics Operations
@@ -214,11 +234,16 @@ async def get_active_integrations(self) -> List[IntegrationAdapter]:
         return await self.get_all_integrations(active_only=True)
 
     async def get_integration_provider_by_category(
-        self, category: str, active_only: bool = True
+        self, category: str, active_only: bool = True, **kwargs
     ) -> List[IntegrationAdapter]:
         """Get integration providers filtered by category"""
-        return await self.get_integration_providers(category=category, active_only=active_only)
+        return await self.get_integration_providers(
+            category=category, active_only=active_only, **kwargs
+        )
 
-    async def get_active_integration_providers(self) -> List[IntegrationAdapter]:
+    async def get_active_integration_providers(self, **kwargs) -> List[IntegrationAdapter]:
         """Get only active integration providers"""
-        return await self.get_integration_providers(active_only=True)
+        return await self.get_integration_providers(active_only=True, **kwargs)
+
+    async def get_integrations(self, **kwargs) -> List[IntegrationAdapter]:
+        return await self._integration_api.get_integration_providers(**kwargs)