blaxel 0.64.0__py3-none-any.whl

blaxel/api/workspaces/update_workspace.py

@@ -0,0 +1,176 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.workspace import Workspace
+from ...types import Response
+
+
+def _get_kwargs(
+    workspace_name: str,
+    *,
+    body: Workspace,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": f"/workspaces/{workspace_name}",
+    }
+
+    _body = body.to_dict()
+
+    _kwargs["json"] = _body
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[Workspace]:
+    if response.status_code == 200:
+        response_200 = Workspace.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: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[Workspace]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    workspace_name: str,
+    *,
+    client: AuthenticatedClient,
+    body: Workspace,
+) -> Response[Workspace]:
+    """Update workspace
+
+     Updates a workspace by name.
+
+    Args:
+        workspace_name (str):
+        body (Workspace): Workspace
+
+    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[Workspace]
+    """
+
+    kwargs = _get_kwargs(
+        workspace_name=workspace_name,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    workspace_name: str,
+    *,
+    client: AuthenticatedClient,
+    body: Workspace,
+) -> Optional[Workspace]:
+    """Update workspace
+
+     Updates a workspace by name.
+
+    Args:
+        workspace_name (str):
+        body (Workspace): Workspace
+
+    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:
+        Workspace
+    """
+
+    return sync_detailed(
+        workspace_name=workspace_name,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace_name: str,
+    *,
+    client: AuthenticatedClient,
+    body: Workspace,
+) -> Response[Workspace]:
+    """Update workspace
+
+     Updates a workspace by name.
+
+    Args:
+        workspace_name (str):
+        body (Workspace): Workspace
+
+    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[Workspace]
+    """
+
+    kwargs = _get_kwargs(
+        workspace_name=workspace_name,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    workspace_name: str,
+    *,
+    client: AuthenticatedClient,
+    body: Workspace,
+) -> Optional[Workspace]:
+    """Update workspace
+
+     Updates a workspace by name.
+
+    Args:
+        workspace_name (str):
+        body (Workspace): Workspace
+
+    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:
+        Workspace
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace_name=workspace_name,
+            client=client,
+            body=body,
+        )
+    ).parsed

blaxel/api/workspaces/update_workspace_user_role.py

@@ -0,0 +1,187 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.update_workspace_user_role_body import UpdateWorkspaceUserRoleBody
+from ...models.workspace_user import WorkspaceUser
+from ...types import Response
+
+
+def _get_kwargs(
+    sub_or_email: str,
+    *,
+    body: UpdateWorkspaceUserRoleBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": f"/users/{sub_or_email}",
+    }
+
+    _body = body.to_dict()
+
+    _kwargs["json"] = _body
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, WorkspaceUser]]:
+    if response.status_code == 200:
+        response_200 = WorkspaceUser.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+    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, WorkspaceUser]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sub_or_email: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateWorkspaceUserRoleBody,
+) -> Response[Union[Any, WorkspaceUser]]:
+    """Update user role in workspace
+
+     Updates the role of a user in the workspace.
+
+    Args:
+        sub_or_email (str):
+        body (UpdateWorkspaceUserRoleBody):
+
+    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, WorkspaceUser]]
+    """
+
+    kwargs = _get_kwargs(
+        sub_or_email=sub_or_email,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sub_or_email: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateWorkspaceUserRoleBody,
+) -> Optional[Union[Any, WorkspaceUser]]:
+    """Update user role in workspace
+
+     Updates the role of a user in the workspace.
+
+    Args:
+        sub_or_email (str):
+        body (UpdateWorkspaceUserRoleBody):
+
+    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, WorkspaceUser]
+    """
+
+    return sync_detailed(
+        sub_or_email=sub_or_email,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sub_or_email: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateWorkspaceUserRoleBody,
+) -> Response[Union[Any, WorkspaceUser]]:
+    """Update user role in workspace
+
+     Updates the role of a user in the workspace.
+
+    Args:
+        sub_or_email (str):
+        body (UpdateWorkspaceUserRoleBody):
+
+    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, WorkspaceUser]]
+    """
+
+    kwargs = _get_kwargs(
+        sub_or_email=sub_or_email,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sub_or_email: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateWorkspaceUserRoleBody,
+) -> Optional[Union[Any, WorkspaceUser]]:
+    """Update user role in workspace
+
+     Updates the role of a user in the workspace.
+
+    Args:
+        sub_or_email (str):
+        body (UpdateWorkspaceUserRoleBody):
+
+    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, WorkspaceUser]
+    """
+
+    return (
+        await asyncio_detailed(
+            sub_or_email=sub_or_email,
+            client=client,
+            body=body,
+        )
+    ).parsed

blaxel/authentication/__init__.py

@@ -0,0 +1,45 @@
+from .apikey import ApiKeyProvider
+from .authentication import (
+    PublicProvider,
+    RunClientWithCredentials,
+    get_authentication_headers,
+    new_client,
+    new_client_from_settings,
+    new_client_with_credentials,
+)
+from .credentials import (
+    Config,
+    ContextConfig,
+    Credentials,
+    WorkspaceConfig,
+    load_credentials,
+    load_credentials_from_settings,
+)
+from .device_mode import (
+    BearerToken,
+    DeviceLogin,
+    DeviceLoginFinalizeRequest,
+    DeviceLoginFinalizeResponse,
+    DeviceLoginResponse,
+)
+
+__all__ = (
+    "ApiKeyProvider",
+    "PublicProvider",
+    "RunClientWithCredentials",
+    "new_client_with_credentials",
+    "new_client_from_settings",
+    "new_client",
+    "get_authentication_headers",
+    "Config",
+    "ContextConfig",
+    "Credentials",
+    "WorkspaceConfig",
+    "load_credentials",
+    "load_credentials_from_settings",
+    "BearerToken",
+    "DeviceLogin",
+    "DeviceLoginFinalizeRequest",
+    "DeviceLoginFinalizeResponse",
+    "DeviceLoginResponse",
+)

blaxel/authentication/apikey.py

@@ -0,0 +1,50 @@
+"""
+This module provides the ApiKeyProvider class, which handles API key-based authentication for Blaxel.
+"""
+
+from typing import Generator
+
+from httpx import Auth, Request, Response
+
+
+class ApiKeyProvider(Auth):
+    """
+    A provider that authenticates requests using an API key.
+    """
+
+    def __init__(self, credentials, workspace_name: str):
+        """
+        Initializes the ApiKeyProvider with the given credentials and workspace name.
+
+        Parameters:
+            credentials: Credentials containing the API key.
+            workspace_name (str): The name of the workspace.
+        """
+        self.credentials = credentials
+        self.workspace_name = workspace_name
+
+    def get_headers(self):
+        """
+        Retrieves the authentication headers containing the API key and workspace information.
+
+        Returns:
+            dict: A dictionary of headers with API key and workspace.
+        """
+        return {
+            "X-Blaxel-Api-Key": self.credentials.apiKey,
+            "X-Blaxel-Workspace": self.workspace_name,
+        }
+
+    def auth_flow(self, request: Request) -> Generator[Request, Response, None]:
+        """
+        Authenticates the request by adding API key and workspace headers.
+
+        Parameters:
+            request (Request): The HTTP request to authenticate.
+
+        Yields:
+            Request: The authenticated request.
+        """
+        request.headers["X-Blaxel-Api-Key"] = self.credentials.apiKey
+        request.headers["X-Blaxel-Workspace"] = self.workspace_name
+        yield request

blaxel/authentication/authentication.py

@@ -0,0 +1,176 @@
+"""
+This module provides classes and functions for handling various authentication methods,
+including public access, API key authentication, client credentials, and bearer tokens.
+It also includes utilities for creating authenticated clients and managing authentication headers.
+"""
+
+from dataclasses import dataclass
+from typing import Dict, Generator
+
+from httpx import Auth, Request, Response
+
+from blaxel.aimon.settings import Settings, get_settings
+
+from ..client import AuthenticatedClient
+from .apikey import ApiKeyProvider
+from .clientcredentials import ClientCredentials
+from .credentials import (
+    Credentials,
+    current_context,
+    load_credentials,
+    load_credentials_from_settings,
+)
+from .device_mode import BearerToken
+
+global provider_singleton
+provider_singleton = None
+
+class PublicProvider(Auth):
+    """
+    A provider that allows public access without any authentication.
+    """
+
+    def auth_flow(self, request: Request) -> Generator[Request, Response, None]:
+        """
+        Processes the authentication flow for public access by yielding the request as-is.
+
+        Parameters:
+            request (Request): The HTTP request to process.
+
+        Yields:
+            Request: The unmodified request.
+        """
+        yield request
+
+
+@dataclass
+class RunClientWithCredentials:
+    """
+    A dataclass that holds credentials and workspace information for initializing an authenticated client.
+
+    Attributes:
+        credentials (Credentials): The credentials used for authentication.
+        workspace (str): The name of the workspace.
+        api_url (str): The base API URL.
+        run_url (str): The run-specific URL.
+    """
+    credentials: Credentials
+    workspace: str
+    api_url: str = ""
+    run_url: str = ""
+
+    def __post_init__(self):
+        """
+        Post-initialization to set the API and run URLs from settings.
+        """
+        from ..common.settings import get_settings
+
+        settings = get_settings()
+        self.api_url = settings.base_url
+        self.run_url = settings.run_url
+
+
+def new_client_from_settings(settings: Settings):
+    """
+    Creates a new authenticated client using the provided settings.
+
+    Parameters:
+        settings (Settings): The settings containing authentication and workspace information.
+
+    Returns:
+        AuthenticatedClient: An instance of AuthenticatedClient configured with the provided settings.
+    """
+    credentials = load_credentials_from_settings(settings)
+
+    client_config = RunClientWithCredentials(
+        credentials=credentials,
+        workspace=settings.workspace,
+    )
+    return new_client_with_credentials(client_config)
+
+
+def new_client():
+    """
+    Creates a new authenticated client based on the current context and settings.
+
+    Returns:
+        AuthenticatedClient: An instance of AuthenticatedClient configured with the current context or settings.
+    """
+    settings = get_settings()
+    context = current_context()
+    if context.workspace and not settings.authentication.client.credentials:
+        credentials = load_credentials(context.workspace)
+        client_config = RunClientWithCredentials(
+            credentials=credentials,
+            workspace=context.workspace,
+        )
+    else:
+        credentials = load_credentials_from_settings(settings)
+        client_config = RunClientWithCredentials(
+            credentials=credentials,
+            workspace=settings.workspace,
+        )
+    return new_client_with_credentials(client_config)
+
+
+def new_client_with_credentials(config: RunClientWithCredentials):
+    """
+    Creates a new authenticated client using the provided client configuration.
+
+    Parameters:
+        config (RunClientWithCredentials): The client configuration containing credentials and workspace information.
+
+    Returns:
+        AuthenticatedClient: An instance of AuthenticatedClient configured with the provided credentials.
+    """
+    provider: Auth = None
+    if config.credentials.apiKey:
+        provider = ApiKeyProvider(config.credentials, config.workspace)
+    elif config.credentials.access_token:
+        provider = BearerToken(config.credentials, config.workspace, config.api_url)
+    elif config.credentials.client_credentials:
+        provider = ClientCredentials(config.credentials, config.workspace, config.api_url)
+    else:
+        provider = PublicProvider()
+
+    return AuthenticatedClient(base_url=config.api_url, provider=provider)
+
+
+def get_authentication_headers(settings: Settings) -> Dict[str, str]:
+    """
+    Retrieves authentication headers based on the current context and settings.
+
+    Parameters:
+        settings (Settings): The settings containing authentication and workspace information.
+
+    Returns:
+        Dict[str, str]: A dictionary of authentication headers.
+    """
+    global provider_singleton
+
+    if provider_singleton:
+        return provider_singleton.get_headers()
+
+    context = current_context()
+    if context.workspace and not settings.authentication.client.credentials:
+        credentials = load_credentials(context.workspace)
+    else:
+        settings = get_settings()
+        credentials = load_credentials_from_settings(settings)
+
+    config = RunClientWithCredentials(
+        credentials=credentials,
+        workspace=settings.workspace,
+    )
+    provider = None
+    if config.credentials.apiKey:
+        provider = ApiKeyProvider(config.credentials, config.workspace)
+    elif config.credentials.access_token:
+        provider = BearerToken(config.credentials, config.workspace, config.api_url)
+    elif config.credentials.client_credentials:
+        provider = ClientCredentials(config.credentials, config.workspace, config.api_url)
+
+    if provider is None:
+        return None
+    provider_singleton = provider
+    return provider.get_headers()