hyperpocket-langgraph 0.1.10__tar.gz → 0.2.0__tar.gz

{hyperpocket_langgraph-0.1.10 → hyperpocket_langgraph-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperpocket-langgraph
-Version: 0.1.10
+Version: 0.2.0
 Author-email: Hyperpocket Team <hyperpocket@vessl.ai>
 Requires-Python: >=3.10
 Requires-Dist: hyperpocket>=0.0.3

{hyperpocket_langgraph-0.1.10 → hyperpocket_langgraph-0.2.0}/hyperpocket_langgraph/__init__.py

@@ -1,3 +1,3 @@
 from hyperpocket_langgraph.pocket_langgraph import PocketLanggraph
 
-__all__ = ["PocketLanggraph"]
+__all__ = ["PocketLanggraph"]

{hyperpocket_langgraph-0.1.10 → hyperpocket_langgraph-0.2.0}/hyperpocket_langgraph/pocket_langgraph.py

@@ -1,26 +1,21 @@
 import copy
 from typing import Optional
 
+from hyperpocket.config import pocket_logger
 from langchain_core.runnables import RunnableConfig
 from langgraph.errors import NodeInterrupt
 from pydantic import BaseModel
 
-from hyperpocket.config import pocket_logger
-
 try:
     from langchain_core.messages import ToolMessage
     from langchain_core.tools import BaseTool, StructuredTool
 except ImportError:
-    raise ImportError(
-        "You need to install langchain to use pocket langgraph."
-    )
+    raise ImportError("You need to install langchain to use pocket langgraph.")
 
 try:
     from langgraph.graph import MessagesState
 except ImportError:
-    raise ImportError(
-        "You need to install langgraph to use pocket langgraph"
-    )
+    raise ImportError("You need to install langgraph to use pocket langgraph")
 
 from hyperpocket import Pocket
 from hyperpocket.tool import Tool as PocketTool
@@ -34,16 +29,22 @@ class PocketLanggraph(Pocket):
     def get_tools(self, use_profile: Optional[bool] = None):
         if use_profile is not None:
             self.use_profile = use_profile
-        return [self._get_langgraph_tool(tool_impl) for tool_impl in
-                self.core.tools.values()]
-
-    def get_tool_node(self, should_interrupt: bool = False, use_profile: Optional[bool] = None):
+        return [
+            self._get_langgraph_tool(tool_impl)
+            for tool_impl in self.core.tools.values()
+        ]
+
+    def get_tool_node(
+        self, should_interrupt: bool = False, use_profile: Optional[bool] = None
+    ):
         if use_profile is not None:
             self.use_profile = use_profile
 
-        async def _tool_node(state: PocketLanggraphBaseState, config: RunnableConfig) -> dict:
+        async def _tool_node(
+            state: PocketLanggraphBaseState, config: RunnableConfig
+        ) -> dict:
             thread_id = config.get("configurable", {}).get("thread_id", "default")
-            last_message = state['messages'][-1]
+            last_message = state["messages"][-1]
             tool_calls = last_message.tool_calls
 
             # 01. prepare
@@ -54,9 +55,9 @@ class PocketLanggraph(Pocket):
                 pocket_logger.debug(f"prepare tool {tool_call}")
                 _tool_call = copy.deepcopy(tool_call)
 
-                tool_call_id = _tool_call['id']
-                tool_name = _tool_call['name']
-                tool_args = _tool_call['args']
+                tool_call_id = _tool_call["id"]
+                tool_name = _tool_call["name"]
+                tool_args = _tool_call["args"]
 
                 if self.use_profile:
                     body = tool_args.pop("body")
@@ -68,27 +69,42 @@ class PocketLanggraph(Pocket):
                 if isinstance(body, BaseModel):
                     body = body.model_dump()
 
-                prepare = await self.prepare_in_subprocess(tool_name, body=body, thread_id=thread_id,
-                                                           profile=profile)
+                prepare = await self.prepare_in_subprocess(
+                    tool_name, body=body, thread_id=thread_id, profile=profile
+                )
                 need_prepare |= True if prepare else False
 
                 if prepare is None:
-                    prepare_done_list.append(ToolMessage(content="prepare done", tool_call_id=tool_call_id))
+                    prepare_done_list.append(
+                        ToolMessage(content="prepare done", tool_call_id=tool_call_id)
+                    )
                 else:
-                    prepare_list.append(ToolMessage(content=prepare, tool_call_id=tool_call_id))
+                    prepare_list.append(
+                        ToolMessage(content=prepare, tool_call_id=tool_call_id)
+                    )
 
             if need_prepare:
                 pocket_logger.debug(f"need prepare : {prepare_list}")
                 if should_interrupt:  # interrupt
-                    pocket_logger.debug(f"{last_message.name}({last_message.id}) is interrupt.")
-                    result = "\n\t" + "\n\t".join(set(msg.content for msg in prepare_list))
-                    raise NodeInterrupt(f'{result}\n\nThe tool execution interrupted. Please talk to me to resume.')
+                    pocket_logger.debug(
+                        f"{last_message.name}({last_message.id}) is interrupt."
+                    )
+                    result = "\n\t" + "\n\t".join(
+                        set(msg.content for msg in prepare_list)
+                    )
+                    raise NodeInterrupt(
+                        f"{result}\n\nThe tool execution interrupted. Please talk to me to resume."
+                    )
 
                 else:  # multi turn
-                    pocket_logger.debug(f"{last_message.name}({last_message.id}) is multi-turn")
+                    pocket_logger.debug(
+                        f"{last_message.name}({last_message.id}) is multi-turn"
+                    )
                     return {"messages": prepare_done_list + prepare_list}
 
-            pocket_logger.debug(f"no need prepare {last_message.name}({last_message.id})")
+            pocket_logger.debug(
+                f"no need prepare {last_message.name}({last_message.id})"
+            )
 
             # 02. authenticate and tool call
             tool_messages = []
@@ -96,9 +112,9 @@ class PocketLanggraph(Pocket):
                 pocket_logger.debug(f"authenticate and call {tool_call}")
                 _tool_call = copy.deepcopy(tool_call)
 
-                tool_call_id = _tool_call['id']
-                tool_name = _tool_call['name']
-                tool_args = _tool_call['args']
+                tool_call_id = _tool_call["id"]
+                tool_name = _tool_call["name"]
+                tool_args = _tool_call["args"]
                 if self.use_profile:
                     body = tool_args.pop("body")
                     profile = tool_args.pop("profile", "default")
@@ -111,27 +127,48 @@ class PocketLanggraph(Pocket):
 
                 try:
                     auth = await self.authenticate_in_subprocess(
-                        tool_name, body=body, thread_id=thread_id, profile=profile)
+                        tool_name, body=body, thread_id=thread_id, profile=profile
+                    )
                 except Exception as e:
