impello 0.2.0__py3-none-any.whl

impello/__init__.py

@@ -0,0 +1,84 @@
+"""The Python SDK for Impello sandboxes.
+
+Impello runs its own build of E2B's open-source ``infra``, so the sandbox API
+is the same API. Unlike the TypeScript client, the Python one needs no changes
+to work against it: there is no ``e2b_`` key pattern anywhere in ``e2b``, so it
+takes an ``imp_`` key today. All this package has to supply is where to send
+the request.
+
+So this is a wrapper, and it is deliberately thin. It will be replaced by a
+full clone before we take payments, for the same reason the TypeScript client
+is one: ``pip show impello`` printing ``e2b`` is a poor thing for a paid
+product to say about itself, and the client sends a ``publisher: e2b`` header
+to our own servers. See ``docs/decisions/sdk-self-contained.md``.
+
+Usage is E2B's, unchanged::
+
+    from impello import Sandbox
+
+    sandbox = Sandbox.create()
+    result = sandbox.commands.run("echo hello")
+    sandbox.pause()
+"""
+
+import e2b as _e2b
+from e2b import *  # noqa: F401,F403
+from e2b.connection_config import ApiParams, merge_api_params
+
+from ._defaults import DEFAULT_DOMAIN, defaults
+
+__version__ = "0.2.0"
+
+
+class _ImpelloDefaults:
+    """Bind Impello's settings underneath every call.
+
+    ``ClientFactory._resolve_api_params`` is E2B's own seam for this: every
+    class method funnels through it, and ``merge_api_params`` already gives
+    per-call params precedence over bound ones. So this overrides one method
+    instead of mirroring the twelve descriptors on ``Sandbox``, and it changes
+    nothing about ``e2b`` itself. Importing this package does not retarget a
+    plain ``e2b`` call in the same process, and it does not touch ``os.environ``.
+    """
+
+    @classmethod
+    def _resolve_api_params(cls, **opts: "ApiParams") -> "ApiParams":
+        return merge_api_params(defaults(), super()._resolve_api_params(**opts))
+
+
+class Sandbox(_ImpelloDefaults, _e2b.Sandbox):
+    """An Impello sandbox."""
+
+
+class AsyncSandbox(_ImpelloDefaults, _e2b.AsyncSandbox):
+    """An Impello sandbox, async."""
+
+
+class Impello(_e2b.E2B):
+    """A client with its connection settings bound explicitly.
+
+    Use this instead of the module-level ``Sandbox`` when one process talks to
+    more than one account or more than one fleet. Clients are isolated from
+    each other. Params passed here beat the environment; params passed to a
+    single call beat both.
+
+    Example::
+
+        from impello import Impello
+
+        client = Impello(api_key="imp_...")
+        sandbox = client.Sandbox.create()
+    """
+
+    def __init__(self, **opts: "ApiParams"):
+        super().__init__(**merge_api_params(defaults(), opts))
+
+
+__all__ = [
+    *[name for name in dir(_e2b) if not name.startswith("_")],
+    "Sandbox",
+    "AsyncSandbox",
+    "Impello",
+    "DEFAULT_DOMAIN",
+    "__version__",
+]

impello/_defaults.py

@@ -0,0 +1,57 @@
+"""Where an Impello setting comes from, and in what order.
+
+Every setting reads an ``IMPELLO_`` name first, then the matching ``E2B_``
+name. The fallback is the migration, not politeness: callers already export
+``E2B_API_KEY``, ``E2B_API_URL`` and ``E2B_DOMAIN``, and the flag day that
+changes the key prefix is hard enough without renaming every environment on the
+same afternoon. Rename when convenient. Nothing breaks if you never do.
+"""
+
+import os
+from typing import Optional
+
+from e2b.connection_config import ApiParams
+
+DEFAULT_DOMAIN = "sandbox.impello.ai"
+
+# Each entry is one setting and the ``ApiParams`` key it fills.
+_SETTINGS = (
+    ("API_KEY", "api_key"),
+    ("API_URL", "api_url"),
+    ("DOMAIN", "domain"),
+    ("SANDBOX_URL", "sandbox_url"),
+)
+
+
+def _read(name: str) -> Optional[str]:
+    """Read one setting, Impello's name first."""
+    return os.getenv(f"IMPELLO_{name}") or os.getenv(f"E2B_{name}")
+
+
+def defaults() -> ApiParams:
+    """The params bound to every Impello call, resolved fresh each time.
+
+    Read at call time rather than at import, so a test or a caller that sets an
+    environment variable after importing this package still gets it.
+
+    A setting that is absent is left out of the result. It must not appear as
+    ``None``, because ``merge_api_params`` drops a ``None`` from the per-call
+    params but keeps one in the bound params, where it would clear the value
+    the SDK would otherwise resolve for itself.
+    """
+    params = {}
+
+    for name, key in _SETTINGS:
+        value = _read(name)
+        if value:
+            params[key] = value
+
+    debug = _read("DEBUG")
+    if debug:
+        params["debug"] = debug.lower() == "true"
+
+    # Only the domain has a default. Without one the SDK falls back to E2B's
+    # own `e2b.app`, and the failure is a connection to somebody else's fleet.
+    params.setdefault("domain", DEFAULT_DOMAIN)
+
+    return params

