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

hyperpocket/session/redis.py

@@ -1,14 +1,18 @@
 import json
-from typing import List, Optional, Any
+from typing import Any, List, Optional
 
 import redis
 
-from hyperpocket.auth import AuthProvider, AUTH_CONTEXT_MAP
+from hyperpocket.auth import AUTH_CONTEXT_MAP, AuthProvider
 from hyperpocket.auth.context import AuthContext
-from hyperpocket.config.session import SessionConfigRedis
-from hyperpocket.config.session import SessionType
-from hyperpocket.session.interface import SessionStorageInterface, SESSION_KEY_DELIMITER, \
-    BaseSessionValue, V, K
+from hyperpocket.config.session import SessionConfigRedis, SessionType
+from hyperpocket.session.interface import (
+    SESSION_KEY_DELIMITER,
+    BaseSessionValue,
+    K,
+    SessionStorageInterface,
+    V,
+)
 
 RedisSessionKey = str
 RedisSessionValue = BaseSessionValue
@@ -24,7 +28,9 @@ class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionV
     def session_storage_type(cls) -> SessionType:
         return SessionType.REDIS
 
-    def get(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> Optional[V]:
+    def get(
+        self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs
+    ) -> Optional[V]:
         key = self._make_session_key(auth_provider.name, thread_id, profile)
         raw_session: Any = self.client.get(key)
         if raw_session is None:
@@ -33,7 +39,9 @@ class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionV
         session = self._deserialize(raw_session)
         return session
 
-    def get_by_thread_id(self, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs) -> List[V]:
+    def get_by_thread_id(
+        self, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs
+    ) -> List[V]:
         if auth_provider is None:
             auth_provider_name = "*"
         else:
@@ -57,19 +65,24 @@ class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionV
 
         return session_list
 
-    def set(self, auth_provider: AuthProvider,
-            thread_id: str,
-            profile: str,
-            auth_scopes: List[str],
-            auth_resolve_uid: Optional[str],
-            auth_context: Optional[AuthContext],
-            is_auth_scope_universal: bool, **kwargs) -> V:
+    def set(
+        self,
+        auth_provider: AuthProvider,
+        thread_id: str,
+        profile: str,
+        auth_scopes: List[str],
+        auth_resolve_uid: Optional[str],
+        auth_context: Optional[AuthContext],
+        is_auth_scope_universal: bool,
+        **kwargs,
+    ) -> V:
         session = self._make_session(
             auth_provider_name=auth_provider.name,
             auth_scopes=auth_scopes,
             auth_context=auth_context,
             auth_resolve_uid=auth_resolve_uid,
-            is_auth_scope_universal=is_auth_scope_universal)
+            is_auth_scope_universal=is_auth_scope_universal,
+        )
 
         key = self._make_session_key(auth_provider.name, thread_id, profile)
 
@@ -77,7 +90,9 @@ class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionV
         self.client.set(key, raw_session)
         return session
 
-    def delete(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> bool:
+    def delete(
+        self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs
+    ) -> bool:
         key = self._make_session_key(auth_provider.name, thread_id, profile)
         return self.client.delete(key) == 1
 
@@ -92,17 +107,18 @@ class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionV
 
     @staticmethod
     def _make_session(
-            auth_provider_name: str,
-            auth_scopes: List[str],
-            auth_context: AuthContext,
-            auth_resolve_uid: str,
-            is_auth_scope_universal: bool) -> V:
+        auth_provider_name: str,
+        auth_scopes: List[str],
+        auth_context: AuthContext,
+        auth_resolve_uid: str,
+        is_auth_scope_universal: bool,
+    ) -> V:
         return RedisSessionValue(
             auth_provider_name=auth_provider_name,
             auth_scopes=set(auth_scopes),
             auth_context=auth_context,
             auth_resolve_uid=auth_resolve_uid,
-            scoped=is_auth_scope_universal
+            scoped=is_auth_scope_universal,
         )
 
     @staticmethod
@@ -116,13 +132,14 @@ class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionV
         if auth_scopes:
             auth_scopes = list(auth_scopes)
 
-        serialized = {"auth_context_value": auth_context_value,
-                      "auth_context_type": auth_context_type,
-                      "auth_provider_name": session.auth_provider_name,
-                      "scoped": session.scoped,
-                      "auth_scopes": auth_scopes,
-                      "auth_resolve_uid": session.auth_resolve_uid,
-                      }
+        serialized = {
+            "auth_context_value": auth_context_value,
+            "auth_context_type": auth_context_type,
+            "auth_provider_name": session.auth_provider_name,
+            "scoped": session.scoped,
+            "auth_scopes": auth_scopes,
+            "auth_resolve_uid": session.auth_resolve_uid,
+        }
 
         return json.dumps(serialized)
 
