blaxel 0.1.9rc37__tar.gz → 0.1.10__tar.gz

{blaxel-0.1.9rc37 → blaxel-0.1.10}/.gitignore

@@ -23,4 +23,5 @@ dmypy.json
 /.coverage
 uv.lock
 
-telemetry.sh
+telemetry.sh
+definition.yml

{blaxel-0.1.9rc37 → blaxel-0.1.10}/Makefile

@@ -1,6 +1,19 @@
 ARGS:= $(wordlist 2,$(words $(MAKECMDGOALS)),$(MAKECMDGOALS))
 
-sdk:
+sdk-sandbox:
+	cp ../sandbox/sandbox-api/docs/openapi.yml ./definition.yml
+	rm -rf src/blaxel/sandbox/client/api src/blaxel/sandbox/client/models
+	openapi-python-client generate \
+		--path=definition.yml \
+		--output-path=./tmp-sdk-sandbox \
+		--overwrite \
+		--custom-template-path=./templates \
+		--config=./openapi-python-client.yml
+	cp -r ./tmp-sdk-sandbox/blaxel/* ./src/blaxel/sandbox/client
+	rm -rf ./tmp-sdk-sandbox
+	uv run ruff check --fix
+
+sdk-controlplane:
 	cp ../controlplane/api/api/definitions/controlplane.yml ./definition.yml
 	rm -rf src/blaxel/client/api src/blaxel/client/models
 	openapi-python-client generate \
@@ -13,6 +26,8 @@ sdk:
 	rm -rf ./tmp-sdk-python
 	uv run ruff check --fix
 
+sdk: sdk-sandbox sdk-controlplane
+
 doc:
 	rm -rf docs
 	uv run pdoc blaxel-docs src/blaxel -o docs --force --skip-errors

{blaxel-0.1.9rc37 → blaxel-0.1.10}/PKG-INFO

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

{blaxel-0.1.9rc37 → blaxel-0.1.10}/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.10/integrationtest/load_test.py

@@ -0,0 +1,53 @@
+import asyncio
+import time
+from collections import Counter
+
+from blaxel.client import client
+from blaxel.common.settings import settings
+
+
+async def request_agent(name):
+    response = await client.get_async_httpx_client().get(
+        f"{settings.run_url}/{settings.workspace}/agents/{name}"
+    )
+    if response.status_code != 200:
+        raise Exception(f"Agent {name} returned status code {response.status_code} with body {response.text}")
+    return response.status_code
+
+async def main():
+    number_of_calls = 500
+    batch_size = 100
+    agent_name = "agent-telemetry-ts"
+
+    total_start_time = time.time()
+    batch_times = []
+
+    for batch_start in range(0, number_of_calls, batch_size):
+        batch_end = min(batch_start + batch_size, number_of_calls)
+        batch_tasks = [request_agent(agent_name) for _ in range(batch_start, batch_end)]
+        print(f"Processing batch {batch_start//batch_size + 1} ({batch_start}-{batch_end-1})")
+
+        batch_start_time = time.time()
+        status_codes = await asyncio.gather(*batch_tasks)
+        batch_time = time.time() - batch_start_time
+        batch_times.append(batch_time)
+
+        status_counts = Counter(status_codes)
+        print(f"Completed batch {batch_start//batch_size + 1}")
+        print(f"Status codes: {dict(status_counts)}")
+        print(f"Batch time: {batch_time:.2f}s")
+        print(f"Mean time per request in batch: {batch_time/batch_size:.3f}s")
+        print("-" * 50)
+
+    total_time = time.time() - total_start_time
+    mean_time_per_request = total_time / number_of_calls
+
+    print("\nSummary:")
+    print(f"Total execution time: {total_time:.2f}s")
+    print(f"Mean time per request: {mean_time_per_request:.3f}s")
+    print(f"Fastest batch: {min(batch_times):.2f}s")
+    print(f"Slowest batch: {max(batch_times):.2f}s")
+    print(f"Average batch time: {sum(batch_times)/len(batch_times):.2f}s")
+
+if __name__ == "__main__":
+    asyncio.run(main())

blaxel-0.1.10/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.10/integrationtest/sandbox.py

@@ -0,0 +1,80 @@
+import asyncio
+import logging
+import os
+
+from blaxel.client.models import Metadata, Port, Runtime, Sandbox, SandboxSpec
+from blaxel.sandbox.base import ResponseError
+from blaxel.sandbox.client.models import ProcessRequest
+from blaxel.sandbox.sandbox import SandboxInstance
+
+logger = logging.getLogger(__name__)
+
+
+async def create_sandbox(sandbox_name: str):
+    # Create sandbox
+    image = "blaxel/prod-base:14769328323"
+    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 main():
+    user = os.environ.get("USER")
+    sandbox_name = "sandbox-test-3"
+    sandbox = None
+    try:
+        sandbox = await create_sandbox(sandbox_name)
+        sandbox = await SandboxInstance.get(sandbox_name)
+
+        # Filesystem tests
+        await sandbox.fs.write(f"/Users/{user}/Downloads/test", "Hello world")
+        content = await sandbox.fs.read(f"/Users/{user}/Downloads/test")
+        assert content == "Hello world", "File content is not correct"
+        dir = await sandbox.fs.ls(f"/Users/{user}/Downloads")
+        assert dir.files and len(dir.files) >= 1, "Directory is empty"
+        assert any(f.path == f"/Users/{user}/Downloads/test" for f in dir.files), "File not found in directory"
+        await sandbox.fs.mkdir(f"/Users/{user}/Downloads/test2")
+        after_mkdir = await sandbox.fs.ls(f"/Users/{user}/Downloads/test2")
+        assert not after_mkdir.files or len(after_mkdir.files) == 0, "Directory is not empty after mkdir"
+        await sandbox.fs.cp(f"/Users/{user}/Downloads/test", f"/Users/{user}/Downloads/test2/test")
+        after_cp_ls = await sandbox.fs.ls(f"/Users/{user}/Downloads/test2")
+        assert after_cp_ls.files and any(f.path == f"/Users/{user}/Downloads/test2/test" for f in after_cp_ls.files), "File not found in directory after cp"
+        await sandbox.fs.rm(f"/Users/{user}/Downloads/test")
+        try:
+            await sandbox.fs.rm(f"/Users/{user}/Downloads/test2")
+        except ResponseError as e:
+            logger.info(f"That is expected => {e.error}")
+        await sandbox.fs.rm(f"/Users/{user}/Downloads/test2", True)
+
+        # Process tests
+        process = await sandbox.process.exec(ProcessRequest(name="test", command="echo 'Hello world'"))
+        assert getattr(process, "status", None) != "completed", "Process did complete without waiting"
+        await asyncio.sleep(0.01)
+        completed_process = await sandbox.process.get("test")
+        assert getattr(completed_process, "status", None) == "completed", "Process did not complete"
+        logs = await sandbox.process.logs("test")
+        assert logs == 'Hello world\n', "Logs are not correct"
+        try:
+            await sandbox.process.kill("test")
+        except ResponseError as e:
+            logger.info(f"That is expected => {e.error}")
+    finally:
+        logger.info("Deleting sandbox")
+        await SandboxInstance.delete(sandbox_name)
+
+if __name__ == "__main__":
+    asyncio.run(main())

blaxel-0.1.10/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.10/integrationtest/sandbox_small.py

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

{blaxel-0.1.9rc37 → blaxel-0.1.10}/pyproject.toml

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

{blaxel-0.1.9rc37 → blaxel-0.1.10}/src/blaxel/authentication/__init__.py

@@ -19,16 +19,25 @@ def get_credentials() -> Optional[CredentialsType]:
     Returns:
         Optional[CredentialsType]: The credentials or None if not found
     """
+    def get_workspace():
+        if os.environ.get("BL_WORKSPACE"):
+            return os.environ.get("BL_WORKSPACE")
+        home_dir = Path.home()
+        config_path = home_dir / '.blaxel' / 'config.yaml'
+        with open(config_path, encoding='utf-8') as f:
+            config_json = yaml.safe_load(f)
+        return config_json.get("context", {}).get("workspace")
+
     if os.environ.get("BL_API_KEY"):
         return CredentialsType(
             api_key=os.environ.get("BL_API_KEY"),
-            workspace=os.environ.get("BL_WORKSPACE")
+            workspace=get_workspace()
         )
 
     if os.environ.get("BL_CLIENT_CREDENTIALS"):
         return CredentialsType(
             client_credentials=os.environ.get("BL_CLIENT_CREDENTIALS"),
-            workspace=os.environ.get("BL_WORKSPACE")
+            workspace=get_workspace()
         )
 
     try:

blaxel-0.1.10/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