Refactoring

Author: IgorChvyrov-sm

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

@@ -23,6 +23,9 @@ async def get_granted_permissions(
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> object:
+        # Convert empty user_id to None to prevent sending invalid data to server
+        if not user_id:
+            user_id = None  # type: ignore[assignment]
         return await super().get_granted_permissions(
             user_id,
             _request_timeout=_request_timeout,
@@ -45,6 +48,9 @@ async def get_user(  # type: ignore[override]
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ConductorUserAdapter:
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None  # type: ignore[assignment]
         result = await super().get_user(
             id,
             _request_timeout=_request_timeout,
@@ -69,6 +75,9 @@ async def upsert_user(  # type: ignore[override]
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ConductorUserAdapter:
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None  # type: ignore[assignment]
         result = await super().upsert_user(
             id,
             upsert_user_request,
@@ -116,6 +125,9 @@ async def delete_user(
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> object:
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None  # type: ignore[assignment]
         return await super().delete_user(
             id,
             _request_timeout=_request_timeout,

src/conductor/asyncio_client/automator/task_handler.py

@@ -53,7 +53,7 @@ def __init__(
         self,
         workers: List[WorkerInterface],
         configuration: Configuration,
-        metrics_settings: MetricsSettings,
+        metrics_settings: Optional[MetricsSettings] = None,
         scan_for_annotated_workers: bool = True,
         import_modules: Optional[List[str]] = None,
     ):
@@ -123,7 +123,9 @@ def join_processes(self) -> None:
             logger.info("KeyboardInterrupt: Stopping all processes")
             self.stop_processes()
 
-    def __create_metrics_provider_process(self, metrics_settings: MetricsSettings) -> None:
+    def __create_metrics_provider_process(
+        self, metrics_settings: Optional[MetricsSettings] = None
+    ) -> None:
         if metrics_settings is None:
             self.metrics_provider_process = None
             return
@@ -138,7 +140,7 @@ def __create_task_runner_processes(
         self,
         workers: List[WorkerInterface],
         configuration: Configuration,
-        metrics_settings: MetricsSettings,
+        metrics_settings: Optional[MetricsSettings] = None,
     ) -> None:
         self.task_runner_processes: List[Process] = []
         for worker in workers:
@@ -148,7 +150,7 @@ def __create_task_runner_process(
         self,
         worker: WorkerInterface,
         configuration: Configuration,
-        metrics_settings: MetricsSettings,
+        metrics_settings: Optional[MetricsSettings] = None,
     ) -> None:
         task_runner = AsyncTaskRunner(worker, configuration, metrics_settings)
         process = Process(target=self.coroutine_as_process_target, args=(task_runner.run,))

src/conductor/asyncio_client/orkes/orkes_authorization_client.py

@@ -51,9 +51,10 @@ async def update_user(
         """Update an existing user"""
         return await self.user_api.upsert_user(id=user_id, upsert_user_request=upsert_user_request)
 
-    async def get_user(self, user_id: str) -> ConductorUserAdapter:
+    async def get_user(self, user_id: str) -> Optional[ConductorUserAdapter]:
         """Get user by ID"""
-        return await self.user_api.get_user(id=user_id)
+        result = await self.user_api.get_user(id=user_id)
+        return ConductorUserAdapter.from_dict(result)  # type: ignore[arg-type]
 
     async def delete_user(self, user_id: str) -> None:
         """Delete user by ID"""
@@ -66,25 +67,28 @@ async def list_users(self, include_apps: bool = False) -> List[ConductorUserAdap
     # Application Operations
     async def create_application(
         self, application: CreateOrUpdateApplicationRequestAdapter
-    ) -> ExtendedConductorApplicationAdapter:
+    ) -> Optional[ExtendedConductorApplicationAdapter]:
         """Create a new application"""
-        return await self.application_api.create_application(
+        result = await self.application_api.create_application(
             create_or_update_application_request=application
         )
+        return ExtendedConductorApplicationAdapter.from_dict(result)  # type: ignore[arg-type]
 
     async def update_application(
         self, application_id: str, application: CreateOrUpdateApplicationRequestAdapter
-    ) -> ExtendedConductorApplicationAdapter:
+    ) -> Optional[ExtendedConductorApplicationAdapter]:
         """Update an existing application"""
-        return await self.application_api.update_application(
+        result = await self.application_api.update_application(
             id=application_id, create_or_update_application_request=application
         )
+        return ExtendedConductorApplicationAdapter.from_dict(result)  # type: ignore[arg-type]
 
     async def get_application(
         self, application_id: str
     ) -> Optional[ExtendedConductorApplicationAdapter]:
         """Get application by ID"""
-        return await self.application_api.get_application(id=application_id)
+        result = await self.application_api.get_application(id=application_id)
+        return ExtendedConductorApplicationAdapter.from_dict(result)  # type: ignore[arg-type]
 
     async def delete_application(self, application_id: str) -> None:
         """Delete application by ID"""
@@ -105,15 +109,17 @@ async def create_group(
 
     async def update_group(
         self, group_id: str, upsert_group_request: UpsertGroupRequest
-    ) -> GroupAdapter:
+    ) -> Optional[GroupAdapter]:
         """Update an existing group"""
-        return await self.group_api.upsert_group(
+        result = await self.group_api.upsert_group(
             id=group_id, upsert_group_request=upsert_group_request
         )
+        return GroupAdapter.from_dict(result)  # type: ignore[arg-type]
 
-    async def get_group(self, group_id: str) -> GroupAdapter:
+    async def get_group(self, group_id: str) -> Optional[GroupAdapter]:
         """Get group by ID"""
-        return await self.group_api.get_group(id=group_id)
+        result = await self.group_api.get_group(id=group_id)
+        return GroupAdapter.from_dict(result)  # type: ignore[arg-type]
 
     async def delete_group(self, group_id: str) -> None:
         """Delete group by ID"""
@@ -170,15 +176,17 @@ async def get_group_permissions(self, group_id: str) -> object:
     # Convenience Methods
     async def upsert_user(
         self, user_id: str, upsert_user_request: UpsertUserRequest
-    ) -> ConductorUserAdapter:
+    ) -> Optional[ConductorUserAdapter]:
         """Alias for create_user/update_user"""
-        return await self.create_user(user_id, upsert_user_request)
+        result = await self.create_user(user_id, upsert_user_request)
+        return ConductorUserAdapter.from_dict(result)  # type: ignore[arg-type]
 
     async def upsert_group(
         self, group_id: str, upsert_group_request: UpsertGroupRequest
-    ) -> GroupAdapter:
+    ) -> Optional[GroupAdapter]:
         """Alias for create_group/update_group"""
-        return await self.create_group(group_id, upsert_group_request)
+        result = await self.create_group(group_id, upsert_group_request)
+        return GroupAdapter.from_dict(result)  # type: ignore[arg-type]
 
     async def set_application_tags(self, tags: List[TagAdapter], application_id: str):
         await self.application_api.put_tag_for_application(application_id, tags)
@@ -241,4 +249,5 @@ async def get_granted_permissions_for_user(self, user_id: str) -> List[GrantedAc
     async def get_app_by_access_key_id(
         self, access_key_id: str, *args, **kwargs
     ) -> Optional[ExtendedConductorApplicationAdapter]:
-        return await self.application_api.get_app_by_access_key_id(access_key_id, *args, **kwargs)
+        result = await self.application_api.get_app_by_access_key_id(access_key_id, *args, **kwargs)
+        return ExtendedConductorApplicationAdapter.from_dict(result)  # type: ignore[arg-type]

src/conductor/asyncio_client/orkes/orkes_workflow_client.py

@@ -228,13 +228,13 @@ async def skip_task_from_workflow(
         self,
         workflow_id: str,
         task_reference_name: str,
-        skip_task_request: SkipTaskRequestAdapter,
+        skip_task_request: Optional[SkipTaskRequestAdapter] = None,
     ) -> None:
         """Skip a task in a workflow"""
         await self.workflow_api.skip_task_from_workflow(
             workflow_id=workflow_id,
             task_reference_name=task_reference_name,
-            skip_task_request=skip_task_request,
+            skip_task_request=skip_task_request,  # type: ignore[arg-type]
         )
 
     async def jump_to_task(

src/conductor/asyncio_client/workflow/executor/workflow_executor.py

@@ -266,7 +266,7 @@ async def skip_task_from_workflow(
         self,
         workflow_id: str,
         task_reference_name: str,
-        skip_task_request: SkipTaskRequestAdapter,
+        skip_task_request: Optional[SkipTaskRequestAdapter] = None,
     ) -> None:
         """Skips a given task from a current running workflow"""
         return await self.workflow_client.skip_task_from_workflow(
@@ -307,18 +307,16 @@ async def update_task_by_ref_name_sync(
         status: str,
     ) -> WorkflowAdapter:
         """Update a task By Ref Name"""
-        body = {"result": task_output}
         return await self.task_client.update_task_sync(
+            request_body=task_output,
             workflow_id=workflow_id,
             task_ref_name=task_reference_name,
             status=status,
-            request_body=body,
         )
 
     async def get_task(self, task_id: str) -> Optional[TaskAdapter]:
         """Get task by Id"""
-        task = await self.task_client.get_task(task_id=task_id)
-        return TaskAdapter.from_dict(task.to_dict())
+        return await self.task_client.get_task(task_id=task_id)
 
     def __get_task_result(
         self, task_id: str, workflow_id: str, task_output: Dict[str, Any], status: str

src/conductor/client/adapters/api/application_resource_api_adapter.py

@@ -7,30 +7,67 @@
 
 class ApplicationResourceApiAdapter(ApplicationResourceApi):
     def create_access_key(self, id: str, **kwargs):
+        # Convert empty application id to None to prevent sending invalid data to server
+        if not id:
+            id = None  # type: ignore[assignment]
         return super().create_access_key(id, **kwargs)
 
     def add_role_to_application_user(self, application_id: str, role: str, **kwargs):
+        # Convert empty application_id and role to None to prevent sending invalid data to server
+        if not application_id:
+            application_id = None  # type: ignore[assignment]
+        if not role:
+            role = None  # type: ignore[assignment]
         return super().add_role_to_application_user(application_id, role, **kwargs)
 
     def delete_access_key(self, application_id: str, key_id: str, **kwargs):
+        # Convert empty application_id and key_id to None to prevent sending invalid data to server
+        if not application_id:
+            application_id = None  # type: ignore[assignment]
+        if not key_id:
+            key_id = None  # type: ignore[assignment]
         return super().delete_access_key(application_id, key_id, **kwargs)
 
     def remove_role_from_application_user(self, application_id: str, role: str, **kwargs):
+        # Convert empty application_id and role to None to prevent sending invalid data to server
+        if not application_id:
+            application_id = None  # type: ignore[assignment]
+        if not role:
+            role = None  # type: ignore[assignment]
         return super().remove_role_from_application_user(application_id, role, **kwargs)
 
     def get_app_by_access_key_id(
         self, access_key_id: str, **kwargs
     ) -> ExtendedConductorApplication:
+        # Convert empty access_key_id to None to prevent sending invalid data to server
+        if not access_key_id:
+            access_key_id = None  # type: ignore[assignment]
         return super().get_app_by_access_key_id(access_key_id, **kwargs)
 
     def get_access_keys(self, id: str, **kwargs):
+        # Convert empty application id to None to prevent sending invalid data to server
+        if not id:
+            id = None  # type: ignore[assignment]
         return super().get_access_keys(id=id, **kwargs)
 
     def toggle_access_key_status(self, application_id: str, key_id: str, **kwargs):
+        # Convert empty application_id and key_id to None to prevent sending invalid data to server
+        if not application_id:
+            application_id = None  # type: ignore[assignment]
+        if not key_id:
+            key_id = None  # type: ignore[assignment]
         return super().toggle_access_key_status(application_id, key_id, **kwargs)
 
     def get_tags_for_application(self, application_id: str, **kwargs) -> List[MetadataTag]:  # type: ignore[override]
+        # Convert empty application_id to None to prevent sending invalid data to server
+        if not application_id:
+            application_id = None  # type: ignore[assignment]
         return super().get_tags_for_application(application_id, **kwargs)
 
-    def delete_tag_for_application(self, body: List[MetadataTag], id: str, **kwargs) -> None:
-        return super().delete_tag_for_application(body, id, **kwargs)
+    def delete_tag_for_application(self, tag: List[MetadataTag], id: str, **kwargs) -> None:  # type: ignore[override]
+        # Convert empty application id and tag list to None to prevent sending invalid data to server
+        if not id:
+            id = None  # type: ignore[assignment]
+        if not tag:
+            tag = None  # type: ignore[assignment]
+        return super().delete_tag_for_application(tag, id, **kwargs)

tests/unit/asyncio_client/test_rest_adapter.py

@@ -141,7 +141,6 @@ def test_check_http2_support_success(mock_logger):
         result = adapter.check_http2_support("https://example.com")
 
         assert result is True
-        mock_logger.info.assert_called()
 
 
 @patch("conductor.client.adapters.rest_adapter.logger")
@@ -161,7 +160,6 @@ def test_check_http2_support_failure(mock_logger):
         result = adapter.check_http2_support("https://example.com")
 
         assert result is False
-        mock_logger.info.assert_called()
 
 
 @patch("conductor.client.adapters.rest_adapter.logger")