@@ -146,5 +163,5 @@ class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionV
             auth_scopes=auth_scopes,
             auth_resolve_uid=session_dict["auth_resolve_uid"],
             scoped=session_dict["scoped"],
-            auth_context=auth_context
+            auth_context=auth_context,
         )

hyperpocket/tool/__init__.py

@@ -1,14 +1,14 @@
 from hyperpocket.tool.function import from_dock, from_func, function_tool
-from hyperpocket.tool.tool import Tool, ToolRequest, ToolAuth
-from hyperpocket.tool.wasm.tool import from_local, from_git
+from hyperpocket.tool.tool import Tool, ToolAuth, ToolRequest
+from hyperpocket.tool.wasm.tool import from_git, from_local
 
 __all__ = [
-    'Tool',
-    'ToolAuth',
-    'ToolRequest',
-    'from_local',
-    'from_git',
-    'from_dock',
-    'from_func',
-    'function_tool'
+    "Tool",
+    "ToolAuth",
+    "ToolRequest",
+    "from_local",
+    "from_git",
+    "from_dock",
+    "from_func",
+    "function_tool",
 ]

hyperpocket/tool/function/__init__.py

@@ -4,8 +4,4 @@ from hyperpocket.tool.function.tool import FunctionTool
 from_func = FunctionTool.from_func
 from_dock = FunctionTool.from_dock
 
-__all__ = [
-    "from_func",
-    "from_dock",
-    "function_tool"
-]
+__all__ = ["from_func", "from_dock", "function_tool"]

hyperpocket/tool/function/annotation.py

@@ -1,12 +1,18 @@
-from typing import List, Callable, Optional
+from typing import Callable, List, Optional
 
 from hyperpocket.auth import AuthProvider
 from hyperpocket.tool.function.tool import FunctionTool
 from hyperpocket.tool.tool import ToolAuth
 
 
-def function_tool(func: Optional[Callable] = None, *, auth_provider: AuthProvider = None, scopes: List[str] = None,
-                  auth_handler: str = None, tool_vars: dict[str, str] = None):
+def function_tool(
+    func: Optional[Callable] = None,
+    *,
+    auth_provider: AuthProvider = None,
+    scopes: List[str] = None,
+    auth_handler: str = None,
+    tool_vars: dict[str, str] = None,
+):
     def decorator(inner_func: Callable):
         if not callable(inner_func):
             raise ValueError("FunctionTool can only be created from a callable")
@@ -15,14 +21,10 @@ def function_tool(func: Optional[Callable] = None, *, auth_provider: AuthProvide
             auth = ToolAuth(
                 auth_provider=auth_provider,
                 scopes=scopes if scopes else [],
-                auth_handler=auth_handler
+                auth_handler=auth_handler,
             )
 
-        return FunctionTool.from_func(
-            func=inner_func,
-            auth=auth,
-            tool_vars=tool_vars
-        )
+        return FunctionTool.from_func(func=inner_func, auth=auth, tool_vars=tool_vars)
 
     if func is not None:
         return decorator(func)

hyperpocket/tool/function/tool.py

@@ -1,8 +1,7 @@
 import asyncio
 import copy
 import inspect
-from typing import Any, Coroutine
-from typing import Callable, Optional
+from typing import Any, Callable, Coroutine, Optional
 
 from pydantic import BaseModel
 
@@ -15,6 +14,7 @@ class FunctionTool(Tool):
     """
     FunctionTool is Tool executing local python method.
     """
+
     func: Optional[Callable[..., str]]
     afunc: Optional[Callable[..., Coroutine[Any, Any, str]]]
 
@@ -90,14 +90,14 @@ class FunctionTool(Tool):
     @classmethod
     def from_func(
         cls,
-        func: Callable | 'FunctionTool',
-        afunc: Callable[..., Coroutine[Any, Any, str]] | 'FunctionTool' = None,
+        func: Callable | "FunctionTool",
+        afunc: Callable[..., Coroutine[Any, Any, str]] | "FunctionTool" = None,
         auth: Optional[ToolAuth] = None,
         tool_vars: dict[str, str] = None,
     ) -> "FunctionTool":
         if tool_vars is None:
             tool_vars = dict()
-            
+
         if isinstance(func, FunctionTool):
             if tool_vars is not None:
                 func.override_tool_variables(tool_vars)
@@ -108,7 +108,7 @@ class FunctionTool(Tool):
             return afunc
         elif not callable(func) and not callable(afunc):
             raise ValueError("FunctionTool can only be created from a callable")
-        
+
         model = function_to_model(func)
         argument_json_schema = flatten_json_schema(model.model_json_schema())
 
@@ -119,9 +119,9 @@ class FunctionTool(Tool):
             description=func.__doc__ if func.__doc__ is not None else "",
             argument_json_schema=argument_json_schema,
             auth=auth,
-            default_tool_vars=tool_vars
+            default_tool_vars=tool_vars,
         )
