gohumanloop 0.0.2__py3-none-any.whl → 0.0.3__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,
@@ -444,7 +444,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
         provider = self.providers[provider_id]
         return await provider.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

@@ -65,7 +65,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 +146,7 @@ class APIProvider(BaseProvider):
                     continue
                 raise
                 
-    async def request_humanloop(
+    async def async_request_humanloop(
         self,
         task_id: str,
         conversation_id: str,
@@ -208,7 +208,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
@@ -231,13 +231,13 @@ class APIProvider(BaseProvider):
                 
             # Create polling task
             poll_task = asyncio.create_task(
-                self._poll_request_status(conversation_id, request_id, platform)
+                self._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 +258,7 @@ class APIProvider(BaseProvider):
                 status=HumanLoopStatus.ERROR,
                 error=str(e)
             )
-    async def check_request_status(
+    async def async_check_request_status(
         self,
         conversation_id: str,
         request_id: str
@@ -297,7 +297,7 @@ class APIProvider(BaseProvider):
         return result
 
             
-    async def cancel_request(
+    async def async_cancel_request(
         self,
         conversation_id: str,
         request_id: str
@@ -312,7 +312,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 +335,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 +359,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 +372,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 +398,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 +424,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 +496,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
@@ -518,13 +518,13 @@ class APIProvider(BaseProvider):
                 
             # Create polling task
             poll_task = asyncio.create_task(
-                self._poll_request_status(conversation_id, request_id, platform)
+                self._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 +546,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 +579,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

@@ -109,7 +109,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 +134,52 @@ 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
+        """
+
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # 如果事件循环已经在运行，创建一个新的事件循环
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            loop = new_loop
+            
+        try:
+            return loop.run_until_complete(
+                self.async_request_humanloop(
+                    task_id=task_id,
+                    conversation_id=conversation_id,
+                    loop_type=loop_type,
+                    context=context,
+                    metadata=metadata,
+                    timeout=timeout
+                    ))
+        finally:
+            if loop != asyncio.get_event_loop():
+                loop.close()
+
+
+    async def async_check_request_status(
         self,
         conversation_id: str,
         request_id: str
@@ -163,7 +207,39 @@ 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
+        """
+        
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # 如果事件循环已经在运行，创建一个新的事件循环
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            loop = new_loop
+            
+        try:
+            return loop.run_until_complete(
+                self.async_check_request_status(
+                    conversation_id=conversation_id,
+                    request_id=request_id
+                ))
+        finally:
+            if loop != asyncio.get_event_loop():
+                loop.close()
+
+
+    async def async_check_conversation_status(
         self,
         conversation_id: str
     ) -> HumanLoopResult:
@@ -195,9 +271,40 @@ 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
+        """
+
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # 如果事件循环已经在运行，创建一个新的事件循环
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            loop = new_loop
+            
+        try:
+            return loop.run_until_complete(
+               self.async_check_conversation_status(
+                    conversation_id=conversation_id
+                ))
+        finally:
+            if loop != asyncio.get_event_loop():
+                loop.close()
+    
+
+    async def async_cancel_request(
         self,
         conversation_id: str,
         request_id: str
@@ -224,7 +331,38 @@ 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
+        """
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # 如果事件循环已经在运行，创建一个新的事件循环
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            loop = new_loop
+            
+        try:
+            return loop.run_until_complete(
+               self.async_cancel_request(
+                    conversation_id=conversation_id,
+                    request_id=request_id
+                ))
+        finally:
+            if loop != asyncio.get_event_loop():
+                loop.close()
+
+    async def async_cancel_conversation(
         self,
         conversation_id: str
     ) -> bool:
@@ -258,7 +396,38 @@ 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
+        """
+        
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # 如果事件循环已经在运行，创建一个新的事件循环
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            loop = new_loop
+            
+        try:
+            return loop.run_until_complete(
+               self.async_cancel_conversation(
+                    conversation_id=conversation_id
+                ))
+        finally:
+            if loop != asyncio.get_event_loop():
+                loop.close()
+
+
+    async def async_continue_humanloop(
         self,
         conversation_id: str,
         context: Dict[str, Any],
@@ -290,7 +459,46 @@ 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
+        """
+
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # 如果事件循环已经在运行，创建一个新的事件循环
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            loop = new_loop
+            
+        try:
+            return loop.run_until_complete(
+               self.async_continue_humanloop(
+                    conversation_id=conversation_id,
+                    context=context,
+                    metadata=metadata,
+                    timeout=timeout
+                    ))
+        finally:
+            if loop != asyncio.get_event_loop():
+                loop.close()
+
+    def async_get_conversation_history(self, conversation_id: str) -> List[Dict[str, Any]]:
         """Get complete history for the specified conversation
         
         Args:
@@ -315,8 +523,30 @@ 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
+        """
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            loop = new_loop
+            
+        try:
+            return loop.run_until_complete(self.async_get_conversation_history(conversation_id))
+        finally:
+            if loop != asyncio.get_event_loop():
+                loop.close()
+
 
-    def _create_timeout_task(
+    async def _async_create_timeout_task(
         self, 
         conversation_id: str,
         request_id: str,