fix: reading improvements

Author: rubenfonseca

aws_lambda_powertools/utilities/idempotency/exceptions.py

@@ -75,7 +75,7 @@ class IdempotencyKeyError(BaseError):
 
 class IdempotencyModelTypeError(BaseError):
     """
-    Model type does not match expected type
+    Model type does not match expected payload output
     """
 
 

aws_lambda_powertools/utilities/idempotency/idempotency.py

@@ -4,7 +4,6 @@
 import functools
 import logging
 import os
-from inspect import isclass
 from typing import Any, Callable, Dict, Optional, Type, Union, cast
 
 from aws_lambda_powertools.middleware_factory import lambda_handler_decorator
@@ -108,8 +107,8 @@ def idempotent_function(
     output_serializer: Optional[Union[BaseIdempotencySerializer, Type[BaseIdempotencyModelSerializer]]]
             Serializer to transform the data to and from a dictionary.
             If not supplied, no serialization is done via the NoOpSerializer.
-            In case a serializer of type inheriting BaseIdempotencyModelSerializer] is given,
-            the serializer is deduced from the function return type.
+            In case a serializer of type inheriting BaseIdempotencyModelSerializer is given,
+            the serializer is derived from the function return type.
     Examples
     --------
     **Processes an order in an idempotent manner**
@@ -137,7 +136,8 @@ def process_order(customer_id: str, order: dict, **kwargs):
                 output_serializer=output_serializer,
             ),
         )
-    if isclass(output_serializer) and issubclass(output_serializer, BaseIdempotencyModelSerializer):
+
+    if issubclass(output_serializer, BaseIdempotencyModelSerializer):
         # instantiate an instance of the serializer class
         output_serializer = output_serializer.instantiate(function.__annotations__.get("return", None))
 

aws_lambda_powertools/utilities/idempotency/serialization/base.py

@@ -28,10 +28,10 @@ class BaseIdempotencyModelSerializer(BaseIdempotencySerializer):
     @abstractmethod
     def instantiate(cls, model_type: Any) -> BaseIdempotencySerializer:
         """
-        Instantiate the serializer from the given model type.
-        In case there is the model_type is unknown, None will be sent to the method.
+        Creates an instance of a serializer based on a provided model type.
+        In case the model_type is unknown, None will be sent as `model_type`.
         It's on the implementer to verify that:
-        - None is handled
+        - None is handled correctly
         - A model type not matching the expected types is handled
 
         Parameters

aws_lambda_powertools/utilities/idempotency/serialization/dataclass.py

@@ -14,12 +14,16 @@
 
 
 class DataclassSerializer(BaseIdempotencyModelSerializer):
+    """
+    A serializer class for transforming data between dataclass objects and dictionaries.
+    """
+
     def __init__(self, model: Type[DataClass]):
         """
         Parameters
         ----------
-        model: Model
-            A Pydantic model of the type to transform
+        model: Type[DataClass]
+            A dataclass type to be used for serialization and deserialization
         """
         self.__model: Type[DataClass] = model
 

aws_lambda_powertools/utilities/idempotency/serialization/pydantic.py

@@ -11,26 +11,26 @@
     BaseIdempotencySerializer,
 )
 
-Model = BaseModel
-
 
 class PydanticSerializer(BaseIdempotencyModelSerializer):
-    def __init__(self, model: Type[Model]):
+    """Pydantic serializer for idempotency models"""
+
+    def __init__(self, model: Type[BaseModel]):
         """
         Parameters
         ----------
         model: Model
-            A Pydantic model of the type to transform
+            Pydantic model to be used for serialization
         """
-        self.__model: Type[Model] = model
+        self.__model: Type[BaseModel] = model
 
-    def to_dict(self, data: Model) -> Dict:
+    def to_dict(self, data: BaseModel) -> Dict:
         if callable(getattr(data, "model_dump", None)):
             # Support for pydantic V2
             return data.model_dump()  # type: ignore[unused-ignore,attr-defined]
         return data.dict()
 
-    def from_dict(self, data: Dict) -> Model:
+    def from_dict(self, data: Dict) -> BaseModel:
         if callable(getattr(self.__model, "model_validate", None)):
             # Support for pydantic V2
             return self.__model.model_validate(data)  # type: ignore[unused-ignore,attr-defined]