sqlalchemy-serializer-meta 0.1.0__py3-none-any.whl

sqlalchemy_serializer_meta/__init__.py

@@ -0,0 +1,424 @@
+"""
+# Serializer Models
+"""
+
+from sqlalchemy import Table
+from .serializer import (
+    AbstractSerializer,
+    Validatable,
+    Saveable,
+    Updatable,
+    Deletable,
+    Representable,
+    Creatable,
+    ToInstance,
+    ExtendsPydantic,
+)
+from typing import Self, NoReturn, Optional, Any, Union
+from pydantic import BaseModel, ValidationError
+
+
+# Serializer Exceptions
+class SerializerError(Exception):
+    """
+    Serializer Error
+
+    You must apply excpetion as following otherwise an error will occure
+
+    ```py
+    from playstation import serializer
+
+    raise serializer.SerializerError(TypeError, "Error Message")
+
+    # Your code will be catched to form a message like this
+    try:
+        # Code
+    except SerializerError as e:
+        message: str = e.args[1] # Exception message
+        type: Exception = e.args[0] # Exception Type
+    """
+
+    pass
+
+
+# Serializer Interface
+class SerializerInterface(
+    AbstractSerializer,
+    Validatable,
+    Saveable,
+    Updatable,
+    Deletable,
+    Representable,
+    Creatable,
+    ToInstance,
+    ExtendsPydantic,
+):
+    pass
+
+
+# Serializer class
+class Serializer(SerializerInterface):
+    @property
+    def data(self: Self) -> dict:
+        """
+        Property to get data
+        """
+        # Check instance
+        if self.instance:
+            return self.to_representation(self.instance)
+        # Return self._data
+        return self.validated_data
+
+    @property
+    def validated_data(self: Self) -> dict:
+        """
+        Property to get validated data
+
+        Returns:
+            - Python Dictionary of the validated data
+        """
+        # Check validated data
+        if not hasattr(self, "_validated_data"):
+            raise Exception("You Should run .is_valid() method first to validate data.")
+        # Return validated_data
+        return self._validated_data
+
+    def is_valid(self: Self) -> bool:
+        """
+        Method to validate data
+
+        Returns:
+            - True incase data validation passes otherwise False
+        """
+        # Implement validation logic here
+        # Grab the data
+        data: Optional[dict] = self._data
+
+        # Check data
+        self.__data_checker()
+
+        # validate data
+        if self.validate(data):
+            return True
+        # Data not valid
+        return False
+
+    def __data_checker(self: Self) -> Optional[NoReturn]:
+        """
+        Method used to check private attribute _data
+        """
+        # Grab data
+        data: Optional[dict] = self._data
+        # Check if it is not None
+        if data is None:
+            raise ValueError("data: parameter should not be None")
+        # Check datatype for self._data
+        if not isinstance(data, dict):
+            raise TypeError("data: parameter should be of type dictionary")
+
+    def validate(self: Self, data: dict) -> bool:
+        """
+        Method used to validate data.
+
+        Creates:
+            self._validated_data is created when using this function
+
+        Returns:
+            - bool True in case of validated otherwise False
+        """
+        # Implement your validation logic here
+        # Check data keys if match the fields of the model or mismatch
+        self.__validate_data_fields(data)
+        # Get all validate methods
+        validate_methods: list[str] = self.__validate_methods()
+        # Create validated_data
+        self._validated_data: dict = data
+        # Get Fields
+        fields: set[str] = set(self.fields)
+        # Check Validation methods
+        if validate_methods:
+            for method in validate_methods:
+                try:
+                    # Grab key
+                    key: str = method.replace("validate_", "")
+                    # Grab the field
+                    value: Optional[str] = data.get(key)
+                    # Check if field is in fields
+                    if key in fields:
+                        # Call each validation method
+                        self._validated_data[key] = getattr(self, method)(value)
+                except SerializerError as e:
+                    # add to error
+                    self.errors.append(
+                        {
+                            "msg": str(e.args[1]),
+                            "field": key,
+                            "input": (
+                                value
+                                if key != "password"
+                                else "" if key in self.write_only else ""
+                            ),
+                            "type": f"{e.args[0].__name__}",
+                        }
+                    )
+                except Exception as e:
+                    self.errors.append(
+                        {
+                            "msg": str(e),
+                            "field": key,
+                            "input": (
+                                value
+                                if key != "password"
+                                else "" if key in self.write_only else ""
+                            ),
+                            "type": f"{type(e).__name__}",
+                        }
+                    )
+        # Validate using pydantic
+        if self.pydantic_model is not None:
+            self._validated_data = getattr(self, "validate_pydantic")(
+                self.validated_data
+            )
+
+        return not bool(self.errors)
+
+    def __validate_data_fields(self: Self, data: dict) -> Optional[NoReturn]:
+        """
+        Method used to validate data fields
+        """
+        # Grab fields
+        fields: set = {
+            key for key in self.model.__dict__.keys() if not key.startswith("_")
+        }
+        # Check if data keys match with fields
+        for key in data.keys():
+            if key not in fields:
+                raise ValueError(f"Invalid field: {key}")
+
+    def __validate_methods(self: Self) -> list[str]:
+        """
+        Method to retrieve a list of validation callable methods.
+
+        Returns:
+            - list of (callable) methods
+        """
+        return [
+            method
+            for method in dir(self)
+            if method.startswith("validate_")  # Get all validate methods
+            if method.replace("validate_", "")
+            in self.fields  # Check if validation method matchs name of a field
+            if callable(getattr(self, method))  # Check if it is a callable method
+        ]
+
+    def validate_pydantic(self: Self, validated_data: dict) -> Optional[BaseModel]:
+        """Validate data using Pydantic."""
+        try:
+            model: BaseModel = getattr(self, "pydantic_model")
+            if not model:
+                raise AttributeError("No Pydantic model defined")
+            return model(**validated_data).model_dump()
+        except ValidationError as e:
+            self.errors.extend(e.errors())
+        except SerializerError as e:
+            # add to error
+            self.errors.append(
+                {
+                    "msg": str(
+                        e.args[1]
+                    ),  # error message SerializerError(<class Exception>, error_message)
+                    "type": f"{e.args[0].__name__}",  # Excpetion class name,
+                }
+            )
+        except AttributeError as e:
+            # error
+            error: dict = {"msg": str(e), "type": f"{type(e).__name__}"}
+            self.errors.append(error)
+        except Exception as e:
+            # error
+            error: dict = {"msg": str(e), "type": f"{type(e).__name__}"}
+            self.errors.append(error)
+        return None
+
+    def save(self: Self) -> object:
+        """
+        Method to create new instance of an object or update an existing object
+
+        Returns:
+            - Instance of the model.
+        """
+        # Grab the data
+        data: Optional[dict] = getattr(self, "validated_data", None)
+        # Check data
+        if data is None:
+            raise ValueError("No validated data found")
+        # Check if save method exists
+        self.__check_save()
+        # Check if object instance exists or not
+        # Grab object id
+        object_id: Optional[int] = data.get("id", None)
+        instance: Optional[None] = None
+        # Check if id exists
+        if object_id:
+            # Check if object instance exists or not
+            instance: object = self.model.query.get(object_id)
+            if instance:
+                # Update instance
+                self.instance = self.update(data, instance)
+                return self.instance
+        # Else perform create new instance method
+        self.instance = self.create(data)
+        # Return the instance
+        return self.instance
+
+    def __check_save(self: Self) -> Optional[NoReturn]:
+        """
+        Checker function to check if model object has a method .save()
+
+        Raises:
+            - Error in case the model does not have a method .save()
+        """
+        if not hasattr(self.model, "save"):
+            raise AttributeError("Model object must have a method .save()")
+
+    def update(self: Self, validated_data: dict, instance: object) -> object:
+        """
+        Method to update an existing object
+        """
+        # Implement update logic here
+        for key, value in validated_data.items():
+            # Check if model has the key and key is not in read_only fields
+            if hasattr(self.model, key) and key not in self.read_only:
+                setattr(instance, key, value)
+        # Save
+        instance.save()
+        # Return instance
+        return instance
+
+    def delete(self: Self) -> None:
+        """
+        Method to delete an existing object
+        """
+        # Implement delete logic here
+        instance: object = self.instance
+        # Check instance
+        if not instance:
+            raise ValueError("Instance does not exist")
+        # Perform delete function
+        if not hasattr(instance, "delete"):
+            raise AttributeError("Model object must have a method .delete()")
+        # Initiate delete instance
+        instance.delete()
+
+    def create(self, validated_data: dict) -> object:
+        """
+        Create a new instance of the model.
+
+        Args:
+            - validated_data (dict): Validated data of the parameters of new instance.
+
+        Returns:
+            - Newly created instance of the model.
+        """
+        # Create the model
+        instance = self.model(**validated_data)
+        # Create instance
+        instance.save()
+        # Return the instance
+        return instance
+
+    def to_representation(self, instance: object) -> dict:
+        """
+        Convert the model instance into a dictionary representation.
+        """
+        # Implement representation logic here
+        fields: list[str] = self.fields
+        # Serialize
+        serialized_data: dict = {
+            field: self.__grab_field(instance, field)
+            for field in fields
+            if field not in self.write_only
+        }
+        # Return Serialized data
+        return serialized_data
+
+    def __grab_field(self, instance: object, field: str) -> Any:
+        """Helper function to grab field for serialization process."""
+        # Grab field value from instance_dict
+        value: Any = getattr(instance, field)
+        # Grab nested serializer
+        # If value is None, check if the field is a relationship
+        if self.__check_model(value):
+            nested_serialization = getattr(self, field, None)
+            return self.__serialize_relationship(nested_serialization, value)
+        if isinstance(value, list):
+            nested_serialization = getattr(self, field, None)
+            return self.__serialize_relationship_list(nested_serialization, value)
+        # Return Value
+        return value
+
+    def __check_model(self, instance: object) -> bool:
+        """Helper function to check if the model exists."""
+        # Check if the model exists
+        return hasattr(instance, "__table__") and isinstance(instance.__table__, Table)
+
+    def __serialize_relationship(
+        self,
+        nested_serializer: Optional["Serializer"],
+        relationship: object,
+    ) -> Any:
+        """Helper function to serialize a single nested relationship."""
+        if nested_serializer and isinstance(nested_serializer, Serializer):
+            nested_serializer.instance = relationship
+            return nested_serializer.data
+        return self.__grab_field(relationship, "id")
+
+    def __serialize_relationship_list(
+        self, nested_serializer: Optional["Serializer"], relationship: list
+    ) -> list:
+        """Helper function to serialize a list of nested relationships."""
+        if nested_serializer and isinstance(nested_serializer, Serializer):
+            nested_serializer.instance = relationship
+            return nested_serializer.data
+        return [
+            self.__grab_field(model, "id")
+            for model in relationship
+            if self.__check_model(model)
+        ]
+
+    def to_instance(self, find_by: str = "id") -> Optional[object]:
+        """
+        Convert the dictionary representation into a model instance.
+        """
+        # Implement instance creation logic here
+        if self._data:
+            instance: object = self.model.query.get(self._data[find_by])
+            return instance
+        return None
+
+
+# Model Serializer
+class ModelSerializer(Serializer):
+    @property
+    def data(self: Self) -> dict:
+        """
+        Property to get serialized model
+        """
+        # Get the model
+        model: object = self.instance
+        # Check model
+        if model is None:
+
+            raise ValueError("Model instance is not provided")
+
+        # Treat instance as many instances
+        if self.many:
+            if not isinstance(self.instance, list):
+                raise TypeError("Expected a list of instances with many set to True")
+            return [self.to_representation(instance) for instance in self.instance]
+
+        if isinstance(model, list):
+            model = model[0]
+
+        # Call to_representation method
+        return self.to_representation(model)

