improv: rename schema to model as per Tom's review

Author: heitorlessa

aws_lambda_powertools/utilities/parser/__init__.py

@@ -2,7 +2,7 @@
 """
 from . import envelopes
 from .envelopes import BaseEnvelope
-from .exceptions import SchemaValidationError
+from .exceptions import ModelValidationError
 from .parser import event_parser
 from .pydantic import BaseModel, root_validator, validator
 
@@ -13,5 +13,5 @@
     "BaseModel",
     "validator",
     "root_validator",
-    "SchemaValidationError",
+    "ModelValidationError",
 ]

aws_lambda_powertools/utilities/parser/envelopes/base.py

@@ -11,15 +11,15 @@ class BaseEnvelope(ABC):
     """ABC implementation for creating a supported Envelope"""
 
     @staticmethod
-    def _parse(data: Union[Dict[str, Any], str], schema: BaseModel) -> Any:
-        """Parses envelope data against schema provided
+    def _parse(data: Union[Dict[str, Any], str], model: BaseModel) -> Any:
+        """Parses envelope data against model provided
 
         Parameters
         ----------
         data : Dict
             Data to be parsed and validated
-        schema
-            Schema to parse and validate data against
+        model
+            Data model to parse and validate data against
 
         Returns
         -------
@@ -30,29 +30,29 @@ def _parse(data: Union[Dict[str, Any], str], schema: BaseModel) -> Any:
             logger.debug("Skipping parsing as event is None")
             return data
 
-        logger.debug("parsing event against schema")
+        logger.debug("parsing event against model")
         if isinstance(data, str):
             logger.debug("parsing event as string")
-            return schema.parse_raw(data)
+            return model.parse_raw(data)
 
-        return schema.parse_obj(data)
+        return model.parse_obj(data)
 
     @abstractmethod
-    def parse(self, data: Dict[str, Any], schema: BaseModel):
-        """Implementation to parse data against envelope schema, then against the schema
+    def parse(self, data: Dict[str, Any], model: BaseModel):
+        """Implementation to parse data against envelope model, then against the data model
 
-        NOTE: Call `_parse` method to fully parse data with schema provided.
+        NOTE: Call `_parse` method to fully parse data with model provided.
 
         Example
         -------
 
         **EventBridge envelope implementation example**
 
         def parse(...):
-            # 1. parses data against envelope schema
-            parsed_envelope = EventBridgeSchema(**data)
+            # 1. parses data against envelope model
+            parsed_envelope = EventBridgeModel(**data)
 
-            # 2. parses portion of data within the envelope against schema
-            return self._parse(data=parsed_envelope.detail, schema=schema)
+            # 2. parses portion of data within the envelope against model
+            return self._parse(data=parsed_envelope.detail, model=data_model)
         """
         return NotImplemented  # pragma: no cover

aws_lambda_powertools/utilities/parser/envelopes/dynamodb.py

@@ -4,7 +4,7 @@
 from pydantic import BaseModel
 from typing_extensions import Literal
 
-from ..schemas import DynamoDBStreamSchema
+from ..models import DynamoDBStreamModel
 from .base import BaseEnvelope
 
 logger = logging.getLogger(__name__)
@@ -13,32 +13,32 @@
 class DynamoDBEnvelope(BaseEnvelope):
     """ DynamoDB Stream Envelope to extract data within NewImage/OldImage
 
-    Note: Values are the parsed schema models. Images' values can also be None, and
+    Note: Values are the parsed models. Images' values can also be None, and
     length of the list is the record's amount in the original event.
     """
 
-    def parse(self, data: Dict[str, Any], schema: BaseModel) -> List[Dict[Literal["NewImage", "OldImage"], BaseModel]]:
-        """Parses DynamoDB Stream records found in either NewImage and OldImage with schema provided
+    def parse(self, data: Dict[str, Any], model: BaseModel) -> List[Dict[Literal["NewImage", "OldImage"], BaseModel]]:
+        """Parses DynamoDB Stream records found in either NewImage and OldImage with model provided
 
         Parameters
         ----------
         data : Dict
             Lambda event to be parsed
-        schema : BaseModel
-            User schema provided to parse after extracting data using envelope
+        model : BaseModel
+            Data model provided to parse after extracting data using envelope
 
         Returns
         -------
         List
