hyperpocket 0.3.6__py3-none-any.whl → 0.4.0__py3-none-any.whl

hyperpocket/tool/wasm/README.md

@@ -1,166 +0,0 @@
-# Wasm(WebAssembly)
-
----
-
-## How To Use
-
-### plain url
-
-load the tool by providing a GitHub URL
-
-```python
-from hyperpocket import Pocket
-
-pocket = Pocket(tools=[
-    'https://github.com/your-organization/your-repository/tree/main',
-])
-```
-
-- in this case, read tool code from `main` branch by default
-
-### from_git
-
-- using `from_git`, you can specify branch and tool code path
-
-```python
-from hyperpocket import Pocket
-from hyperpocket.tool import from_git
-
-pocket = Pocket(tools=[
-    from_git("https://github.com/your-organization/your-repository", "branch-name", "your/tool/code/path"),
-])
-```
-
-### from_local
-
-- using `from_local`, you can load a tool by specifying a local path
-
-```python
-from hyperpocket import Pocket
-from hyperpocket.tool import from_local
-
-pocket = Pocket(tools=[
-    from_local("your/local/tool/code/path")
-])
-```
-
-## WasmToolRequest
-
-The class to initiate WasmTool
-
-WasmToolRequest offer those build method:
-
-- `from_local`
-- `from_git`
-
-Each `WasmToolRequest` has it's own `Lock` object
-
-Those `Lock` object is managed by `Lockfile` in the `Pocket` class
-
-```mermaid
-classDiagram
-    class WasmToolRequest {
-        +Lock lock
-        + from_git()
-        + from_local()
-    }
-
-    class Lock{
-        +key()
-        +sync()
-    }
-
-    class GitLock{
-        +key()
-        +sync()
-    }
-
-    class LocalLock{
-        +key()
-        +sync()
-    }
-
-    class Lockfile {
-        +dict[tuple,Lock] locks
-
-        + add_lock()
-        + get_lock()
-        + sync()
-        + write()
-    }
-
-    ToolRequest <|.. WasmToolRequest : Implementation
-    Lock o-- WasmToolRequest : 1..1
-    Lock <|.. GitLock : Implementation
-    Lock <|.. LocalLock : Implementation
-    Lock o-- Lockfile : n..1
-    Lockfile o-- Pocket : 1..1
-```
-
-### Inject tool variables
-
-If the user specifies [tool_vars] in the `config.toml` of the tool's repository, which is allowed to be injected dynamically when the user develops an agent, it can be injected through the following steps.
-
-```toml
-# config.toml of a tool
-
-[tool_vars]
-config1 = "config1"
-config2 = "config2"
-```
-
-1. Injecting tool_vars when importing tool in code.
-
-```python
-from_git('https://github.com/your-organization/your-repository/tree/main',tool_vars = {
-    "config1": "modified_config1"
-})
-```
-
-2. Injecting tool_vars by settings.toml
-   Hyperpocket checks the `settings.toml` from the agent code directory.
-
-## WasmTool
-
-```python
-class WasmTool(Tool):
-    _invoker: WasmInvoker = None
-    pkg_lock: Lock = None
-    rel_path: str
-    runtime: ScriptRuntime = None
-    json_schema: Optional[dict] = None
-    readme: Optional[str] = None
-```
-
-- `_invoker`: A class for executing WASM.
-- `pkg_lock`: The lock class for the tool.
-- Used for determining the package path where the current WASM code is stored.
-- `rel_path`: The relative path to the location of the WASM code within the package.
-- `runtime`: The runtime language of the WASM code.
-- `json_schema`: The JSON schema for the WASM tool.
-- Information read from schema.json.
-- `readme`: The README information.
-
-## WasmInvoker
-
-A class for running actual WASM
-
-1. Combines runtime information, authentication details, and body content to render HTML.
-2. Stores the rendered HTML in memory.
-3. Launches a browser to execute the WASM.
-4. The browser sends a request to the server to retrieve the rendered HTML.
-5. Executes code specific to each runtime within the HTML and returns the result.
-
-```mermaid
-sequenceDiagram
-    participant WasmTool as WasmTool (Includes Server)
-    participant Browser as Browser (Executes WASM Runtime)
-
-
-    WasmTool->>WasmTool: Render HTML and Store in Memory
-    WasmTool->>Browser: Launch Browser
-    Browser->>WasmTool: Request Rendered HTML
-    WasmTool->>Browser: Provide Rendered HTML
-    Browser->>Browser: Execute Injected WASM Runtime Script
-    Browser->>WasmTool: Return Execution Result
-```

