gohumanloop 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

gohumanloop/providers/base.py

@@ -1,6 +1,5 @@
 from abc import ABC
-import re
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional, List, Tuple
 import asyncio
 import json
 import uuid
@@ -10,25 +9,32 @@ from gohumanloop.utils.threadsafedict import ThreadSafeDict
 from gohumanloop.utils import run_async_safely
 
 from gohumanloop.core.interface import (
-    HumanLoopProvider, HumanLoopResult, HumanLoopStatus, HumanLoopType
+    HumanLoopProvider,
+    HumanLoopResult,
+    HumanLoopStatus,
+    HumanLoopType,
 )
 
+
 class BaseProvider(HumanLoopProvider, ABC):
     """Base implementation of human-in-the-loop provider"""
 
-    
-    def __init__(self, name: str,  config: Optional[Dict[str, Any]] = None):
+    def __init__(self, name: str, config: Optional[Dict[str, Any]] = None):
         self.config = config or {}
         # Custom name, will use UUID if not provided
         self.name = name
         # Store request information using (conversation_id, request_id) as key
-        self._requests = ThreadSafeDict() # Using thread-safe dictionary to store request information
+        self._requests: ThreadSafeDict[
+            Tuple[str, str], Dict[str, Any]
+        ] = (
+            ThreadSafeDict()
+        )  # Using thread-safe dictionary to store request information
         # Store conversation information, including request list and latest request ID
-        self._conversations = {}
+        self._conversations: Dict[str, Dict[str, Any]] = {}
         # For quick lookup of requests in conversations
-        self._conversation_requests = defaultdict(list)
+        self._conversation_requests: defaultdict[str, List[str]] = defaultdict(list)
         # Store timeout tasks
-        self._timeout_tasks = {}
+        self._timeout_tasks: Dict[Tuple[str, str], asyncio.Task] = {}
 
         self.prompt_template = self.config.get("prompt_template", "{context}")
 
@@ -36,13 +42,18 @@ class BaseProvider(HumanLoopProvider, ABC):
         """Returns a string description of this instance"""
         total_conversations = len(self._conversations)
         total_requests = len(self._requests)
-        active_requests = sum(1 for req in self._requests.values()
-                            if req["status"] in [HumanLoopStatus.PENDING, HumanLoopStatus.INPROGRESS])
-        
-        return (f"conversations={total_conversations}, "
-                f"total_requests={total_requests}, "
-                f"active_requests={active_requests})")
-    
+        active_requests = sum(
+            1
+            for req in self._requests.values()
+            if req["status"] in [HumanLoopStatus.PENDING, HumanLoopStatus.INPROGRESS]
+        )
+
+        return (
+            f"conversations={total_conversations}, "
+            f"total_requests={total_requests}, "
+            f"active_requests={active_requests})"
+        )
+
     def __repr__(self) -> str:
         """Returns a detailed string representation of this instance"""
         return self.__str__()
@@ -56,13 +67,13 @@ class BaseProvider(HumanLoopProvider, ABC):
         conversation_id: str,
         request_id: str,
         error: Optional[str] = None,
-    ):
+    ) -> None:
         """Update request status"""
         request_key = (conversation_id, request_id)
         if request_key in self._requests:
             self._requests[request_key]["status"] = HumanLoopStatus.ERROR
             self._requests[request_key]["error"] = error
-        
+
     def _store_request(
         self,
         conversation_id: str,
@@ -84,7 +95,7 @@ class BaseProvider(HumanLoopProvider, ABC):
             "status": HumanLoopStatus.PENDING,
             "timeout": timeout,
         }
-        
+
         # Update conversation information
         if conversation_id not in self._conversations:
             self._conversations[conversation_id] = {
@@ -92,24 +103,29 @@ class BaseProvider(HumanLoopProvider, ABC):
                 "latest_request_id": None,
                 "created_at": datetime.now().isoformat(),
             }
-        
+
         # Add request to conversation request list
         self._conversation_requests[conversation_id].append(request_id)
         # Update latest request ID
         self._conversations[conversation_id]["latest_request_id"] = request_id
-        
-    def _get_request(self, conversation_id: str, request_id: str) -> Optional[Dict[str, Any]]:
+
+    def _get_request(
+        self, conversation_id: str, request_id: str
+    ) -> Optional[Dict[str, Any]]:
         """Get request information"""
