boxfab-code-interpreter 0.1.0a1__py3-none-any.whl

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/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/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