-    
+
     @classmethod
     def from_dock(
         cls,
@@ -138,29 +138,39 @@ class FunctionTool(Tool):
                 model = function_to_model(func)
             argument_json_schema = flatten_json_schema(model.model_json_schema())
             if not callable(func):
-                raise ValueError(f"Dock element should be a list of functions, but found {func}")
+                raise ValueError(
+                    f"Dock element should be a list of functions, but found {func}"
+                )
             is_coroutine = inspect.iscoroutinefunction(func)
             auth = None
             if func.__dict__.get("__auth__") is not None:
                 auth = ToolAuth(**func.__dict__["__auth__"])
             if is_coroutine:
-                tools.append(cls(
-                    func=None,
-                    afunc=func,
-                    name=func.__name__,
-                    description=func.__doc__,
-                    argument_json_schema=argument_json_schema,
-                    auth=auth,
-                    default_tool_vars=(tool_vars | func.__dict__.get("__vars__", {})),
-                ))
+                tools.append(
+                    cls(
+                        func=None,
+                        afunc=func,
+                        name=func.__name__,
+                        description=func.__doc__,
+                        argument_json_schema=argument_json_schema,
+                        auth=auth,
+                        default_tool_vars=(
+                            tool_vars | func.__dict__.get("__vars__", {})
+                        ),
+                    )
+                )
             else:
-                tools.append(cls(
-                    func=func,
-                    afunc=None,
-                    name=func.__name__,
-                    description=func.__doc__,
-                    argument_json_schema=argument_json_schema,
-                    auth=auth,
-                    default_tool_vars=(tool_vars | func.__dict__.get("__vars__", {})),
-                ))
+                tools.append(
+                    cls(
+                        func=func,
+                        afunc=None,
+                        name=func.__name__,
+                        description=func.__doc__,
+                        argument_json_schema=argument_json_schema,
+                        auth=auth,
+                        default_tool_vars=(
+                            tool_vars | func.__dict__.get("__vars__", {})
+                        ),
+                    )
+                )
         return tools

hyperpocket/tool/tool.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Optional, Type, Callable
+from typing import Callable, Optional, Type
 
 from pydantic import BaseModel, Field
 
@@ -13,23 +13,29 @@ class ToolAuth(BaseModel):
     """
     ToolAuth is an object that represents the authentication information required to invoke a tool
     """
+
     scopes: list[str] = Field(
         default=None,
         description="Indicates which authentication provider’s credentials are required to invoke the tool. "
-                    "If auth_provider is not specified, the tool is considered to require no authentication.")
+        "If auth_provider is not specified, the tool is considered to require no authentication.",
+    )
     auth_provider: Optional[AuthProvider] = Field(
         default=None,
         description="Specifies which authentication handler should be used when invoking the tool. "
-                    "If auth_handler is not specified, the default handler of the authentication provider will be used.")
+        "If auth_handler is not specified, the default handler of the authentication provider will be used.",
+    )
     auth_handler: Optional[str] = Field(
         default=None,
         description="Indicates the authentication scopes required to invoke the tool. "
-                    "If authentication is not performed or the authentication handler is non-scoped, the value should be None.")
+        "If authentication is not performed or the authentication handler is non-scoped, the value should be None.",
+    )
 
 
 class ToolRequest(abc.ABC):
     postprocessings: Optional[list[Callable]] = None
-    overridden_tool_vars: dict[str, str] = Field(default_factory=dict, description="overridden tool variables")
+    overridden_tool_vars: dict[str, str] = Field(
+        default_factory=dict, description="overridden tool variables"
+    )
 
     @abc.abstractmethod
     def __str__(self):
@@ -52,7 +58,7 @@ class ToolRequest(abc.ABC):
             self.postprocessings.extend(postprocessings)
         return self
 
-    def override_tool_variables(self, override_vars: dict[str, str]) -> 'ToolRequest':
+    def override_tool_variables(self, override_vars: dict[str, str]) -> "ToolRequest":
         self.overridden_tool_vars = override_vars
         return self
 
@@ -61,14 +67,24 @@ class Tool(BaseModel, abc.ABC):
     """
     Pocket Tool Interface
     """
