volcano-sdk-python 0.13.1__py3-none-any.whl → 0.13.3__py3-none-any.whl

volcano_sdk/_function_resolution.py

@@ -15,6 +15,8 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING
 from urllib.parse import urlsplit
 
+import httpx
+
 if TYPE_CHECKING:
     from .errors import NotFoundError
 
@@ -106,28 +108,30 @@ def valid_invoke_url(value: object, api_url: str) -> str | None:
     return None
 
 
-def _absolute_url_scheme(value: str) -> str:
-    """Return the lowercase scheme of an absolute URL, or "" when there is none.
+def _absolute_url_scheme(value: str) -> str | None:
+    """Return the lowercase scheme of an absolute URL, or None when unusable.
 
-    Unparseable input yields "" rather than raising, so a malformed URL reads
+    Unparseable input yields None rather than raising, so a malformed URL reads
     as unusable to every caller.
 
     Returns
     -------
-    str
-        The lowercase scheme, or an empty string for an invalid authority or URL.
+    str or None
+        The lowercase scheme, or None for an invalid authority or URL.
 
     """
     if not value or any(character.isspace() for character in value):
-        return ""
+        return None
     try:
         parsed = urlsplit(value)
         # Reading the authority is the validation: an unclosed IPv6 literal or
         # a port out of range raises here rather than at request time.
         host, _port = parsed.hostname, parsed.port
-    except ValueError:
-        return ""
-    return parsed.scheme.lower() if host else ""
+        # urlsplit accepts controls that HTTPX rejects when invoking the URL.
+        _ = httpx.URL(value)
+    except (ValueError, httpx.InvalidURL):
+        return None
+    return parsed.scheme.lower() if host else None
 
 
 def lookup(api_url: str, authorization: str, name: str) -> CachedOutcome | None:

volcano_sdk/_log_response.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 
+import math
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, TypeGuard
 
 if TYPE_CHECKING:
     from .models import JSONValue
@@ -11,6 +12,38 @@ if TYPE_CHECKING:
 INVALID_LOG_RESPONSE = "Expected a complete log response"
 
 
+def _is_object_mapping(value: object) -> TypeGuard[Mapping[object, object]]:
+    return isinstance(value, Mapping)
+
+
+def _is_object_list(value: object) -> TypeGuard[list[object]]:
+    return isinstance(value, list)
+
+
+def _is_object_tuple(value: object) -> TypeGuard[tuple[object, ...]]:
+    return isinstance(value, tuple)
+
+
+def _is_json_scalar(value: object) -> TypeGuard[str | int | float | bool | None]:
+    if isinstance(value, float):
+        return math.isfinite(value)
+    return value is None or isinstance(value, (str, int, bool))
+
+
+def _is_json_value(value: object) -> TypeGuard[JSONValue]:
+    if _is_json_scalar(value):
+        return True
+    if _is_object_list(value):
+        return all(_is_json_value(item) for item in value)
+    if _is_object_tuple(value):
+        return all(_is_json_value(item) for item in value)
+    if _is_object_mapping(value):
+        return all(
+            isinstance(key, str) and _is_json_value(item) for key, item in value.items()
+        )
+    return False
+
+
 def response_values(payload: object) -> Mapping[str, object]:
     """Require a JSON object for the response envelope.
 
@@ -21,9 +54,25 @@ def response_values(payload: object) -> Mapping[str, object]:
         TypeError: The response envelope is not an object.
 
     """
-    if not isinstance(payload, Mapping):
+    if not _is_object_mapping(payload):
         raise TypeError(INVALID_LOG_RESPONSE)
-    return cast("Mapping[str, object]", payload)
+    values: dict[str, object] = {}
+    for key, value in payload.items():
+        if not isinstance(key, str):
+            raise TypeError(INVALID_LOG_RESPONSE)
+        values[key] = value
+    return values
+
+
+def _row_values(item: object) -> Mapping[str, JSONValue]:
+    if not _is_object_mapping(item):
+        raise TypeError(INVALID_LOG_RESPONSE)
+    row: dict[str, JSONValue] = {}
+    for key, value in item.items():
+        if not isinstance(key, str) or not _is_json_value(value):
+            raise TypeError(INVALID_LOG_RESPONSE)
+        row[key] = value
+    return row
 
 
 def response_data(values: Mapping[str, object]) -> tuple[Mapping[str, JSONValue], ...]:
@@ -37,12 +86,9 @@ def response_data(values: Mapping[str, object]) -> tuple[Mapping[str, JSONValue]
 
     """
     raw_data = values.get("data")
-    if not isinstance(raw_data, list):
-        raise TypeError(INVALID_LOG_RESPONSE)
-    data = cast("list[object]", raw_data)
-    if any(not isinstance(item, Mapping) for item in data):
+    if not _is_object_list(raw_data):
         raise TypeError(INVALID_LOG_RESPONSE)
-    return tuple(cast("Mapping[str, JSONValue]", item) for item in data)
+    return tuple(_row_values(item) for item in raw_data)
 
 
 def search_metadata(values: Mapping[str, object]) -> tuple[int, bool, str | None]:

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)