hyperpocket/tool/wasm/__init__.py

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

hyperpocket/tool/wasm/browser.py

@@ -1,63 +0,0 @@
-import asyncio
-
-from playwright.async_api import (
-    BrowserContext,
-    Page,
-    Playwright,
-    Route,
-    async_playwright,
-)
-
-
-class InvokerBrowser(object):
-    _instance: "InvokerBrowser" = None
-    _lock = asyncio.Lock()
-    playwright: Playwright
-    browser_context: BrowserContext
-
-    def __init__(self):
-        raise RuntimeError("Use InvokerBrowser.get_instance() instead")
-
-    async def _async_init(self):
-        self.playwright = await async_playwright().start()
-        self.browser_context = await self.playwright.chromium.launch_persistent_context(
-            headless=True,
-            args=[
-                "--disable-web-security=True",
-            ],
-            user_data_dir="/tmp/chrome_dev_user",
-        )
-
-    @classmethod
-    async def get_instance(cls):
-        if not cls._instance:
-            async with cls._lock:
-                if cls._instance is None:
-                    instance = cls.__new__(cls)
-                    await instance._async_init()
-                    cls._instance = instance
-        return cls._instance
-
-    async def new_page(self) -> Page:
-        page = await self.browser_context.new_page()
-
-        async def _hijack_route(route: Route):
-            response = await route.fetch()
-            body = await response.body()
-            await route.fulfill(
-                response=response,
-                body=body,
-                headers={
-                    **response.headers,
-                    "Cross-Origin-Opener-Policy": "same-origin",
-                    "Cross-Origin-Embedder-Policy": "require-corp",
-                    "Cross-Origin-Resource-Policy": "cross-origin",
-                },
-            )
-
-        await page.route("**/*", _hijack_route)
-        return page
-
-    async def teardown(self):
-        await self.browser_context.close()
-        await self.playwright.stop()

hyperpocket/tool/wasm/invoker.py

@@ -1,41 +0,0 @@
-import asyncio
-import json
-import uuid
-from typing import Any
-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 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:
-        loop = asyncio.get_running_loop()
-        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:
-        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
-        )
-        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"
-        )
-        await page.goto(url)
-        stdout = await future_data.future
-        await page.close()
-        return stdout

hyperpocket/tool/wasm/script.py

