capo-cloudfront 0.2.0__py3-none-any.whl

capo_cloudfront/_operations/cloudfront2020_05_31/update_vpc_origin.py

@@ -0,0 +1,196 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#UpdateVpcOrigin``."""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+import zapros
+from typing_extensions import Never
+
+import capo_cloudfront._auth._signers
+import capo_cloudfront._auth._sigv4
+import capo_cloudfront.errors.access_denied
+import capo_cloudfront.errors.cannot_update_entity_while_in_use
+import capo_cloudfront.errors.entity_already_exists
+import capo_cloudfront.errors.entity_limit_exceeded
+import capo_cloudfront.errors.entity_not_found
+import capo_cloudfront.errors.illegal_update
+import capo_cloudfront.errors.inconsistent_quantities
+import capo_cloudfront.errors.invalid_argument
+import capo_cloudfront.errors.invalid_if_match_version
+import capo_cloudfront.errors.precondition_failed
+import capo_cloudfront.errors.unsupported_operation
+import capo_cloudfront.types.update_vpc_origin_request
+import capo_cloudfront.types.update_vpc_origin_result
+import capo_cloudfront.types.vpc_origin
+import capo_cloudfront.types.vpc_origin_endpoint_config
+from capo_cloudfront._protocol.errors import parse_error_metadata
+from capo_cloudfront._protocol.xml import Element, fromstring, tostring
+from capo_cloudfront._rule_engine._endpoint_rule_set import EndpointParams, resolve
+from capo_cloudfront._services._pipeline import AsyncOperationOptions, OperationOptions
+from capo_cloudfront.errors import UnknownServiceError
+
+
+def handle_error(response: zapros.Response) -> Never:
+    root = fromstring(response.read())
+    code, message = parse_error_metadata(root)
+    match code:
+        case "AccessDenied":
+            raise capo_cloudfront.errors.access_denied.AccessDenied.from_xml(root)
+        case "CannotUpdateEntityWhileInUse":
+            raise capo_cloudfront.errors.cannot_update_entity_while_in_use.CannotUpdateEntityWhileInUse.from_xml(
+                root
+            )
+        case "EntityAlreadyExists":
+            raise capo_cloudfront.errors.entity_already_exists.EntityAlreadyExists.from_xml(
+                root
+            )
+        case "EntityLimitExceeded":
+            raise capo_cloudfront.errors.entity_limit_exceeded.EntityLimitExceeded.from_xml(
+                root
+            )
+        case "EntityNotFound":
+            raise capo_cloudfront.errors.entity_not_found.EntityNotFound.from_xml(root)
+        case "IllegalUpdate":
+            raise capo_cloudfront.errors.illegal_update.IllegalUpdate.from_xml(root)
+        case "InconsistentQuantities":
+            raise capo_cloudfront.errors.inconsistent_quantities.InconsistentQuantities.from_xml(
+                root
+            )
+        case "InvalidArgument":
+            raise capo_cloudfront.errors.invalid_argument.InvalidArgument.from_xml(root)
+        case "InvalidIfMatchVersion":
+            raise capo_cloudfront.errors.invalid_if_match_version.InvalidIfMatchVersion.from_xml(
+                root
+            )
+        case "PreconditionFailed":
+            raise capo_cloudfront.errors.precondition_failed.PreconditionFailed.from_xml(
+                root
+            )
+        case "UnsupportedOperation":
+            raise capo_cloudfront.errors.unsupported_operation.UnsupportedOperation.from_xml(
+                root
+            )
+        case _:
+            raise UnknownServiceError(code=code, message=message, response=response)
+
+
+def handle_response(
+    response: zapros.Response,
+) -> capo_cloudfront.types.update_vpc_origin_result.UpdateVpcOriginResult:
+    out: capo_cloudfront.types.update_vpc_origin_result.UpdateVpcOriginResult = {
+        "vpc_origin": capo_cloudfront.types.vpc_origin.deserialize_xml(
+            fromstring(response.read())
+        )
+    }  # type: ignore[typeddict-item]
+    if "ETag" in response.headers:
+        out["e_tag"] = str(response.headers["ETag"])
+    return out
+
+
+async def async_handle_response(
+    response: zapros.Response,
+) -> capo_cloudfront.types.update_vpc_origin_result.UpdateVpcOriginResult:
+    out: capo_cloudfront.types.update_vpc_origin_result.UpdateVpcOriginResult = {
+        "vpc_origin": capo_cloudfront.types.vpc_origin.deserialize_xml(
+            fromstring(await response.aread())
+        )
+    }  # type: ignore[typeddict-item]
+    if "ETag" in response.headers:
+        out["e_tag"] = str(response.headers["ETag"])
+    return out
+
+
+def get_signer(
+    options: AsyncOperationOptions | OperationOptions,
+    auth_schemes: list[dict[str, Any]] | None = None,
+) -> capo_cloudfront._auth._signers.Signer | None:
+    name_to_schema = {s["name"]: s for s in (auth_schemes or [])}  # noqa: F841
+    if options.credentials_provider is not None:
+        sigv4_config = (
+            name_to_schema.get("sigv4")
+            or name_to_schema.get("sigv4a")
+            or name_to_schema.get("sigv4-s3express")
+            or capo_cloudfront._auth._sigv4.build_sigv4_auth_scheme(
+                "cloudfront", options.region
+            )
+        )
+        if sigv4_config is not None:
+            return capo_cloudfront._auth._signers.SigV4Signer(
+                options.credentials_provider, auth_scheme=sigv4_config
+            )
+    raise RuntimeError("Auth was not resolved")
+
+
+def build_request(
+    options: OperationOptions | AsyncOperationOptions,
+    input_: capo_cloudfront.types.update_vpc_origin_request.UpdateVpcOriginRequest,
+) -> zapros.Request:
+    endpoint = resolve(
+        EndpointParams(
+            UseDualStack=options.use_dual_stack,
+            UseFIPS=options.use_fips,
+            Endpoint=options.endpoint,
+            Region=options.region,
+        )
+    )  # noqa: F841
+    url = endpoint.url.rstrip("/") + "/2020-05-31/vpc-origin/{Id}"
+    url = url.replace("{Id}", quote(str(input_["id"]), safe=""))
+    params: dict[str, str] = {}
+    headers: dict[str, str] = {k: ", ".join(v) for k, v in endpoint.headers.items()}
+    if "if_match" in input_:
+        headers["If-Match"] = str(input_["if_match"])
+    if "vpc_origin_endpoint_config" in input_:
+        payload_root = Element("_")
+        capo_cloudfront.types.vpc_origin_endpoint_config.serialize_xml(
+            input_["vpc_origin_endpoint_config"],
+            payload_root,
+            "VpcOriginEndpointConfig",
+        )
+        body: bytes | None = tostring(payload_root[0])
+        headers["content-type"] = "application/xml"
+    else:
+        body = b""
+    signer = get_signer(options, auth_schemes=endpoint.properties.get("authSchemes"))
+    normalized_url = zapros.URL(url)
+    normalized_url.search_params.update(params)
+    return zapros.Request(
+        normalized_url, "PUT", headers=headers, body=body, context={"signer": signer}
+    )
+
+
+def update_vpc_origin(
+    options: OperationOptions,
+    input_: capo_cloudfront.types.update_vpc_origin_request.UpdateVpcOriginRequest,
+) -> tuple[
+    capo_cloudfront.types.update_vpc_origin_result.UpdateVpcOriginResult,
+    zapros.Response,
+]:
+    response = options.client.handler.handle(build_request(options, input_))
+    try:
+        if response.status >= 400:
+            response.read()
+            handle_error(response)
+        return handle_response(response), response
+    except BaseException:
+        response.close()
+        raise
+
+
+async def async_update_vpc_origin(
+    options: AsyncOperationOptions,
+    input_: capo_cloudfront.types.update_vpc_origin_request.UpdateVpcOriginRequest,
+) -> tuple[
+    capo_cloudfront.types.update_vpc_origin_result.UpdateVpcOriginResult,
+    zapros.Response,
+]:
+    response = await options.client.handler.ahandle(build_request(options, input_))
+    try:
+        if response.status >= 400:
+            await response.aread()
+            handle_error(response)
+        return await async_handle_response(response), response
+    except BaseException:
+        await response.aclose()
+        raise

