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

gohumanloop/manager/ghl_manager.py

@@ -98,22 +98,22 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
         if auto_start_sync:
             # 判断是否处在异步环境
             if asyncio.get_event_loop().is_running():
-                asyncio.create_task(self.astart_sync_task())
+                asyncio.create_task(self.async_start_sync_task())
             else:
                 self.start_sync_task()
 
         
-    async def get_ghl_provider(self) -> GoHumanLoopProvider:
+    async def async_get_ghl_provider(self) -> GoHumanLoopProvider:
         """
         获取 GoHumanLoop 提供者实例
         
         Returns:
             GoHumanLoopProvider: GoHumanLoop 提供者实例
         """
-        provider = await self.get_provider(self.default_provider_id)
+        provider = await self.async_get_provider(self.default_provider_id)
         return provider
     
-    async def astart_sync_task(self):
+    async def async_start_sync_task(self):
         """启动数据同步任务"""
         if self._sync_task is None or self._sync_task.done():
             self._sync_task = asyncio.create_task(self._async_data_periodically())
@@ -176,7 +176,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
         # 对每个任务进行数据同步
         for task_id in task_ids:
             # 获取任务相关的所有对话
-            conversations = await self.aget_task_conversations(task_id)
+            conversations = await self.async_get_task_conversations(task_id)
             
             # 收集任务数据
             task_data = {
@@ -188,7 +188,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
             # 收集每个对话的数据
             for conversation_id in conversations:
                 # 获取对话中的所有请求
-                request_ids = await self.aget_conversation_requests(conversation_id)
+                request_ids = await self.async_get_conversation_requests(conversation_id)
                 
                 conversation_data = {
                     "conversation_id": conversation_id,
@@ -198,7 +198,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
                 
                 # 收集每个请求的数据
                 for request_id in request_ids:
-                    result = await self._aget_request_status(conversation_id, request_id)
+                    result = await self._async_get_request_status(conversation_id, request_id)
                     
                     # 添加请求数据
                     conversation_data["requests"].append({
@@ -227,7 +227,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
                     
                     # 添加此对话中的已取消请求
                     for request_id in cancel_info.get("request_ids", []):
-                        result = await self._aget_request_status(conv_id, request_id, cancel_info.get("provider_id"))
+                        result = await self._async_get_request_status(conv_id, request_id, cancel_info.get("provider_id"))
                     
                         # 添加请求数据
                         cancelled_conv_data["requests"].append({
@@ -245,7 +245,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
                     task_data["conversations"].append(cancelled_conv_data)
             
             # 发送数据到平台
-            await self._asend_task_data_to_platform(task_data)
+            await self._async_send_task_data_to_platform(task_data)
         
         # 更新最后同步时间
         self._last_sync_time = current_time
@@ -288,7 +288,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
                 
                 # 收集每个请求的数据
                 for request_id in request_ids:
-                    result = loop.run_until_complete(self._aget_request_status(conversation_id, request_id))
+                    result = loop.run_until_complete(self._async_get_request_status(conversation_id, request_id))
                     
                     # 添加请求数据
                     conversation_data["requests"].append({
@@ -318,7 +318,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
                     # 添加此对话中的已取消请求
                     for request_id in cancel_info.get("request_ids", []):
                         result = loop.run_until_complete(
-                            self._aget_request_status(conv_id, request_id, cancel_info.get("provider_id"))
+                            self._async_get_request_status(conv_id, request_id, cancel_info.get("provider_id"))
                         )
                     
                         # 添加请求数据
@@ -337,13 +337,13 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
                     task_data["conversations"].append(cancelled_conv_data)
             
             # 发送数据到平台
-            loop.run_until_complete(self._asend_task_data_to_platform(task_data))
+            loop.run_until_complete(self._async_send_task_data_to_platform(task_data))
             loop.close()
         
         # 更新最后同步时间
         self._last_sync_time = current_time
     
-    async def _asend_task_data_to_platform(self, task_data: Dict[str, Any]):
+    async def _async_send_task_data_to_platform(self, task_data: Dict[str, Any]):
         """发送任务数据到 GoHumanLoop 平台"""
         try:
             # 构建 API 请求 URL
@@ -390,7 +390,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
             print(f"发送任务数据到平台异常: {str(e)}")
 
     
-    async def cancel_conversation(
+    async def async_cancel_conversation(
         self,
         conversation_id: str,
         provider_id: Optional[str] = None
@@ -411,13 +411,13 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
         }
         
         # 调用父类方法执行实际取消操作
-        return await super().cancel_conversation(conversation_id, provider_id)
+        return await super().async_cancel_conversation(conversation_id, provider_id)
     
     def __str__(self) -> str:
         """返回此实例的字符串描述"""
         return f"GoHumanLoop(default_provider={self.default_provider_id}, providers={len(self.providers)})"
     
-    async def _aget_request_status(
+    async def _async_get_request_status(
         self,
         conversation_id: str,
         request_id: str,
@@ -434,7 +434,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
         Returns:
             HumanLoopResult: 请求状态结果
         """
-        # 如果没有指定provider_id，从存储的映射中获取
+        # check_request_status
         if provider_id is None:
             provider_id = self._conversation_provider.get(conversation_id)
             
@@ -442,9 +442,9 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
             raise ValueError(f"Provider '{provider_id}' not found")
             
         provider = self.providers[provider_id]
-        return await provider.check_request_status(conversation_id, request_id)
+        return await provider.async_check_request_status(conversation_id, request_id)
 
-    async def check_request_status(
+    async def async_check_request_status(
         self,
         conversation_id: str,
         request_id: str,
@@ -462,7 +462,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
             raise ValueError(f"Provider '{provider_id}' not found")
             
         provider = self.providers[provider_id]
-        result = await provider.check_request_status(conversation_id, request_id)
+        result = await provider.async_check_request_status(conversation_id, request_id)
         
         # 如果有回调且状态不是等待或进行中
         if result.status not in [HumanLoopStatus.PENDING]:
@@ -470,7 +470,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
             await self.async_data_to_platform()
             # 触发状态更新回调
             if (conversation_id, request_id) in self._callbacks:
-                await self._trigger_update_callback(conversation_id, request_id, provider, result)
+                await self._async_trigger_update_callback(conversation_id, request_id, provider, result)
 
         return result
     
@@ -492,7 +492,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
         except Exception as e:
             print(f"最终同步数据同步失败: {str(e)}")
 
-    async def ashutdown(self):
+    async def async_shutdown(self):
         """
         关闭管理器并确保数据同步（异步版本）
         
@@ -514,12 +514,12 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
     
     async def __aenter__(self):
         """实现异步上下文管理器协议的进入方法"""
-        await self.astart_sync_task()
+        await self.async_start_sync_task()
         return self
     
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """实现异步上下文管理器协议的退出方法"""
-        await self.ashutdown()
+        await self.async_shutdown()
     
     def __enter__(self):
         """实现同步上下文管理器协议的进入方法"""

gohumanloop/providers/api_provider.py

@@ -4,7 +4,7 @@ from typing import Dict, Any, Optional
 
 import aiohttp
 from pydantic import SecretStr
-
+from concurrent.futures import ThreadPoolExecutor
 from gohumanloop.core.interface import (
     HumanLoopResult, HumanLoopStatus, HumanLoopType
 )
@@ -56,6 +56,18 @@ class APIProvider(BaseProvider):
         
         # Store the currently running polling tasks.
         self._poll_tasks = {}
+         # Create thread pool for background service execution
+        self._executor = ThreadPoolExecutor(max_workers=10)
+
+
+    def __del__(self):
+        """析构函数，确保线程池被正确关闭"""
+        self._executor.shutdown(wait=False)
+
+        # 取消所有邮件检查任务
+        for task_key, future in list(self._poll_tasks.items()):
+            future.cancel()
+        self._poll_tasks.clear()
         
     def __str__(self) -> str:
         """Returns a string description of this instance"""
@@ -65,7 +77,7 @@ class APIProvider(BaseProvider):
             api_info += f"  Default Platform: {self.default_platform}\n"
         return f"{api_info}{base_str}"
         
-    async def _make_api_request(
+    async def _async_make_api_request(
         self, 
         endpoint: str, 
         method: str = "POST", 
@@ -146,7 +158,7 @@ class APIProvider(BaseProvider):
                     continue
                 raise
                 
-    async def request_humanloop(
+    async def async_request_humanloop(
         self,
         task_id: str,
         conversation_id: str,
@@ -208,7 +220,7 @@ class APIProvider(BaseProvider):
         
         try:
             # Send API request
-            response = await self._make_api_request(
+            response = await self._async_make_api_request(
                 endpoint="v1/humanloop/request",
                 method="POST",
                 data=request_data
@@ -230,14 +242,13 @@ class APIProvider(BaseProvider):
                 )
                 
             # Create polling task
-            poll_task = asyncio.create_task(
-                self._poll_request_status(conversation_id, request_id, platform)
+            self._poll_tasks[(conversation_id, request_id)] = self._executor.submit(
+            self._run_async_poll_request_status, conversation_id, request_id, platform
             )
-            self._poll_tasks[(conversation_id, request_id)] = poll_task
             
             # Create timeout task if timeout is set
             if timeout:
-                self._create_timeout_task(conversation_id, request_id, timeout)
+               await self._async_create_timeout_task(conversation_id, request_id, timeout)
                 
             return HumanLoopResult(
                 conversation_id=conversation_id,
@@ -258,7 +269,23 @@ class APIProvider(BaseProvider):
                 status=HumanLoopStatus.ERROR,
                 error=str(e)
             )
-    async def check_request_status(
+
+    def _run_async_poll_request_status(self, conversation_id: str, request_id: str, platform: str):
+        """Run asynchronous API interaction in a separate thread"""
+        # Create new event loop
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        try:
+            # Run interaction processing in the new event loop
+            loop.run_until_complete(self._async_poll_request_status(conversation_id, request_id, platform))
+        finally:
+            loop.close()
+            # Remove from task dictionary
+            if (conversation_id, request_id) in self._poll_tasks:
+                del self._poll_tasks[(conversation_id, request_id)]
+
+    async def async_check_request_status(
         self,
         conversation_id: str,
         request_id: str
@@ -297,7 +324,7 @@ class APIProvider(BaseProvider):
         return result
 
             
-    async def cancel_request(
+    async def async_cancel_request(
         self,
         conversation_id: str,
         request_id: str
@@ -312,7 +339,7 @@ class APIProvider(BaseProvider):
             bool: Whether cancellation was successful, True for success, False for failure
         """
         # First call parent method to update local state
-        result = await super().cancel_request(conversation_id, request_id)
+        result = await super().async_cancel_request(conversation_id, request_id)
         if not result:
             return False
             
@@ -335,7 +362,7 @@ class APIProvider(BaseProvider):
                 platform=platform
             ).model_dump()
             
-            response = await self._make_api_request(
+            response = await self._async_make_api_request(
                 endpoint="v1/humanloop/cancel",
                 method="POST",
                 data=cancel_data
@@ -359,7 +386,7 @@ class APIProvider(BaseProvider):
             logger.error(f"Cancel request failed: {str(e)}")
             return False
             
-    async def cancel_conversation(
+    async def async_cancel_conversation(
         self,
         conversation_id: str
     ) -> bool:
@@ -372,7 +399,7 @@ class APIProvider(BaseProvider):
             bool: Whether cancellation was successful
         """
         # First call parent method to update local state
-        result = await super().cancel_conversation(conversation_id)
+        result = await super().async_cancel_conversation(conversation_id)
         if not result:
             return False
             
@@ -398,7 +425,7 @@ class APIProvider(BaseProvider):
                 platform=platform
             ).model_dump()
             
-            response = await self._make_api_request(
+            response = await self._async_make_api_request(
                 endpoint="v1/humanloop/cancel_conversation",
                 method="POST",
                 data=cancel_data
@@ -424,7 +451,7 @@ class APIProvider(BaseProvider):
             return False
 
 
-    async def continue_humanloop(
+    async def async_continue_humanloop(
         self,
         conversation_id: str,
         context: Dict[str, Any],
@@ -496,7 +523,7 @@ class APIProvider(BaseProvider):
         
         try:
             # Send API request
-            response = await self._make_api_request(
+            response = await self._async_make_api_request(
                 endpoint="v1/humanloop/continue",
                 method="POST",
                 data=continue_data
@@ -516,15 +543,14 @@ class APIProvider(BaseProvider):
                     error=error_msg
                 )
                 
-            # Create polling task
-            poll_task = asyncio.create_task(
-                self._poll_request_status(conversation_id, request_id, platform)
+             # Create polling task
+            self._poll_tasks[(conversation_id, request_id)] = self._executor.submit(
+            self._run_async_poll_request_status, conversation_id, request_id, platform
             )
-            self._poll_tasks[(conversation_id, request_id)] = poll_task
             
             # Create timeout task if timeout is set
             if timeout:
-                self._create_timeout_task(conversation_id, request_id, timeout)
+                await self._async_create_timeout_task(conversation_id, request_id, timeout)
                 
             return HumanLoopResult(
                 conversation_id=conversation_id,
@@ -546,7 +572,7 @@ class APIProvider(BaseProvider):
                 error=str(e)
             )
             
-    async def _poll_request_status(
+    async def _async_poll_request_status(
         self,
         conversation_id: str,
         request_id: str,
@@ -579,7 +605,7 @@ class APIProvider(BaseProvider):
                     platform=platform
                 ).model_dump()
                 
-                response = await self._make_api_request(
+                response = await self._async_make_api_request(
                     endpoint="v1/humanloop/status",
                     method="GET",
                     params=params

gohumanloop/providers/base.py

@@ -7,6 +7,7 @@ import uuid
 from datetime import datetime
 from collections import defaultdict
 from gohumanloop.utils.threadsafedict import ThreadSafeDict
+from gohumanloop.utils import run_async_safely
 
 from gohumanloop.core.interface import (
     HumanLoopProvider, HumanLoopResult, HumanLoopStatus, HumanLoopType
@@ -109,7 +110,7 @@ class BaseProvider(HumanLoopProvider, ABC):
         """Get all request IDs in the conversation"""
         return self._conversation_requests.get(conversation_id, [])
         
-    async def request_humanloop(
+    async def async_request_humanloop(
         self,
         task_id: str,
         conversation_id: str,
@@ -134,8 +135,42 @@ class BaseProvider(HumanLoopProvider, ABC):
         # Subclasses must implement this method
         raise NotImplementedError("Subclasses must implement request_humanloop")
         
+    def request_humanloop(
+        self,
+        task_id: str,
+        conversation_id: str,
+        loop_type: HumanLoopType,
+        context: Dict[str, Any],
+        metadata: Optional[Dict[str, Any]] = None,
+        timeout: Optional[int] = None
+    ) -> HumanLoopResult:
+        """Request human-in-the-loop interaction (synchronous version)
         
-    async def check_request_status(
+        Args:
+            task_id: Task identifier
+            conversation_id: Conversation ID for multi-turn dialogues
+            loop_type: Type of human loop interaction
+            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
+                )
+            )
+
+
+    async def async_check_request_status(
         self,
         conversation_id: str,
         request_id: str
@@ -163,7 +198,28 @@ class BaseProvider(HumanLoopProvider, ABC):
         raise NotImplementedError("Subclasses must implement check_request_status")
 
 
-    async def check_conversation_status(
+    def check_request_status(
+        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
+                )
+            )
+
+    async def async_check_conversation_status(
         self,
         conversation_id: str
     ) -> HumanLoopResult:
@@ -195,9 +251,29 @@ class BaseProvider(HumanLoopProvider, ABC):
                 error=f"No requests found in conversation '{conversation_id}'"
             )
             
-        return await self.check_request_status(conversation_id, latest_request_id)
+        return await self.async_check_request_status(conversation_id, latest_request_id)
+    
+    
+    def check_conversation_status(
+        self,
+        conversation_id: str
+    ) -> HumanLoopResult:
+        """Check conversation status (synchronous version)
         
-    async def cancel_request(
+        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
@@ -224,7 +300,29 @@ class BaseProvider(HumanLoopProvider, ABC):
             return True
         return False
     
-    async def cancel_conversation(
+    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
+                )
+            )
+
+    async def async_cancel_conversation(
         self,
         conversation_id: str
     ) -> bool:
@@ -258,7 +356,27 @@ class BaseProvider(HumanLoopProvider, ABC):
                 
         return success
         
-    async def continue_humanloop(
+
+    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
+                )
+            )
+
+    async def async_continue_humanloop(
         self,
         conversation_id: str,
         context: Dict[str, Any],
@@ -290,7 +408,36 @@ class BaseProvider(HumanLoopProvider, ABC):
         # Subclasses need to implement specific continuation logic
         raise NotImplementedError("Subclasses must implement continue_humanloop")
         
-    def get_conversation_history(self, conversation_id: str) -> List[Dict[str, Any]]:
+
+    def continue_humanloop(
+        self,
+        conversation_id: str,
+        context: Dict[str, Any],
+        metadata: Optional[Dict[str, Any]] = None,
+        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
+                    )
+            )
+
+    def async_get_conversation_history(self, conversation_id: str) -> List[Dict[str, Any]]:
         """Get complete history for the specified conversation
         
         Args:
@@ -315,8 +462,22 @@ class BaseProvider(HumanLoopProvider, ABC):
                 })
         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)
+            )
 
-    def _create_timeout_task(
+    async def _async_create_timeout_task(
         self, 
         conversation_id: str,
         request_id: str,