boxlite 0.1.0__cp311-cp311-macosx_11_0_arm64.whl

boxlite/__init__.py

@@ -0,0 +1,25 @@
+"""
+BoxLite - Lightweight, secure containerization for any environment.
+
+Following SQLite philosophy: "BoxLite" for branding, "boxlite" for code APIs.
+"""
+
+import os
+from pathlib import Path
+
+# Set BOXLITE_BIN_DIR if not already set, to help Rust find binaries
+if "BOXLITE_BIN_DIR" not in os.environ:
+    # Check if binaries are bundled with the package
+    package_bin_dir = Path(__file__).parent / "bin"
+    if package_bin_dir.exists():
+        os.environ["BOXLITE_BIN_DIR"] = str(package_bin_dir)
+
+from .core.box import Box
+from .boxes import CodeBox
+
+# Future specialized containers
+# from .boxes.browser import BrowserBox
+# from .boxes.claude_code import ClaudeCodeBox
+
+__version__ = "0.1.0"
+__all__ = ["Box", "CodeBox"]

boxlite/boxes/__init__.py

@@ -0,0 +1,11 @@
+"""
+Specialized BoxLite containers for specific use cases.
+"""
+
+from .codebox import CodeBox
+
+# Future specialized containers
+# from .browser import BrowserBox
+# from .claude_code import ClaudeCodeBox
+
+__all__ = ["CodeBox"]

boxlite/boxes/codebox.py

@@ -0,0 +1,126 @@
+"""
+CodeBox - Secure Python code execution container.
+
+Provides a simple, secure environment for running untrusted Python code.
+"""
+
+from typing import Optional, Dict, Any, Union
+from ..core.box import Box
+
+
+class CodeBox(Box):
+    """
+    Secure container for executing Python code.
+
+    CodeBox provides an isolated environment for running untrusted Python code
+    with built-in safety and result formatting.
+
+    Example:
+        >>> with CodeBox() as codebox:
+        ...     result = codebox.run("print('Hello, World!')")
+        ...     print(result)
+    """
+
+    def __init__(
+        self,
+        image: str = "python:slim",
+        memory_mib: Optional[int] = None,
+        cpus: Optional[int] = None,
+        **kwargs
+    ):
+        """
+        Create a new CodeBox for Python code execution.
+
+        Args:
+            image: Container image with Python (default: python:slim)
+            memory_mib: Memory limit in MiB (default: system default)
+            cpus: Number of CPU cores (default: system default)
+            **kwargs: Additional Box configuration options
+        """
+        # Set up Python-specific defaults
+        config = {
+            'engine': kwargs.get('engine', 'libkrun'),
+            'memory_mib': memory_mib,
+            'cpus': cpus,
+        }
+
+        # Filter out None values
+        config = {k: v for k, v in config.items() if v is not None}
+
+        # Merge with any additional kwargs
+        config.update({k: v for k, v in kwargs.items() if k not in config})
+
+        # Initialize the base Box with Python image
+        super().__init__(image=image, **config)
+
+    async def run(self, code: str, timeout: Optional[int] = None) -> Union[str, Dict[str, Any]]:
+        """
+        Execute Python code in the secure container.
+
+        Args:
+            code: Python code to execute
+            timeout: Execution timeout in seconds (not yet implemented)
+
+        Returns:
+            Execution output as a string
+
+        Example:
+            >>> async with CodeBox() as cb:
+            ...     result = await cb.run("print('Hello, World!')")
+            ...     print(result)
+            [stdout] Hello, World!
+
+        Note:
+            Uses python3 from the container image.
+            For custom Python paths, use execute() directly:
+                await cb.execute("/path/to/python", "-c", code)
+        """
+        # Execute Python code using python3 -c
+        return await self.execute("/usr/local/bin/python", "-c", code)
+
+    async def run_script(self, script_path: str) -> str:
+        """
+        Execute a Python script file in the container.
+
+        Args:
+            script_path: Path to the Python script on the host
+
+        Returns:
+            Execution output as a string
+        """
+        with open(script_path, 'r') as f:
+            code = f.read()
+        return await self.run(code)
+
+    async def install_package(self, package: str) -> str:
+        """
+        Install a Python package in the container using pip.
+
+        Args:
+            package: Package name (e.g., 'requests', 'numpy==1.24.0')
+
+        Returns:
+            Installation output
+
+        Example:
+            >>> async with CodeBox() as cb:
+            ...     await cb.install_package("requests")
+            ...     result = await cb.run("import requests; print(requests.__version__)")
+        """
+        return await self.execute("pip", "install", package)
+
+    async def install_packages(self, *packages: str) -> str:
+        """
+        Install multiple Python packages.
+
+        Args:
+            *packages: Package names to install
+
+        Returns:
+            Installation output
+
+        Example:
+            >>> async with CodeBox() as cb:
+            ...     await cb.install_packages("requests", "numpy", "pandas")
+        """
+        return await self.execute("pip", "install", *packages)

boxlite/core/__init__.py

@@ -0,0 +1,7 @@
+"""
+Core BoxLite functionality.
+"""
+
+from .box import Box
+
+__all__ = ["Box"]

boxlite/core/box.py