capo_cloudfront/_operations/cloudfront2020_05_31/verify_dns_configuration.py

@@ -0,0 +1,141 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#VerifyDnsConfiguration``."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import zapros
+from typing_extensions import Never
+
+import capo_cloudfront._auth._signers
+import capo_cloudfront._auth._sigv4
+import capo_cloudfront.errors.access_denied
+import capo_cloudfront.errors.entity_not_found
+import capo_cloudfront.errors.invalid_argument
+import capo_cloudfront.types.dns_configuration_list
+import capo_cloudfront.types.verify_dns_configuration_request
+import capo_cloudfront.types.verify_dns_configuration_result
+from capo_cloudfront._protocol.errors import parse_error_metadata
+from capo_cloudfront._protocol.xml import Element, SubElement, fromstring, tostring
+from capo_cloudfront._rule_engine._endpoint_rule_set import EndpointParams, resolve
+from capo_cloudfront._services._pipeline import AsyncOperationOptions, OperationOptions
+from capo_cloudfront.errors import UnknownServiceError
+
+
+def handle_error(response: zapros.Response) -> Never:
+    root = fromstring(response.read())
+    code, message = parse_error_metadata(root)
+    match code:
+        case "AccessDenied":
+            raise capo_cloudfront.errors.access_denied.AccessDenied.from_xml(root)
+        case "EntityNotFound":
+            raise capo_cloudfront.errors.entity_not_found.EntityNotFound.from_xml(root)
+        case "InvalidArgument":
+            raise capo_cloudfront.errors.invalid_argument.InvalidArgument.from_xml(root)
+        case _:
+            raise UnknownServiceError(code=code, message=message, response=response)
+
+
+def handle_response(
+    response: zapros.Response,
+) -> capo_cloudfront.types.verify_dns_configuration_result.VerifyDnsConfigurationResult:
+    out: capo_cloudfront.types.verify_dns_configuration_result.VerifyDnsConfigurationResult = capo_cloudfront.types.verify_dns_configuration_result.deserialize_xml(
+        fromstring(response.read())
+    )
+    return out
+
+
+async def async_handle_response(
+    response: zapros.Response,
+) -> capo_cloudfront.types.verify_dns_configuration_result.VerifyDnsConfigurationResult:
+    out: capo_cloudfront.types.verify_dns_configuration_result.VerifyDnsConfigurationResult = capo_cloudfront.types.verify_dns_configuration_result.deserialize_xml(
+        fromstring(await response.aread())
+    )
+    return out
+
+
+def get_signer(
+    options: AsyncOperationOptions | OperationOptions,
+    auth_schemes: list[dict[str, Any]] | None = None,
+) -> capo_cloudfront._auth._signers.Signer | None:
+    name_to_schema = {s["name"]: s for s in (auth_schemes or [])}  # noqa: F841
+    if options.credentials_provider is not None:
+        sigv4_config = (
+            name_to_schema.get("sigv4")
+            or name_to_schema.get("sigv4a")
+            or name_to_schema.get("sigv4-s3express")
+            or capo_cloudfront._auth._sigv4.build_sigv4_auth_scheme(
+                "cloudfront", options.region
+            )
+        )
+        if sigv4_config is not None:
+            return capo_cloudfront._auth._signers.SigV4Signer(
+                options.credentials_provider, auth_scheme=sigv4_config
+            )
+    raise RuntimeError("Auth was not resolved")
+
+
+def build_request(
+    options: OperationOptions | AsyncOperationOptions,
+    input_: capo_cloudfront.types.verify_dns_configuration_request.VerifyDnsConfigurationRequest,
+) -> zapros.Request:
+    endpoint = resolve(
+        EndpointParams(
+            UseDualStack=options.use_dual_stack,
+            UseFIPS=options.use_fips,
+            Endpoint=options.endpoint,
+            Region=options.region,
+        )
+    )  # noqa: F841
+    url = endpoint.url.rstrip("/") + "/2020-05-31/verify-dns-configuration"
+    params: dict[str, str] = {}
+    headers: dict[str, str] = {k: ", ".join(v) for k, v in endpoint.headers.items()}
+    root = Element("VerifyDnsConfigurationRequest")
+    if "domain" in input_:
+        SubElement(root, "Domain").text = str(input_["domain"])
+    if "identifier" in input_:
+        SubElement(root, "Identifier").text = str(input_["identifier"])
+    body: bytes | None = tostring(root)
+    headers["content-type"] = "application/xml"
+    signer = get_signer(options, auth_schemes=endpoint.properties.get("authSchemes"))
+    normalized_url = zapros.URL(url)
+    normalized_url.search_params.update(params)
+    return zapros.Request(
+        normalized_url, "POST", headers=headers, body=body, context={"signer": signer}
+    )
+
+
+def verify_dns_configuration(
+    options: OperationOptions,
+    input_: capo_cloudfront.types.verify_dns_configuration_request.VerifyDnsConfigurationRequest,
+) -> tuple[
+    capo_cloudfront.types.verify_dns_configuration_result.VerifyDnsConfigurationResult,
+    zapros.Response,
+]:
+    response = options.client.handler.handle(build_request(options, input_))
+    try:
+        if response.status >= 400:
+            response.read()
+            handle_error(response)
+        return handle_response(response), response
+    except BaseException:
+        response.close()
+        raise
+
+
+async def async_verify_dns_configuration(
+    options: AsyncOperationOptions,
+    input_: capo_cloudfront.types.verify_dns_configuration_request.VerifyDnsConfigurationRequest,
+) -> tuple[
+    capo_cloudfront.types.verify_dns_configuration_result.VerifyDnsConfigurationResult,
+    zapros.Response,
+]:
+    response = await options.client.handler.ahandle(build_request(options, input_))
+    try:
+        if response.status >= 400:
+            await response.aread()
+            handle_error(response)
+        return await async_handle_response(response), response
+    except BaseException:
+        await response.aclose()
+        raise

