capo-codeartifact 0.1.0__py3-none-any.whl

capo_codeartifact/_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_codeartifact/_protocol/serialize.py

@@ -0,0 +1,47 @@
+"""Shared request-binding serialization runtime.
+
+Hand-written, not regenerated. Text encodings for values bound to HTTP
+labels, query parameters, and headers by the generated operations.
+"""
+
+from __future__ import annotations
+
+import base64
+import datetime
+from email.utils import format_datetime
+
+
+def as_utc(value: datetime.datetime) -> datetime.datetime:
+    """Normalize to an aware UTC datetime; naive values are taken as UTC."""
+    if value.tzinfo is None:
+        return value.replace(tzinfo=datetime.timezone.utc)
+    return value.astimezone(datetime.timezone.utc)
+
+
+def fmt_date_time(value: datetime.datetime) -> str:
+    """RFC 3339 with a ``Z`` designator, e.g. ``2015-01-25T08:00:00Z``."""
+    return as_utc(value).isoformat().replace("+00:00", "Z")
+
+
+def fmt_http_date(value: datetime.datetime) -> str:
+    """IMF-fixdate, e.g. ``Sun, 25 Jan 2015 08:00:00 GMT``."""
+    return format_datetime(as_utc(value), usegmt=True)
+
+
+def fmt_epoch_seconds(value: datetime.datetime) -> str:
+    """Seconds since the epoch; whole seconds carry no ``.0`` suffix."""
+    ts = as_utc(value).timestamp()
+    return str(int(ts)) if ts == int(ts) else str(ts)
+
+
+def b64(value: bytes) -> str:
+    return base64.b64encode(value).decode("ascii")
+
+
+__all__ = [
+    "as_utc",
+    "b64",
+    "fmt_date_time",
+    "fmt_epoch_seconds",
+    "fmt_http_date",
+]

capo_codeartifact/_protocol/xml.py

@@ -0,0 +1,33 @@
+"""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")`` and
+    ``el.get("attr")`` lookups match. AWS restXml responses use a default
+    namespace which ElementTree otherwise qualifies onto every tag as
+    ``{ns}Tag``; prefixed attributes (e.g. ``xsi:type``) get the same
+    treatment on their keys."""
+    root = _fromstring(text)
+    for el in root.iter():
+        if el.tag.startswith("{"):
+            el.tag = el.tag.rpartition("}")[2]
+        if any(key.startswith("{") for key in el.attrib):
+            el.attrib = {
+                key.rpartition("}")[2]: value for key, value in el.attrib.items()
+            }
+    return root
+
+
+__all__ = [
+    "Element",
+    "SubElement",
+    "fromstring",
+    "tostring",
+]

capo_codeartifact/_rule_engine/_aws_partition.py