+
     name: str = Field(description="tool name")
     description: str = Field(description="tool description")
-    argument_json_schema: Optional[dict] = Field(default=None, description="tool argument json schema")
-    auth: Optional[ToolAuth] = Field(default=None, description="authentication information to invoke tool")
-    postprocessings: Optional[list[Callable]] = Field(default=None,
-                                                      description="postprocessing functions after tool is invoked")
-    default_tool_vars: dict[str, str] = Field(default_factory=dict, description="default tool variables")
-    overridden_tool_vars: dict[str, str] = Field(default_factory=dict, description="overridden tool variables")
+    argument_json_schema: Optional[dict] = Field(
+        default=None, description="tool argument json schema"
+    )
+    auth: Optional[ToolAuth] = Field(
+        default=None, description="authentication information to invoke tool"
+    )
+    postprocessings: Optional[list[Callable]] = Field(
+        default=None, description="postprocessing functions after tool is invoked"
+    )
+    default_tool_vars: dict[str, str] = Field(
+        default_factory=dict, description="default tool variables"
+    )
+    overridden_tool_vars: dict[str, str] = Field(
+        default_factory=dict, description="overridden tool variables"
+    )
     use_profile: bool = False
 
     @abc.abstractmethod
@@ -89,7 +105,9 @@ class Tool(BaseModel, abc.ABC):
         Returns a schema_model that wraps the existing argument_json_schema
         to include profile and thread_id as arguments when the tool is invoked
         """
-        return self._get_schema_model(self.name, self.argument_json_schema, use_profile=use_profile)
+        return self._get_schema_model(
+            self.name, self.argument_json_schema, use_profile=use_profile
+        )
 
     def get_description(self, use_profile: bool = False) -> str:
         if use_profile:
@@ -97,7 +115,7 @@ class Tool(BaseModel, abc.ABC):
         else:
             return self.description
 
-    def override_tool_variables(self, override_vars: dict[str, str]) -> 'Tool':
+    def override_tool_variables(self, override_vars: dict[str, str]) -> "Tool":
         self.overridden_tool_vars = override_vars
         return self
 
@@ -106,50 +124,55 @@ class Tool(BaseModel, abc.ABC):
         return self.default_tool_vars | self.overridden_tool_vars
 
     @classmethod
-    def from_tool_request(cls, tool_req: ToolRequest, **kwargs) -> 'Tool':
+    def from_tool_request(cls, tool_req: ToolRequest, **kwargs) -> "Tool":
         from hyperpocket.tool.wasm.tool import WasmTool, WasmToolRequest
+
         if isinstance(tool_req, WasmToolRequest):
             return WasmTool.from_tool_request(tool_req, **kwargs)
-        raise ValueError('Unknown tool request type')
+        raise ValueError("Unknown tool request type")
 
     @classmethod
-    def _get_schema_model(cls, name: str, json_schema: Optional[dict], use_profile: bool) -> Optional[Type[BaseModel]]:
+    def _get_schema_model(
+        cls, name: str, json_schema: Optional[dict], use_profile: bool
+    ) -> Optional[Type[BaseModel]]:
         try:
             if not json_schema:
                 pocket_logger.info(f"{name} tool's json_schema is none.")
                 return None
-            if 'description' not in json_schema:
-                json_schema['description'] = 'The argument of the tool.'
+            if "description" not in json_schema:
+                json_schema["description"] = "The argument of the tool."
 
             if use_profile:
                 json_schema = {
-                    'title': name,
-                    'type': 'object',
-                    'properties': {
-                        'thread_id': {
-                            'type': 'string',
-                            'default': 'default',
-                            'description': 'The ID of the chat thread where the tool is invoked. Omitted when unknown.',
+                    "title": name,
+                    "type": "object",
+                    "properties": {
+                        "thread_id": {
+                            "type": "string",
+                            "default": "default",
+                            "description": "The ID of the chat thread where the tool is invoked. Omitted when unknown.",
                         },
-                        'profile': {
-                            'type': 'string',
-                            'default': 'default',
-                            'description': '''The profile of the user invoking the tool. Inferred from user's messages.
+                        "profile": {
+                            "type": "string",
+                            "default": "default",
+                            "description": """The profile of the user invoking the tool. Inferred from user's messages.
                             Users can request tools to be invoked in specific personas, which is called a profile.
                             If the user's profile name can be inferred from the query, pass it as a string in the 'profile'
