volcano-sdk-python 0.13.0__py3-none-any.whl → 0.13.2__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]: