Migrating functions from v1 to v2

Author: leandrodamascena

aws_lambda_powertools/utilities/batch/base.py

@@ -309,7 +309,7 @@ def _collect_sqs_failures(self):
             # we convert to an event source data class...but self.model is still true
             # therefore, we do an additional check on whether the failed message is still a model
             # see https://github.com/aws-powertools/powertools-lambda-python/issues/2091
-            if self.model and getattr(msg, "parse_obj", None):
+            if self.model and getattr(msg, "model_validate", None):
                 msg_id = msg.messageId
             else:
                 msg_id = msg.message_id
@@ -320,7 +320,7 @@ def _collect_kinesis_failures(self):
         failures = []
         for msg in self.fail_messages:
             # # see https://github.com/aws-powertools/powertools-lambda-python/issues/2091
-            if self.model and getattr(msg, "parse_obj", None):
+            if self.model and getattr(msg, "model_validate", None):
                 msg_id = msg.kinesis.sequenceNumber
             else:
                 msg_id = msg.kinesis.sequence_number
@@ -331,7 +331,7 @@ def _collect_dynamodb_failures(self):
         failures = []
         for msg in self.fail_messages:
             # see https://github.com/aws-powertools/powertools-lambda-python/issues/2091
-            if self.model and getattr(msg, "parse_obj", None):
+            if self.model and getattr(msg, "model_validate", None):
                 msg_id = msg.dynamodb.SequenceNumber
             else:
                 msg_id = msg.dynamodb.sequence_number

aws_lambda_powertools/utilities/idempotency/base.py

@@ -39,14 +39,22 @@ def _prepare_data(data: Any) -> Any:
     We will convert Python dataclasses, pydantic models or event source data classes to a dict,
     otherwise return data as-is.
     """
+
+    # Convert from dataclasses
     if hasattr(data, "__dataclass_fields__"):
         import dataclasses
 
         return dataclasses.asdict(data)
 
+    # Convert from Pydantic model
+    if callable(getattr(data, "model_dump", None)):
+        return data.model_dump()
+
+    # Convert from event source data class
     if callable(getattr(data, "dict", None)):
         return data.dict()
 
+    # Return raw event
     return getattr(data, "raw_event", data)
 
 

aws_lambda_powertools/utilities/idempotency/serialization/pydantic.py

@@ -25,16 +25,10 @@ def __init__(self, model: Type[BaseModel]):
         self.__model: Type[BaseModel] = model
 
     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()
+        return data.model_dump()
 
     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]
-        return self.__model.parse_obj(data)
+        return self.__model.model_validate(data)
 
     @classmethod
     def instantiate(cls, model_type: Any) -> BaseIdempotencySerializer:

aws_lambda_powertools/utilities/parser/envelopes/apigw.py

@@ -27,6 +27,6 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             Parsed detail payload with model provided
         """
         logger.debug(f"Parsing incoming data with Api Gateway model {APIGatewayProxyEventModel}")
-        parsed_envelope: APIGatewayProxyEventModel = APIGatewayProxyEventModel.parse_obj(data)
+        parsed_envelope: APIGatewayProxyEventModel = APIGatewayProxyEventModel.model_validate(data)
         logger.debug(f"Parsing event payload in `detail` with {model}")
         return self._parse(data=parsed_envelope.body, model=model)

aws_lambda_powertools/utilities/parser/envelopes/apigwv2.py

@@ -27,6 +27,6 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             Parsed detail payload with model provided
         """
         logger.debug(f"Parsing incoming data with Api Gateway model V2 {APIGatewayProxyEventV2Model}")
-        parsed_envelope: APIGatewayProxyEventV2Model = APIGatewayProxyEventV2Model.parse_obj(data)
+        parsed_envelope: APIGatewayProxyEventV2Model = APIGatewayProxyEventV2Model.model_validate(data)
         logger.debug(f"Parsing event payload in `detail` with {model}")
         return self._parse(data=parsed_envelope.body, model=model)

aws_lambda_powertools/utilities/parser/envelopes/bedrock_agent.py

@@ -27,6 +27,6 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             Parsed detail payload with model provided
         """
         logger.debug(f"Parsing incoming data with Bedrock Agent model {BedrockAgentEventModel}")