-                    pocket_logger.error(f"occur exception during authenticate. error : {e}")
+                    pocket_logger.error(
+                        f"occur exception during authenticate. error : {e}"
+                    )
                     tool_messages.append(
-                        ToolMessage(content=f"occur exception during authenticate. error : {e}", tool_name=tool_name,
-                                    tool_call_id=tool_call_id))
+                        ToolMessage(
+                            content=f"occur exception during authenticate. error : {e}",
+                            tool_name=tool_name,
+                            tool_call_id=tool_call_id,
+                        )
+                    )
                     continue
 
                 try:
                     result = await self.tool_call_in_subprocess(
-                        tool_name, body=body, envs=auth, thread_id=thread_id,
-                        profile=tool_args.get("profile", "default"))
+                        tool_name,
+                        body=body,
+                        envs=auth,
+                        thread_id=thread_id,
+                        profile=tool_args.get("profile", "default"),
+                    )
                 except Exception as e:
-                    pocket_logger.error(f"occur exception during tool calling. error : {e}")
+                    pocket_logger.error(
+                        f"occur exception during tool calling. error : {e}"
+                    )
                     tool_messages.append(
-                        ToolMessage(content=f"occur exception during tool calling. error : {e}", tool_name=tool_name,
-                                    tool_call_id=tool_call_id))
+                        ToolMessage(
+                            content=f"occur exception during tool calling. error : {e}",
+                            tool_name=tool_name,
+                            tool_call_id=tool_call_id,
+                        )
+                    )
                     continue
 
                 pocket_logger.debug(f"{tool_name} tool result : {result}")
