aws-lambda-powertools 3.14.1a5__py3-none-any.whl → 3.15.0__py3-none-any.whl

aws_lambda_powertools/event_handler/api_gateway.py

@@ -407,7 +407,7 @@ class Route:
 
         # OpenAPI spec only understands paths with { }. So we'll have to convert Powertools' < >.
         # https://swagger.io/specification/#path-templating
-        self.openapi_path = re.sub(r"<(.*?)>", lambda m: f"{{{''.join(m.group(1))}}}", self.path)
+        self.openapi_path = re.sub(r"<(.*?)>", lambda m: f"{{{''.join(m.group(1))}}}", self.path)  # type: ignore[arg-type]
 
         self.rule = rule
         self.func = func

aws_lambda_powertools/shared/version.py

@@ -1,3 +1,3 @@
 """Exposes version constant to avoid circular dependencies."""
 
-VERSION = "3.14.1a5"
+VERSION = "3.15.0"

aws_lambda_powertools/utilities/data_classes/kafka_event.py

@@ -10,7 +10,19 @@ if TYPE_CHECKING:
     from collections.abc import Iterator
 
 
-class KafkaEventRecord(DictWrapper):
+class KafkaEventRecordSchemaMetadata(DictWrapper):
+    @property
+    def data_format(self) -> str | None:
+        """The data format of the Kafka record."""
+        return self.get("dataFormat", None)
+
+    @property
+    def schema_id(self) -> str | None:
+        """The schema id of the Kafka record."""
+        return self.get("schemaId", None)
+
+
+class KafkaEventRecordBase(DictWrapper):
     @property
     def topic(self) -> str:
         """The Kafka topic."""
@@ -36,6 +48,24 @@ class KafkaEventRecord(DictWrapper):
         """The Kafka record timestamp type."""
         return self["timestampType"]
 
