boxfab-code-interpreter 0.1.0a1__tar.gz

boxfab_code_interpreter-0.1.0a1/LICENSE

@@ -0,0 +1,10 @@
+MIT License
+
+Copyright (c) 2025 FOUNDRYLABS, INC.
+Copyright (c) 2026 ContextFab, Inc.
+
+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.

boxfab_code_interpreter-0.1.0a1/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: boxfab-code-interpreter
+Version: 0.1.0a1
+Summary: BoxFab Code Interpreter: run AI-generated code in BoxFab sandboxes, Jupyter-style
+Author: ContextFab, Inc.
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: boxfab>=0.1.0a3,<0.2
+Requires-Dist: httpx>=0.20.0,<1.0.0
+Requires-Dist: attrs>=21.3.0
+Requires-Python: >=3.11
+Project-URL: Repository, https://github.com/boxfab/python-sdk
+Description-Content-Type: text/markdown
+
+# BoxFab Code Interpreter (Python)
+
+Run AI-generated code in isolated [BoxFab](https://boxfab.io) sandboxes, Jupyter-style:
+Python, JavaScript, TypeScript, R, Java and Bash, with results such as text, tables and charts
+returned as data.
+
+## Getting started
+
+### 1. Install the SDK
+
+```bash
+pip install boxfab-code-interpreter
+```
+
+### 2. Get a BoxFab API key
+
+Get a key from the [BoxFab dashboard](https://dashboard.boxfab.io) and set it as `BOXFAB_API_KEY`.
+The SDK reads only `BOXFAB_*` variables.
+
+### 3. Execute code with code interpreter inside Sandbox
+
+```py
+from boxfab_code_interpreter import Sandbox
+
+with Sandbox.create() as sandbox:
+    sandbox.run_code("x = 1")
+    execution = sandbox.run_code("x+=1; x")
+    print(execution.text)  # outputs 2
+```
+
+### 4. Bind the configuration to a client
+
+The top-level `Sandbox` and `AsyncSandbox` exports read their configuration from the environment variables. To use an explicit configuration — e.g. several API keys or domains in one process — create a `BoxFab` client and use the resource classes it exposes:
+
+```py
+from boxfab_code_interpreter import BoxFab
+
+client = BoxFab(api_key="e2b_***", domain="boxfab.io")
+
+with client.Sandbox.create() as sandbox:
+    execution = sandbox.run_code("x = 1; x += 1; x")
+
+# The async variant is exposed as well.
+async_sandbox = await client.AsyncSandbox.create()
+
+# The core resources are bound to the client's configuration as well.
+volume = client.Volume.create("my-volume")
+exists = client.Template.exists("my-template")
+secret = client.Secret.create("openai-api-key", "sk-***")
+
+# The classes can be assigned and used like the top-level ones.
+Sandbox = client.Sandbox
+paginator = Sandbox.list()
+```
+
+Per-call params still take precedence over the client's params, and clients are isolated from each other and from the env-configured top-level exports.
+
+## Under the hood
+
+Sandboxes are created from the `code-interpreter-v1` template, which BoxFab provides to every team:
+a Jupyter server with common data-science packages. BoxFab sandboxes are
+[Firecracker](https://firecracker-microvm.github.io/) microVMs, run on the open-source
+[E2B](https://github.com/e2b-dev/infra) sandbox infrastructure. This package is derived from the
+open-source E2B Code Interpreter SDK;
+[UPSTREAM.md](https://github.com/boxfab/python-sdk/blob/main/UPSTREAM.md) lists every change.
+
+**Using the E2B Code Interpreter SDKs.** BoxFab serves the same API and provides the
+`code-interpreter-v1` template, so the E2B Code Interpreter SDKs work with it as well. Set both
+variables, the domain first:
+
+```bash
+export E2B_DOMAIN=boxfab.io
+export E2B_API_KEY="<your BoxFab API key>"
+```
+
+Without `E2B_DOMAIN`, the E2B SDKs send requests, including the key, to E2B's own service.
+
+Tested against BoxFab with `e2b-code-interpreter` 2.11.6 (Python) and `@e2b/code-interpreter` 2.9.0
+(JavaScript).
+
+## License
+
+MIT, as the E2B Code Interpreter SDK it is derived from; see [LICENSE](LICENSE).
+
+BoxFab is a product of ContextFab, Inc.

boxfab_code_interpreter-0.1.0a1/README.md

@@ -0,0 +1,85 @@
+# BoxFab Code Interpreter (Python)
+
+Run AI-generated code in isolated [BoxFab](https://boxfab.io) sandboxes, Jupyter-style:
+Python, JavaScript, TypeScript, R, Java and Bash, with results such as text, tables and charts
+returned as data.
+
+## Getting started
+
+### 1. Install the SDK
+
+```bash
+pip install boxfab-code-interpreter
+```
+
+### 2. Get a BoxFab API key
+
+Get a key from the [BoxFab dashboard](https://dashboard.boxfab.io) and set it as `BOXFAB_API_KEY`.
+The SDK reads only `BOXFAB_*` variables.
+
+### 3. Execute code with code interpreter inside Sandbox
+
+```py
+from boxfab_code_interpreter import Sandbox
+
+with Sandbox.create() as sandbox:
+    sandbox.run_code("x = 1")
+    execution = sandbox.run_code("x+=1; x")
+    print(execution.text)  # outputs 2
+```
+
+### 4. Bind the configuration to a client
+
+The top-level `Sandbox` and `AsyncSandbox` exports read their configuration from the environment variables. To use an explicit configuration — e.g. several API keys or domains in one process — create a `BoxFab` client and use the resource classes it exposes:
+
+```py
+from boxfab_code_interpreter import BoxFab
+
+client = BoxFab(api_key="e2b_***", domain="boxfab.io")
+
+with client.Sandbox.create() as sandbox:
+    execution = sandbox.run_code("x = 1; x += 1; x")
+
+# The async variant is exposed as well.
+async_sandbox = await client.AsyncSandbox.create()
+
+# The core resources are bound to the client's configuration as well.
+volume = client.Volume.create("my-volume")
+exists = client.Template.exists("my-template")
+secret = client.Secret.create("openai-api-key", "sk-***")
+
+# The classes can be assigned and used like the top-level ones.
+Sandbox = client.Sandbox
+paginator = Sandbox.list()
+```
+
+Per-call params still take precedence over the client's params, and clients are isolated from each other and from the env-configured top-level exports.
+
+## Under the hood
+
+Sandboxes are created from the `code-interpreter-v1` template, which BoxFab provides to every team:
+a Jupyter server with common data-science packages. BoxFab sandboxes are
+[Firecracker](https://firecracker-microvm.github.io/) microVMs, run on the open-source
+[E2B](https://github.com/e2b-dev/infra) sandbox infrastructure. This package is derived from the
+open-source E2B Code Interpreter SDK;
+[UPSTREAM.md](https://github.com/boxfab/python-sdk/blob/main/UPSTREAM.md) lists every change.
+
+**Using the E2B Code Interpreter SDKs.** BoxFab serves the same API and provides the
+`code-interpreter-v1` template, so the E2B Code Interpreter SDKs work with it as well. Set both
+variables, the domain first:
+
+```bash
+export E2B_DOMAIN=boxfab.io
+export E2B_API_KEY="<your BoxFab API key>"
+```
+
+Without `E2B_DOMAIN`, the E2B SDKs send requests, including the key, to E2B's own service.
+
+Tested against BoxFab with `e2b-code-interpreter` 2.11.6 (Python) and `@e2b/code-interpreter` 2.9.0
+(JavaScript).
+
+## License
+
+MIT, as the E2B Code Interpreter SDK it is derived from; see [LICENSE](LICENSE).
+
+BoxFab is a product of ContextFab, Inc.

boxfab_code_interpreter-0.1.0a1/boxfab_code_interpreter/__init__.py

@@ -0,0 +1,15 @@
+from boxfab import *
+from .client import BoxFab, BoxFabClientParams, E2B, E2BClientParams
+from .code_interpreter_sync import Sandbox
+from .code_interpreter_async import AsyncSandbox
+from .models import (
+    Context,
+    Execution,
+    ExecutionError,
+    Result,
+    MIMEType,
+    Logs,
+    OutputHandler,
+    OutputMessage,
+    RunCodeLanguage,
+)

boxfab_code_interpreter-0.1.0a1/boxfab_code_interpreter/charts.py

@@ -0,0 +1,232 @@
+import enum
+from typing import Any, List, Tuple, Optional, Union
+
+
+class ChartType(str, enum.Enum):
+    """
+    Chart types
+    """
+
+    LINE = "line"
+    SCATTER = "scatter"
+    BAR = "bar"
+    PIE = "pie"
+    BOX_AND_WHISKER = "box_and_whisker"
+    SUPERCHART = "superchart"
+    UNKNOWN = "unknown"
+
+
+class ScaleType(str, enum.Enum):
+    """
+    Ax scale types
+    """
+
+    LINEAR = "linear"
+    DATETIME = "datetime"
+    CATEGORICAL = "categorical"
+    LOG = "log"
+    SYMLOG = "symlog"
+    LOGIT = "logit"
+    FUNCTION = "function"
+    FUNCTIONLOG = "functionlog"
+    ASINH = "asinh"
+    UNKNOWN = "unknown"
+
+
+class Chart:
+    """
+    Extracted data from a chart. It's useful for building an interactive charts or custom visualizations.
+    """
+
+    type: ChartType
+    title: str
+
+    elements: List[Any]
+
+    def __init__(self, **kwargs):
+        self._raw_data = kwargs
+        self.type = ChartType(kwargs["type"] or ChartType.UNKNOWN)
+        self.title = kwargs["title"]
+        self.elements = kwargs["elements"]
+
+    def to_dict(self) -> dict:
+        return self._raw_data
+
+
+class Chart2D(Chart):
+    x_label: Optional[str]
+    y_label: Optional[str]
+    x_unit: Optional[str]
+    y_unit: Optional[str]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.x_label = kwargs["x_label"]
+        self.y_label = kwargs["y_label"]
+        self.x_unit = kwargs["x_unit"]
+        self.y_unit = kwargs["y_unit"]
+
+
+class PointData:
+    label: str
+    points: List[Tuple[Union[str, float], Union[str, float]]]
+
+    def __init__(self, **kwargs):
+        self.label = kwargs["label"]
+        self.points = [(x, y) for x, y in kwargs["points"]]
+
+
+class PointChart(Chart2D):
+    x_ticks: List[Union[str, float]]
+    x_tick_labels: List[str]
+    x_scale: ScaleType
+
+    y_ticks: List[Union[str, float]]
+    y_tick_labels: List[str]
+    y_scale: ScaleType
+
+    elements: List[PointData]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.x_label = kwargs["x_label"]
+
+        try:
+            self.x_scale = ScaleType(kwargs.get("x_scale"))
+        except ValueError:
+            self.x_scale = ScaleType.UNKNOWN
+
+        self.x_ticks = kwargs["x_ticks"]
+        self.x_tick_labels = kwargs["x_tick_labels"]
+
+        self.y_label = kwargs["y_label"]
+
+        try:
+            self.y_scale = ScaleType(kwargs.get("y_scale"))
+        except ValueError:
+            self.y_scale = ScaleType.UNKNOWN
+
+        self.y_ticks = kwargs["y_ticks"]
+        self.y_tick_labels = kwargs["y_tick_labels"]
+
+        self.elements = [PointData(**d) for d in kwargs["elements"]]
+
+
+class LineChart(PointChart):
+    type = ChartType.LINE
+
+
+class ScatterChart(PointChart):
+    type = ChartType.SCATTER
+
+
+class BarData:
+    label: str
+    group: str
+    value: str
+
+    def __init__(self, **kwargs):
+        self.label = kwargs["label"]
+        self.value = kwargs["value"]
+        self.group = kwargs["group"]
+
+
+class BarChart(Chart2D):
+    type = ChartType.BAR
+
+    elements: List[BarData]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.elements = [BarData(**d) for d in kwargs["elements"]]
+
+
+class PieData:
+    label: str
+    angle: float
+    radius: float
+
+    def __init__(self, **kwargs):
+        self.label = kwargs["label"]
+        self.angle = kwargs["angle"]
+        self.radius = kwargs["radius"]
+
+
+class PieChart(Chart):
+    type = ChartType.PIE
+
+    elements: List[PieData]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.elements = [PieData(**d) for d in kwargs["elements"]]
+
+
+class BoxAndWhiskerData:
+    label: str
+    min: float
+    first_quartile: float
+    median: float
+    third_quartile: float
+    max: float
+    outliers: List[float]
+
+    def __init__(self, **kwargs):
+        self.label = kwargs["label"]
+        self.min = kwargs["min"]
+        self.first_quartile = kwargs["first_quartile"]
+        self.median = kwargs["median"]
+        self.third_quartile = kwargs["third_quartile"]
+        self.max = kwargs["max"]
+        self.outliers = kwargs.get("outliers") or []
+
+
+class BoxAndWhiskerChart(Chart2D):
+    type = ChartType.BOX_AND_WHISKER
+
+    elements: List[BoxAndWhiskerData]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.elements = [BoxAndWhiskerData(**d) for d in kwargs["elements"]]
+
+
+class SuperChart(Chart):
+    type = ChartType.SUPERCHART
+
+    elements: List[Chart]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.elements = []
+        for raw_chart in kwargs["elements"]:
+            chart = _deserialize_chart(raw_chart)
+            if chart is not None:
+                self.elements.append(chart)
+
+
+ChartTypes = Union[
+    Chart, LineChart, ScatterChart, BarChart, PieChart, BoxAndWhiskerChart, SuperChart
+]
+
+
+def _deserialize_chart(data: Optional[dict]) -> Optional[ChartTypes]:
+    if not data:
+        return None
+
+    if data["type"] == ChartType.LINE:
+        chart = LineChart(**data)
+    elif data["type"] == ChartType.SCATTER:
+        chart = ScatterChart(**data)
+    elif data["type"] == ChartType.BAR:
+        chart = BarChart(**data)
+    elif data["type"] == ChartType.PIE:
+        chart = PieChart(**data)
+    elif data["type"] == ChartType.BOX_AND_WHISKER:
+        chart = BoxAndWhiskerChart(**data)
+    elif data["type"] == ChartType.SUPERCHART:
+        chart = SuperChart(**data)
+    else:
+        chart = Chart(**data)
+
+    return chart

boxfab_code_interpreter-0.1.0a1/boxfab_code_interpreter/client.py

@@ -0,0 +1,95 @@
+from typing import Dict, Type, TypeVar, Unpack, cast
+
+from boxfab import ApiParams, BoxFabClientParams, E2BClientParams
+from boxfab import BoxFab as CoreBoxFab
+from boxfab_code_interpreter.code_interpreter_async import AsyncSandbox
+from boxfab_code_interpreter.code_interpreter_sync import Sandbox
+
+T = TypeVar("T")
+
+__all__ = ["BoxFab", "BoxFabClientParams", "E2B", "E2BClientParams"]
+
+
+def _bind(cls: Type[T], api_params: ApiParams) -> Type[T]:
+    """Generate a subclass of ``cls`` carrying ``api_params`` as its bound params."""
+    return cast(
+        Type[T],
+        type(cls.__name__, (cls,), {"_bound_api_params": api_params}),
+    )
+
+
+class BoxFab:
+    """
+    BoxFab client with an explicitly bound connection configuration.
+
+    The resource classes exposed by the client (`Sandbox`, `AsyncSandbox`,
+    `Volume`, `AsyncVolume`, `Template`, `AsyncTemplate`, `Secret`,
+    `AsyncSecret`) behave exactly like the top-level exports of the same name,
+    except the params passed to the client are used as the defaults instead of
+    the environment variables.
+    Per-call params still take precedence over the client's params.
+
+    Multiple clients are fully isolated from each other and from the top-level
+    env-configured exports.
+
+    Example:
+    ```python
+    from boxfab_code_interpreter import BoxFab
+
+    client = BoxFab(api_key="e2b_...", domain="boxfab.io")
+
+    sandbox = client.Sandbox.create()
+    execution = sandbox.run_code("x = 1; x += 1; x")
+    ```
+    """
+
+    def __init__(self, **opts: Unpack[BoxFabClientParams]):
+        """
+        Create a new client with the API params bound to it.
+
+        :param opts: API params used as the defaults for every call made
+            through this client's resource classes.
+        """
+        # Params are copied so later mutations of the caller's dicts cannot
+        # change the bound configuration.
+        api_params = cast(ApiParams, dict(cast(Dict[str, object], opts)))
+
+        headers = api_params.get("headers")
+        if headers is not None:
+            api_params["headers"] = dict(headers)
+
+        api_headers = api_params.get("api_headers")
+        if api_headers is not None:
+            api_params["api_headers"] = dict(api_headers)
+
+        self.Sandbox = _bind(Sandbox, api_params)
+        """Code Interpreter `Sandbox` class bound to this client's connection configuration."""
+
+        self.AsyncSandbox = _bind(AsyncSandbox, api_params)
+        """Code Interpreter `AsyncSandbox` class bound to this client's connection configuration."""
+
+        # The resources that are not specific to the Code Interpreter are bound
+        # by the core client.
+        core = CoreBoxFab(**api_params)
+
+        self.Volume = core.Volume
+        """`Volume` class bound to this client's connection configuration."""
+
+        self.AsyncVolume = core.AsyncVolume
+        """`AsyncVolume` class bound to this client's connection configuration."""
+
+        self.Template = core.Template
+        """`Template` class bound to this client's connection configuration."""
+
+        self.AsyncTemplate = core.AsyncTemplate
+        """`AsyncTemplate` class bound to this client's connection configuration."""
+
+        self.Secret = core.Secret
+        """`Secret` class bound to this client's connection configuration."""
+
+        self.AsyncSecret = core.AsyncSecret
+        """`AsyncSecret` class bound to this client's connection configuration."""
+
+
+# Upstream name, kept so code written for the upstream package ports by changing only the import.
+E2B = BoxFab