blaxel 0.1.10rc39__tar.gz → 0.1.10rc41__tar.gz

{blaxel-0.1.10rc39 → blaxel-0.1.10rc41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.1.10rc39
+Version: 0.1.10rc41
 Summary: Add your description here
 Author-email: cploujoux <cploujoux@blaxel.ai>
 License-File: LICENSE

{blaxel-0.1.10rc39 → blaxel-0.1.10rc41}/integrationtest/fastapi_langchain.py

@@ -67,7 +67,7 @@ async def validation_exception_handler(request: Request, e: Exception):
 @app.post("/")
 async def handle_request(request: Request):
     start = time()
-    tools = await bl_tools(["blaxel-search", "mymcp"]).to_langchain()
+    tools = await bl_tools(["blaxel-search"]).to_langchain()
     logger.info(f"Loaded tools in {round(time() - start, 4)} seconds")
     start = time()
     logger.info(f"Converted tools to langchain in {round(time() - start, 4)} seconds")

blaxel-0.1.10rc41/integrationtest/mcp_creation.py

@@ -0,0 +1,97 @@
+import logging
+import os
+import time
+
+from blaxel.client import client
+from blaxel.client.api.functions import (create_function, delete_function,
+                                         get_function)
+from blaxel.client.api.integrations import (create_integration_connection,
+                                            delete_integration_connection)
+from blaxel.client.models import (Function, FunctionSpec,
+                                  IntegrationConnection,
+                                  IntegrationConnectionSpec, Metadata, Runtime)
+from blaxel.tools import bl_tools
+
+logger = logging.getLogger(__name__)
+
+async def wait_mcp_ready(name, max_wait: int = 60000, interval: int = 1000):
+    start_time = time.time() * 1000
+    mcp: Function = await get_function.asyncio(
+        name,
+        client=client,
+    )
+    while mcp.status != "DEPLOYED":
+        await asyncio.sleep(1)
+        logger.info(f"Waiting for MCP to be deployed, status: {mcp.status}")
+        mcp = await get_function.asyncio(
+            name,
+            client=client,
+        )
+        if (time.time() * 1000) - start_time > max_wait:
+            raise Exception("MCP did not deploy in time")
+
+async def main():
+    try:
+        team_id = os.getenv("SLACK_TEAM_ID")
+        bot_token = os.getenv("SLACK_BOT_TOKEN")
+        mcp_name = "my-slack-mcp"
+        integration_connection_name = "my-slack-integration"
+
+        if not team_id or not bot_token:
+            raise Exception("SLACK_TEAM_ID and SLACK_BOT_TOKEN must be set")
+
+        # Create integration connection
+        integration_connection: IntegrationConnection = await create_integration_connection.asyncio(
+            client=client,
+            body=IntegrationConnection(
+                metadata=Metadata(
+                    name=integration_connection_name
+                ),
+                spec=IntegrationConnectionSpec(
+                    integration="slack",
+                    config={
+                        "teamId": team_id
+                    },
+                    secret={
+                        "botToken": bot_token
+                    }
+                )
+            )
+        )
+
+        # Create MCP
+        await create_function.asyncio(
+            client=client,
+            body=Function(
+                metadata=Metadata(
+                    name=mcp_name
+                ),
+                spec=FunctionSpec(
+                    integration_connections=[integration_connection.metadata.name],
+                    runtime=Runtime(
+                        type_="mcp"
+                    )
+                )
+            )
+        )
+        await wait_mcp_ready(mcp_name)
+
+        ### DO SOME STUFF WITH MCP
+        tools = await bl_tools([mcp_name]).initialize()
+        print(await tools.get_tools()[0].coroutine())
+    except Exception as e:
+        logger.error(f"There was an error while creating/using MCP, {e}")
+    finally:
+        ### CLEANUP
+        await delete_function.asyncio(
+            mcp_name,
+            client=client,
+        )
+        await delete_integration_connection.asyncio(
+            integration_connection_name,
+            client=client,
+        )
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

blaxel-0.1.10rc41/integrationtest/sandbox_502.py

@@ -0,0 +1,83 @@
+import asyncio
+import logging
+import random
+import string
+
+from blaxel.client.models import Metadata, Port, Runtime, Sandbox, SandboxSpec
+from blaxel.common.settings import settings
+from blaxel.sandbox.client import client
+from blaxel.sandbox.client.models import ProcessRequest
+from blaxel.sandbox.sandbox import SandboxInstance
+
+logger = logging.getLogger(__name__)
+
+
+def random_string(length: int):
+    return ''.join(random.choices(string.ascii_letters + string.digits, k=length)).lower()
+
+
+async def create_sandbox(sandbox_name: str):
+    # Create sandbox
+    image = "blaxel/prod-base:latest"
+    logger.info(f"Creating sandbox {sandbox_name} with image {image}")
+    sandbox = await SandboxInstance.create(Sandbox(
+        metadata=Metadata(name=sandbox_name),
+        spec=SandboxSpec(
+            runtime=Runtime(
+                image=image,
+                memory=2048,
+                cpu=2,
+                ports=[
+                    Port(name="sandbox-api", target=8080, protocol="HTTP")
+                ]
+            )
+        )
+    ))
+    logger.info("Waiting for sandbox to be deployed")
+    await sandbox.wait(max_wait=120000, interval=1000)
+    logger.info("Sandbox deployed")
+    return sandbox
+
+async def run_process_with_retry(sandbox: SandboxInstance, command: str):
+    for _ in range(2):
+        try:
+            # new_client = client.with_base_url(sandbox.process.url).with_headers(settings.headers)
+            # response = await new_client.get_async_httpx_client().get(f"/health")
+            # print(response.text)
+            dir = await sandbox.fs.ls("/")
+            print(dir)
+            process = await sandbox.process.exec(ProcessRequest(name="test", command=command))
+            print(f"Process {process.name} started with pid {process.pid}")
+            return process
+        except Exception as e:
+            print("Failed to run process, retrying...", e)
+            await asyncio.sleep(1)
+
+async def main():
+    sandbox_name = random_string(10)
+    try:
+        print(f"Creating sandbox {sandbox_name}")
+        sandbox = await create_sandbox(sandbox_name)
+        sandbox = await SandboxInstance.get(sandbox_name)
+        await run_process_with_retry(sandbox, 'pwd')
+        await SandboxInstance.delete(sandbox_name)
+    except Exception as e:
+        print(e)
+    finally:
+        await SandboxInstance.delete(sandbox_name)
+
+    sandbox_name = random_string(10)
+    try:
+        print(f"Creating sandbox {sandbox_name}")
+        sandbox = await create_sandbox(sandbox_name)
+        sandbox = await SandboxInstance.get(sandbox_name)
+        await run_process_with_retry(sandbox, 'pwd')
+        await SandboxInstance.delete(sandbox_name)
+    except Exception as e:
+        print(e)
+    finally:
+        await SandboxInstance.delete(sandbox_name)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{blaxel-0.1.10rc39 → blaxel-0.1.10rc41}/integrationtest/sandbox_small.py

@@ -1,4 +1,5 @@
 import asyncio
+import json
 import logging
 
 from blaxel.sandbox.sandbox import SandboxInstance
@@ -7,9 +8,10 @@ logger = logging.getLogger(__name__)
 
 
 async def main():
-    sandbox_name = "base-3"
+    sandbox_name = "spinup-test5"
     sandbox = await SandboxInstance.get(sandbox_name)
-    print(await sandbox.fs.ls("/"))
+    result = await sandbox.fs.ls("/root")
+    print(json.dumps(result.to_dict(), indent=4))
     # Filesystem tests
 
 if __name__ == "__main__":

{blaxel-0.1.10rc39 → blaxel-0.1.10rc41}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blaxel"
-version = "0.1.10.pre-39"
+version = "0.1.10.pre-41"
 description = "Add your description here"
 readme = "README.md"
 authors = [{ name = "cploujoux", email = "cploujoux@blaxel.ai" }]

blaxel-0.1.10rc41/src/blaxel/client/api/compute/create_sandbox_preview.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.preview import Preview
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_name: str,
+    *,
+    body: Preview,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/sandboxes/{sandbox_name}/previews",
+    }
+
+    if type(body) == dict:
+        _body = body
+    else:
+        _body = body.to_dict()
+
+    _kwargs["json"] = _body
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[Preview]:
+    if response.status_code == 200:
+        response_200 = Preview.from_dict(response.json())
+
+        return response_200
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: Client, response: httpx.Response) -> Response[Preview]:
+    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_name: str,
+    *,
+    client: Union[Client],
+    body: Preview,
+) -> Response[Preview]:
+    """Create Sandbox Preview
+
+     Create a preview
+
+    Args:
+        sandbox_name (str):
+        body (Preview): Preview of a Resource
+
+    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[Preview]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_name=sandbox_name,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_name: str,
+    *,
+    client: Union[Client],
+    body: Preview,
+) -> Optional[Preview]:
+    """Create Sandbox Preview
+
+     Create a preview
+
+    Args:
+        sandbox_name (str):
+        body (Preview): Preview of a Resource
+
+    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:
+        Preview
+    """
+
+    return sync_detailed(
+        sandbox_name=sandbox_name,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_name: str,
+    *,
+    client: Union[Client],
+    body: Preview,
+) -> Response[Preview]:
+    """Create Sandbox Preview
+
+     Create a preview
+
+    Args:
+        sandbox_name (str):
+        body (Preview): Preview of a Resource
+
+    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[Preview]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_name=sandbox_name,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_name: str,
+    *,
+    client: Union[Client],
+    body: Preview,
+) -> Optional[Preview]:
+    """Create Sandbox Preview
+
+     Create a preview
+
+    Args:
+        sandbox_name (str):
+        body (Preview): Preview of a Resource
+
+    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:
+        Preview
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_name=sandbox_name,
+            client=client,
+            body=body,
+        )
+    ).parsed

blaxel-0.1.10rc41/src/blaxel/client/api/compute/create_sandbox_preview_token.py

@@ -0,0 +1,192 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.preview_token import PreviewToken
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_name: str,
+    preview_name: str,
+    *,
+    body: PreviewToken,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/sandboxes/{sandbox_name}/previews/{preview_name}/tokens",
+    }
+
+    if type(body) == dict:
+        _body = body
+    else:
+        _body = body.to_dict()
+
+    _kwargs["json"] = _body
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[PreviewToken]:
+    if response.status_code == 200:
+        response_200 = PreviewToken.from_dict(response.json())
+
+        return response_200
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: Client, response: httpx.Response) -> Response[PreviewToken]:
+    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_name: str,
+    preview_name: str,
+    *,
+    client: Union[Client],
+    body: PreviewToken,
+) -> Response[PreviewToken]:
+    """Create token for Sandbox Preview
+
+     Creates a token for a Sandbox Preview.
+
+    Args:
+        sandbox_name (str):
+        preview_name (str):
+        body (PreviewToken): Token for a Preview
+
+    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[PreviewToken]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_name=sandbox_name,
+        preview_name=preview_name,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_name: str,
+    preview_name: str,
+    *,
+    client: Union[Client],
+    body: PreviewToken,
+) -> Optional[PreviewToken]:
+    """Create token for Sandbox Preview
+
+     Creates a token for a Sandbox Preview.
+
+    Args:
+        sandbox_name (str):
+        preview_name (str):
+        body (PreviewToken): Token for a Preview
+
+    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:
+        PreviewToken
+    """
+
+    return sync_detailed(
+        sandbox_name=sandbox_name,
+        preview_name=preview_name,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_name: str,
+    preview_name: str,
+    *,
+    client: Union[Client],
+    body: PreviewToken,
+) -> Response[PreviewToken]:
+    """Create token for Sandbox Preview
+
+     Creates a token for a Sandbox Preview.
+
+    Args:
+        sandbox_name (str):
+        preview_name (str):
+        body (PreviewToken): Token for a Preview
+
+    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[PreviewToken]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_name=sandbox_name,
+        preview_name=preview_name,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_name: str,
+    preview_name: str,
+    *,
+    client: Union[Client],
+    body: PreviewToken,
+) -> Optional[PreviewToken]:
+    """Create token for Sandbox Preview
+
+     Creates a token for a Sandbox Preview.
+
+    Args:
+        sandbox_name (str):
+        preview_name (str):
+        body (PreviewToken): Token for a Preview
+
+    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:
+        PreviewToken
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_name=sandbox_name,
+            preview_name=preview_name,
+            client=client,
+            body=body,
+        )
+    ).parsed