+    @property
+    def key_schema_metadata(self) -> KafkaEventRecordSchemaMetadata | None:
+        """The metadata of the Key Kafka record."""
+        return (
+            None if self.get("keySchemaMetadata") is None else KafkaEventRecordSchemaMetadata(self["keySchemaMetadata"])
+        )
+
+    @property
+    def value_schema_metadata(self) -> KafkaEventRecordSchemaMetadata | None:
+        """The metadata of the Value Kafka record."""
+        return (
+            None
+            if self.get("valueSchemaMetadata") is None
+            else KafkaEventRecordSchemaMetadata(self["valueSchemaMetadata"])
+        )
+
+
+class KafkaEventRecord(KafkaEventRecordBase):
     @property
     def key(self) -> str | None:
         """
@@ -83,18 +113,7 @@ class KafkaEventRecord(DictWrapper):
         return CaseInsensitiveDict((k, bytes(v)) for chunk in self.headers for k, v in chunk.items())
 
 
-class KafkaEvent(DictWrapper):
-    """Self-managed or MSK Apache Kafka event trigger
-    Documentation:
-    --------------
-    - https://docs.aws.amazon.com/lambda/latest/dg/with-kafka.html
-    - https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html
-    """
-
-    def __init__(self, data: dict[str, Any]):
-        super().__init__(data)
-        self._records: Iterator[KafkaEventRecord] | None = None
-
+class KafkaEventBase(DictWrapper):
     @property
     def event_source(self) -> str:
         """The AWS service from which the Kafka event record originated."""
@@ -115,6 +134,19 @@ class KafkaEvent(DictWrapper):
         """The decoded Kafka bootstrap URL."""
         return self.bootstrap_servers.split(",")
 
+
+class KafkaEvent(KafkaEventBase):
+    """Self-managed or MSK Apache Kafka event trigger
+    Documentation:
+    --------------
+    - https://docs.aws.amazon.com/lambda/latest/dg/with-kafka.html
+    - https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html
+    """
+
+    def __init__(self, data: dict[str, Any]):
+        super().__init__(data)
+        self._records: Iterator[KafkaEventRecord] | None = None
+
     @property
     def records(self) -> Iterator[KafkaEventRecord]:
         """The Kafka records."""

aws_lambda_powertools/utilities/kafka/__init__.py

@@ -0,0 +1,9 @@
+from aws_lambda_powertools.utilities.kafka.consumer_records import ConsumerRecords
+from aws_lambda_powertools.utilities.kafka.kafka_consumer import kafka_consumer
+from aws_lambda_powertools.utilities.kafka.schema_config import SchemaConfig
+
+__all__ = [
+    "kafka_consumer",
+    "ConsumerRecords",
+    "SchemaConfig",
+]

aws_lambda_powertools/utilities/kafka/consumer_records.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from functools import cached_property
+from typing import TYPE_CHECKING, Any
+
+from aws_lambda_powertools.utilities.data_classes.common import CaseInsensitiveDict
+from aws_lambda_powertools.utilities.data_classes.kafka_event import KafkaEventBase, KafkaEventRecordBase
+from aws_lambda_powertools.utilities.kafka.deserializer.deserializer import get_deserializer
+from aws_lambda_powertools.utilities.kafka.serialization.serialization import serialize_to_output_type
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from aws_lambda_powertools.utilities.kafka.schema_config import SchemaConfig
+
+
+class ConsumerRecordRecords(KafkaEventRecordBase):
+    """
+    A Kafka Consumer Record
+    """
+
+    def __init__(self, data: dict[str, Any], schema_config: SchemaConfig | None = None):
+        super().__init__(data)
+        self.schema_config = schema_config
+
+    @cached_property
+    def key(self) -> Any:
+        key = self.get("key")
+
+        # Return None if key doesn't exist
+        if not key:
+            return None
+
+        # Determine schema type and schema string
+        schema_type = None
+        schema_str = None
+        output_serializer = None
+
+        if self.schema_config and self.schema_config.key_schema_type:
+            schema_type = self.schema_config.key_schema_type
+            schema_str = self.schema_config.key_schema
+            output_serializer = self.schema_config.key_output_serializer
+
+        # Always use get_deserializer if None it will default to DEFAULT
+        deserializer = get_deserializer(schema_type, schema_str)
+        deserialized_value = deserializer.deserialize(key)
+
+        # Apply output serializer if specified
+        if output_serializer:
+            return serialize_to_output_type(deserialized_value, output_serializer)
+
+        return deserialized_value
+
+    @cached_property
+    def value(self) -> Any:
+        value = self["value"]
+
+        # Determine schema type and schema string
+        schema_type = None
+        schema_str = None
+        output_serializer = None
+
+        if self.schema_config and self.schema_config.value_schema_type:
+            schema_type = self.schema_config.value_schema_type
+            schema_str = self.schema_config.value_schema
+            output_serializer = self.schema_config.value_output_serializer
+
+        # Always use get_deserializer if None it will default to DEFAULT
+        deserializer = get_deserializer(schema_type, schema_str)
+        deserialized_value = deserializer.deserialize(value)
+
+        # Apply output serializer if specified
+        if output_serializer:
+            return serialize_to_output_type(deserialized_value, output_serializer)
+
+        return deserialized_value
+
+    @property
+    def original_value(self) -> str:
+        """The original (base64 encoded) Kafka record value."""
+        return self["value"]
+
+    @property
+    def original_key(self) -> str | None:
+        """
+        The original (base64 encoded) Kafka record key.
+
+        This key is optional; if not provided,
+        a round-robin algorithm will be used to determine
+        the partition for the message.
+        """
+
+        return self.get("key")
+
+    @property
+    def original_headers(self) -> list[dict[str, list[int]]]:
+        """The raw Kafka record headers."""
+        return self["headers"]
+
+    @cached_property
+    def headers(self) -> dict[str, bytes]:
+        """Decodes the headers as a single dictionary."""
+        return CaseInsensitiveDict((k, bytes(v)) for chunk in self.original_headers for k, v in chunk.items())
+
+
+class ConsumerRecords(KafkaEventBase):
+    """Self-managed or MSK Apache Kafka event trigger
+    Documentation:
+    --------------
+    - https://docs.aws.amazon.com/lambda/latest/dg/with-kafka.html
+    - https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html
+    """
+
+    def __init__(self, data: dict[str, Any], schema_config: SchemaConfig | None = None):
+        super().__init__(data)
+        self._records: Iterator[ConsumerRecordRecords] | None = None
+        self.schema_config = schema_config
+
+    @property
+    def records(self) -> Iterator[ConsumerRecordRecords]:
+        """The Kafka records."""
+        for chunk in self["records"].values():
+            for record in chunk:
+                yield ConsumerRecordRecords(data=record, schema_config=self.schema_config)
+
+    @property
+    def record(self) -> ConsumerRecordRecords:
+        """
+        Returns the next Kafka record using an iterator.
+
+        Returns
+        -------
+        ConsumerRecordRecords
+            The next Kafka record.
+
+        Raises
+        ------
+        StopIteration
+            If there are no more records available.
+
+        """
+        if self._records is None:
+            self._records = self.records
+        return next(self._records)

aws_lambda_powertools/utilities/kafka/deserializer/avro.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import io
+
+from avro.io import BinaryDecoder, DatumReader
+from avro.schema import parse as parse_schema
+
+from aws_lambda_powertools.utilities.kafka.deserializer.base import DeserializerBase
+from aws_lambda_powertools.utilities.kafka.exceptions import (
+    KafkaConsumerAvroSchemaParserError,
+    KafkaConsumerDeserializationError,
+)
+
+
+class AvroDeserializer(DeserializerBase):
+    """
+    Deserializer for Apache Avro formatted data.
+
+    This class provides functionality to deserialize Avro binary data using
+    a provided Avro schema definition.
+    """
+
+    def __init__(self, schema_str: str):
+        try:
+            self.parsed_schema = parse_schema(schema_str)
+            self.reader = DatumReader(self.parsed_schema)
+        except Exception as e:
+            raise KafkaConsumerAvroSchemaParserError(
+                f"Invalid Avro schema. Please ensure the provided avro schema is valid: {type(e).__name__}: {str(e)}",
+            ) from e
+
+    def deserialize(self, data: bytes | str) -> object:
+        """
+        Deserialize Avro binary data to a Python dictionary.
+
+        Parameters
+        ----------
+        data : bytes or str
+            The Avro binary data to deserialize. If provided as a string,
+            it will be decoded to bytes first.
+
+        Returns
+        -------
+        dict[str, Any]
+            Deserialized data as a dictionary.
+
+        Raises
+        ------
+        KafkaConsumerDeserializationError
+            When the data cannot be deserialized according to the schema,
+            typically due to data format incompatibility.
+
+        Examples
+        --------
+        >>> deserializer = AvroDeserializer(schema_str)
+        >>> avro_data = b'...'  # binary Avro data
+        >>> try:
+        ...     result = deserializer.deserialize(avro_data)
+        ...     # Process the deserialized data
+        ... except KafkaConsumerDeserializationError as e:
+        ...     print(f"Failed to deserialize: {e}")
+        """
+        try:
+            value = self._decode_input(data)
+            bytes_reader = io.BytesIO(value)
+            decoder = BinaryDecoder(bytes_reader)
+            return self.reader.read(decoder)
+        except Exception as e:
+            raise KafkaConsumerDeserializationError(
+                f"Error trying to deserialize avro data - {type(e).__name__}: {str(e)}",
+            ) from e

aws_lambda_powertools/utilities/kafka/deserializer/base.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import base64
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class DeserializerBase(ABC):
+    """
+    Abstract base class for deserializers.
+
+    This class defines the interface for all deserializers in the Kafka consumer utility
+    and provides a common method for decoding input data.
+
+    Methods
+    -------
+    deserialize(data)
+        Abstract method that must be implemented by subclasses to deserialize data.
+    _decode_input(data)
+        Helper method to decode input data to bytes.
+
+    Examples
+    --------
+    >>> class MyDeserializer(DeserializerBase):
+    ...     def deserialize(self, data: bytes | str) -> dict[str, Any]:
+    ...         value = self._decode_input(data)
+    ...         # Custom deserialization logic here
+    ...         return {"key": "value"}
+    """
+
+    @abstractmethod
+    def deserialize(self, data: str) -> dict[str, Any] | str | object:
+        """
+        Deserialize input data to a Python dictionary.
+
+        This abstract method must be implemented by subclasses to provide
+        specific deserialization logic.
+
+        Parameters
+        ----------
+        data : str
+            The data to deserialize, it's always a base64 encoded string
+
+        Returns
+        -------
+        dict[str, Any]
+            The deserialized data as a dictionary.
+        """
+        raise NotImplementedError("Subclasses must implement the deserialize method")
+
+    def _decode_input(self, data: bytes | str) -> bytes:
+        return base64.b64decode(data)

aws_lambda_powertools/utilities/kafka/deserializer/default.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import base64
+
+from aws_lambda_powertools.utilities.kafka.deserializer.base import DeserializerBase
+
+
+class DefaultDeserializer(DeserializerBase):
+    """
+    A default deserializer that performs base64 decode + binary decode on the input data.
+
+    This deserializer simply returns the input data with base64 decode, which is useful when
+    no customized deserialization is needed or when handling raw data formats.
+    """
+
+    def deserialize(self, data: bytes | str) -> str:
+        """
+        Return the input data base64 decoded.
+
+        This method implements the deserialize interface and performs base64 decode.
+
+        Parameters
+        ----------
+        data : bytes or str
+            The input data to "deserialize".
+
+        Returns
+        -------
+        dict[str, Any]
+            The input data base64 decoded.
+
+        Example
+        --------
+        >>> deserializer = NoOpDeserializer()
+        >>>
+        >>> # With string input
+        >>> string_data = "Hello, world!"
+        >>> result = deserializer.deserialize(string_data)
+        >>> print(result == string_data)  # Output: True
+        >>>
+        >>> # With bytes input
+        >>> bytes_data = b"Binary data"
+        >>> result = deserializer.deserialize(bytes_data)
+        >>> print(result == bytes_data)  # Output: True
+        """
+        return base64.b64decode(data).decode("utf-8")

aws_lambda_powertools/utilities/kafka/deserializer/deserializer.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import hashlib
+from typing import TYPE_CHECKING, Any
+
+from aws_lambda_powertools.utilities.kafka.deserializer.default import DefaultDeserializer
+from aws_lambda_powertools.utilities.kafka.deserializer.json import JsonDeserializer
+
+if TYPE_CHECKING:
+    from aws_lambda_powertools.utilities.kafka.deserializer.base import DeserializerBase
+
+# Cache for deserializers
+_deserializer_cache: dict[str, DeserializerBase] = {}
+
+
+def _get_cache_key(schema_type: str | object, schema_value: Any) -> str:
+    if schema_value is None:
+        return str(schema_type)
+
+    if isinstance(schema_value, str):
+        # For string schemas like Avro, hash the content
+        schema_hash = hashlib.md5(schema_value.encode("utf-8"), usedforsecurity=False).hexdigest()
+    else:
+        # For objects like Protobuf, use the object id
+        schema_hash = str(id(schema_value))
+
+    return f"{schema_type}_{schema_hash}"
+
+
+def get_deserializer(schema_type: str | object, schema_value: Any) -> DeserializerBase:
+    """
+    Factory function to get the appropriate deserializer based on schema type.
+
+    This function creates and returns a deserializer instance that corresponds to the
+    specified schema type. It handles lazy imports for optional dependencies.
+
+    Parameters
+    ----------
+    schema_type : str
+        The type of schema to use for deserialization.
+        Supported values are: "AVRO", "PROTOBUF", "JSON", or any other value for no-op.
+    schema_value : Any
+        The schema definition to use for deserialization. The format depends on the
+        schema_type:
+        - For "AVRO": A string containing the Avro schema definition
+        - For "PROTOBUF": A object containing the Protobuf schema definition
+        - For "JSON": Not used (can be None)
+        - For other types: Not used (can be None)
+
+    Returns
+    -------
+    DeserializerBase
+        An instance of a deserializer that implements the DeserializerBase interface.
+
+    Examples
+    --------
+    >>> # Get an Avro deserializer
+    >>> avro_schema = '''
+    ...     {
+    ...       "type": "record",
+    ...       "name": "User",
+    ...       "fields": [
+    ...         {"name": "name", "type": "string"},
+    ...         {"name": "age", "type": "int"}
+    ...       ]
+    ...     }
+    ... '''
+    >>> deserializer = get_deserializer("AVRO", avro_schema)
+    >>>
+    >>> # Get a JSON deserializer
+    >>> json_deserializer = get_deserializer("JSON", None)
+    >>>
+    >>> # Get a no-op deserializer for raw data
+    >>> no_op_deserializer = get_deserializer("RAW", None)
+    """
+
+    # Generate a cache key based on schema type and value
+    cache_key = _get_cache_key(schema_type, schema_value)
+
+    # Check if we already have this deserializer in cache
+    if cache_key in _deserializer_cache:
+        return _deserializer_cache[cache_key]
+
+    deserializer: DeserializerBase
+
+    if schema_type == "AVRO":
+        # Import here to avoid dependency if not used
+        from aws_lambda_powertools.utilities.kafka.deserializer.avro import AvroDeserializer
+
+        deserializer = AvroDeserializer(schema_value)
+    elif schema_type == "PROTOBUF":
+        # Import here to avoid dependency if not used
+        from aws_lambda_powertools.utilities.kafka.deserializer.protobuf import ProtobufDeserializer
+
+        deserializer = ProtobufDeserializer(schema_value)
+    elif schema_type == "JSON":
+        deserializer = JsonDeserializer()
+
+    else:
+        # Default to no-op deserializer
+        deserializer = DefaultDeserializer()
+
+    # Store in cache for future use
+    _deserializer_cache[cache_key] = deserializer
+
+    # Default to default deserializer that is base64 decode + bytes decoded
+    return deserializer

aws_lambda_powertools/utilities/kafka/deserializer/json.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import base64
+import json
+
+from aws_lambda_powertools.utilities.kafka.deserializer.base import DeserializerBase
+from aws_lambda_powertools.utilities.kafka.exceptions import KafkaConsumerDeserializationError
+
+
+class JsonDeserializer(DeserializerBase):
+    """
+    Deserializer for JSON formatted data.
+
+    This class provides functionality to deserialize JSON data from bytes or string
+    into Python dictionaries.
+    """
+
+    def deserialize(self, data: bytes | str) -> dict:
+        """
+        Deserialize JSON data to a Python dictionary.
+
+        Parameters
+        ----------
+        data : bytes or str
+            The JSON data to deserialize. If provided as bytes, it will be decoded as UTF-8.
+            If provided as a string, it's assumed to be base64-encoded and will be decoded first.
+
+        Returns
+        -------
+        dict
+            Deserialized data as a dictionary.
+
+        Raises
+        ------
+        KafkaConsumerDeserializationError
+            When the data cannot be deserialized as valid JSON.
+
+        Examples
+        --------
+        >>> deserializer = JsonDeserializer()
+        >>> json_data = '{"key": "value", "number": 123}'
+        >>> try:
+        ...     result = deserializer.deserialize(json_data)
+        ...     print(result["key"])  # Output: value
+        ... except KafkaConsumerDeserializationError as e:
+        ...     print(f"Failed to deserialize: {e}")
+        """
+        try:
+            return json.loads(base64.b64decode(data).decode("utf-8"))
+        except Exception as e:
+            raise KafkaConsumerDeserializationError(
+                f"Error trying to deserialize json data -  {type(e).__name__}: {str(e)}",
+            ) from e

aws_lambda_powertools/utilities/kafka/deserializer/protobuf.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from typing import Any
+
+from google.protobuf.internal.decoder import _DecodeVarint  # type: ignore[attr-defined]
+from google.protobuf.json_format import MessageToDict
+
+from aws_lambda_powertools.utilities.kafka.deserializer.base import DeserializerBase
+from aws_lambda_powertools.utilities.kafka.exceptions import (
+    KafkaConsumerDeserializationError,
+)
+
+
+class ProtobufDeserializer(DeserializerBase):
+    """
+    Deserializer for Protocol Buffer formatted data.
+
+    This class provides functionality to deserialize Protocol Buffer binary data
+    into Python dictionaries using the provided Protocol Buffer message class.
+    """
+
+    def __init__(self, message_class: Any):
+        self.message_class = message_class
+
+    def deserialize(self, data: bytes | str) -> dict:
+        """
+        Deserialize Protocol Buffer binary data to a Python dictionary.
+
+        Parameters
+        ----------
+        data : bytes or str
+            The Protocol Buffer binary data to deserialize. If provided as a string,
+            it's assumed to be base64-encoded and will be decoded first.
+
+        Returns
+        -------
+        dict
+            Deserialized data as a dictionary with field names preserved from the
+            Protocol Buffer definition.
+
+        Raises
+        ------
+        KafkaConsumerDeserializationError
+            When the data cannot be deserialized according to the message class,
+            typically due to data format incompatibility or incorrect message class.
+
+        Notes
+        -----
+        This deserializer handles both standard Protocol Buffer format and the Confluent
+        Schema Registry format which includes message index information. It will first try
+        standard deserialization and fall back to message index handling if needed.
+
+        Example
+        --------
+        >>> # Assuming proper protobuf setup
+        >>> deserializer = ProtobufDeserializer(my_proto_module.MyMessage)
+        >>> proto_data = b'...'  # binary protobuf data
+        >>> try:
+        ...     result = deserializer.deserialize(proto_data)
+        ...     # Process the deserialized dictionary
+        ... except KafkaConsumerDeserializationError as e:
+        ...     print(f"Failed to deserialize: {e}")
+        """
+        value = self._decode_input(data)
+        try:
+            message = self.message_class()
+            message.ParseFromString(value)
+            return MessageToDict(message, preserving_proto_field_name=True)
+        except Exception:
+            return self._deserialize_with_message_index(value, self.message_class())
+
+    def _deserialize_with_message_index(self, data: bytes, parser: Any) -> dict:
+        """
+        Deserialize protobuf message with Confluent message index handling.
+
+        Parameters
+        ----------
+        data : bytes
+            data
+        parser : google.protobuf.message.Message
+            Protobuf message instance to parse the data into
+
+        Returns
+        -------
+        dict
+            Dictionary representation of the parsed protobuf message with original field names
+
+        Raises
+        ------
+        KafkaConsumerDeserializationError
+            If deserialization fails
+
+        Notes
+        -----
+        This method handles the special case of Confluent Schema Registry's message index
+        format, where the message is prefixed with either a single 0 (for the first schema)
+        or a list of schema indexes. The actual protobuf message follows these indexes.
+        """
+
+        buffer = memoryview(data)
+        pos = 0
+
+        try:
+            first_value, new_pos = _DecodeVarint(buffer, pos)
+            pos = new_pos
+
+            if first_value != 0:
+                for _ in range(first_value):
+                    _, new_pos = _DecodeVarint(buffer, pos)
+                    pos = new_pos
+
+            parser.ParseFromString(data[pos:])
+            return MessageToDict(parser, preserving_proto_field_name=True)
+        except Exception as e:
+            raise KafkaConsumerDeserializationError(
+                f"Error trying to deserialize protobuf data - {type(e).__name__}: {str(e)}",
+            ) from e

aws_lambda_powertools/utilities/kafka/exceptions.py

@@ -0,0 +1,22 @@
+class KafkaConsumerAvroSchemaParserError(Exception):
+    """
+    Error raised when parsing Avro schema definition fails.
+    """
+
+
+class KafkaConsumerDeserializationError(Exception):
+    """
+    Error raised when message deserialization fails.
+    """
+
+
+class KafkaConsumerMissingSchemaError(Exception):
+    """
+    Error raised when a required schema is not provided.
+    """
+
+
+class KafkaConsumerOutputSerializerError(Exception):
+    """
+    Error raised when output serializer fails.
+    """

aws_lambda_powertools/utilities/kafka/kafka_consumer.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from aws_lambda_powertools.middleware_factory import lambda_handler_decorator
+from aws_lambda_powertools.utilities.kafka.consumer_records import ConsumerRecords
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from aws_lambda_powertools.utilities.kafka.schema_config import SchemaConfig
+    from aws_lambda_powertools.utilities.typing import LambdaContext
+
+
+@lambda_handler_decorator
+def kafka_consumer(
+    handler: Callable[[Any, LambdaContext], Any],
+    event: dict[str, Any],
+    context: LambdaContext,
+    schema_config: SchemaConfig | None = None,
+):
+    """
+    Decorator for processing Kafka consumer records in AWS Lambda functions.
+
+    This decorator transforms the raw Lambda event into a ConsumerRecords object,
+    making it easier to process Kafka messages with optional schema validation
+    and deserialization.
+
+    Parameters
+    ----------
+    handler : Callable[[Any, LambdaContext], Any]
+        The Lambda handler function being decorated.
+    event : dict[str, Any]
+        The Lambda event containing Kafka records.
+    context : LambdaContext
+        The Lambda context object.
+    schema_config : SchemaConfig, optional
+        Schema configuration for deserializing Kafka records.
+        Must be an instance of SchemaConfig.
+
+    Returns
+    -------
+    Any
+        The return value from the handler function.
+
+    Examples
+    --------
+    >>> from aws_lambda_powertools.utilities.kafka import kafka_consumer, SchemaConfig
+    >>>
+    >>> # With schema validation using SchemaConfig
+    >>> schema_config = SchemaConfig(value_schema_type="JSON")
+    >>>
+    >>> @kafka_consumer(schema_config=schema_config)
+    >>> def handler_with_schema(records, context):
+    >>>     for record in records:
+    >>>         # record.value will be automatically deserialized according to schema_config
+    >>>         process_message(record.value)
+    >>>     return {"statusCode": 200}
+    """
+    return handler(ConsumerRecords(event, schema_config), context)

aws_lambda_powertools/utilities/kafka/schema_config.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from aws_lambda_powertools.utilities.kafka.exceptions import KafkaConsumerMissingSchemaError
+
+
+class SchemaConfig:
+    """
+    Configuration for schema management in Kafka consumers.
+
+    This class handles schema configuration for both keys and values in Kafka records,
+    supporting AVRO, PROTOBUF, and JSON schema types.
+
+    Parameters
+    ----------
+    value_schema_type : {'AVRO', 'PROTOBUF', 'JSON', None}, default=None
+        Schema type for message values.
+    value_schema : str, optional
+        Schema definition for message values. Required when value_schema_type is 'AVRO' or 'PROTOBUF'.
+    value_output_serializer : Any, optional
+        Custom output serializer for message values. Supports Pydantic classes, Dataclasses and Custom Class
+    key_schema_type : {'AVRO', 'PROTOBUF', 'JSON', None}, default=None
+        Schema type for message keys.
+    key_schema : str, optional
+        Schema definition for message keys. Required when key_schema_type is 'AVRO' or 'PROTOBUF'.
+    key_output_serializer : Any, optional
+        Custom serializer for message keys. Supports Pydantic classes, Dataclasses and Custom Class
+
+    Raises
+    ------
+    KafkaConsumerMissingSchemaError
+        When schema_type is set to 'AVRO' or 'PROTOBUF' but the corresponding schema
+        definition is not provided.
+
+    Examples
+    --------
+    >>> # Configure with AVRO schema for values
+    >>> avro_schema = '''
+    ... {
+    ...   "type": "record",
+    ...   "name": "User",
+    ...   "fields": [
+    ...     {"name": "name", "type": "string"},
+    ...     {"name": "age", "type": "int"}
+    ...   ]
+    ... }
+    ... '''
+    >>> config = SchemaConfig(value_schema_type="AVRO", value_schema=avro_schema)
+
+    >>> # Configure with JSON schema for both keys and values
+    >>> config = SchemaConfig(
+    ...     value_schema_type="JSON",
+    ...     key_schema_type="JSON"
+    ... )
+    """
+
+    def __init__(
+        self,
+        value_schema_type: Literal["AVRO", "PROTOBUF", "JSON"] | None = None,
+        value_schema: str | None = None,
+        value_output_serializer: Any | None = None,
+        key_schema_type: Literal["AVRO", "PROTOBUF", "JSON", None] | None = None,
+        key_schema: str | None = None,
+        key_output_serializer: Any | None = None,
+    ):
+        # Validate schema requirements
+        self._validate_schema_requirements(value_schema_type, value_schema, "value")
+        self._validate_schema_requirements(key_schema_type, key_schema, "key")
+
+        self.value_schema_type = value_schema_type
+        self.value_schema = value_schema
+        self.value_output_serializer = value_output_serializer
+        self.key_schema_type = key_schema_type
+        self.key_schema = key_schema
+        self.key_output_serializer = key_output_serializer
+
+    def _validate_schema_requirements(self, schema_type: str | None, schema: str | None, prefix: str) -> None:
+        """Validate that schema is provided when required by schema_type."""
+        if schema_type in ["AVRO", "PROTOBUF"] and schema is None:
+            raise KafkaConsumerMissingSchemaError(
+                f"{prefix}_schema must be provided when {prefix}_schema_type is {schema_type}",
+            )

aws_lambda_powertools/utilities/kafka/serialization/base.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from aws_lambda_powertools.utilities.kafka.serialization.types import T
+
+
+class OutputSerializerBase(ABC):
+    """
+    Abstract base class for output serializers.
+
+    This class defines the interface for serializers that transform dictionary data
+    into specific output formats or class instances.
+
+    Methods
+    -------
+    serialize(data, output)
+        Abstract method that must be implemented by subclasses to serialize data.
+
+    Examples
+    --------
+    >>> class MyOutputSerializer(OutputSerializerBase):
+    ...     def serialize(self, data: dict[str, Any], output=None):
+    ...         if output:
+    ...             # Convert dictionary to class instance
+    ...             return output(**data)
+    ...         return data  # Return as is if no output class provided
+    """
+
+    @abstractmethod
+    def serialize(self, data: dict[str, Any], output: type[T] | Callable | None = None) -> T | dict[str, Any]:
+        """
+        Serialize dictionary data into a specific output format or class instance.
+
+        This abstract method must be implemented by subclasses to provide
+        specific serialization logic.
+
+        Parameters
+        ----------
+        data : dict[str, Any]
+            The dictionary data to serialize.
+        output : type[T] or None, optional
+            Optional class type to convert the dictionary into. If provided,
+            the method should return an instance of this class.
+
+        Returns
+        -------
+        T or dict[str, Any]
+            An instance of output if provided, otherwise a processed dictionary.
+            The generic type T represents the type of the output.
+        """
+        raise NotImplementedError("Subclasses must implement this method")

aws_lambda_powertools/utilities/kafka/serialization/custom_dict.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from aws_lambda_powertools.utilities.kafka.serialization.base import OutputSerializerBase
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from aws_lambda_powertools.utilities.kafka.serialization.types import T
+
+
+class CustomDictOutputSerializer(OutputSerializerBase):
+    """
+    Serializer that allows custom dict transformations.
+
+    This serializer takes dictionary data and either returns it as-is or passes it
+    through a custom transformation function provided as the output parameter.
+    """
+
+    def serialize(self, data: dict[str, Any], output: type[T] | Callable | None = None) -> T | dict[str, Any]:
+        return data if output is None else output(data)  # type: ignore[call-arg]

aws_lambda_powertools/utilities/kafka/serialization/dataclass.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from dataclasses import is_dataclass
+from typing import TYPE_CHECKING, Any, cast
+
+from aws_lambda_powertools.utilities.kafka.serialization.base import OutputSerializerBase
+from aws_lambda_powertools.utilities.kafka.serialization.types import T
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class DataclassOutputSerializer(OutputSerializerBase):
+    """
+    Serializer that converts dictionary data into dataclass instances.
+
+    This serializer takes dictionary data and converts it into an instance of the specified
+    dataclass type.
+    """
+
+    def serialize(self, data: dict[str, Any], output: type[T] | Callable | None = None) -> T | dict[str, Any]:
+        if not is_dataclass(output):  # pragma: no cover
+            raise ValueError("Output class must be a dataclass")
+
+        return cast(T, output(**data))

aws_lambda_powertools/utilities/kafka/serialization/pydantic.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pydantic import TypeAdapter
+
+from aws_lambda_powertools.utilities.kafka.serialization.base import OutputSerializerBase
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from aws_lambda_powertools.utilities.kafka.serialization.types import T
+
+
+class PydanticOutputSerializer(OutputSerializerBase):
+    """
+    Serializer that converts dictionary data into Pydantic model instances.
+
+    This serializer takes dictionary data and validates/converts it into an instance
+    of the specified Pydantic model type using Pydantic's TypeAdapter.
+    """
+
+    def serialize(self, data: dict[str, Any], output: type[T] | Callable | None = None) -> T | dict[str, Any]:
+        # Use TypeAdapter for better support of Union types and other complex types
+        adapter: TypeAdapter = TypeAdapter(output)
+        return adapter.validate_python(data)

aws_lambda_powertools/utilities/kafka/serialization/serialization.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import is_dataclass
+from typing import TYPE_CHECKING, Annotated, Any, Optional, Union, get_args, get_origin
+
+# Conditionally import or define UnionType based on Python version
+if sys.version_info >= (3, 10):
+    from types import UnionType  # Available in Python 3.10+
+else:
+    UnionType = Union  # Fallback for Python 3.9
+
+from aws_lambda_powertools.utilities.kafka.serialization.custom_dict import CustomDictOutputSerializer
+from aws_lambda_powertools.utilities.kafka.serialization.dataclass import DataclassOutputSerializer
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from aws_lambda_powertools.utilities.kafka.serialization.types import T
+
+
+def _get_output_serializer(output: type[T] | Callable | None = None) -> Any:
+    """
+    Returns the appropriate serializer for the given output class.
+    Uses lazy imports to avoid unnecessary dependencies.
+    """
+    # Check if it's a dataclass
+    if is_dataclass(output):
+        return DataclassOutputSerializer()
+
+    if _is_pydantic_model(output):
+        from aws_lambda_powertools.utilities.kafka.serialization.pydantic import PydanticOutputSerializer
+
+        return PydanticOutputSerializer()
+
+    # Default to custom serializer
+    return CustomDictOutputSerializer()
+
+
+def _is_pydantic_model(obj: Any) -> bool:
+    if isinstance(obj, type):
+        # Check for Pydantic model attributes without direct import
+        has_model_fields = getattr(obj, "model_fields", None) is not None
+        has_model_validate = callable(getattr(obj, "model_validate", None))
+        return has_model_fields and has_model_validate
+
+    origin = get_origin(obj)
+    if origin in (Union, Optional, Annotated) or (sys.version_info >= (3, 10) and origin in (Union, UnionType)):
+        # Check if any element in the Union is a Pydantic model
+        for arg in get_args(obj):
+            if _is_pydantic_model(arg):
+                return True
+
+    return False
+
+
+def serialize_to_output_type(
+    data: object | dict[str, Any],
+    output: type[T] | Callable | None = None,
+) -> T | dict[str, Any]:
+    """
+    Helper function to directly serialize data to the specified output class
+    """
+    serializer = _get_output_serializer(output)
+    return serializer.serialize(data, output)

aws_lambda_powertools/utilities/kafka/serialization/types.py

@@ -0,0 +1,3 @@
+from typing import TypeVar
+
+T = TypeVar("T")

aws_lambda_powertools/utilities/parser/models/kafka.py

@@ -8,6 +8,11 @@ from aws_lambda_powertools.shared.functions import base64_decode, bytes_to_strin
 SERVERS_DELIMITER = ","
 
 
+class KafkaRecordSchemaMetadata(BaseModel):
+    dataFormat: str
+    schemaId: str
+
+
 class KafkaRecordModel(BaseModel):
     topic: str
     partition: int
@@ -17,6 +22,8 @@ class KafkaRecordModel(BaseModel):
     key: Optional[bytes] = None
     value: Union[str, Type[BaseModel]]
     headers: List[Dict[str, bytes]]
+    keySchemaMetadata: Optional[KafkaRecordSchemaMetadata] = None
+    valueSchemaMetadata: Optional[KafkaRecordSchemaMetadata] = None
 
     # key is optional; only decode if not None
     @field_validator("key", mode="before")

{aws_lambda_powertools-3.14.1a5.dist-info → aws_lambda_powertools-3.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aws_lambda_powertools
-Version: 3.14.1a5
+Version: 3.15.0
 Summary: Powertools for AWS Lambda (Python) is a developer toolkit to implement Serverless best practices and increase developer velocity.
 License: MIT
 Keywords: aws_lambda_powertools,aws,tracing,logging,lambda,powertools,feature_flags,idempotency,middleware
@@ -21,11 +21,14 @@ Provides-Extra: all
 Provides-Extra: aws-sdk
 Provides-Extra: datadog
 Provides-Extra: datamasking
+Provides-Extra: kafka-consumer-avro
+Provides-Extra: kafka-consumer-protobuf
 Provides-Extra: parser
 Provides-Extra: redis
 Provides-Extra: tracer
 Provides-Extra: validation
 Provides-Extra: valkey
+Requires-Dist: avro (>=1.12.0,<2.0.0) ; extra == "kafka-consumer-avro"
 Requires-Dist: aws-encryption-sdk (>=3.1.1,<5.0.0) ; extra == "all" or extra == "datamasking"
 Requires-Dist: aws-xray-sdk (>=2.8.0,<3.0.0) ; extra == "tracer" or extra == "all"
 Requires-Dist: boto3 (>=1.34.32,<2.0.0) ; extra == "aws-sdk"
@@ -33,6 +36,7 @@ Requires-Dist: datadog-lambda (>=6.106.0,<7.0.0) ; extra == "datadog"
 Requires-Dist: fastjsonschema (>=2.14.5,<3.0.0) ; extra == "validation" or extra == "all"
 Requires-Dist: jmespath (>=1.0.1,<2.0.0)
 Requires-Dist: jsonpath-ng (>=1.6.0,<2.0.0) ; extra == "all" or extra == "datamasking"
+Requires-Dist: protobuf (>=6.30.2,<7.0.0) ; extra == "kafka-consumer-protobuf"
 Requires-Dist: pydantic (>=2.4.0,<3.0.0) ; extra == "parser" or extra == "all"
 Requires-Dist: pydantic-settings (>=2.6.1,<3.0.0) ; extra == "all"
 Requires-Dist: redis (>=4.4,<7.0) ; extra == "redis"

{aws_lambda_powertools-3.14.1a5.dist-info → aws_lambda_powertools-3.15.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 aws_lambda_powertools/__init__.py,sha256=o4iEHU0MfWC0_TfVmisxi0VOAUw5uQfqLQWr0t29ZaE,676
 aws_lambda_powertools/event_handler/__init__.py,sha256=HWTBEIrd2Znes31qT9h8k9PEfmWwepWyh9bxed2ES-0,1275
-aws_lambda_powertools/event_handler/api_gateway.py,sha256=XD51QGNfdq8ihkCu7YX-OAa6-Ny2Mr2j_-SXwBfLa7g,121997
+aws_lambda_powertools/event_handler/api_gateway.py,sha256=LQfrqwXCze2sY8kaG2v4x67AE-c70ASJ5bxK19U6peU,122023
 aws_lambda_powertools/event_handler/appsync.py,sha256=MNUlaM-4Ioaejei4L5hoW_DuDgOkQWAtMmKZU_Jwce4,18530
 aws_lambda_powertools/event_handler/bedrock_agent.py,sha256=j3pKSDUmfb5MNcanqm78s9THh7bvh40LKKgnov95JcU,15146
 aws_lambda_powertools/event_handler/bedrock_agent_function.py,sha256=7EXeF-mOVAaFiw5Lu872NQVDexzPkgAFNj5nvE9KU4I,9441
@@ -98,7 +98,7 @@ aws_lambda_powertools/shared/json_encoder.py,sha256=JQeWNu-4M7_xI_hqYExrxsb3OcEH
 aws_lambda_powertools/shared/lazy_import.py,sha256=TbXQm2bcwXdZrYdBaJJXIswyLlumM85RJ_A_0w-h-GU,2019
 aws_lambda_powertools/shared/types.py,sha256=EZ_tbX3F98LA4Zcra1hTEjzRacpZAtggK957Zcv1oKg,135
 aws_lambda_powertools/shared/user_agent.py,sha256=DrCMFQuT4a4iIrpcWpAIjY37EFqR9-QxlxDGD-Nn9Gg,7081
-aws_lambda_powertools/shared/version.py,sha256=eUo_YT-BfCNDvETaiIO0Wo6WcgYqYOYZrB7U0r-a6H8,85
+aws_lambda_powertools/shared/version.py,sha256=and7WBc_Ox1Z0FcIGlQjGhuFeAT1WVEaKytTKGK0tuk,83
 aws_lambda_powertools/tracing/__init__.py,sha256=f4bMThOPBPWTPVcYqcAIErAJPerMsf3H_Z4gCXCsK9I,141
 aws_lambda_powertools/tracing/base.py,sha256=WSO986XGBOe9K0F2SnG6ustJokIrtO0m0mcL8N7mfno,4544
 aws_lambda_powertools/tracing/extensions.py,sha256=APOfXOq-hRBKaK5WyfIyrd_6M1_9SWJZ3zxLA9jDZzU,492
@@ -137,7 +137,7 @@ aws_lambda_powertools/utilities/data_classes/dynamo_db_stream_event.py,sha256=tK
 aws_lambda_powertools/utilities/data_classes/event_bridge_event.py,sha256=TeTtx2jOKyZSVdSPFrtxZUgv0Yt6HW_H7J5NNxy_mHo,2434
 aws_lambda_powertools/utilities/data_classes/event_source.py,sha256=CKo1_TY0UcUVsh3PUk39z2WFVC2Bf4QgXWj93eEHbcY,1211
 aws_lambda_powertools/utilities/data_classes/iot_registry_event.py,sha256=wUa0Gr64maNGkd9qKNxtwFHawIJN-nj9X8uLFdINE7c,10842
-aws_lambda_powertools/utilities/data_classes/kafka_event.py,sha256=21K9iSH0sv_oj7alGWcommPUNDfto-tovIHspdIdsH4,4119
+aws_lambda_powertools/utilities/data_classes/kafka_event.py,sha256=kjTfsvOpiAtY1le4sb55VxsPqmjLedxqk7ruMc3SxfI,5171
 aws_lambda_powertools/utilities/data_classes/kinesis_firehose_event.py,sha256=5H-Rt6LG80_jVkTlWxhutZH0cv4Xrhzm-fqwkpjPfQM,10508
 aws_lambda_powertools/utilities/data_classes/kinesis_stream_event.py,sha256=QVDKkcXQRp6T0KfjoZXkr_2U__5w9IT096jZqaoa4hI,5022
 aws_lambda_powertools/utilities/data_classes/lambda_function_url_event.py,sha256=dFhL3IYebW4WeJc1XJJYmF94gI_qYeay6EpT9b2mDZU,633
@@ -190,6 +190,25 @@ aws_lambda_powertools/utilities/idempotency/serialization/no_op.py,sha256=9m5-EG
 aws_lambda_powertools/utilities/idempotency/serialization/pydantic.py,sha256=NVKiKk87d_8BgcYpyxHJVRnRaDVCA6PP28SG3J0GGKg,1471
 aws_lambda_powertools/utilities/jmespath_utils/__init__.py,sha256=Br89UButW4sLv2Dkjz_MiPS0TpMEPOO-W4wW0n9quPc,3597
 aws_lambda_powertools/utilities/jmespath_utils/envelopes.py,sha256=jZJYbUldrZgCWl-PL8oRmC9p6G6D-3812kJmJfLkM6Q,817
+aws_lambda_powertools/utilities/kafka/__init__.py,sha256=PUx4xgcL7td8fSfumD6INCdmGGIy7E11eqHk0w4XiEU,320
+aws_lambda_powertools/utilities/kafka/consumer_records.py,sha256=1S6mRcKeqPQtiRyDJIL308TQ9dEMdv13JdBFCwRVVmo,4825
+aws_lambda_powertools/utilities/kafka/deserializer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aws_lambda_powertools/utilities/kafka/deserializer/avro.py,sha256=G2pr5GLOsurhRCcMNCpd1VFcIh79LSYWDqg4_qVN0-g,2401
+aws_lambda_powertools/utilities/kafka/deserializer/base.py,sha256=-bOPbZADsKK-HuQupZy54csY74rvIXVIQiFxGHxjTww,1549
+aws_lambda_powertools/utilities/kafka/deserializer/default.py,sha256=GhAUfZO3rcasy_ZiKEv3IOFX_VNDTA61zb2eo0HAIcQ,1416
+aws_lambda_powertools/utilities/kafka/deserializer/deserializer.py,sha256=Wh4-srDUFGBUZ0kXiiU-R8DznumOKdLPk9Va88LT7zE,3733
+aws_lambda_powertools/utilities/kafka/deserializer/json.py,sha256=2_helv8DyUoK60z3wflLd1BwkuRINaVjucyYie10qUM,1742
+aws_lambda_powertools/utilities/kafka/deserializer/protobuf.py,sha256=WEaJysV__sZy32HNpqZZ6KrZyxyvsEnxf24On36zeXY,4183
+aws_lambda_powertools/utilities/kafka/exceptions.py,sha256=kwNfAcYmiTgk19QEdN6oHtMc2dDIZh64uWr_d5X3FFc,495
+aws_lambda_powertools/utilities/kafka/kafka_consumer.py,sha256=x1RcOWJcG74JvzrahO4cSSrAuSZFUlMtg14QjAjtJjY,2069
+aws_lambda_powertools/utilities/kafka/schema_config.py,sha256=GaSiwKWiUEQqrdBZWMaGl_DQcqpyplohoCMgMrCOyGI,3268
+aws_lambda_powertools/utilities/kafka/serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aws_lambda_powertools/utilities/kafka/serialization/base.py,sha256=z3Z_CbmBbrKDfzZjyvWkhdhnmgpR4CznefweATh-0_8,1904
+aws_lambda_powertools/utilities/kafka/serialization/custom_dict.py,sha256=ZEIiPy9HxdImeCh0ljzWPFw93SD1ktsJpIKqD2_uzfg,789
+aws_lambda_powertools/utilities/kafka/serialization/dataclass.py,sha256=uWqi8K0Hcn-ET-RcJwwn4HyOCtu_Oq6oTZxXtIW8xBE,871
+aws_lambda_powertools/utilities/kafka/serialization/pydantic.py,sha256=2Uuv6b20bsYVOY5gl8tcVHVVi3krCquEzPVuzsO5LeE,933
+aws_lambda_powertools/utilities/kafka/serialization/serialization.py,sha256=XqLLZcHFea0jhtznNrrZeK5vW1arEBu8a0jwziJC-jY,2312
+aws_lambda_powertools/utilities/kafka/serialization/types.py,sha256=zClRo5ve8RGia7wQnby41W-Zprj-slOA5da1LfYnuhw,45
 aws_lambda_powertools/utilities/parameters/__init__.py,sha256=KVJWu7pyunw9to8VkTZ0fy6MCR9iW0tUCjAJVqgdwdw,771
 aws_lambda_powertools/utilities/parameters/appconfig.py,sha256=CqFVXUKMjKsGX0eUClPxQNlLdPTJbbYOTU_7Vz8b8TY,8363
 aws_lambda_powertools/utilities/parameters/base.py,sha256=kTzLaVcp64mM6CwfP3Tz4kkMFvUwLexg9DVJ1zkFUtw,12743
@@ -231,7 +250,7 @@ aws_lambda_powertools/utilities/parser/models/cloudwatch.py,sha256=1y2WmgBbIo6Gk
 aws_lambda_powertools/utilities/parser/models/dynamodb.py,sha256=ktjvd5L7LLvitgi1yPFbtc_TK8J_3yzqIHmaZ4UfTt8,2197
 aws_lambda_powertools/utilities/parser/models/event_bridge.py,sha256=Fanggwc7Ug_YTzFGl1utSRn7fjxILNR_GnkrNG9IQ88,941
 aws_lambda_powertools/utilities/parser/models/iot_registry_events.py,sha256=hnuCxt9jYri_MRI9Z-n7aknA2CcBIHkPD__G9jSQEZ4,5448
-aws_lambda_powertools/utilities/parser/models/kafka.py,sha256=JbnuSOX9D_IqUjvxvajsIJT4uw8adD_EOkEJx8mhkws,1919
+aws_lambda_powertools/utilities/parser/models/kafka.py,sha256=vd214aPiGW434yFdpZCBpTnPCrJ4_IyXHK8kifhxEI0,2137
 aws_lambda_powertools/utilities/parser/models/kinesis.py,sha256=-8zJh1GJd69QCo0tGQkg7SEqbcWJCbwmeSb1Rx8Jt40,1790
 aws_lambda_powertools/utilities/parser/models/kinesis_firehose.py,sha256=K1MbkoX9yZjMcZOJ7H7nek3OgVoBAjtqorKlcoWRlQ8,939
 aws_lambda_powertools/utilities/parser/models/kinesis_firehose_sqs.py,sha256=VTXGKlo0aBpi8njpOOiTaNFncl0_vRRWmiI7Z6ngKPI,875
@@ -271,7 +290,7 @@ aws_lambda_powertools/utilities/validation/envelopes.py,sha256=YD5HOFx6IClQgii0n
 aws_lambda_powertools/utilities/validation/exceptions.py,sha256=PKy_19zQMBJGCMMFl-sMkcm-cc0v3zZBn_bhGE4wKNo,2084
 aws_lambda_powertools/utilities/validation/validator.py,sha256=khCqFhACSdn0nKyYRRPiC5Exht956hTfSfhlV3IRmpg,10099
 aws_lambda_powertools/warnings/__init__.py,sha256=vqDVeZz8wGtD8WGYNSkQE7AHwqtIrPGRxuoJR_BBnSs,1193
-aws_lambda_powertools-3.14.1a5.dist-info/LICENSE,sha256=vMHS2eBgmwPUIMPb7LQ4p7ib_FPVQXarVjAasflrTwo,951
-aws_lambda_powertools-3.14.1a5.dist-info/METADATA,sha256=TYPPhrkGsCqiCw_aIAbfQXQdf7NpV0umhSPTESQUaIw,11304
-aws_lambda_powertools-3.14.1a5.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-aws_lambda_powertools-3.14.1a5.dist-info/RECORD,,
+aws_lambda_powertools-3.15.0.dist-info/LICENSE,sha256=vMHS2eBgmwPUIMPb7LQ4p7ib_FPVQXarVjAasflrTwo,951
+aws_lambda_powertools-3.15.0.dist-info/METADATA,sha256=10eOohXPQlEeOM8QpLP-2ZyvAuukPgXLD5JJgtY-PI0,11528
+aws_lambda_powertools-3.15.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+aws_lambda_powertools-3.15.0.dist-info/RECORD,,