hyperpocket 0.0.3__py3-none-any.whl → 0.1.9__py3-none-any.whl

hyperpocket/tool/wasm/tool.py

@@ -1,11 +1,11 @@
+import os
 import json
 import pathlib
 from typing import Any, Optional
 
 import toml
-
 from hyperpocket.auth import AuthProvider
-from hyperpocket.config import pocket_logger
+from hyperpocket.config import settings, pocket_logger
 from hyperpocket.repository import Lock, Lockfile
 from hyperpocket.repository.lock import GitLock, LocalLock
 from hyperpocket.tool import Tool, ToolRequest
@@ -18,26 +18,23 @@ class WasmToolRequest(ToolRequest):
     lock: Lock
     rel_path: str
 
-    def __init__(self, lock: Lock, rel_path: str):
+    def __init__(self, lock: Lock, rel_path: str, tool_vars: dict):
         self.lock = lock
         self.rel_path = rel_path
+        self.overridden_tool_vars = tool_vars
 
     def __str__(self):
         return f"ToolRequest(lock={self.lock}, rel_path={self.rel_path})"
 
+def from_local(path: str, tool_vars: Optional[dict[str, str]] = None) -> WasmToolRequest:
+    if tool_vars is None:
+        tool_vars = dict()
+    return WasmToolRequest(LocalLock(path), "", tool_vars)
 
