hyperpocket 0.1.9__tar.gz → 0.1.10__tar.gz

{hyperpocket-0.1.9 → hyperpocket-0.1.10}/.gitignore

@@ -14,6 +14,7 @@ __pycache__/
 build/
 develop-eggs/
 dist/
+!tools/**/dist/
 downloads/
 eggs/
 .eggs/

{hyperpocket-0.1.9 → hyperpocket-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperpocket
-Version: 0.1.9
+Version: 0.1.10
 Summary: Building AI agent with hyperpocket tool in a flash
 Project-URL: Homepage, https://vessl-ai.github.io/hyperpocket
 Project-URL: Repository, https://github.com/vessl-ai/hyperpocket
@@ -76,16 +76,16 @@ Or just use LLM API Clients out of the box.
 ### Using out-of-the-box tools
 
 ```python
-from hyperpocket.tool import from_git
+
 from langchain_openai import ChatOpenAI
 
 from hyperpocket_langchain import PocketLangchain
 
 pklc = PocketLangchain(
-    tools=[
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/get-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/post-message"),
-    ]
+  tools=[
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+  ]
 )
 tools = pklc.get_tools()
 
@@ -124,7 +124,7 @@ Hyperpocket provides way to use end user auth easily.
 You can manage your auths in request-wise level. (e.g. you can use different auths for different requests)
 
 ```python
-from hyperpocket.tool import from_git
+
 from langchain_openai import ChatOpenAI
 from langgraph.graph import StateGraph, START, MessagesState
 from langgraph.prebuilt import tools_condition
@@ -132,10 +132,10 @@ from langgraph.prebuilt import tools_condition
 from hyperpocket_langgraph import PocketLanggraph
 
 pklg = PocketLanggraph(
-    tools=[
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/get-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/post-message"),
-    ],
+  tools=[
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+  ],
 )
 llm = ChatOpenAI()
 
@@ -160,22 +160,21 @@ graph_builder.compile()
 ```
 
 ```python
-from hyperpocket.config import secret
-from hyperpocket.tool import from_git
 from llama_index.core.agent import FunctionCallingAgent
 from llama_index.llms.openai import OpenAI
 
+from hyperpocket.config import secret
 from hyperpocket_llamaindex import PocketLlamaindex
 
 llm = OpenAI(api_key=secret["OPENAI_API_KEY"])
 pocket = PocketLlamaindex(
-    tools=[
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/get-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/post-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/linear/get-issues"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/google/get-calendar-events"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/google/get-calendar-list"),
-    ]
+  tools=[
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/linear/get-issues",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/google/get-calendar-events",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/google/get-calendar-list",
+  ]
 )
 tools = pocket.get_tools()
 

{hyperpocket-0.1.9 → hyperpocket-0.1.10}/README.md

@@ -51,16 +51,16 @@ Or just use LLM API Clients out of the box.
 ### Using out-of-the-box tools
 
 ```python
-from hyperpocket.tool import from_git
+
 from langchain_openai import ChatOpenAI
 
 from hyperpocket_langchain import PocketLangchain
 
 pklc = PocketLangchain(
-    tools=[
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/get-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/post-message"),
-    ]
+  tools=[
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+  ]
 )
 tools = pklc.get_tools()
 
@@ -99,7 +99,7 @@ Hyperpocket provides way to use end user auth easily.
 You can manage your auths in request-wise level. (e.g. you can use different auths for different requests)
 
 ```python
-from hyperpocket.tool import from_git
+
 from langchain_openai import ChatOpenAI
 from langgraph.graph import StateGraph, START, MessagesState
 from langgraph.prebuilt import tools_condition
@@ -107,10 +107,10 @@ from langgraph.prebuilt import tools_condition
 from hyperpocket_langgraph import PocketLanggraph
 
 pklg = PocketLanggraph(
-    tools=[
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/get-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/post-message"),
-    ],
+  tools=[
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+  ],
 )
 llm = ChatOpenAI()
 
@@ -135,22 +135,21 @@ graph_builder.compile()
 ```
 
 ```python
-from hyperpocket.config import secret
-from hyperpocket.tool import from_git
 from llama_index.core.agent import FunctionCallingAgent
 from llama_index.llms.openai import OpenAI
 
+from hyperpocket.config import secret
 from hyperpocket_llamaindex import PocketLlamaindex
 
 llm = OpenAI(api_key=secret["OPENAI_API_KEY"])
 pocket = PocketLlamaindex(
-    tools=[
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/get-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/post-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/linear/get-issues"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/google/get-calendar-events"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/google/get-calendar-list"),
-    ]
+  tools=[
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/linear/get-issues",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/google/get-calendar-events",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/google/get-calendar-list",
+  ]
 )
 tools = pocket.get_tools()
 

{hyperpocket-0.1.9 → hyperpocket-0.1.10}/hyperpocket/pocket_core.py

@@ -38,7 +38,7 @@ class PocketCore:
                     lock = LocalLock(tool_like)
                     req = WasmToolRequest(lock, "")
                 else:
-                    base_repo_url, git_ref, rel_path = GitLock.parsing_repo_url(repo_url=tool_like)
+                    base_repo_url, git_ref, rel_path = GitLock.parse_repo_url(repo_url=tool_like)
                     lock = GitLock(repository_url=base_repo_url, git_ref=git_ref)
                     req = WasmToolRequest(lock=lock, rel_path=rel_path, tool_vars={})
 

{hyperpocket-0.1.9 → hyperpocket-0.1.10}/hyperpocket/util/extract_func_param_desc_from_docstring.py

@@ -23,14 +23,12 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
     if not docstring:
         return {}
 
-    pocket_logger.debug(f"try to extract docstring of {func.__name__} by google style..")
     param_mapping = extract_param_desc_by_google_stype_docstring(docstring, func_params)
     if param_mapping:
         pocket_logger.debug(f"success extract docstring of {func.__name__} by google style!")
         return param_mapping
     pocket_logger.debug(f"not found param desc of {func.__name__} by google style..")
 
-    pocket_logger.debug(f"try to extract docstring of {func.__name__} by other style..")
     param_mapping = extract_param_desc_by_other_styles(docstring, func_params)
     if param_mapping:
         pocket_logger.debug(f"success extract docstring of {func.__name__} by other style!")
@@ -38,7 +36,6 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
     pocket_logger.debug(f"not found param desc of {func.__name__} by other styles..")
 
     # Plain Text Style matching
-    pocket_logger.debug(f"try to extract docstring of {func.__name__} by plain text style..")
     param_descriptions = []
     for line in docstring.split("\n"):
         split_line = line.strip().split(":")
@@ -46,7 +43,8 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
             continue
 
         param_name = split_line[0]
-        cleaned_param_name = clean_bracket_content(param_name)
+        cleaned_param_name = clean_string(param_name)
+        cleaned_param_name = clean_bracket_content(cleaned_param_name)
         description = ":".join(split_line[1:]).strip()
         if cleaned_param_name in func_params:
             param_descriptions.append((cleaned_param_name, description))
@@ -58,6 +56,11 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
     return param_mapping
 
 
+def clean_string(input_string):
+    cleaned = re.sub(r"^[^a-zA-Z_]*|[^a-zA-Z0-9_()\s]*$", "", input_string)
+    return cleaned.strip()
+
+
 def clean_bracket_content(content):
     return re.sub(r"[(\[{<].*?[)\]}>]", "", content)
 
@@ -65,9 +68,9 @@ def clean_bracket_content(content):
 def extract_param_desc_by_other_styles(docstring, func_params) -> dict[str, str]:
     param_descriptions = []
     # Pattern for Sphinx-style or Javadoc-style `:param`, `@param`, `:arg`, `@arg`
-    param_pattern = r"(?:@param|:param|:arg|@arg)\s+(\w+)(?:\s*:\s*|\s+|:\s+)(.*)"
-    matches = re.findall(param_pattern, docstring)
-    for param, desc in matches:
+    param_pattern = r"^\s*(?:@param|:param|:arg|@arg):?\s+(\w+)(?:\((.*?)\))?:?\s*(.*)"
+    matches = re.findall(param_pattern, docstring, re.MULTILINE)
+    for param, _, desc in matches:
         cleaned_param = clean_bracket_content(param)
         param_descriptions.append((cleaned_param, desc.strip()))
     # Ensure no duplicates and match with function parameters
@@ -87,7 +90,7 @@ def extract_param_desc_by_google_stype_docstring(docstring, func_params) -> dict
     param_descriptions = {}
     for line in param_lines:
         # Match parameter line with "name (type): description"
-        param_match = re.match(r"^\s*(\w+)\s*\(\s*(.*?)\s*\)\s*:\s*(.*)", line)
+        param_match = re.match(r"^[^a-zA-Z_]*([a-zA-Z_]\w*)\s*[\(\[]\s*(.*?)\s*[\)\]]\s*:\s*(.*)", line)
         if param_match:
             param, _, desc = param_match.groups()
             cleaned_param = clean_bracket_content(param)

{hyperpocket-0.1.9 → hyperpocket-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperpocket"
-version = "0.1.9"
+version = "0.1.10"
 description = "Building AI agent with hyperpocket tool in a flash"
 authors = [{ name = "Hyperpocket Team", email = "hyperpocket@vessl.ai" }]
 requires-python = ">=3.10"

{hyperpocket-0.1.9 → hyperpocket-0.1.10}/tests/test_pocket.py

@@ -1,6 +1,8 @@
+import ast
 from unittest.async_case import IsolatedAsyncioTestCase
 from urllib.parse import urlparse, parse_qs, unquote
 
+import pytest
 from pydantic import BaseModel
 
 from hyperpocket import Pocket
@@ -99,22 +101,29 @@ class TestPocket(IsolatedAsyncioTestCase):
         # then
         self.assertEqual(result, "4")
 
-    # async def test_wasm_tool(self):
-    #     # given
-    #     tool_name = "simple_echo_text"
-    #
-    #     # when
-    #     result = await self.pocket.ainvoke(
-    #         tool_name=tool_name,
-    #         body={
-    #             "text": "test"
-    #         },
-    #         thread_id=self.thread_id,
-    #         profile=self.profile,
-    #     )
-    #
-    #     # then
-    #     self.assertTrue(result.startswith("echo message : test"))
+    @pytest.mark.skip(reason="after open repo")
+    async def test_wasm_tool(self):
+        # given
+        tool_name = "simple_echo_text"
+        self.pocket = Pocket(
+            tools=[
+                "https://github.com/vessl-ai/hyperpocket/tree/main/tools/none/simple-echo-tool"
+            ]
+        )
+
+        # when
+        result = await self.pocket.ainvoke(
+            tool_name=tool_name,
+            body={
+                "text": "test"
+            },
+            thread_id=self.thread_id,
+            profile=self.profile,
+        )
+        output = ast.literal_eval(result)
+
+        # then
+        self.assertTrue(output["stdout"].startswith("echo message : test"))
 
     async def test_initialize_tool_auth(self):
         # given

hyperpocket-0.1.10/tests/utils/test_extract_func_param_desc_from_docstring.py

@@ -0,0 +1,214 @@
+import unittest
+
+from hyperpocket.util.extract_func_param_desc_from_docstring import extract_param_docstring_mapping
+
+
+class TestExtractFuncParamDescFromDocstring(unittest.TestCase):
+    def test_extract_google_style_param_case1(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            Args:
+                a(int): first desc
+                b(int): second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_google_style_param_case2(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            Args:
+                - a (int) : first desc
+                - b (int) : second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_google_style_param_case3(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            Args:
+                1. a (int) : first desc
+                2. b (int) : second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_other_style_param_case1(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            :param: a: first desc
+            :param: b: second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_other_style_param_case2(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            :param: a(int): first desc
+            :param: b(int): second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_other_style_param_case3(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            @param: a: first desc
+            @param: b: second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_other_style_param_case4(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            @param a(int): first desc
+            @param b(int): second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_other_style_param_case5(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            @arg: a: first desc
+            @arg: b: second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_other_style_param_case6(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            @arg a(int): first desc
+            @arg b(int): second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_other_style_param_case7(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            :arg: a: first desc
+            :arg: b: second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_other_style_param_case8(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            :arg a(int): first desc
+            :arg b(int): second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_other_style_param_case9(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            @arg a first desc
+            @arg b second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_other_style_param_case10(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            :arg a first desc
+            :arg b second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_plain_style_param_case1(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            a(int) : first desc
+            b(int) : second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_plain_style_param_case2(self):
+        def style_func(a: int, b: int):
+            """
+            Style Function
+
+            - a(int) : first desc
+            - b(int) : second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})
+
+    def test_extract_plain_style_param_case3(self):
+        def style_func(a: int, b: int):
+            """
+            a: first desc
+            b: second desc
+            """
+            pass
+
+        params = extract_param_docstring_mapping(style_func)
+        self.assertEqual(params, {'a': 'first desc', 'b': 'second desc'})