Changing highlights + import

Author: leandrodamascena

docs/utilities/parser.md

@@ -1,25 +1,30 @@
 import json
-from typing import Any, Dict, Optional, TypeVar, Union
-from aws_lambda_powertools.utilities.parser import BaseEnvelope, BaseModel
+from typing import Any, Dict, Optional, Type, TypeVar, Union
+
+from pydantic import BaseModel
+
+from aws_lambda_powertools.utilities.parser import BaseEnvelope, event_parser
 from aws_lambda_powertools.utilities.parser.models import EventBridgeModel
-from aws_lambda_powertools.utilities.parser import event_parser
 from aws_lambda_powertools.utilities.typing import LambdaContext
 
 Model = TypeVar("Model", bound=BaseModel)
 
+
 class EventBridgeEnvelope(BaseEnvelope):
-    def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: type[Model]) -> Optional[Model]:
+    def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model]) -> Optional[Model]:
         if data is None:
             return None
 
-        parsed_envelope = EventBridgeModel.parse_obj(data)
+        parsed_envelope = EventBridgeModel.model_validate(data)
         return self._parse(data=parsed_envelope.detail, model=model)
 
+
 class OrderDetail(BaseModel):
     order_id: str
     amount: float
     customer_id: str
 
+
 @event_parser(model=OrderDetail, envelope=EventBridgeEnvelope)
 def lambda_handler(event: OrderDetail, context: LambdaContext):
     try:
@@ -32,16 +37,15 @@ def lambda_handler(event: OrderDetail, context: LambdaContext):
 
         return {
             "statusCode": 200,
-            "body": json.dumps({
-                "message": f"Order {event.order_id} processed successfully",
-                "order_id": event.order_id,
-                "amount": event.amount,
-                "customer_id": event.customer_id
-            })
+            "body": json.dumps(
+                {
+                    "message": f"Order {event.order_id} processed successfully",
+                    "order_id": event.order_id,
+                    "amount": event.amount,
+                    "customer_id": event.customer_id,
+                },
+            ),
         }
     except Exception as e:
         print(f"Error processing order: {str(e)}")
-        return {
-            "statusCode": 500,
-            "body": json.dumps({"error": "Internal server error"})
-        }
+        return {"statusCode": 500, "body": json.dumps({"error": "Internal server error"})}

examples/parser/src/bring_your_own_envelope.py

@@ -1,23 +1,21 @@
-from aws_lambda_powertools.utilities.parser import BaseModel, parse, Field, ValidationError
+from pydantic import Field, ValidationError
+
+from aws_lambda_powertools.utilities.parser import parse
 from aws_lambda_powertools.utilities.parser.models import EventBridgeModel
 
+
 # Define a custom EventBridge model by extending the built-in EventBridgeModel
 class MyCustomEventBridgeModel(EventBridgeModel):
     detail_type: str = Field(alias="detail-type")
     source: str
     detail: dict
 
+
 def lambda_handler(event: dict, context):
     try:
         # Manually parse the incoming event into the custom model
         parsed_event: MyCustomEventBridgeModel = parse(model=MyCustomEventBridgeModel, event=event)
 
-        return {
-            "statusCode": 200,
-            "body": f"Event from {parsed_event.source}, type: {parsed_event.detail_type}"
-        }
+        return {"statusCode": 200, "body": f"Event from {parsed_event.source}, type: {parsed_event.detail_type}"}
     except ValidationError as e:
-        return {
-            "statusCode": 400,
-            "body": f"Validation error: {str(e)}"
-        }
+        return {"statusCode": 400, "body": f"Validation error: {str(e)}"}

examples/parser/src/custom_data_model_with_eventbridge.py

@@ -1,23 +1,20 @@
-from aws_lambda_powertools.utilities.parser import event_parser, BaseModel
-from aws_lambda_powertools.utilities.parser import envelopes
+from pydantic import BaseModel
+
+from aws_lambda_powertools.utilities.parser import envelopes, event_parser
 from aws_lambda_powertools.utilities.typing import LambdaContext
 
+
 class UserModel(BaseModel):