@@ -1,134 +0,0 @@
-import base64
-import enum
-import pathlib
-from typing import Optional
-
-import toml
-from pydantic import BaseModel
-
-from hyperpocket.config import pocket_logger
-
-
-class ScriptRuntime(enum.Enum):
-    Node = "node"
-    Python = "python"
-    Wasm = "wasm"
-
-
-_RuntimePackageFiles = {
-    ScriptRuntime.Node: ["dist/index.js"],
-    ScriptRuntime.Python: ["main.py", "requirements.txt"],
-    ScriptRuntime.Wasm: ["dist/index.wasm"],
-}
-
-
-class ScriptFileNodeContent(BaseModel):
-    contents: str
-
-
-class ScriptFileNode(BaseModel):
-    directory: Optional[dict[str, "ScriptFileNode"]] = None
-    file: Optional[ScriptFileNodeContent] = None
-
-    @classmethod
-    def create_file_tree(cls, path: str, contents: str) -> dict[str, "ScriptFileNode"]:
-        path_split = path.split("/")
-        if len(path_split) == 1:
-            return {
-                path_split[0]: ScriptFileNode(
-                    file=ScriptFileNodeContent(contents=contents)
-                )
-            }
-        node = cls.create_file_tree("/".join(path_split[1:]), contents)
-        return {path_split[0]: ScriptFileNode(directory=node)}
-
-    @staticmethod
-    def merge(
-        a: dict[str, "ScriptFileNode"], b: [str, "ScriptFileNode"]
-    ) -> dict[str, "ScriptFileNode"]:
-        for k, v in b.items():
-            if k in a:
-                if a[k].directory and v.directory:
-                    a[k].directory = ScriptFileNode.merge(a[k].directory, v.directory)
-                elif a[k].file and v.file:
-                    a[k].file = v.file
-            else:
-                a[k] = v
-        return a
-
-
-class Script(BaseModel):
-    id: str
-    tool_path: str
-    rendered_html: str
-    runtime: ScriptRuntime
-
-    def load_file_tree(self) -> dict[str, ScriptFileNode]:
-        relpaths = _RuntimePackageFiles[self.runtime]
-        file_tree = dict()
-        for p in relpaths:
-            filepath = pathlib.Path(self.tool_path) / p
-            with filepath.open("r") as f:
-                contents = f.read().encode("utf-8")
-                encoded_bytes = base64.b64encode(contents)
-                encoded_str = encoded_bytes.decode()
-                file_tree = ScriptFileNode.merge(
-                    file_tree, ScriptFileNode.create_file_tree(p, encoded_str)
-                )
-        return file_tree
-
-    @property
-    def package_name(self) -> Optional[str]:
-        if self.runtime != ScriptRuntime.Python:
-            return
-        pyproject = toml.load(pathlib.Path(self.tool_path) / "pyproject.toml")
-        if "project" in pyproject:
-            name = pyproject["project"]["name"]
-        if "tool" in pyproject and "poetry" in pyproject["tool"]:
-            name = pyproject["tool"]["poetry"]["name"]
-        if not name:
-            raise ValueError("Could not find package name")
-        return name.replace("-", "_")
-
-    @property
-    def entrypoint(self) -> str:
-        pocket_logger.info(self.tool_path)
-        if self.runtime == ScriptRuntime.Node:
-            return "dist/index.js"
-        elif self.runtime == ScriptRuntime.Wasm:
-            return "dist/main.wasm"
-        pyproject = toml.load(pathlib.Path(self.tool_path) / "pyproject.toml")
-        version = None
-        if "project" in pyproject:
-            version = pyproject["project"]["version"]
-        elif "tool" in pyproject and "poetry" in pyproject["tool"]:
-            version = pyproject["tool"]["poetry"]["version"]
-        else:
-            raise ValueError("Could not find package version")
-        wheel_name = f"{self.package_name}-{version}-py3-none-any.whl"
-        wheel_path = pathlib.Path(self.tool_path) / "dist" / wheel_name
-        if not wheel_path.exists():
-            raise ValueError(f"Wheel file {wheel_path} does not exist")
-        return wheel_name
-
-    def dist_file_path(self, file_name: str) -> str:
-        return str(pathlib.Path(self.tool_path) / "dist" / file_name)
-
-
-class _ScriptStore(object):
-    scripts: dict[str, Script] = {}
-
-    def __init__(self):
-        self.rendered_html = {}
-
-    def add_script(self, script: Script):
-        if script.id in self.scripts:
-            raise ValueError("Script id already exists")
-        self.scripts[script.id] = script
-
-    def get_script(self, script_id: str) -> Script:
-        # ValueError exception is intentional
-        return self.scripts[script_id]
-
-
-ScriptStore = _ScriptStore()

hyperpocket/tool/wasm/templates/__init__.py

@@ -1,35 +0,0 @@
-import base64
-import json
-
-from jinja2 import DictLoader, Environment
-
-from hyperpocket.tool.wasm.templates.node import node_template
-from hyperpocket.tool.wasm.templates.python import python_template
-
-TemplateEnvironments = Environment(
-    loader=DictLoader(
-        {
-            "python.html": python_template,
-            "node.html": node_template,
-        }
-    ),
-    autoescape=False,
-)
-
-
-def render(
-    language: str, script_id: str, env: dict[str, str], body: str, **kwargs
-) -> str:
-    env_json = json.dumps(env)
-    template = TemplateEnvironments.get_template(f"{language.lower()}.html")
-    body_bytes = body.encode("utf-8")
-    body_b64_bytes = base64.b64encode(body_bytes)
-    body_b64 = body_b64_bytes.decode("ascii")
-    return template.render(
-        **{
-            "SCRIPT_ID": script_id,
-            "ENV_JSON": env_json,
-            "BODY_JSON_B64": body_b64,
-        }
-        | kwargs
-    )

hyperpocket/tool/wasm/templates/node.py

