aws-lambda-powertools 3.15.0__py3-none-any.whl → 3.15.1__py3-none-any.whl

aws_lambda_powertools/shared/version.py

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

aws_lambda_powertools/utilities/kafka/consumer_records.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
@@ -13,6 +14,8 @@ if TYPE_CHECKING:
 
     from aws_lambda_powertools.utilities.kafka.schema_config import SchemaConfig
 
+logger = logging.getLogger(__name__)
+
 
 class ConsumerRecordRecords(KafkaEventRecordBase):
     """
@@ -31,18 +34,24 @@ class ConsumerRecordRecords(KafkaEventRecordBase):
         if not key:
             return None
 
+        logger.debug("Deserializing key field")
+
         # Determine schema type and schema string
         schema_type = None
-        schema_str = None
+        schema_value = 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
+            schema_value = 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)
+        deserializer = get_deserializer(
+            schema_type=schema_type,
+            schema_value=schema_value,
+            field_metadata=self.key_schema_metadata,
+        )
         deserialized_value = deserializer.deserialize(key)
 
         # Apply output serializer if specified
@@ -57,16 +66,22 @@ class ConsumerRecordRecords(KafkaEventRecordBase):
 
         # Determine schema type and schema string
         schema_type = None
-        schema_str = None
+        schema_value = None
         output_serializer = None
 
+        logger.debug("Deserializing value field")
+
         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
+            schema_value = 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)
+        deserializer = get_deserializer(
+            schema_type=schema_type,
+            schema_value=schema_value,
+            field_metadata=self.value_schema_metadata,
+        )
         deserialized_value = deserializer.deserialize(value)
 
         # Apply output serializer if specified

aws_lambda_powertools/utilities/kafka/deserializer/avro.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import io
+import logging
+from typing import Any
 
 from avro.io import BinaryDecoder, DatumReader
 from avro.schema import parse as parse_schema
@@ -9,8 +11,11 @@ from aws_lambda_powertools.utilities.kafka.deserializer.base import Deserializer
 from aws_lambda_powertools.utilities.kafka.exceptions import (
     KafkaConsumerAvroSchemaParserError,
     KafkaConsumerDeserializationError,
+    KafkaConsumerDeserializationFormatMismatch,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class AvroDeserializer(DeserializerBase):
     """
@@ -20,10 +25,11 @@ class AvroDeserializer(DeserializerBase):
     a provided Avro schema definition.
     """
 
-    def __init__(self, schema_str: str):
+    def __init__(self, schema_str: str, field_metadata: dict[str, Any] | None = None):
         try:
             self.parsed_schema = parse_schema(schema_str)
             self.reader = DatumReader(self.parsed_schema)
+            self.field_metatada = field_metadata
         except Exception as e:
             raise KafkaConsumerAvroSchemaParserError(
                 f"Invalid Avro schema. Please ensure the provided avro schema is valid: {type(e).__name__}: {str(e)}",
@@ -60,6 +66,13 @@ class AvroDeserializer(DeserializerBase):
         ... except KafkaConsumerDeserializationError as e:
         ...     print(f"Failed to deserialize: {e}")
         """
+        data_format = self.field_metatada.get("dataFormat") if self.field_metatada else None
+
+        if data_format and data_format != "AVRO":
+            raise KafkaConsumerDeserializationFormatMismatch(f"Expected data is AVRO but you sent {data_format}")
+
+        logger.debug("Deserializing data with AVRO format")
+
         try:
             value = self._decode_input(data)
             bytes_reader = io.BytesIO(value)

aws_lambda_powertools/utilities/kafka/deserializer/default.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import base64
+import logging
 
 from aws_lambda_powertools.utilities.kafka.deserializer.base import DeserializerBase
 
+logger = logging.getLogger(__name__)
+
 
 class DefaultDeserializer(DeserializerBase):
     """
@@ -43,4 +46,5 @@ class DefaultDeserializer(DeserializerBase):
         >>> result = deserializer.deserialize(bytes_data)
         >>> print(result == bytes_data)  # Output: True
         """
+        logger.debug("Deserializing data with primitives types")
         return base64.b64decode(data).decode("utf-8")

aws_lambda_powertools/utilities/kafka/deserializer/deserializer.py

@@ -13,21 +13,27 @@ if TYPE_CHECKING:
 _deserializer_cache: dict[str, DeserializerBase] = {}
 
 
