tongflow 0.2.2__tar.gz → 0.2.4__tar.gz

{tongflow-0.2.2/tongflow.egg-info → tongflow-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tongflow
-Version: 0.2.2
+Version: 0.2.4
 Summary: Python SDK for TongFlow — author plugins and run multi-modal GenAI workflows
 Author: TongFlow contributors
 License-Expression: AGPL-3.0-only

{tongflow-0.2.2 → tongflow-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tongflow"
-version = "0.2.2"
+version = "0.2.4"
 description = "Python SDK for TongFlow — author plugins and run multi-modal GenAI workflows"
 readme = "README.md"
 requires-python = ">=3.10"

tongflow-0.2.4/tests/test_http_store.py

@@ -0,0 +1,76 @@
+"""HttpStore round-trip against a minimal in-process HTTP sink."""
+
+from __future__ import annotations
+
+import json
+import threading
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from tongflow.engine.store import HttpStore
+
+TOKEN = "test-token"
+
+
+class _Sink(BaseHTTPRequestHandler):
+    blobs: dict[str, bytes] = {}
+    counter = 0
+
+    def _authed(self) -> bool:
+        return self.headers.get("Authorization") == f"Bearer {TOKEN}"
+
+    def do_POST(self):  # noqa: N802
+        if not self._authed():
+            self.send_error(401)
+            return
+        qs = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
+        ext = (qs.get("ext") or ["bin"])[0]
+        length = int(self.headers.get("Content-Length", "0"))
+        data = self.rfile.read(length)
+        _Sink.counter += 1
+        file_key = f"tasks/t1/{_Sink.counter}.{ext}"
+        _Sink.blobs[file_key] = data
+        body = json.dumps({"file_key": file_key}).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):  # noqa: N802
+        if not self._authed():
+            self.send_error(401)
+            return
+        qs = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
+        key = (qs.get("file_key") or [""])[0]
+        blob = _Sink.blobs.get(key)
+        if blob is None:
+            self.send_error(404)
+            return
+        self.send_response(200)
+        self.send_header("Content-Type", "application/octet-stream")
+        self.end_headers()
+        self.wfile.write(blob)
+
+    def log_message(self, *args):  # silence
+        pass
+
+
+def test_http_store_roundtrip():
+    server = HTTPServer(("127.0.0.1", 0), _Sink)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        endpoint = f"http://127.0.0.1:{server.server_address[1]}/assets"
+        store = HttpStore(endpoint, TOKEN)
+
+        ref = store.put(b"hello-bytes", mime="image/png", ext="png")
+        assert ref["file_key"].endswith(".png")
+        assert ref["mime"] == "image/png"
+
+        assert store.get(ref["file_key"]) == b"hello-bytes"
+        assert store.get("tasks/does-not-exist.png") is None
+        # URL-ish refs skip the sink entirely
+        assert store.get("https://example.com/x.png") is None
+        assert store.get("mem://abc") is None
+    finally:
+        server.shutdown()

{tongflow-0.2.2 → tongflow-0.2.4}/tongflow/__init__.py

@@ -11,6 +11,6 @@ from .deploy_marker import deploy
 from .engine import run_workflow
 from .progress import progress
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"
 
 __all__ = ["deploy", "progress", "run_workflow"]

{tongflow-0.2.2 → tongflow-0.2.4}/tongflow/engine/__main__.py

@@ -9,7 +9,8 @@ Request shape::
     {"workflow": <executable workflow dict>,
      "inputs": {<name>: ...},
      "options": {"plugins_dir", "data_dir", "out_dir", "abi_path",
-                 "file_key_base", "auto_install", "org", "task_id"}}
+                 "file_key_base", "inline_outputs", "asset_endpoint",
+                 "asset_token", "auto_install", "org", "task_id"}}
 
 The TongFlow desktop app uses this to delegate workflow execution to the SDK
 engine (one execution core) while keeping its own DB / SSE / abort shell. The
@@ -59,6 +60,8 @@ def main() -> int:
             abi_path=opts.get("abi_path"),
             file_key_base=opts.get("file_key_base"),
             inline_outputs=bool(opts.get("inline_outputs", True)),
+            asset_endpoint=opts.get("asset_endpoint"),
+            asset_token=opts.get("asset_token"),
             auto_install=bool(opts.get("auto_install", True)),
             org=opts.get("org") or "https://github.com/tong-io",
             plugin_git_urls=opts.get("plugin_git_urls"),

{tongflow-0.2.2 → tongflow-0.2.4}/tongflow/engine/runner.py

@@ -37,7 +37,7 @@ from .plugins import (
     prepare_python_env,
     scan_manifest,
 )
-from .store import AssetStore, DiskStore, MemoryStore
+from .store import AssetStore, DiskStore, HttpStore, MemoryStore
 
 EventCb = Callable[[dict[str, Any]], None]
 
