moru 0.1.0__tar.gz

moru-0.1.0/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 FOUNDRYLABS, INC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

moru-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: moru
+Version: 0.1.0
+Summary: Moru SDK that gives agents cloud environments
+License: MIT
+License-File: LICENSE
+Author: Moru AI
+Author-email: hello@moru.ai
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: attrs (>=23.2.0)
+Requires-Dist: dockerfile-parse (>=2.0.1,<3.0.0)
+Requires-Dist: httpcore (>=1.0.5,<2.0.0)
+Requires-Dist: httpx (>=0.27.0,<1.0.0)
+Requires-Dist: packaging (>=24.1)
+Requires-Dist: protobuf (>=4.21.0)
+Requires-Dist: python-dateutil (>=2.8.2)
+Requires-Dist: rich (>=14.0.0)
+Requires-Dist: typing-extensions (>=4.1.0)
+Requires-Dist: wcmatch (>=10.1,<11.0)
+Project-URL: Bug Tracker, https://github.com/moru-ai/sdks/issues
+Project-URL: Homepage, https://github.com/moru-ai/sdks
+Project-URL: Repository, https://github.com/moru-ai/sdks/tree/main/packages/python-sdk
+Description-Content-Type: text/markdown
+
+# Moru Python SDK
+
+Moru SDK for Python provides cloud environments for AI agents.
+
+## Installation
+
+```bash
+pip install moru
+```
+
+## Quick Start
+
+### 1. Set your API key
+
+```bash
+export MORU_API_KEY=your_api_key
+```
+
+### 2. Create a sandbox
+
+```python
+from moru import Sandbox
+
+with Sandbox() as sandbox:
+    sandbox.run_code('print("Hello from Moru!")')
+```
+
+## Acknowledgement
+
+This project is a fork of [E2B](https://github.com/e2b-dev/E2B).
+

moru-0.1.0/README.md

@@ -0,0 +1,30 @@
+# Moru Python SDK
+
+Moru SDK for Python provides cloud environments for AI agents.
+
+## Installation
+
+```bash
+pip install moru
+```
+
+## Quick Start
+
+### 1. Set your API key
+
+```bash
+export MORU_API_KEY=your_api_key
+```
+
+### 2. Create a sandbox
+
+```python
+from moru import Sandbox
+
+with Sandbox() as sandbox:
+    sandbox.run_code('print("Hello from Moru!")')
+```
+
+## Acknowledgement
+
+This project is a fork of [E2B](https://github.com/e2b-dev/E2B).

moru-0.1.0/moru/__init__.py

@@ -0,0 +1,174 @@
+"""
+Secure sandboxed cloud environments made for AI agents and AI apps.
+
+Check docs [here](https://moru.io/docs).
+
+Moru Sandbox is a secure cloud sandbox environment made for AI agents and AI
+apps.
+Sandboxes allow AI agents and apps to have long running cloud secure environments.
+In these environments, large language models can use the same tools as humans do.
+
+Moru Python SDK supports both sync and async API:
+
+```py
+from moru import Sandbox
+
+# Create sandbox
+sandbox = Sandbox.create()
+```
+
+```py
+from moru import AsyncSandbox
+
+# Create sandbox
+sandbox = await AsyncSandbox.create()
+```
+"""
+
+from .api import (
+    ApiClient,
+    client,
+)
+from .connection_config import (
+    ConnectionConfig,
+    ProxyTypes,
+)
+from .exceptions import (
+    AuthenticationException,
+    BuildException,
+    FileUploadException,
+    InvalidArgumentException,
+    NotEnoughSpaceException,
+    NotFoundException,
+    SandboxException,
+    TemplateException,
+    TimeoutException,
+)
+from .sandbox.commands.command_handle import (
+    CommandExitException,
+    CommandResult,
+    PtyOutput,
+    PtySize,
+    Stderr,
+    Stdout,
+)
+from .sandbox.commands.main import ProcessInfo
+from .sandbox.filesystem.filesystem import EntryInfo, FileType, WriteInfo
+from .sandbox.filesystem.watch_handle import (
+    FilesystemEvent,
+    FilesystemEventType,
+)
+from .sandbox.network import ALL_TRAFFIC
+from .sandbox.sandbox_api import (
+    GitHubMcpServer,
+    GitHubMcpServerConfig,
+    McpServer,
+    SandboxInfo,
+    SandboxMetrics,
+    SandboxNetworkOpts,
+    SandboxQuery,
+    SandboxState,
+)
+from .sandbox_async.commands.command_handle import AsyncCommandHandle
+from .sandbox_async.filesystem.watch_handle import AsyncWatchHandle
+from .sandbox_async.main import AsyncSandbox
+from .sandbox_async.paginator import AsyncSandboxPaginator
+from .sandbox_async.utils import OutputHandler
+from .sandbox_sync.commands.command_handle import CommandHandle
+from .sandbox_sync.filesystem.watch_handle import WatchHandle
+from .sandbox_sync.main import Sandbox
+from .sandbox_sync.paginator import SandboxPaginator
+from .template.logger import (
+    LogEntry,
+    LogEntryEnd,
+    LogEntryLevel,
+    LogEntryStart,
+    default_build_logger,
+)
+from .template.main import TemplateBase, TemplateClass
+from .template.readycmd import (
+    ReadyCmd,
+    wait_for_file,
+    wait_for_port,
+    wait_for_process,
+    wait_for_timeout,
+    wait_for_url,
+)
+from .template.types import BuildInfo, CopyItem
+from .template_async.main import AsyncTemplate
+from .template_sync.main import Template
+
+__all__ = [
+    # API
+    "ApiClient",
+    "client",
+    # Connection config
+    "ConnectionConfig",
+    "ProxyTypes",
+    # Exceptions
+    "SandboxException",
+    "TimeoutException",
+    "NotFoundException",
+    "AuthenticationException",
+    "InvalidArgumentException",
+    "NotEnoughSpaceException",
+    "TemplateException",
+    "BuildException",
+    "FileUploadException",
+    # Sandbox API
+    "SandboxInfo",
+    "SandboxMetrics",
+    "ProcessInfo",
+    "SandboxQuery",
+    "SandboxState",
+    "SandboxMetrics",
+    # Command handle
+    "CommandResult",
+    "Stderr",
+    "Stdout",
+    "CommandExitException",
+    "PtyOutput",
+    "PtySize",
+    # Filesystem
+    "FilesystemEvent",
+    "FilesystemEventType",
+    "EntryInfo",
+    "WriteInfo",
+    "FileType",
+    # Network
+    "SandboxNetworkOpts",
+    "ALL_TRAFFIC",
+    # Sync sandbox
+    "Sandbox",
+    "SandboxPaginator",
+    "WatchHandle",
+    "CommandHandle",
+    # Async sandbox
+    "OutputHandler",
+    "AsyncSandboxPaginator",
+    "AsyncSandbox",
+    "AsyncWatchHandle",
+    "AsyncCommandHandle",
+    # Template
+    "Template",
+    "AsyncTemplate",
+    "TemplateBase",
+    "TemplateClass",
+    "CopyItem",
+    "BuildInfo",
+    "ReadyCmd",
+    "wait_for_file",
+    "wait_for_url",
+    "wait_for_port",
+    "wait_for_process",
+    "wait_for_timeout",
+    "LogEntry",
+    "LogEntryStart",
+    "LogEntryEnd",
+    "LogEntryLevel",
+    "default_build_logger",
+    # MCP
+    "McpServer",
+    "GitHubMcpServer",
+    "GitHubMcpServerConfig",
+]

moru-0.1.0/moru/api/__init__.py

@@ -0,0 +1,164 @@
+import json
+import logging
+import os
+from dataclasses import dataclass
+from types import TracebackType
+from typing import Optional, Union
+
+from httpx import AsyncBaseTransport, BaseTransport, Limits
+
+from moru.api.client.client import AuthenticatedClient
+from moru.api.client.types import Response
+from moru.api.metadata import default_headers
+from moru.connection_config import ConnectionConfig
+from moru.exceptions import (
+    AuthenticationException,
+    RateLimitException,
+    SandboxException,
+)
+
+logger = logging.getLogger(__name__)
+
+limits = Limits(
+    max_keepalive_connections=int(os.getenv("MORU_MAX_KEEPALIVE_CONNECTIONS", "20")),
+    max_connections=int(os.getenv("MORU_MAX_CONNECTIONS", "2000")),
+    keepalive_expiry=int(os.getenv("MORU_KEEPALIVE_EXPIRY", "300")),
+)
+
+
+@dataclass
+class SandboxCreateResponse:
+    sandbox_id: str
+    sandbox_domain: Optional[str]
+    envd_version: str
+    envd_access_token: str
+    traffic_access_token: Optional[str]
+
+
+def handle_api_exception(
+    e: Response,
+    default_exception_class: type[Exception] = SandboxException,
+    stack_trace: Optional[TracebackType] = None,
+):
+    try:
+        body = json.loads(e.content) if e.content else {}
+    except json.JSONDecodeError:
+        body = {}
+
+    if e.status_code == 401:
+        message = f"{e.status_code}: Unauthorized, please check your credentials."
+        if body.get("message"):
+            message += f" - {body['message']}"
+        return AuthenticationException(message)
+
+    if e.status_code == 429:
+        message = f"{e.status_code}: Rate limit exceeded, please try again later."
+        if body.get("message"):
+            message += f" - {body['message']}"
+        return RateLimitException(message)
+
+    if "message" in body:
+        return default_exception_class(
+            f"{e.status_code}: {body['message']}"
+        ).with_traceback(stack_trace)
+    return default_exception_class(f"{e.status_code}: {e.content}").with_traceback(
+        stack_trace
+    )
+
+
+class ApiClient(AuthenticatedClient):
+    """
+    The client for interacting with the Moru API.
+    """
+
+    def __init__(
+        self,
+        config: ConnectionConfig,
+        require_api_key: bool = True,
+        require_access_token: bool = False,
+        transport: Optional[Union[BaseTransport, AsyncBaseTransport]] = None,
+        *args,
+        **kwargs,
+    ):
+        if require_api_key and require_access_token:
+            raise AuthenticationException(
+                "Only one of api_key or access_token can be required, not both",
+            )
+
+        if not require_api_key and not require_access_token:
+            raise AuthenticationException(
+                "Either api_key or access_token is required",
+            )
+
+        token = None
+        if require_api_key:
+            if config.api_key is None:
+                raise AuthenticationException(
+                    "API key is required. "
+                    "You can either set the environment variable `MORU_API_KEY` "
+                    'or you can pass it directly to the method like api_key="..."',
+                )
+            token = config.api_key
+
+        if require_access_token:
+            if config.access_token is None:
+                raise AuthenticationException(
+                    "Access token is required. "
+                    "You can set the environment variable `MORU_ACCESS_TOKEN` or pass the `access_token` in options.",
+                )
+            token = config.access_token
+
+        auth_header_name = "X-API-KEY" if require_api_key else "Authorization"
+        prefix = "" if require_api_key else "Bearer"
+
+        headers = {
+            **default_headers,
+            **(config.headers or {}),
+        }
+
+        # Prevent passing these parameters twice
+        more_headers: Optional[dict] = kwargs.pop("headers", None)
+        if more_headers:
+            headers.update(more_headers)
+        kwargs.pop("token", None)
+        kwargs.pop("auth_header_name", None)
+        kwargs.pop("prefix", None)
+
+        super().__init__(
+            base_url=config.api_url,
+            httpx_args={
+                "event_hooks": {
+                    "request": [self._log_request],
+                    "response": [self._log_response],
+                },
+                "proxy": config.proxy,
+                "transport": transport,
+            },
+            headers=headers,
+            token=token,
+            auth_header_name=auth_header_name,
+            prefix=prefix,
+            *args,
+            **kwargs,
+        )
+
+    def _log_request(self, request):
+        logger.info(f"Request {request.method} {request.url}")
+
+    def _log_response(self, response: Response):
+        if response.status_code >= 400:
+            logger.error(f"Response {response.status_code}")
+        else:
+            logger.info(f"Response {response.status_code}")
+
+
+# We need to override the logging hooks for the async usage
+class AsyncApiClient(ApiClient):
+    async def _log_request(self, request):
+        logger.info(f"Request {request.method} {request.url}")
+
+    async def _log_response(self, response: Response):
+        if response.status_code >= 400:
+            logger.error(f"Response {response.status_code}")
+        else:
+            logger.info(f"Response {response.status_code}")

moru-0.1.0/moru/api/client/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing Moru API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

moru-0.1.0/moru/api/client/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

moru-0.1.0/moru/api/client/api/sandboxes/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

moru-0.1.0/moru/api/client/api/sandboxes/delete_sandboxes_sandbox_id.py

@@ -0,0 +1,161 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": f"/sandboxes/{sandbox_id}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+        )
+    ).parsed