sqlalchemy_serializer_meta/serializer.py

@@ -0,0 +1,199 @@
+"""
+# File that contains abstract classes for how serializer should be implemented.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Iterable, Self
+from pydantic import BaseModel
+
+
+# Abstract Serializer
+class AbstractSerializer(ABC):
+    """
+    Abstract class for serializer implementation.
+    """
+
+    def __init__(
+        self,
+        instance: Optional[object] = None,
+        data: Optional[dict] = None,
+        many: bool = False,
+    ) -> None:
+        self.instance: Optional[object] = instance
+        self._data: Optional[dict] = data
+        self.many: bool = many
+        self._errors = []
+        self._meta = self.get_meta()  # Access Meta Class
+        self._fields: Optional[Iterable[str]] = getattr(self._meta, "fields", None)
+        self._write_only: Iterable[str] = getattr(self._meta, "write_only", [])
+        self._read_only: Iterable[str] = getattr(self._meta, "read_only", {"id"})
+
+        self.fields = self._fields  # Trigger the fields setter
+        self.write_only = self._write_only  # Trigger the write_only setter
+        self.read_only = self._read_only  # Trigger the read_only setter
+
+    def get_meta(self):
+        meta = getattr(self, "Meta", None)
+        if meta is None:
+            raise AttributeError("Meta class is not defined.")
+        return meta
+
+    @property
+    def data(self) -> dict:
+        """
+        Property to get serialized model
+        """
+        raise NotImplementedError("data property must be implemented by subclasses")
+
+    @property
+    def model(self):
+        return getattr(self._meta, "model", None)
+
+    @property
+    def fields(self) -> Optional[Iterable[str]]:
+        return self._fields
+
+    @fields.setter
+    def fields(self, serializer_fields: Optional[Iterable[str]]) -> None:
+        """
+        Setter property method for fields.
+
+        Args:
+            - serializer_fields (Iterable Python Object): Fields for serializer.
+        """
+        if serializer_fields is None:
+            raise ValueError("Fields cannot be None.")
+        fields = [key for key in self.model.__dict__.keys() if not key.startswith("_")]
+        if not self.__check_fields(serializer_fields):
+            fields = [
+                key for key in serializer_fields if self.__existing_field(key, fields)
+            ]
+        self._fields = fields
+
+    @property
+    def write_only(self) -> Iterable[str]:
+        return self._write_only
+
+    @write_only.setter
+    def write_only(self, serializer_fields: Optional[Iterable[str]]) -> None:
+        """
+        Setter property method write_only fields.
+
+        Args:
+            - serializer_fields (Iterable Python Object): Fields for serializer.
+        """
+        if serializer_fields is None:
+            return
+        fields = [key for key in self.model.__dict__.keys()]
+        if not self.__check_fields(serializer_fields):
+            fields = [
+                key for key in serializer_fields if self.__existing_field(key, fields)
+            ]
+        self._write_only = fields
+
+    @property
+    def read_only(self) -> Iterable[str]:
+        return self._read_only
+
+    @read_only.setter
+    def read_only(self, serializer_fields: Optional[Iterable[str]]) -> None:
+        """
+        Setter property method read_only fields.
+
+        Args:
+            - serializer_fields (Iterable Python Object): Fields for serializer.
+        """
+        if serializer_fields is None:
+            return
+        fields = [key for key in self.model.__dict__.keys()]
+        if not self.__check_fields(serializer_fields):
+            fields = [
+                key for key in serializer_fields if self.__existing_field(key, fields)
+            ]
+        self._read_only = fields
+
+    def __existing_field(self, field: str, fields: list[str]) -> bool:
+        """
+        Check if field exists in fields.
+        """
+        if field not in fields:
+            raise ValueError(f"Field '{field}' does not exist in model.")
+        return True
+
+    def __check_fields(self, fields: Optional[Iterable[str]]) -> bool:
+        """
+        Helper function to check fields specified fields against '__all__'
+
+        Args:
+            - fields (Optional[Iterable[str]]): Fields
+
+        Returns:
+            - True in case all fields otherwise False
+        """
+        if isinstance(fields, str) and fields == "__all__":
+            return True
+        if isinstance(fields, list) and len(fields) == 1 and fields[0] == "__all__":
+            return True
+        return False
+
+    @property
+    def errors(self) -> Optional[list]:
+        return self._errors
+
+
+class Validatable(ABC):
+    @property
+    def validated_data(self) -> dict:
+        pass
+
+    @abstractmethod
+    def is_valid(self) -> bool:
+        pass
+
+    @abstractmethod
+    def validate(self) -> bool:
+        pass
+
+
+class Saveable(ABC):
+    @abstractmethod
+    def save(self) -> object:
+        pass
+
+
+class Updatable(ABC):
+    @abstractmethod
+    def update(self) -> object:
+        pass
+
+
+class Deletable(ABC):
+    @abstractmethod
+    def delete(self) -> None:
+        pass
+
+
+class Representable(ABC):
+    @abstractmethod
+    def to_representation(self, instance: object) -> dict:
+        pass
+
+
+class Creatable(ABC):
+    @abstractmethod
+    def create(self, validated_data: dict) -> dict:
+        pass
+
+
+class ToInstance(ABC):
+    @abstractmethod
+    def to_instance(self, data: dict) -> object:
+        pass
+
+
+class ExtendsPydantic(ABC):
+    pydantic_model: Optional[BaseModel] = None
+
+    @abstractmethod
+    def validate_pydantic(self: Self, data: dict) -> None:
+        pass

sqlalchemy_serializer_meta-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Yuri Boiko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlalchemy_serializer_meta-0.1.0.dist-info/METADATA

@@ -0,0 +1,392 @@
+Metadata-Version: 2.1
+Name: sqlalchemy_serializer_meta
+Version: 0.1.0
+Summary: A simple serializer for SQLAlchemy models and Flask Models
+Home-page: https://github.com/Wehda23/sqlalchemy_serializer_meta
+Author: Waheed Khaled Elhariri
+Author-email: waheedkhaled95@gmail.com
+License: MIT
+Keywords: sqlalchemy serializer pydantic flask
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy
+Requires-Dist: pydantic ==2.7.4
+Requires-Dist: pydantic-core ==2.18.4
+
+# Serializer Module for Flask Application
+
+This module provides a set of serializers for your Flask application, allowing you to easily validate and serialize data. The serializers are built with flexibility and extendability in mind, providing features such as nested serialization and integration with Pydantic models.
+
+## Installation
+
+To use the serializers in your project, simply include the necessary files in your application directory.
+
+## Usage
+
+Can be used to Serialize SQLAlchemy Model or Flask-SQLAlchemy model.
+
+### Basic Usage
+
+Here's an example of how to use the `UserRegisterSerializer` to validate and create a new user:
+
+```python
+from your_application.serializers import UserRegisterSerializer
+from your_application.models import User
+
+data = {
+    "first_name": "John",
+    "last_name": "Doe",
+    "email": "john.doe@example.com",
+    "password": "securepassword123"
+}
+
+serializer = UserRegisterSerializer(data=data)
+if serializer.is_valid():
+    user = serializer.save()
+    print("User created:", user)
+else:
+    print("Errors:", serializer.errors)
+```
+
+In this example your custom serializer module/package
+
+```py
+from sqlalchemy_serializer_meta import Serializer, ModelSerializer, SerializerError
+from your_application.models import User
+
+class UserRegisterSerializer(Serializer):
+    class Meta:
+        model = User
+        fields = ['first_name', 'last_name', 'email', 'password']
+
+    def validate_first_name(self, value) -> str:
+        # Your Code
+        return value
+
+class UserSerializer(ModelSerializer):
+    class Meta:
+        model = User
+        fields = ["first_name", "last_name", "email", "password"]
+
+class UserLoginSerializer(Serializer):
+    class Meta:
+        model = User
+        fields = ['email', 'password']
+
+    def validate_email(self, email: str) -> str:
+        # Your Code
+        # Code pass
+        self.instance = object # User Object
+        return email
+
+    def validate_password(self, password: str) -> str:
+        # Your Code
+        return password
+
+    # Override serializer
+    def to_representation(self, instance: object) -> dict:
+        # Your Code
+        return UserSerializer(instance=instance).data
+```
+
+### Nested Serialization
+
+To handle nested relationships, you can define nested serializers and use them in your main serializer. 
+
+#### Single Nested Object
+
+When dealing with a single nested object, you do not need to specify `many=True`. Here's an example:
+
+```python
+from your_application.serializers import UserSerializer, ShippingAddressSerializer
+
+class UserDetailSerializer(UserSerializer):
+    shipping_address = ShippingAddressSerializer()
+
+    class Meta:
+        model = User
+        fields = ['id', 'first_name', 'last_name', 'email', 'shipping_address']
+
+# Usage
+user = User.query.get(1)
+serializer = UserDetailSerializer(instance=user)
+print(serializer.data)
+```
+
+This will serialize the `shipping_address` field as a dictionary:
+
+```json
+{
+    "id": 1,
+    "first_name": "John",
+    "last_name": "Doe",
+    "email": "john.doe@example.com",
+    "shipping_address": {
+        "street": "123 Main St",
+        "city": "Anytown",
+        "zipcode": "12345"
+    }
+}
+```
+
+#### Multiple Nested Objects
+
+When dealing with multiple nested objects, use `many=True` to return a list of dictionaries. Here's an example:
+
+```python
+from your_application.serializers import UserSerializer, ShippingAddressSerializer
+
+class UserDetailSerializer(UserSerializer):
+    shipping_addresses = ShippingAddressSerializer(many=True)
+
+    class Meta:
+        model = User
+        fields = ['id', 'first_name', 'last_name', 'email', 'shipping_addresses']
+
+# Usage
+user = User.query.get(1)
+serializer = UserDetailSerializer(instance=user)
+print(serializer.data)
+```
+
+This will serialize the `shipping_addresses` field as a list of dictionaries:
+
+```json
+{
+    "id": 1,
+    "first_name": "John",
+    "last_name": "Doe",
+    "email": "john.doe@example.com",
+    "shipping_addresses": [
+        {
+            "street": "123 Main St",
+            "city": "Anytown",
+            "zipcode": "12345"
+        },
+        {
+            "street": "456 Elm St",
+            "city": "Othertown",
+            "zipcode": "67890"
+        }
+    ]
+}
+```
+
+### Integration with Pydantic Models
+
+You can also integrate Pydantic models for additional validation. Here's an example:
+
+```python
+from your_application.serializers import UserSerializer, SerializerError
+from pydantic import BaseModel, EmailStr, ValidationError
+
+class UserPydanticModel(BaseModel):
+    first_name: str
+    last_name: str
+    email: EmailStr
+
+class UserPydanticSerializer(UserSerializer):
+    pydantic_model = UserPydanticModel
+
+    def validate_pydantic(self, data):
+        try:
+            pydantic_instance = self.pydantic_model(**data)
+            return pydantic_instance.model_dump()  # Dump the validated model to dictionary
+        except ValidationError as e:
+            raise SerializerError(e, "Invalid data")
+
+# Usage
+data = {
+    "first_name": "John",
+    "last_name": "Doe",
+    "email": "john.doe@example.com"
+}
+
+serializer = UserPydanticSerializer(data=data)
+if serializer.is_valid():
+    print("Valid data:", serializer.validated_data)
+else:
+    print("Errors:", serializer.errors)
+```
+
+### Updating Existing Instances
+
+The `.save()` method is designed to update an instance if it already exists, rather than creating a new one. If the `instance` attribute is set, `.save()` will call the `.update()` method. If `instance` is `None`, it will call `.create()`.
+
+Here's an example:
+
+```python
+from your_application.serializers import UserSerializer
+from your_application.models import User
+
+# Update an existing user
+user_instance = User.query.get(1)
+data = {
+    "first_name": "Jane",
+    "last_name": "Doe",
+    "email": "jane.doe@example.com"
+}
+
+serializer = UserSerializer(instance=user_instance, data=data)
+if serializer.is_valid():
+    user = serializer.save()
+    print("User updated:", user)
+else:
+    print("Errors:", serializer.errors)
+```
+
+## Custom Serializers
+
+You can create custom serializers by inheriting from `Serializer` or `ModelSerializer`. Here's an example:
+
+```python
+from sqlalchemy_serializer_meta import ModelSerializer
+from your_application.models import CustomModel
+
+class CustomModelSerializer(ModelSerializer):
+    class Meta:
+        model = CustomModel
+        fields = ['id', 'name', 'description']
+
+# Usage
+instance = CustomModel.query.get(1)
+serializer = CustomModelSerializer(instance=instance)
+print(serializer.data)
+```
+
+## Serializer Validated Fields
+
+You can customize your field validation by adding `validate_<field_name>` methods in your `Serializer class`.
+
+Can be used in SQLAlchemy and Flask API
+
+```py
+from sqlalchemy_serializer_meta import Serializer
+from your_application.models import CustomModel
+from your_application.validators import CustomValidator
+from typing import Union
+
+class CustomPydantic(BaseModel):
+    id: str
+    name: str
+    description: EmailStr
+
+class CustomModelSerializer(Serializer):
+    # If not specified the validate_pydantic method won't be called hence no errors will occure
+    pydantic_model: BaseModel = CustomPydantic
+
+    class Meta:
+        model = CustomModel
+        fields = ['id', 'name', 'description']
+
+    # Custom Validation for name
+    def validate_name(self, value):
+        # This will trigger Custome made Validator or pass
+        CustomValidator(SerializerError).validate(value)
+        return value
+
+
+def serialize(data: dict) -> Union[dict, list[dict]]:
+    # To trigger validators you have to initiate .is_valid() method
+    serializer = CustomModelSerializer(data=data)
+
+    try:
+        # Trigger validation
+        if serializer.is_valid():
+            serializer.save()
+            return serializer.data
+        # If validation did not pass custom validation Grab Errors
+        return serializer.errors
+        # if validation did not pass Pydantic Validation
+    except ValidationError as e: # If pydanic model not defined this error will not occure because validate_pydantic wont be called.
+        return e.errors()
+        # other unexpected or unhandled errors.
+    except Exception as e:
+        return e
+
+serialize({'name': 'test', 'description': 'test@test.com',"id":1})
+```
+
+### Reusable Serializer Design with SQLAlchemy and Flask-SQLAlchemy
+
+The design of the `CustomModelSerializer` class in our Flask application leverages the flexibility and robustness of SQLAlchemy and Flask-SQLAlchemy, allowing it to be highly reusable across different projects. This approach ensures that the main views or functions in your API can remain focused on returning data or handling errors, rather than getting bogged down in validation logic.
+
+#### Key Features of the Design:
+
+1. **Modular Validation:**
+    - By using Pydantic for model validation, we ensure that data is consistently validated before it is processed or saved.
+    - Custom validation methods like `validate_name` allow for specific field-level validation rules, making the serializer adaptable to different models and requirements.
+
+2. **Separation of Concerns:**
+    - The serializer handles data validation, deserialization, and serialization, keeping these concerns separate from the view logic.
+    - This separation allows the view functions to focus on API response generation, improving readability and maintainability.
+
+3. **Custom Error Handling:**
+    - The design includes robust error handling, catching validation errors from Pydantic and custom validators, and other exceptions.
+    - This ensures that the API can provide meaningful error messages to the client, improving the user experience and making debugging easier.
+
+4. **Ease of Integration:**
+    - The `CustomModelSerializer` can be easily integrated with Flask routes, as demonstrated in the example.
+    - This flexibility makes it simple to reuse the serializer across different endpoints or even different projects, as long as they use SQLAlchemy and Flask-SQLAlchemy.
+
+#### Example Usage in Flask API:
+
+```py
+from flask import Flask, request, jsonify
+from sqlalchemy_serializer_meta import Serializer
+from your_application.models import CustomModel
+from your_application.validators import CustomValidator
+from pydantic import BaseModel, EmailStr, ValidationError
+from typing import Union
+
+class CustomPydantic(BaseModel):
+    id: str
+    name: str
+    description: EmailStr
+
+class CustomModelSerializer(Serializer):
+    pydantic_model: BaseModel = CustomPydantic
+
+    class Meta:
+        model = CustomModel
+        fields = ['id', 'name', 'description']
+
+    def validate_name(self, value):
+        CustomValidator(SerializerError).validate(value)
+        return value
+
+app = Flask(__name__)
+
+@app.route('/serialize', methods=['POST'])
+def serialize_data():
+    data = request.json
+    serializer = CustomModelSerializer(data=data)
+
+    try:
+        if serializer.is_valid():
+            serializer.save()
+            return jsonify(serializer.data), 201
+        return jsonify(serializer.errors), 400
+    except ValidationError as e:
+        return jsonify(e.errors()), 422
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(debug=True)
+```
+
+#### Benefits for Different Projects:
+
+- **Consistency:** Ensures consistent data validation across various projects, reducing the likelihood of errors and inconsistencies.
+- **Reusability:** The modular design means the same serializer class can be used across different models and endpoints, minimizing duplicate code.
+- **Focus on Business Logic:** By handling validation and serialization within the serializer, the main view functions can focus on business logic and API response handling, making the codebase cleaner and more maintainable.
+
+By adopting this design, you can create scalable, maintainable, and robust APIs that leverage the power of SQLAlchemy and Flask-SQLAlchemy, ensuring that your application remains flexible and adaptable to changing requirements.

sqlalchemy_serializer_meta-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+sqlalchemy_serializer_meta/__init__.py,sha256=R0tgVeUHxXSuV8ET8KTKDKFstS2h6iCaE7JvVMFpmF4,14503
+sqlalchemy_serializer_meta/serializer.py,sha256=lr0MOZmMT5Ynf89oLUJtLKQYrId674xRbfAVdaWb2DY,5782
+sqlalchemy_serializer_meta-0.1.0.dist-info/LICENSE,sha256=c1dx0gfbut5pHGHayRypYfy9dQjP5zGcINW3OvzNIQo,1086
+sqlalchemy_serializer_meta-0.1.0.dist-info/METADATA,sha256=W7COlzr2Qvqlz1P6ZpW2KaXVaFYml-2UYNLyCoAD_8Q,13204
+sqlalchemy_serializer_meta-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sqlalchemy_serializer_meta-0.1.0.dist-info/top_level.txt,sha256=rlJUoEf220tqtRa1uvL41fVE9MrRuenX6nYjyTEAbYM,27
+sqlalchemy_serializer_meta-0.1.0.dist-info/RECORD,,

sqlalchemy_serializer_meta-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sqlalchemy_serializer_meta-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlalchemy_serializer_meta