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

volcano_sdk/_session.py

@@ -4,8 +4,8 @@ from __future__ import annotations
 
 import base64
 import json
-from collections.abc import Mapping
-from typing import TYPE_CHECKING, cast
+from collections.abc import Callable, Mapping
+from typing import TYPE_CHECKING, TypeGuard
 from uuid import UUID
 
 from .errors import AuthenticationError
@@ -17,6 +17,11 @@ _JWT_PARTS = 3
 _REFRESH_USER_MISMATCH = "Refreshed session belongs to a different user"
 _REFRESH_SESSION_MISMATCH = "Refreshed credentials belong to a different server session"
 _MISSING_SESSION_ID = "Cannot refresh supplied credentials without a session identifier"
+_decode_json: Callable[[str], object] = json.loads
+
+
+def _is_claim_mapping(value: object) -> TypeGuard[Mapping[object, object]]:
+    return isinstance(value, Mapping)
 
 
 def session_id_from_access_token(access_token: str) -> str | None:
@@ -33,15 +38,12 @@ def session_id_from_access_token(access_token: str) -> str | None:
         return None
     padding = "=" * (-len(parts[1]) % 4)
     try:
-        payload = cast(
-            "object", json.loads(base64.urlsafe_b64decode(parts[1] + padding).decode())
-        )
+        payload = _decode_json(base64.urlsafe_b64decode(parts[1] + padding).decode())
     except (ValueError, UnicodeDecodeError, RecursionError):
         return None
-    if not isinstance(payload, Mapping):
+    if not _is_claim_mapping(payload):
         return None
-    values = cast("Mapping[object, object]", payload)
-    return _normalized_session_id(values.get("session_id"))
+    return _normalized_session_id(payload.get("session_id"))
 
 
 def _normalized_session_id(session_id: object) -> str | None:

volcano_sdk/_session_operations.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from concurrent.futures import Future
-from threading import Lock
+from threading import Lock, get_ident
 from typing import TYPE_CHECKING, TypeVar
 
 from .errors import SessionChangedError, VolcanoError
@@ -44,6 +44,8 @@ class SessionOperations:
         self._lock: LockType = Lock()
         self.refreshing: Future[Session] | None = None
         self.signing_out: Future[BaseException | None] | None = None
