scalebox-sdk 0.1.0__py3-none-any.whl

scalebox/client/client.py

@@ -0,0 +1,102 @@
+import os
+import sys
+
+from utils.httpxclient import HTTPXClient
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "generated"))
+
+import asyncio
+
+import httpx
+from generated import api_pb2
+from generated.api_pb2_connect import AsyncFilesystemClient
+
+
+# 自定义 HTTP 客户端适配器
+class CustomHTTPClient:
+    def __init__(self):
+        self.client = httpx.Client()
+
+    def request(self, method, url, headers, content, timeout, extensions):
+        # 移除可能导致问题的参数或调整调用方式
+        # 根据 ConnectRPC 的实际需求调整
+        try:
+            response = self.client.request(
+                method=method,
+                url=url,
+                headers=headers,
+                content=content,
+                timeout=timeout,
+            )
+            return response
+        except TypeError as e:
+            # 如果仍然有参数问题，尝试不同的调用方式
+            if "unexpected keyword argument" in str(e):
+                # 移除有问题的参数
+                kwargs = {
+                    "method": method,
+                    "url": url,
+                    "headers": headers,
+                    "content": content,
+                    "timeout": timeout,
+                }
+                # 移除可能引起问题的参数
+                if "body" in str(e):
+                    kwargs.pop("content", None)
+
+                response = self.client.request(**kwargs)
+                return response
+            raise
+
+
+async def main():
+    # 创建客户端
+    client = AsyncFilesystemClient(
+        base_url="http://localhost:8080", http_client=HTTPXClient
+    )
+
+    # 调用服务器流式方法
+    # extra = {"Authorization": "Bearer root","Transfer-Encoding":"chunked",
+    #          "Keepalive-Ping-Interval":1000}
+    extra = {"Authorization": "Bearer root"}
+    # resp=fs_cli.stat(api_pb2.StatRequest(path="/root/Dockerfile"),extra_headers=extra)
+    # print(resp)
+    # print(resp.entry)
+    # stream = fs_cli.watch_dir(api_pb2.WatchDirRequest(path="/root"), extra_headers=extra)
+    # request = RequestType(your_field="value")
+
+    # 处理流式响应
+    async for response in client.watch_dir(
+        api_pb2.WatchDirRequest(path="/root"), extra_headers=extra
+    ):
+        print(f"Received: {response}")
+        # 处理每个响应项
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+# print("Available protocol options:")
+# print(f"CONNECT_PROTOBUF: {ConnectProtocol.CONNECT_PROTOBUF}")
+# print(f"CONNECT_JSON: {ConnectProtocol.CONNECT_JSON}")
+# # print(f"GRPC_PROTOBUF: {ConnectProtocol.GRPC_PROTOBUF}")
+# # print(f"GRPC_JSON: {ConnectProtocol.GRPC_JSON}")
+# BASE = "http://localhost:8080"
+# # client = CustomHTTPClient()
+# fs_cli=FilesystemClient(base_url=BASE,protocol=ConnectProtocol.CONNECT_PROTOBUF)
+# # extra = {"Authorization": "Bearer root","Transfer-Encoding":"chunked",
+# #          "Keepalive-Ping-Interval":1000}
+# extra = {"Authorization": "Bearer root"}
+# # resp=fs_cli.stat(api_pb2.StatRequest(path="/root/Dockerfile"),extra_headers=extra)
+# # print(resp)
+# # print(resp.entry)
+# stream=fs_cli.watch_dir(api_pb2.WatchDirRequest(path="/root"),extra_headers=extra)
+# # 3. 消费流
+# print("-------------------------")
+# for resp in stream:
+#     # resp 就是 api_pb2.WatchDirResponse
+#     print(resp)
+#
+# # 4. 检查错误（可选）
+# if stream.error():
+#     raise stream.error()

scalebox/client/requirements.txt

@@ -0,0 +1,5 @@
+connect-python[protobuf]>=0.4.2
+protobuf>=4.21
+httpx>=0.24
+grpcio>=1.74.0
+grpcio-tools>=1.74.0

scalebox/code_interpreter/__init__.py

@@ -0,0 +1,12 @@
+from .code_interpreter_async import AsyncSandbox
+from .code_interpreter_sync import Sandbox
+from .models import (
+    Context,
+    Execution,
+    ExecutionError,
+    Logs,
+    MIMEType,
+    OutputHandler,
+    OutputMessage,
+    Result,
+)

scalebox/code_interpreter/charts.py

@@ -0,0 +1,230 @@
+import enum
+from typing import Any, List, Optional, Tuple, 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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        super().__init__(**kwargs)
+        self.elements = [BarData(**d) for d in kwargs["elements"]]
+
+
+class PieData:
+    label: str
+    angle: float
+    radius: float
+
+    def __init__(self, **kwargs) -> None:
+        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) -> None:
+        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) -> None:
+        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) -> None:
+        super().__init__(**kwargs)
+        self.elements = [BoxAndWhiskerData(**d) for d in kwargs["elements"]]
+
+
+class SuperChart(Chart):
+    type = ChartType.SUPERCHART
+
+    elements: List[
+        Union[LineChart, ScatterChart, BarChart, PieChart, BoxAndWhiskerChart]
+    ]
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.elements = [_deserialize_chart(g) for g in kwargs["elements"]]
+
+
+ChartTypes = Union[
+    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