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

gohumanloop/utils/threadsafedict.py

@@ -3,8 +3,9 @@ import asyncio
 import threading
 
 
-K = TypeVar('K')
-V = TypeVar('V')
+K = TypeVar("K")
+V = TypeVar("V")
+
 
 class ThreadSafeDict(Generic[K, V]):
     """
@@ -27,71 +28,71 @@ class ThreadSafeDict(Generic[K, V]):
     - 为每个键创建独立的锁，减少不同键之间的锁竞争
     - 使用全局锁 self._global_lock 保护键级别锁的创建和删除
     """
-    
-    def __init__(self):
-        self._dict = {}
+
+    def __init__(self) -> None:
+        self._dict: dict[Any, Any] = {}
         # 使用 threading.RLock 支持同步操作的线程安全
         self._sync_lock = threading.RLock()
         # 使用 asyncio.Lock 支持异步操作的线程安全
         self._async_lock = asyncio.Lock()
         # 键级别锁字典
-        self._key_locks = {}
+        self._key_locks: dict[Any, asyncio.Lock] = {}
         # 键级别锁的全局锁
         self._global_lock = asyncio.Lock()
-        
-    async def _get_key_lock(self, key):
+
+    async def _get_key_lock(self, key: K) -> asyncio.Lock:
         """获取指定键的锁，如果不存在则创建"""
         async with self._global_lock:
             if key not in self._key_locks:
                 self._key_locks[key] = asyncio.Lock()
             return self._key_locks[key]
-    
+
     # 同步方法 - 使用 threading.RLock 保证线程安全
-    def __getitem__(self, key: K) -> V:
+    def __getitem__(self, key: K) -> Any:
         """获取值 - 同步方法，用于 dict[key] 语法"""
         with self._sync_lock:
             return self._dict[key]
-    
+
     def __setitem__(self, key: K, value: V) -> None:
         """设置值 - 同步方法，用于 dict[key] = value 语法"""
         with self._sync_lock:
             self._dict[key] = value
-    
+
     def __delitem__(self, key: K) -> None:
         """删除键 - 同步方法，用于 del dict[key] 语法"""
         with self._sync_lock:
             del self._dict[key]
-    
+
     def __contains__(self, key: K) -> bool:
         """检查键是否存在 - 同步方法，用于 key in dict 语法"""
         with self._sync_lock:
             return key in self._dict
-    
-    def get(self, key: K, default: Optional[V] = None) -> Optional[V]:
+
+    def get(self, key: K, default: Optional[V] = None) -> Any:
         """获取值，如果不存在则返回默认值 - 同步方法"""
         with self._sync_lock:
             return self._dict.get(key, default)
-    
+
     def __len__(self) -> int:
         """获取字典长度 - 同步方法，用于 len(dict) 语法"""
         with self._sync_lock:
             return len(self._dict)
-    
-    def keys(self):
+
+    def keys(self) -> list:
         """获取所有键 - 同步方法"""
         with self._sync_lock:
             return list(self._dict.keys())
-    
-    def values(self):
+
+    def values(self) -> list:
         """获取所有值 - 同步方法"""
         with self._sync_lock:
             return list(self._dict.values())
-    
-    def items(self):
+
+    def items(self) -> list:
         """获取所有键值对 - 同步方法"""
         with self._sync_lock:
             return list(self._dict.items())
-            
+
     def update(self, key: K, updates: Dict[str, Any]) -> bool:
         """更新字典中的值 - 同步方法"""
         with self._sync_lock:
@@ -99,7 +100,7 @@ class ThreadSafeDict(Generic[K, V]):
                 self._dict[key].update(updates)
                 return True
             return False
-            
+
     def update_item(self, key: K, item_key: Any, item_value: Any) -> bool:
         """更新字典中的单个项 - 同步方法"""
         with self._sync_lock:
@@ -107,20 +108,20 @@ class ThreadSafeDict(Generic[K, V]):
                 self._dict[key][item_key] = item_value
                 return True
             return False