-        return self._requests.get((conversation_id, request_id))
-        
+        ret: Optional[Dict[str, Any]] = self._requests.get(
+            (conversation_id, request_id)
+        )
+        return ret
+
     def _get_conversation(self, conversation_id: str) -> Optional[Dict[str, Any]]:
         """Get conversation information"""
         return self._conversations.get(conversation_id)
-        
+
     def _get_conversation_requests(self, conversation_id: str) -> List[str]:
         """Get all request IDs in the conversation"""
         return self._conversation_requests.get(conversation_id, [])
-        
+
     async def async_request_humanloop(
         self,
         task_id: str,
@@ -117,10 +133,10 @@ class BaseProvider(HumanLoopProvider, ABC):
         loop_type: HumanLoopType,
         context: Dict[str, Any],
         metadata: Optional[Dict[str, Any]] = None,
-        timeout: Optional[int] = None
+        timeout: Optional[int] = None,
     ) -> HumanLoopResult:
         """Request human-in-the-loop interaction
-        
+
         Args:
             task_id: Task identifier
             conversation_id: Conversation ID for multi-turn dialogues
@@ -128,13 +144,13 @@ class BaseProvider(HumanLoopProvider, ABC):
             context: Context information provided to human
             metadata: Additional metadata
             timeout: Request timeout in seconds
-            
+
         Returns:
             HumanLoopResult: Result object containing request ID and initial status
         """
         # Subclasses must implement this method
         raise NotImplementedError("Subclasses must implement request_humanloop")
-        
+
     def request_humanloop(
         self,
         task_id: str,
@@ -142,10 +158,10 @@ class BaseProvider(HumanLoopProvider, ABC):
         loop_type: HumanLoopType,
         context: Dict[str, Any],
         metadata: Optional[Dict[str, Any]] = None,
-        timeout: Optional[int] = None
+        timeout: Optional[int] = None,
     ) -> HumanLoopResult:
         """Request human-in-the-loop interaction (synchronous version)
-        
+
         Args:
             task_id: Task identifier
             conversation_id: Conversation ID for multi-turn dialogues
@@ -153,34 +169,32 @@ class BaseProvider(HumanLoopProvider, ABC):
             context: Context information provided to human
             metadata: Additional metadata
             timeout: Request timeout in seconds
-            
+
         Returns:
             HumanLoopResult: Result object containing request ID and initial status
         """
 
-        return run_async_safely(
-                self.async_request_humanloop(
-                    task_id=task_id,
-                    conversation_id=conversation_id,
-                    loop_type=loop_type,
-                    context=context,
-                    metadata=metadata,
-                    timeout=timeout
-                )
+        result: HumanLoopResult = run_async_safely(
+            self.async_request_humanloop(
+                task_id=task_id,
+                conversation_id=conversation_id,
+                loop_type=loop_type,
+                context=context,
+                metadata=metadata,
+                timeout=timeout,
             )
-
+        )
+        return result
 
     async def async_check_request_status(
-        self,
-        conversation_id: str,
-        request_id: str
+        self, conversation_id: str, request_id: str
     ) -> HumanLoopResult:
         """Check request status
-        
+
         Args:
             conversation_id: Conversation identifier for multi-turn dialogues
             request_id: Request identifier for specific interaction request
-            
+
         Returns:
             HumanLoopResult: Result object containing current request status, including status, response data, etc.
         """
@@ -191,43 +205,40 @@ class BaseProvider(HumanLoopProvider, ABC):
                 request_id=request_id,
                 loop_type=HumanLoopType.CONVERSATION,
                 status=HumanLoopStatus.ERROR,
-                error=f"Request '{request_id}' not found in conversation '{conversation_id}'"
+                error=f"Request '{request_id}' not found in conversation '{conversation_id}'",
             )
-            
+
         # Subclasses need to implement specific status check logic
         raise NotImplementedError("Subclasses must implement check_request_status")
 
-
     def check_request_status(
-        self,
-        conversation_id: str,
-        request_id: str
+        self, conversation_id: str, request_id: str
     ) -> HumanLoopResult:
         """Check conversation status (synchronous version)
-        
+
         Args:
             conversation_id: Conversation identifier
-            
+
         Returns:
             HumanLoopResult: Result containing the status of the latest request in the conversation
         """
 