+        self._refresh_owner: int | None = None
+        self._sign_out_owner: int | None = None
         self._locally_cleared: bool = False
         self._verified_pair: tuple[str, str | None] | None = (
             (verified.access_token, verified.refresh_token)
@@ -91,11 +93,15 @@ class SessionOperations:
             future = self.refreshing
             if future is None or future.done():
                 future = self.refreshing = Future()
-                owner = True
+                claimed = future
+                self._refresh_owner = get_ident()
             else:
-                owner = False
-        if owner:
-            self._complete(future, operation)
+                claimed = None
+        if claimed is None and self._refresh_owner == get_ident() and not future.done():
+            message = "Reentrant refresh"
+            raise RuntimeError(message)
+        if claimed is not None:
+            self._complete(claimed, operation)
         return future.result()
 
     def sign_out(
@@ -105,13 +111,21 @@ class SessionOperations:
             future = self.signing_out
             if future is None:
                 future = self.signing_out = Future()
-                owner = True
+                claimed = future
+                self._sign_out_owner = get_ident()
             else:
-                owner = False
+                claimed = None
             preceding = self.refreshing
             pending = preceding is not None and not preceding.done()
-        if owner:
-            self._complete_revocation(future, operation, preceding, pending=pending)
+        if (
+            claimed is None
+            and self._sign_out_owner == get_ident()
+            and not future.done()
+        ):
+            message = "Reentrant sign-out"
+            raise RuntimeError(message)
+        if claimed is not None:
+            self._complete_revocation(claimed, operation, preceding, pending=pending)
         self._sign_out_result(future)
 
     def wait_for_sign_out(self) -> None:

volcano_sdk/_transport.py

@@ -11,6 +11,7 @@ from typing import (
     TYPE_CHECKING,
     ParamSpec,
     Protocol,
+    TypeGuard,
     TypeVar,
     cast,
     overload,
@@ -288,6 +289,8 @@ HTTP_RATE_LIMITED = 429
 HTTP_OK = 200
 HTTP_SERVER_ERROR_MIN = 500
 HTTP_SERVER_ERROR_MAX = 599
+_RETRY_AFTER_HEADER = "Retry-After"
+_URL_TRAILING_SLASHES = "/"
 _MALFORMED_USER_PROFILE = "Expected a complete user profile"
 _MALFORMED_SESSION_PAGE = "Expected a complete session page"
 _MALFORMED_LINKED_OAUTH_PROVIDERS = "Expected complete linked OAuth providers"
@@ -351,6 +354,17 @@ class _ParsedHTTPResponse(_RawHTTPResponse, Protocol):
     def parsed(self) -> object: ...
 
 
+class _JSONResponse(Protocol):
+    def json(self) -> object: ...
+
+
+class _JSONDecoder(Protocol):
+    def __call__(self, document: bytes, /) -> object: ...
+
+
+_decode_json: _JSONDecoder = json.loads
+
+
 @runtime_checkable
 class _ModelPayload(Protocol):
     def to_dict(self) -> Mapping[str, object]: ...
@@ -704,7 +718,7 @@ class Transport(Protocol):
         bucket_name: str,
         path: str,
         data: bytes,
-        content_type: str = "application/octet-stream",
+        content_type: str,
     ) -> TransportResponse: ...
 
     def download_storage_object(
@@ -802,14 +816,21 @@ def _required_request_string(kwargs: Mapping[str, object], key: str) -> str:
     return value
 
 
+def _is_object_mapping(value: object) -> TypeGuard[Mapping[object, object]]:
+    return isinstance(value, Mapping)
+
+
+def _is_object_dict(value: object) -> TypeGuard[dict[object, object]]:
+    return isinstance(value, dict)
+
+
 def _request_headers(kwargs: Mapping[str, object]) -> dict[str, str]:
     raw_headers = kwargs.get("headers", {})
-    if not isinstance(raw_headers, Mapping):
+    if not _is_object_mapping(raw_headers):
         field = "headers"
         raise _InvalidGeneratedRequestError(field)
-    source = cast("Mapping[object, object]", raw_headers)
     headers: dict[str, str] = {}
-    for key, value in source.items():
+    for key, value in raw_headers.items():
         if not isinstance(key, str) or not isinstance(value, str):
             field = "headers"
             raise _InvalidGeneratedRequestError(field)
@@ -823,12 +844,11 @@ def _request_params(
     raw_params = kwargs.get("params")
     if raw_params is None:
         return None
-    if not isinstance(raw_params, Mapping):
+    if not _is_object_mapping(raw_params):
         field = "params"
         raise _InvalidGeneratedRequestError(field)
-    source = cast("Mapping[object, object]", raw_params)
     params: dict[str, str | int | float | bool | None] = {}
-    for key, value in source.items():
+    for key, value in raw_params.items():
         if not isinstance(key, str) or (
             value is not None and not isinstance(value, (str, int, float, bool))
         ):
@@ -853,14 +873,13 @@ def _generated_request(
     )
 
 
-def _json_object(response: httpx.Response) -> dict[str, object]:
-    raw = cast("object", response.json())
-    if not isinstance(raw, dict):
+def _json_object(response: _JSONResponse) -> dict[str, object]:
+    raw = response.json()
+    if not _is_object_dict(raw):
         field = "response body"
         raise _InvalidGeneratedRequestError(field)
-    source = cast("Mapping[object, object]", raw)
     payload: dict[str, object] = {}
-    for key, value in source.items():
+    for key, value in raw.items():
         if not isinstance(key, str):
             field = "response body key"
             raise _InvalidGeneratedRequestError(field)
@@ -873,10 +892,7 @@ def response_payload(response: TransportResponse, expected_status: int) -> objec
     if status != expected_status:
         payload: Mapping[object, object]
         raw_payload = response.payload
-        if isinstance(raw_payload, dict):
-            payload = cast("Mapping[object, object]", raw_payload)
-        else:
-            payload = {}
+        payload = raw_payload if _is_object_dict(raw_payload) else {}
         message = str(
             payload.get("error") or payload.get("message") or "Volcano request failed"
         )
@@ -884,7 +900,7 @@ def response_payload(response: TransportResponse, expected_status: int) -> objec
         code = str(code_value) if code_value is not None else None
         retry_after = None
         if status == HTTP_RATE_LIMITED:
-            retry_after_value = _header(response.headers, "Retry-After")
+            retry_after_value = _header(response.headers, _RETRY_AFTER_HEADER)
             try:
                 retry_after = (
                     int(retry_after_value) if retry_after_value is not None else None
@@ -908,7 +924,7 @@ class GeneratedTransport:
         timeout: float = 60.0,
         httpx_transport: httpx.BaseTransport | None = None,
     ) -> None:
-        self._api_url: str = api_url.rstrip("/")
+        self._api_url: str = api_url.rstrip(_URL_TRAILING_SLASHES)
         self._timeout: float = timeout
         self._httpx_transport: httpx.BaseTransport | None = httpx_transport
 
@@ -932,7 +948,7 @@ class GeneratedTransport:
             payload = parsed
         else:
             try:
-                raw = cast("object", json.loads(response.content))
+                raw = _decode_json(response.content)
                 payload = raw
             except (json.JSONDecodeError, UnicodeDecodeError):
                 payload = None
@@ -946,7 +962,7 @@ class GeneratedTransport:
     @staticmethod
     def _raw_response(response: _RawHTTPResponse) -> TransportResponse:
         try:
-            payload = cast("object", json.loads(response.content))
+            payload = _decode_json(response.content)
         except (json.JSONDecodeError, UnicodeDecodeError):
             payload = None
         return _GeneratedTransportResponse(
@@ -1833,14 +1849,8 @@ class GeneratedTransport:
         # invoke contract's { payload } envelope.
         plain_payload = _plain_json(payload)
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                method="POST",
-                url=invoke_url,
-                json={"payload": plain_payload},
-                headers={
-                    "Authorization": f"Bearer {authorization}",
-                    "Content-Type": "application/json",
-                },
+            response = client.get_httpx_client().post(
+                invoke_url, json={"payload": plain_payload}
             )
         return self._raw_response(response)
 

volcano_sdk/auth.py

@@ -459,12 +459,22 @@ def _oauth_provider_token_status_from_payload(
     )
 
 
+class _OAuthAPIData(Protocol):
+    @property
+    def data(self) -> object: ...
+
+
+def _oauth_api_data(payload: _OAuthAPIData) -> object:
+    return payload.data
+
+
 def _oauth_api_data_from_payload(payload: object) -> JSONValue:
     if not isinstance(payload, CallOAuthProviderAPIResponse200):
         raise VolcanoError(_INVALID_OAUTH_API_RESPONSE)
-    if not _is_json_value(payload.data):
+    data = _oauth_api_data(payload)
+    if not _is_json_value(data):
         raise VolcanoError(_INVALID_OAUTH_API_RESPONSE)
-    return _freeze_json(payload.data)
+    return _freeze_json(data)
 
 
 class _SetSession(Protocol):

volcano_sdk/durable.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping, Sequence
+import math
+from collections.abc import Mapping
 from datetime import datetime
-from typing import Protocol, cast, runtime_checkable
+from typing import Protocol, TypeGuard, runtime_checkable
 from uuid import UUID
 
 from ._transport import (
@@ -46,6 +47,15 @@ _UUID_IDENTIFIERS = {
 }
 _HTTP_ACCEPTED = 202
 _HTTP_OK = 200
+_EXECUTION_STATUSES: tuple[DurableExecutionStatus, ...] = (
+    "pending",
+    "running",
+    "succeeded",
+    "failed",
+    "timed_out",
+    "stopped",
+    "unknown",
+)
 
 
 class DurableClientContext(Protocol):
@@ -318,13 +328,105 @@ def _identifier(value: object, field: str) -> str:
 
 
 def _execution_fields(payload: object) -> Mapping[str, object]:
-    if not isinstance(payload, Mapping):
+    if not _is_object_mapping(payload):
         raise TypeError(_INVALID_EXECUTION_PAYLOAD)
-    values = cast("Mapping[str, object]", payload)
     for required in ("id", "function_id", "name", "status", "region", "created_at"):
-        if not isinstance(values.get(required), str) or not values[required]:
+        if not isinstance(payload.get(required), str) or not payload[required]:
             raise TypeError(_INVALID_EXECUTION_PAYLOAD)
-    return values
+    return payload
+
+
+def _is_object_mapping(value: object) -> TypeGuard[Mapping[str, object]]:
+    return _is_mapping(value) and all(isinstance(key, str) for key in value)
+
+
+def _is_mapping(value: object) -> TypeGuard[Mapping[object, object]]:
+    return isinstance(value, Mapping)
+
+
+def _is_sequence(value: object) -> TypeGuard[list[object] | tuple[object, ...]]:
+    return isinstance(value, (list, tuple))
+
+
+def _execution_status(value: object) -> DurableExecutionStatus:
+    for status in _EXECUTION_STATUSES:
+        if value == status:
+            return status
+    raise TypeError(_INVALID_EXECUTION_PAYLOAD)
+
+
+def _json_result(value: object) -> JSONValue:
+    try:
+        if _is_json_value(value, set()):
+            return value
+    except RecursionError as error:
+        raise TypeError(_INVALID_EXECUTION_PAYLOAD) from error
+    raise TypeError(_INVALID_EXECUTION_PAYLOAD)
+
+
+def _is_json_value(value: object, active: set[int]) -> TypeGuard[JSONValue]:
+    if _is_json_scalar(value):
+        return True
+    if _is_mapping(value):
+        return _is_json_mapping(value, active)
+    if _is_sequence(value):
+        return _is_json_sequence(value, active)
+    return False
+
+
+def _is_json_scalar(value: object) -> TypeGuard[str | int | float | bool | None]:
+    if value is None or isinstance(value, bool):
+        return True
+    if isinstance(value, str):
+        return _is_utf8(value)
+    if isinstance(value, int):
+        return _is_json_int(value)
+    if isinstance(value, float):
+        return math.isfinite(value)
+    return False
+
+
+def _is_utf8(value: str) -> bool:
+    try:
+        _ = value.encode()
+    except UnicodeEncodeError:
+        return False
+    return True
+
+
+def _is_json_int(value: int) -> bool:
+    try:
+        _ = int.__str__(value)
+    except ValueError:
+        return False
+    return True
+
+
+def _is_json_mapping(value: Mapping[object, object], active: set[int]) -> bool:
+    marker = id(value)
+    if marker in active:
+        return False
+    active.add(marker)
+    try:
+        return all(
+            isinstance(key, str) and _is_utf8(key) and _is_json_value(item, active)
+            for key, item in value.items()
+        )
+    finally:
+        active.remove(marker)
+
+
+def _is_json_sequence(
+    value: list[object] | tuple[object, ...], active: set[int]
+) -> bool:
+    marker = id(value)
+    if marker in active:
+        return False
+    active.add(marker)
+    try:
+        return all(_is_json_value(item, active) for item in value)
+    finally:
+        active.remove(marker)
 
 
 def _durable_execution(payload: object) -> DurableExecution:
@@ -337,10 +439,10 @@ def _durable_execution(payload: object) -> DurableExecution:
         id=str(values["id"]),
         function_id=str(values["function_id"]),
         name=str(values["name"]),
-        status=cast("DurableExecutionStatus", str(values["status"])),
+        status=_execution_status(values["status"]),
         region=str(values["region"]),
         created_at=created_at,
-        result=cast("JSONValue", values.get("result")),
+        result=_json_result(values.get("result")),
         result_expired=result_expired,
         error=_durable_error(values.get("error")),
         completed_at=_datetime(values.get("completed_at")),
@@ -350,11 +452,10 @@ def _durable_execution(payload: object) -> DurableExecution:
 def _durable_error(payload: object) -> DurableExecutionFailure | None:
     if payload is None:
         return None
-    if not isinstance(payload, Mapping):
+    if not _is_object_mapping(payload):
         raise TypeError(_INVALID_EXECUTION_PAYLOAD)
-    values = cast("Mapping[str, object]", payload)
-    error_type = values.get("type")
-    message = values.get("message")
+    error_type = payload.get("type")
+    message = payload.get("message")
     return DurableExecutionFailure(
         type=None if error_type is None else str(error_type),
         message=None if message is None else str(message),
@@ -362,23 +463,22 @@ def _durable_error(payload: object) -> DurableExecutionFailure | None:
 
 
 def _durable_execution_page(payload: object) -> DurableExecutionPage:
-    if not isinstance(payload, Mapping):
+    if not _is_object_mapping(payload):
         raise TypeError(_INVALID_EXECUTION_PAGE)
-    values = cast("Mapping[str, object]", payload)
-    raw_data = values.get("data")
+    raw_data: object = payload.get("data")
     if raw_data is None:
-        raw_data = []
-    if not isinstance(raw_data, (list, tuple)):
+        raw_data = list[object]()
+    if not _is_sequence(raw_data):
         raise TypeError(_INVALID_EXECUTION_PAGE)
-    data = tuple(cast("Sequence[object]", raw_data))
-    has_more = values.get("has_more", False)
+    data = tuple(raw_data)
+    has_more = payload.get("has_more", False)
     if not isinstance(has_more, bool):
         raise TypeError(_INVALID_EXECUTION_PAGE)
     return DurableExecutionPage(
         executions=tuple(_durable_execution(entry) for entry in data),
-        page=_count(values.get("page")),
-        limit=_count(values.get("limit")),
-        total=_count(values.get("total")),
+        page=_count(payload.get("page")),
+        limit=_count(payload.get("limit")),
+        total=_count(payload.get("total")),
         has_more=has_more,
     )
 
@@ -402,8 +502,7 @@ def _datetime(value: object) -> datetime | None:
 def _parse_datetime(value: object) -> datetime:
     if not isinstance(value, str) or not value:
         raise TypeError(_INVALID_EXECUTION_PAYLOAD)
-    text = value.replace("Z", "+00:00") if value.endswith("Z") else value
     try:
-        return datetime.fromisoformat(text)
+        return datetime.fromisoformat(value)
     except ValueError as error:
         raise TypeError(_INVALID_EXECUTION_PAYLOAD) from error

volcano_sdk/functions.py

@@ -359,6 +359,13 @@ def _stale_mapping(response: TransportResponse) -> bool:
     )
 
 
+class _JSONLoader(Protocol):
+    def loads(self, s: str, /, *, parse_constant: Callable[[str], None]) -> object: ...
+
+
+_JSON_LOADER: _JSONLoader = json
+
+
 def _function_data(response: TransportResponse) -> JSONValue:
     if not response.content:
         return _json_value(response.payload)
@@ -369,7 +376,7 @@ def _function_data(response: TransportResponse) -> JSONValue:
     is_json = content_type is not None and "application/json" in content_type.lower()
     if is_json or text.startswith(("{", "[")):
         try:
-            decoded: object = json.loads(text, parse_constant=_reject_json_constant)
+            decoded = _JSON_LOADER.loads(text, parse_constant=_reject_json_constant)
             return _json_value(decoded)
         except ValueError:
             pass

volcano_sdk/realtime.py

@@ -10,7 +10,6 @@ from itertools import count
 from types import MappingProxyType
 from typing import (
     TYPE_CHECKING,
-    Any,
     Literal,
     Protocol,
     TypeAlias,
@@ -47,9 +46,11 @@ if TYPE_CHECKING:
 _PostgresFetchRequest: TypeAlias = PostgresFetchRequest
 _SubscriptionT = TypeVar("_SubscriptionT")
 _DefaultT = TypeVar("_DefaultT")
+_MessageT = TypeVar("_MessageT")
 
-MessageCallback = Callable[[Any], object]
-RealtimeCallback = Callable[[Any], object]
+MessageCallback: TypeAlias = Callable[[_MessageT], object]
+RealtimeCallback: TypeAlias = Callable[[_MessageT], object]
+_StoredCallback = Callable[..., object]
 UnsubscribeCallback = Callable[[], None]
 ChannelType: TypeAlias = Literal["broadcast", "presence", "postgres"]
 PostgresEvent: TypeAlias = Literal["INSERT", "UPDATE", "DELETE"]
@@ -703,7 +704,7 @@ def _presence_info(info: object) -> RealtimePresenceInfo:
 
 
 async def _run_connection_callback(
-    callback: RealtimeCallback,
+    callback: _StoredCallback,
     context: object,
 ) -> None:
     result = callback(context)
@@ -738,7 +739,7 @@ class Channel:
         self._name: str = name
         self._type: ChannelType = channel_type
         self._fetch_config: _PostgresFetchConfig = fetch_config
-        self._callbacks: dict[str, list[MessageCallback]] = {}
+        self._callbacks: dict[str, list[_StoredCallback]] = {}
         self._presence_state: dict[str, RealtimePresenceInfo] = {}
         self._presence_events: list[tuple[str, RealtimePresenceInfo]] = []
         self._presence_syncing: bool = False
@@ -787,7 +788,7 @@ class Channel:
         """Canonical channel name sent to realtime."""
         return self._name
 
-    def on(self, event: str, callback: MessageCallback) -> Channel:
+    def on(self, event: str, callback: Callable[[_MessageT], object]) -> Channel:
         """Register a callback for messages or presence events.
 
         Returns
@@ -852,7 +853,9 @@ class Channel:
 
         return unsubscribe
 
-    def on_presence_sync(self, callback: MessageCallback) -> UnsubscribeCallback:
+    def on_presence_sync(
+        self, callback: Callable[[Mapping[str, RealtimePresenceInfo]], object]
+    ) -> UnsubscribeCallback:
         """Observe immutable snapshots of a presence channel's current state.
 
         Requires a presence channel.
@@ -1204,7 +1207,7 @@ class Channel:
 
     async def _run_callback(
         self,
-        callback: MessageCallback,
+        callback: _StoredCallback,
         delivery: _CallbackDelivery,
     ) -> None:
         if not self._callback_delivery_is_current(delivery):
@@ -1406,7 +1409,7 @@ class Realtime:
         self._channels: dict[str, Channel] = {}
         self._callback_tasks: set[asyncio.Task[None]] = set()
         self._removing_channels: set[str] = set()
-        self._connection_callbacks: dict[str, dict[int, RealtimeCallback]] = {
+        self._connection_callbacks: dict[str, dict[int, _StoredCallback]] = {
             "connect": {},
             "disconnect": {},
             "error": {},
@@ -1458,7 +1461,9 @@ class Realtime:
             for request in requests
         )
 
-    def on_connect(self, callback: RealtimeCallback) -> UnsubscribeCallback:
+    def on_connect(
+        self, callback: Callable[[RealtimeConnectContext], object]
+    ) -> UnsubscribeCallback:
         """Register a connection callback.
 
         Returns
@@ -1469,7 +1474,9 @@ class Realtime:
         """
         return self._register_connection_callback("connect", callback)
 
-    def on_disconnect(self, callback: RealtimeCallback) -> UnsubscribeCallback:
+    def on_disconnect(
+        self, callback: Callable[[RealtimeDisconnectContext], object]
+    ) -> UnsubscribeCallback:
         """Register a disconnection callback.
 
         Returns
@@ -1480,7 +1487,9 @@ class Realtime:
         """
         return self._register_connection_callback("disconnect", callback)
 
-    def on_error(self, callback: RealtimeCallback) -> UnsubscribeCallback:
+    def on_error(
+        self, callback: Callable[[RealtimeErrorContext], object]
+    ) -> UnsubscribeCallback:
         """Register a transport-error callback.
 
         Returns
@@ -1494,7 +1503,7 @@ class Realtime:
     def _register_connection_callback(
         self,
         event: str,
-        callback: RealtimeCallback,
+        callback: _StoredCallback,
     ) -> UnsubscribeCallback:
         require_callable(callback, CALLBACK_NOT_CALLABLE)
         callback_id = next(self._callback_ids)

{volcano_sdk_python-0.13.2.dist-info → volcano_sdk_python-0.13.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: volcano-sdk-python
-Version: 0.13.2
+Version: 0.13.4
 Summary: Official Python SDK for Volcano
 Project-URL: Homepage, https://volcano.dev
 Project-URL: Repository, https://github.com/Kong/volcano-sdk-python

{volcano_sdk_python-0.13.2.dist-info → volcano_sdk_python-0.13.4.dist-info}/RECORD

@@ -6,22 +6,22 @@ volcano_sdk/_lock_renewer.py,sha256=cgogAmoRM_An-PdymXumuGmxm62MGqOsQU4c_PYlUjg,
 volcano_sdk/_lock_worker.py,sha256=IJ0TAFyKiLhS40j0LGLUcOnIrdaqCY3_ZVgETtXp0bc,3139
 volcano_sdk/_log_response.py,sha256=nSVV0Ir1szJftohnBj2hiP6-pf-rqsOv67brlJGdwQ8,3907
 volcano_sdk/_realtime_fetch_worker.py,sha256=f3mUPe5qZmGuhA9jfpqEUtpLZmvlJ1FhI1XkNz238FI,10406
-volcano_sdk/_session.py,sha256=qiuAXTxo5Yz3AM2T_gqPWBD7TmKl2KhvfWwpsmu7h9g,3033
-volcano_sdk/_session_operations.py,sha256=MdEWU_SrS56jmYCzyH81jqneb_pbIaJJI8vFb2WZsJo,5807
-volcano_sdk/_transport.py,sha256=WbU20NvfH5YPKApZE9bR4zRsCFNXBHTAbaCP8NiHqeY,65315
-volcano_sdk/auth.py,sha256=iwVAnTJV34q3yXWQbgLttD7rIziT3yIl9M3nB3fh-Uk,58253
+volcano_sdk/_session.py,sha256=FiZD11mtOtXSL68WMQQOirxKLRmWk4NIh25zvJxRqek,3124
+volcano_sdk/_session_operations.py,sha256=dS4seAcD-HNYNs2zOXTk66qA9HliqhXyQwEz91nhY-4,6446
+volcano_sdk/_transport.py,sha256=j85miD43LvghpQZOEKJYbia4WbpGKz6a4W2gkzfQgWw,65308
+volcano_sdk/auth.py,sha256=wO34z_fkwGscosLIPR9aQYyd6NsNMkqxk-8wGJQeJSU,58435
 volcano_sdk/client.py,sha256=HYvcsCD5_FGCkNv2Zo38hH9HYk1gEL8Cowy_U_K0rw8,13923
 volcano_sdk/connection_string.py,sha256=Ba-PrP8oeD1ILG-5zBLz1LPjUDEVoM_7tQwZ5EslB54,2712
 volcano_sdk/database.py,sha256=xZpn5V1zNdft9sgb2W6vO-Sfo61IOJ5bjLS5LpRZ8Sg,13887
-volcano_sdk/durable.py,sha256=zdLKsapHg7o5jgG1XUGKD2r-6rpeUs7wUN58i-gTmWU,13887
+volcano_sdk/durable.py,sha256=D-bo3BR_u1G-0gUAFWO2NGSClgaTElJVFV7hk29KR0I,16307
 volcano_sdk/durable_authoring.py,sha256=DBB31rQqtJQqL7BtOiaEAsz75FeQ1tarUTG1ctftDN8,37322
 volcano_sdk/errors.py,sha256=ujND4F6E9OWr0-VLpuTdvnSZJPVhNUyHnvXJCDp39V0,1649
-volcano_sdk/functions.py,sha256=1H2O8bk_057x080gz7f62x9Etn1mtHvWMXktisJo5HA,16796
+volcano_sdk/functions.py,sha256=AA-cJ1Pf5W2_Qx5NRKI1dgPg6wGxCuU8llfpOcsdGh4,16950
 volcano_sdk/locks.py,sha256=Zf2nBoolXK-zXeAJYdqbhmfkn3OiNUpX7XmmDhvGCmI,11779
 volcano_sdk/logs.py,sha256=VC2mM2kykvVcnFRd082HAAdVC4gn_2RXwvc998m8rK8,4692
 volcano_sdk/models.py,sha256=ZIo2YdZ-Ba7rCmHBo3eV9LGjpEftVTeVmrrfq-zGujs,11182
 volcano_sdk/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-volcano_sdk/realtime.py,sha256=-mUVBwaon5qPFWOsWVyW0jRCeBKbeCd110wBBxD_YcY,66800
+volcano_sdk/realtime.py,sha256=HySI4IemLEsPCWxEhi_1THFWAtEzOoTwDunIqxbZDdk,67083
 volcano_sdk/storage.py,sha256=5RjF1LNZ_qEBBmBAfWB-NHvtqm2_Hyc7bSeOPt4xImI,33461
 volcano_sdk/_generated/__init__.py,sha256=ZlB8wMYdN6EjpUS5W_lX3jsxq9G1kOcmUr-j3Fccfn8,164
 volcano_sdk/_generated/client.py,sha256=GDzw6T2uRmPlUb1DImpBGxwy0dNbhmBknfvvIQW0GuU,12387
@@ -810,7 +810,7 @@ volcano_sdk/_generated/models/usage_data_point.py,sha256=d4U08JbVTiIMM_l2BmRILL1
 volcano_sdk/_generated/models/variable.py,sha256=t8XaBfTwIH42L8RL4DFDtdqbhVfDEnRS5Axq2q6Tpvk,6405
 volcano_sdk/_generated/models/variable_deploy_source.py,sha256=G_aCiFHzQx8WhJFs0GvYZEFclfTrfkDvd3kT1e3vty8,463
 volcano_sdk/_generated/models/variable_status.py,sha256=THSsKBSiAYG4kAtBzGA4TZqxjgx8hdL0Q4qCdZfOj00,391
-volcano_sdk_python-0.13.2.dist-info/METADATA,sha256=1h3743OIToGmex6Rb8-s_PAgPuTSJ7e5xrKM718o1Bs,46989
-volcano_sdk_python-0.13.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-volcano_sdk_python-0.13.2.dist-info/licenses/LICENSE,sha256=AIHJy-5MFqM8fHfuGFTTb9a8rvJGypcVgN4aZ-7XTWw,11387
-volcano_sdk_python-0.13.2.dist-info/RECORD,,
+volcano_sdk_python-0.13.4.dist-info/METADATA,sha256=_vQoCoKrlj5CAQ2fzMPXPf6tnP7hkCn98bJsDBDHOpI,46989
+volcano_sdk_python-0.13.4.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+volcano_sdk_python-0.13.4.dist-info/licenses/LICENSE,sha256=AIHJy-5MFqM8fHfuGFTTb9a8rvJGypcVgN4aZ-7XTWw,11387
+volcano_sdk_python-0.13.4.dist-info/RECORD,,