away rebranding

Author: codeSamuraii

.github/workflows/integration.yml

@@ -24,7 +24,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: Install pyfuse + dev deps
+      - name: Install away + dev deps
         run: |
           pip install -e ".[redis,rabbitmq]"
           pip install pytest pytest-asyncio
@@ -80,7 +80,7 @@ jobs:
           python-version: "3.13"
 
       # --- Install --------------------------------------------------------
-      - name: Install pyfuse + backend extras
+      - name: Install away + backend extras
         run: |
           pip install -e ".[${{ matrix.backend.extras }}]"
           pip install pytest pytest-asyncio pytest-timeout
@@ -94,15 +94,15 @@ jobs:
       - name: Generate signing token
         if: matrix.signing
         run: |
-          TOKEN=$(python -c "from pyfuse.core.token import generate_token; print(generate_token())")
-          echo "PYFUSE_SIGNING_TOKEN=$TOKEN" >> "$GITHUB_ENV"
+          TOKEN=$(python -c "from away.core.token import generate_token; print(generate_token())")
+          echo "AWAY_SIGNING_TOKEN=$TOKEN" >> "$GITHUB_ENV"
 
       # --- Run e2e tests --------------------------------------------------
       - name: Run end-to-end tests
         env:
-          PYFUSE_TEST_BACKEND: ${{ matrix.backend.url }}
-          PYFUSE_TEST_SIGNING: ${{ matrix.signing && '1' || '0' }}
-          PYFUSE_TEST_SANDBOX: ${{ matrix.sandbox && '1' || '0' }}
+          AWAY_TEST_BACKEND: ${{ matrix.backend.url }}
+          AWAY_TEST_SIGNING: ${{ matrix.signing && '1' || '0' }}
+          AWAY_TEST_SANDBOX: ${{ matrix.sandbox && '1' || '0' }}
         run: pytest tests/test_e2e.py -x -v --timeout=120
 
       # --- Dump worker logs on failure ------------------------------------
@@ -111,7 +111,7 @@ jobs:
         run: |
           echo "=== Worker process logs ==="
           # Collected by the test fixtures via subprocess
-          cat /tmp/pyfuse-worker-*.log 2>/dev/null || echo "(no log files)"
+          cat /tmp/away-worker-*.log 2>/dev/null || echo "(no log files)"
 
   # -----------------------------------------------------------------------
   # Mypy type checking
@@ -124,10 +124,10 @@ jobs:
         with:
           python-version: "3.13"
 
-      - name: Install pyfuse + dev deps
+      - name: Install away + dev deps
         run: |
           pip install -e ".[redis,rabbitmq]"
           pip install mypy pytest pytest-asyncio
 
       - name: Run mypy
-        run: mypy pyfuse/
+        run: mypy away/

.gitignore

@@ -11,4 +11,6 @@ poetry.lock
 dist/
 build/
 .DS_Store
-.claudeignore
+.claudeignore
+node_modules/
+cloud_poc/frontend/dist/

README.md

@@ -1,4 +1,4 @@
-# pyfuse
+# away
 
 **Run any Python function on a remote worker — zero setup, zero deployment.**
 
