blaxel 0.1.11rc44__tar.gz → 0.1.12rc45__tar.gz

{blaxel-0.1.11rc44 → blaxel-0.1.12rc45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.1.11rc44
+Version: 0.1.12rc45
 Summary: Add your description here
 Author-email: cploujoux <cploujoux@blaxel.ai>
 License-File: LICENSE

{blaxel-0.1.11rc44 → blaxel-0.1.12rc45}/integrationtest/mcp_creation.py

@@ -3,13 +3,19 @@ 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.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__)

{blaxel-0.1.11rc44 → blaxel-0.1.12rc45}/integrationtest/sandbox.py

@@ -12,7 +12,7 @@ logger = logging.getLogger(__name__)
 
 async def create_sandbox(sandbox_name: str):
     # Create sandbox
-    image = "blaxel/prod-base:14769328323"
+    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),

{blaxel-0.1.11rc44 → blaxel-0.1.12rc45}/integrationtest/sandbox_502.py

@@ -4,8 +4,6 @@ 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
 

blaxel-0.1.12rc45/integrationtest/sandbox_preview.py

@@ -0,0 +1,132 @@
+import asyncio
+import logging
+from datetime import datetime, timedelta, timezone
+
+import aiohttp
+
+from blaxel.client.models import (Metadata, Port, Preview, PreviewSpec,
+                                  Runtime, Sandbox, SandboxSpec)
+from blaxel.common.settings import settings
+from blaxel.sandbox.sandbox import SandboxInstance
+
+logger = logging.getLogger(__name__)
+
+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 test_public_preview(sandbox: SandboxInstance):
+    try:
+        # Create a public preview
+        await sandbox.previews.create(Preview(
+            metadata=Metadata(name="preview-test-public"),
+            spec=PreviewSpec(
+                port=443,
+                prefix_url="small-prefix",
+                public=True
+            )
+        ))
+
+        # List previews
+        previews = await sandbox.previews.list()
+        assert len(previews) >= 1, "No previews found"
+
+        # Get the preview
+        retrieved_preview = await sandbox.previews.get("preview-test-public")
+        assert retrieved_preview.name == "preview-test-public", "Preview name is not correct"
+
+        # Check the URL
+        url = retrieved_preview.spec.url if retrieved_preview.spec else None
+        assert url is not None, "Preview URL is not correct"
+        workspace = settings.workspace
+        expected_url = f"https://small-prefix-{workspace}.preview.bl.run"
+        assert url == expected_url, f"Preview URL is not correct => {url}"
+
+        # Test the preview endpoint
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{url}/health") as response:
+                assert response.status == 200, f"Preview is not working => {response.status}:{await response.text()}"
+
+        logger.info("Public preview is healthy :)")
+    except Exception as e:
+        logger.error("ERROR IN PUBLIC PREVIEW TEST => ", exc_info=e)
+        raise
+    finally:
+        await sandbox.previews.delete("preview-test-public")
+
+async def test_private_preview(sandbox: SandboxInstance):
+    try:
+        # Create a private preview
+        preview = await sandbox.previews.create(Preview(
+            metadata=Metadata(name="preview-test-private"),
+            spec=PreviewSpec(
+                port=443,
+                public=False
+            )
+        ))
+
+        # Get the preview URL
+        url = preview.spec.url if preview.spec else None
+        assert url is not None, "Preview URL is not correct"
+
+        # Create a token
+        token = await preview.tokens.create(datetime.now(timezone.utc) + timedelta(minutes=10))
+        logger.info(f"Token created => {token.value}")
+
+        # List tokens
+        tokens = await preview.tokens.list()
+        assert len(tokens) >= 1, "No tokens found"
+        assert any(t.value == token.value for t in tokens), "Token not found in list"
+
+        # Test the preview endpoint without token
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{url}/health") as response:
+                assert response.status == 401, f"Preview is not protected by token, response => {response.status}"
+
+        # Test the preview endpoint with token
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{url}/health?bl_preview_token={token.value}") as response:
+                assert response.status == 200, f"Preview is not working with token, response => {response.status}"
+
+        logger.info("Private preview is healthy with token :)")
+
+        # Delete the token
+        await preview.tokens.delete(token.value)
+    except Exception as e:
+        logger.error("ERROR IN PRIVATE PREVIEW TEST => ", exc_info=e)
+        raise
+    finally:
+        await sandbox.previews.delete("preview-test-private")
+
+async def main():
+    sandbox_name = "sandbox-preview-test"
+    sandbox = None
+    try:
+        sandbox = await create_sandbox(sandbox_name)
+        await test_public_preview(sandbox)
+        await test_private_preview(sandbox)
+    finally:
+        if sandbox:
+            logger.info("Deleting sandbox")
+            await SandboxInstance.delete(sandbox_name)
+
+if __name__ == "__main__":
+    asyncio.run(main())

{blaxel-0.1.11rc44 → blaxel-0.1.12rc45}/pyproject.toml

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

{blaxel-0.1.11rc44 → blaxel-0.1.12rc45}/src/blaxel/client/models/preview_spec.py

@@ -14,11 +14,13 @@ class PreviewSpec:
 
     Attributes:
         port (Union[Unset, int]): Port of the preview
+        prefix_url (Union[Unset, str]): Prefix URL
         public (Union[Unset, bool]): Whether the preview is public
         url (Union[Unset, str]): URL of the preview
     """
 
     port: Union[Unset, int] = UNSET
+    prefix_url: Union[Unset, str] = UNSET
     public: Union[Unset, bool] = UNSET
     url: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -26,6 +28,8 @@ class PreviewSpec:
     def to_dict(self) -> dict[str, Any]:
         port = self.port
 
+        prefix_url = self.prefix_url
+
         public = self.public
 
         url = self.url
@@ -35,6 +39,8 @@ class PreviewSpec:
         field_dict.update({})
         if port is not UNSET:
             field_dict["port"] = port
+        if prefix_url is not UNSET:
+            field_dict["prefixUrl"] = prefix_url
         if public is not UNSET:
             field_dict["public"] = public
         if url is not UNSET:
@@ -49,12 +55,15 @@ class PreviewSpec:
         d = src_dict.copy()
         port = d.pop("port", UNSET)
 
+        prefix_url = d.pop("prefixUrl", UNSET)
+
         public = d.pop("public", UNSET)
 
         url = d.pop("url", UNSET)
 
         preview_spec = cls(
             port=port,
+            prefix_url=prefix_url,
             public=public,
             url=url,
         )

{blaxel-0.1.11rc44 → blaxel-0.1.12rc45}/src/blaxel/client/models/preview_token_spec.py

@@ -15,13 +15,11 @@ class PreviewTokenSpec:
     Attributes:
         expired (Union[Unset, bool]): Whether the token is expired
         expires_at (Union[Unset, str]): Expiration time of the token
-        public (Union[Unset, bool]): Whether the token is public
         token (Union[Unset, str]): Token
     """
 
     expired: Union[Unset, bool] = UNSET
     expires_at: Union[Unset, str] = UNSET
-    public: Union[Unset, bool] = UNSET
     token: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -30,8 +28,6 @@ class PreviewTokenSpec:
 
         expires_at = self.expires_at
 
-        public = self.public
-
         token = self.token
 
         field_dict: dict[str, Any] = {}
@@ -41,8 +37,6 @@ class PreviewTokenSpec:
             field_dict["expired"] = expired
         if expires_at is not UNSET:
             field_dict["expiresAt"] = expires_at
-        if public is not UNSET:
-            field_dict["public"] = public
         if token is not UNSET:
             field_dict["token"] = token
 
@@ -57,14 +51,11 @@ class PreviewTokenSpec:
 
         expires_at = d.pop("expiresAt", UNSET)
 
-        public = d.pop("public", UNSET)
-
         token = d.pop("token", UNSET)
 
         preview_token_spec = cls(
             expired=expired,
             expires_at=expires_at,
-            public=public,
             token=token,
         )
 

{blaxel-0.1.11rc44 → blaxel-0.1.12rc45}/src/blaxel/sandbox/base.py

@@ -58,8 +58,10 @@ class SandboxHandleBase:
     def url(self):
         if self.forced_url:
             return self.forced_url
-        if settings.run_internal_hostname:
-            return self.internal_url
+        # Uncomment and use this when agent and mcp are available in mk3
+        # Update all requests made in this package to use fallbackUrl when internalUrl is not working
+        # if settings.run_internal_hostname:
+        #     return self.internal_url
         return self.external_url
 
     def handle_response(self, response: Response):

blaxel-0.1.12rc45/src/blaxel/sandbox/client/api/filesystem/get_watch_filesystem_path.py

@@ -0,0 +1,165 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.error_response import ErrorResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    path: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/watch/filesystem/{path}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[Union[ErrorResponse, str]]:
+    if response.status_code == 200:
+        response_200 = response.text
+        return response_200
+    if response.status_code == 400:
+        response_400 = ErrorResponse.from_dict(response.text)
+
+        return response_400
+    if response.status_code == 500:
+        response_500 = ErrorResponse.from_dict(response.text)
+
+        return response_500
+    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[Union[ErrorResponse, str]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    path: str,
+    *,
+    client: Union[Client],
+) -> Response[Union[ErrorResponse, str]]:
+    """Stream file modification events in a directory
+
+     Streams the path of modified files (one per line) in the given directory. Closes when the client
+    disconnects.
+
+    Args:
+        path (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[ErrorResponse, str]]
+    """
+
+    kwargs = _get_kwargs(
+        path=path,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    path: str,
+    *,
+    client: Union[Client],
+) -> Optional[Union[ErrorResponse, str]]:
+    """Stream file modification events in a directory
+
+     Streams the path of modified files (one per line) in the given directory. Closes when the client
+    disconnects.
+
+    Args:
+        path (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[ErrorResponse, str]
+    """
+
+    return sync_detailed(
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    path: str,
+    *,
+    client: Union[Client],
+) -> Response[Union[ErrorResponse, str]]:
+    """Stream file modification events in a directory
+
+     Streams the path of modified files (one per line) in the given directory. Closes when the client
+    disconnects.
+
+    Args:
+        path (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[ErrorResponse, str]]
+    """
+
+    kwargs = _get_kwargs(
+        path=path,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    path: str,
+    *,
+    client: Union[Client],
+) -> Optional[Union[ErrorResponse, str]]:
+    """Stream file modification events in a directory
+
+     Streams the path of modified files (one per line) in the given directory. Closes when the client
+    disconnects.
+
+    Args:
+        path (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[ErrorResponse, str]
+    """
+
+    return (
+        await asyncio_detailed(
+            path=path,
+            client=client,
+        )
+    ).parsed

blaxel-0.1.12rc45/src/blaxel/sandbox/client/api/filesystem/get_ws_watch_filesystem_path.py

@@ -0,0 +1,161 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.error_response import ErrorResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    path: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/ws/watch/filesystem/{path}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[Union[ErrorResponse, str]]:
+    if response.status_code == 101:
+        response_101 = cast(str, response.json())
+        return response_101
+    if response.status_code == 400:
+        response_400 = ErrorResponse.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 500:
+        response_500 = ErrorResponse.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: Client, response: httpx.Response) -> Response[Union[ErrorResponse, str]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    path: str,
+    *,
+    client: Union[Client],
+) -> Response[Union[ErrorResponse, str]]:
+    """Stream file modification events in a directory via WebSocket
+
+     Streams JSON events of modified files in the given directory. Closes when the client disconnects.
+
+    Args:
+        path (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[ErrorResponse, str]]
+    """
+
+    kwargs = _get_kwargs(
+        path=path,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    path: str,
+    *,
+    client: Union[Client],
+) -> Optional[Union[ErrorResponse, str]]:
+    """Stream file modification events in a directory via WebSocket
+
+     Streams JSON events of modified files in the given directory. Closes when the client disconnects.
+
+    Args:
+        path (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[ErrorResponse, str]
+    """
+
+    return sync_detailed(
+        path=path,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    path: str,
+    *,
+    client: Union[Client],
+) -> Response[Union[ErrorResponse, str]]:
+    """Stream file modification events in a directory via WebSocket
+
+     Streams JSON events of modified files in the given directory. Closes when the client disconnects.
+
+    Args:
+        path (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[ErrorResponse, str]]
+    """
+
+    kwargs = _get_kwargs(
+        path=path,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    path: str,
+    *,
+    client: Union[Client],
+) -> Optional[Union[ErrorResponse, str]]:
+    """Stream file modification events in a directory via WebSocket
+
+     Streams JSON events of modified files in the given directory. Closes when the client disconnects.
+
+    Args:
+        path (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[ErrorResponse, str]
+    """
+
+    return (
+        await asyncio_detailed(
+            path=path,
+            client=client,
+        )
+    ).parsed