turbo-lambda 0.1.0__tar.gz

turbo_lambda-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.3
+Name: turbo-lambda
+Version: 0.1.0
+Summary: Turbo Lambda Description
+Author: Sam Mosleh
+Author-email: Sam Mosleh <sam.mosleh.d@gmail.com>
+Requires-Dist: orjson>=3.11.3
+Requires-Dist: pydantic-settings>=2.11.0
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# turbo-lambda
+Turbo Lambda Library

turbo_lambda-0.1.0/README.md

@@ -0,0 +1,2 @@
+# turbo-lambda
+Turbo Lambda Library

turbo_lambda-0.1.0/pyproject.toml

@@ -0,0 +1,84 @@
+[project]
+name = "turbo-lambda"
+version = "0.1.0"
+description = "Turbo Lambda Description"
+readme = "README.md"
+authors = [{ name = "Sam Mosleh", email = "sam.mosleh.d@gmail.com" }]
+requires-python = ">=3.12"
+dependencies = [
+    "orjson>=3.11.3",
+    "pydantic-settings>=2.11.0",
+]
+
+[dependency-groups]
+dev = [
+    "coverage>=7.11.0",
+    "ipykernel>=7.0.1",
+    "mypy>=1.18.2",
+    "pytest>=8.4.2",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.2,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.mypy]
+plugins = ['pydantic.mypy']
+
+[tool.pytest.ini_options]
+xfail_strict = true
+testpaths = "tests"
+# asyncio_mode = "auto"
+addopts = ["--strict-config", "--strict-markers"]
+markers = ["slow: marks tests as slow (deselect with '-m \"not slow\"')"]
+filterwarnings = ["error"]
+
+[tool.coverage.run]
+branch = true
+parallel = true
+relative_files = true
+source = ["src", "tests"]
+
+[tool.coverage.report]
+show_missing = true
+# skip_covered = true
+partial_branches = [
+    "# pragma: no cover\\b",
+    "# pragma: (nt|posix|cygwin|darwin|linux|msys|win32|cpython|pypy) (no )?cover\\b",
+    "# pragma: (>=?|<=?|==|!=)\\d+\\.\\d+ cover\\b",
+]
+exclude_also = ['case _:\n\s*assert_never\(.*\)']
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "F",   # pyflakes
+    "PL",  # pylint
+    "I",   # isort
+    "C",   # flake8-comprehensions
+    "B",   # flake8-bugbear
+    "Q",   # flake8-quotes
+    "T20", # flake8-print
+    "S",   # flake8-bandit
+    "N",   # pep8-naming
+    "UP",  # pyupgrade
+    "RUF", # ruff
+]
+ignore = [
+    "E501", # line too long, handled by formatter
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101", "S311"]
+
+[tool.semantic_release]
+commit_parser = "emoji"
+commit_message = "🔖 {version}\n\nAutomatically generated by python-semantic-release"
+version_toml = ["pyproject.toml:project.version"]
+allow_zero_version = true
+
+[tool.semantic_release.commit_parser_options]
+major_tags = ["💥"]
+minor_tags = ["✨"]
+patch_tags = ["🚑️", "🔒️", "🐛", "⚡️"]

turbo_lambda-0.1.0/src/turbo_lambda/decorators.py

@@ -0,0 +1,221 @@
+import inspect
+import logging
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import AbstractContextManager
+from functools import wraps
+from types import TracebackType
+from typing import Any, Protocol, overload
+
+import pydantic
+
+from turbo_lambda import schemas
+from turbo_lambda.errors import (
+    RequestValidationError,
+    general_error_to_gateway_response,
+)
+from turbo_lambda.log import log_after_call, logger, logger_bind
+
+
+class LambdaHandlerT[ResponseT](Protocol):
+    def __call__(
+        self, event: schemas.EventType, context: schemas.LambdaContextProtocol
+    ) -> ResponseT: ...
+
+
+class ModelDumpProtocol[DumpOutput](Protocol):
+    def model_dump(self) -> DumpOutput: ...
+
+
+@overload
+def validated_handler[RequestT: pydantic.BaseModel, DumpOutput](
+    func: Callable[[RequestT], ModelDumpProtocol[DumpOutput]],
+) -> LambdaHandlerT[DumpOutput]: ...
+
+
+@overload
+def validated_handler[RequestT: pydantic.BaseModel, ResponseT](
+    func: Callable[[RequestT], ResponseT],
+) -> LambdaHandlerT[ResponseT]: ...
+
+
+def validated_handler[RequestT: pydantic.BaseModel, ResponseT](
+    func: Callable[[RequestT], ResponseT],
+) -> LambdaHandlerT[Any]:
+    func_annotations = inspect.signature(func, eval_str=True)
+    request_type: type[RequestT] = next(
+        iter(func_annotations.parameters.values())
+    ).annotation
+    response_type_adapter: pydantic.TypeAdapter[ResponseT] = pydantic.TypeAdapter(
+        func_annotations.return_annotation
+    )
+
+    def wrapper(
+        event: schemas.EventType, context: schemas.LambdaContextProtocol
+    ) -> Any:
+        try:
+            validated_event = request_type.model_validate(event)
+        except pydantic.ValidationError as e:
+            raise RequestValidationError(e) from e
+        logger.debug("parsed_event", extra={"event": validated_event})
+        return response_type_adapter.dump_python(
+            func(validated_event), mode="json", by_alias=True
+        )
+
+    return wrapper
+
+
+def context_manager_middleware[**P, T](
+    cm: Callable[P, AbstractContextManager[Any]],
+) -> Callable[[Callable[P, T]], Callable[P, T]]:
+    def decorator(func: Callable[P, T]) -> Callable[P, T]:
+        @wraps(func)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            with cm(*args, **kwargs):
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def error_transformer_handler[**P, T, E: Exception](
+    error_handler: Callable[[E], T],
+) -> Callable[[Callable[P, T]], Callable[P, T]]:
+    error_handler_annotations = inspect.signature(error_handler, eval_str=True)
+    error_type: type[E] = next(
+        iter(error_handler_annotations.parameters.values())
+    ).annotation
+
+    def decorator(func: Callable[P, T]) -> Callable[P, T]:
+        @wraps(func)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            try:
+                return func(*args, **kwargs)
+            except error_type as e:
+                return error_handler(e)
+
+        return wrapper
+
+    return decorator
+
+
+def request_logger_handler[ResponseT](
+    func: LambdaHandlerT[ResponseT],
+) -> LambdaHandlerT[ResponseT]:
+    def bind_extractor(
+        event: schemas.EventType, context: schemas.LambdaContextProtocol
+    ) -> AbstractContextManager[None]:
+        return logger_bind(
+            lambda_context={
+                "name": context.function_name,
+                "memory_size": context.memory_limit_in_mb,
+                "arn": context.invoked_function_arn,
+                "request_id": context.aws_request_id,
+            },
+        )
+
+    return context_manager_middleware(
+        bind_extractor,
+    )(
+        log_after_call(
+            log_level=logging.DEBUG,
+            log_message="request",
+            result_extractor=lambda _: {},  # TODO: Remove after mypy fix
+        )(
+            func,
+        ),
+    )
+
+
+def gateway_handler[RequestT: pydantic.BaseModel](
+    func: Callable[[RequestT], schemas.ApiGatewayResponse],
+) -> LambdaHandlerT[schemas.ApiGatewaySerializedResponse]:
+    def bind_extractor(
+        event: schemas.EventType, context: schemas.LambdaContextProtocol
+    ) -> AbstractContextManager[None]:
+        return logger_bind(
+            lambda_context={
+                "name": context.function_name,
+                "memory_size": context.memory_limit_in_mb,
+                "arn": context.invoked_function_arn,
+                "request_id": context.aws_request_id,
+            },
+            correlation_id=event["requestContext"].get("requestId"),
+        )
+
+    def result_extractor(
+        response: schemas.ApiGatewaySerializedResponse,
+    ) -> dict[str, Any]:
+        return {"status_code": response["statusCode"]}
+
+    return context_manager_middleware(
+        bind_extractor,
+    )(
+        log_after_call(
+            log_level=logging.DEBUG,
+            log_message="request",
+            result_extractor=result_extractor,
+        )(
+            error_transformer_handler(general_error_to_gateway_response)(
+                validated_handler(func),
+            ),
+        )
+    )
+
+
+def parallel_sqs_handler[RequestT](
+    *,
+    max_workers: int,
+) -> Callable[
+    [Callable[[RequestT], None]],
+    Callable[[schemas.SqsEvent[RequestT]], schemas.LambdaCheckpointResponse],
+]:
+    def decorator(
+        func: Callable[[RequestT], None],
+    ) -> Callable[[schemas.SqsEvent[RequestT]], schemas.LambdaCheckpointResponse]:
+        func_annotations = inspect.signature(func, eval_str=True)
+        request_type: type[RequestT] = next(
+            iter(func_annotations.parameters.values())
+        ).annotation
+        SqsEventType = schemas.SqsEvent[request_type]  # type: ignore[valid-type] # noqa: N806
+
+        def single_record_processor(
+            rec: schemas.SqsRecordModel[RequestT],
+        ) -> schemas.LambdaCheckpointItem | None:
+            try:
+                func(rec.body)
+            except Exception:
+                return schemas.LambdaCheckpointItem(item_identifier=rec.message_id)
+            return None
+
+        def wrapper(event: SqsEventType) -> schemas.LambdaCheckpointResponse:
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                responses = executor.map(single_record_processor, event.records)
+            return schemas.LambdaCheckpointResponse(
+                batch_item_failures=[item for item in responses if item is not None]
+            )
+
+        return wrapper
+
+    return decorator
+
+
+class CachedContextManager[T]:
+    def __init__(self, context_manager: AbstractContextManager[T]) -> None:
+        self._context_manager = context_manager
+
+    def __enter__(self) -> T:
+        self._value = self._context_manager.__enter__()
+        return self._value
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        return self._context_manager.__exit__(exc_type, exc_value, traceback)
+
+    def __call__(self) -> T:
+        return self._value

turbo_lambda-0.1.0/src/turbo_lambda/errors.py

@@ -0,0 +1,59 @@
+from http import HTTPStatus
+from typing import Any
+
+import pydantic
+
+from turbo_lambda import schemas
+
+
+class ApplicationError(Exception):
+    pass
+
+
+class UnauthorizedError(ApplicationError):
+    def __init__(self) -> None:
+        super().__init__("Unauthorized")
+
+
+class GeneralError(ApplicationError):
+    def __init__(
+        self,
+        error_type: str = "about:blank",
+        status_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
+        title: str | None = None,
+        detail: str = "General error",
+        extensions: Any = None,
+    ) -> None:
+        super().__init__()
+        self.error_type = error_type
+        self.status_code = status_code
+        self.title = status_code.description if title is None else title
+        self.detail = detail
+        self.extensions = extensions
+
+
+class RequestValidationError(GeneralError):
+    def __init__(self, error: pydantic.ValidationError) -> None:
+        super().__init__(
+            error_type="https://docs.pydantic.dev/errors/validation_errors/",
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+            title=error.title,
+            detail=str(error),
+            extensions=error.errors(),
+        )
+
+
+def general_error_to_gateway_response(
+    error: GeneralError,
+) -> schemas.ApiGatewaySerializedResponse:
+    return schemas.ApiGatewayResponse(
+        status_code=error.status_code,
+        headers={"Content-Type": "application/problem+json"},
+        body=schemas.HttpErrorResponse(
+            type=error.error_type,
+            status=error.status_code,
+            title=error.title,
+            detail=error.detail,
+            extensions=error.extensions,
+        ),
+    ).model_dump()

turbo_lambda-0.1.0/src/turbo_lambda/log.py

@@ -0,0 +1,181 @@
+import contextlib
+import contextvars
+import inspect
+import logging
+import os
+import time
+from collections.abc import Callable, Generator, Iterable, Mapping
+from functools import singledispatch, wraps
+from typing import Any, Never, overload
+
+import orjson
+import pydantic
+
+LOGGING_CTX: contextvars.ContextVar[dict[str, Any]] = contextvars.ContextVar(
+    "LOGGING_CTX"
+)
+_DEFAULT_TRANSLATOR = {
+    "levelname": "level",
+    "name": "logger",
+    "asctime": "timestamp",
+    "exc_text": "exc_info",
+    "funcName": "func_name",
+    "threadName": "thread_name",
+    "processName": "process_name",
+    "taskName": "task_name",
+}
+_DEFAULT_IGNORE = {
+    "msg",
+    "args",
+    "levelno",
+    "exc_info",
+    "created",
+    "msecs",
+    "relativeCreated",
+}
+
+
+@contextlib.contextmanager
+def logger_bind(**kwargs: Any) -> Generator[None]:
+    token = LOGGING_CTX.set(LOGGING_CTX.get({}) | kwargs)
+    try:
+        yield
+    finally:
+        LOGGING_CTX.reset(token)
+
+
+def _context_adder_filter(record: logging.LogRecord) -> bool:
+    for k, v in LOGGING_CTX.get({}).items():
+        setattr(record, k, v)
+    return True
+
+
+@singledispatch
+def orjson_custom_type_handler(value: Any) -> Never:
+    raise TypeError()
+
+
+@orjson_custom_type_handler.register(set)
+def _(value: set[Any]) -> Any:
+    return list(value)
+
+
+@orjson_custom_type_handler.register(pydantic.BaseModel)
+def _(value: pydantic.BaseModel) -> Any:
+    return value.model_dump(mode="json")
+
+
+class JsonFormatter(logging.Formatter):
+    def __init__(
+        self,
+        translator_dict: Mapping[str, str] | None = None,
+        ignored_keys: set[str] | None = None,
+    ):
+        self.translator_dict = translator_dict or _DEFAULT_TRANSLATOR
+        self.ignored_keys = ignored_keys or _DEFAULT_IGNORE
+        self.default_time_format = "%Y-%m-%dT%H:%M:%S"
+        self.default_msec_format = "%s.%03dZ"
+        super().__init__()
+
+    def format(self, record: logging.LogRecord) -> str:
+        record.message = record.getMessage()
+        record.asctime = self.formatTime(record)
+        if record.exc_info and record.exc_text is None:
+            record.exc_text = self.formatException(record.exc_info)
+        if record.stack_info:
+            record.stack_info = self.formatStack(record.stack_info)
+        message_dict = {
+            self.translator_dict.get(rec_key, rec_key): rec_val
+            for rec_key, rec_val in vars(record).items()
+            if rec_key not in self.ignored_keys
+        }
+        return orjson.dumps(message_dict, default=orjson_custom_type_handler).decode()
+
+
+def config_default_logger() -> None:  # pragma: no cover
+    handler = logging.StreamHandler()
+    handler.setFormatter(json_formatter)
+    logger.addHandler(handler)
+
+
+def config_lambda_logger() -> None:  # pragma: no cover
+    if log_level := os.environ.get("AWS_LAMBDA_LOG_LEVEL"):
+        logger.setLevel(log_level)
+    logging.getLogger().handlers[0].setFormatter(json_formatter)
+
+
+@overload
+def log_after_call[**P, T](func: Callable[P, T]) -> Callable[P, T]: ...
+
+
+@overload
+def log_after_call[**P, T](
+    *,
+    log_level: int = logging.INFO,
+    log_message: str = "call",
+    excluded_fields: Iterable[str] = ("self", "context"),
+    result_extractor: Callable[[T], dict[str, Any]] = lambda _: {},
+) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
+
+
+def log_after_call[**P, T](
+    func: Callable[P, T] | None = None,
+    log_level: int = logging.INFO,
+    log_message: str = "call",
+    excluded_fields: Iterable[str] = ("self", "context"),
+    result_extractor: Callable[[T], dict[str, Any]] = lambda _: {},
+) -> Callable[P, T] | Callable[[Callable[P, T]], Callable[P, T]]:
+    def decorator(func: Callable[P, T]) -> Callable[P, T]:
+        sig = inspect.signature(func)
+
+        @wraps(func)
+        def wrapper(*f_args: P.args, **f_kwargs: P.kwargs) -> T:
+            extra: dict[str, Any] = {
+                "function": {
+                    "name": func.__qualname__,
+                    "module": func.__module__,
+                    "pathname": func.__code__.co_filename,
+                    "firstlineno": func.__code__.co_firstlineno,
+                },
+                "arguments": get_arguments(sig, excluded_fields, f_args, f_kwargs),
+            }
+            exc_info = False
+            st = time.monotonic()
+            try:
+                result = func(*f_args, **f_kwargs)
+                extra.update(result_extractor(result))
+                return result
+            except Exception:
+                exc_info = True
+                raise
+            finally:
+                extra["duration"] = time.monotonic() - st
+                logger.log(
+                    log_level if not exc_info else logging.ERROR,
+                    log_message,
+                    exc_info=exc_info,
+                    extra=extra,
+                )
+
+        return wrapper
+
+    return decorator if func is None else decorator(func)
+
+
+def get_arguments(
+    sig: inspect.Signature,
+    excluded_fields: Iterable[str],
+    args: Iterable[Any],
+    kwargs: dict[str, Any],
+) -> dict[str, Any]:
+    bind = sig.bind(*args, **kwargs)
+    bind.apply_defaults()
+    for field in excluded_fields:
+        bind.arguments.pop(field, None)
+    return bind.arguments
+
+
+json_formatter = JsonFormatter()
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+logger.addFilter(_context_adder_filter)

turbo_lambda-0.1.0/src/turbo_lambda/schemas.py

@@ -0,0 +1,503 @@
+import base64
+import datetime
+import os
+import re
+from enum import Enum
+from http import HTTPStatus
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Literal,
+    NewType,
+    Protocol,
+    TypedDict,
+    assert_never,
+)
+
+import annotated_types
+import pydantic
+from pydantic_core import core_schema
+
+IS_LAMBDA = os.environ.get("AWS_EXECUTION_ENV", "").startswith("AWS_Lambda_")
+EventType = NewType("EventType", dict[str, Any])
+_ROUTE_ARN_PATTERN_STR = r"^arn:aws:execute-api:(?P<region>[a-zA-Z0-9-]+):(?P<account_id>\d+):(?P<api_id>[a-zA-Z0-9]+)/(?P<stage>[^/]+)/(?P<method>[A-Z]+)/(?P<resource_path>.*)$"
+_ROUTE_ARN_PATTERN = re.compile(_ROUTE_ARN_PATTERN_STR)
+
+
+class LambdaContextProtocol(Protocol):
+    function_name: str
+    memory_limit_in_mb: int
+    invoked_function_arn: str
+    aws_request_id: str
+
+
+class GatewayEventPathParameters[ParamT](pydantic.BaseModel):
+    path_parameters: Annotated[ParamT, pydantic.Field(alias="pathParameters")]
+
+
+class GatewayEventQueryParameters[ParamT](pydantic.BaseModel):
+    query_string_parameters: Annotated[
+        ParamT | None, pydantic.Field(alias="queryStringParameters")
+    ] = None
+
+
+class HttpErrorResponse(pydantic.BaseModel):
+    """RFC7807 Compatible schema."""
+
+    type: str
+    status: int
+    title: str
+    detail: str
+    extensions: Any
+
+
+class ApiGatewaySerializedResponse(TypedDict):
+    statusCode: int
+    headers: dict[str, str]
+    body: str | None
+    isBase64Encoded: bool
+
+
+class ApiGatewayResponse(pydantic.BaseModel):
+    status_code: int | None = None
+    headers: dict[str, str] | None = None
+    body: pydantic.BaseModel | bytes | None
+
+    @pydantic.model_serializer
+    def serializer(self) -> ApiGatewaySerializedResponse:
+        match self.body:
+            case pydantic.BaseModel():
+                return {
+                    "statusCode": self.status_code or HTTPStatus.OK,
+                    "headers": {"Content-Type": "application/json"}
+                    | (self.headers or {}),
+                    "body": self.body.model_dump_json(by_alias=True),
+                    "isBase64Encoded": False,
+                }
+            case bytes():
+                return {
+                    "statusCode": self.status_code or HTTPStatus.OK,
+                    "headers": {"Content-Type": "application/octet-stream"}
+                    | (self.headers or {}),
+                    "body": base64.b64encode(self.body).decode(),
+                    "isBase64Encoded": True,
+                }
+            case None:
+                return {
+                    "statusCode": self.status_code or HTTPStatus.NO_CONTENT,
+                    "headers": (self.headers or {}),
+                    "body": None,
+                    "isBase64Encoded": False,
+                }
+            case _:
+                assert_never(self.body)
+
+    if TYPE_CHECKING:
+
+        def model_dump(self) -> ApiGatewaySerializedResponse: ...  # type: ignore[override]
+
+
+class SqsAttributesModel(pydantic.BaseModel):
+    approximate_receive_count: Annotated[
+        str,
+        pydantic.Field(
+            alias="ApproximateReceiveCount",
+            description="The number of times a message has been received across all queues but not deleted.",
+            examples=["1", "2"],
+        ),
+    ]
+    message_deduplication_id: Annotated[
+        str | None,
+        pydantic.Field(
+            alias="MessageDeduplicationId",
+            description="Returns the value provided by the producer that calls the SendMessage action.",
+            examples=["msg-dedup-12345", "unique-msg-abc123", None],
+        ),
+    ] = None
+    message_group_id: Annotated[
+        str | None,
+        pydantic.Field(
+            alias="MessageGroupId",
+            description="Returns the value provided by the producer that calls the SendMessage action.",
+            examples=["order-processing", "user-123-updates", None],
+        ),
+    ] = None
+    aws_trace_header: Annotated[
+        str | None,
+        pydantic.Field(
+            alias="AWSTraceHeader",
+            description="The AWS X-Ray trace header for request tracing.",
+            examples=["Root=1-5e1b4151-5ac6c58239c1e5b4", None],
+        ),
+    ] = None
+    sent_timestamp: Annotated[
+        datetime.datetime,
+        pydantic.Field(
+            alias="SentTimestamp",
+            description="The time the message was sent to the queue (epoch time in milliseconds).",
+            examples=["1545082649183", "1545082650636", "1713185156609"],
+        ),
+    ]
+    sequence_number: Annotated[
+        str | None,
+        pydantic.Field(
+            alias="SequenceNumber",
+            description="Returns the value provided by Amazon SQS.",
+            examples=["18849496460467696128", "18849496460467696129", None],
+        ),
+    ] = None
+    dead_letter_queue_source_arn: Annotated[
+        str | None,
+        pydantic.Field(
+            alias="DeadLetterQueueSourceArn",
+            description="The ARN of the dead-letter queue from which the message was moved.",
+            examples=[
+                "arn:aws:sqs:eu-central-1:123456789012:sqs-redrive-SampleQueue-RNvLCpwGmLi7",
+                None,
+            ],
+        ),
+    ] = None
+    sender_id: Annotated[
+        str,
+        pydantic.Field(
+            alias="SenderId",
+            description="The user ID for IAM users or the role ID for IAM roles that sent the message.",
+            examples=["AIDAIENQZJOLO23YVJ4VO", "AMCXIENQZJOLO23YVJ4VO"],
+        ),
+    ]
+    approximate_first_receive_timestamp: Annotated[
+        datetime.datetime,
+        pydantic.Field(
+            alias="ApproximateFirstReceiveTimestamp",
+            description="The time the message was first received from the queue (epoch time in milliseconds).",
+            examples=["1545082649185", "1545082650649", "1713185156612"],
+        ),
+    ]
+
+
+class SqsMsgAttributeModel(pydantic.BaseModel):
+    string_value: Annotated[
+        str | None,
+        pydantic.Field(
+            alias="stringValue",
+            description="The string value of the message attribute.",
+            examples=["100", "active", "user-12345", None],
+        ),
+    ] = None
+    binary_value: Annotated[
+        str | None,
+        pydantic.Field(
+            alias="binaryValue",
+            description="The binary value of the message attribute, base64-encoded.",
+            examples=["base64Str", "SGVsbG8gV29ybGQ=", None],
+        ),
+    ] = None
+    string_list_values: Annotated[
+        list[str],
+        pydantic.Field(
+            alias="stringListValues",
+            description="A list of string values for the message attribute.",
+            examples=[["item1", "item2"], ["tag1", "tag2", "tag3"], []],
+        ),
+    ] = []
+    binary_list_values: Annotated[
+        list[str],
+        pydantic.Field(
+            alias="binaryListValues",
+            description="A list of binary values for the message attribute, each base64-encoded.",
+            examples=[["dmFsdWUx", "dmFsdWUy"], ["aGVsbG8="], []],
+        ),
+    ] = []
+    data_type: Annotated[
+        str,
+        pydantic.Field(
+            alias="dataType",
+            description="The data type of the message attribute (String, Number, Binary, or custom data type).",
+            examples=["String", "Number", "Binary", "String.custom", "Number.float"],
+        ),
+    ]
+
+
+class SqsRecordModel[BodyT](pydantic.BaseModel):
+    message_id: Annotated[
+        str,
+        pydantic.Field(
+            alias="messageId",
+            description="A unique identifier for the message. A MessageId is considered unique across all AWS accounts.",
+            examples=[
+                "059f36b4-87a3-44ab-83d2-661975830a7d",
+                "2e1424d4-f796-459a-8184-9c92662be6da",
+                "db37cc61-1bb0-4e77-b6f3-7cf87f44a72a",
+            ],
+        ),
+    ]
+    receipt_handle: Annotated[
+        str,
+        pydantic.Field(
+            alias="receiptHandle",
+            description="An identifier associated with the act of receiving the message, used for message deletion.",
+            examples=[
+                "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
+                "AQEBzWwaftRI0KuVm4tP+/7q1rGgNqicHq...",
+            ],
+        ),
+    ]
+    body: Annotated[
+        BodyT,
+        pydantic.Field(
+            description="The message's contents (not URL-encoded). Can be plain text or JSON.",
+            examples=[
+                "Test message.",
+                '{"message": "foo1"}',
+                "hello world",
+            ],
+        ),
+    ]
+    attributes: Annotated[
+        SqsAttributesModel,
+        pydantic.Field(
+            description="A map of the attributes requested in ReceiveMessage to their respective values.",
+        ),
+    ]
+    message_attributes: Annotated[
+        dict[str, SqsMsgAttributeModel],
+        pydantic.Field(
+            alias="messageAttributes",
+            description="User-defined message attributes as key-value pairs.",
+        ),
+    ]
+    md5_of_body: Annotated[
+        str,
+        pydantic.Field(
+            alias="md5OfBody",
+            description="An MD5 digest of the non-URL-encoded message body string.",
+            examples=[
+                "e4e68fb7bd0e697a0ae8f1bb342846b3",
+                "6a204bd89f3c8348afd5c77c717a097a",
+            ],
+        ),
+    ]
+    md5_of_message_attributes: Annotated[
+        str | None,
+        pydantic.Field(
+            alias="md5OfMessageAttributes",
+            description="An MD5 digest of the non-URL-encoded message attribute string.",
+            examples=[
+                "00484c68...59e48fb7",
+                "b25f48e8...f4e4f0bb",
+                None,
+            ],
+        ),
+    ] = None
+    event_source: Annotated[
+        Literal["aws:sqs"],
+        pydantic.Field(
+            alias="eventSource",
+            description="The AWS service that invoked the function.",
+            examples=["aws:sqs"],
+        ),
+    ]
+    event_source_arn: Annotated[
+        str,
+        pydantic.Field(
+            alias="eventSourceARN",
+            description="The Amazon Resource Name (ARN) of the SQS queue.",
+            examples=[
+                "arn:aws:sqs:us-east-2:123456789012:my-queue",
+                "arn:aws:sqs:eu-central-1:123456789012:sqs-redrive-SampleDLQ-Emgp9MFSLBZm",
+            ],
+        ),
+    ]
+    aws_region: Annotated[
+        str,
+        pydantic.Field(
+            alias="awsRegion",
+            description="The AWS region where the SQS queue is located.",
+            examples=["us-east-1", "us-east-2", "eu-central-1"],
+        ),
+    ]
+
+
+class SqsEvent[BodyT](pydantic.BaseModel):
+    records: Annotated[
+        list[SqsRecordModel[BodyT]],
+        pydantic.Field(
+            alias="Records",
+            description="A list of SQS message records included in the event.",
+            examples=[
+                [
+                    {
+                        "messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
+                        "body": "Test message.",
+                    }
+                ]
+            ],
+        ),
+    ]
+
+
+class LambdaCheckpointItem(pydantic.BaseModel):
+    item_identifier: Annotated[
+        str, pydantic.Field(serialization_alias="itemIdentifier")
+    ]
+
+
+class LambdaCheckpointResponse(pydantic.BaseModel):
+    batch_item_failures: Annotated[
+        list[LambdaCheckpointItem],
+        pydantic.Field(serialization_alias="batchItemFailures"),
+    ]
+
+
+class EventBridgeModel[DetailT](pydantic.BaseModel):
+    version: Annotated[
+        str,
+        pydantic.Field(
+            description="By default, this is set to 0 (zero) in all events.",
+            examples=["0"],
+        ),
+    ]
+    id: Annotated[
+        str,
+        pydantic.Field(
+            description="A Version 4 UUID generated for every event.",
+            examples=["6a7e8feb-b491-4cf7-a9f1-bf3703467718"],
+        ),
+    ]
+    source: Annotated[
+        str,
+        pydantic.Field(
+            description="Identifies the service that sourced the event. \
+        All events sourced from within AWS begin with 'aws.'",
+            examples=["aws.ec2", "aws.s3", "aws.events", "aws.scheduler"],
+        ),
+    ]
+    account: Annotated[
+        str,
+        pydantic.Field(
+            description="The 12-digit AWS account ID of the owner of the service emitting the event.",
+            examples=["111122223333", "123456789012"],
+        ),
+    ]
+    time: Annotated[
+        datetime.datetime,
+        pydantic.Field(
+            description="The event timestamp, which can be specified by the service originating the event.",
+            examples=["2017-12-22T18:43:48Z", "2023-01-15T10:30:00Z"],
+        ),
+    ]
+    region: Annotated[
+        str,
+        pydantic.Field(
+            description="Identifies the AWS region where the event originated.",
+            examples=["us-east-1", "us-west-2", "eu-west-1"],
+        ),
+    ]
+    resources: Annotated[
+        list[str],
+        pydantic.Field(
+            description="A JSON array that contains ARNs that identify resources involved in the event. "
+            "Inclusion of these ARNs is at the discretion of the service.",
+            examples=[
+                ["arn:aws:ec2:us-west-1:123456789012:instance/i-1234567890abcdef0"],
+                ["arn:aws:s3:::my-bucket/my-key"],
+                ["arn:aws:events:us-east-1:123456789012:rule/MyRule"],
+            ],
+        ),
+    ]
+    detail_type: Annotated[
+        str,
+        pydantic.Field(
+            alias="detail-type",
+            description="Identifies, in combination with the source Field, the fields and values that appear in the detail field.",
+            examples=[
+                "EC2 Instance State-change Notification",
+                "Object Created",
+                "Scheduled Event",
+            ],
+        ),
+    ]
+    detail: Annotated[
+        DetailT,
+        pydantic.Field(
+            description="A JSON object, whose content is at the discretion of the service originating the event.",
+        ),
+    ]
+    replay_name: Annotated[
+        str | None,
+        pydantic.Field(
+            alias="replay-name",
+            description="Identifies whether the event is being replayed and what is the name of the replay.",
+            examples=["replay_archive", "my-replay-2023"],
+        ),
+    ] = None
+
+
+class RouteARN(pydantic.BaseModel):
+    region: str
+    account_id: int
+    api_id: str
+    stage: str
+    method: str
+    resource_path: str
+
+
+def _route_arn_validate(v: str | Any) -> dict[str, str] | Any:
+    if not isinstance(v, str):
+        return v
+    matched = _ROUTE_ARN_PATTERN.match(v)
+    if not matched:
+        raise ValueError("Invalid Route ARN")
+    return matched.groupdict()
+
+
+def _route_arn_serialize(value: RouteARN) -> str:
+    return f"arn:aws:execute-api:{value.region}:{value.account_id}:{value.api_id}/{value.stage}/{value.method}/{value.resource_path}"
+
+
+type RouteARNStr = Annotated[
+    RouteARN,
+    pydantic.BeforeValidator(
+        _route_arn_validate,
+        json_schema_input_type=core_schema.str_schema(pattern=_ROUTE_ARN_PATTERN_STR),
+    ),
+    pydantic.PlainSerializer(
+        _route_arn_serialize,
+        return_type=core_schema.str_schema(pattern=_ROUTE_ARN_PATTERN_STR),
+    ),
+]
+
+
+class ActionEnum(Enum):
+    API_INVOKE = "execute-api:Invoke"
+
+
+class EffectEnum(Enum):
+    ALLOW = "Allow"
+    DENY = "Deny"
+
+
+class AuthorizerPolicyStatement(pydantic.BaseModel):
+    action: Annotated[ActionEnum, pydantic.Field(serialization_alias="Action")]
+    effect: Annotated[EffectEnum, pydantic.Field(serialization_alias="Effect")]
+    resource: Annotated[str, pydantic.Field(serialization_alias="Resource")]
+
+
+class AuthorizerPolicyDocument(pydantic.BaseModel):
+    version: Annotated[
+        Literal["2012-10-17"], pydantic.Field(serialization_alias="Version")
+    ]
+    statement: Annotated[
+        list[AuthorizerPolicyStatement],
+        annotated_types.Len(1),
+        pydantic.Field(serialization_alias="Statement"),
+    ]
+
+
+class AuthorizerResponse(pydantic.BaseModel):
+    principal_id: Annotated[str, pydantic.Field(serialization_alias="principalId")]
+    policy_document: Annotated[
+        AuthorizerPolicyDocument, pydantic.Field(serialization_alias="policyDocument")
+    ]
+    context: dict[str, str]