-        return run_async_safely(
-                self.async_check_request_status(
-                    conversation_id=conversation_id,
-                    request_id=request_id
-                )
+        result: HumanLoopResult = run_async_safely(
+            self.async_check_request_status(
+                conversation_id=conversation_id, request_id=request_id
             )
+        )
+
+        return result
 
     async def async_check_conversation_status(
-        self,
-        conversation_id: str
+        self, conversation_id: str
     ) -> HumanLoopResult:
         """Check conversation status
-        
+
         Args:
             conversation_id: Conversation identifier
-            
+
         Returns:
             HumanLoopResult: Result containing the status of the latest request in the conversation
         """
@@ -238,9 +249,9 @@ class BaseProvider(HumanLoopProvider, ABC):
                 request_id="",
                 loop_type=HumanLoopType.CONVERSATION,
                 status=HumanLoopStatus.ERROR,
-                error=f"Conversation '{conversation_id}' not found"
+                error=f"Conversation '{conversation_id}' not found",
             )
-            
+
         latest_request_id = conversation_info.get("latest_request_id")
         if not latest_request_id:
             return HumanLoopResult(
@@ -248,42 +259,34 @@ class BaseProvider(HumanLoopProvider, ABC):
                 request_id="",
                 loop_type=HumanLoopType.CONVERSATION,
                 status=HumanLoopStatus.ERROR,
-                error=f"No requests found in conversation '{conversation_id}'"
+                error=f"No requests found in conversation '{conversation_id}'",
             )
-            
+
         return await self.async_check_request_status(conversation_id, latest_request_id)
-    
-    
-    def check_conversation_status(
-        self,
-        conversation_id: str
-    ) -> HumanLoopResult:
+
+    def check_conversation_status(self, conversation_id: str) -> HumanLoopResult:
         """Check conversation status (synchronous version)
-        
+
         Args:
             conversation_id: Conversation identifier
-            
+
         Returns:
             HumanLoopResult: Result containing the status of the latest request in the conversation
         """
-    
-        return run_async_safely(
-                self.async_check_conversation_status(
-                    conversation_id=conversation_id
-                )
-            )
 
-    async def async_cancel_request(
-        self,
-        conversation_id: str,
-        request_id: str
-    ) -> bool:
+        result: HumanLoopResult = run_async_safely(
+            self.async_check_conversation_status(conversation_id=conversation_id)
+        )
+
+        return result
+
+    async def async_cancel_request(self, conversation_id: str, request_id: str) -> bool:
         """Cancel human-in-the-loop request
-        
+
         Args:
             conversation_id: Conversation identifier for multi-turn dialogues
             request_id: Request identifier for specific interaction request
-            
+
         Returns:
             bool: Whether cancellation was successful, True indicates success, False indicates failure
         """
@@ -299,44 +302,38 @@ class BaseProvider(HumanLoopProvider, ABC):
             self._requests[request_key]["status"] = HumanLoopStatus.CANCELLED
             return True
         return False
-    
-    def cancel_request(
-        self,
-        conversation_id: str,
-        request_id: str
-    ) -> bool:
+
+    def cancel_request(self, conversation_id: str, request_id: str) -> bool:
         """Cancel human-in-the-loop request (synchronous version)
-        
+
         Args:
             conversation_id: Conversation identifier for multi-turn dialogues
             request_id: Request identifier for specific interaction request
-            
+
         Returns:
             bool: Whether cancellation was successful, True indicates success, False indicates failure
         """
 
