# 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.
Raw data
{
"_id": null,
"home_page": "https://github.com/Wehda23/sqlalchemy_serializer_meta",
"name": "sqlalchemy-serializer-meta",
"maintainer": null,
"docs_url": null,
"requires_python": null,
"maintainer_email": null,
"keywords": "sqlalchemy serializer pydantic flask",
"author": "Waheed Khaled Elhariri",
"author_email": "waheedkhaled95@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/26/d2/63a7d9619daa497c0a873582d1407574ec213364b419c0d9041a353a518d/sqlalchemy_serializer_meta-0.1.0.tar.gz",
"platform": null,
"description": "# Serializer Module for Flask Application\r\n\r\nThis 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.\r\n\r\n## Installation\r\n\r\nTo use the serializers in your project, simply include the necessary files in your application directory.\r\n\r\n## Usage\r\n\r\nCan be used to Serialize SQLAlchemy Model or Flask-SQLAlchemy model.\r\n\r\n### Basic Usage\r\n\r\nHere's an example of how to use the `UserRegisterSerializer` to validate and create a new user:\r\n\r\n```python\r\nfrom your_application.serializers import UserRegisterSerializer\r\nfrom your_application.models import User\r\n\r\ndata = {\r\n \"first_name\": \"John\",\r\n \"last_name\": \"Doe\",\r\n \"email\": \"john.doe@example.com\",\r\n \"password\": \"securepassword123\"\r\n}\r\n\r\nserializer = UserRegisterSerializer(data=data)\r\nif serializer.is_valid():\r\n user = serializer.save()\r\n print(\"User created:\", user)\r\nelse:\r\n print(\"Errors:\", serializer.errors)\r\n```\r\n\r\nIn this example your custom serializer module/package\r\n\r\n```py\r\nfrom sqlalchemy_serializer_meta import Serializer, ModelSerializer, SerializerError\r\nfrom your_application.models import User\r\n\r\nclass UserRegisterSerializer(Serializer):\r\n class Meta:\r\n model = User\r\n fields = ['first_name', 'last_name', 'email', 'password']\r\n\r\n def validate_first_name(self, value) -> str:\r\n # Your Code\r\n return value\r\n\r\nclass UserSerializer(ModelSerializer):\r\n class Meta:\r\n model = User\r\n fields = [\"first_name\", \"last_name\", \"email\", \"password\"]\r\n\r\nclass UserLoginSerializer(Serializer):\r\n class Meta:\r\n model = User\r\n fields = ['email', 'password']\r\n\r\n def validate_email(self, email: str) -> str:\r\n # Your Code\r\n # Code pass\r\n self.instance = object # User Object\r\n return email\r\n\r\n def validate_password(self, password: str) -> str:\r\n # Your Code\r\n return password\r\n\r\n # Override serializer\r\n def to_representation(self, instance: object) -> dict:\r\n # Your Code\r\n return UserSerializer(instance=instance).data\r\n```\r\n\r\n### Nested Serialization\r\n\r\nTo handle nested relationships, you can define nested serializers and use them in your main serializer. \r\n\r\n#### Single Nested Object\r\n\r\nWhen dealing with a single nested object, you do not need to specify `many=True`. Here's an example:\r\n\r\n```python\r\nfrom your_application.serializers import UserSerializer, ShippingAddressSerializer\r\n\r\nclass UserDetailSerializer(UserSerializer):\r\n shipping_address = ShippingAddressSerializer()\r\n\r\n class Meta:\r\n model = User\r\n fields = ['id', 'first_name', 'last_name', 'email', 'shipping_address']\r\n\r\n# Usage\r\nuser = User.query.get(1)\r\nserializer = UserDetailSerializer(instance=user)\r\nprint(serializer.data)\r\n```\r\n\r\nThis will serialize the `shipping_address` field as a dictionary:\r\n\r\n```json\r\n{\r\n \"id\": 1,\r\n \"first_name\": \"John\",\r\n \"last_name\": \"Doe\",\r\n \"email\": \"john.doe@example.com\",\r\n \"shipping_address\": {\r\n \"street\": \"123 Main St\",\r\n \"city\": \"Anytown\",\r\n \"zipcode\": \"12345\"\r\n }\r\n}\r\n```\r\n\r\n#### Multiple Nested Objects\r\n\r\nWhen dealing with multiple nested objects, use `many=True` to return a list of dictionaries. Here's an example:\r\n\r\n```python\r\nfrom your_application.serializers import UserSerializer, ShippingAddressSerializer\r\n\r\nclass UserDetailSerializer(UserSerializer):\r\n shipping_addresses = ShippingAddressSerializer(many=True)\r\n\r\n class Meta:\r\n model = User\r\n fields = ['id', 'first_name', 'last_name', 'email', 'shipping_addresses']\r\n\r\n# Usage\r\nuser = User.query.get(1)\r\nserializer = UserDetailSerializer(instance=user)\r\nprint(serializer.data)\r\n```\r\n\r\nThis will serialize the `shipping_addresses` field as a list of dictionaries:\r\n\r\n```json\r\n{\r\n \"id\": 1,\r\n \"first_name\": \"John\",\r\n \"last_name\": \"Doe\",\r\n \"email\": \"john.doe@example.com\",\r\n \"shipping_addresses\": [\r\n {\r\n \"street\": \"123 Main St\",\r\n \"city\": \"Anytown\",\r\n \"zipcode\": \"12345\"\r\n },\r\n {\r\n \"street\": \"456 Elm St\",\r\n \"city\": \"Othertown\",\r\n \"zipcode\": \"67890\"\r\n }\r\n ]\r\n}\r\n```\r\n\r\n### Integration with Pydantic Models\r\n\r\nYou can also integrate Pydantic models for additional validation. Here's an example:\r\n\r\n```python\r\nfrom your_application.serializers import UserSerializer, SerializerError\r\nfrom pydantic import BaseModel, EmailStr, ValidationError\r\n\r\nclass UserPydanticModel(BaseModel):\r\n first_name: str\r\n last_name: str\r\n email: EmailStr\r\n\r\nclass UserPydanticSerializer(UserSerializer):\r\n pydantic_model = UserPydanticModel\r\n\r\n def validate_pydantic(self, data):\r\n try:\r\n pydantic_instance = self.pydantic_model(**data)\r\n return pydantic_instance.model_dump() # Dump the validated model to dictionary\r\n except ValidationError as e:\r\n raise SerializerError(e, \"Invalid data\")\r\n\r\n# Usage\r\ndata = {\r\n \"first_name\": \"John\",\r\n \"last_name\": \"Doe\",\r\n \"email\": \"john.doe@example.com\"\r\n}\r\n\r\nserializer = UserPydanticSerializer(data=data)\r\nif serializer.is_valid():\r\n print(\"Valid data:\", serializer.validated_data)\r\nelse:\r\n print(\"Errors:\", serializer.errors)\r\n```\r\n\r\n### Updating Existing Instances\r\n\r\nThe `.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()`.\r\n\r\nHere's an example:\r\n\r\n```python\r\nfrom your_application.serializers import UserSerializer\r\nfrom your_application.models import User\r\n\r\n# Update an existing user\r\nuser_instance = User.query.get(1)\r\ndata = {\r\n \"first_name\": \"Jane\",\r\n \"last_name\": \"Doe\",\r\n \"email\": \"jane.doe@example.com\"\r\n}\r\n\r\nserializer = UserSerializer(instance=user_instance, data=data)\r\nif serializer.is_valid():\r\n user = serializer.save()\r\n print(\"User updated:\", user)\r\nelse:\r\n print(\"Errors:\", serializer.errors)\r\n```\r\n\r\n## Custom Serializers\r\n\r\nYou can create custom serializers by inheriting from `Serializer` or `ModelSerializer`. Here's an example:\r\n\r\n```python\r\nfrom sqlalchemy_serializer_meta import ModelSerializer\r\nfrom your_application.models import CustomModel\r\n\r\nclass CustomModelSerializer(ModelSerializer):\r\n class Meta:\r\n model = CustomModel\r\n fields = ['id', 'name', 'description']\r\n\r\n# Usage\r\ninstance = CustomModel.query.get(1)\r\nserializer = CustomModelSerializer(instance=instance)\r\nprint(serializer.data)\r\n```\r\n\r\n## Serializer Validated Fields\r\n\r\nYou can customize your field validation by adding `validate_<field_name>` methods in your `Serializer class`.\r\n\r\nCan be used in SQLAlchemy and Flask API\r\n\r\n```py\r\nfrom sqlalchemy_serializer_meta import Serializer\r\nfrom your_application.models import CustomModel\r\nfrom your_application.validators import CustomValidator\r\nfrom typing import Union\r\n\r\nclass CustomPydantic(BaseModel):\r\n id: str\r\n name: str\r\n description: EmailStr\r\n\r\nclass CustomModelSerializer(Serializer):\r\n # If not specified the validate_pydantic method won't be called hence no errors will occure\r\n pydantic_model: BaseModel = CustomPydantic\r\n\r\n class Meta:\r\n model = CustomModel\r\n fields = ['id', 'name', 'description']\r\n\r\n # Custom Validation for name\r\n def validate_name(self, value):\r\n # This will trigger Custome made Validator or pass\r\n CustomValidator(SerializerError).validate(value)\r\n return value\r\n\r\n\r\ndef serialize(data: dict) -> Union[dict, list[dict]]:\r\n # To trigger validators you have to initiate .is_valid() method\r\n serializer = CustomModelSerializer(data=data)\r\n\r\n try:\r\n # Trigger validation\r\n if serializer.is_valid():\r\n serializer.save()\r\n return serializer.data\r\n # If validation did not pass custom validation Grab Errors\r\n return serializer.errors\r\n # if validation did not pass Pydantic Validation\r\n except ValidationError as e: # If pydanic model not defined this error will not occure because validate_pydantic wont be called.\r\n return e.errors()\r\n # other unexpected or unhandled errors.\r\n except Exception as e:\r\n return e\r\n\r\nserialize({'name': 'test', 'description': 'test@test.com',\"id\":1})\r\n```\r\n\r\n### Reusable Serializer Design with SQLAlchemy and Flask-SQLAlchemy\r\n\r\nThe 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.\r\n\r\n#### Key Features of the Design:\r\n\r\n1. **Modular Validation:**\r\n - By using Pydantic for model validation, we ensure that data is consistently validated before it is processed or saved.\r\n - Custom validation methods like `validate_name` allow for specific field-level validation rules, making the serializer adaptable to different models and requirements.\r\n\r\n2. **Separation of Concerns:**\r\n - The serializer handles data validation, deserialization, and serialization, keeping these concerns separate from the view logic.\r\n - This separation allows the view functions to focus on API response generation, improving readability and maintainability.\r\n\r\n3. **Custom Error Handling:**\r\n - The design includes robust error handling, catching validation errors from Pydantic and custom validators, and other exceptions.\r\n - This ensures that the API can provide meaningful error messages to the client, improving the user experience and making debugging easier.\r\n\r\n4. **Ease of Integration:**\r\n - The `CustomModelSerializer` can be easily integrated with Flask routes, as demonstrated in the example.\r\n - 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.\r\n\r\n#### Example Usage in Flask API:\r\n\r\n```py\r\nfrom flask import Flask, request, jsonify\r\nfrom sqlalchemy_serializer_meta import Serializer\r\nfrom your_application.models import CustomModel\r\nfrom your_application.validators import CustomValidator\r\nfrom pydantic import BaseModel, EmailStr, ValidationError\r\nfrom typing import Union\r\n\r\nclass CustomPydantic(BaseModel):\r\n id: str\r\n name: str\r\n description: EmailStr\r\n\r\nclass CustomModelSerializer(Serializer):\r\n pydantic_model: BaseModel = CustomPydantic\r\n\r\n class Meta:\r\n model = CustomModel\r\n fields = ['id', 'name', 'description']\r\n\r\n def validate_name(self, value):\r\n CustomValidator(SerializerError).validate(value)\r\n return value\r\n\r\napp = Flask(__name__)\r\n\r\n@app.route('/serialize', methods=['POST'])\r\ndef serialize_data():\r\n data = request.json\r\n serializer = CustomModelSerializer(data=data)\r\n\r\n try:\r\n if serializer.is_valid():\r\n serializer.save()\r\n return jsonify(serializer.data), 201\r\n return jsonify(serializer.errors), 400\r\n except ValidationError as e:\r\n return jsonify(e.errors()), 422\r\n except Exception as e:\r\n return jsonify({\"error\": str(e)}), 500\r\n\r\nif __name__ == '__main__':\r\n app.run(debug=True)\r\n```\r\n\r\n#### Benefits for Different Projects:\r\n\r\n- **Consistency:** Ensures consistent data validation across various projects, reducing the likelihood of errors and inconsistencies.\r\n- **Reusability:** The modular design means the same serializer class can be used across different models and endpoints, minimizing duplicate code.\r\n- **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.\r\n\r\nBy 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.\r\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "A simple serializer for SQLAlchemy models and Flask Models",
"version": "0.1.0",
"project_urls": {
"Homepage": "https://github.com/Wehda23/sqlalchemy_serializer_meta"
},
"split_keywords": [
"sqlalchemy",
"serializer",
"pydantic",
"flask"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "1658cdb87fffbb6786ce055be6505e32afaca0025f976f6624eaa0c8556c392c",
"md5": "e7ea3cf49f007791a4978c7962702a93",
"sha256": "cb5c5b876cbf4b3a6db1ca1a1544edeffed86045e7ddd93c48667b5a7b44b7a7"
},
"downloads": -1,
"filename": "sqlalchemy_serializer_meta-0.1.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "e7ea3cf49f007791a4978c7962702a93",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": null,
"size": 10521,
"upload_time": "2024-07-07T04:54:33",
"upload_time_iso_8601": "2024-07-07T04:54:33.756031Z",
"url": "https://files.pythonhosted.org/packages/16/58/cdb87fffbb6786ce055be6505e32afaca0025f976f6624eaa0c8556c392c/sqlalchemy_serializer_meta-0.1.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "26d263a7d9619daa497c0a873582d1407574ec213364b419c0d9041a353a518d",
"md5": "645cf6544456b4fe1dd1aa0f4c2a7ffc",
"sha256": "d88ff4ef50b3d4c3cb5c88ad6affa029082f324c74f24a2f89e55272edfdde59"
},
"downloads": -1,
"filename": "sqlalchemy_serializer_meta-0.1.0.tar.gz",
"has_sig": false,
"md5_digest": "645cf6544456b4fe1dd1aa0f4c2a7ffc",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 12843,
"upload_time": "2024-07-07T04:54:35",
"upload_time_iso_8601": "2024-07-07T04:54:35.540891Z",
"url": "https://files.pythonhosted.org/packages/26/d2/63a7d9619daa497c0a873582d1407574ec213364b419c0d9041a353a518d/sqlalchemy_serializer_meta-0.1.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-07-07 04:54:35",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "Wehda23",
"github_project": "sqlalchemy_serializer_meta",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "sqlalchemy-serializer-meta"
}
JSON
