reflectapi-runtime 0.17.2a4__tar.gz → 0.17.2a5__tar.gz

{reflectapi_runtime-0.17.2a4 → reflectapi_runtime-0.17.2a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflectapi-runtime
-Version: 0.17.2a4
+Version: 0.17.2a5
 Summary: Runtime library for ReflectAPI Python clients
 Project-URL: Homepage, https://github.com/thepartly/reflectapi
 Project-URL: Repository, https://github.com/thepartly/reflectapi

{reflectapi_runtime-0.17.2a4 → reflectapi_runtime-0.17.2a5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "reflectapi-runtime"
-version = "0.17.2a4"
+version = "0.17.2a5"
 description = "Runtime library for ReflectAPI Python clients"
 readme = "README.md"
 requires-python = ">=3.12"

{reflectapi_runtime-0.17.2a4 → reflectapi_runtime-0.17.2a5}/src/reflectapi_runtime/__init__.py

@@ -46,6 +46,7 @@ from .option import (
     undefined,
 )
 from .response import ApiResponse, TransportMetadata
+from .serde import parse_externally_tagged, serialize_externally_tagged
 from .streaming import AsyncStreamingClient, StreamingResponse
 from .testing import (
     AsyncCassetteMiddleware,
@@ -56,7 +57,7 @@ from .testing import (
 )
 from .types import BatchResult, ReflectapiEmpty, ReflectapiInfallible
 
-__version__ = "0.17.2a4"
+__version__ = "0.17.2a5"
 
 __all__ = [
     # Authentication
@@ -97,6 +98,8 @@ __all__ = [
     "ReflectapiEmpty",
     "ReflectapiInfallible",
     "ReflectapiOption",
+    "parse_externally_tagged",
+    "serialize_externally_tagged",
     "StreamingResponse",
     "TestClientMixin",
     "TimeoutError",

reflectapi_runtime-0.17.2a5/src/reflectapi_runtime/serde.py

@@ -0,0 +1,48 @@
+"""Serialization helpers used by generated ReflectAPI clients."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+
+VariantHandler = Callable[[Any], Any] | str
+VariantSerializers = dict[str, tuple[Callable[[Any], bool], Callable[[Any], Any]]]
+
+
+def parse_externally_tagged(
+    data: Any,
+    variants: dict[str, VariantHandler],
+    types: tuple[type[Any], ...],
+    enum_name: str,
+) -> Any:
+    """Parse an externally tagged enum from ``{"Variant": value}`` format."""
+    if types and isinstance(data, types):
+        return data
+    if isinstance(data, str) and data in variants:
+        handler = variants[data]
+        if handler == "_unit":
+            return data
+    if isinstance(data, dict):
+        if len(data) != 1:
+            raise ValueError("Externally tagged enum must have exactly one key")
+        key, value = next(iter(data.items()))
+        if key in variants:
+            handler = variants[key]
+            if handler == "_unit":
+                return key
+            if callable(handler):
+                return handler(value)
+    raise ValueError(f"Unknown variant for {enum_name}: {data}")
+
+
+def serialize_externally_tagged(
+    root: Any,
+    serializers: VariantSerializers,
+    enum_name: str,
+) -> Any:
+    """Serialize an externally tagged enum to ``{"Variant": value}`` format."""
+    for _variant_name, (check, serialize) in serializers.items():
+        if check(root):
+            return serialize(root)
+    raise ValueError(f"Cannot serialize {enum_name} variant: {type(root)}")