blaxel 0.2.30__py3-none-any.whl → 0.2.31rc120__py3-none-any.whl

blaxel/__init__.py

@@ -4,8 +4,8 @@ from .core.common.autoload import autoload
 from .core.common.env import env
 from .core.common.settings import settings
 
-__version__ = "0.2.30"
-__commit__ = "65a88e27efd0b99c49c23a5cc339865d3bafca2e"
+__version__ = "0.2.31.pre-120"
+__commit__ = "a23256023f1d955467e2ee297a96b3d321172acf"
 __sentry_dsn__ = "https://9711de13cd02b285ca4378c01de8dc30@o4508714045276160.ingest.us.sentry.io/4510461121462272"
 __all__ = ["autoload", "settings", "env"]
 

blaxel/core/client/client.py

@@ -105,6 +105,12 @@ class Client:
     def get_httpx_client(self) -> httpx.Client:
         """Get the underlying httpx.Client, constructing a new one if not previously set"""
         if self._client is None:
+            # Set default limits if not provided in httpx_args to prevent TLS handshake issues
+            limits = self._httpx_args.get("limits")
+            if limits is None:
+                limits = httpx.Limits(max_connections=100, max_keepalive_connections=20)
+            # Disable HTTP/2 to prevent TLS handshake issues in certain environments
+            http2 = self._httpx_args.get("http2", False)
             self._client = httpx.Client(
                 base_url=self._base_url,
                 cookies=self._cookies,
@@ -113,7 +119,9 @@ class Client:
                 verify=self._verify_ssl,
                 follow_redirects=self._follow_redirects,
                 auth=self._auth,
-                **self._httpx_args,
+                limits=limits,
+                http2=http2,
+                **{k: v for k, v in self._httpx_args.items() if k not in ("limits", "http2")},
             )
         return self._client
 
@@ -137,6 +145,12 @@ class Client:
     def get_async_httpx_client(self) -> httpx.AsyncClient:
         """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
         if self._async_client is None:
+            # Set default limits if not provided in httpx_args to prevent TLS handshake issues
+            limits = self._httpx_args.get("limits")
+            if limits is None:
+                limits = httpx.Limits(max_connections=100, max_keepalive_connections=20)
+            # Disable HTTP/2 to prevent TLS handshake issues in certain environments
+            http2 = self._httpx_args.get("http2", False)
             self._async_client = httpx.AsyncClient(
                 base_url=self._base_url,
                 cookies=self._cookies,
@@ -145,7 +159,9 @@ class Client:
                 verify=self._verify_ssl,
                 follow_redirects=self._follow_redirects,
                 auth=self._auth,
-                **self._httpx_args,
+                limits=limits,
+                http2=http2,
+                **{k: v for k, v in self._httpx_args.items() if k not in ("limits", "http2")},
             )
         return self._async_client
 

blaxel/core/sandbox/client/api/filesystem/delete_filesystem_tree_path.py

@@ -0,0 +1,188 @@
+from http import HTTPStatus
+from typing import Any, Union
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.error_response import ErrorResponse
+from ...models.success_response import SuccessResponse
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    path: str,
+    *,
+    recursive: Union[Unset, bool] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["recursive"] = recursive
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": f"/filesystem/tree/{path}",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Union[ErrorResponse, SuccessResponse] | None:
+    if response.status_code == 200:
+        response_200 = SuccessResponse.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = ErrorResponse.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 422:
+        response_422 = ErrorResponse.from_dict(response.json())
+
+        return response_422
+    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, SuccessResponse]]:
+    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],
+    recursive: Union[Unset, bool] = UNSET,
+) -> Response[Union[ErrorResponse, SuccessResponse]]:
+    """Delete directory tree
+
+     Delete a directory tree recursively
+
+    Args:
+        path (str):
+        recursive (Union[Unset, bool]):
+
+    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, SuccessResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        path=path,
+        recursive=recursive,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    path: str,
+    *,
+    client: Union[Client],
+    recursive: Union[Unset, bool] = UNSET,
+) -> Union[ErrorResponse, SuccessResponse] | None:
+    """Delete directory tree
+
+     Delete a directory tree recursively
+
+    Args:
+        path (str):
+        recursive (Union[Unset, bool]):
+
+    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, SuccessResponse]
+    """
+
+    return sync_detailed(
+        path=path,
+        client=client,
+        recursive=recursive,
+    ).parsed
+
+
+async def asyncio_detailed(
+    path: str,
+    *,
+    client: Union[Client],
+    recursive: Union[Unset, bool] = UNSET,
+) -> Response[Union[ErrorResponse, SuccessResponse]]:
+    """Delete directory tree
+
+     Delete a directory tree recursively
+
+    Args:
+        path (str):
+        recursive (Union[Unset, bool]):
+
+    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, SuccessResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        path=path,
+        recursive=recursive,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    path: str,
+    *,
+    client: Union[Client],
+    recursive: Union[Unset, bool] = UNSET,
+) -> Union[ErrorResponse, SuccessResponse] | None:
+    """Delete directory tree
+
+     Delete a directory tree recursively
+
+    Args:
+        path (str):
+        recursive (Union[Unset, bool]):
+
+    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, SuccessResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            path=path,
+            client=client,
+            recursive=recursive,
+        )
+    ).parsed

