watasu-code-interpreter 0.1.47__tar.gz → 0.1.49__tar.gz

{watasu_code_interpreter-0.1.47 → watasu_code_interpreter-0.1.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: watasu-code-interpreter
-Version: 0.1.47
+Version: 0.1.49
 Summary: Code Interpreter SDK for Watasu
 Project-URL: Repository, https://github.com/watasuio/sdk
 License-Expression: MIT OR Apache-2.0

{watasu_code_interpreter-0.1.47 → watasu_code_interpreter-0.1.49}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "watasu-code-interpreter"
-version = "0.1.47"
+version = "0.1.49"
 description = "Code Interpreter SDK for Watasu"
 readme = "README.md"
 requires-python = ">=3.9"

{watasu_code_interpreter-0.1.47 → watasu_code_interpreter-0.1.49}/src/watasu_code_interpreter/main.py

@@ -25,13 +25,13 @@ class Sandbox(BaseSandbox):
         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,
+        context: Optional[Context] = None,
+        on_stdout: Optional[Callable[[OutputMessage], Any]] = None,
+        on_stderr: Optional[Callable[[OutputMessage], Any]] = None,
+        on_result: Optional[Callable[[Result], Any]] = None,
+        on_error: Optional[Callable[[ExecutionError], Any]] = None,
         envs: Optional[Dict[str, str]] = None,
-        timeout: Optional[int] = None,
+        timeout: Optional[float] = None,
         request_timeout: Optional[float] = None,
     ) -> Execution:
         """Run Python code in the sandbox and return structured execution output."""
@@ -78,21 +78,18 @@ class Sandbox(BaseSandbox):
     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]:
+    def list_code_contexts(self) -> 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]
@@ -100,14 +97,12 @@ class Sandbox(BaseSandbox):
     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,
         )
 
 
@@ -151,13 +146,13 @@ class AsyncSandbox(BaseAsyncSandbox):
         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,
+        context: Optional[Context] = None,
+        on_stdout: Optional[Callable[[OutputMessage], Any]] = None,
+        on_stderr: Optional[Callable[[OutputMessage], Any]] = None,
+        on_result: Optional[Callable[[Result], Any]] = None,
+        on_error: Optional[Callable[[ExecutionError], Any]] = None,
         envs: Optional[Dict[str, str]] = None,
-        timeout: Optional[int] = None,
+        timeout: Optional[float] = None,
         request_timeout: Optional[float] = None,
     ) -> Execution:
         """Run Python code in the sandbox and return structured execution output."""
@@ -195,46 +190,39 @@ class AsyncSandbox(BaseAsyncSandbox):
     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]:
+    async def list_code_contexts(self) -> 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]],
+    on_stdout: Optional[Callable[[OutputMessage], Any]],
+    on_stderr: Optional[Callable[[OutputMessage], Any]],
+    on_result: Optional[Callable[[Result], Any]],
+    on_error: Optional[Callable[[ExecutionError], Any]],
 ) -> None:
     for message in execution.logs.stdout:
         if on_stdout is not None:

{watasu_code_interpreter-0.1.47 → watasu_code_interpreter-0.1.49}/src/watasu_code_interpreter/models.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json as jsonlib
 import time
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, List, Optional, TypeVar
@@ -25,12 +26,12 @@ class OutputMessage:
     def __str__(self) -> str:
         return self.line
 
-    def to_json(self) -> Dict[str, Any]:
-        return {
+    def to_json(self) -> str:
+        return jsonlib.dumps({
             "line": self.line,
             "timestamp": self.timestamp,
             "error": self.error,
-        }
+        })
 
 
 @dataclass
@@ -40,11 +41,11 @@ class Logs:
     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],
-        }
+    def to_json(self) -> str:
+        return jsonlib.dumps({
+            "stdout": [_message_line(message) for message in self.stdout],
+            "stderr": [_message_line(message) for message in self.stderr],
+        })
 
 
 @dataclass
@@ -55,12 +56,12 @@ class ExecutionError:
     value: str
     traceback: str
 
-    def to_json(self) -> Dict[str, Any]:
-        return {
+    def to_json(self) -> str:
+        return jsonlib.dumps({
             "name": self.name,
             "value": self.value,
             "traceback": self.traceback,
-        }
+        })
 
 
 @dataclass
@@ -181,13 +182,12 @@ class Execution:
                 return result.text
         return None
 
-    def to_json(self) -> Dict[str, Any]:
-        return {
-            "results": [result.to_json() for result in self.results],
+    def to_json(self) -> str:
+        return jsonlib.dumps({
+            "results": serialize_results(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)
@@ -217,6 +217,32 @@ class Context:
             "cwd": self.cwd,
         }
 
+    @classmethod
+    def from_json(cls, data: Dict[str, str]):
+        return cls(
+            context_id=data.get("id"),
+            language=data.get("language"),
+            cwd=data.get("cwd"),
+        )
+
+
+def serialize_results(results: List[Result]) -> List[Dict[str, Any]]:
+    serialized = []
+    for result in results:
+        item = {}
+        for key in result.formats():
+            if key == "chart" and result.chart is not None:
+                item[key] = result.chart.to_dict()
+            else:
+                item[key] = result[key]
+        item["text"] = result.text
+        serialized.append(item)
+    return serialized
+
+
+def _message_line(message: Any) -> str:
+    return str(message.line) if hasattr(message, "line") else str(message)
+
 
 def execution_from_api(payload: Dict[str, Any]) -> Execution:
     execution = payload.get("execution") or payload