dify-sandbox 1.0.0__py3-none-any.whl

dify_sandbox/__init__.py

@@ -0,0 +1,22 @@
+"""
+Dify Sandbox Python SDK
+
+A Python SDK for interacting with the Dify Sandbox API.
+"""
+
+from .client import DifySandboxClient
+from .models import (
+    DifySandboxResponse,
+    RunCodeResponse,
+    UploadFileResponse,
+    DependencyInfo,
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    "DifySandboxClient",
+    "DifySandboxResponse",
+    "RunCodeResponse",
+    "UploadFileResponse",
+    "DependencyInfo",
+]

dify_sandbox/client.py

@@ -0,0 +1,410 @@
+"""
+Dify Sandbox SDK - Main Client
+
+This module provides the main client for interacting with the Dify Sandbox API.
+"""
+
+import os
+from typing import Optional, Union, BinaryIO
+import requests
+
+from .models import (
+    DifySandboxResponse,
+    RunCodeResponse,
+    RunCommandResponse,
+    UploadFileResponse,
+    DependencyInfo,
+)
+
+
+class DifySandboxClient:
+    """
+    Client for interacting with Dify Sandbox API.
+    
+    Example:
+        client = DifySandboxClient(
+            base_url="http://localhost:8194",
+            api_key="dify-sandbox"
+        )
+        
+        # Run Python code
+        result = client.run_python("print('Hello, World!')")
+        print(result.stdout)
+        
+        # Upload a file
+        with open("test.txt", "rb") as f:
+            upload_result = client.upload_file(f, "test.txt")
+        
+        # Download a file
+        content = client.download_file(upload_result.data.filename)
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:8194",
+        api_key: str = "dify-sandbox",
+        timeout: int = 30,
+    ):
+        """
+        Initialize the Dify Sandbox client.
+        
+        Args:
+            base_url: Base URL of the Dify Sandbox server
+            api_key: API key for authentication (X-Api-Key header)
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self.session = requests.Session()
+        self.session.headers.update({"X-Api-Key": self.api_key})
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        json: Optional[dict] = None,
+        files: Optional[dict] = None,
+        stream: bool = False,
+    ) -> requests.Response:
+        """
+        Make an HTTP request to the API.
+        
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            path: API path (will be appended to base_url)
+            json: JSON data to send
+            files: Files to upload
+            stream: Whether to stream the response
+            
+        Returns:
+            requests.Response object
+            
+        Raises:
+            requests.HTTPError: If the request fails
+        """
+        url = f"{self.base_url}{path}"
+        response = self.session.request(
+            method=method,
+            url=url,
+            json=json,
+            files=files,
+            timeout=self.timeout,
+            stream=stream,
+        )
+        response.raise_for_status()
+        return response
+
+    def health_check(self) -> bool:
+        """
+        Check if the sandbox server is healthy.
+        
+        Returns:
+            True if server is healthy, False otherwise
+        """
+        try:
+            response = self._request("GET", "/health")
+            return response.status_code == 200
+        except requests.RequestException:
+            return False
+
+    def run_python(
+        self,
+        code: str,
+        preload: str = "",
+        enable_network: bool = False,
+    ) -> RunCodeResponse:
+        """
+        Run Python code in the sandbox.
+        
+        Args:
+            code: Python code to execute
+            preload: Optional preload code to run before main code
+            enable_network: Whether to enable network access
+            
+        Returns:
+            RunCodeResponse with execution results
+        """
+        return self._run_code("python3", code, preload, enable_network)
+
+    def run_nodejs(
+        self,
+        code: str,
+        preload: str = "",
+        enable_network: bool = False,
+    ) -> RunCodeResponse:
+        """
+        Run Node.js code in the sandbox.
+        
+        Args:
+            code: Node.js code to execute
+            preload: Optional preload code to run before main code
+            enable_network: Whether to enable network access
+            
+        Returns:
+            RunCodeResponse with execution results
+        """
+        return self._run_code("nodejs", code, preload, enable_network)
+
+    def _run_code(
+        self,
+        language: str,
+        code: str,
+        preload: str,
+        enable_network: bool,
+    ) -> RunCodeResponse:
+        """
+        Internal method to run code in the sandbox.
+        
+        Args:
+            language: Programming language ("python3" or "nodejs")
+            code: Code to execute
+            preload: Preload code
+            enable_network: Enable network access
+            
+        Returns:
+            RunCodeResponse with execution results
+        """
+        payload = {
+            "language": language,
+            "code": code,
+            "preload": preload,
+            "enable_network": enable_network,
+        }
+        response = self._request("POST", "/v1/sandbox/run", json=payload)
+        result = DifySandboxResponse.from_dict(response.json())
+        
+        if not result.is_success:
+            raise Exception(f"API error: {result.message}")
+        
+        return RunCodeResponse.from_dict(result.data)
+
+    def get_dependencies(self, language: str = "python3") -> DependencyInfo:
+        """
+        Get list of installed dependencies.
+        
+        Args:
+            language: Programming language ("python3" or "nodejs")
+            
+        Returns:
+            DependencyInfo with list of dependencies
+        """
+        response = self._request(
+            "GET", "/v1/sandbox/dependencies", json={"language": language}
+        )
+        result = DifySandboxResponse.from_dict(response.json())
+        
+        if not result.is_success:
+            raise Exception(f"API error: {result.message}")
+        
+        return DependencyInfo.from_dict(result.data)
+
+    def update_dependencies(self, language: str = "python3") -> DifySandboxResponse:
+        """
+        Update dependencies for the specified language.
+        
+        Args:
+            language: Programming language ("python3" or "nodejs")
+            
+        Returns:
+            DifySandboxResponse with update result
+        """
+        response = self._request(
+            "POST", "/v1/sandbox/dependencies/update", json={"language": language}
+        )
+        result = DifySandboxResponse.from_dict(response.json())
+        
+        if not result.is_success:
+            raise Exception(f"API error: {result.message}")
+        
+        return result
+
+    def refresh_dependencies(self, language: str = "python3") -> DifySandboxResponse:
+        """
+        Refresh dependencies for the specified language.
+        
+        Args:
+            language: Programming language ("python3" or "nodejs")
+            
+        Returns:
+            DifySandboxResponse with refresh result
+        """
+        response = self._request(
+            "GET", "/v1/sandbox/dependencies/refresh", json={"language": language}
+        )
+        result = DifySandboxResponse.from_dict(response.json())
+        
+        if not result.is_success:
+            raise Exception(f"API error: {result.message}")
+        
+        return result
+
+    def upload_file(
+        self,
+        file: Union[BinaryIO, str],
+        filename: Optional[str] = None,
+    ) -> UploadFileResponse:
+        """
+        Upload a file to the sandbox.
+        
+        Args:
+            file: File object or file path to upload
+            filename: Optional filename (required if file is a file object)
+            
+        Returns:
+            UploadFileResponse with uploaded file info
+            
+        Example:
+            # Upload from file path
+            result = client.upload_file("/path/to/file.txt")
+            
+            # Upload from file object
+            with open("file.txt", "rb") as f:
+                result = client.upload_file(f, "file.txt")
+        """
+        if isinstance(file, str):
+            # file is a path
+            if not os.path.exists(file):
+                raise FileNotFoundError(f"File not found: {file}")
+            
+            if filename is None:
+                filename = os.path.basename(file)
+            
+            with open(file, "rb") as f:
+                return self._upload_file_object(f, filename)
+        else:
+            # file is a file object
+            if filename is None:
+                raise ValueError("filename is required when file is a file object")
+            return self._upload_file_object(file, filename)
+
+    def _upload_file_object(
+        self,
+        file: BinaryIO,
+        filename: str,
+    ) -> UploadFileResponse:
+        """
+        Internal method to upload a file object.
+        
+        Args:
+            file: File object to upload
+            filename: Name of the file
+            
+        Returns:
+            UploadFileResponse with uploaded file info
+        """
+        files = {"file": (filename, file)}
+        response = self._request("POST", "/v1/sandbox/file/upload", files=files)
+        result = DifySandboxResponse.from_dict(response.json())
+        
+        if not result.is_success:
+            raise Exception(f"API error: {result.message}")
+        
+        return UploadFileResponse.from_dict(result.data)
+
+    def download_file(
+        self,
+        filename: str,
+        save_path: Optional[str] = None,
+    ) -> Union[bytes, str]:
+        """
+        Download a file from the sandbox.
+        
+        Args:
+            filename: Name of the file to download
+            save_path: Optional path to save the file. If not provided, returns bytes.
+            
+        Returns:
+            File content as bytes if save_path is None, otherwise the save_path
+            
+        Example:
+            # Download to bytes
+            content = client.download_file("uploaded_file.txt")
+            
+            # Download to file
+            client.download_file("uploaded_file.txt", "downloaded.txt")
+        """
+        payload = {"filename": filename}
+        response = self._request(
+            "POST", "/v1/sandbox/file/download", json=payload, stream=True
+        )
+        
+        if save_path:
+            with open(save_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            return save_path
+        else:
+            return response.content
+
+    def delete_file(self, filename: str) -> DifySandboxResponse:
+        """
+        Delete a file from the sandbox.
+
+        Args:
+            filename: Name of the file to delete
+
+        Returns:
+            DifySandboxResponse with deletion result
+
+        Example:
+            client.delete_file("uploaded_file.txt")
+        """
+        payload = {"filename": filename}
+        response = self._request("POST", "/v1/sandbox/file/delete", json=payload)
+        result = DifySandboxResponse.from_dict(response.json())
+
+        if not result.is_success:
+            raise Exception(f"API error: {result.message}")
+
+        return result
+
+    def run_command(
+        self,
+        command: str,
+        args: Optional[list] = None,
+        work_dir: str = "",
+        timeout: int = 0,
+        enable_network: bool = False,
+    ) -> RunCommandResponse:
+        """
+        Run a sandbox-approved binary against a previously uploaded file.
+
+        The command basename is matched against the deny-list exposed by the
+        sandbox (shells, rm, sudo, package managers, ...). Any
+        argument that looks like a shell metacharacter is rejected so the
+        request cannot accidentally invoke a shell.
+
+        Args:
+            command: Command basename to execute, e.g. "python3".
+            args: Arguments to pass to the command (each must be
+                shell-metachar free).
+            work_dir: Working directory, relative to the sandbox upload
+                directory. Empty means the upload directory itself.
+            timeout: Optional per-request timeout in seconds. 0 means
+                use the sandbox-wide worker timeout.
+            enable_network: Forwarded to the sandbox only when the sandbox
+                itself was started with network access enabled.
+
+        Returns:
+            RunCommandResponse with execution results.
+
+        Example:
+            client.upload_file("hello.py")
+            result = client.run_command("python3", ["hello.py"])
+            print(result.stdout)
+        """
+        payload = {
+            "command": command,
+            "args": args or [],
+            "work_dir": work_dir,
+            "timeout": timeout,
+            "enable_network": enable_network,
+        }
+        response = self._request("POST", "/v1/sandbox/run/command", json=payload)
+        result = DifySandboxResponse.from_dict(response.json())
+
+        if not result.is_success:
+            raise Exception(f"API error: {result.message}")
+
+        return RunCommandResponse.from_dict(result.data)

dify_sandbox/models.py

@@ -0,0 +1,106 @@
+"""
+Dify Sandbox SDK - Data Models
+
+This module contains data models for the Dify Sandbox SDK.
+"""
+
+from dataclasses import dataclass
+from typing import Optional, Any, Dict
+
+
+@dataclass
+class DifySandboxResponse:
+    """Base response from Dify Sandbox API"""
+    code: int
+    message: str
+    data: Optional[Any] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DifySandboxResponse":
+        return cls(
+            code=data.get("code", -1),
+            message=data.get("message", ""),
+            data=data.get("data")
+        )
+
+    @property
+    def is_success(self) -> bool:
+        return self.code == 0
+
+
+@dataclass
+class RunCodeResponse:
+    """Response from code execution endpoint"""
+    stdout: str
+    stderr: str
+    error: str
+    exit_code: int
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "RunCodeResponse":
+        return cls(
+            stdout=data.get("stdout", ""),
+            stderr=data.get("stderr", ""),
+            error=data.get("error", ""),
+            exit_code=data.get("exit_code", -1)
+        )
+
+    @property
+    def is_success(self) -> bool:
+        return self.exit_code == 0 and not self.error
+
+
+@dataclass
+class RunCommandResponse:
+    """Response from the command execution endpoint.
+
+    Mirrors ``RunCodeResponse`` because both endpoints share the same
+    stdout/stderr/exit_code envelope. ``RunCommandResponse`` exists as a
+    separate type so callers can tell which endpoint produced the data
+    without inspecting the request URL.
+    """
+    stdout: str
+    stderr: str
+    error: str
+    exit_code: int
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "RunCommandResponse":
+        return cls(
+            stdout=data.get("stdout", ""),
+            stderr=data.get("stderr", ""),
+            error=data.get("error", ""),
+            exit_code=data.get("exit_code", -1),
+        )
+
+    @property
+    def is_success(self) -> bool:
+        return self.exit_code == 0 and not self.error
+
+
+@dataclass
+class UploadFileResponse:
+    """Response from file upload endpoint"""
+    filename: str
+    size: int
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "UploadFileResponse":
+        return cls(
+            filename=data.get("filename", ""),
+            size=data.get("size", 0)
+        )
+
+
+@dataclass
+class DependencyInfo:
+    """Information about installed dependencies"""
+    language: str
+    dependencies: list
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DependencyInfo":
+        return cls(
+            language=data.get("language", ""),
+            dependencies=data.get("dependencies", [])
+        )

dify_sandbox-1.0.0.dist-info/METADATA

@@ -0,0 +1,352 @@
+Metadata-Version: 2.4
+Name: dify-sandbox
+Version: 1.0.0
+Summary: Python SDK for Dify Sandbox API
+Home-page: https://github.com/langgenius/dify-sandbox
+Author: Dify
+Author-email: support@dify.ai
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.0; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: mypy>=0.900; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Dify Sandbox Python SDK
+
+Python SDK for interacting with the Dify Sandbox API.
+
+## Installation
+
+```bash
+pip install -e sdk/
+```
+
+Or install dependencies directly:
+
+```bash
+pip install requests
+```
+
+## Quick Start
+
+```python
+from dify_sandbox import DifySandboxClient
+
+# Initialize client
+client = DifySandboxClient(
+    base_url="http://localhost:8194",
+    api_key="your-api-key"
+)
+
+# Run Python code
+result = client.run_python("print('Hello from sandbox!')")
+print(result.stdout)  # Output: Hello from sandbox!
+
+# Run Node.js code
+result = client.run_nodejs("console.log('Hello from Node.js!')")
+print(result.stdout)  # Output: Hello from Node.js!
+
+# Upload a Python script and run it from the sandbox upload directory
+with open("hello.py", "rb") as f:
+    uploaded = client.upload_file(f, filename="hello.py")
+
+result = client.run_command(
+    command="python3",
+    args=[uploaded.filename],
+    timeout=30,
+)
+print(result.stdout)
+```
+
+## Features
+
+- **Code Execution**: Run Python and Node.js code in a secure sandbox
+- **Command Execution**: Launch sandbox-approved binaries (e.g. `python3`,
+  `node`) against previously uploaded files via the deny-list enforced
+  `POST /v1/sandbox/run/command` endpoint
+- **File Operations**: Upload and download files to/from the sandbox
+- **Dependency Management**: View and manage sandbox dependencies
+- **Health Check**: Monitor sandbox server status
+
+## API Reference
+
+### Client Initialization
+
+```python
+client = DifySandboxClient(
+    base_url="http://localhost:8194",  # Sandbox server URL
+    api_key="your-api-key",             # API key for authentication
+    timeout=30                          # Request timeout in seconds
+)
+```
+
+### Code Execution
+
+#### Run Python Code
+
+```python
+result = client.run_python(
+    code="print('Hello, World!')",
+    preload="",              # Optional: code to run before main code
+    enable_network=False     # Optional: enable network access
+)
+
+print(result.stdout)    # Standard output
+print(result.stderr)    # Standard error
+print(result.exit_code) # Exit code (0 = success)
+```
+
+#### Run Node.js Code
+
+```python
+result = client.run_nodejs(
+    code="console.log('Hello, World!')",
+    preload="",
+    enable_network=False
+)
+
+print(result.stdout)
+print(result.stderr)
+print(result.exit_code)
+```
+
+### Command Execution
+
+Run a sandbox-approved binary against a file that was previously uploaded
+to the sandbox via `upload_file`. The endpoint enforces a deny-list of
+dangerous commands (shells, `rm`, `sudo`, package managers, …) and rejects
+any argument containing shell metacharacters so the request can never
+accidentally spawn a shell.
+
+```python
+# 1. Upload the script you want to execute
+with open("hello.py", "rb") as f:
+    uploaded = client.upload_file(f, filename="hello.py")
+
+# 2. Invoke python3 with the uploaded file as an argument
+result = client.run_command(
+    command="python3",            # Command basename (resolved via PATH)
+    args=[uploaded.filename],     # Arguments; cannot contain shell metachars
+    work_dir="",                  # "" or "." → sandbox upload_dir; or a relative subdir
+    timeout=30,                   # 0 → use the sandbox worker timeout
+    enable_network=False,         # Must respect global enable_network setting
+)
+
+print(result.stdout)
+print(result.stderr)
+print(result.exit_code)
+```
+
+#### `work_dir` rules
+
+| Input                | Result                                                |
+|----------------------|-------------------------------------------------------|
+| `""` or `"."`        | Resolved to the sandbox `upload_dir` itself           |
+| `"scripts"`          | Resolved to `<upload_dir>/scripts`                    |
+| `<upload_dir>` (absolute) | Resolved to `upload_dir` itself                  |
+| `/etc`, `../etc`, …  | Rejected with `work_dir is invalid: ...`              |
+
+#### Deny-list
+
+The deny-list is the union of a built-in default (shells, `rm`, `sudo`,
+`apt`, `pip3`, `npm`, …) and the operator-configured
+`blocked_commands` list. User configuration can only add entries — never
+remove them. Commands that match the deny-list, or arguments containing
+shell metacharacters (`|`, `&`, `;`, `<`, `>`, `` ` ``, `$`, `*`, `?`,
+`{`, `}`, `~`, `!`, `#`, quotes, …) are rejected with a 400 before any
+process is spawned.
+
+### File Operations
+
+#### Upload File
+
+```python
+# Upload from file path
+result = client.upload_file("/path/to/file.txt")
+print(result.filename)  # Uploaded filename in sandbox
+print(result.size)      # File size in bytes
+
+# Upload from file object
+with open("local_file.txt", "rb") as f:
+    result = client.upload_file(f, filename="custom_name.txt")
+```
+
+#### Download File
+
+```python
+# Download to memory
+content = client.download_file("sandbox_file.txt")
+
+# Download to local file
+client.download_file("sandbox_file.txt", save_path="local_copy.txt")
+```
+
+### Dependency Management
+
+#### Get Dependencies
+
+```python
+deps = client.get_dependencies(language="python3")
+print(deps.dependencies)  # List of installed packages
+```
+
+#### Update Dependencies
+
+```python
+response = client.update_dependencies(language="python3")
+print(response.message)
+```
+
+#### Refresh Dependencies
+
+```python
+response = client.refresh_dependencies(language="python3")
+print(response.message)
+```
+
+### Health Check
+
+```python
+if client.health_check():
+    print("Sandbox is healthy")
+else:
+    print("Sandbox is not responding")
+```
+
+## Data Models
+
+### RunCodeResponse
+
+```python
+@dataclass
+class RunCodeResponse:
+    stdout: str      # Standard output from code execution
+    stderr: str      # Standard error from code execution
+    exit_code: int   # Exit code (0 = success)
+    error: str       # Sandbox-side error message (empty on success)
+```
+
+### RunCommandResponse
+
+```python
+@dataclass
+class RunCommandResponse:
+    stdout: str      # Standard output from the executed command
+    stderr: str      # Standard error from the executed command
+    exit_code: int   # Exit code (0 = success)
+    error: str       # Sandbox-side error message (empty on success)
+```
+
+### UploadFileResponse
+
+```python
+@dataclass
+class UploadFileResponse:
+    filename: str  # Filename in sandbox
+    size: int      # File size in bytes
+```
+
+### DependencyInfo
+
+```python
+@dataclass
+class DependencyInfo:
+    language: str       # Language (python3/nodejs)
+    dependencies: list  # List of dependencies
+```
+
+### DifySandboxResponse
+
+```python
+@dataclass
+class DifySandboxResponse:
+    code: int       # Response code (0 = success)
+    message: str    # Response message
+    data: Any       # Response data
+```
+
+## End-to-end Example: Upload a Script, Then Run It
+
+```python
+from dify_sandbox import DifySandboxClient
+
+client = DifySandboxClient(base_url="http://localhost:8194", api_key="dify-sandbox")
+
+# Local script we want to run inside the sandbox
+script = b"""
+import sys
+print("hello from the sandbox!")
+print("args:", sys.argv[1:])
+"""
+
+# 1. Upload the script — the server stores it in upload_dir and returns the
+#    filename it used (a UUID is appended to avoid collisions).
+with open("hello.py", "wb") as f:
+    f.write(script)
+
+uploaded = client.upload_file("hello.py")
+print("uploaded as:", uploaded.filename)
+
+# 2. Run python3 with the uploaded file as its argument.
+result = client.run_command(
+    command="python3",
+    args=[uploaded.filename],
+    timeout=10,
+)
+
+assert result.exit_code == 0, result.stderr
+print(result.stdout)
+```
+
+## Examples
+
+See the `examples/` directory for complete usage examples:
+
+- `basic_usage.py` - Basic code execution examples
+- `file_operations.py` - File upload and download examples
+- `dependency_management.py` - Dependency management examples
+- `command_execution.py` - Upload a script and run it through the deny-list-enforced `run_command` endpoint
+
+## Error Handling
+
+The SDK raises exceptions for API errors:
+
+```python
+try:
+    result = client.run_python("invalid code")
+except Exception as e:
+    print(f"Error: {e}")
+```
+
+`run_command` raises the same kind of exception when the deny-list rejects
+the command, when an argument contains shell metacharacters, or when the
+work directory is invalid — the exception message is the human-readable
+reason returned by the sandbox.
+
+## License
+
+MIT License

dify_sandbox-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+dify_sandbox/__init__.py,sha256=cT-RoMHZVYVSy72gMq9bDzEqM2_qmgAum1vJnxy3-1U,402
+dify_sandbox/client.py,sha256=UiLpaVCV7Lg02xE0xhPBYLXJXv1fQZ7y-RPqcknsfVY,12753
+dify_sandbox/models.py,sha256=Mb-Oi-mkx6El8R_6DF7VD2OiPI8iSvgNA93HSmb7LqA,2658
+dify_sandbox-1.0.0.dist-info/METADATA,sha256=XQNAIG51UZCKbZWc05PIyCnW5X-lji8AOcKiemgbqNM,9415
+dify_sandbox-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+dify_sandbox-1.0.0.dist-info/top_level.txt,sha256=Gkc2twiAhYZSCB2n2dNa68hdwIuzuojtc3DTvMgKB-c,13
+dify_sandbox-1.0.0.dist-info/RECORD,,

dify_sandbox-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dify_sandbox-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dify_sandbox