-            List of records parsed with schema provided
+            List of records parsed with model provided
         """
-        parsed_envelope = DynamoDBStreamSchema(**data)
+        parsed_envelope = DynamoDBStreamModel(**data)
         output = []
         for record in parsed_envelope.Records:
             output.append(
                 {
-                    "NewImage": self._parse(record.dynamodb.NewImage, schema),
-                    "OldImage": self._parse(record.dynamodb.OldImage, schema),
+                    "NewImage": self._parse(record.dynamodb.NewImage, model),
+                    "OldImage": self._parse(record.dynamodb.OldImage, model),
                 }
             )
         # noinspection PyTypeChecker

aws_lambda_powertools/utilities/parser/envelopes/event_bridge.py

@@ -3,7 +3,7 @@
 
 from pydantic import BaseModel
 
-from ..schemas import EventBridgeSchema
+from ..models import EventBridgeModel
 from .base import BaseEnvelope
 
 logger = logging.getLogger(__name__)
@@ -12,20 +12,20 @@
 class EventBridgeEnvelope(BaseEnvelope):
     """EventBridge envelope to extract data within detail key"""
 
-    def parse(self, data: Dict[str, Any], schema: BaseModel) -> BaseModel:
-        """Parses data found with schema provided
+    def parse(self, data: Dict[str, Any], model: BaseModel) -> BaseModel:
+        """Parses data found with model provided
 
         Parameters
         ----------
         data : Dict
             Lambda event to be parsed
-        schema : BaseModel
-            User schema provided to parse after extracting data using envelope
+        model : BaseModel
+            Data model provided to parse after extracting data using envelope
 
         Returns
         -------
         Any
-            Parsed detail payload with schema provided
+            Parsed detail payload with model provided
         """
-        parsed_envelope = EventBridgeSchema(**data)
-        return self._parse(data=parsed_envelope.detail, schema=schema)
+        parsed_envelope = EventBridgeModel(**data)
+        return self._parse(data=parsed_envelope.detail, model=model)

aws_lambda_powertools/utilities/parser/envelopes/sqs.py

@@ -3,7 +3,7 @@
 
 from pydantic import BaseModel
 
-from ..schemas import SqsSchema
+from ..models import SqsModel
 from .base import BaseEnvelope
 
 logger = logging.getLogger(__name__)
@@ -13,29 +13,29 @@ class SqsEnvelope(BaseEnvelope):
     """SQS Envelope to extract array of Records
 
     The record's body parameter is a string, though it can also be a JSON encoded string.
-    Regardless of it's type it'll be parsed into a BaseModel object.
+    Regardless of its type it'll be parsed into a BaseModel object.
 
-    Note: Records will be parsed the same way so if schema is str,
+    Note: Records will be parsed the same way so if model is str,
     all items in the list will be parsed as str and npt as JSON (and vice versa)
     """
 
-    def parse(self, data: Dict[str, Any], schema: Union[BaseModel, str]) -> List[Union[BaseModel, str]]:
-        """Parses records found with schema provided
+    def parse(self, data: Dict[str, Any], model: Union[BaseModel, str]) -> List[Union[BaseModel, str]]:
+        """Parses records found with model provided
 
         Parameters
         ----------
         data : Dict
             Lambda event to be parsed
-        schema : BaseModel
-            User schema provided to parse after extracting data using envelope
+        model : BaseModel
+            Data model provided to parse after extracting data using envelope
 
         Returns
         -------
         List