capo_cloudfront/_pagination.py

@@ -0,0 +1,21 @@
+"""Runtime helpers for generated paginated ``iter_*`` operation methods."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def resolve_path(obj: Any, path: tuple[str, ...]) -> Any:
+    """Walk ``path`` segments on a nested ``dict`` (TypedDict at runtime).
+
+    Returns ``None`` as soon as any intermediate value is missing or non-dict —
+    the generated iter loop uses a falsy token as the terminate signal, so this
+    short-circuit gives the same semantics for dotted paths as for top-level ones.
+    """
+    for key in path:
+        if not isinstance(obj, dict):
+            return None
+        obj = obj.get(key)
+        if obj is None:
+            return None
+    return obj

capo_cloudfront/_protocol/__init__.py

@@ -0,0 +1 @@
+"""Protocol runtime modules. Hand-written; not generated."""

capo_cloudfront/_protocol/errors.py

@@ -0,0 +1,59 @@
+"""Shared service-error runtime.
+
+Hand-written, not regenerated. Helpers for extracting error metadata
+from HTTP error responses.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from zapros import Response
+
+if TYPE_CHECKING:
+    from xml.etree.ElementTree import Element
+
+
+def parse_error_metadata(root: Element) -> tuple[str | None, str | None]:
+    """Return ``(code, message)`` from a restXml error envelope.
+
+    Accepts either an ``<Error>`` element directly or an
+    ``<ErrorResponse>`` wrapper whose first ``<Error>`` child holds the
+    metadata. Missing children yield ``None``.
+    """
+    err = root if root.tag.endswith("Error") else root.find("Error")
+    if err is None:
+        return None, None
+    code_el = err.find("Code")
+    msg_el = err.find("Message")
+    code = code_el.text if code_el is not None else None
+    message = msg_el.text if msg_el is not None else None
+    return code, message
+
+
+def parse_error_metadata_json(
+    response: Response, data: dict
+) -> tuple[str | None, str | None]:
+    """Return ``(code, message)`` from a restJson1 error response.
+
+    Code precedence: the ``X-Amzn-Errortype`` response header, then the
+    ``__type`` body field, then ``code``. The raw value is normalized by
+    dropping a ``prefix#`` namespace and a trailing ``:uri`` suffix.
+    Message comes from ``message`` or ``Message``. Missing values yield
+    ``None``.
+    """
+    code = (
+        response.headers.get("X-Amzn-Errortype")
+        or data.get("__type")
+        or data.get("code")
+    )
+    if code is not None:
+        code = code.rsplit("#", 1)[-1].split(":", 1)[0]
+    message = data.get("message") or data.get("Message")
+    return code, message
+
+
+__all__ = [
+    "parse_error_metadata",
+    "parse_error_metadata_json",
+]