-   username: str
-   parentid_1: str
-   parentid_2: str
+    username: str
+    parentid_1: str
+    parentid_2: str
+
 
 @event_parser(model=UserModel, envelope=envelopes.EventBridgeEnvelope)
 def lambda_handler(event: UserModel, context: LambdaContext):
-    if event.parentid_1!= event.parentid_2:
-        return {
-            "statusCode": 400,
-            "body": "Parent ids do not match"
-        }
+    if event.parentid_1 != event.parentid_2:
+        return {"statusCode": 400, "body": "Parent ids do not match"}
 
     # If parentids match, proceed with user registration
 
-    return {
-        "statusCode": 200,
-        "body": f"User {event.username} registered successfully"
-    }
+    return {"statusCode": 200, "body": f"User {event.username} registered successfully"}

examples/parser/src/envelope_with_event_parser.py

@@ -1,25 +1,22 @@
-from aws_lambda_powertools.utilities.parser import parse, BaseModel
-from aws_lambda_powertools.utilities.parser import field_validator
+from pydantic import BaseModel, field_validator
+
+from aws_lambda_powertools.utilities.parser import parse
 from aws_lambda_powertools.utilities.typing import LambdaContext
 
+
 class HelloWorldModel(BaseModel):
     message: str
 
-    @field_validator('message')
+    @field_validator("message")
     def is_hello_world(cls, v):
         if v != "hello world":
             raise ValueError("Message must be hello world!")
         return v
 
+
 def lambda_handler(event: dict, context: LambdaContext):
     try:
         parsed_event = parse(model=HelloWorldModel, event=event)
-        return {
-            "statusCode": 200,
-            "body": f"Received message: {parsed_event.message}"
-        }
+        return {"statusCode": 200, "body": f"Received message: {parsed_event.message}"}
     except ValueError as e:
-        return {
-            "statusCode": 400,
-            "body": str(e)
-        }
+        return {"statusCode": 400, "body": str(e)}

examples/parser/src/field_validator.py

@@ -1,12 +1,14 @@
-from aws_lambda_powertools.utilities.parser import BaseModel
+from pydantic import BaseModel
+
 from aws_lambda_powertools.utilities.parser import event_parser
 
+
 class MyEvent(BaseModel):
     id: int
     name: str
 
+
 @event_parser(model=MyEvent)
 def lambda_handler(event: MyEvent, context):
-    #if your model is valid, you can return
+    # if your model is valid, you can return
     return {"statusCode": 200, "body": f"Hello {event.name}, your ID is {event.id}"}
-   

examples/parser/src/getting_started_with_parser.py

@@ -1,27 +1,31 @@
+from pydantic import BaseModel, model_validator
+
+from aws_lambda_powertools.utilities.parser import parse
 from aws_lambda_powertools.utilities.typing import LambdaContext
-from aws_lambda_powertools.utilities.parser import parse, BaseModel
-from aws_lambda_powertools.utilities.parser import model_validator
+
 
 class UserModel(BaseModel):
-	username: str
-	parentid_1: str
-	parentid_2: str
+    username: str
+    parentid_1: str
+    parentid_2: str
+
+    @model_validator(mode="after")  # (1)!
+    def check_parents_match(cls, values):
+        pi1, pi2 = values.get("parentid_1"), values.get("parentid_2")
+        if pi1 is not None and pi2 is not None and pi1 != pi2:
+            raise ValueError("Parent ids do not match")
+        return values
+
 
-	@model_validator(mode='after')
-	def check_parents_match(cls, values):
-		pi1, pi2 = values.get('parentid_1'), values.get('parentid_2')
-		if pi1 is not None and pi2 is not None and pi1 != pi2:
-			raise ValueError('Parent ids do not match')
-		return values
 def lambda_handler(event: dict, context: LambdaContext):
     try:
         parsed_event = parse(model=UserModel, event=event)
         return {
             "statusCode": 200,
-            "body": f"Received parent id from: {parsed_event.username}"
+            "body": f"Received parent id from: {parsed_event.username}",
         }
     except ValueError as e:
         return {
             "statusCode": 400,
-            "body": str(e)
-        }
+            "body": str(e),
+        }

