watasu-code-interpreter 0.1.47__tar.gz

watasu_code_interpreter-0.1.47/.gitignore

@@ -0,0 +1,10 @@
+.pytest_cache/
+**/__pycache__/
+*.py[cod]
+dist/
+*.egg-info/
+
+ts/node_modules/
+ts/dist/
+
+rust/target/

watasu_code_interpreter-0.1.47/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: watasu-code-interpreter
+Version: 0.1.47
+Summary: Code Interpreter SDK for Watasu
+Project-URL: Repository, https://github.com/watasuio/sdk
+License-Expression: MIT OR Apache-2.0
+Requires-Python: >=3.9
+Requires-Dist: watasu<0.2,>=0.1.47
+Description-Content-Type: text/markdown
+
+# Watasu Code Interpreter Python SDK
+
+Python package for Watasu code interpreter sandboxes.
+
+## Install
+
+```bash
+pip install watasu-code-interpreter
+```
+
+Set `WATASU_API_KEY` before using the SDK.
+
+## Usage
+
+```python
+from watasu_code_interpreter import Sandbox
+
+with Sandbox.create() as sbx:
+    context = sbx.create_code_context()
+    execution = sbx.run_code(
+        "print('hello')\n2 + 3",
+        context=context,
+        on_stdout=lambda message: print(message.line),
+    )
+
+    print(execution.text)
+    sbx.remove_code_context(context)
+```
+
+`Sandbox.create()` starts the `code-interpreter` template by default. Code runs
+in persistent contexts and returns structured `results`, `logs`, and `error`
+fields for each execution.
+
+The package installs `watasu` and exposes the `watasu_code_interpreter` import
+path.

watasu_code_interpreter-0.1.47/README.md

@@ -0,0 +1,35 @@
+# Watasu Code Interpreter Python SDK
+
+Python package for Watasu code interpreter sandboxes.
+
+## Install
+
+```bash
+pip install watasu-code-interpreter
+```
+
+Set `WATASU_API_KEY` before using the SDK.
+
+## Usage
+
+```python
+from watasu_code_interpreter import Sandbox
+
+with Sandbox.create() as sbx:
+    context = sbx.create_code_context()
+    execution = sbx.run_code(
+        "print('hello')\n2 + 3",
+        context=context,
+        on_stdout=lambda message: print(message.line),
+    )
+
+    print(execution.text)
+    sbx.remove_code_context(context)
+```
+
+`Sandbox.create()` starts the `code-interpreter` template by default. Code runs
+in persistent contexts and returns structured `results`, `logs`, and `error`
+fields for each execution.
+
+The package installs `watasu` and exposes the `watasu_code_interpreter` import
+path.

watasu_code_interpreter-0.1.47/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "watasu-code-interpreter"
+version = "0.1.47"
+description = "Code Interpreter SDK for Watasu"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT OR Apache-2.0"
+dependencies = [
+  "watasu>=0.1.47,<0.2",
+]
+
+[project.urls]
+Repository = "https://github.com/watasuio/sdk"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/watasu_code_interpreter"]

watasu_code_interpreter-0.1.47/src/watasu_code_interpreter/__init__.py

@@ -0,0 +1,36 @@
+"""Code execution helpers for the Watasu Python SDK."""
+
+from watasu import *  # noqa: F403
+from watasu import __all__ as _watasu_all
+
+from . import code_interpreter_async, code_interpreter_sync, constants, exceptions
+from .main import AsyncSandbox, Sandbox
+from .models import (
+    Context,
+    Execution,
+    ExecutionError,
+    Logs,
+    MIMEType,
+    OutputHandler,
+    OutputMessage,
+    Result,
+)
+
+_code_interpreter_all = [
+    "AsyncSandbox",
+    "Context",
+    "code_interpreter_async",
+    "code_interpreter_sync",
+    "constants",
+    "Execution",
+    "ExecutionError",
+    "exceptions",
+    "Logs",
+    "MIMEType",
+    "OutputHandler",
+    "OutputMessage",
+    "Result",
+    "Sandbox",
+]
+
+__all__ = sorted(set(_watasu_all) | set(_code_interpreter_all))

