resolve the pylint issue

Author: Dhruvkumar-Microsoft

src/backend/v3/config/settings.py

@@ -86,17 +86,17 @@ def __init__(self):
             20  # Maximum number of replanning rounds 20 needed to accommodate complex tasks
         )
 
-         # Event-driven notification system for approvals and clarifications
+        # Event-driven notification system for approvals and clarifications
         self._approval_events: Dict[str, asyncio.Event] = {}
         self._clarification_events: Dict[str, asyncio.Event] = {}
-        
+
         # Default timeout for waiting operations (5 minutes)
         self.default_timeout: float = 300.0
 
     def get_current_orchestration(self, user_id: str) -> MagenticOrchestration:
         """get existing orchestration instance."""
         return self.orchestrations.get(user_id, None)
-    
+
     def set_approval_pending(self, plan_id: str) -> None:
         """Set an approval as pending and create an event for it."""
         self.approvals[plan_id] = None
@@ -115,31 +115,31 @@ def set_approval_result(self, plan_id: str, approved: bool) -> None:
     async def wait_for_approval(self, plan_id: str, timeout: Optional[float] = None) -> bool:
         """
         Wait for an approval decision with timeout.
-        
+
         Args:
             plan_id: The plan ID to wait for
             timeout: Timeout in seconds (defaults to default_timeout)
-            
+
         Returns:
             The approval decision (True/False)
-            
+
         Raises:
             asyncio.TimeoutError: If timeout is exceeded
             KeyError: If plan_id is not found in approvals
         """
         if timeout is None:
             timeout = self.default_timeout
-            
+
         if plan_id not in self.approvals:
             raise KeyError(f"Plan ID {plan_id} not found in approvals")
-            
+
         if self.approvals[plan_id] is not None:
             # Already has a result
             return self.approvals[plan_id]
-            
+
         if plan_id not in self._approval_events:
             self._approval_events[plan_id] = asyncio.Event()
-            
+
         try:
             await asyncio.wait_for(self._approval_events[plan_id].wait(), timeout=timeout)
             return self.approvals[plan_id]
@@ -161,7 +161,7 @@ async def wait_for_approval(self, plan_id: str, timeout: Optional[float] = None)
             # cleaning up successful approvals
             if plan_id in self.approvals and self.approvals[plan_id] is None:
                 self.cleanup_approval(plan_id)
-            
+
     def set_clarification_pending(self, request_id: str) -> None:
         """Set a clarification as pending and create an event for it."""
         self.clarifications[request_id] = None
@@ -180,31 +180,31 @@ def set_clarification_result(self, request_id: str, answer: str) -> None:
     async def wait_for_clarification(self, request_id: str, timeout: Optional[float] = None) -> str:
         """
         Wait for a clarification response with timeout.
-        
+
         Args:
             request_id: The request ID to wait for
             timeout: Timeout in seconds (defaults to default_timeout)
-            
+
         Returns:
             The clarification response
-            
+
         Raises:
             asyncio.TimeoutError: If timeout is exceeded
             KeyError: If request_id is not found in clarifications
         """
         if timeout is None:
             timeout = self.default_timeout
-            
+
         if request_id not in self.clarifications:
             raise KeyError(f"Request ID {request_id} not found in clarifications")
-            
+
         if self.clarifications[request_id] is not None:
             # Already has a result
             return self.clarifications[request_id]
-            
+
         if request_id not in self._clarification_events:
             self._clarification_events[request_id] = asyncio.Event()
-            
+
         try:
             await asyncio.wait_for(self._clarification_events[request_id].wait(), timeout=timeout)
             return self.clarifications[request_id]

src/backend/v3/magentic_agents/proxy_agent.py