-def from_local(path: str) -> WasmToolRequest:
-    return WasmToolRequest(LocalLock(path), "")
-
-
-def from_git(repository: str, ref: str, rel_path: str) -> WasmToolRequest:
-    return WasmToolRequest(GitLock(repository_url=repository, git_ref=ref), rel_path)
-
-
-def from_github(owner: str, repo: str, ref: str, rel_path: str) -> WasmToolRequest:
-    repository = f"https://github.com/{owner}/{repo}"
-    return from_git(repository, ref, rel_path)
-
+def from_git(repository: str, ref: str, rel_path: str, tool_vars: Optional[dict[str, str]] = None) -> WasmToolRequest:
+    if not tool_vars:
+        tool_vars = dict()
+    return WasmToolRequest(GitLock(repository_url=repository, git_ref=ref), rel_path, tool_vars)
 
 class WasmTool(Tool):
     """
@@ -76,6 +73,7 @@ class WasmTool(Tool):
             pocket_logger.warning(f"{toolpkg_path} failed to load json schema. error : {e}")
             json_schema = None
 
+        default_tool_vars = dict()
         try:
             with config_path.open("r") as f:
                 config = toml.load(f)
@@ -92,6 +90,7 @@ class WasmTool(Tool):
                 else:
                     raise ValueError("`language` field is required in config.toml")
                 auth = cls._get_auth(config)
+                default_tool_vars = config.get("tool_vars", {})
         except Exception as e:
             raise ValueError(f"Failed to load config.toml: {e}")
 
@@ -100,6 +99,7 @@ class WasmTool(Tool):
                 readme = f.read()
         else:
             readme = None
+        
         return cls(
             name=name,
             description=description,
@@ -109,6 +109,9 @@ class WasmTool(Tool):
             readme=readme,
             pkg_lock=tool_req.lock,
             rel_path=tool_req.rel_path,
+            postprocessings=tool_req.postprocessings,
+            default_tool_vars=default_tool_vars,
+            overridden_tool_vars=tool_req.overridden_tool_vars,
         )
 
     @classmethod
@@ -124,7 +127,7 @@ class WasmTool(Tool):
             auth_handler=auth_handler,
             scopes=scopes,
         )
-
+    
     def template_arguments(self) -> dict[str, str]:
         return {}
 
@@ -133,7 +136,7 @@ class WasmTool(Tool):
             str(self.pkg_lock.toolpkg_path() / self.rel_path),
             self.runtime,
             body,
-            envs,
+            envs | self.tool_vars,
             **kwargs,
         )
 
@@ -142,6 +145,6 @@ class WasmTool(Tool):
             str(self.pkg_lock.toolpkg_path() / self.rel_path),
             self.runtime,
             body,
-            envs,
+            envs | self.tool_vars,
             **kwargs,
         )

hyperpocket/tool_like.py

@@ -0,0 +1,5 @@
+from typing import Union, Callable
+
+from hyperpocket.tool import ToolRequest, Tool
+
+ToolLike = Union[Tool, str, Callable, ToolRequest]

hyperpocket/util/__init__.py

@@ -1 +1 @@
-__all__ = ['json_schema_to_model', "tool_to_open_ai_spec"]
+__all__ = ['json_schema_to_model']

hyperpocket/util/extract_func_param_desc_from_docstring.py

@@ -41,13 +41,13 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
     pocket_logger.debug(f"try to extract docstring of {func.__name__} by plain text style..")
     param_descriptions = []
     for line in docstring.split("\n"):
-        l = line.strip().split(":")
-        if len(l) < 2:
+        split_line = line.strip().split(":")
+        if len(split_line) < 2:
             continue
 
-        param_name = l[0]
+        param_name = split_line[0]
         cleaned_param_name = clean_bracket_content(param_name)
-        description = ":".join(l[1:]).strip()
+        description = ":".join(split_line[1:]).strip()
         if cleaned_param_name in func_params:
             param_descriptions.append((cleaned_param_name, description))
 

hyperpocket/util/function_to_model.py

@@ -1,6 +1,6 @@
 import inspect
 from inspect import signature, Parameter
-from typing import Any, Dict, Type, Tuple, List
+from typing import Any, Dict, Type, Tuple
 
 from pydantic import BaseModel, create_model
 from pydantic.fields import FieldInfo
@@ -33,7 +33,10 @@ def function_to_model(func: callable) -> Type[BaseModel]:
         if param.annotation is Parameter.empty:
             raise Exception(f"Should all arguments be annotated but {param_name} is not annotated")
 
-        if param.annotation.__module__ != "builtins" and not issubclass(param.annotation, BaseModel):
+        if param.annotation.__module__ == "typing" and param.annotation.__name__ == "Optional":
+            fields[param_name] = (
+                param.annotation.__args__[0], FieldInfo(default=param.default, description=param_desc_map.get(param_name, "")))
+        elif param.annotation.__module__ != "builtins" and not issubclass(param.annotation, BaseModel):
             raise Exception(
                 f"currently only support builtin types and pydantic BaseModel but {param_name} is not builtin type")
 

hyperpocket/util/json_schema_to_model.py

@@ -1,4 +1,4 @@
-from typing import Type
+from typing import Type, Union
 
 from pydantic import BaseModel, create_model, Field
 
@@ -12,32 +12,25 @@ def json_schema_to_model(schema: dict, model_name: str = "DynamicModel") -> Type
     required_fields = schema.get("required", [])
     for property_name, property_schema in schema.get("properties", {}).items():
         field_type, field_default, field_description, required = None, None, None, False
-        if "type" in property_schema:
-            json_type = property_schema["type"]
-            if json_type == "integer":
-                field_type = int
-            elif json_type == "string":
-                field_type = str
-            elif json_type == "object":
-                if "properties" in property_schema:
-                    # Recursively create nested models
-                    field_type = json_schema_to_model(property_schema, model_name)
-                else:
-                    field_type = dict
 
-            elif json_type == "array":
-                # Handle arrays; currently assuming array of objects or primitives
-                item_schema = property_schema.get("items", {})
-                if item_schema.get("type") == "object":
-                    field_type = list[json_schema_to_model(item_schema, model_name)]
-                else:
-                    field_type = list
-            if "default" in property_schema:
-                field_default = property_schema["default"]
-            if "description" in property_schema:
-                field_description = property_schema["description"]
-            if property_name in required_fields:
-                required = True
+        if "anyOf" in property_schema:
+            types = []
+            for item in property_schema["anyOf"]:
+                sub_type = _convert_to_python_type(item["type"], model_name, property_schema)
+                types.append(sub_type)
+
+            field_type = Union[tuple(types)]
+        elif "type" in property_schema:
+            field_type = _convert_to_python_type(property_schema["type"], model_name, property_schema)
+        else:
+            raise RuntimeError("have no type in json schema.")
+
+        if "default" in property_schema:
+            field_default = property_schema["default"]
+        if "description" in property_schema:
+            field_description = property_schema["description"]
+        if property_name in required_fields:
+            required = True
 
         if required:
             fields[property_name] = (field_type, Field(description=field_description))
@@ -67,3 +60,31 @@ def json_schema_to_model(schema: dict, model_name: str = "DynamicModel") -> Type
     model.Config = Config
 
     return model
+
+
+def _convert_to_python_type(json_type, model_name, property_schema):
+    field_type = None
+    if json_type == "integer":
+        field_type = int
+    elif json_type == "string":
+        field_type = str
+    elif json_type == "boolean":
+        field_type = bool
+    elif json_type == "number":
+        field_type = float
+    elif json_type == "none":
+        field_type = type(None)
+    elif json_type == "object":
+        if "properties" in property_schema:
+            # Recursively create nested models
+            field_type = json_schema_to_model(property_schema, model_name)
+        else:
+            field_type = dict
+    elif json_type == "array":
+        # Handle arrays; currently assuming array of objects or primitives
+        item_schema = property_schema.get("items", {})
+        if item_schema.get("type") == "object":
+            field_type = list[json_schema_to_model(item_schema, model_name)]
+        else:
+            field_type = list
+    return field_type

{hyperpocket-0.0.3.dist-info → hyperpocket-0.1.9.dist-info}/METADATA

@@ -1,47 +1,41 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: hyperpocket
-Version: 0.0.3
+Version: 0.1.9
 Summary: Building AI agent with hyperpocket tool in a flash
-Home-page: https://vessl-ai.github.io/hyperpocket
-Author: VESSL AI Devs
-Author-email: dev@vessl.ai
-Requires-Python: >=3.11,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: click (>=8.1.7,<9.0.0)
-Requires-Dist: dynaconf (>=3.2.6,<4.0.0)
-Requires-Dist: fastapi (>=0.115.5,<0.116.0)
-Requires-Dist: gitpython (>=3.1.43,<4.0.0)
-Requires-Dist: httpx (==0.27)
-Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
-Requires-Dist: multiprocess (>=0.70.17,<0.71.0)
-Requires-Dist: playwright (>=1.49.0,<2.0.0)
-Requires-Dist: pydantic (>=2.10.2,<3.0.0)
-Requires-Dist: pygithub (>=2.5.0,<3.0.0)
-Requires-Dist: python-multipart (>=0.0.19,<0.0.20)
-Requires-Dist: redis (>=5.2.1,<6.0.0)
-Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: toml (>=0.10.2,<0.11.0)
-Requires-Dist: uvicorn (>=0.32.1,<0.33.0)
+Project-URL: Homepage, https://vessl-ai.github.io/hyperpocket
 Project-URL: Repository, https://github.com/vessl-ai/hyperpocket
+Author-email: Hyperpocket Team <hyperpocket@vessl.ai>
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.7
+Requires-Dist: dynaconf>=3.2.6
+Requires-Dist: fastapi>=0.115.5
+Requires-Dist: gitpython>=3.1.43
+Requires-Dist: httpx==0.27
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: multiprocess>=0.70.17
+Requires-Dist: playwright>=1.49.0
+Requires-Dist: pydantic>=2.10.2
+Requires-Dist: pygithub>=2.5.0
+Requires-Dist: python-multipart>=0.0.19
+Requires-Dist: redis>=5.2.1
+Requires-Dist: requests>=2.32.3
+Requires-Dist: toml>=0.10.2
+Requires-Dist: uvicorn>=0.32.1
 Description-Content-Type: text/markdown
 
-# Pocket 👛
+# Hyperpocket 👛
 
-Pocket is where tools belong. Power your agent up with a pocket of tools. 👛
+Hyperpocket is where tools belong. Power your agent up with a pocket of tools. 👛
 
 <figure>
-<img src="image.png" alt="4d-pocket" width="200"/>
-<figcaption>© Doraemon</figcaption>
+<img src="../../logo.png" alt="hyperpocket" width="200"/>
 </figure>
 
 ## Introduction
 
-Pocket is a tool that allows you to easily use tool and auth for agents on your machine.
+Hyperpocket is a tool that allows you to easily use tool and auth for agents on your machine.
 
-**_Start fast._** Just install Pocket and use it. We know you don't have time to authenticate to our server.
+**_Start fast._** Just install Hyperpocket and use it. We know you don't have time to authenticate to our server.
 
 **_Go securely._** Not like others, you are the only one who knows your secret tokens. We do NOT. All of your secret
 tokens belong to your infrastructure, not ours.
@@ -52,17 +46,12 @@ with the dependency spaghetti.
 
 **_Battery Included_** You can use popular tools and authentication providers out-of-the-box.
 
-<figure>
-<img src="pocket1.png" alt="pocket-flow" width="400"/>
-<figcaption></figcaption>
-</figure>
-
 ## Installation
 
-1. install pocket
+1. install hyperpocket
 
 ```bash
-pip install pocket
+pip install hyperpocket
 ```
 
 2. install playwright
@@ -87,17 +76,15 @@ 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
 
-import hyperpocket as pk
-import hyperpocket.curated_tools
-from pocket_langchain import PocketLangchain
+from hyperpocket_langchain import PocketLangchain
 
 pklc = PocketLangchain(
     tools=[
-        *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
-        *pk.curated_tools.LINEAR,
-        "https://github.com/my-org/some-awesome-tool",
+        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 = pklc.get_tools()
@@ -111,45 +98,43 @@ llm_tool_binding.invoke(...)
 
 There are two kinds of auth process, one is using system auth(developer api key) and the other is using end user auth.
 
-Pocket provides way to use end user auth easily.
+Hyperpocket provides way to use end user auth easily.
 (Of course, you can also just set your STRIPE_API_KEY when using Stripe API related tools)
 
 - Supported methods
 
-    - [x] OAuth
-    - [x] Token
-    - [ ] Basic Auth (Username, Password)
+  - [x] OAuth
+  - [x] Token
+  - [ ] Basic Auth (Username, Password)
 
 - Supported OAuth Providers
-    - [x] Google
-    - [x] GitHub
-    - [x] Slack
-    - [x] Linear
-    - [ ] Facebook
-    - [ ] X (Previously Twitter)
-    - [ ] LinkedIn
-    - [ ] Discord
-    - [ ] Zoom
-    - [ ] Microsoft
-    - [ ] Spotify
-    - [ ] Twitch
+  - [x] Google
+  - [x] GitHub
+  - [x] Slack
+  - [x] Linear
+  - [ ] Facebook
+  - [ ] X (Previously Twitter)
+  - [ ] LinkedIn
+  - [ ] Discord
+  - [ ] Zoom
+  - [ ] Microsoft
+  - [ ] Spotify
+  - [ ] Twitch
 
 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
 
-import hyperpocket as pk
-import hyperpocket.curated_tools
-from pocket_langgraph import PocketLanggraph
+from hyperpocket_langgraph import PocketLanggraph
 
 pklg = PocketLanggraph(
     tools=[
-        *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
-        *pk.curated_tools.LINEAR,
-        "https://github.com/my-org/some-awesome-tool",
+        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"),
     ],
 )
 llm = ChatOpenAI()
@@ -175,12 +160,12 @@ 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 pocket_llamaindex import PocketLlamaindex
 
-from hyperpocket.config import secret
-from hyperpocket.tool import from_git
+from hyperpocket_llamaindex import PocketLlamaindex
 
 llm = OpenAI(api_key=secret["OPENAI_API_KEY"])
 pocket = PocketLlamaindex(
@@ -227,12 +212,8 @@ Assistance: Here are the recent 10 messages.
 
 ### Config
 
-Running `pocket config init` will create your config file in `$HOME/.pocket/settings.toml`
-
 The `settings.toml` looks as follows.
 
-TODO: Add `secrets.toml`.
-
 ```toml
 log_level = "debug"
 internal_server_port = "8000" # optional, default is 8000
@@ -273,11 +254,11 @@ client_secret = ""  # your github client secret
 
 - While creating your github OAuth app, configuring your app's `Authorization callback URL` is different for your
   development environment and production environment.
-    - For development environment, you can use `http://localhost:8000/auth/github/callback`
-        - **Note**: Default port for pocket dev server is `8000`. If you are using a different port, make sure to
-          replace `8000` with your actual port number.
-    - For production environment, you can use `https://yourdomain.com/auth/github/callback`
-        - **Note**: Make sure to replace `yourdomain.com` with your actual domain name that this app will be hosted on.
+  - For development environment, you can use `http://localhost:8000/auth/github/callback`
+    - **Note**: Default port for hyperpocket dev server is `8000`. If you are using a different port, make sure to
+      replace `8000` with your actual port number.
+  - For production environment, you can use `https://yourdomain.com/auth/github/callback`
+    - **Note**: Make sure to replace `yourdomain.com` with your actual domain name that this app will be hosted on.
 
 #### How to integrate SLACK OAuth app
 
@@ -288,15 +269,53 @@ client_secret = ""  # your github client secret
 - Redirect URLs :
   `{public_server_protocol}://{public_hostname}:[{public_server_port}]/{callback_url_rewrite_prefix}/auth/slack/oauth2/callback`
 - Scopes : What you want to request to user.
-    - Recommended scopes :
-        - channels:history,
-        - channels:read,
-        - chat:write,
-        - groups:history,
-        - groups:read,
-        - im:history,
-        - mpim:history,
-        - reactions:read,
-        - reactions:write,
+  - Recommended scopes :
+    - channels:history,
+    - channels:read,
+    - chat:write,
+    - groups:history,
+    - groups:read,
+    - im:history,
+    - mpim:history,
+    - reactions:read,
+    - reactions:write,
 
 3. Set your Slack APP Client ID / Client Secret in `$HOME/.pocket/settings.toml`
+
+#### How to start adding a new token auth
+
+1. Generate boilerplate codes for token-based auth services ?
+
+```
+# service_name should be lowercase including underscore
+poetry run hyperpocket devtool create-token-auth-template {service_name}
+```
+
+It will generate boilerplate code lines for a new token-based auth service
+
+2. Extend AuthProvider enum to add your new auth provider.
+
+```python
+class AuthProvider(Enum):
+SERVICE = 'service'
+```
+
+3. Specify auth provider for tools
+
+1) github repo or local
+
+```toml
+[auth]
+auth_provider = "{service_name}"
+auth_handler = "{service_name}-token"
+scopes = []
+```
+
+2. function_tool
+
+```python
+@function_tool(
+    auth_provider=AuthProvider.SERVICE
+)
+def my_function(**kwargs):
+```