-                            JSON property. Omitted when unknown.''',
+                            JSON property. Omitted when unknown.""",
                         },
-                        'body': json_schema
+                        "body": json_schema,
                     },
-                    'required': [
-                        'body',
-                    ]
+                    "required": [
+                        "body",
+                    ],
                 }
 
             model = json_schema_to_model(json_schema, name)
             return model
         except Exception as e:
-            pocket_logger.warning(f"failed to get tool({name}) schema model. error : {e}")
+            pocket_logger.warning(
+                f"failed to get tool({name}) schema model. error : {e}"
+            )
             pass
 
     def with_postprocessing(self, postprocessing: Callable):

hyperpocket/tool/wasm/__init__.py

@@ -1,3 +1,3 @@
 from hyperpocket.tool.wasm.tool import WasmTool
 
-__all__ = ["WasmTool"]
+__all__ = ["WasmTool"]

hyperpocket/tool/wasm/browser.py

@@ -1,11 +1,16 @@
 import asyncio
-import os
 
-from playwright.async_api import async_playwright, Page, Playwright, BrowserContext, Route
+from playwright.async_api import (
+    BrowserContext,
+    Page,
+    Playwright,
+    Route,
+    async_playwright,
+)
 
 
 class InvokerBrowser(object):
-    _instance: 'InvokerBrowser' = None
+    _instance: "InvokerBrowser" = None
     _lock = asyncio.Lock()
     playwright: Playwright
     browser_context: BrowserContext
@@ -18,9 +23,9 @@ class InvokerBrowser(object):
         self.browser_context = await self.playwright.chromium.launch_persistent_context(
             headless=True,
             args=[
-                '--disable-web-security=True',
+                "--disable-web-security=True",
             ],
-            user_data_dir='/tmp/chrome_dev_user',
+            user_data_dir="/tmp/chrome_dev_user",
         )
 
     @classmethod
@@ -44,13 +49,13 @@ class InvokerBrowser(object):
                 body=body,
                 headers={
                     **response.headers,
-                    'Cross-Origin-Opener-Policy': 'same-origin',
-                    'Cross-Origin-Embedder-Policy': 'require-corp',
-                    'Cross-Origin-Resource-Policy': 'cross-origin',
-                }
+                    "Cross-Origin-Opener-Policy": "same-origin",
+                    "Cross-Origin-Embedder-Policy": "require-corp",
+                    "Cross-Origin-Resource-Policy": "cross-origin",
+                },
             )
 
-        await page.route('**/*', _hijack_route)
+        await page.route("**/*", _hijack_route)
         return page
 
     async def teardown(self):

hyperpocket/tool/wasm/invoker.py

@@ -7,34 +7,34 @@ from urllib.parse import urljoin
 from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
 from hyperpocket.tool.wasm.browser import InvokerBrowser
-from hyperpocket.tool.wasm.script import ScriptRuntime, ScriptStore, Script
+from hyperpocket.tool.wasm.script import Script, ScriptRuntime, ScriptStore
 from hyperpocket.tool.wasm.templates import render
 
 
 class WasmInvoker(object):
-    def invoke(self,
-               tool_path: str,
-               runtime: ScriptRuntime,
-               body: Any,
-               envs: dict,
-               **kwargs) -> str:
+    def invoke(
+        self, tool_path: str, runtime: ScriptRuntime, body: Any, envs: dict, **kwargs
+    ) -> str:
         loop = asyncio.get_running_loop()
-        return loop.run_until_complete(self.ainvoke(tool_path, runtime, body, envs, **kwargs))
+        return loop.run_until_complete(
+            self.ainvoke(tool_path, runtime, body, envs, **kwargs)
+        )
 
-    async def ainvoke(self,
-                      tool_path: str,
-                      runtime: ScriptRuntime,
-                      body: Any,
-                      envs: dict,
-                      **kwargs) -> str:
+    async def ainvoke(
+        self, tool_path: str, runtime: ScriptRuntime, body: Any, envs: dict, **kwargs
+    ) -> str:
         uid = str(uuid.uuid4())
         html = render(runtime.value, uid, envs, json.dumps(body))
-        script = Script(id=uid, tool_path=tool_path, rendered_html=html, runtime=runtime)
+        script = Script(
+            id=uid, tool_path=tool_path, rendered_html=html, runtime=runtime
+        )
         ScriptStore.add_script(script=script)
         future_data = FutureStore.create_future(uid=uid)
         browser = await InvokerBrowser.get_instance()
         page = await browser.new_page()
-        url = urljoin(config.internal_base_url + '/', f'tools/wasm/scripts/{uid}/browse')
+        url = urljoin(
+            config().internal_base_url + "/", f"tools/wasm/scripts/{uid}/browse"
+        )
         await page.goto(url)
         stdout = await future_data.future
         await page.close()