-    
+
     # 异步方法 - 使用 asyncio.Lock 保证线程安全
-    async def aget(self, key: K, default: Optional[V] = None) -> Optional[V]:
+    async def aget(self, key: K, default: Optional[V] = None) -> Any:
         """安全地获取值 - 异步方法"""
         async with self._async_lock:
             return self._dict.get(key, default)
-    
+
     async def aset(self, key: K, value: V) -> None:
         """安全地设置值 - 异步方法"""
         key_lock = await self._get_key_lock(key)
         async with key_lock:
             async with self._async_lock:
                 self._dict[key] = value
-            
+
     async def adelete(self, key: K) -> bool:
         """安全地删除键 - 异步方法"""
         key_lock = await self._get_key_lock(key)
@@ -134,7 +135,7 @@ class ThreadSafeDict(Generic[K, V]):
                             del self._key_locks[key]
                     return True
                 return False
-    
+
     async def aupdate(self, key: K, updates: Dict[str, Any]) -> bool:
         """安全地更新值 - 异步方法"""
         key_lock = await self._get_key_lock(key)
@@ -144,7 +145,7 @@ class ThreadSafeDict(Generic[K, V]):
                     self._dict[key].update(updates)
                     return True
                 return False
-    
+
     async def aupdate_item(self, key: K, item_key: Any, item_value: Any) -> bool:
         """安全地更新字典中的单个项 - 异步方法"""
         key_lock = await self._get_key_lock(key)
@@ -154,90 +155,97 @@ class ThreadSafeDict(Generic[K, V]):
                     self._dict[key][item_key] = item_value
                     return True
                 return False
-    
+
     async def acontains(self, key: K) -> bool:
         """安全地检查键是否存在 - 异步方法"""
         async with self._async_lock:
             return key in self._dict
-            
+
     async def alen(self) -> int:
         """安全地获取字典长度 - 异步方法"""
         async with self._async_lock:
             return len(self._dict)
-            
-    async def akeys(self):
+
+    async def akeys(self) -> list:
         """安全地获取所有键 - 异步方法"""
         async with self._async_lock:
             return list(self._dict.keys())
-            
-    async def avalues(self):
+
+    async def avalues(self) -> list:
         """安全地获取所有值 - 异步方法"""
         async with self._async_lock:
             return list(self._dict.values())
-            
-    async def aitems(self):
+
+    async def aitems(self) -> list:
         """安全地获取所有键值对 - 异步方法"""
         async with self._async_lock:
             return list(self._dict.items())
 
+
 if __name__ == "__main__":
     # 测试同步方法
-    def test_sync_methods():
+    def test_sync_methods() -> None:
         print("\n=== 测试同步方法 ===")
-        sync_dict = ThreadSafeDict()
-        
+        sync_dict: ThreadSafeDict = ThreadSafeDict()
+
         # 测试基本的增删改查操作
         sync_dict["key1"] = "value1"
         print("设置并获取:", sync_dict["key1"])  # value1
         print("键存在性检查:", "key1" in sync_dict)  # True
         print("获取默认值:", sync_dict.get("not_exist", "default"))  # default
-        
+
         # 测试字典长度
         print("字典长度:", len(sync_dict))  # 1
-        
+
         # 测试字典方法
         sync_dict["key2"] = "value2"
         print("所有键:", sync_dict.keys())  # ['key1', 'key2']
         print("所有值:", sync_dict.values())  # ['value1', 'value2']
-        print("所有键值对:", sync_dict.items())  # [('key1', 'value1'), ('key2', 'value2')]
-        
+        print(
+            "所有键值对:", sync_dict.items()
+        )  # [('key1', 'value1'), ('key2', 'value2')]
+
         # 测试嵌套字典更新
         sync_dict["nested"] = {"a": 1}
         sync_dict.update("nested", {"b": 2})
         sync_dict.update_item("nested", "c", 3)
         print("嵌套字典:", sync_dict["nested"])  # {'a': 1, 'b': 2, 'c': 3}