-        parsed_envelope: BedrockAgentEventModel = BedrockAgentEventModel.parse_obj(data)
+        parsed_envelope: BedrockAgentEventModel = BedrockAgentEventModel.model_validate(data)
         logger.debug(f"Parsing event payload in `input_text` with {model}")
         return self._parse(data=parsed_envelope.input_text, model=model)

aws_lambda_powertools/utilities/parser/envelopes/cloudwatch.py

@@ -34,7 +34,7 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             List of records parsed with model provided
         """
         logger.debug(f"Parsing incoming data with SNS model {CloudWatchLogsModel}")
-        parsed_envelope = CloudWatchLogsModel.parse_obj(data)
+        parsed_envelope = CloudWatchLogsModel.model_validate(data)
         logger.debug(f"Parsing CloudWatch records in `body` with {model}")
         return [
             self._parse(data=record.message, model=model) for record in parsed_envelope.awslogs.decoded_data.logEvents

aws_lambda_powertools/utilities/parser/envelopes/dynamodb.py

@@ -31,7 +31,7 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             List of dictionaries with NewImage and OldImage records parsed with model provided
         """
         logger.debug(f"Parsing incoming data with DynamoDB Stream model {DynamoDBStreamModel}")
-        parsed_envelope = DynamoDBStreamModel.parse_obj(data)
+        parsed_envelope = DynamoDBStreamModel.model_validate(data)
         logger.debug(f"Parsing DynamoDB Stream new and old records with {model}")
         return [
             {

aws_lambda_powertools/utilities/parser/envelopes/event_bridge.py

@@ -27,6 +27,6 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             Parsed detail payload with model provided
         """
         logger.debug(f"Parsing incoming data with EventBridge model {EventBridgeModel}")
-        parsed_envelope: EventBridgeModel = EventBridgeModel.parse_obj(data)
+        parsed_envelope: EventBridgeModel = EventBridgeModel.model_validate(data)
         logger.debug(f"Parsing event payload in `detail` with {model}")
         return self._parse(data=parsed_envelope.detail, model=model)

aws_lambda_powertools/utilities/parser/envelopes/kafka.py

@@ -38,7 +38,7 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
         )
 
         logger.debug(f"Parsing incoming data with Kafka event model {model_parse_event}")
-        parsed_envelope = model_parse_event.parse_obj(data)
+        parsed_envelope = model_parse_event.model_validate(data)
         logger.debug(f"Parsing Kafka event records in `value` with {model}")
         ret_list = []
         for records in parsed_envelope.records.values():

aws_lambda_powertools/utilities/parser/envelopes/kinesis.py

@@ -35,7 +35,7 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             List of records parsed with model provided
         """
         logger.debug(f"Parsing incoming data with Kinesis model {KinesisDataStreamModel}")
-        parsed_envelope: KinesisDataStreamModel = KinesisDataStreamModel.parse_obj(data)
+        parsed_envelope: KinesisDataStreamModel = KinesisDataStreamModel.model_validate(data)
         logger.debug(f"Parsing Kinesis records in `body` with {model}")
         models = []
         for record in parsed_envelope.Records:

aws_lambda_powertools/utilities/parser/envelopes/kinesis_firehose.py

@@ -37,7 +37,7 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             List of records parsed with model provided
         """
         logger.debug(f"Parsing incoming data with Kinesis Firehose model {KinesisFirehoseModel}")
-        parsed_envelope: KinesisFirehoseModel = KinesisFirehoseModel.parse_obj(data)
+        parsed_envelope: KinesisFirehoseModel = KinesisFirehoseModel.model_validate(data)
         logger.debug(f"Parsing Kinesis Firehose records in `body` with {model}")
         models = []
         for record in parsed_envelope.records:

aws_lambda_powertools/utilities/parser/envelopes/lambda_function_url.py

@@ -27,6 +27,6 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             Parsed detail payload with model provided
         """
         logger.debug(f"Parsing incoming data with Lambda function URL model {LambdaFunctionUrlModel}")
-        parsed_envelope: LambdaFunctionUrlModel = LambdaFunctionUrlModel.parse_obj(data)
+        parsed_envelope: LambdaFunctionUrlModel = LambdaFunctionUrlModel.model_validate(data)
         logger.debug(f"Parsing event payload in `detail` with {model}")
         return self._parse(data=parsed_envelope.body, model=model)

aws_lambda_powertools/utilities/parser/envelopes/sns.py

@@ -34,7 +34,7 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             List of records parsed with model provided
         """
         logger.debug(f"Parsing incoming data with SNS model {SnsModel}")
-        parsed_envelope = SnsModel.parse_obj(data)
+        parsed_envelope = SnsModel.model_validate(data)
         logger.debug(f"Parsing SNS records in `body` with {model}")
         return [self._parse(data=record.Sns.Message, model=model) for record in parsed_envelope.Records]
 
@@ -66,11 +66,11 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             List of records parsed with model provided
         """
         logger.debug(f"Parsing incoming data with SQS model {SqsModel}")
-        parsed_envelope = SqsModel.parse_obj(data)
+        parsed_envelope = SqsModel.model_validate(data)
         output = []
         for record in parsed_envelope.Records:
             # We allow either AWS expected contract (str) or a custom Model, see #943
             body = cast(str, record.body)
-            sns_notification = SnsNotificationModel.parse_raw(body)
+            sns_notification = SnsNotificationModel.model_validate_json(body)
             output.append(self._parse(data=sns_notification.Message, model=model))
         return output

aws_lambda_powertools/utilities/parser/envelopes/sqs.py

@@ -34,6 +34,6 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             List of records parsed with model provided
         """
         logger.debug(f"Parsing incoming data with SQS model {SqsModel}")
-        parsed_envelope = SqsModel.parse_obj(data)
+        parsed_envelope = SqsModel.model_validate(data)
         logger.debug(f"Parsing SQS records in `body` with {model}")
         return [self._parse(data=record.body, model=model) for record in parsed_envelope.Records]

aws_lambda_powertools/utilities/parser/envelopes/vpc_lattice.py

@@ -27,6 +27,6 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             Parsed detail payload with model provided
         """
         logger.debug(f"Parsing incoming data with VPC Lattice model {VpcLatticeModel}")
-        parsed_envelope: VpcLatticeModel = VpcLatticeModel.parse_obj(data)
+        parsed_envelope: VpcLatticeModel = VpcLatticeModel.model_validate(data)
         logger.debug(f"Parsing event payload in `detail` with {model}")
         return self._parse(data=parsed_envelope.body, model=model)

aws_lambda_powertools/utilities/parser/envelopes/vpc_latticev2.py

@@ -27,6 +27,6 @@ def parse(self, data: Optional[Union[Dict[str, Any], Any]], model: Type[Model])
             Parsed detail payload with model provided
         """
         logger.debug(f"Parsing incoming data with VPC Lattice V2 model {VpcLatticeV2Model}")
-        parsed_envelope: VpcLatticeV2Model = VpcLatticeV2Model.parse_obj(data)
+        parsed_envelope: VpcLatticeV2Model = VpcLatticeV2Model.model_validate(data)
         logger.debug(f"Parsing event payload in `detail` with {model}")
         return self._parse(data=parsed_envelope.body, model=model)

aws_lambda_powertools/utilities/parser/models/s3.py

@@ -101,7 +101,7 @@ class S3RecordModel(BaseModel):
     s3: S3Message
     glacierEventData: Optional[S3EventRecordGlacierEventData] = None
 
-    @root_validator(allow_reuse=True, skip_on_failure=True)
+    @root_validator(allow_reuse=True, skip_on_failure=True)  # review
     def validate_s3_object(cls, values):
         event_name = values.get("eventName")
         s3_object = values.get("s3").object

aws_lambda_powertools/utilities/parser/models/s3_batch_operation.py

@@ -12,7 +12,7 @@ class S3BatchOperationTaskModel(BaseModel):
     s3BucketArn: Optional[str] = None
     s3Bucket: Optional[str] = None
 
-    @validator("s3Bucket", pre=True, always=True)
+    @validator("s3Bucket", pre=True, always=True)  # review
     def validate_bucket(cls, current_value, values):
         # Get the s3 bucket, either from 's3Bucket' property (invocationSchemaVersion '2.0')
         # or from 's3BucketArn' (invocationSchemaVersion '1.0')

docs/utilities/parser.md

@@ -414,7 +414,7 @@ Here's a snippet of how the EventBridge envelope we demonstrated previously is i
             Any
                 Parsed detail payload with model provided
             """
-            parsed_envelope = EventBridgeModel.parse_obj(data)
+            parsed_envelope = EventBridgeModel.model_validate(data)
             return self._parse(data=parsed_envelope.detail, model=model)
     ```
 

tests/functional/batch/sample_models.py

@@ -1,7 +1,9 @@
 import json
 from typing import Dict, Optional
 
-from aws_lambda_powertools.utilities.parser import BaseModel, validator
+from pydantic import field_validator
+
+from aws_lambda_powertools.utilities.parser import BaseModel
 from aws_lambda_powertools.utilities.parser.models import (
     DynamoDBStreamChangedRecordModel,
     DynamoDBStreamRecordModel,
@@ -33,7 +35,7 @@ class OrderDynamoDB(BaseModel):
 
     # auto transform json string
     # so Pydantic can auto-initialize nested Order model
-    @validator("Message", pre=True)
+    @field_validator("Message", mode="before")
     def transform_message_to_dict(cls, value: Dict[Literal["S"], str]):
         try:
             return json.loads(value["S"])

tests/functional/event_handler/test_openapi_encoders.py

@@ -4,7 +4,7 @@
 
 import pytest
 from pydantic import BaseModel
-from pydantic.color import Color
+from pydantic.color import Color  # review
 
 from aws_lambda_powertools.event_handler.openapi.encoders import jsonable_encoder
 

tests/functional/event_handler/test_openapi_responses.py

@@ -88,7 +88,12 @@ class User(BaseModel):
 
     @app.get(
         "/",
-        responses={200: {"description": "Custom response", "content": {"application/json": {"schema": User.schema()}}}},
+        responses={
+            200: {
+                "description": "Custom response",
+                "content": {"application/json": {"schema": User.model_json_schema()}},
+            },
+        },
     )
     def handler():
         return {"message": "hello world"}

tests/functional/idempotency/test_idempotency.py

@@ -1344,7 +1344,7 @@ class PaymentOutput(BaseModel):
         output_serializer=output_serializer,
     )
     def collect_payment(payment: PaymentInput) -> PaymentOutput:
-        return PaymentOutput(**payment.dict())
+        return PaymentOutput(**payment.model_dump())
 
     # WHEN
     payment = PaymentInput(**mock_event)
@@ -1383,7 +1383,7 @@ class PaymentOutput(BaseModel):
 
         @idempotent_function_decorator
         def collect_payment(payment: PaymentInput):
-            return PaymentOutput(**payment.dict())
+            return PaymentOutput(**payment.model_dump())
 
 
 def test_idempotent_function_serialization_pydantic_failure_bad_type():
@@ -1411,7 +1411,7 @@ class PaymentOutput(BaseModel):
 
         @idempotent_function_decorator
         def collect_payment(payment: PaymentInput) -> dict:
-            return PaymentOutput(**payment.dict())
+            return PaymentOutput(**payment.model_dump())
 
 
 @pytest.mark.parametrize("output_serializer_type", ["explicit", "deduced"])
@@ -1747,7 +1747,7 @@ class Foo(BaseModel):
     expected_result = {"name": "Bar"}
     data = Foo(name="Bar")
     as_dict = _prepare_data(data)
-    assert as_dict == data.dict()
+    assert as_dict == data.model_dump()
     assert as_dict == expected_result
 
 

tests/functional/test_utilities_batch.py

@@ -5,6 +5,7 @@
 
 import pytest
 from botocore.config import Config
+from pydantic import field_validator
 
 from aws_lambda_powertools.utilities.batch import (
     AsyncBatchProcessor,
@@ -24,7 +25,7 @@
     KinesisStreamRecord,
 )
 from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord
-from aws_lambda_powertools.utilities.parser import BaseModel, validator
+from aws_lambda_powertools.utilities.parser import BaseModel
 from aws_lambda_powertools.utilities.parser.models import (
     DynamoDBStreamChangedRecordModel,
     DynamoDBStreamRecordModel,
@@ -523,7 +524,7 @@ class OrderDynamoDB(BaseModel):
 
         # auto transform json string
         # so Pydantic can auto-initialize nested Order model
-        @validator("Message", pre=True)
+        @field_validator("Message", mode="before")
         def transform_message_to_dict(cls, value: Dict[Literal["S"], str]):
             return json.loads(value["S"])
 
@@ -567,7 +568,7 @@ class OrderDynamoDB(BaseModel):
 
         # auto transform json string
         # so Pydantic can auto-initialize nested Order model
-        @validator("Message", pre=True)
+        @field_validator("Message", mode="before")
         def transform_message_to_dict(cls, value: Dict[Literal["S"], str]):
             return json.loads(value["S"])