@@ -280,37 +280,37 @@ async def _wait_for_user_clarification(
         #     request_id=request_id,
         #     answer=orchestration_config.clarifications[request_id],
         # )
-        
+
         """
         Wait for user clarification response using event-driven pattern with timeout handling.
-        
+
         Args:
             request_id: The request ID to wait for clarification
-            
+
         Returns:
             UserClarificationResponse: Clarification result with request ID and answer
-            
+
         Raises:
             asyncio.TimeoutError: If timeout is exceeded (300 seconds default)
         """
-       # logger.info(f"Waiting for user clarification for request: {request_id}")
-        
+        # logger.info(f"Waiting for user clarification for request: {request_id}")
+
         # Initialize clarification as pending using the new event-driven method
         orchestration_config.set_clarification_pending(request_id)
-        
+
         try:
             # Wait for clarification with timeout using the new event-driven method
             answer = await orchestration_config.wait_for_clarification(request_id)
-            
-            #logger.info(f"Clarification received for request {request_id}: {answer}")
+
+            # logger.info(f"Clarification received for request {request_id}: {answer}")
             return UserClarificationResponse(
                 request_id=request_id,
                 answer=answer,
             )
         except asyncio.TimeoutError:
             # Enhanced timeout handling - notify user via WebSocket and cleanup
             logger.debug(f"Clarification timeout for request {request_id} - notifying user and terminating process")
-            
+
             # Create timeout notification message
             from v3.models.messages import TimeoutNotification, WebsocketMessageType
             timeout_notification = TimeoutNotification(
@@ -320,7 +320,7 @@ async def _wait_for_user_clarification(
                 timestamp=time.time(),
                 timeout_duration=orchestration_config.default_timeout
             )
-            
+
             # Send timeout notification to user via WebSocket
             try:
                 await connection_config.send_status_update_async(
@@ -331,25 +331,25 @@ async def _wait_for_user_clarification(
                 logger.info(f"Timeout notification sent to user {self.user_id} for clarification {request_id}")
             except Exception as e:
                 logger.error(f"Failed to send timeout notification: {e}")
-            
+
             # Clean up this specific request
             orchestration_config.cleanup_clarification(request_id)
-            
+
             # Return None to indicate silent termination
             # The timeout naturally stops this specific wait operation without affecting other tasks
             return None
-            
+
         except KeyError as e:
             # Silent error handling for invalid request IDs
             logger.debug(f"Request ID not found: {e} - terminating process silently")
             return None
-            
+
         except asyncio.CancelledError:
             # Handle task cancellation gracefully
             logger.debug(f"Clarification request {request_id} was cancelled")
             orchestration_config.cleanup_clarification(request_id)
             return None
-            
+
         except Exception as e:
             # Silent error handling for unexpected errors
             logger.debug(f"Unexpected error waiting for clarification: {e} - terminating process silently")
@@ -358,12 +358,10 @@ async def _wait_for_user_clarification(
         finally:
             # Ensure cleanup happens for any incomplete requests
             # This provides an additional safety net for resource cleanup
-            if (request_id in orchestration_config.clarifications and 
-                orchestration_config.clarifications[request_id] is None):
+            if (request_id in orchestration_config.clarifications and orchestration_config.clarifications[request_id] is None):
                 logger.debug(f"Final cleanup for pending clarification request {request_id}")
                 orchestration_config.cleanup_clarification(request_id)
 
-
     async def get_response(self, chat_history, **kwargs):
         """Get response from the agent - required by Agent base class."""
         # Extract the latest user message

src/backend/v3/orchestration/human_approval_manager.py

@@ -5,7 +5,6 @@
 
 import asyncio
 import logging
-import time
 from typing import Any, Optional
 
 import v3.models.messages as messages
@@ -219,37 +218,37 @@ async def _wait_for_user_approval(
         # )
         """
         Wait for user approval response using event-driven pattern with timeout handling.
-        
+
         Args:
             m_plan_id: The plan ID to wait for approval
-            
+
         Returns:
             PlanApprovalResponse: Approval result with approved status and plan ID
-            
+
         Raises:
             asyncio.TimeoutError: If timeout is exceeded (300 seconds default)
         """
         logger.info(f"Waiting for user approval for plan: {m_plan_id}")
-        
+
         if not m_plan_id:
             logger.error("No plan ID provided for approval")
             return messages.PlanApprovalResponse(approved=False, m_plan_id=m_plan_id)
-        
+
         # Initialize approval as pending using the new event-driven method
         orchestration_config.set_approval_pending(m_plan_id)
-        
+
         try:
             # Wait for approval with timeout using the new event-driven method
             approved = await orchestration_config.wait_for_approval(m_plan_id)
-            
+
             logger.info(f"Approval received for plan {m_plan_id}: {approved}")
             return messages.PlanApprovalResponse(
                 approved=approved, m_plan_id=m_plan_id
             )
         except asyncio.TimeoutError:
             # Enhanced timeout handling - notify user via WebSocket and cleanup
             logger.debug(f"Approval timeout for plan {m_plan_id} - notifying user and terminating process")
-            
+
             # Create timeout notification message
             timeout_message = messages.TimeoutNotification(
                 timeout_type="approval",
@@ -258,7 +257,7 @@ async def _wait_for_user_approval(
                 timestamp=asyncio.get_event_loop().time(),
                 timeout_duration=orchestration_config.default_timeout
             )
-            
+
             # Send timeout notification to user via WebSocket
             try:
                 await connection_config.send_status_update_async(
@@ -269,25 +268,25 @@ async def _wait_for_user_approval(
                 logger.info(f"Timeout notification sent to user {self.current_user_id} for plan {m_plan_id}")
             except Exception as e:
                 logger.error(f"Failed to send timeout notification: {e}")
-            
+
             # Clean up this specific request
             orchestration_config.cleanup_approval(m_plan_id)
-            
+
             # Return None to indicate silent termination
             # The timeout naturally stops this specific wait operation without affecting other tasks
             return None
-            
+
         except KeyError as e:
             # Silent error handling for invalid plan IDs
             logger.debug(f"Plan ID not found: {e} - terminating process silently")
             return None
-            
+
         except asyncio.CancelledError:
             # Handle task cancellation gracefully
             logger.debug(f"Approval request {m_plan_id} was cancelled")
             orchestration_config.cleanup_approval(m_plan_id)
             return None
-            
+
         except Exception as e:
             # Silent error handling for unexpected errors
             logger.debug(f"Unexpected error waiting for approval: {e} - terminating process silently")
@@ -296,8 +295,7 @@ async def _wait_for_user_approval(
         finally:
             # Ensure cleanup happens for any incomplete requests
             # This provides an additional safety net for resource cleanup
-            if (m_plan_id in orchestration_config.approvals and 
-                orchestration_config.approvals[m_plan_id] is None):
+            if (m_plan_id in orchestration_config.approvals and orchestration_config.approvals[m_plan_id] is None):
                 logger.debug(f"Final cleanup for pending approval plan {m_plan_id}")
                 orchestration_config.cleanup_approval(m_plan_id)
 

src/backend/v3/orchestration/orchestration_manager.py

@@ -119,7 +119,7 @@ async def run_orchestration(self, user_id, input_task) -> None:
         """Run the orchestration with user input loop."""
 
         job_id = str(uuid.uuid4())
-        #orchestration_config.approvals[job_id] = None
+        # orchestration_config.approvals[job_id] = None
 
         # Use the new event-driven method to set approval as pending
         orchestration_config.set_approval_pending(job_id)