volcano-sdk-python 0.13.4__py3-none-any.whl → 0.14.0__py3-none-any.whl

volcano_sdk/__init__.py

@@ -7,6 +7,7 @@ from .errors import (
     AuthenticationError,
     ConflictError,
     NotFoundError,
+    PermissionDeniedError,
     RateLimitedError,
     ServerError,
     SessionChangedError,
@@ -19,6 +20,19 @@ from .models import (
     AuthSession,
     AuthStateCallback,
     AuthSubscription,
+    DurableApproval,
+    DurableApprovalCounts,
+    DurableApprovalDailyCounts,
+    DurableApprovalDecider,
+    DurableApprovalDecision,
+    DurableApprovalExecution,
+    DurableApprovalFunction,
+    DurableApprovalFunctionCounts,
+    DurableApprovalListOptions,
+    DurableApprovalPage,
+    DurableApprovalStats,
+    DurableApprovalStatsOptions,
+    DurableApprovalStatus,
     DurableExecution,
     DurableExecutionFailure,
     DurableExecutionPage,
@@ -58,6 +72,19 @@ __all__ = [
     "AuthSubscription",
     "AuthenticationError",
     "ConflictError",
+    "DurableApproval",
+    "DurableApprovalCounts",
+    "DurableApprovalDailyCounts",
+    "DurableApprovalDecider",
+    "DurableApprovalDecision",
+    "DurableApprovalExecution",
+    "DurableApprovalFunction",
+    "DurableApprovalFunctionCounts",
+    "DurableApprovalListOptions",
+    "DurableApprovalPage",
+    "DurableApprovalStats",
+    "DurableApprovalStatsOptions",
+    "DurableApprovalStatus",
     "DurableExecution",
     "DurableExecutionFailure",
     "DurableExecutionPage",
@@ -73,12 +100,29 @@ __all__ = [
     "NotFoundError",
     "OAuthProviderName",
     "OAuthProviderTokenStatus",
+    "PermissionDeniedError",
     "PostgresChange",
     "RateLimitedError",
     "RealtimeConnectContext",
     "RealtimeDisconnectContext",
     "RealtimeErrorContext",
     "RealtimePresenceInfo",
+    "SandboxAccess",
+    "SandboxBuildLog",
+    "SandboxBuildLogOptions",
+    "SandboxBuildLogPage",
+    "SandboxCommandOptions",
+    "SandboxCommandResult",
+    "SandboxCreateOptions",
+    "SandboxDeployOptions",
+    "SandboxDeployment",
+    "SandboxDeploymentPage",
+    "SandboxExecOptions",
+    "SandboxExecutionResult",
+    "SandboxPreset",
+    "SandboxSession",
+    "SandboxState",
+    "Sandboxes",
     "ServerError",
     "Session",
     "SessionChangedError",
@@ -97,3 +141,24 @@ __all__ = [
     "VolcanoError",
     "database_connection_string",
 ]
+
+from .sandbox_deployment_models import (
+    SandboxBuildLog,
+    SandboxBuildLogOptions,
+    SandboxBuildLogPage,
+    SandboxDeployment,
+    SandboxDeploymentPage,
+    SandboxDeployOptions,
+)
+from .sandbox_models import (
+    SandboxAccess,
+    SandboxCommandOptions,
+    SandboxCommandResult,
+    SandboxCreateOptions,
+    SandboxExecOptions,
+    SandboxExecutionResult,
+    SandboxPreset,
+    SandboxState,
+)
+from .sandbox_session import SandboxSession
+from .sandboxes import Sandboxes

volcano_sdk/_auth_base.py

@@ -0,0 +1,47 @@
+"""Shared authentication facade capabilities."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ._auth_context import auth_context
+from ._auth_requests import AuthRequests
+from ._auth_values import (
+    user_from_payload,
+)
+from .errors import (
+    SessionChangedError,
+)
+
+if TYPE_CHECKING:
+    from ._auth_context import AuthContext, AuthContextSource
+    from ._session_operations import SessionOperations
+    from .models import (
+        Session,
+        User,
+    )
+
+
+class AuthBase:
+    """Share typed client capabilities across authentication operation groups."""
+
+    def __init__(
+        self,
+        client: AuthContext | AuthContextSource,
+        *,
+        _requests: AuthRequests | None = None,
+    ) -> None:
+        """Create an authentication facade backed by a client."""
+        self._client: AuthContext = auth_context(client)
+        self._requests: AuthRequests = (
+            AuthRequests(self._client) if _requests is None else _requests
+        )
+
+    def _update_current_user(
+        self, payload: object, binding: tuple[int, SessionOperations, Session | None]
+    ) -> User:
+        generation = self._requests.owned_session(binding)[0]
+        user, snapshot = user_from_payload(payload)
+        if not self._client.update_session_user_if_current(snapshot, generation):
+            raise SessionChangedError
+        return user

volcano_sdk/_auth_context.py

@@ -0,0 +1,88 @@
+"""Typed client capabilities for authentication."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+
+    from ._session_operations import SessionOperations
+    from ._transport import (
+        Transport,
+    )
+    from .models import (
+        AuthChangeEvent,
+        AuthStateCallback,
+        AuthSubscription,
+        JSONValue,
+        Session,
+    )
+
+
+class SetSession(Protocol):
+    def __call__(
+        self,
+        session: Session,
+        *,
+        event: AuthChangeEvent | None,
+    ) -> None: ...
+
+
+class SetSessionIfCurrent(Protocol):
+    def __call__(
+        self,
+        session: Session,
+        generation: int,
+        *,
+        event: AuthChangeEvent,
+        notifications: list[Callable[[], None]] | None = None,
+    ) -> bool: ...
+
+
+class ClearSessionIfCurrent(Protocol):
+    def __call__(
+        self,
+        generation: int,
+        *,
+        lineage: SessionOperations | None = None,
+        event: AuthChangeEvent,
+        notifications: list[Callable[[], None]] | None = None,
+    ) -> bool: ...
+
+
+@dataclass(frozen=True, slots=True)
+class AuthContext:
+    """Typed client operations required by the authentication facade."""
+
+    transport: Callable[[], Transport]
+    current_session: Callable[[], Session | None]
+    anon_token: Callable[[], str]
+    api_base_url: Callable[[], str]
+    set_session: SetSession
+    capture_session: Callable[[], tuple[int, Session | None]]
+    capture_session_binding: Callable[[], tuple[int, SessionOperations, Session | None]]
+    update_session_user_if_current: Callable[[Mapping[str, JSONValue], int], bool]
+    set_session_if_current: SetSessionIfCurrent
+    clear_session_if_current: ClearSessionIfCurrent
+    subscribe_auth_state_change: Callable[[AuthStateCallback], AuthSubscription]
+
+
+@runtime_checkable
+class AuthContextSource(Protocol):
+    """The private authentication context factory retained by VolcanoClient."""
+
+    def _auth_context(self) -> AuthContext: ...
+
+
+def auth_context(client: AuthContextSource | AuthContext) -> AuthContext:
+    """Preserve Auth(client) while keeping its internal callbacks private.
+
+    Returns:
+        The client's authentication capabilities or the supplied context.
+
+    """
+    if isinstance(client, AuthContextSource):
+        return client._auth_context()  # ruff: ignore[private-member-access] # pyright: ignore[reportPrivateUsage]
+    return client

volcano_sdk/_auth_email.py

@@ -0,0 +1,185 @@
+"""Email identity, confirmation, and password recovery operations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ._auth_base import AuthBase
+from ._auth_values import (
+    INVALID_AUTH_TRANSPORT,
+    NO_ACTIVE_SESSION,
+    email_change_result_from_payload,
+)
+from ._transport import (
+    AuthCancelEmailChangeTransport,
+    AuthConfirmEmailChangeTransport,
+    AuthConfirmEmailTransport,
+    AuthForgotPasswordTransport,
+    AuthRequestEmailChangeTransport,
+    AuthResendConfirmationTransport,
+    AuthResetPasswordTransport,
+    invoke,
+    response_payload,
+)
+from .errors import (
+    AuthenticationError,
+)
+
+if TYPE_CHECKING:
+    from .models import (
+        EmailChangeResult,
+        User,
+    )
+
+
+class EmailAuth(AuthBase):
+    """Email identity, confirmation, and password recovery operations."""
+
+    def reset_password_for_email(self, *, email: str) -> None:
+        """Request a reset email without revealing whether the account exists.
+
+        Raises:
+            TypeError: The transport does not support this authentication operation.
+
+        """
+        transport = self._client.transport()
+        if not isinstance(transport, AuthForgotPasswordTransport):
+            raise TypeError(INVALID_AUTH_TRANSPORT)
+        response = invoke(
+            transport.auth_forgot_password,
+            authorization=self._client.anon_token(),
+            email=email,
+        )
+        _ = response_payload(response, 200)
+
+    def request_email_change(self, *, new_email: str) -> EmailChangeResult:
+        """Request a confirmation email without changing the current session.
+
+        Returns:
+            The server acknowledgement of the requested email change.
+
+        Raises:
+            AuthenticationError: There is no active session.
+            TypeError: The transport does not support this authentication operation.
+
+        """
+        binding = self._client.capture_session_binding()
+        if binding[2] is None:
+            raise AuthenticationError(NO_ACTIVE_SESSION)
+        transport = self._client.transport()
+        if not isinstance(transport, AuthRequestEmailChangeTransport):
+            raise TypeError(INVALID_AUTH_TRANSPORT)
+        response = self._requests.request(
+            lambda access_token: invoke(
+                transport.auth_request_email_change,
+                authorization=access_token,
+                new_email=new_email,
+            ),
+            binding=binding,
+        )
+        result = email_change_result_from_payload(response_payload(response, 200))
+        _ = self._requests.owned_session(binding)
+        return result
+
+    def cancel_email_change(self) -> None:
+        """Cancel a pending email change without changing the current session.
+
+        Raises:
+            AuthenticationError: There is no active session.
+            TypeError: The transport does not support this authentication operation.
+
+        """
+        binding = self._client.capture_session_binding()
+        if binding[2] is None:
+            raise AuthenticationError(NO_ACTIVE_SESSION)
+        transport = self._client.transport()
+        if not isinstance(transport, AuthCancelEmailChangeTransport):
+            raise TypeError(INVALID_AUTH_TRANSPORT)
+        response = self._requests.request(
+            lambda access_token: invoke(
+                transport.auth_cancel_email_change,
+                authorization=access_token,
+            ),
+            binding=binding,
+        )
+        _ = response_payload(response, 200)
+        _ = self._requests.owned_session(binding)
+
+    def confirm_email_change(self, *, token: str) -> User:
+        """Confirm a pending email change and return the updated user.
+
+        Returns:
+            The updated profile after confirming the new email.
+
+        Raises:
+            AuthenticationError: There is no active session.
+            TypeError: The transport does not support this authentication operation.
+
+        """
+        binding = self._client.capture_session_binding()
+        if binding[2] is None:
+            raise AuthenticationError(NO_ACTIVE_SESSION)
+        transport = self._client.transport()
+        if not isinstance(transport, AuthConfirmEmailChangeTransport):
+            raise TypeError(INVALID_AUTH_TRANSPORT)
+        response = self._requests.request(
+            lambda access_token: invoke(
+                transport.auth_confirm_email_change,
+                authorization=access_token,
+                token=token,
+            ),
+            binding=binding,
+        )
+        return self._update_current_user(response_payload(response, 200), binding)
+
+    def confirm_email(self, *, token: str) -> None:
+        """Confirm an email with its token without changing local state.
+
+        Raises:
+            TypeError: The transport does not support this authentication operation.
+
+        """
+        transport = self._client.transport()
+        if not isinstance(transport, AuthConfirmEmailTransport):
+            raise TypeError(INVALID_AUTH_TRANSPORT)
+        response = invoke(
+            transport.auth_confirm_email,
+            authorization=self._client.anon_token(),
+            token=token,
+        )
+        _ = response_payload(response, 200)
+
+    def resend_confirmation(self, *, email: str) -> None:
+        """Request a generic confirmation resend without changing local state.
+
+        Raises:
+            TypeError: The transport does not support this authentication operation.
+
+        """
+        transport = self._client.transport()
+        if not isinstance(transport, AuthResendConfirmationTransport):
+            raise TypeError(INVALID_AUTH_TRANSPORT)
+        response = invoke(
+            transport.auth_resend_confirmation,
+            authorization=self._client.anon_token(),
+            email=email,
+        )
+        _ = response_payload(response, 200)
+
+    def reset_password(self, *, token: str, new_password: str) -> None:
+        """Set a new password with a recovery token without changing local state.
+
+        Raises:
+            TypeError: The transport does not support this authentication operation.
+
+        """
+        transport = self._client.transport()
+        if not isinstance(transport, AuthResetPasswordTransport):
+            raise TypeError(INVALID_AUTH_TRANSPORT)
+        response = invoke(
+            transport.auth_reset_password,
+            authorization=self._client.anon_token(),
+            token=token,
+            new_password=new_password,
+        )
+        _ = response_payload(response, 200)