watasu_code_interpreter-0.1.47/src/watasu_code_interpreter/charts.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+import enum
+from typing import Any, List, Optional, Tuple, Union
+
+
+class ChartType(str, enum.Enum):
+    """Supported chart kinds returned by code execution."""
+
+    LINE = "line"
+    SCATTER = "scatter"
+    BAR = "bar"
+    PIE = "pie"
+    BOX_AND_WHISKER = "box_and_whisker"
+    SUPERCHART = "superchart"
+    UNKNOWN = "unknown"
+
+
+class ScaleType(str, enum.Enum):
+    """Supported chart axis scale kinds."""
+
+    LINEAR = "linear"
+    DATETIME = "datetime"
+    CATEGORICAL = "categorical"
+    LOG = "log"
+    SYMLOG = "symlog"
+    LOGIT = "logit"
+    FUNCTION = "function"
+    FUNCTIONLOG = "functionlog"
+    ASINH = "asinh"
+    UNKNOWN = "unknown"
+
+
+class Chart:
+    """Extracted chart data for custom visualizations."""
+
+    type: ChartType
+    title: str
+    elements: List[Any]
+
+    def __init__(self, **kwargs: Any) -> None:
+        self._raw_data = dict(kwargs)
+        self.type = _chart_type(kwargs.get("type"))
+        self.title = str(kwargs.get("title") or "")
+        self.elements = list(kwargs.get("elements") or [])
+
+    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: Any) -> None:
+        super().__init__(**kwargs)
+        self.x_label = kwargs.get("x_label")
+        self.y_label = kwargs.get("y_label")
+        self.x_unit = kwargs.get("x_unit")
+        self.y_unit = kwargs.get("y_unit")
+
+
+class PointData:
+    label: str
+    points: List[Tuple[Union[str, float], Union[str, float]]]
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.label = str(kwargs.get("label") or "")
+        self.points = [(x, y) for x, y in kwargs.get("points") or []]
+
+
+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: Any) -> None:
+        super().__init__(**kwargs)
+        self.x_ticks = list(kwargs.get("x_ticks") or [])
+        self.x_tick_labels = list(kwargs.get("x_tick_labels") or [])
+        self.x_scale = _scale_type(kwargs.get("x_scale"))
+        self.y_ticks = list(kwargs.get("y_ticks") or [])
+        self.y_tick_labels = list(kwargs.get("y_tick_labels") or [])
+        self.y_scale = _scale_type(kwargs.get("y_scale"))
+        self.elements = [PointData(**item) for item in kwargs.get("elements") or []]
+
+
+class LineChart(PointChart):
+    type = ChartType.LINE
+
+
+class ScatterChart(PointChart):
+    type = ChartType.SCATTER
+
+
+class BarData:
+    label: str
+    group: str
+    value: str
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.label = str(kwargs.get("label") or "")
+        self.value = str(kwargs.get("value") or "")
+        self.group = str(kwargs.get("group") or "")
+
+
+class BarChart(Chart2D):
+    type = ChartType.BAR
+    elements: List[BarData]
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.elements = [BarData(**item) for item in kwargs.get("elements") or []]
+
+
+class PieData:
+    label: str
+    angle: float
+    radius: float
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.label = str(kwargs.get("label") or "")
+        self.angle = float(kwargs.get("angle") or 0)
+        self.radius = float(kwargs.get("radius") or 0)
+
+
+class PieChart(Chart):
+    type = ChartType.PIE
+    elements: List[PieData]
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.elements = [PieData(**item) for item in kwargs.get("elements") or []]
+
+
+class BoxAndWhiskerData:
+    label: str
+    min: float
+    first_quartile: float
+    median: float
+    third_quartile: float
+    max: float
+    outliers: List[float]
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.label = str(kwargs.get("label") or "")
+        self.min = float(kwargs.get("min") or 0)
+        self.first_quartile = float(kwargs.get("first_quartile") or 0)
+        self.median = float(kwargs.get("median") or 0)
+        self.third_quartile = float(kwargs.get("third_quartile") or 0)
+        self.max = float(kwargs.get("max") or 0)
+        self.outliers = [float(item) for item in kwargs.get("outliers") or []]
+
+
+class BoxAndWhiskerChart(Chart2D):
+    type = ChartType.BOX_AND_WHISKER
+    elements: List[BoxAndWhiskerData]
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.elements = [
+            BoxAndWhiskerData(**item) for item in kwargs.get("elements") or []
+        ]
+
+
+class SuperChart(Chart):
+    type = ChartType.SUPERCHART
+    elements: List[
+        Union[LineChart, ScatterChart, BarChart, PieChart, BoxAndWhiskerChart, Chart]
+    ]
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.elements = [
+            _deserialize_chart(item) or Chart(**item)
+            for item in kwargs.get("elements") or []
+            if isinstance(item, dict)
+        ]
+
+
+ChartTypes = Union[
+    LineChart, ScatterChart, BarChart, PieChart, BoxAndWhiskerChart, SuperChart
+]
+
+
+def _deserialize_chart(data: Optional[dict]) -> Optional[ChartTypes]:
+    if not data:
+        return None
+
+    chart_type = _chart_type(data.get("type"))
+    if chart_type == ChartType.LINE:
+        return LineChart(**data)
+    if chart_type == ChartType.SCATTER:
+        return ScatterChart(**data)
+    if chart_type == ChartType.BAR:
+        return BarChart(**data)
+    if chart_type == ChartType.PIE:
+        return PieChart(**data)
+    if chart_type == ChartType.BOX_AND_WHISKER:
+        return BoxAndWhiskerChart(**data)
+    if chart_type == ChartType.SUPERCHART:
+        return SuperChart(**data)
+    return Chart(**data)
+
+
+def _chart_type(value: Any) -> ChartType:
+    try:
+        return ChartType(value)
+    except ValueError:
+        return ChartType.UNKNOWN
+
+
+def _scale_type(value: Any) -> ScaleType:
+    try:
+        return ScaleType(value)
+    except ValueError:
+        return ScaleType.UNKNOWN

