ai2in 0.1.0__tar.gz

ai2in-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+dist/
+*.egg-info/
+__pycache__/
+*.pyc

ai2in-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AI2IN.dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ai2in-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: ai2in
+Version: 0.1.0
+Summary: Python SDK for AI2IN — secure AI code sandboxes, hosted in India.
+Project-URL: Homepage, https://ai2in.dev
+Project-URL: Repository, https://github.com/AI2IN-DEV/AI2IN
+Project-URL: Documentation, https://ai2in.dev
+Author: AI2IN.dev
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,code-interpreter,e2b,india,sandbox
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# ai2in — Python SDK
+
+The developer client for [AI2IN.dev](https://ai2in.dev) — secure AI code
+sandboxes, hosted in India. Spin up an isolated Linux sandbox, run untrusted /
+AI‑generated Python in a stateful kernel, and get back rich, typed results
+(text, HTML tables, charts, JSON) — the E2B code‑interpreter model, in‑region.
+
+Stdlib‑only, zero dependencies.
+
+## Install
+
+```bash
+pip install ai2in            # once published
+# or, from this repo:
+pip install -e sdk/python
+```
+
+## Quickstart
+
+```python
+from ai2in import Sandbox
+
+with Sandbox(api_key="ai2in_live_…", base_url="https://api.ai2in.dev") as sbx:
+    execution = sbx.run_code(
+        "import pandas as pd; pd.DataFrame({'gst_lakh_cr': [1.87, 1.73, 1.95]})"
+    )
+
+    print(execution.text)            # the main result's plain text
+    print(execution.logs.stdout)     # ['…']
+
+    for r in execution.results:      # rich, typed outputs
+        if r.html:                   # e.g. a DataFrame → HTML table
+            save(r.html)
+        if r.png:                    # e.g. a matplotlib figure → base64 PNG
+            save_image(r.png)
+
+    if execution.error:              # structured error for self-correction
+        print(execution.error.name, execution.error.value)
+```
+
+State persists across `run_code` calls in the same sandbox (like a notebook):
+
+```python
+sbx.run_code("x = 41")
+sbx.run_code("x + 1").text   # "42"
+```
+
+## Streaming
+
+Pass callbacks to stream output **live** as the kernel produces it (long loops,
+training logs, incremental prints). The events are still accumulated into the
+returned `Execution`, so the return value is identical whether or not you stream:
+
+```python
+execution = sbx.run_code(
+    "for i in range(5):\n    print('step', i)\n    import time; time.sleep(1)",
+    on_stdout=lambda t: print(t, end="", flush=True),  # arrives chunk-by-chunk
+    on_result=lambda r: render(r),                     # display() calls, figures, the value
+    on_error=lambda e: print(e.value),
+)
+print(execution.execution_ms)                          # still get the full Execution
+```
+
+## Result model
+
+`run_code()` returns an `Execution`:
+
+| Field | Type | Notes |
+|---|---|---|
+| `results` | `list[Result]` | rich outputs; the cell's value has `is_main_result=True` |
+| `logs` | `Logs` | `.stdout` / `.stderr` (lists of str) |
+| `error` | `ExecutionError \| None` | `.name`, `.value`, `.traceback` |
+| `text` | `str \| None` | convenience: the main result's text |
+
+Each `Result` may carry any of: `text`, `html`, `markdown`, `svg`, `png`,
+`jpeg`, `pdf`, `latex`, `json`, `javascript`. Call `r.formats()` for what's
+present.
+
+## Local dev
+
+Point at a local engine (default `http://localhost:4000`):
+
+```python
+with Sandbox() as sbx:            # talks to localhost:4000
+    print(sbx.run_code("print(1 + 1)").logs.stdout)
+```
+
+---
+
+© 2026 AI2IN.dev — see the repository LICENSE.

ai2in-0.1.0/README.md

@@ -0,0 +1,90 @@
+# ai2in — Python SDK
+
+The developer client for [AI2IN.dev](https://ai2in.dev) — secure AI code
+sandboxes, hosted in India. Spin up an isolated Linux sandbox, run untrusted /
+AI‑generated Python in a stateful kernel, and get back rich, typed results
+(text, HTML tables, charts, JSON) — the E2B code‑interpreter model, in‑region.
+
+Stdlib‑only, zero dependencies.
+
+## Install
+
+```bash
+pip install ai2in            # once published
+# or, from this repo:
+pip install -e sdk/python
+```
+
+## Quickstart
+
+```python
+from ai2in import Sandbox
+
+with Sandbox(api_key="ai2in_live_…", base_url="https://api.ai2in.dev") as sbx:
+    execution = sbx.run_code(
+        "import pandas as pd; pd.DataFrame({'gst_lakh_cr': [1.87, 1.73, 1.95]})"
+    )
+
+    print(execution.text)            # the main result's plain text
+    print(execution.logs.stdout)     # ['…']
+
+    for r in execution.results:      # rich, typed outputs
+        if r.html:                   # e.g. a DataFrame → HTML table
+            save(r.html)
+        if r.png:                    # e.g. a matplotlib figure → base64 PNG
+            save_image(r.png)
+
+    if execution.error:              # structured error for self-correction
+        print(execution.error.name, execution.error.value)
+```
+
+State persists across `run_code` calls in the same sandbox (like a notebook):
+
+```python
+sbx.run_code("x = 41")
+sbx.run_code("x + 1").text   # "42"
+```
+
+## Streaming
+
+Pass callbacks to stream output **live** as the kernel produces it (long loops,
+training logs, incremental prints). The events are still accumulated into the
+returned `Execution`, so the return value is identical whether or not you stream:
+
+```python
+execution = sbx.run_code(
+    "for i in range(5):\n    print('step', i)\n    import time; time.sleep(1)",
+    on_stdout=lambda t: print(t, end="", flush=True),  # arrives chunk-by-chunk
+    on_result=lambda r: render(r),                     # display() calls, figures, the value
+    on_error=lambda e: print(e.value),
+)
+print(execution.execution_ms)                          # still get the full Execution
+```
+
+## Result model
+
+`run_code()` returns an `Execution`:
+
+| Field | Type | Notes |
+|---|---|---|
+| `results` | `list[Result]` | rich outputs; the cell's value has `is_main_result=True` |
+| `logs` | `Logs` | `.stdout` / `.stderr` (lists of str) |
+| `error` | `ExecutionError \| None` | `.name`, `.value`, `.traceback` |
+| `text` | `str \| None` | convenience: the main result's text |
+
+Each `Result` may carry any of: `text`, `html`, `markdown`, `svg`, `png`,
+`jpeg`, `pdf`, `latex`, `json`, `javascript`. Call `r.formats()` for what's
+present.
+
+## Local dev
+
+Point at a local engine (default `http://localhost:4000`):
+
+```python
+with Sandbox() as sbx:            # talks to localhost:4000
+    print(sbx.run_code("print(1 + 1)").logs.stdout)
+```
+
+---
+
+© 2026 AI2IN.dev — see the repository LICENSE.

ai2in-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ai2in"
+version = "0.1.0"
+description = "Python SDK for AI2IN — secure AI code sandboxes, hosted in India."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "AI2IN.dev" }]
+keywords = ["ai", "agents", "sandbox", "code-interpreter", "india", "e2b"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+# Stdlib-only — zero third-party dependencies.
+dependencies = []
+
+[project.urls]
+Homepage = "https://ai2in.dev"
+Repository = "https://github.com/AI2IN-DEV/AI2IN"
+Documentation = "https://ai2in.dev"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ai2in"]

ai2in-0.1.0/src/ai2in/__init__.py

@@ -0,0 +1,296 @@
+"""
+AI2IN Python SDK — the developer-facing client for sandboxes.
+
+    from ai2in import Sandbox
+
+    with Sandbox(api_key="ai2in_live_…") as sbx:
+        execution = sbx.run_code("import pandas as pd; pd.DataFrame({'x': [1, 2]})")
+        print(execution.text)          # the main result's text
+        for r in execution.results:    # rich, typed results (html, png, …)
+            if r.png:
+                ...
+
+The code-interpreter result model mirrors E2B's: each cell yields `results`
+(any of text/html/markdown/svg/png/jpeg/latex/json), structured `logs`, and a
+structured `error`. Talks to the AI2IN Sandbox Service (default
+http://localhost:4000; pass base_url="https://api.ai2in.dev" in production).
+Pass api_key=… for a bearer token when auth is on.
+
+Stdlib-only — no third-party dependencies.
+"""
+from __future__ import annotations
+
+import json
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+
+__version__ = "0.1.0"
+__all__ = ["Sandbox", "Execution", "Result", "Logs", "ExecutionError", "CommandHandle", "Watcher"]
+
+
+@dataclass
+class Result:
+    """One rich output. Any MIME field may be set; is_main_result marks the
+    cell's return value."""
+    text: Optional[str] = None
+    html: Optional[str] = None
+    markdown: Optional[str] = None
+    svg: Optional[str] = None
+    png: Optional[str] = None       # base64
+    jpeg: Optional[str] = None      # base64
+    pdf: Optional[str] = None       # base64
+    latex: Optional[str] = None
+    json: Optional[Any] = None
+    javascript: Optional[str] = None
+    is_main_result: bool = False
+
+    def formats(self) -> list[str]:
+        return [k for k in ("text", "html", "markdown", "svg", "png", "jpeg",
+                            "pdf", "latex", "json", "javascript")
+                if getattr(self, k) is not None]
+
+
+@dataclass
+class Logs:
+    stdout: list[str] = field(default_factory=list)
+    stderr: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ExecutionError:
+    name: str
+    value: str
+    traceback: str
+
+
+@dataclass
+class Execution:
+    results: list[Result] = field(default_factory=list)
+    logs: Logs = field(default_factory=Logs)
+    error: Optional[ExecutionError] = None
+    execution_ms: Optional[int] = None
+
+    @property
+    def text(self) -> Optional[str]:
+        for r in self.results:
+            if r.is_main_result:
+                return r.text
+        return None
+
+
+def _result_from(item: dict) -> Result:
+    return Result(
+        text=item.get("text"), html=item.get("html"), markdown=item.get("markdown"),
+        svg=item.get("svg"), png=item.get("png"), jpeg=item.get("jpeg"),
+        pdf=item.get("pdf"), latex=item.get("latex"), json=item.get("json"),
+        javascript=item.get("javascript"), is_main_result=bool(item.get("is_main_result")),
+    )
+
+
+def _parse_execution(r: dict) -> Execution:
+    results = [_result_from(item) for item in (r.get("results") or [])]
+    logs_in = r.get("logs") or {}
+    logs = Logs(stdout=list(logs_in.get("stdout") or []), stderr=list(logs_in.get("stderr") or []))
+    err = r.get("error")
+    error = ExecutionError(err["name"], err.get("value", ""), err.get("traceback", "")) if err else None
+    return Execution(results=results, logs=logs, error=error, execution_ms=r.get("execution_ms"))
+
+
+class CommandHandle:
+    """Handle to a background command — poll ``logs()`` or ``kill()`` it."""
+
+    def __init__(self, sandbox: "Sandbox", command_id: str, pid: int):
+        self._sb = sandbox
+        self.id = command_id
+        self.pid = pid
+
+    def logs(self) -> dict:
+        """Current buffered output + status: {stdout, stderr, status, exit_code}."""
+        return self._sb._req("POST", f"/v1/sandboxes/{self._sb.id}/commands/{self.id}/logs")
+
+    def kill(self) -> dict:
+        """Terminate the command (SIGTERM to its process group)."""
+        return self._sb._req("POST", f"/v1/sandboxes/{self._sb.id}/commands/{self.id}/kill")
+
+
+class _Commands:
+    """Long-running commands: ``run`` blocks; ``start`` backgrounds and returns a
+    handle. Pair ``start`` with ``get_host`` to run a server and preview it."""
+
+    def __init__(self, sandbox: "Sandbox"):
+        self._sb = sandbox
+
+    def run(self, cmd: str) -> dict:
+        r = self._sb._req("POST", f"/v1/sandboxes/{self._sb.id}/shell", {"cmd": cmd})
+        return {"stdout": r.get("stdout", ""), "stderr": r.get("stderr", ""), "exit_code": r.get("exit_code", 0)}
+
+    def start(self, cmd: str) -> CommandHandle:
+        r = self._sb._req("POST", f"/v1/sandboxes/{self._sb.id}/commands", {"cmd": cmd})
+        return CommandHandle(self._sb, r["command_id"], r["pid"])
+
+    def list(self) -> list:
+        return self._sb._req("GET", f"/v1/sandboxes/{self._sb.id}/commands").get("commands", [])
+
+
+class Watcher:
+    """A filesystem watcher. ``poll()`` returns events since the last poll
+    (create/modify/remove); ``stop()`` ends it."""
+
+    def __init__(self, sandbox: "Sandbox", watch_id: str):
+        self._sb = sandbox
+        self.id = watch_id
+
+    def poll(self) -> list:
+        return self._sb._req("POST", f"/v1/sandboxes/{self._sb.id}/fs/watch/{self.id}/poll").get("events", [])
+
+    def stop(self) -> dict:
+        return self._sb._req("POST", f"/v1/sandboxes/{self._sb.id}/fs/watch/{self.id}/stop")
+
+
+class _Files:
+    """Filesystem access inside the sandbox (rooted at the workspace)."""
+
+    def __init__(self, sandbox: "Sandbox"):
+        self._sb = sandbox
+
+    def list(self, path: str = ".") -> list:
+        return self._sb._req("POST", f"/v1/sandboxes/{self._sb.id}/fs/list", {"path": path}).get("entries", [])
+
+    def read(self, path: str) -> str:
+        return self._sb._req("POST", f"/v1/sandboxes/{self._sb.id}/fs/read", {"path": path}).get("content", "")
+
+    def write(self, path: str, content: str) -> dict:
+        return self._sb._req("POST", f"/v1/sandboxes/{self._sb.id}/fs/write", {"path": path, "content": content})
+
+    def watch(self, path: str = ".", recursive: bool = True) -> Watcher:
+        r = self._sb._req("POST", f"/v1/sandboxes/{self._sb.id}/fs/watch", {"path": path, "recursive": recursive})
+        return Watcher(self._sb, r["watch_id"])
+
+
+class Sandbox:
+    """A live, isolated sandbox. Created on construction; kill() (or the context
+    manager) tears it down."""
+
+    def __init__(self, base_url: str = "http://localhost:4000", api_key: Optional[str] = None,
+                 region: str = "ap-south-1"):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.region = region
+        self.id: Optional[str] = None
+        self.commands = _Commands(self)
+        self.files = _Files(self)
+        self._create()
+
+    def _req(self, method: str, path: str, body: Optional[dict] = None) -> dict:
+        data = json.dumps(body).encode() if body is not None else None
+        req = urllib.request.Request(self.base_url + path, data=data, method=method)
+        req.add_header("Content-Type", "application/json")
+        if self.api_key:
+            req.add_header("Authorization", f"Bearer {self.api_key}")
+        with urllib.request.urlopen(req) as resp:
+            return json.loads(resp.read().decode())
+
+    def _create(self) -> None:
+        self.id = self._req("POST", "/v1/sandboxes")["id"]
+
+    def run_code(
+        self,
+        code: str,
+        on_stdout: Optional[Callable[[str], None]] = None,
+        on_stderr: Optional[Callable[[str], None]] = None,
+        on_result: Optional[Callable[[Result], None]] = None,
+        on_error: Optional[Callable[[ExecutionError], None]] = None,
+    ) -> Execution:
+        """Run a Python cell in the sandbox's stateful kernel; return the rich
+        Execution (results / logs / error).
+
+        Pass any of on_stdout/on_stderr/on_result/on_error to stream output live
+        as it's produced. The events are still accumulated into the returned
+        Execution, so the return value is identical whether or not you stream.
+        """
+        if not (on_stdout or on_stderr or on_result or on_error):
+            return _parse_execution(self._req("POST", f"/v1/sandboxes/{self.id}/run", {"code": code}))
+        return self._run_stream(code, on_stdout, on_stderr, on_result, on_error)
+
+    def _run_stream(self, code, on_stdout, on_stderr, on_result, on_error) -> Execution:
+        data = json.dumps({"code": code}).encode()
+        req = urllib.request.Request(
+            self.base_url + f"/v1/sandboxes/{self.id}/run/stream", data=data, method="POST")
+        req.add_header("Content-Type", "application/json")
+        if self.api_key:
+            req.add_header("Authorization", f"Bearer {self.api_key}")
+
+        results: list[Result] = []
+        logs = Logs()
+        error: Optional[ExecutionError] = None
+        execution_ms: Optional[int] = None
+
+        with urllib.request.urlopen(req) as resp:
+            buf = ""
+            for raw in resp:  # iterate the SSE stream line-by-line, live
+                buf += raw.decode("utf-8")
+                while "\n\n" in buf:
+                    frame, buf = buf.split("\n\n", 1)
+                    line = frame.strip()
+                    if line.startswith("data:"):
+                        line = line[5:].strip()
+                    if not line:
+                        continue
+                    ev = json.loads(line)
+                    kind = ev.get("type")
+                    if kind == "stdout":
+                        logs.stdout.append(ev["text"])
+                        if on_stdout:
+                            on_stdout(ev["text"])
+                    elif kind == "stderr":
+                        logs.stderr.append(ev["text"])
+                        if on_stderr:
+                            on_stderr(ev["text"])
+                    elif kind == "result":
+                        r = _result_from(ev["result"])
+                        results.append(r)
+                        if on_result:
+                            on_result(r)
+                    elif kind == "error":
+                        e = ev["error"]
+                        error = ExecutionError(e["name"], e.get("value", ""), e.get("traceback", ""))
+                        if on_error:
+                            on_error(error)
+                    elif kind == "end":
+                        execution_ms = ev.get("execution_ms")
+
+        return Execution(results=results, logs=logs, error=error, execution_ms=execution_ms)
+
+    def pause(self) -> dict:
+        """Pause the sandbox: its container is stopped (no CPU/RAM) while the
+        full filesystem is preserved, so a long-running agent session can be
+        parked cheaply and ``resume()``-d later. Returns the sandbox view."""
+        return self._req("POST", f"/v1/sandboxes/{self.id}/pause")
+
+    def resume(self) -> dict:
+        """Resume a paused sandbox: the container is started again (fresh memory,
+        the filesystem exactly as left) and reopened for work."""
+        return self._req("POST", f"/v1/sandboxes/{self.id}/resume")
+
+    def get_metrics(self) -> dict:
+        """Live resource usage: cpu_pct, mem_used_mb, mem_pct, pids, net_*,
+        uptime_s (E2B ``get_metrics`` parity)."""
+        return self._req("GET", f"/v1/sandboxes/{self.id}/metrics")
+
+    def get_host(self, port: int) -> str:
+        """Expose a port the sandbox binds internally (e.g. a dev server on
+        3000) at a public HTTPS URL and return its host (E2B ``get_host``
+        parity). Build the URL as ``f"https://{sbx.get_host(3000)}"``."""
+        return self._req("POST", f"/v1/sandboxes/{self.id}/expose", {"port": port})["host"]
+
+    def kill(self) -> None:
+        if self.id:
+            self._req("DELETE", f"/v1/sandboxes/{self.id}")
+            self.id = None
+
+    def __enter__(self) -> "Sandbox":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.kill()