-            List of records parsed with schema provided
+            List of records parsed with model provided
         """
-        parsed_envelope = SqsSchema(**data)
+        parsed_envelope = SqsModel(**data)
         output = []
         for record in parsed_envelope.Records:
-            output.append(self._parse(record.body, schema))
+            output.append(self._parse(record.body, model))
         return output

aws_lambda_powertools/utilities/parser/exceptions.py

@@ -2,9 +2,9 @@ class InvalidEnvelopeError(Exception):
     """Input envelope is not callable and instance of BaseEnvelope"""
 
 
-class SchemaValidationError(Exception):
-    """Input data does not conform with schema"""
+class ModelValidationError(Exception):
+    """Input data does not conform with model"""
 
 
-class InvalidSchemaTypeError(Exception):
-    """Input schema does not implement BaseModel"""
+class InvalidModelTypeError(Exception):
+    """Input data model does not implement BaseModel"""

aws_lambda_powertools/utilities/parser/models/__init__.py

@@ -0,0 +1,12 @@
+from .dynamodb import DynamoDBStreamChangedRecordModel, DynamoDBStreamModel, DynamoDBStreamRecordModel
+from .event_bridge import EventBridgeModel
+from .sqs import SqsModel, SqsRecordModel
+
+__all__ = [
+    "DynamoDBStreamModel",
+    "EventBridgeModel",
+    "DynamoDBStreamChangedRecordModel",
+    "DynamoDBStreamRecordModel",
+    "SqsModel",
+    "SqsRecordModel",
+]

aws_lambda_powertools/utilities/parser/schemas/dynamodb.py renamed to aws_lambda_powertools/utilities/parser/models/dynamodb.py

@@ -5,7 +5,7 @@
 from typing_extensions import Literal
 
 
-class DynamoDBStreamChangedRecordSchema(BaseModel):
+class DynamoDBStreamChangedRecordModel(BaseModel):
     ApproximateCreationDateTime: Optional[date]
     Keys: Dict[str, Dict[str, Any]]
     NewImage: Optional[Dict[str, Any]]
@@ -16,13 +16,13 @@ class DynamoDBStreamChangedRecordSchema(BaseModel):
 
     # context on why it's commented: https://github.com/awslabs/aws-lambda-powertools-python/pull/118
     # since both images are optional, they can both be None. However, at least one must
-    # exist in a legal schema of NEW_AND_OLD_IMAGES type
+    # exist in a legal model of NEW_AND_OLD_IMAGES type
     # @root_validator
     # def check_one_image_exists(cls, values): # noqa: E800
     #     new_img, old_img = values.get("NewImage"), values.get("OldImage") # noqa: E800
     #     stream_type = values.get("StreamViewType") # noqa: E800
     #     if stream_type == "NEW_AND_OLD_IMAGES" and not new_img and not old_img: # noqa: E800
-    #         raise TypeError("DynamoDB streams schema failed validation, missing both new & old stream images") # noqa: E800,E501
+    #         raise TypeError("DynamoDB streams model failed validation, missing both new & old stream images") # noqa: E800,E501
     #     return values # noqa: E800
 
 
@@ -31,16 +31,16 @@ class UserIdentity(BaseModel):
     principalId: Literal["dynamodb.amazonaws.com"]
 
 
-class DynamoDBStreamRecordSchema(BaseModel):
+class DynamoDBStreamRecordModel(BaseModel):
     eventID: str
     eventName: Literal["INSERT", "MODIFY", "REMOVE"]
     eventVersion: float
     eventSource: Literal["aws:dynamodb"]
     awsRegion: str
     eventSourceARN: str
-    dynamodb: DynamoDBStreamChangedRecordSchema
+    dynamodb: DynamoDBStreamChangedRecordModel
     userIdentity: Optional[UserIdentity]
 
 
-class DynamoDBStreamSchema(BaseModel):
-    Records: List[DynamoDBStreamRecordSchema]
+class DynamoDBStreamModel(BaseModel):
+    Records: List[DynamoDBStreamRecordModel]

aws_lambda_powertools/utilities/parser/schemas/event_bridge.py renamed to aws_lambda_powertools/utilities/parser/models/event_bridge.py

@@ -4,7 +4,7 @@
 from pydantic import BaseModel, Field
 
 
-class EventBridgeSchema(BaseModel):
+class EventBridgeModel(BaseModel):
     version: str
     id: str  # noqa: A003,VNE003
     source: str

aws_lambda_powertools/utilities/parser/schemas/sqs.py renamed to aws_lambda_powertools/utilities/parser/models/sqs.py

@@ -5,7 +5,7 @@
 from typing_extensions import Literal
 
 
-class SqsAttributesSchema(BaseModel):
+class SqsAttributesModel(BaseModel):
     ApproximateReceiveCount: str
     ApproximateFirstReceiveTimestamp: datetime
     MessageDeduplicationId: Optional[str]
@@ -16,7 +16,7 @@ class SqsAttributesSchema(BaseModel):
     AWSTraceHeader: Optional[str]
 
 
-class SqsMsgAttributeSchema(BaseModel):
+class SqsMsgAttributeModel(BaseModel):
     stringValue: Optional[str]
     binaryValue: Optional[str]
     stringListValues: List[str] = []
@@ -48,18 +48,18 @@ class SqsMsgAttributeSchema(BaseModel):
     #     return values # noqa: E800
 
 
-class SqsRecordSchema(BaseModel):
+class SqsRecordModel(BaseModel):
     messageId: str
     receiptHandle: str
     body: str
-    attributes: SqsAttributesSchema
-    messageAttributes: Dict[str, SqsMsgAttributeSchema]
+    attributes: SqsAttributesModel
+    messageAttributes: Dict[str, SqsMsgAttributeModel]
     md5OfBody: str
     md5OfMessageAttributes: Optional[str]
     eventSource: Literal["aws:sqs"]
     eventSourceARN: str
     awsRegion: str
 
 
-class SqsSchema(BaseModel):
-    Records: List[SqsRecordSchema]
+class SqsModel(BaseModel):
+    Records: List[SqsRecordModel]