watasu_code_interpreter-0.1.47/src/watasu_code_interpreter/code_interpreter_async.py

@@ -0,0 +1,3 @@
+from .main import AsyncSandbox
+
+__all__ = ["AsyncSandbox"]

watasu_code_interpreter-0.1.47/src/watasu_code_interpreter/code_interpreter_sync.py

@@ -0,0 +1,3 @@
+from .main import Sandbox
+
+__all__ = ["Sandbox"]

watasu_code_interpreter-0.1.47/src/watasu_code_interpreter/constants.py

@@ -0,0 +1,5 @@
+DEFAULT_TEMPLATE = "code-interpreter"
+JUPYTER_PORT = 49999
+DEFAULT_TIMEOUT = 300
+
+__all__ = ["DEFAULT_TEMPLATE", "DEFAULT_TIMEOUT", "JUPYTER_PORT"]

watasu_code_interpreter-0.1.47/src/watasu_code_interpreter/exceptions.py

@@ -0,0 +1,18 @@
+from watasu import TimeoutException
+
+
+def format_request_timeout_error() -> Exception:
+    """Build the standard request-timeout exception."""
+    return TimeoutException(
+        "Request timed out - the 'request_timeout' option can be used to increase this timeout"
+    )
+
+
+def format_execution_timeout_error() -> Exception:
+    """Build the standard code-execution-timeout exception."""
+    return TimeoutException(
+        "Execution timed out - the 'timeout' option can be used to increase this timeout"
+    )
+
+
+__all__ = ["format_execution_timeout_error", "format_request_timeout_error"]