@@ -0,0 +1,160 @@
+"""AWS partitions table and ``aws.partition`` rules-engine function.
+
+Data sourced from AWS SDK ``partitions.json``. All dispatch tables are
+materialised at codegen time:
+
+* ``_REGION_LOOKUP`` — O(1) dict of explicit region name -> partition outputs.
+* ``_REGEX_LOOKUP`` — compiled-regex / outputs pairs for unknown regions.
+* ``_DEFAULT_OUTPUTS`` — fallback partition (``aws``)."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+_PARTITION_AWS: dict[str, Any] = {
+    "dnsSuffix": "amazonaws.com",
+    "dualStackDnsSuffix": "api.aws",
+    "implicitGlobalRegion": "us-east-1",
+    "name": "aws",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_CN: dict[str, Any] = {
+    "dnsSuffix": "amazonaws.com.cn",
+    "dualStackDnsSuffix": "api.amazonwebservices.com.cn",
+    "implicitGlobalRegion": "cn-northwest-1",
+    "name": "aws-cn",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_EUSC: dict[str, Any] = {
+    "dnsSuffix": "amazonaws.eu",
+    "dualStackDnsSuffix": "api.amazonwebservices.eu",
+    "implicitGlobalRegion": "eusc-de-east-1",
+    "name": "aws-eusc",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_ISO: dict[str, Any] = {
+    "dnsSuffix": "c2s.ic.gov",
+    "dualStackDnsSuffix": "api.aws.ic.gov",
+    "implicitGlobalRegion": "us-iso-east-1",
+    "name": "aws-iso",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_ISO_B: dict[str, Any] = {
+    "dnsSuffix": "sc2s.sgov.gov",
+    "dualStackDnsSuffix": "api.aws.scloud",
+    "implicitGlobalRegion": "us-isob-east-1",
+    "name": "aws-iso-b",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_ISO_E: dict[str, Any] = {
+    "dnsSuffix": "cloud.adc-e.uk",
+    "dualStackDnsSuffix": "api.cloud-aws.adc-e.uk",
+    "implicitGlobalRegion": "eu-isoe-west-1",
+    "name": "aws-iso-e",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_ISO_F: dict[str, Any] = {
+    "dnsSuffix": "csp.hci.ic.gov",
+    "dualStackDnsSuffix": "api.aws.hci.ic.gov",
+    "implicitGlobalRegion": "us-isof-south-1",
+    "name": "aws-iso-f",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+_PARTITION_AWS_US_GOV: dict[str, Any] = {
+    "dnsSuffix": "amazonaws.com",
+    "dualStackDnsSuffix": "api.aws",
+    "implicitGlobalRegion": "us-gov-west-1",
+    "name": "aws-us-gov",
+    "supportsDualStack": True,
+    "supportsFIPS": True,
+}
+
+_REGION_LOOKUP: dict[str, dict[str, Any]] = {
+    "af-south-1": _PARTITION_AWS,
+    "ap-east-1": _PARTITION_AWS,
+    "ap-east-2": _PARTITION_AWS,
+    "ap-northeast-1": _PARTITION_AWS,
+    "ap-northeast-2": _PARTITION_AWS,
+    "ap-northeast-3": _PARTITION_AWS,
+    "ap-south-1": _PARTITION_AWS,
+    "ap-south-2": _PARTITION_AWS,
+    "ap-southeast-1": _PARTITION_AWS,
+    "ap-southeast-2": _PARTITION_AWS,
+    "ap-southeast-3": _PARTITION_AWS,
+    "ap-southeast-4": _PARTITION_AWS,
+    "ap-southeast-5": _PARTITION_AWS,
+    "ap-southeast-6": _PARTITION_AWS,
+    "ap-southeast-7": _PARTITION_AWS,
+    "aws-global": _PARTITION_AWS,
+    "ca-central-1": _PARTITION_AWS,
+    "ca-west-1": _PARTITION_AWS,
+    "eu-central-1": _PARTITION_AWS,
+    "eu-central-2": _PARTITION_AWS,
+    "eu-north-1": _PARTITION_AWS,
+    "eu-south-1": _PARTITION_AWS,
+    "eu-south-2": _PARTITION_AWS,
+    "eu-west-1": _PARTITION_AWS,
+    "eu-west-2": _PARTITION_AWS,
+    "eu-west-3": _PARTITION_AWS,
+    "il-central-1": _PARTITION_AWS,
+    "me-central-1": _PARTITION_AWS,
+    "me-south-1": _PARTITION_AWS,
+    "mx-central-1": _PARTITION_AWS,
+    "sa-east-1": _PARTITION_AWS,
+    "us-east-1": _PARTITION_AWS,
+    "us-east-2": _PARTITION_AWS,
+    "us-west-1": _PARTITION_AWS,
+    "us-west-2": _PARTITION_AWS,
+    "aws-cn-global": _PARTITION_AWS_CN,
+    "cn-north-1": _PARTITION_AWS_CN,
+    "cn-northwest-1": _PARTITION_AWS_CN,
+    "eusc-de-east-1": _PARTITION_AWS_EUSC,
+    "aws-iso-global": _PARTITION_AWS_ISO,
+    "us-iso-east-1": _PARTITION_AWS_ISO,
+    "us-iso-west-1": _PARTITION_AWS_ISO,
+    "aws-iso-b-global": _PARTITION_AWS_ISO_B,
+    "us-isob-east-1": _PARTITION_AWS_ISO_B,
+    "us-isob-west-1": _PARTITION_AWS_ISO_B,
+    "aws-iso-e-global": _PARTITION_AWS_ISO_E,
+    "eu-isoe-west-1": _PARTITION_AWS_ISO_E,
+    "aws-iso-f-global": _PARTITION_AWS_ISO_F,
+    "us-isof-east-1": _PARTITION_AWS_ISO_F,
+    "us-isof-south-1": _PARTITION_AWS_ISO_F,
+    "aws-us-gov-global": _PARTITION_AWS_US_GOV,
+    "us-gov-east-1": _PARTITION_AWS_US_GOV,
+    "us-gov-west-1": _PARTITION_AWS_US_GOV,
+}
+
+_REGEX_LOOKUP: tuple[tuple[re.Pattern[str], dict[str, Any]], ...] = (
+    (re.compile(r"^(us|eu|ap|sa|ca|me|af|il|mx)\-\w+\-\d+$"), _PARTITION_AWS),
+    (re.compile(r"^cn\-\w+\-\d+$"), _PARTITION_AWS_CN),
+    (re.compile(r"^eusc\-(de)\-\w+\-\d+$"), _PARTITION_AWS_EUSC),
+    (re.compile(r"^us\-iso\-\w+\-\d+$"), _PARTITION_AWS_ISO),
+    (re.compile(r"^us\-isob\-\w+\-\d+$"), _PARTITION_AWS_ISO_B),
+    (re.compile(r"^eu\-isoe\-\w+\-\d+$"), _PARTITION_AWS_ISO_E),
+    (re.compile(r"^us\-isof\-\w+\-\d+$"), _PARTITION_AWS_ISO_F),
+    (re.compile(r"^us\-gov\-\w+\-\d+$"), _PARTITION_AWS_US_GOV),
+)
+
+_DEFAULT_OUTPUTS: dict[str, Any] = _PARTITION_AWS
+
+
+def aws_partition(region: Any) -> dict[str, Any] | None:
+    """Resolve ``region`` to a partition outputs dict."""
+    if not isinstance(region, str):
+        return None
+    outputs = _REGION_LOOKUP.get(region)
+    if outputs is not None:
+        return outputs
+    for pattern, outputs in _REGEX_LOOKUP:
+        if pattern.fullmatch(region):
+            return outputs
+    return _DEFAULT_OUTPUTS

capo_codeartifact/_rule_engine/_endpoint_rule_set.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ._aws_partition import aws_partition
+from ._endpoint_runtime import (
+    Endpoint,
+    EndpointError,
+    get_attr,
+    interpolate,
+)
+
+
+class EndpointParams:
+    def __init__(
+        self,
+        *,
+        UseDualStack: bool | None = None,
+        UseFIPS: bool | None = None,
+        Region: str | None = None,
+        Endpoint: str | None = None,
+    ):
+        self.UseDualStack = UseDualStack if UseDualStack is not None else False
+        self.UseFIPS = UseFIPS if UseFIPS is not None else False
+        self.Region = Region if Region is not None else None
+        self.Endpoint = Endpoint if Endpoint is not None else None
+
+
+def resolve(p: EndpointParams) -> Endpoint:  # type: ignore
+    """Resolve endpoint from parameters using generated ruleset."""
+    _locals: dict[str, Any] = {}
+    if p.Endpoint is not None:
+        if p.UseFIPS is True:
+            raise EndpointError(
+                interpolate(
+                    "Invalid Configuration: FIPS and custom endpoint are not supported",
+                    p,
+                    _locals,
+                )
+            )
+        if p.UseDualStack is True:
+            raise EndpointError(
+                interpolate(
+                    "Invalid Configuration: Dualstack and custom endpoint are not supported",
+                    p,
+                    _locals,
+                )
+            )
+        return Endpoint(url=p.Endpoint, properties={}, headers={})
+    _locals: dict[str, Any] = {}
+    if p.Region is not None:
+        _locals["PartitionResult"] = aws_partition(p.Region)
+        if _locals["PartitionResult"] is not None:
+            if p.UseFIPS is True:
+                if p.UseDualStack is True:
+                    if True is get_attr(
+                        _locals["PartitionResult"],
+                        interpolate("supportsFIPS", p, _locals),
+                    ):
+                        if True is get_attr(
+                            _locals["PartitionResult"],
+                            interpolate("supportsDualStack", p, _locals),
+                        ):
+                            return Endpoint(
+                                url=interpolate(
+                                    "https://codeartifact-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                    p,
+                                    _locals,
+                                ),
+                                properties={},
+                                headers={},
+                            )
+                    raise EndpointError(
+                        interpolate(
+                            "FIPS and DualStack are enabled, but this partition does not support one or both",
+                            p,
+                            _locals,
+                        )
+                    )
+            if p.UseFIPS is True:
+                if (
+                    get_attr(
+                        _locals["PartitionResult"],
+                        interpolate("supportsFIPS", p, _locals),
+                    )
+                    is True
+                ):
+                    return Endpoint(
+                        url=interpolate(
+                            "https://codeartifact-fips.{Region}.{PartitionResult#dnsSuffix}",
+                            p,
+                            _locals,
+                        ),
+                        properties={},
+                        headers={},
+                    )
+                raise EndpointError(
+                    interpolate(
+                        "FIPS is enabled but this partition does not support FIPS",
+                        p,
+                        _locals,
+                    )
+                )
+            if p.UseDualStack is True:
+                if True is get_attr(
+                    _locals["PartitionResult"],
+                    interpolate("supportsDualStack", p, _locals),
+                ):
+                    return Endpoint(
+                        url=interpolate(
+                            "https://codeartifact.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                            p,
+                            _locals,
+                        ),
+                        properties={},
+                        headers={},
+                    )
+                raise EndpointError(
+                    interpolate(
+                        "DualStack is enabled but this partition does not support DualStack",
+                        p,
+                        _locals,
+                    )
+                )
+            return Endpoint(
+                url=interpolate(
+                    "https://codeartifact.{Region}.{PartitionResult#dnsSuffix}",
+                    p,
+                    _locals,
+                ),
+                properties={},
+                headers={},
+            )
+    _locals: dict[str, Any] = {}
+    raise EndpointError(
+        interpolate("Invalid Configuration: Missing Region", p, _locals)
+    )
+    raise EndpointError("No endpoint rules matched")