-def _get_cache_key(schema_type: str | object, schema_value: Any) -> str:
+def _get_cache_key(schema_type: str | object, schema_value: Any, field_metadata: dict[str, Any]) -> str:
+    schema_metadata = None
+
+    if field_metadata:
+        schema_metadata = field_metadata.get("schemaId")
+
     if schema_value is None:
-        return str(schema_type)
+        schema_hash = f"{str(schema_type)}_{schema_metadata}"
 
     if isinstance(schema_value, str):
+        hashable_value = f"{schema_value}_{schema_metadata}"
         # For string schemas like Avro, hash the content
-        schema_hash = hashlib.md5(schema_value.encode("utf-8"), usedforsecurity=False).hexdigest()
+        schema_hash = hashlib.md5(hashable_value.encode("utf-8"), usedforsecurity=False).hexdigest()
     else:
         # For objects like Protobuf, use the object id
-        schema_hash = str(id(schema_value))
+        schema_hash = f"{str(id(schema_value))}_{schema_metadata}"
 
     return f"{schema_type}_{schema_hash}"
 
 
-def get_deserializer(schema_type: str | object, schema_value: Any) -> DeserializerBase:
+def get_deserializer(schema_type: str | object, schema_value: Any, field_metadata: Any) -> DeserializerBase:
     """
     Factory function to get the appropriate deserializer based on schema type.
 
@@ -75,7 +81,7 @@ def get_deserializer(schema_type: str | object, schema_value: Any) -> Deserializ
     """
 
     # Generate a cache key based on schema type and value
-    cache_key = _get_cache_key(schema_type, schema_value)
+    cache_key = _get_cache_key(schema_type, schema_value, field_metadata)
 
     # Check if we already have this deserializer in cache
     if cache_key in _deserializer_cache:
@@ -87,14 +93,14 @@ def get_deserializer(schema_type: str | object, schema_value: Any) -> Deserializ
         # Import here to avoid dependency if not used
         from aws_lambda_powertools.utilities.kafka.deserializer.avro import AvroDeserializer
 
-        deserializer = AvroDeserializer(schema_value)
+        deserializer = AvroDeserializer(schema_str=schema_value, field_metadata=field_metadata)
     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)
+        deserializer = ProtobufDeserializer(message_class=schema_value, field_metadata=field_metadata)
     elif schema_type == "JSON":
-        deserializer = JsonDeserializer()
+        deserializer = JsonDeserializer(field_metadata=field_metadata)
 
     else:
         # Default to no-op deserializer

aws_lambda_powertools/utilities/kafka/deserializer/json.py

@@ -2,9 +2,16 @@ from __future__ import annotations
 
 import base64
 import json
+import logging
+from typing import Any
 
 from aws_lambda_powertools.utilities.kafka.deserializer.base import DeserializerBase
-from aws_lambda_powertools.utilities.kafka.exceptions import KafkaConsumerDeserializationError
+from aws_lambda_powertools.utilities.kafka.exceptions import (
+    KafkaConsumerDeserializationError,
+    KafkaConsumerDeserializationFormatMismatch,
+)
+
+logger = logging.getLogger(__name__)
 
 
 class JsonDeserializer(DeserializerBase):
@@ -15,6 +22,9 @@ class JsonDeserializer(DeserializerBase):
     into Python dictionaries.
     """
 
+    def __init__(self, field_metadata: dict[str, Any] | None = None):
+        self.field_metatada = field_metadata
+
     def deserialize(self, data: bytes | str) -> dict:
         """
         Deserialize JSON data to a Python dictionary.
@@ -45,6 +55,14 @@ class JsonDeserializer(DeserializerBase):
         ... except KafkaConsumerDeserializationError as e:
         ...     print(f"Failed to deserialize: {e}")
         """
+
+        data_format = self.field_metatada.get("dataFormat") if self.field_metatada else None
+
+        if data_format and data_format != "JSON":
+            raise KafkaConsumerDeserializationFormatMismatch(f"Expected data is JSON but you sent {data_format}")
+
+        logger.debug("Deserializing data with JSON format")
+
         try:
             return json.loads(base64.b64decode(data).decode("utf-8"))
         except Exception as e:

aws_lambda_powertools/utilities/kafka/deserializer/protobuf.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
 
+import logging
 from typing import Any
 
-from google.protobuf.internal.decoder import _DecodeVarint  # type: ignore[attr-defined]
+from google.protobuf.internal.decoder import _DecodeSignedVarint  # 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,
+    KafkaConsumerDeserializationFormatMismatch,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class ProtobufDeserializer(DeserializerBase):
     """