@@ -7,21 +7,21 @@
 [![Typed](https://img.shields.io/badge/typing-strict%20mypy-blue)](https://mypy-lang.org/)
 [![Zero Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen)]()
 
-Add `@trace` to a function. pyfuse captures its source, dependencies, and imports automatically.
+Add `@trace` to a function. away captures its source, dependencies, and imports automatically.
 Workers reconstruct and execute everything from scratch — no shared filesystem, no deployment pipeline.
 Missing packages are installed on the fly.
 
 ## Quick start
 
 ```bash
-pip install pyfuse
+pip install away
 ```
 
 ```python
-import asyncio, math, pyfuse
-from pyfuse import trace
+import asyncio, math, away
+from away import trace
 
-pyfuse.connect("local://localhost:9748")
+away.connect("local://localhost:9748")
 
 def add(a, b):
     return a + b
@@ -39,19 +39,19 @@ asyncio.run(main())
 Only the entry point needs `@trace` — everything it calls is captured automatically.
 
 ```bash
-pyfuse worker --backend local://localhost:9748 --tmp   # start a worker
+away worker --backend local://localhost:9748 --tmp   # start a worker
 python my_script.py                                    # → 5.0
 ```
 
-For multi-machine, swap `local://` for `redis://`. That's it.
+For multi-machine, swap `local://` for `redis://` or an `https://` managed broker URL. That's it.
 
 ## Sandbox
 
 Run tasks inside Docker containers for isolation — transparent to clients:
 
 ```bash
-pyfuse sandbox setup                                      # build image (once)
-pyfuse worker --backend redis://localhost:6379 --sandbox  # run with isolation
+away sandbox setup                                      # build image (once)
+away worker --backend redis://localhost:6379 --sandbox  # run with isolation
 ```
 
 See [Sandbox](docs/SANDBOX.md) for configuration and management.
@@ -62,13 +62,13 @@ Pre-shared token or PIN-based pairing + HMAC-SHA256 — workers reject untrusted
 
 ```bash
 # Token-based (recommended for CI/CD)
-pyfuse token generate                                       # generate once
-export PYFUSE_SIGNING_TOKEN=<token>                         # set on client & worker
-pyfuse worker --backend redis://localhost:6379 --require-signing
+away token generate                                       # generate once
+export AWAY_SIGNING_TOKEN=<token>                         # set on client & worker
+away worker --backend redis://localhost:6379 --require-signing
 
 # PIN-based pairing (interactive)
-pyfuse worker --backend redis://localhost:6379 --pair       # displays a 6-digit PIN
-pyfuse pair --backend redis://localhost:6379                # on client: enter the PIN
+away worker --backend redis://localhost:6379 --pair       # displays a 6-digit PIN
+away pair --backend redis://localhost:6379                # on client: enter the PIN
 ```
 
 After setup, tasks are signed automatically. No client-side code changes. See [Signing & Pairing](docs/SIGNING.md) for details.
@@ -83,10 +83,10 @@ After setup, tasks are signed automatically. No client-side code changes. See [S
 | **Retry & timeout** | `@trace(timeout=30, retries=3)` with exponential backoff |
 | **Scheduling** | `.run_in(delay)`, `.run_at(datetime)`, `.run_every(freq)` with cancellation |
 | **Throttling** | `@trace(throttle=timedelta(hours=24)/50)` — rate-limit executions |
-| **Progress & cancellation** | `pyfuse.progress(3, 10)` inside tasks; `await future.cancel()` on client |
+| **Progress & cancellation** | `away.progress(3, 10)` inside tasks; `await future.cancel()` on client |
 | **Heartbeat & stall detection** | Workers heartbeat; clients raise `TaskStalled` on silence |
 | **Content-hash caching** | Same code = cache hit, regardless of client |
-| **Pluggable backends** | `local://` (same-machine TCP), `redis://`, `amqp://` (RabbitMQ) |
+| **Pluggable backends** | `local://` (same-machine TCP), `redis://`, `amqp://` (RabbitMQ), `http://`/`https://` (hosted broker API) |
 | **Docker sandbox** | Container isolation, transparent to clients |
 | **Signed execution** | Pre-shared token or PIN pairing + HMAC-SHA256 task authentication |
 | **Graceful shutdown** | Ctrl+C drains in-flight tasks; second Ctrl+C force-quits |
@@ -99,12 +99,13 @@ After setup, tasks are signed automatically. No client-side code changes. See [S
 | **[Technical Overview](docs/TECHNICAL_OVERVIEW.md)** | Architecture, serialization format, internals |
 | **[Signing & Pairing](docs/SIGNING.md)** | Cryptographic task signing protocol |
 | **[Sandbox](docs/SANDBOX.md)** | Docker container isolation |
+| **[Cloud POC](docs/CLOUD_POC.md)** | Local FastAPI + MongoDB + Kubernetes + React prototype for managed hosting |
 
 ## Examples
 
 ```bash
-pyfuse worker --backend local://localhost:9748 --tmp
-pyfuse run examples/remote_execution.py
+away worker --backend local://localhost:9748 --tmp
+away run examples/remote_execution.py
 ```
 
 [`remote_execution.py`](examples/remote_execution.py) · [`async_execution.py`](examples/async_execution.py) · [`package_installation.py`](examples/package_installation.py) · [`progress_reporting.py`](examples/progress_reporting.py) · [`cancellation.py`](examples/cancellation.py) · [`scheduling.py`](examples/scheduling.py) · [`throttling_and_retry.py`](examples/throttling_and_retry.py) · [`large_module.py`](examples/large_module.py)

pyfuse/__init__.py away/__init__.pypyfuse/__init__.py renamed to away/__init__.py

@@ -1,11 +1,11 @@
-"""Public API for pyfuse — remote Python function execution."""
+"""Public API for away — remote Python function execution."""
 
 import inspect
 from typing import Any
 from collections.abc import Callable
 
-from pyfuse.core.task import Task
-from pyfuse.core.errors import (
+from away.core.task import Task
+from away.core.errors import (
     Error,
     RemoteError,
     TaskStalled,
@@ -17,11 +17,11 @@
     ThrottleError,
     WorkerOnlyError,
 )
-from pyfuse.core.models import ImportInfo, FunctionNode
-from pyfuse.graph.graph import Graph
-from pyfuse.graph.store import Store, MergeResult
-from pyfuse.worker.deps import install_package_as, worker_only_import
-from pyfuse.core.pairing import (
+from away.core.models import ImportInfo, FunctionNode
+from away.graph.graph import Graph
+from away.graph.store import Store, MergeResult
+from away.worker.deps import install_package_as, worker_only_import
+from away.core.pairing import (
     PairingResult,
     generate_pin,
     load_shared_key,
@@ -30,31 +30,31 @@
     initiate_pairing,
     respond_to_pairing,
 )
-from pyfuse.core.signing import (
+from away.core.signing import (
     sign_json,
     derive_key,
     verify_signature,
     compute_signature,
     verify_and_load_json,
 )
-from pyfuse.core.token import (
+from away.core.token import (
     load_token,
     save_token,
     clear_token,
     generate_token,
     resolve_signing_key,
 )
-from pyfuse.core.version import _VERSION
-from pyfuse.core.progress import ProgressInfo
-from pyfuse.core.progress import progress as progress
-from pyfuse.worker.remote import serve, connect, disconnect
-from pyfuse.worker.result import Result, ResultEnvelope
-from pyfuse.worker.worker import Worker
-from pyfuse.worker.worker import execute as execute
-from pyfuse.worker.sandbox import DockerSandbox
-from pyfuse.worker.schedule import ScheduleHandle
-from pyfuse.graph.decorator import trace
-from pyfuse.worker.backends.base import Backend
+from away.core.version import _VERSION
+from away.core.progress import ProgressInfo
+from away.core.progress import progress as progress
+from away.worker.remote import serve, connect, disconnect
+from away.worker.result import Result, ResultEnvelope
+from away.worker.worker import Worker
+from away.worker.worker import execute as execute
+from away.worker.sandbox import DockerSandbox
+from away.worker.schedule import ScheduleHandle
+from away.graph.decorator import trace
+from away.worker.backends.base import Backend
 
 
 def get_graph() -> Graph:
@@ -63,8 +63,8 @@ def get_graph() -> Graph:
     The returned :class:`Graph` has :meth:`~Graph.to_mermaid` for
     visualization::
 
-        print(pyfuse.get_graph().to_mermaid())           # full graph
-        print(pyfuse.get_graph().to_mermaid(my_func))    # subgraph of my_func
+        print(away.get_graph().to_mermaid())           # full graph
+        print(away.get_graph().to_mermaid(my_func))    # subgraph of my_func
     """
     return Graph.default()