capo_cloudfront/_protocol/eventstream.py

@@ -0,0 +1,238 @@
+"""Shared Amazon eventstream binary-format runtime.
+
+Hand-written, not regenerated. Provides framing, header encoding, and
+checksum validation for Smithy event-stream messages.
+"""
+
+from __future__ import annotations
+
+import datetime
+import uuid
+import zlib
+from collections.abc import AsyncIterator, Callable, Iterator
+from dataclasses import dataclass, field
+from typing import TypeVar, Union
+
+HeaderValue = Union[bool, int, bytes, str, datetime.datetime, uuid.UUID]
+T = TypeVar("T")
+
+
+# Header type constants from the Amazon eventstream specification.
+_TRUE_HEADER = 0x00
+_FALSE_HEADER = 0x01
+_BYTE_HEADER = 0x02
+_SHORT_HEADER = 0x03
+_INTEGER_HEADER = 0x04
+_LONG_HEADER = 0x05
+_BYTE_ARRAY_HEADER = 0x06
+_STRING_HEADER = 0x07
+_TIMESTAMP_HEADER = 0x08
+_UUID_HEADER = 0x09
+
+
+def _encode_header_value(value: HeaderValue) -> bytes:
+    if isinstance(value, bool):
+        return bytes([_TRUE_HEADER if value else _FALSE_HEADER])
+    if isinstance(value, int):
+        if -128 <= value <= 127:
+            return bytes([_BYTE_HEADER]) + value.to_bytes(1, "big", signed=True)
+        if -32768 <= value <= 32767:
+            return bytes([_SHORT_HEADER]) + value.to_bytes(2, "big", signed=True)
+        if -2147483648 <= value <= 2147483647:
+            return bytes([_INTEGER_HEADER]) + value.to_bytes(4, "big", signed=True)
+        # Fall through to signed 64-bit.
+        return bytes([_LONG_HEADER]) + value.to_bytes(8, "big", signed=True)
+    if isinstance(value, bytes):
+        return bytes([_BYTE_ARRAY_HEADER]) + len(value).to_bytes(2, "big") + value
+    if isinstance(value, str):
+        encoded = value.encode("utf-8")
+        return bytes([_STRING_HEADER]) + len(encoded).to_bytes(2, "big") + encoded
+    if isinstance(value, datetime.datetime):
+        millis = int(value.timestamp() * 1000)
+        return bytes([_TIMESTAMP_HEADER]) + millis.to_bytes(8, "big", signed=True)
+    if isinstance(value, uuid.UUID):
+        return bytes([_UUID_HEADER]) + value.bytes
+    raise TypeError(f"unsupported eventstream header value: {value!r}")
+
+
+def _decode_header_value(
+    type_byte: int, data: bytes | bytearray, pos: int
+) -> tuple[HeaderValue, int]:
+    if type_byte == _TRUE_HEADER:
+        return True, pos
+    if type_byte == _FALSE_HEADER:
+        return False, pos
+    if type_byte == _BYTE_HEADER:
+        return int.from_bytes(data[pos : pos + 1], "big", signed=True), pos + 1
+    if type_byte == _SHORT_HEADER:
+        return int.from_bytes(data[pos : pos + 2], "big", signed=True), pos + 2
+    if type_byte == _INTEGER_HEADER:
+        return int.from_bytes(data[pos : pos + 4], "big", signed=True), pos + 4
+    if type_byte == _LONG_HEADER:
+        return int.from_bytes(data[pos : pos + 8], "big", signed=True), pos + 8
+    if type_byte == _BYTE_ARRAY_HEADER:
+        length = int.from_bytes(data[pos : pos + 2], "big")
+        pos += 2
+        return bytes(data[pos : pos + length]), pos + length
+    if type_byte == _STRING_HEADER:
+        length = int.from_bytes(data[pos : pos + 2], "big")
+        pos += 2
+        return data[pos : pos + length].decode("utf-8"), pos + length
+    if type_byte == _TIMESTAMP_HEADER:
+        millis = int.from_bytes(data[pos : pos + 8], "big", signed=True)
+        return (
+            datetime.datetime.fromtimestamp(millis / 1000, tz=datetime.timezone.utc),
+            pos + 8,
+        )
+    if type_byte == _UUID_HEADER:
+        return uuid.UUID(bytes=bytes(data[pos : pos + 16])), pos + 16
+    raise ValueError(f"unsupported eventstream header type: {type_byte:#x}")
+
+
+def _encode_headers(headers: dict[str, HeaderValue]) -> bytes:
+    parts: list[bytes] = []
+    for name, value in headers.items():
+        name_bytes = name.encode("utf-8")
+        if len(name_bytes) > 255:
+            raise ValueError(f"eventstream header name too long: {name!r}")
+        parts.append(bytes([len(name_bytes)]) + name_bytes)
+        parts.append(_encode_header_value(value))
+    return b"".join(parts)
+
+
+def _decode_headers(data: bytes | bytearray) -> dict[str, HeaderValue]:
+    pos = 0
+    headers: dict[str, HeaderValue] = {}
+    while pos < len(data):
+        name_len = data[pos]
+        pos += 1
+        name = data[pos : pos + name_len].decode("utf-8")
+        pos += name_len
+        type_byte = data[pos]
+        pos += 1
+        value, pos = _decode_header_value(type_byte, data, pos)
+        headers[name] = value
+    return headers
+
+
+@dataclass
+class Message:
+    """A single Amazon eventstream message."""
+
+    headers: dict[str, HeaderValue] = field(default_factory=dict)
+    payload: bytes = b""
+
+    def encode(self) -> bytes:
+        """Serialize this message into eventstream framing bytes."""
+        headers_bytes = _encode_headers(self.headers)
+        headers_length = len(headers_bytes)
+        payload = self.payload
+        total_length = 12 + headers_length + len(payload)
+
+        prelude = total_length.to_bytes(4, "big") + headers_length.to_bytes(4, "big")
+        prelude_crc = zlib.crc32(prelude).to_bytes(4, "big")
+        message_body = prelude + prelude_crc + headers_bytes + payload
+        message_crc = zlib.crc32(message_body).to_bytes(4, "big")
+        return message_body + message_crc
+
+
+@dataclass
+class MessageDecoder:
+    """Stateful decoder that turns byte chunks into :class:`Message` objects.
+
+    ``feed`` may emit zero, one, or many messages for each chunk. Partial
+    frames are buffered until the next chunk completes them.
+    """
+
+    _buffer: bytearray = field(default_factory=bytearray, init=False)
+
+    def feed(self, data: bytes) -> Iterator[Message]:
+        """Append ``data`` to the internal buffer and yield any full messages."""
+        self._buffer.extend(data)
+        while True:
+            if len(self._buffer) < 12:
+                return
+
+            total_length = int.from_bytes(self._buffer[:4], "big")
+            headers_length = int.from_bytes(self._buffer[4:8], "big")
+            prelude = bytes(self._buffer[:8])
+            prelude_crc = int.from_bytes(self._buffer[8:12], "big")
+
+            if total_length < 12 + headers_length:
+                raise ValueError(
+                    f"invalid eventstream message: total_length={total_length} "
+                    f"is smaller than minimum {12 + headers_length}"
+                )
+
+            message_end = total_length + 4
+            if len(self._buffer) < message_end:
+                return
+
+            computed_prelude_crc = zlib.crc32(prelude) & 0xFFFFFFFF
+            if computed_prelude_crc != prelude_crc:
+                raise ValueError("eventstream prelude checksum mismatch")
+
+            message_bytes = bytes(self._buffer[:total_length])
+            message_crc = int.from_bytes(
+                self._buffer[total_length : total_length + 4], "big"
+            )
+            computed_message_crc = zlib.crc32(message_bytes) & 0xFFFFFFFF
+            if computed_message_crc != message_crc:
+                raise ValueError("eventstream message checksum mismatch")
+
+            headers = _decode_headers(self._buffer[12 : 12 + headers_length])
+            payload = bytes(self._buffer[12 + headers_length : total_length])
+            del self._buffer[:message_end]
+            yield Message(headers=headers, payload=payload)
+
+
+def raw_stream_to_events(
+    raw_stream: Iterator[bytes], decoder: MessageDecoder, deser: Callable[[Message], T]
+) -> Iterator[T]:
+    """Map a raw byte iterator into deserialized event objects."""
+    for chunk in raw_stream:
+        for message in decoder.feed(chunk):
+            yield deser(message)
+
+
+async def async_raw_stream_to_events(
+    raw_stream: AsyncIterator[bytes],
+    decoder: MessageDecoder,
+    deser: Callable[[Message], T],
+) -> AsyncIterator[T]:
+    """Map an async raw byte iterator into deserialized event objects."""
+    async for chunk in raw_stream:
+        for message in decoder.feed(chunk):
+            yield deser(message)
+
+
+def read_messages(
+    raw_stream: Iterator[bytes], decoder: MessageDecoder
+) -> Iterator[Message]:
+    """Yield :class:`Message` objects framed out of a raw byte iterator.
+
+    Used by RPC event streams (e.g. awsJson) where the first message may be an
+    initial-response that must be pulled off before consuming the events.
+    """
+    for chunk in raw_stream:
+        yield from decoder.feed(chunk)
+
+
+async def async_read_messages(
+    raw_stream: AsyncIterator[bytes], decoder: MessageDecoder
+) -> AsyncIterator[Message]:
+    """Async variant of :func:`read_messages`."""
+    async for chunk in raw_stream:
+        for message in decoder.feed(chunk):
+            yield message
+
+
+__all__ = [
+    "HeaderValue",
+    "Message",
+    "MessageDecoder",
+    "async_raw_stream_to_events",
+    "async_read_messages",
+    "raw_stream_to_events",
+    "read_messages",
+]

capo_cloudfront/_protocol/xml.py

@@ -0,0 +1,27 @@
+"""Shared XML protocol runtime.
+
+Hand-written, not regenerated. Holds re-exports of
+``xml.etree.ElementTree`` primitives generated code depends on.
+"""
+
+from xml.etree.ElementTree import Element, SubElement, tostring
+from xml.etree.ElementTree import fromstring as _fromstring
+
+
+def fromstring(text: str | bytes) -> Element:
+    """Parse XML and strip namespaces so generated ``el.find("Tag")``
+    lookups match. AWS restXml responses use a default namespace which
+    ElementTree otherwise qualifies onto every tag as ``{ns}Tag``."""
+    root = _fromstring(text)
+    for el in root.iter():
+        if el.tag.startswith("{"):
+            el.tag = el.tag.rpartition("}")[2]
+    return root
+
+
+__all__ = [
+    "Element",
+    "SubElement",
+    "fromstring",
+    "tostring",
+]