-        
+
         # 测试删除操作
         del sync_dict["key1"]
         print("删除后检查:", "key1" in sync_dict)  # False
 
     # 测试异步方法
-    async def test_async_methods():
+    async def test_async_methods() -> None:
         print("\n=== 测试异步方法 ===")
-        async_dict = ThreadSafeDict()
-        
+        async_dict: ThreadSafeDict = ThreadSafeDict()
+
         # 测试基本的异步增删改查
         await async_dict.aset("key1", "value1")
         print("异步获取:", await async_dict.aget("key1"))  # value1
         print("异步键检查:", await async_dict.acontains("key1"))  # True
-        
+
         # 测试异步字典操作
         await async_dict.aset("key2", "value2")
         print("异步长度:", await async_dict.alen())  # 2
         print("异步所有键:", await async_dict.akeys())  # ['key1', 'key2']
         print("异步所有值:", await async_dict.avalues())  # ['value1', 'value2']
-        print("异步所有键值对:", await async_dict.aitems())  # [('key1', 'value1'), ('key2', 'value2')]
-        
+        print(
+            "异步所有键值对:", await async_dict.aitems()
+        )  # [('key1', 'value1'), ('key2', 'value2')]
+
         # 测试异步嵌套字典更新
         await async_dict.aset("nested", {"x": 1})
         await async_dict.aupdate("nested", {"y": 2})
         await async_dict.aupdate_item("nested", "z", 3)
-        print("异步嵌套字典:", await async_dict.aget("nested"))  # {'x': 1, 'y': 2, 'z': 3}
-        
+        print(
+            "异步嵌套字典:", await async_dict.aget("nested")
+        )  # {'x': 1, 'y': 2, 'z': 3}
+
         # 测试异步删除
         await async_dict.adelete("key1")
         print("异步删除后检查:", await async_dict.acontains("key1"))  # False
-        
+
     # 运行测试
     test_sync_methods()
-    asyncio.run(test_async_methods())
+    asyncio.run(test_async_methods())

gohumanloop/utils/utils.py

@@ -1,13 +1,13 @@
 import asyncio
 import os
-from typing import Optional, Union
+from typing import Awaitable, Any, Optional, Union
 from pydantic import SecretStr
-import warnings
 import logging
 
 logger = logging.getLogger(__name__)
 
-def run_async_safely(coro):
+
+def run_async_safely(coro: Awaitable[Any]) -> Any:
     """
     Safely run async coroutines in synchronous environment
     Will raise RuntimeError if called in async environment
@@ -16,7 +16,7 @@ def run_async_safely(coro):
         loop = asyncio.get_running_loop()
     except RuntimeError:  # No running event loop
         loop = None
-    
+
     if loop is not None:
         raise RuntimeError(
             "Detected running event loop! "
@@ -24,19 +24,19 @@ def run_async_safely(coro):
             "If you really need to call sync code from async context, "
             "consider using asyncio.to_thread() or other proper methods."
         )
-    
+
     # Handle synchronous environment
     try:
         loop = asyncio.get_event_loop()
-        logger.info("Using existing event loop.")
+        logger.debug("Using existing event loop.")
     except RuntimeError:
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
         own_loop = True
-        logger.info("Created new event loop.")
+        logger.debug("Created new event loop.")
     else:
         own_loop = False
-    
+
     try:
         return loop.run_until_complete(coro)
     finally:
@@ -47,24 +47,24 @@ def run_async_safely(coro):
 def get_secret_from_env(
     key: Union[str, list, tuple],
     default: Optional[str] = None,
-    error_message: Optional[str] = None
+    error_message: Optional[str] = None,
 ) -> Optional[SecretStr]:
-        """Get a value from an environment variable."""
-        if isinstance(key, (list, tuple)):
-            for k in key:
-                if k in os.environ:
-                    return SecretStr(os.environ[k])
-        if isinstance(key, str) and key in os.environ:
-            return SecretStr(os.environ[key])
-        if isinstance(default, str):
-            return SecretStr(default)
-        if default is None:
-            return None
-        if error_message:
-            raise ValueError(error_message)
-        msg = (
-            f"Did not find {key}, please add an environment variable"
-            f" `{key}` which contains it, or pass"
-            f" `{key}` as a named parameter."
-        )
-        raise ValueError(msg)
+    """Get a value from an environment variable."""
+    if isinstance(key, (list, tuple)):
+        for k in key:
+            if k in os.environ:
+                return SecretStr(os.environ[k])
+    if isinstance(key, str) and key in os.environ:
+        return SecretStr(os.environ[key])
+    if isinstance(default, str):
+        return SecretStr(default)
+    if default is None:
+        return None
+    if error_message:
+        raise ValueError(error_message)
+    msg = (
+        f"Did not find {key}, please add an environment variable"
+        f" `{key}` which contains it, or pass"
+        f" `{key}` as a named parameter."
+    )
+    raise ValueError(msg)

gohumanloop-0.0.6.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.4
+Name: gohumanloop
+Version: 0.0.6
+Summary: Perfecting AI workflows with human intelligence
+Author-email: gohumanloop authors <baird0917@163.com>
+Project-URL: repository, https://github.com/ptonlix/gohumanloop
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.11.16
+Requires-Dist: click>=8.1.8
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: pydantic>=2.11.3
+Requires-Dist: tomli>=2.2.1
+Provides-Extra: email
+Requires-Dist: imapclient>=3.0.1; extra == "email"
+Provides-Extra: langgraph
+Requires-Dist: langgraph>=0.3.30; extra == "langgraph"
+Provides-Extra: apiservices
+Requires-Dist: fastapi>=0.115.12; extra == "apiservices"
+Requires-Dist: uvicorn>=0.34.2; extra == "apiservices"
+Dynamic: license-file
+
+<div align="center">
+
+![Wordmark Logo of HumanLayer](./docs/images/wordmark.png)
+<b face="雅黑">Perfecting AI workflows with human intelligence</b>
+
+</div>
+
+**GoHumanLoop**: A Python library empowering AI agents to dynamically request human input (approval/feedback/conversation) at critical stages. Core features:
+
+- `Human-in-the-loop control`: Lets AI agent systems pause and escalate decisions, enhancing safety and trust.
+- `Multi-channel integration`: Supports Terminal, Email, API, and frameworks like LangGraph/CrewAI (soon).
+- `Flexible workflows`: Combines automated reasoning with human oversight for reliable AI operations.
+
+Ensures responsible AI deployment by bridging autonomous agents and human judgment.
+
+<div align="center">
+<img alt="Repostart" src="https://img.shields.io/github/stars/ptonlix/gohumanloop"/>
+<img alt=" Python" src="https://img.shields.io/badge/Python-3.10%2B-blue"/>
+<img alt="license" src="https://img.shields.io/badge/license-MIT-green"/>
+
+[简体中文](README-zh.md) | English
+
+</div>
+
+## Table of contents
+
+- [Getting Started](#getting-started)
+- [Why GoHumanloop?](#why-humanlayer)
+- [Key Features](#key-features)
+- [Examples](#examples)
+- [Roadmap](#roadmap)
+- [Contributing](#contributing)
+- [License](#license)
+
+## 🎹 Getting Started
+
+To get started, check out the following example or jump straight into one of the [Examples](./examples/):
+
+- 🦜⛓️ [LangGraph](./examples/langgraph/)
+
+### Example
+
+**GoHumanLoop** currently supports `Python`.
+
+- Installation
+
+```shell
+pip install gohumanloop
+```
+
+- Example
+
+The following example enhances [the official LangGraph example](https://langchain-ai.github.io/langgraph/tutorials/get-started/4-human-in-the-loop/#5-resume-execution) with `human-in-the-loop` functionality.
+
+> 💡 By default, it uses `Terminal` as the `langgraph_adapter` for human interaction.
+
+```python
+import os
+from langchain.chat_models import init_chat_model
+from typing import Annotated
+
+from langchain_tavily import TavilySearch
+from langchain_core.tools import tool
+from typing_extensions import TypedDict
+
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode, tools_condition
+
+# from langgraph.types import Command, interrupt  # Don't use langgraph, use gohumanloop instead
+
+from gohumanloop.adapters.langgraph_adapter import interrupt, create_resume_command
+
+os.environ["DEEPSEEK_API_KEY"] = "sk-xxx"
+os.environ["TAVILY_API_KEY"] = "tvly-xxx"
+
+llm = init_chat_model("deepseek:deepseek-chat")
+
+class State(TypedDict):
+    messages: Annotated[list, add_messages]
+
+graph_builder = StateGraph(State)
+
+@tool
+def human_assistance(query: str) -> str:
+    """Request assistance from a human."""
+    human_response = interrupt({"query": query})
+    return human_response
+
+tool = TavilySearch(max_results=2)
+tools = [tool, human_assistance]
+llm_with_tools = llm.bind_tools(tools)
+
+def chatbot(state: State):
+    message = llm_with_tools.invoke(state["messages"])
+    # Because we will be interrupting during tool execution,
+    # we disable parallel tool calling to avoid repeating any
+    # tool invocations when we resume.
+    assert len(message.tool_calls) <= 1
+    return {"messages": [message]}
+
+graph_builder.add_node("chatbot", chatbot)
+
+tool_node = ToolNode(tools=tools)
+graph_builder.add_node("tools", tool_node)
+
+graph_builder.add_conditional_edges(
+    "chatbot",
+    tools_condition,
+)
+graph_builder.add_edge("tools", "chatbot")
+graph_builder.add_edge(START, "chatbot")
+
+memory = MemorySaver()
+
+graph = graph_builder.compile(checkpointer=memory)
+
+user_input = "I need some expert guidance for building an AI agent. Could you request assistance for me?"
+config = {"configurable": {"thread_id": "1"}}
+
+events = graph.stream(
+    {"messages": [{"role": "user", "content": user_input}]},
+    config,
+    stream_mode="values",
+)
+for event in events:
+    if "messages" in event:
+        event["messages"][-1].pretty_print()
+
+# LangGraph code:
+# human_response = (
+#     "We, the experts are here to help! We'd recommend you check out LangGraph to build your agent."
+#     "It's much more reliable and extensible than simple autonomous agents."
+# )
+
+# human_command = Command(resume={"data": human_response})
+
+# GoHumanLoop code:
+human_command = create_resume_command() # Use this command to resume the execution，instead of using the command above
+
+events = graph.stream(human_command, config, stream_mode="values")
+for event in events:
+    if "messages" in event:
+        event["messages"][-1].pretty_print()
+
+```
+
+## 🎵 Why GoHumanloop?
+
+### Human-in-the-loop
+
+<div align="center">
+	<img height=240 src="http://cdn.oyster-iot.cloud/202505210851404.png"><br>
+    <b face="雅黑">Even with state-of-the-art agentic reasoning and prompt routing, LLMs are not sufficiently reliable to be given access to high-stakes functions without human oversight</b>
+</div>
+<br>
+
+`Human-in-the-loop` is an AI system design philosophy that integrates human judgment and supervision into AI decision-making processes. This concept is particularly important in AI Agent systems:
+
+- **Safety Assurance**: Allows human intervention and review at critical decision points to prevent potentially harmful AI decisions
+- **Quality Control**: Improves accuracy and reliability of AI outputs through expert feedback
+- **Continuous Learning**: AI systems can learn and improve from human feedback, creating a virtuous cycle
+- **Clear Accountability**: Maintains ultimate human control over important decisions with clear responsibility
+
+In practice, Human-in-the-loop can take various forms - from simple decision confirmation to deep human-AI collaborative dialogues - ensuring optimal balance between autonomy and human oversight to maximize the potential of AI Agent systems.
+
+#### Typical Use Cases
+
+<div align="center">
+	<img height=120 src="http://cdn.oyster-iot.cloud/tool-call-review.png"><br>
+    <b face="雅黑"> A human can review and edit the output from the agent before proceeding. This is particularly critical in applications where the tool calls requested may be sensitive or require human oversight.</b>
+</div>
+<br>
+
+- 🛠️ Tool Call Review: Humans can review, edit or approve tool call requests initiated by LLMs before execution
+- ✅ Model Output Verification: Humans can review, edit or approve content generated by LLMs (text, decisions, etc.)
+- 💡 Context Provision: Allows LLMs to actively request human input for clarification, additional details or multi-turn conversation context
+
+### Secure and Efficient Go➡Humanloop
+
+`GoHumanloop` provides a set of tools deeply integrated within AI Agents to ensure constant `Human-in-the-loop` oversight. It deterministically ensures high-risk function calls must undergo human review while also enabling human expert feedback, thereby improving AI system reliability and safety while reducing risks from LLM hallucinations.
+
+<div align="center">
+	<img height=420 src="http://cdn.oyster-iot.cloud/202505210943862.png"><br>
+    <b face="雅黑"> The Outer-Loop and Inversion of Control</b>
+</div>
+<br>
+
+Through `GoHumanloop`'s encapsulation, you can implement secure and efficient `Human-in-the-loop` when requesting tools, Agent nodes, MCP services and other Agents.
+
+## 📚 Key Features
+
+<div align="center">
+	<img height=360 src="http://cdn.oyster-iot.cloud/202505211030197.png"><br>
+    <b face="雅黑"> GoHumanLoop Architecture</b>
+</div>
+<br>
+
+`GoHumanloop` offers the following core capabilities:
+
+- **Approval:** Requests human review or approval when executing specific tool calls or Agent nodes
+- **Information:** Obtains critical human input during task execution to reduce LLM hallucination risks
+- **Conversation:** Enables multi-turn interactions with humans through dialogue to acquire richer contextual information
+- **Framework-specific Integration:** Provides specialized integration methods for specific Agent frameworks, such as `interrupt` and `resume` for `LangGraph`
+
+## 📅 Roadmap
+
+| Feature           | Status     |
+| ----------------- | ---------- |
+| Approval          | ⚙️ Beta    |
+| Information       | ⚙️ Beta    |
+| Conversation      | ⚙️ Beta    |
+| Email Provider    | ⚙️ Beta    |
+| Terminal Provider | ⚙️ Beta    |
+| API Provider      | ⚙️ Beta    |
+| Default Manager   | ⚙️ Beta    |
+| GLH Manager       | 🗓️ Planned |
+| Langchain Support | ⚙️ Beta    |
+| CrewAI Support    | 🗓️ Planned |
+
+- 💡 GLH Manager - GoHumanLoop Manager will integrate with the upcoming GoHumanLoop Hub platform to provide users with more flexible management options.
+
+## 🤝 Contributing
+
+The GoHumanLoop SDK and documentation are open source. We welcome contributions in the form of issues, documentation and PRs. For more details, please see [CONTRIBUTING.md](./CONTRIBUTING.md)
+
+## 📱 Contact
+
+<img height=300 src="http://cdn.oyster-iot.cloud/202505231802103.png"/>
+
+🎉 If you're interested in this project, feel free to scan the QR code to contact the author.
+
+## 🌟 Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=gohumanloop/gohumanloop&type=Date)](https://www.star-history.com/#gohumanloop/gohumanloop&Date)

gohumanloop-0.0.6.dist-info/RECORD

@@ -0,0 +1,30 @@
+gohumanloop/__init__.py,sha256=oJqVOtRRDHNxwxZ2Blw7ycBRwcTBMTURUCx-XcL2YJ0,1969
+gohumanloop/__main__.py,sha256=zdGKN92H9SgwZfL4xLqPkE1YaiRcHhVg_GqC-H1VurA,75
+gohumanloop/adapters/__init__.py,sha256=cFXd9qzyR0oZg8mR912PShj2b_3BAM_RO_cIVMXVdWQ,390
+gohumanloop/adapters/langgraph_adapter.py,sha256=il_zsQMdgbJrwIn_ucQiH1ku3JhozxIQ7RH82KqTLwA,36750
+gohumanloop/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gohumanloop/cli/main.py,sha256=Txjk31MlkiX9zeHZfFEXEu0s2IBESY8sxrxBEzZKk2U,767
+gohumanloop/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gohumanloop/core/interface.py,sha256=D59FR4Bj-7gCFXw_55pPcFBjG2bY-EI5sYZl46tBaB0,21476
+gohumanloop/core/manager.py,sha256=xyJJItJvt5ZPudAa3kWy282jn-I5yCsLJYNPaJyIQLI,29906
+gohumanloop/manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gohumanloop/manager/ghl_manager.py,sha256=rmbfaS5mAb9c8RPr9Id24vO5DJT9ZC4D282dHZ26SJE,22695
+gohumanloop/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gohumanloop/models/api_model.py,sha256=1LtSQdx2ZVMzTdPrOVGe1JE1Cn_B0CnNQDp1-LlnqLw,2950
+gohumanloop/models/glh_model.py,sha256=gix4f_57G4URkwXhCspWhU08Sf1MKu9FtUCx424Vf3A,940
+gohumanloop/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gohumanloop/providers/api_provider.py,sha256=kgduU2udtBUaaMHOjDic7v3bb5kTJeedmlLRpcaOgJM,25771
+gohumanloop/providers/base.py,sha256=JHvkInxLIWkUvypR3fphRGgisSMOkutpl-fRnYSHdOw,21893
+gohumanloop/providers/email_provider.py,sha256=n4-k4m3oQ8TocT-yxGLTwUMTXfgddFiGxEKMq9W6FGA,44704
+gohumanloop/providers/ghl_provider.py,sha256=NmOac2LR0d87pc91sMuYtvTYsKdp4wZrhfmSYuZL2ko,2350
+gohumanloop/providers/terminal_provider.py,sha256=6YiATcbc6TIYrmzT2BSd9U6gNnE6o8TX4HO1M5Ejxgc,14613
+gohumanloop/utils/__init__.py,sha256=l0e3lnOVrt6HwaxidNGFXORX4awCKemhJZ_t3k-5u-s,124
+gohumanloop/utils/context_formatter.py,sha256=sAWrKJpxmsHga6gsyBwFBlAsHW8bjR1hkaGhk1PoE1M,2064
+gohumanloop/utils/threadsafedict.py,sha256=9uyewnwmvS3u1fCx3SK0YWFxHMcyIwlye1Ev7WW7WHA,9588
+gohumanloop/utils/utils.py,sha256=-bti65OaVh5dlvc5BIgiTw6dqxmqdKnOQHE0V-LKjek,2107
+gohumanloop-0.0.6.dist-info/licenses/LICENSE,sha256=-U5tuCcSpndQwSKWtZbFbazb-_AtZcZL2kQgHbSLg-M,1064
+gohumanloop-0.0.6.dist-info/METADATA,sha256=waWXbFIFOXC9loVTl4OJUTB-UbjSae_TZcXLIrMek8k,10057
+gohumanloop-0.0.6.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+gohumanloop-0.0.6.dist-info/entry_points.txt,sha256=wM6jqRRD8bQXkvIduRVCuAJIlbyWg_F5EDXo5OZ_PwY,88
+gohumanloop-0.0.6.dist-info/top_level.txt,sha256=LvOXBqS6Mspmcuqp81uz0Vjx_m_YI0w06DOPCiI1BfY,12
+gohumanloop-0.0.6.dist-info/RECORD,,

{gohumanloop-0.0.5.dist-info → gohumanloop-0.0.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any