examples/parser/src/model_validator.py

@@ -1,22 +1,19 @@
-from aws_lambda_powertools.utilities.parser import BaseModel, ValidationError
+from pydantic import BaseModel, ValidationError
+
 from aws_lambda_powertools.utilities.parser import parse
 
+
 # Define a Pydantic model for the expected structure of the input
 class MyEvent(BaseModel):
     id: int
     name: str
 
+
 def lambda_handler(event: dict, context):
     try:
         # Manually parse the incoming event into MyEvent model
         parsed_event: MyEvent = parse(model=MyEvent, event=event)
-        return {
-            "statusCode": 200,
-            "body": f"Hello {parsed_event.name}, your ID is {parsed_event.id}"
-        }
+        return {"statusCode": 200, "body": f"Hello {parsed_event.name}, your ID is {parsed_event.id}"}
     except ValidationError as e:
         # Catch validation errors and return a 400 response
-        return {
-            "statusCode": 400,
-            "body": f"Validation error: {str(e)}"
-        }
+        return {"statusCode": 400, "body": f"Validation error: {str(e)}"}

examples/parser/src/parser_function.py

@@ -1,27 +1,26 @@
-from aws_lambda_powertools.utilities.parser import parse, BaseModel
+from pydantic import BaseModel
+
 from aws_lambda_powertools.logging import Logger
+from aws_lambda_powertools.utilities.parser import parse
 from aws_lambda_powertools.utilities.typing import LambdaContext
 
 logger = Logger()
 
+
 class UserModel(BaseModel):
     username: str
     parentid_1: str
     parentid_2: str
 
+
 def validate_user(event):
     try:
         user = parse(model=UserModel, event=event)
-        return {
-            "statusCode": 200,
-            "body": user.model_dump_json()
-        }
+        return {"statusCode": 200, "body": user.model_dump_json()}
     except Exception as e:
         logger.exception("Validation error")
-        return {
-            "statusCode": 400,
-            "body": str(e)
-        }
+        return {"statusCode": 400, "body": str(e)}
+
 
 @logger.inject_lambda_context
 def lambda_handler(event: dict, context: LambdaContext) -> dict:
@@ -37,9 +36,6 @@ def lambda_handler(event: dict, context: LambdaContext) -> dict:
         user_dict = user.model_dump()
         user_json = user.model_dump_json()
 
-        logger.debug("User serializations", extra={
-            "dict": user_dict,
-            "json": user_json
-        })
+        logger.debug("User serializations", extra={"dict": user_dict, "json": user_json})
 
-    return result
+    return result

examples/parser/src/serialization_parser.py

@@ -1,19 +1,25 @@
 from typing import Any, Type
-from aws_lambda_powertools.utilities.parser import event_parser, BaseEnvelope, BaseModel
+
+from pydantic import BaseModel, Json
+
+from aws_lambda_powertools.utilities.parser import BaseEnvelope, event_parser
 from aws_lambda_powertools.utilities.typing import LambdaContext
-from aws_lambda_powertools.utilities.parser.types import Json
+
 
 class CancelOrder(BaseModel):
     order_id: int
     reason: str
 
+
 class CancelOrderModel(BaseModel):
     body: Json[CancelOrder]
 
+
 class CustomEnvelope(BaseEnvelope):
     def parse(self, data: dict, model: Type[BaseModel]) -> Any:
         return model.model_validate({"body": data.get("body", {})})
 
+
 @event_parser(model=CancelOrderModel, envelope=CustomEnvelope)
 def lambda_handler(event: CancelOrderModel, context: LambdaContext):
     cancel_order: CancelOrder = event.body
@@ -25,5 +31,5 @@ def lambda_handler(event: CancelOrderModel, context: LambdaContext):
 
     return {
         "statusCode": 200,
-        "body": f"Order {cancel_order.order_id} cancelled successfully"
-    }
+        "body": f"Order {cancel_order.order_id} cancelled successfully",
+    }