@@ -1,87 +0,0 @@
-node_template = """
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>PyScript Offline</title>
-</head>
-<body>
-<script type="module">
-    function loadConfig() {
-        globalThis.toolConfigs = {
-            envs: `{{ ENV_JSON }}`,
-            body: `{{ BODY_JSON_B64 }}`,
-            scriptID: `{{ SCRIPT_ID }}`
-        }
-    }
-    import { WebContainer } from 'https://esm.run/@webcontainer/api@1.5.1';
-    function decodeContent(content) {
-        return Uint8Array.from(atob(content), c => c.charCodeAt(0));
-    }
-    function decodeFileTree(filetree) {
-        const decoded = {};
-        for (const [key, value] of Object.entries(filetree)) {
-            if (value.file) {
-                decoded[key] = {
-                    file: {
-                        contents: decodeContent(value.file.contents)
-                    }
-                }
-            } else if (value.directory) {
-                decoded[key] = {
-                    directory: decodeFileTree(value.directory)
-                }
-            } else if (value.symlink) {
-                decoded[key] = {
-                    symlink: value.symlink
-                }
-            }
-        }
-        return decoded;
-    }
-    async function main() {
-        loadConfig();
-        const b64FilesResp = await fetch(`/tools/wasm/scripts/${globalThis.toolConfigs.scriptID}/file_tree`);
-        const b64Files = await b64FilesResp.json();
-        const files = decodeFileTree(b64Files.tree);
-        const webcontainer = await WebContainer.boot();
-        
-        await webcontainer.mount(files)
-        const envs = JSON.parse(globalThis.toolConfigs.envs)
-        envs['DEPLOYED'] = 'true'
-        const runProcess = await webcontainer.spawn('node', ['dist/index.js'], {
-            output: true,
-            env: envs,
-        });
-        const stdin = runProcess.input.getWriter();
-        const decodedBytes = atob(globalThis.toolConfigs.body);
-        await (async () => {
-            await stdin.ready
-            await stdin.write(decodedBytes);
-        })()
-        let stdout = '';
-        runProcess.output.pipeTo(
-            new WritableStream({
-                write(chunk) {
-                    stdout += chunk;
-                }
-            })
-        )
-        await runProcess.exit;
-        if (stdout.startsWith(decodedBytes)) {
-            stdout = stdout.slice(decodedBytes);
-        }
-        await fetch(`/tools/wasm/scripts/${globalThis.toolConfigs.scriptID}/done`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ stdout })
-        });
-    }
-    main();
-</script>
-</body>
-</html>
-"""

hyperpocket/tool/wasm/templates/python.py

@@ -1,93 +0,0 @@
-python_template = """
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>PyScript Offline</title>
-    <script src="https://cdn.jsdelivr.net/pyodide/v0.26.4/full/pyodide.js"></script>
-</head>
-<body>
-<script type="module">
-    function loadConfig() {
-        globalThis.toolConfigs = {
-            envs: `{{ ENV_JSON }}`,
-            body: `{{ BODY_JSON_B64 }}`,
-            scriptID: `{{ SCRIPT_ID }}`
-        }
-    }
-    async function _main() {
-        // load the script configs
-        loadConfig();
-        
-        // get entrypoint wheel
-        const entrypointResp = await fetch(`/tools/wasm/scripts/${globalThis.toolConfigs.scriptID}/entrypoint`);
-        const { package_name: packageName, entrypoint } = await entrypointResp.json();
-        
-        // initialize pyodide
-        const pyodide = await loadPyodide({
-            env: JSON.parse(globalThis.toolConfigs.envs),
-        });
-        await pyodide.loadPackage("micropip");
-        await pyodide.loadPackage("ssl");
-        const micropip = pyodide.pyimport("micropip");
-        await micropip.install(entrypoint);
-        await micropip.install("pyodide-http")
-        
-        let emitted = false;
-        const decodedBytes = atob(globalThis.toolConfigs.body);
-        pyodide.setStdin({
-            stdin: () => {
-                if (emitted) {
-                    return null;
-                }
-                emitted = true;
-                return decodedBytes;
-            },
-            autoEOF: true,
-        })
-        let stdout = "";
-        let stderr = "";
-        pyodide.setStdout({
-            batched: (x) => { stdout += x; },
-        })
-        pyodide.setStderr({
-            batched: (x) => { stderr += x; },
-        })
-        await pyodide.runPythonAsync(`
-import pyodide_http
-pyodide_http.patch_all()
-
-import ${packageName}
-${packageName}.main()
-`);
-        console.log(stdout)
-        await fetch(`/tools/wasm/scripts/${globalThis.toolConfigs.scriptID}/done`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ stdout, stderr })
-        });
-    }
-    
-    async function main() {
-        try {
-            await _main();
-        } catch (e) {
-            console.error(e);
-            await fetch(`/tools/wasm/scripts/${globalThis.toolConfigs.scriptID}/done`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify({ error: e.message })
-            });
-        }
-    }
-    
-    main();
-</script>
-</body>
-</html>
-"""