-        return run_async_safely(
-                self.async_cancel_request(
-                    conversation_id=conversation_id,
-                    request_id=request_id
-                )
+        result: bool = run_async_safely(
+            self.async_cancel_request(
+                conversation_id=conversation_id, request_id=request_id
             )
+        )
 
-    async def async_cancel_conversation(
-        self,
-        conversation_id: str
-    ) -> bool:
+        return result
+
+    async def async_cancel_conversation(self, conversation_id: str) -> bool:
         """Cancel the entire conversation
-        
+
         Args:
             conversation_id: Conversation identifier
-            
+
         Returns:
             bool: Whether the cancellation was successful
         """
         if conversation_id not in self._conversations:
             return False
-            
+
         # Cancel all requests in the conversation
         success = True
         for request_id in self._get_conversation_requests(conversation_id):
@@ -344,37 +341,36 @@ class BaseProvider(HumanLoopProvider, ABC):
             if request_key in self._requests:
                 # Update request status to cancelled
                 # Only requests in intermediate states (PENDING/IN_PROGRESS) can be cancelled
-                if self._requests[request_key]["status"] in [HumanLoopStatus.PENDING, HumanLoopStatus.INPROGRESS]:
+                if self._requests[request_key]["status"] in [
+                    HumanLoopStatus.PENDING,
+                    HumanLoopStatus.INPROGRESS,
+                ]:
                     self._requests[request_key]["status"] = HumanLoopStatus.CANCELLED
-                    
+
                     # Cancel the timeout task for this request
                     if request_key in self._timeout_tasks:
                         self._timeout_tasks[request_key].cancel()
                         del self._timeout_tasks[request_key]
             else:
                 success = False
-                
+
         return success
-        
 
-    def cancel_conversation(
-        self,
-        conversation_id: str
-    ) -> bool:
+    def cancel_conversation(self, conversation_id: str) -> bool:
         """Cancel the entire conversation (synchronous version)
-        
+
         Args:
             conversation_id: Conversation identifier
-            
+
         Returns:
             bool: Whether the cancellation was successful
         """
-        
-        return run_async_safely(
-                self.async_cancel_conversation(
-                    conversation_id=conversation_id
-                )
-            )
+
+        result: bool = run_async_safely(
+            self.async_cancel_conversation(conversation_id=conversation_id)
+        )
+
+        return result
 
     async def async_continue_humanloop(
         self,
@@ -384,13 +380,13 @@ class BaseProvider(HumanLoopProvider, ABC):
         timeout: Optional[int] = None,
     ) -> HumanLoopResult:
         """Continue human-in-the-loop interaction
-        
+
         Args:
             conversation_id: Conversation ID for multi-turn dialogues
             context: Context information provided to human
             metadata: Additional metadata
             timeout: Request timeout in seconds
-            
+
         Returns:
             HumanLoopResult: Result object containing request ID and status
         """
@@ -402,12 +398,11 @@ class BaseProvider(HumanLoopProvider, ABC):
                 request_id="",
                 loop_type=HumanLoopType.CONVERSATION,
                 status=HumanLoopStatus.ERROR,
-                error=f"Conversation '{conversation_id}' not found"
+                error=f"Conversation '{conversation_id}' not found",
             )
-            
+
         # Subclasses need to implement specific continuation logic
         raise NotImplementedError("Subclasses must implement continue_humanloop")
-        
 
     def continue_humanloop(
         self,
@@ -417,32 +412,36 @@ class BaseProvider(HumanLoopProvider, ABC):
         timeout: Optional[int] = None,
     ) -> HumanLoopResult:
         """Continue human-in-the-loop interaction (synchronous version)
-        
+
         Args:
             conversation_id: Conversation ID for multi-turn dialogues
             context: Context information provided to human
             metadata: Additional metadata
             timeout: Request timeout in seconds
-            
+
         Returns:
             HumanLoopResult: Result object containing request ID and status
         """
 