watasu_code_interpreter-0.1.47/src/watasu_code_interpreter/main.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Callable, Dict, List, Optional, Union
+from urllib.parse import quote
+
+from watasu.connection_config import ApiParams
+from watasu.exceptions import InvalidArgumentException
+from watasu.sandbox_async.main import AsyncSandbox as BaseAsyncSandbox
+from watasu.sandbox_async.main import _AsyncDualMethod, _thread_callback
+from watasu.sandbox_sync.main import Sandbox as BaseSandbox
+
+from .constants import DEFAULT_TEMPLATE
+from .models import Context, Execution, ExecutionError, OutputMessage, Result
+from .models import context_from_api
+from .models import execution_from_api
+
+
+class Sandbox(BaseSandbox):
+    """Sandbox specialized for running Python code."""
+
+    default_template = DEFAULT_TEMPLATE
+
+    def run_code(
+        self,
+        code: str,
+        language: Optional[str] = None,
+        context: Optional[Union[Context, str]] = None,
+        on_stdout: Optional[Callable[[OutputMessage], None]] = None,
+        on_stderr: Optional[Callable[[OutputMessage], None]] = None,
+        on_result: Optional[Callable[[Result], None]] = None,
+        on_error: Optional[Callable[[ExecutionError], None]] = None,
+        envs: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None,
+        request_timeout: Optional[float] = None,
+    ) -> Execution:
+        """Run Python code in the sandbox and return structured execution output."""
+
+        if not isinstance(code, str):
+            raise InvalidArgumentException("code must be a string")
+        if language is not None and context is not None:
+            raise InvalidArgumentException("language and context cannot both be set")
+
+        payload = _compact(
+            {
+                "code": code,
+                "language": language,
+                "context_id": _context_id(context),
+                "env_vars": envs,
+                "timeout_seconds": timeout,
+            }
+        )
+        response = self._require_data_plane().post_json(
+            "/runtime/v1/code/run",
+            json=payload,
+            request_timeout=request_timeout,
+        )
+        execution = execution_from_api(response)
+        _emit_callbacks(execution, on_stdout, on_stderr, on_result, on_error)
+        return execution
+
+    def create_code_context(
+        self,
+        cwd: Optional[str] = None,
+        language: Optional[str] = None,
+        request_timeout: Optional[float] = None,
+    ) -> Context:
+        """Create a persistent code context."""
+
+        payload = _compact({"cwd": cwd, "language": language})
+        response = self._require_data_plane().post_json(
+            "/runtime/v1/code/contexts",
+            json=payload,
+            request_timeout=request_timeout,
+        )
+        return context_from_api(response)
+
+    def remove_code_context(
+        self,
+        context: Union[Context, str],
+        request_timeout: Optional[float] = None,
+    ) -> None:
+        """Remove a persistent code context."""
+
+        self._require_data_plane().delete_json(
+            f"/runtime/v1/code/contexts/{_context_path_id(context)}",
+            request_timeout=request_timeout,
+        )
+
+    def list_code_contexts(self, request_timeout: Optional[float] = None) -> List[Context]:
+        """List persistent code contexts."""
+
+        response = self._require_data_plane().get_json(
+            "/runtime/v1/code/contexts",
+            request_timeout=request_timeout,
+        )
+        contexts = response if isinstance(response, list) else response.get("contexts", [])
+        return [context_from_api(item) for item in contexts]
+
+    def restart_code_context(
+        self,
+        context: Union[Context, str],
+        request_timeout: Optional[float] = None,
+    ) -> None:
+        """Restart a persistent code context."""
+
+        self._require_data_plane().post_json(
+            f"/runtime/v1/code/contexts/{_context_path_id(context)}/restart",
+            json={},
+            request_timeout=request_timeout,
+        )
+
+
+class AsyncSandbox(BaseAsyncSandbox):
+    """Async sandbox specialized for running Python code."""
+
+    default_template = Sandbox.default_template
+
+    @classmethod
+    async def create(cls, *args: Any, **kwargs: Any) -> "AsyncSandbox":
+        """Create a code-interpreter sandbox and return async helpers."""
+
+        return cls(sync_sandbox=await asyncio.to_thread(Sandbox.create, *args, **kwargs))
+
+    beta_create = create
+
+    async def _connect_instance(
+        self, timeout: Optional[int] = None, **opts: ApiParams
+    ) -> "AsyncSandbox":
+        """Reconnect this sandbox and refresh its data-plane session."""
+
+        await asyncio.to_thread(self._sync.connect, timeout=timeout, **opts)
+        self._set_sync(self._sync)
+        return self
+
+    @classmethod
+    async def _connect_class(
+        cls, sandbox_id: str, timeout: Optional[int] = None, **opts: ApiParams
+    ) -> "AsyncSandbox":
+        """Connect to an existing code-interpreter sandbox by id."""
+
+        return cls(
+            sync_sandbox=await asyncio.to_thread(
+                Sandbox.connect, sandbox_id, timeout=timeout, **opts
+            )
+        )
+
+    connect = _AsyncDualMethod(_connect_instance, _connect_class)
+
+    async def run_code(
+        self,
+        code: str,
+        language: Optional[str] = None,
+        context: Optional[Union[Context, str]] = None,
+        on_stdout: Optional[Callable[[OutputMessage], None]] = None,
+        on_stderr: Optional[Callable[[OutputMessage], None]] = None,
+        on_result: Optional[Callable[[Result], None]] = None,
+        on_error: Optional[Callable[[ExecutionError], None]] = None,
+        envs: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None,
+        request_timeout: Optional[float] = None,
+    ) -> Execution:
+        """Run Python code in the sandbox and return structured execution output."""
+
+        loop = asyncio.get_running_loop()
+        return await asyncio.to_thread(
+            self._sync.run_code,
+            code,
+            language=language,
+            context=context,
+            on_stdout=_thread_callback(loop, on_stdout),
+            on_stderr=_thread_callback(loop, on_stderr),
+            on_result=_thread_callback(loop, on_result),
+            on_error=_thread_callback(loop, on_error),
+            envs=envs,
+            timeout=timeout,
+            request_timeout=request_timeout,
+        )
+
+    async def create_code_context(
+        self,
+        cwd: Optional[str] = None,
+        language: Optional[str] = None,
+        request_timeout: Optional[float] = None,
+    ) -> Context:
+        """Create a persistent code context."""
+
+        return await asyncio.to_thread(
+            self._sync.create_code_context,
+            cwd=cwd,
+            language=language,
+            request_timeout=request_timeout,
+        )
+
+    async def remove_code_context(
+        self,
+        context: Union[Context, str],
+        request_timeout: Optional[float] = None,
+    ) -> None:
+        """Remove a persistent code context."""
+
+        await asyncio.to_thread(
+            self._sync.remove_code_context,
+            context,
+            request_timeout=request_timeout,
+        )
+
+    async def list_code_contexts(
+        self, request_timeout: Optional[float] = None
+    ) -> List[Context]:
+        """List persistent code contexts."""
+
+        return await asyncio.to_thread(
+            self._sync.list_code_contexts,
+            request_timeout=request_timeout,
+        )
+
+    async def restart_code_context(
+        self,
+        context: Union[Context, str],
+        request_timeout: Optional[float] = None,
+    ) -> None:
+        """Restart a persistent code context."""
+
+        await asyncio.to_thread(
+            self._sync.restart_code_context,
+            context,
+            request_timeout=request_timeout,
+        )
+
+
+def _emit_callbacks(
+    execution: Execution,
+    on_stdout: Optional[Callable[[OutputMessage], None]],
+    on_stderr: Optional[Callable[[OutputMessage], None]],
+    on_result: Optional[Callable[[Result], None]],
+    on_error: Optional[Callable[[ExecutionError], None]],
+) -> None:
+    for message in execution.logs.stdout:
+        if on_stdout is not None:
+            on_stdout(message)
+    for message in execution.logs.stderr:
+        if on_stderr is not None:
+            on_stderr(message)
+    for result in execution.results:
+        if on_result is not None:
+            on_result(result)
+    if execution.error is not None and on_error is not None:
+        on_error(execution.error)
+
+
+def _context_id(context: Optional[Union[Context, str]]) -> Optional[str]:
+    if context is None:
+        return None
+    return _context_id_required(context)
+
+
+def _context_id_required(context: Union[Context, str]) -> str:
+    if isinstance(context, str):
+        context_id = context
+    elif isinstance(context, dict):
+        value = context.get("id")
+        context_id = str(value) if value is not None else ""
+    else:
+        value = getattr(context, "id", None)
+        context_id = str(value) if value is not None else ""
+
+    if not context_id:
+        raise InvalidArgumentException("context id is required")
+    return context_id
+
+
+def _context_path_id(context: Union[Context, str]) -> str:
+    return quote(_context_id_required(context), safe="")
+
+
+def _compact(payload: Dict[str, Any]) -> Dict[str, Any]:
+    return {key: value for key, value in payload.items() if value is not None}
+
+
+__all__ = [
+    "AsyncSandbox",
+    "Context",
+    "Execution",
+    "ExecutionError",
+    "OutputMessage",
+    "Result",
+    "Sandbox",
+]