@@ -0,0 +1,93 @@
+"""
+Base Box class for BoxLite containers.
+
+This is the main user-facing API that wraps the Rust extension.
+"""
+
+from typing import Optional, Dict, Any, List, Tuple
+import sys
+import os
+import fcntl
+
+
+class Box:
+    """
+    Base class for all BoxLite containers.
+
+    Provides secure, lightweight containerization using VM technology.
+    """
+
+    def __init__(self, image: str = "alpine:latest", **kwargs):
+        """
+        Create a new BoxLite container.
+
+        Args:
+            image: Container image to use (default: alpine:latest)
+            **kwargs: Additional configuration options
+                - engine: VM engine to use ('libkrun', 'firecracker')
+                - memory_mib: Memory limit in MiB
+                - cpus: Number of CPU cores
+                - env: Environment variables as list of (key, value) tuples
+        """
+        # Import the Rust extension - the native Box class
+        try:
+            from ..boxlite import Box as NativeBox
+            # Use the native implementation directly
+            self._native_box = NativeBox({
+                'engine': kwargs.get('engine', 'libkrun'),
+                'image': image,
+                **{k: v for k, v in kwargs.items() if k != 'engine'}
+            })
+            self._use_native = True
+            return
+        except ImportError as e:
+            raise ImportError(
+                f"BoxLite native extension not found: {e}. "
+                "Please install with: pip install boxlite"
+            )
+
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        if self._use_native:
+            self._native_box.__enter__()
+            # Tokio runtime sets stdout/stderr to non-blocking mode
+            # Restore blocking mode to prevent BlockingIOError when printing
+            self._restore_blocking_mode()
+        return self
+
+    def _restore_blocking_mode(self):
+        """Restore blocking mode on stdout/stderr after Tokio sets them to non-blocking."""
+        for fd in [sys.stdout.fileno(), sys.stderr.fileno()]:
+            try:
+                flags = fcntl.fcntl(fd, fcntl.F_GETFL)
+                if flags & os.O_NONBLOCK:
+                    fcntl.fcntl(fd, fcntl.F_SETFL, flags & ~os.O_NONBLOCK)
+            except (OSError, AttributeError):
+                # Ignore errors (e.g., when stdout/stderr is not a real file)
+                pass
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        if self._use_native:
+            return self._native_box.__exit__(exc_type, exc_val, exc_tb)
+        return None
+
+    async def execute(self, command: str, *args) -> str:
+        """
+        Execute a command in the container.
+
+        Args:
+            command: Command to execute
+            *args: Command arguments
+
+        Returns:
+            Command output as string
+        """
+        if self._use_native:
+            result = await self._native_box.run_command(command, list(args) if args else None)
+            if isinstance(result, list):
+                return '\n'.join(f"[{stream}] {text}" for stream, text in result if text.strip())
+            return str(result)
+
+        raise RuntimeError("Container not initialized")

boxlite-0.1.0.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: boxlite
+Version: 0.1.0
+Summary: Python bindings for Boxlite sandbox runtime
+Author: Boxlite Contributors
+Requires-Python: >=3.9

boxlite-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+boxlite-0.1.0.dist-info/RECORD,,
+boxlite-0.1.0.dist-info/WHEEL,sha256=dewdenAwp3PDth0u4HpQhcjieEs1_hiwRbm3WvCuoaI,104
+boxlite-0.1.0.dist-info/METADATA,sha256=7-eRZ_Kg6fNA_C3jaVWfJnjKLx1_JRYGkZAQyAEXT6E,156
+boxlite/__init__.py,sha256=uFUVtHBVkjxpx9NxyyRfezBlLDpunNF_J-NCESPg-bg,726
+boxlite/boxlite.cpython-311-darwin.so,sha256=2ersq6_ezNXrYhEgM6n5dR-_vxjWAhtvxRZ9p8x913s,2445664
+boxlite/core/box.py,sha256=XwcevOo0opXWvVbUNL98Ozb7lf13Ucg8pPVrTqBqbzk,3223
+boxlite/core/__init__.py,sha256=gnumx6utojYT12dd4_kGlJmxwMf0Yidnpc3RsLmOFpc,76
+boxlite/bin/boxlite-runner,sha256=Q03LG8X5hDjjiR0fmdUy9Uc7Gv_8CGGaJFkc1LG-G6U,1640672
+boxlite/bin/boxlite-guest,sha256=P8THYIum1PqfB5aDSnw9pnChURGwrUgKi1JSSP4Gjj8,2640464
+boxlite/.dylibs/libkrunfw.4.dylib,sha256=_0skZ63p91-aH5cstSdJIJjAgffWSUjYtOJgOm42Euo,21979472
+boxlite/.dylibs/libkrun.1.15.1.dylib,sha256=SlWoMO0mUm4oQmisLfkaNVmoKZe68KMJeYUgcyZVncc,4176176
+boxlite/boxes/__init__.py,sha256=MYz3-Hgr9Qh2krmyp79amIGn5YovUOspLxZ-7HK7320,223
+boxlite/boxes/codebox.py,sha256=ZBeXNjlRwRN0ywqnqCfqYdHYJmeZA2bqnPDOdeHXR6s,3850

boxlite-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.6)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_11_0_arm64