-                tool_messages.append(ToolMessage(content=result, tool_name=tool_name, tool_call_id=tool_call_id))
+                tool_messages.append(
+                    ToolMessage(
+                        content=result, tool_name=tool_name, tool_call_id=tool_call_id
+                    )
+                )
 
             return {"messages": tool_messages}
 
@@ -151,10 +188,12 @@ class PocketLanggraph(Pocket):
             if isinstance(body, BaseModel):
                 body = body.model_dump()
 
-            result, interrupted = self.invoke_with_state(pocket_tool.name, body, thread_id, profile, **kwargs)
+            result, interrupted = self.invoke_with_state(
+                pocket_tool.name, body, thread_id, profile, **kwargs
+            )
             say = result
             if interrupted:
-                say = f'{say}\n\nThe tool execution interrupted. Please talk to me to resume.'
+                say = f"{say}\n\nThe tool execution interrupted. Please talk to me to resume."
             return say
 
         async def _ainvoke(**kwargs) -> str:
@@ -170,10 +209,12 @@ class PocketLanggraph(Pocket):
             if isinstance(body, BaseModel):
                 body = body.model_dump()
 
-            result, interrupted = await self.ainvoke_with_state(pocket_tool.name, body, thread_id, profile, **kwargs)
+            result, interrupted = await self.ainvoke_with_state(
+                pocket_tool.name, body, thread_id, profile, **kwargs
+            )
             say = result
             if interrupted:
-                say = f'{say}\n\nThe tool execution interrupted. Please talk to me to resume.'
+                say = f"{say}\n\nThe tool execution interrupted. Please talk to me to resume."
             return say
 
         return StructuredTool.from_function(

{hyperpocket_langgraph-0.1.10 → hyperpocket_langgraph-0.2.0}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "hyperpocket-langgraph"
-version = "0.1.10"
+version = "0.2.0"
 description = ""
 authors = [{ name = "Hyperpocket Team", email = "hyperpocket@vessl.ai" }]
 requires-python = ">=3.10"
@@ -12,31 +12,12 @@ dependencies = ["langgraph>=0.2.59", "hyperpocket>=0.0.3"]
 hyperpocket = { path = "../../hyperpocket", editable = true }
 
 [dependency-groups]
-dev = [
-    "pytest>=8.3.4",
-    "ruff>=0.8.6",
-]
-test = [
-    "langchain-openai>=0.3.1",
-]
+dev = ["pytest>=8.3.4", "ruff>=0.8.6"]
+test = ["langchain-openai>=0.3.1"]
 
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
-[tool.ruff.lint]
-select = [
-    "E", # pycodestyle errors,
-    "F", # pyflakes errors,
-    "I", # isort errors,
-]
-ignore = [
-    "E501", # line too long, handled by formatting
-]
-
 [tool.ruff]
-line-length = 88
-target-version = "py310"
-
-[tool.ruff.lint.per-file-ignores]
-"__init__.py" = ["F401"]
+extend = "../../../.ruff.toml"

{hyperpocket_langgraph-0.1.10 → hyperpocket_langgraph-0.2.0}/tests/test_pocket_langgraph_no_profile.py

@@ -1,20 +1,18 @@
 import ast
 from unittest.async_case import IsolatedAsyncioTestCase
 
+from hyperpocket.config import config, secret
+from hyperpocket.tool import from_git
 from langchain_openai import ChatOpenAI
-from langgraph.constants import START, END
+from langgraph.constants import END, START
 from langgraph.graph import MessagesState, StateGraph
 from langgraph.prebuilt import tools_condition
 from pydantic import BaseModel
 
-from hyperpocket.config import config, secret
-from hyperpocket.tool import from_git
 from hyperpocket_langgraph import PocketLanggraph
 
 
 class TestPocketLanggraphNoProfile(IsolatedAsyncioTestCase):
-
-
     async def asyncSetUp(self):
         config.public_server_port = "https"
         config.public_hostname = "localhost"
@@ -24,15 +22,21 @@ class TestPocketLanggraphNoProfile(IsolatedAsyncioTestCase):
 
         self.pocket = PocketLanggraph(
             tools=[
-                from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/none/simple-echo-tool"),
+                from_git(
+                    "https://github.com/vessl-ai/hyperawesometools",
+                    "main",
+                    "managed-tools/none/simple-echo-tool",
+                ),
                 self.add,
-                self.sub_pydantic_args
+                self.sub_pydantic_args,
             ],
-            use_profile=False
+            use_profile=False,
         )
         tools = self.pocket.get_tools()
         tool_node = self.pocket.get_tool_node()
-        self.llm = ChatOpenAI(model="gpt-4o", api_key=secret["OPENAI_API_KEY"]).bind_tools(tools=tools)
+        self.llm = ChatOpenAI(
+            model="gpt-4o", api_key=secret["OPENAI_API_KEY"]
+        ).bind_tools(tools=tools)
 
         def chatbot(state: MessagesState):
             return {"messages": [self.llm.invoke(state["messages"])]}
@@ -52,7 +56,6 @@ class TestPocketLanggraphNoProfile(IsolatedAsyncioTestCase):
     async def asyncTearDown(self):
         self.pocket._teardown_server()
 
-
     async def test_function_tool_no_profile(self):
         # when
         response = await self.graph.ainvoke({"messages": [("user", "add 1, 2")]})
@@ -62,10 +65,7 @@ class TestPocketLanggraphNoProfile(IsolatedAsyncioTestCase):
 
         # then
         self.assertEqual(tool_call.tool_calls[0]["name"], "add")
-        self.assertEqual(tool_call.tool_calls[0]["args"], {
-            'a': 1,
-            'b': 2
-        })
+        self.assertEqual(tool_call.tool_calls[0]["args"], {"a": 1, "b": 2})
         self.assertEqual(tool_result.content, "3")
 
     async def test_pydantic_function_tool_no_profile(self):
@@ -77,15 +77,16 @@ class TestPocketLanggraphNoProfile(IsolatedAsyncioTestCase):
 
         # then
         self.assertEqual(tool_call.tool_calls[0]["name"], "sub_pydantic_args")
-        self.assertEqual(tool_call.tool_calls[0]["args"], {
-            'a': {"first": 1},
-            'b': {"second": 2}
-        })
+        self.assertEqual(
+            tool_call.tool_calls[0]["args"], {"a": {"first": 1}, "b": {"second": 2}}
+        )
         self.assertEqual(tool_result.content, "-1")
 
     async def test_wasm_tool_no_profile(self):
         # when
-        response = await self.graph.ainvoke({"messages": [("user", "echo 'hello world'")]})
+        response = await self.graph.ainvoke(
+            {"messages": [("user", "echo 'hello world'")]}
+        )
 
         tool_call = response["messages"][1]
         tool_result = response["messages"][2]
@@ -94,9 +95,7 @@ class TestPocketLanggraphNoProfile(IsolatedAsyncioTestCase):
 
         # then
         self.assertEqual(tool_call.tool_calls[0]["name"], "simple_echo_text")
-        self.assertEqual(tool_call.tool_calls[0]["args"], {
-            'text': 'hello world'
-        })
+        self.assertEqual(tool_call.tool_calls[0]["args"], {"text": "hello world"})
         self.assertTrue(output["stdout"].startswith("echo message : hello world"))
 
     @staticmethod

{hyperpocket_langgraph-0.1.10 → hyperpocket_langgraph-0.2.0}/tests/test_pocket_langgraph_use_profile.py

@@ -1,20 +1,18 @@
 import ast
 from unittest.async_case import IsolatedAsyncioTestCase
 
+from hyperpocket.config import config, secret
+from hyperpocket.tool import from_git
 from langchain_openai import ChatOpenAI
-from langgraph.constants import START, END
+from langgraph.constants import END, START
 from langgraph.graph import MessagesState, StateGraph
 from langgraph.prebuilt import tools_condition
 from pydantic import BaseModel
 
-from hyperpocket.config import config, secret
-from hyperpocket.tool import from_git
 from hyperpocket_langgraph import PocketLanggraph
 
 
 class TestPocketLanggraphUseProfile(IsolatedAsyncioTestCase):
-
-
     async def asyncSetUp(self):
         config.public_server_port = "https"
         config.public_hostname = "localhost"
@@ -24,15 +22,21 @@ class TestPocketLanggraphUseProfile(IsolatedAsyncioTestCase):
 
         self.pocket = PocketLanggraph(
             tools=[
-                from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/none/simple-echo-tool"),
+                from_git(
+                    "https://github.com/vessl-ai/hyperawesometools",
+                    "main",
+                    "managed-tools/none/simple-echo-tool",
+                ),
                 self.add,
-                self.sub_pydantic_args
+                self.sub_pydantic_args,
             ],
-            use_profile=True
+            use_profile=True,
         )
         tools = self.pocket.get_tools()
         tool_node = self.pocket.get_tool_node()
-        self.llm = ChatOpenAI(model="gpt-4o", api_key=secret["OPENAI_API_KEY"]).bind_tools(tools=tools)
+        self.llm = ChatOpenAI(
+            model="gpt-4o", api_key=secret["OPENAI_API_KEY"]
+        ).bind_tools(tools=tools)
 
         def chatbot(state: MessagesState):
             return {"messages": [self.llm.invoke(state["messages"])]}
@@ -52,7 +56,6 @@ class TestPocketLanggraphUseProfile(IsolatedAsyncioTestCase):
     async def asyncTearDown(self):
         self.pocket._teardown_server()
 
-
     async def test_function_tool_use_profile(self):
         # when
         response = await self.graph.ainvoke({"messages": [("user", "add 1, 2")]})
@@ -62,10 +65,7 @@ class TestPocketLanggraphUseProfile(IsolatedAsyncioTestCase):
 
         # then
         self.assertEqual(tool_call.tool_calls[0]["name"], "add")
-        self.assertEqual(tool_call.tool_calls[0]["args"]["body"], {
-            'a': 1,
-            'b': 2
-        })
+        self.assertEqual(tool_call.tool_calls[0]["args"]["body"], {"a": 1, "b": 2})
         self.assertEqual(tool_result.content, "3")
 
     async def test_pydantic_function_tool_use_profile(self):
@@ -77,15 +77,17 @@ class TestPocketLanggraphUseProfile(IsolatedAsyncioTestCase):
 
         # then
         self.assertEqual(tool_call.tool_calls[0]["name"], "sub_pydantic_args")
-        self.assertEqual(tool_call.tool_calls[0]["args"]["body"], {
-            'a': {"first": 1},
-            'b': {"second": 2}
-        })
+        self.assertEqual(
+            tool_call.tool_calls[0]["args"]["body"],
+            {"a": {"first": 1}, "b": {"second": 2}},
+        )
         self.assertEqual(tool_result.content, "-1")
 
     async def test_wasm_tool_use_profile(self):
         # when
-        response = await self.graph.ainvoke({"messages": [("user", "echo 'hello world'")]})
+        response = await self.graph.ainvoke(
+            {"messages": [("user", "echo 'hello world'")]}
+        )
 
         tool_call = response["messages"][1]
         tool_result = response["messages"][2]
@@ -94,9 +96,9 @@ class TestPocketLanggraphUseProfile(IsolatedAsyncioTestCase):
 
         # then
         self.assertEqual(tool_call.tool_calls[0]["name"], "simple_echo_text")
-        self.assertEqual(tool_call.tool_calls[0]["args"]["body"], {
-            'text': 'hello world'
-        })
+        self.assertEqual(
+            tool_call.tool_calls[0]["args"]["body"], {"text": "hello world"}
+        )
         self.assertTrue(output["stdout"].startswith("echo message : hello world"))
 
     @staticmethod