watasu_code_interpreter-0.1.47/src/watasu_code_interpreter/models.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, TypeVar
+
+from .charts import ChartTypes, _deserialize_chart
+
+T = TypeVar("T")
+OutputHandler = Callable[[T], Any]
+
+
+class MIMEType(str):
+    """MIME type marker used by code execution results."""
+
+
+@dataclass
+class OutputMessage:
+    """One stdout or stderr line emitted by code execution."""
+
+    line: str
+    timestamp: float = field(default_factory=time.time)
+    error: bool = False
+
+    def __str__(self) -> str:
+        return self.line
+
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            "line": self.line,
+            "timestamp": self.timestamp,
+            "error": self.error,
+        }
+
+
+@dataclass
+class Logs:
+    """Captured stdout and stderr output for an execution."""
+
+    stdout: List[OutputMessage] = field(default_factory=list)
+    stderr: List[OutputMessage] = field(default_factory=list)
+
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            "stdout": [message.to_json() for message in self.stdout],
+            "stderr": [message.to_json() for message in self.stderr],
+        }
+
+
+@dataclass
+class ExecutionError:
+    """Structured exception raised by user code inside the sandbox."""
+
+    name: str
+    value: str
+    traceback: str
+
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "value": self.value,
+            "traceback": self.traceback,
+        }
+
+
+@dataclass
+class Result:
+    """Rich result produced by the last expression of a code execution."""
+
+    text: Optional[str] = None
+    html: Optional[str] = None
+    markdown: Optional[str] = None
+    svg: Optional[str] = None
+    png: Optional[str] = None
+    jpeg: Optional[str] = None
+    pdf: Optional[str] = None
+    latex: Optional[str] = None
+    json: Any = None
+    javascript: Optional[str] = None
+    data: Any = None
+    chart: Optional[ChartTypes] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+    is_main_result: bool = False
+
+    def __post_init__(self) -> None:
+        if isinstance(self.chart, dict):
+            self.chart = _deserialize_chart(self.chart)
+
+    def __getitem__(self, item):
+        return getattr(self, item)
+
+    def formats(self) -> List[str]:
+        """Return available display formats for this result."""
+
+        names = [
+            "text",
+            "html",
+            "markdown",
+            "svg",
+            "png",
+            "jpeg",
+            "pdf",
+            "latex",
+            "json",
+            "javascript",
+            "data",
+            "chart",
+        ]
+        formats = [name for name in names if getattr(self, name) is not None]
+        if self.extra:
+            formats.extend(self.extra)
+        return formats
+
+    def to_json(self) -> Dict[str, Any]:
+        payload = {
+            "text": self.text,
+            "html": self.html,
+            "markdown": self.markdown,
+            "svg": self.svg,
+            "png": self.png,
+            "jpeg": self.jpeg,
+            "pdf": self.pdf,
+            "latex": self.latex,
+            "json": self.json,
+            "javascript": self.javascript,
+            "data": self.data,
+            "chart": self.chart,
+            "extra": self.extra,
+            "is_main_result": self.is_main_result,
+        }
+        return {key: value for key, value in payload.items() if value is not None}
+
+    def __repr__(self) -> str:
+        if self.text:
+            return f"Result({self.text})"
+        return "Result(Formats: " + ", ".join(self.formats()) + ")"
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def _repr_html_(self) -> Optional[str]:
+        return self.html
+
+    def _repr_markdown_(self) -> Optional[str]:
+        return self.markdown
+
+    def _repr_svg_(self) -> Optional[str]:
+        return self.svg
+
+    def _repr_png_(self) -> Optional[str]:
+        return self.png
+
+    def _repr_jpeg_(self) -> Optional[str]:
+        return self.jpeg
+
+    def _repr_pdf_(self) -> Optional[str]:
+        return self.pdf
+
+    def _repr_latex_(self) -> Optional[str]:
+        return self.latex
+
+
+@dataclass
+class Execution:
+    """Complete result of a sandbox code execution."""
+
+    results: List[Result] = field(default_factory=list)
+    logs: Logs = field(default_factory=Logs)
+    error: Optional[ExecutionError] = None
+    execution_count: Optional[int] = None
+
+    @property
+    def text(self) -> Optional[str]:
+        """Text for the main result, when code produced one."""
+
+        for result in self.results:
+            if result.is_main_result and result.text is not None:
+                return result.text
+        for result in self.results:
+            if result.text is not None:
+                return result.text
+        return None
+
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            "results": [result.to_json() for result in self.results],
+            "logs": self.logs.to_json(),
+            "error": self.error.to_json() if self.error else None,
+            "execution_count": self.execution_count,
+        }
+
+
+@dataclass(init=False)
+class Context:
+    """Code execution context metadata."""
+
+    id: str
+    language: Optional[str] = None
+    cwd: Optional[str] = None
+
+    def __init__(
+        self,
+        id: Optional[str] = None,
+        language: Optional[str] = None,
+        cwd: Optional[str] = None,
+        context_id: Optional[str] = None,
+        **_: Any,
+    ) -> None:
+        self.id = str(context_id if context_id is not None else id)
+        self.language = language
+        self.cwd = cwd
+
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "language": self.language,
+            "cwd": self.cwd,
+        }
+
+
+def execution_from_api(payload: Dict[str, Any]) -> Execution:
+    execution = payload.get("execution") or payload
+    logs = execution.get("logs") or {}
+    return Execution(
+        results=[result_from_api(item) for item in execution.get("results") or []],
+        logs=Logs(
+            stdout=[
+                output_message_from_api(item, error=False)
+                for item in logs.get("stdout") or []
+            ],
+            stderr=[
+                output_message_from_api(item, error=True)
+                for item in logs.get("stderr") or []
+            ],
+        ),
+        error=error_from_api(execution.get("error")),
+        execution_count=execution.get("execution_count"),
+    )
+
+
+def context_from_api(payload: Dict[str, Any]) -> Context:
+    return Context(
+        id=payload.get("id"),
+        language=payload.get("language"),
+        cwd=payload.get("cwd"),
+    )
+
+
+def result_from_api(payload: Dict[str, Any]) -> Result:
+    known = {
+        "text",
+        "html",
+        "markdown",
+        "svg",
+        "png",
+        "jpeg",
+        "pdf",
+        "latex",
+        "json",
+        "javascript",
+        "data",
+        "chart",
+        "extra",
+        "is_main_result",
+    }
+    return Result(
+        text=payload.get("text"),
+        html=payload.get("html"),
+        markdown=payload.get("markdown"),
+        svg=payload.get("svg"),
+        png=payload.get("png"),
+        jpeg=payload.get("jpeg"),
+        pdf=payload.get("pdf"),
+        latex=payload.get("latex"),
+        json=payload.get("json"),
+        javascript=payload.get("javascript"),
+        data=payload.get("data"),
+        chart=_deserialize_chart(payload.get("chart")),
+        extra=payload.get("extra") or {
+            key: value for key, value in payload.items() if key not in known
+        },
+        is_main_result=bool(payload.get("is_main_result")),
+    )
+
+
+def output_message_from_api(payload: Any, error: bool) -> OutputMessage:
+    if isinstance(payload, dict):
+        return OutputMessage(
+            line=str(payload.get("line", "")),
+            timestamp=float(payload.get("timestamp") or time.time()),
+            error=bool(payload.get("error", error)),
+        )
+    return OutputMessage(line=str(payload), error=error)
+
+
+def error_from_api(payload: Any) -> Optional[ExecutionError]:
+    if not isinstance(payload, dict):
+        return None
+    return ExecutionError(
+        name=str(payload.get("name") or ""),
+        value=str(payload.get("value") or ""),
+        traceback=str(payload.get("traceback") or ""),
+    )

watasu_code_interpreter-0.1.47/src/watasu_code_interpreter/py.typed

@@ -0,0 +1 @@
+