@@ -19,8 +23,9 @@ class ProtobufDeserializer(DeserializerBase):
     into Python dictionaries using the provided Protocol Buffer message class.
     """
 
-    def __init__(self, message_class: Any):
+    def __init__(self, message_class: Any, field_metadata: dict[str, Any] | None = None):
         self.message_class = message_class
+        self.field_metatada = field_metadata
 
     def deserialize(self, data: bytes | str) -> dict:
         """
@@ -61,57 +66,56 @@ class ProtobufDeserializer(DeserializerBase):
         ... 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.
+        data_format = self.field_metatada.get("dataFormat") if self.field_metatada else None
+        schema_id = self.field_metatada.get("schemaId") if self.field_metatada else None
 
-        Parameters
-        ----------
-        data : bytes
-            data
-        parser : google.protobuf.message.Message
-            Protobuf message instance to parse the data into
+        if data_format and data_format != "PROTOBUF":
+            raise KafkaConsumerDeserializationFormatMismatch(f"Expected data is PROTOBUF but you sent {data_format}")
 
-        Returns
-        -------
-        dict
-            Dictionary representation of the parsed protobuf message with original field names
+        logger.debug("Deserializing data with PROTOBUF format")
 
-        Raises
-        ------
-        KafkaConsumerDeserializationError
-            If deserialization fails
+        try:
+            value = self._decode_input(data)
+            message = self.message_class()
+            if schema_id is None:
+                logger.debug("Plain PROTOBUF data: using default deserializer")
+                # Plain protobuf - direct parser
+                message.ParseFromString(value)
+            elif len(schema_id) > 20:
+                logger.debug("PROTOBUF data integrated with Glue SchemaRegistry: using Glue deserializer")
+                # Glue schema registry integration - remove the first byte
+                message.ParseFromString(value[1:])
+            else:
+                logger.debug("PROTOBUF data integrated with Confluent SchemaRegistry: using Confluent deserializer")
+                # Confluent schema registry integration - remove message index list
+                message.ParseFromString(self._remove_message_index(value))
 
-        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.
-        """
+            return MessageToDict(message, 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
 
+    def _remove_message_index(self, data):
+        """
+        Identifies and removes Confluent Schema Registry MessageIndex from bytes.
+        Returns pure protobuf bytes.
+        """
         buffer = memoryview(data)
         pos = 0
 
-        try:
-            first_value, new_pos = _DecodeVarint(buffer, pos)
-            pos = new_pos
+        logger.debug("Removing message list bytes")
 
-            if first_value != 0:
-                for _ in range(first_value):
-                    _, new_pos = _DecodeVarint(buffer, pos)
-                    pos = new_pos
+        # Read first varint (index count or 0)
+        first_value, new_pos = _DecodeSignedVarint(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
+        # Skip index values if present
+        if first_value != 0:
+            for _ in range(first_value):
+                _, new_pos = _DecodeSignedVarint(buffer, pos)
+                pos = new_pos
+
+        # Return remaining bytes (pure protobuf)
+        return data[pos:]

aws_lambda_powertools/utilities/kafka/exceptions.py

@@ -4,6 +4,12 @@ class KafkaConsumerAvroSchemaParserError(Exception):
     """
 
 
+class KafkaConsumerDeserializationFormatMismatch(Exception):
+    """
+    Error raised when deserialization format is incompatible
+    """
+
+
 class KafkaConsumerDeserializationError(Exception):
     """
     Error raised when message deserialization fails.

aws_lambda_powertools/utilities/kafka/serialization/custom_dict.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING, Any
 
 from aws_lambda_powertools.utilities.kafka.serialization.base import OutputSerializerBase
@@ -9,6 +10,8 @@ if TYPE_CHECKING:
 
     from aws_lambda_powertools.utilities.kafka.serialization.types import T
 
+logger = logging.getLogger(__name__)
+
 
 class CustomDictOutputSerializer(OutputSerializerBase):
     """
@@ -19,4 +22,5 @@ class CustomDictOutputSerializer(OutputSerializerBase):
     """
 
     def serialize(self, data: dict[str, Any], output: type[T] | Callable | None = None) -> T | dict[str, Any]:
+        logger.debug("Serializing output data with CustomDictOutputSerializer")
         return data if output is None else output(data)  # type: ignore[call-arg]

aws_lambda_powertools/utilities/kafka/serialization/dataclass.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from dataclasses import is_dataclass
 from typing import TYPE_CHECKING, Any, cast
 
@@ -9,6 +10,8 @@ from aws_lambda_powertools.utilities.kafka.serialization.types import T
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+logger = logging.getLogger(__name__)
+
 
 class DataclassOutputSerializer(OutputSerializerBase):
     """