impello-0.2.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.5
+Name: impello
+Version: 0.2.0
+Summary: Python SDK for Impello sandboxes.
+Project-URL: Homepage, https://impello.ai
+Project-URL: Repository, https://github.com/21-Dreams/impello
+License-Expression: MIT
+Keywords: agents,code-interpreter,impello,microvm,sandbox
+Requires-Python: >=3.9
+Requires-Dist: e2b<3,>=2.46.0
+Description-Content-Type: text/markdown
+
+# `impello`
+
+The Python SDK for Impello sandboxes.
+
+## Install
+
+```bash
+pip install impello
+```
+
+## Use
+
+```python
+from impello import Sandbox
+
+sandbox = Sandbox.create()
+result = sandbox.commands.run("echo hello")
+
+print(result.stdout)
+
+sandbox.pause()
+```
+
+Set your key in the environment, or pass it to each call:
+
+```bash
+export IMPELLO_API_KEY=imp_...
+```
+
+```python
+Sandbox.list(api_key="imp_...")
+```
+
+For a process that talks to more than one account or more than one fleet, bind
+the settings to a client instead:
+
+```python
+from impello import Impello
+
+client = Impello(api_key="imp_...")
+sandbox = client.Sandbox.create()
+```
+
+## Settings
+
+Every setting reads an `IMPELLO_` name first, then the matching `E2B_` name.
+
+| Variable | Default | What it does |
+|---|---|---|
+| `IMPELLO_API_KEY` | none | The key. Starts with `imp_` |
+| `IMPELLO_DOMAIN` | `sandbox.impello.ai` | The domain the API and the sandboxes sit on |
+| `IMPELLO_API_URL` | `https://api.<domain>` | The API address. Set this to reach a self-hosted API |
+| `IMPELLO_SANDBOX_URL` | derived from the domain | The address a sandbox is reached at |
+| `IMPELLO_DEBUG` | `false` | Talk to `http://localhost:3000` |
+
+The `E2B_` fallback is the migration, not politeness. Callers already export
+`E2B_API_KEY`, `E2B_API_URL` and `E2B_DOMAIN`. Rename when it suits you.
+Nothing breaks if you never do.
+
+Only the domain has a default. Without one the SDK falls back to E2B's own
+`e2b.app`, and the failure is a connection to somebody else's fleet.
+
+Params passed to a single call beat a client's params, which beat the
+environment. That is E2B's own rule and this package keeps it.
+
+## Why this one is a wrapper, when the TypeScript one is a copy
+
+The TypeScript client cannot talk to Impello at all. Its `validateApiKey` runs
+inside the `ApiClient` constructor, is not exported, has no off switch, and
+accepts only `e2b_`. So `@impello/sdk` had to be a copy.
+
+Python has no `e2b_` pattern anywhere. It takes an `imp_` key today. So the
+only thing missing is where to send the request, and that is all this package
+supplies.
+
+It supplies it through `ClientFactory._resolve_api_params`, which is E2B's own
+seam for binding defaults. That means one method is overridden rather than the
+twelve descriptors on `Sandbox`, and **`e2b` itself is untouched**: importing
+`impello` does not retarget a plain `e2b` call in the same process, and it
+never writes to `os.environ`. A test holds that.
+
+## This package will be replaced
+
+A permanent wrapper is the worst outcome. `pip show impello` prints `e2b`, and
+the client sends a `publisher: e2b` header to our own servers. So the wrapper
+ships now and the full clone lands before we take payments, with
+`e2b/api/client/` regenerated from our own spec.
+
+See `docs/decisions/sdk-self-contained.md`.
+
+## Develop
+
+```bash
+python -m venv .venv
+./.venv/bin/pip install -e . pytest
+./.venv/bin/python -m pytest
+```

impello-0.2.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+impello/__init__.py,sha256=q0y_VBGCMoc7I2rejzF_2BjBgz-jltSmT87aExAwolE,2773
+impello/_defaults.py,sha256=CXTF0-azML2Ph1el9Rr1P0Fgd9ZKHVLfUIcGOm5Z89M,1910
+impello-0.2.0.dist-info/METADATA,sha256=viSALj9ELZONVDtmF1KipvR7HGSuDIxjvkIkUn5musk,3287
+impello-0.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+impello-0.2.0.dist-info/RECORD,,

impello-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any