@@ -166,6 +166,8 @@ def run_workflow(
     abi_path: Optional[Union[str, Path]] = None,
     file_key_base: Optional[Union[str, Path]] = None,
     inline_outputs: bool = True,
+    asset_endpoint: Optional[str] = None,
+    asset_token: Optional[str] = None,
     auto_install: bool = True,
     org: str = DEFAULT_ORG,
     plugin_git_urls: Optional[dict[str, str]] = None,
@@ -191,6 +193,11 @@ def run_workflow(
             returned as ``{bytesBase64, mime?, filename?}`` — zero files written
             (besides the required plugin clone / venv). When False, outputs are
             written to ``out_dir`` and returned as ``file_key`` paths.
+        asset_endpoint / asset_token: host-managed asset store (loopback HTTP
+            sink, see :class:`~tongflow.engine.store.HttpStore`). When set it
+            overrides ``inline_outputs``: outputs are POSTed to the host and
+            input ``file_key`` refs are fetched from it — the engine touches
+            no asset files on disk.
         auto_install: clone missing plugins and provision a shared venv.
         org / plugin_git_urls: where to clone official / custom plugins from.
         on_progress: optional callback receiving progress event dicts.
@@ -212,9 +219,13 @@ def run_workflow(
     # Output store: in-memory (inline, zero disk) or on-disk (file_key paths,
     # used by the desktop delegation so the canvas reads via /api/uploads).
     out_path = Path(out_dir).resolve() if out_dir else (data_dir / "engine-out")
-    store: AssetStore = (
-        MemoryStore() if inline_outputs else DiskStore(out_path, fk_base)
-    )
+    store: AssetStore
+    if asset_endpoint:
+        store = HttpStore(asset_endpoint, asset_token)
+    elif inline_outputs:
+        store = MemoryStore()
+    else:
+        store = DiskStore(out_path, fk_base)
 
     def emit(event: dict[str, Any]) -> None:
         if on_progress is not None:

{tongflow-0.2.2 → tongflow-0.2.4}/tongflow/engine/store.py

@@ -7,6 +7,11 @@
   are written to ``out_dir`` and the ``file_key`` is a path (relative to
   ``file_key_base`` when set, else absolute), matching the server's
   ``saveFile`` contract so the canvas can read them via ``/api/uploads``.
+- :class:`HttpStore` (``asset_endpoint`` option): the embedding host owns
+  file storage (e.g. a cloud backend writing to object storage). ``put``
+  POSTs raw bytes over loopback HTTP and gets back the host-assigned
+  ``file_key``; ``get`` fetches bytes for any ``file_key`` the host knows.
+  The engine never sees storage credentials.
 
 ``get`` returns the bytes for a key the store owns, else ``None`` (so the
 filesystem/URL resolver in :mod:`assets` handles plain file_keys / URLs).
@@ -14,7 +19,11 @@ filesystem/URL resolver in :mod:`assets` handles plain file_keys / URLs).
 
 from __future__ import annotations
 
+import json
 import os
+import urllib.error
+import urllib.parse
+import urllib.request
 import uuid
 from pathlib import Path
 from typing import Optional, Protocol
@@ -94,3 +103,76 @@ class DiskStore:
     def get(self, file_key: str) -> Optional[bytes]:
         # Disk file_keys are resolved by the filesystem/URL resolver in assets.
         return None
+
+
+class HttpStore:
+    """Host-managed asset store over (loopback) HTTP.
+
+    The host exposes a single endpoint:
+
+    - ``POST <endpoint>?ext=..&mime=..&filename=..`` with raw bytes as the
+      body -> ``{"file_key": "..."}``
+    - ``GET <endpoint>?file_key=..`` -> raw bytes (404 when unknown)
+
+    Authentication is a Bearer token minted by the host per engine run.
+    """
+
+    # Refs the host sink cannot serve; skip the round trip and let the
+    # URL/data resolver in assets handle them.
+    _SKIP_PREFIXES = ("http://", "https://", "data:", "mem://")
+
+    def __init__(self, endpoint: str, token: Optional[str] = None) -> None:
+        self.endpoint = endpoint
+        self.token = token
+
+    def _headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self.token}"} if self.token else {}
+
+    def put(
+        self,
+        data: bytes,
+        *,
+        mime: Optional[str] = None,
+        filename: Optional[str] = None,
+        ext: str = "bin",
+    ) -> dict[str, str]:
+        params = {"ext": ext.lstrip(".") or "bin"}
+        if mime:
+            params["mime"] = mime
+        if filename:
+            params["filename"] = filename
+        req = urllib.request.Request(
+            f"{self.endpoint}?{urllib.parse.urlencode(params)}",
+            data=bytes(data),
+            method="POST",
+            headers={
+                "Content-Type": "application/octet-stream",
+                **self._headers(),
+            },
+        )
+        with urllib.request.urlopen(req) as resp:
+            payload = json.loads(resp.read().decode("utf-8"))
+        file_key = payload.get("file_key")
+        if not isinstance(file_key, str) or not file_key:
+            raise RuntimeError("asset endpoint returned no file_key")
+        out: dict[str, str] = {"file_key": file_key}
+        if mime:
+            out["mime"] = mime
+        if filename:
+            out["filename"] = filename
+        return out
+
+    def get(self, file_key: str) -> Optional[bytes]:
+        if file_key.startswith(self._SKIP_PREFIXES):
+            return None
+        req = urllib.request.Request(
+            f"{self.endpoint}?{urllib.parse.urlencode({'file_key': file_key})}",
+            headers=self._headers(),
+        )
+        try:
+            with urllib.request.urlopen(req) as resp:
+                return resp.read()
+        except urllib.error.HTTPError as e:
+            if e.code == 404:
+                return None
+            raise

{tongflow-0.2.2 → tongflow-0.2.4/tongflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tongflow
-Version: 0.2.2
+Version: 0.2.4
 Summary: Python SDK for TongFlow — author plugins and run multi-modal GenAI workflows
 Author: TongFlow contributors
 License-Expression: AGPL-3.0-only

{tongflow-0.2.2 → tongflow-0.2.4}/tongflow.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 tests/test_engine.py
+tests/test_http_store.py
 tests/test_protocol.py
 tests/test_scan.py
 tests/test_slots.py