-        return run_async_safely(
-                self.async_continue_humanloop(
-                    conversation_id=conversation_id,
-                    context=context,
-                    metadata=metadata,
-                    timeout=timeout
-                    )
+        result: HumanLoopResult = run_async_safely(
+            self.async_continue_humanloop(
+                conversation_id=conversation_id,
+                context=context,
+                metadata=metadata,
+                timeout=timeout,
             )
+        )
 
-    def async_get_conversation_history(self, conversation_id: str) -> List[Dict[str, Any]]:
+        return result
+
+    async def async_get_conversation_history(
+        self, conversation_id: str
+    ) -> List[Dict[str, Any]]:
         """Get complete history for the specified conversation
-        
+
         Args:
             conversation_id: Conversation identifier
-            
+
         Returns:
             List[Dict[str, Any]]: List of conversation history records, each containing request ID,
                                  status, context, response and other information
@@ -452,54 +451,58 @@ class BaseProvider(HumanLoopProvider, ABC):
             request_key = (conversation_id, request_id)
             if request_key in self._requests:
                 request_info = self._requests[request_key]
-                conversation_history.append({
-                    "request_id": request_id,
-                    "status": request_info.get("status").value if request_info.get("status") else None,
-                    "context": request_info.get("context"),
-                    "response": request_info.get("response"),
-                    "responded_by": request_info.get("responded_by"),
-                    "responded_at": request_info.get("responded_at")
-                })
+                conversation_history.append(
+                    {
+                        "request_id": request_id,
+                        "status": request_info.get("status").value
+                        if request_info.get("status")
+                        else None,
+                        "context": request_info.get("context"),
+                        "response": request_info.get("response"),
+                        "responded_by": request_info.get("responded_by"),
+                        "responded_at": request_info.get("responded_at"),
+                    }
+                )
         return conversation_history
 
     def get_conversation_history(self, conversation_id: str) -> List[Dict[str, Any]]:
         """Get complete history for the specified conversation (synchronous version)
-        
+
         Args:
             conversation_id: Conversation identifier
-            
+
         Returns:
             List[Dict[str, Any]]: List of conversation history records, each containing request ID,
                                  status, context, response and other information
         """
 
-        return run_async_safely(
-                self.async_get_conversation_history(conversation_id=conversation_id)
-            )
+        result: List[Dict[str, Any]] = run_async_safely(
+            self.async_get_conversation_history(conversation_id=conversation_id)
+        )
+
+        return result
 
     async def _async_create_timeout_task(
-        self, 
-        conversation_id: str,
-        request_id: str, 
-        timeout: int
-    ):
+        self, conversation_id: str, request_id: str, timeout: int
+    ) -> None:
         """Create timeout task
-        
+
         Args:
             conversation_id: Conversation ID
             request_id: Request ID
             timeout: Timeout duration in seconds
         """
-        async def timeout_task():
+
+        async def timeout_task() -> None:
             await asyncio.sleep(timeout)
-            
+
             # Check current status
             request_info = self._get_request(conversation_id, request_id)
             if not request_info:
                 return
-                
+
             current_status = request_info.get("status", HumanLoopStatus.PENDING)
-            
+
             # Only trigger timeout when status is PENDING
             # INPROGRESS status means conversation is ongoing, should not be considered as timeout
             if current_status == HumanLoopStatus.PENDING:
@@ -514,11 +517,10 @@ class BaseProvider(HumanLoopProvider, ABC):
                     self._timeout_tasks[(conversation_id, request_id)].cancel()
                 new_task = asyncio.create_task(timeout_task())
                 self._timeout_tasks[(conversation_id, request_id)] = new_task
-                
+
         task = asyncio.create_task(timeout_task())
         self._timeout_tasks[(conversation_id, request_id)] = task
 
-
     def build_prompt(
         self,
         task_id: str,
@@ -528,20 +530,23 @@ class BaseProvider(HumanLoopProvider, ABC):
         created_at: str,
         context: Dict[str, Any],
         metadata: Optional[Dict[str, Any]] = None,
-        color: Optional[bool] = None
+        color: Optional[bool] = None,
     ) -> str:
         """
         Dynamically generate prompt based on content, only showing sections with content,
         and adapt to different terminal color display.
         color: None=auto detect, True=force color, False=no color
         """
+
         # Auto detect if terminal supports ANSI colors
-        def _supports_color():
+        def _supports_color() -> bool:
             try:
                 import sys
+
                 if not hasattr(sys.stdout, "isatty") or not sys.stdout.isatty():
                     return False
                 import os
+
                 if os.name == "nt":
                     # Windows 10+ supports ANSI, older versions don't
                     return "ANSICON" in os.environ or "WT_SESSION" in os.environ
@@ -554,7 +559,7 @@ class BaseProvider(HumanLoopProvider, ABC):
 
         # Define colors
         if color:
-            COLOR_TITLE = "\033[94m"   # bright blue
+            COLOR_TITLE = "\033[94m"  # bright blue
             COLOR_RESET = "\033[0m"
         else:
             COLOR_TITLE = ""
@@ -574,7 +579,9 @@ class BaseProvider(HumanLoopProvider, ABC):
 
         if context.get("additional"):
             lines.append(f"\n{COLOR_TITLE}=== Additional Context ==={COLOR_RESET}")
-            lines.append(json.dumps(context["additional"], indent=2, ensure_ascii=False))
+            lines.append(
+                json.dumps(context["additional"], indent=2, ensure_ascii=False)
+            )
 
         if metadata:
             lines.append(f"\n{COLOR_TITLE}=== Metadata ==={COLOR_RESET}")