@@ -22,4 +25,6 @@ class DataclassOutputSerializer(OutputSerializerBase):
         if not is_dataclass(output):  # pragma: no cover
             raise ValueError("Output class must be a dataclass")
 
+        logger.debug("Serializing output data with DataclassOutputSerializer")
+
         return cast(T, output(**data))

aws_lambda_powertools/utilities/kafka/serialization/pydantic.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING, Any
 
 from pydantic import TypeAdapter
@@ -11,6 +12,8 @@ if TYPE_CHECKING:
 
     from aws_lambda_powertools.utilities.kafka.serialization.types import T
 
+logger = logging.getLogger(__name__)
+
 
 class PydanticOutputSerializer(OutputSerializerBase):
     """
@@ -21,6 +24,7 @@ class PydanticOutputSerializer(OutputSerializerBase):
     """
 
     def serialize(self, data: dict[str, Any], output: type[T] | Callable | None = None) -> T | dict[str, Any]:
+        logger.debug("Serializing output data with PydanticOutputSerializer")
         # Use TypeAdapter for better support of Union types and other complex types
         adapter: TypeAdapter = TypeAdapter(output)
         return adapter.validate_python(data)

{aws_lambda_powertools-3.15.0.dist-info → aws_lambda_powertools-3.15.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aws_lambda_powertools
-Version: 3.15.0
+Version: 3.15.1
 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

{aws_lambda_powertools-3.15.0.dist-info → aws_lambda_powertools-3.15.1.dist-info}/RECORD

@@ -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=and7WBc_Ox1Z0FcIGlQjGhuFeAT1WVEaKytTKGK0tuk,83
+aws_lambda_powertools/shared/version.py,sha256=6rtvj2LhPP0CTjGnsLub8sUdIv49vsogeMeVJfp1Wnw,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
@@ -191,22 +191,22 @@ aws_lambda_powertools/utilities/idempotency/serialization/pydantic.py,sha256=NVK
 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/consumer_records.py,sha256=9v6lHETHJp5tnVcUfkI5qxlBIcij4LIp1idddklucOc,5218
 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/avro.py,sha256=YeRrnY55tw9CM2yZnmQgt6gj1AueSAlcWd6PM4ND0ps,2940
 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/deserializer/default.py,sha256=oFg7ZEQtyI-M4HfswOmqT_qPnmLKCxL3gF5mRogcxkI,1534
+aws_lambda_powertools/utilities/kafka/deserializer/deserializer.py,sha256=c82bDMwqFfMgIMGpryoruCSWluQiLV2roLP1fy-qAuU,4143
+aws_lambda_powertools/utilities/kafka/deserializer/json.py,sha256=La4BcF03-2PWWfL5kejPn3F7WD7oq80bSsYtyN_bu98,2312
+aws_lambda_powertools/utilities/kafka/deserializer/protobuf.py,sha256=yYOJ3ZhR5XaxHO25XaPllrOFgIyDfNHfc2prgAFxcNU,4763
+aws_lambda_powertools/utilities/kafka/exceptions.py,sha256=Lwsl8iR8A-DlleJ28OzZ7tkeUGQMd7P69hYW_ioEtqY,635
 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/custom_dict.py,sha256=RlYO6Ca6VddIeQ77KIi2Y7uj9drBvMutUm-VUuYv0ww,922
+aws_lambda_powertools/utilities/kafka/serialization/dataclass.py,sha256=KOsrKIQs-6smn1CmbOPzBRIydabWn42VkB3_sER46pE,1004
+aws_lambda_powertools/utilities/kafka/serialization/pydantic.py,sha256=BTP11dAfzCre01rQBYBLI9kn1-FjxdZGRRLhapklQUI,1064
 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
@@ -290,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.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,,
+aws_lambda_powertools-3.15.1.dist-info/LICENSE,sha256=vMHS2eBgmwPUIMPb7LQ4p7ib_FPVQXarVjAasflrTwo,951
+aws_lambda_powertools-3.15.1.dist-info/METADATA,sha256=lMRG2jtXHeR08xxirRjwbDG4kQlb40Z01pqWvSEFAks,11528
+aws_lambda_powertools-3.15.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+aws_lambda_powertools-3.15.1.dist-info/RECORD,,