blaxel/core/sandbox/client/api/filesystem/get_filesystem_content_search_path.py

@@ -0,0 +1,250 @@
+from http import HTTPStatus
+from typing import Any, Union
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.content_search_response import ContentSearchResponse
+from ...models.error_response import ErrorResponse
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    path: str,
+    *,
+    query: str,
+    case_sensitive: Union[Unset, bool] = UNSET,
+    max_results: Union[Unset, int] = UNSET,
+    file_pattern: Union[Unset, str] = UNSET,
+    exclude_dirs: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["query"] = query
+
+    params["caseSensitive"] = case_sensitive
+
+    params["maxResults"] = max_results
+
+    params["filePattern"] = file_pattern
+
+    params["excludeDirs"] = exclude_dirs
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/filesystem-content-search/{path}",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Union[ContentSearchResponse, ErrorResponse] | None:
+    if response.status_code == 200:
+        response_200 = ContentSearchResponse.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = ErrorResponse.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 422:
+        response_422 = ErrorResponse.from_dict(response.json())
+
+        return response_422
+    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[ContentSearchResponse, ErrorResponse]]:
+    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],
+    query: str,
+    case_sensitive: Union[Unset, bool] = UNSET,
+    max_results: Union[Unset, int] = UNSET,
+    file_pattern: Union[Unset, str] = UNSET,
+    exclude_dirs: Union[Unset, str] = UNSET,
+) -> Response[Union[ContentSearchResponse, ErrorResponse]]:
+    """Search for text content in files
+
+     Searches for text content inside files using ripgrep. Returns matching lines with context.
+
+    Args:
+        path (str):
+        query (str):
+        case_sensitive (Union[Unset, bool]):
+        max_results (Union[Unset, int]):
+        file_pattern (Union[Unset, str]):
+        exclude_dirs (Union[Unset, 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[ContentSearchResponse, ErrorResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        path=path,
+        query=query,
+        case_sensitive=case_sensitive,
+        max_results=max_results,
+        file_pattern=file_pattern,
+        exclude_dirs=exclude_dirs,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    path: str,
+    *,
+    client: Union[Client],
+    query: str,
+    case_sensitive: Union[Unset, bool] = UNSET,
+    max_results: Union[Unset, int] = UNSET,
+    file_pattern: Union[Unset, str] = UNSET,
+    exclude_dirs: Union[Unset, str] = UNSET,
+) -> Union[ContentSearchResponse, ErrorResponse] | None:
+    """Search for text content in files
+
+     Searches for text content inside files using ripgrep. Returns matching lines with context.
+
+    Args:
+        path (str):
+        query (str):
+        case_sensitive (Union[Unset, bool]):
+        max_results (Union[Unset, int]):
+        file_pattern (Union[Unset, str]):
+        exclude_dirs (Union[Unset, 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[ContentSearchResponse, ErrorResponse]
+    """
+
+    return sync_detailed(
+        path=path,
+        client=client,
+        query=query,
+        case_sensitive=case_sensitive,
+        max_results=max_results,
+        file_pattern=file_pattern,
+        exclude_dirs=exclude_dirs,
+    ).parsed
+
+
+async def asyncio_detailed(
+    path: str,
+    *,
+    client: Union[Client],
+    query: str,
+    case_sensitive: Union[Unset, bool] = UNSET,
+    max_results: Union[Unset, int] = UNSET,
+    file_pattern: Union[Unset, str] = UNSET,
+    exclude_dirs: Union[Unset, str] = UNSET,
+) -> Response[Union[ContentSearchResponse, ErrorResponse]]:
+    """Search for text content in files
+
+     Searches for text content inside files using ripgrep. Returns matching lines with context.
+
+    Args:
+        path (str):
+        query (str):
+        case_sensitive (Union[Unset, bool]):
+        max_results (Union[Unset, int]):
+        file_pattern (Union[Unset, str]):
+        exclude_dirs (Union[Unset, 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[ContentSearchResponse, ErrorResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        path=path,
+        query=query,
+        case_sensitive=case_sensitive,
+        max_results=max_results,
+        file_pattern=file_pattern,
+        exclude_dirs=exclude_dirs,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    path: str,
+    *,
+    client: Union[Client],
+    query: str,
+    case_sensitive: Union[Unset, bool] = UNSET,
+    max_results: Union[Unset, int] = UNSET,
+    file_pattern: Union[Unset, str] = UNSET,
+    exclude_dirs: Union[Unset, str] = UNSET,
+) -> Union[ContentSearchResponse, ErrorResponse] | None:
+    """Search for text content in files
+
+     Searches for text content inside files using ripgrep. Returns matching lines with context.
+
+    Args:
+        path (str):
+        query (str):
+        case_sensitive (Union[Unset, bool]):
+        max_results (Union[Unset, int]):
+        file_pattern (Union[Unset, str]):
+        exclude_dirs (Union[Unset, 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[ContentSearchResponse, ErrorResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            path=path,
+            client=client,
+            query=query,
+            case_sensitive=case_sensitive,
+            max_results=max_results,
+            file_pattern=file_pattern,
+            exclude_dirs=exclude_dirs,
+        )
+    ).parsed