| Name | drf-pydantic JSON |
| Version |
2.8.0
JSON |
| download |
| home_page | None |
| Summary | Use pydantic with the Django REST framework |
| upload_time | 2025-07-17 06:34:59 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.9 |
| license | None |
| keywords |
api
django
drf
pydantic
rest
typing
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
<p align="center">
<a href="https://github.com/georgebv/drf-pydantic/actions/workflows/test.yml" target="_blank">
<img src="https://github.com/georgebv/drf-pydantic/actions/workflows/test.yml/badge.svg?event=pull_request" alt="Test Status">
</a>
<a href="https://codecov.io/gh/georgebv/drf-pydantic" target="_blank">
<img src="https://codecov.io/gh/georgebv/drf-pydantic/branch/main/graph/badge.svg?token=GN9rxzIFMc" alt="Test Coverage"/>
</a>
<a href="https://badge.fury.io/py/drf-pydantic" target="_blank">
<img src="https://badge.fury.io/py/drf-pydantic.svg" alt="PyPI version" height="20">
</a>
</p>
<p align="center">
<i>
Use pydantic with Django REST framework
</i>
</p>
- [Introduction](#introduction)
- [Performance](#performance)
- [Installation](#installation)
- [Usage](#usage)
- [General](#general)
- [Pydantic Validation](#pydantic-validation)
- [Updating Field Values](#updating-field-values)
- [Validation Errors](#validation-errors)
- [Existing Models](#existing-models)
- [Nested Models](#nested-models)
- [Manual Serializer Configuration](#manual-serializer-configuration)
- [Per-Field Configuration](#per-field-configuration)
- [Custom Serializer](#custom-serializer)
- [Additional Properties](#additional-properties)
# Introduction
[Pydantic](https://pydantic-docs.helpmanual.io) is a Python library used to perform
data serialization and validation.
[Django REST framework](https://www.django-rest-framework.org) is a framework built
on top of [Django](https://www.djangoproject.com/) used to write REST APIs.
If you develop DRF APIs and rely on pydantic for data validation/(de)serialization,
then `drf-pydantic` is for you :heart_eyes:.
> [!NOTE]
> The latest version of `drf_pydantic` only supports `pydantic` v2.
> Support for `pydantic` v1 is available in the `1.*` version.
## Performance
Translation between `pydantic` models and `DRF` serializers is done during class
creation (e.g., when you first import the model). This means there will be
zero runtime impact when using `drf_pydantic` in your application.
> [!NOTE]
> There will be a minor penalty if `validate_pydantic` is set to `True` due to pydantic
> model validation. This is minimal compared to an already-present overhead of DRF
> itself because pydantic runs its validation in rust while DRF is pure python.
# Installation
```shell
pip install drf-pydantic
```
# Usage
## General
Use `drf_pydantic.BaseModel` instead of `pydantic.BaseModel` when creating your models:
```python
from drf_pydantic import BaseModel
class MyModel(BaseModel):
name: str
addresses: list[str]
```
`MyModel.drf_serializer` is equivalent to the following DRF Serializer class:
```python
class MyModelSerializer:
name = CharField(allow_null=False, required=True)
addresses = ListField(
allow_empty=True,
allow_null=False,
child=CharField(allow_null=False),
required=True,
)
```
Whenever you need a DRF serializer, you can get it from the model like this:
```python
my_value = MyModel.drf_serializer(data={"name": "Van", "addresses": ["Gym"]})
my_value.is_valid(raise_exception=True)
```
> [!NOTE]
> Models created using `drf_pydantic` are fully identical to those created by
> `pydantic`. The only change is the addition of the `drf_serializer`
> and `drf_config` attributes.
## Pydantic Validation
By default, the generated serializer only uses DRF's validation; however, pydantic
models are often more complex and their numerous validation rules cannot be fully
translated to DRF. To enable pydantic validators to run whenever the generated
DRF serializer validates its data (e.g., via `.is_valid()`),
set `"validate_pydantic": True` within the `drf_config` property of your model:
```python
from drf_pydantic import BaseModel
class MyModel(BaseModel):
name: str
addresses: list[str]
drf_config = {"validate_pydantic": True}
my_serializer = MyModel.drf_serializer(data={"name": "Van", "addresses": []})
my_serializer.is_valid() # this will also validate MyModel
```
With this option enabled, every time you validate data using your DRF serializer,
the parent pydantic model is also validated. If it fails, its
`ValidationError` exception will be wrapped within DRF's `ValidationError`.
Per-field and non-field (object-level) errors are wrapped
similarly to how DRF handles them. This ensures your complex pydantic validation logic
is properly evaluated wherever a DRF serializer is used.
> [!NOTE]
> All `drf_config` values are properly inherited by child classes,
> just like pydantic's `model_config`.
### Updating Field Values
By default, `drf_pydantic` updates values in the DRF serializer
with those from the validated pydantic model:
```python
from drf_pydantic import BaseModel
class MyModel(BaseModel):
name: str
addresses: list[str]
@pydantic.field_validator("name")
@classmethod
def validate_name(cls, v):
assert isinstance(v, str)
return v.strip().title()
drf_config = {"validate_pydantic": True}
my_serializer = MyModel.drf_serializer(data={"name": "van herrington", "addresses": []})
my_serializer.is_valid()
print(my_serializer.validated_data) # {"name": "Van Herrington", "addresses": []}
```
This is handy when you dynamically modify field values within your
pydantic validators. You can disable this behavior by setting
`"backpopulate_after_validation": False`:
```python
class MyModel(BaseModel):
...
drf_config = {"validate_pydantic": True, "backpopulate_after_validation": False}
```
### Validation Errors
By default, pydantic's `ValidationError` is wrapped within DRF's `ValidationError`.
If you want to raise pydantic's `ValidationError` directly,
set `"validation_error": "pydantic"` in the `drf_config` property of your model:
```python
import pydantic
from drf_pydantic import BaseModel
class MyModel(BaseModel):
name: str
addresses: list[str]
@pydantic.field_validator("name")
@classmethod
def validate_name(cls, v):
assert isinstance(v, str)
if v != "Billy":
raise ValueError("Wrong door")
return v
drf_config = {"validate_pydantic": True, "validation_error": "pydantic"}
my_serializer = MyModel.drf_serializer(data={"name": "Van", "addresses": []})
my_serializer.is_valid() # this will raise pydantic.ValidationError
```
> [!NOTE]
> When a model is invalid from both DRF's and pydantic's perspectives and
> exceptions are enabled (`.is_valid(raise_exception=True)`),
> DRF's `ValidationError` will be raised regardless of the `validation_error` setting,
> because DRF validation always runs first.
> [!CAUTION]
> Setting `validation_error` to `pydantic` has side effects:
>
> 1. It may break your views because they expect DRF's `ValidationError`.
> 2. Calling `.is_valid()` will always raise `pydantic.ValidationError` if the data
> is invalid, even without setting `.is_valid(raise_exception=True)`.
## Existing Models
If you have an existing code base and want to add the `drf_serializer`
attribute only to some of your models, you can extend your existing pydantic models
by adding `drf_pydantic.BaseModel` as a parent class to the models you want to extend.
Your existing pydantic models:
```python
from pydantic import BaseModel
class Pet(BaseModel):
name: str
class Dog(Pet):
breed: str
```
Update your `Dog` model and get serializer via the `drf_serializer`:
```python
from drf_pydantic import BaseModel as DRFBaseModel
from pydantic import BaseModel
class Pet(BaseModel):
name: str
class Dog(DRFBaseModel, Pet):
breed: str
Dog.drf_serializer
```
> [!IMPORTANT]
> Inheritance order is important: `drf_pydantic.BaseModel` must always come before
> `pydantic.BaseModel`.
## Nested Models
If you have nested models and want to generate a serializer for only one of them,
you don't need to update all models. Simply update the model you need,
and `drf_pydantic` will automatically generate serializers
for all standard nested pydantic models:
```python
from drf_pydantic import BaseModel as DRFBaseModel
from pydantic import BaseModel
class Apartment(BaseModel):
floor: int
tenant: str
class Building(BaseModel):
address: str
apartments: list[Apartment]
class Block(DRFBaseModel):
buildings: list[Building]
Block.drf_serializer
```
## Manual Serializer Configuration
If `drf_pydantic` doesn't generate the serializer you need,
you can configure the DRF serializer fields for each pydantic field manually,
or create a custom serializer for the model altogether.
> [!IMPORTANT]
> When manually configuring the serializer, you are responsible for setting all
> properties of the fields (e.g., `allow_null`, `required`, `default`, etc.).
> `drf_pydantic` does not perform any introspection for fields that are manually
> configured or for any fields if a custom serializer is used.
### Per-Field Configuration
```python
from typing import Annotated
from drf_pydantic import BaseModel
from rest_framework.serializers import IntegerField
class Person(BaseModel):
name: str
age: Annotated[float, IntegerField(min_value=0, max_value=100)]
```
### Custom Serializer
In the example below, `Person` will use `MyCustomSerializer` as its DRF serializer.
`Employee` will have its own serializer generated by `drf_pydantic` since it doesn't
inherit a user-defined `drf_serializer` attribute.
`Company` will use `Person`'s manually defined serializer for its `ceo` field.
```python
from drf_pydantic import BaseModel, DrfPydanticSerializer
from rest_framework.serializers import CharField, IntegerField
class MyCustomSerializer(DrfPydanticSerializer):
name = CharField(allow_null=False, required=True)
age = IntegerField(allow_null=False, required=True)
class Person(BaseModel):
name: str
age: float
drf_serializer = MyCustomSerializer
class Employee(Person):
salary: float
class Company(BaseModel):
ceo: Person
```
> [!IMPORTANT]
> Added in version `v2.6.0`
>
> Manual `drf_serializer` must have base class of `DrfPydanticSerializer`
> in order for [Pydantic Validation](#pydantic-validation) to work properly.
> You can still use standard `Serializer` from `rest_framework`, but automatic
> pydantic model validation will not work consistently and you will get a warning.
# Additional Properties
Additional field properties are mapped as follows (`pydantic` -> `DRF`):
- `description` -> `help_text`
- `title` -> `label`
- `StringConstraints` -> `min_length` and `max_length`
- `pattern` -> Uses the specialized `RegexField` serializer field
- `max_digits` and `decimal_places` are carried over
(used for `Decimal` types, with the current decimal context precision)
- `ge` / `gt` -> `min_value` (only for numeric types)
- `le` / `lt` -> `max_value` (only for numeric types)
Raw data
{
"_id": null,
"home_page": null,
"name": "drf-pydantic",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.9",
"maintainer_email": null,
"keywords": "api, django, drf, pydantic, rest, typing",
"author": null,
"author_email": "George Bocharov <bocharovgeorgii@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/09/cc/10da0dfb667a40b92e4f6bce037b121b5911bc67dc1caa2f249d7a633bad/drf_pydantic-2.8.0.tar.gz",
"platform": null,
"description": "<p align=\"center\">\n <a href=\"https://github.com/georgebv/drf-pydantic/actions/workflows/test.yml\" target=\"_blank\">\n <img src=\"https://github.com/georgebv/drf-pydantic/actions/workflows/test.yml/badge.svg?event=pull_request\" alt=\"Test Status\">\n </a>\n <a href=\"https://codecov.io/gh/georgebv/drf-pydantic\" target=\"_blank\">\n <img src=\"https://codecov.io/gh/georgebv/drf-pydantic/branch/main/graph/badge.svg?token=GN9rxzIFMc\" alt=\"Test Coverage\"/>\n </a>\n <a href=\"https://badge.fury.io/py/drf-pydantic\" target=\"_blank\">\n <img src=\"https://badge.fury.io/py/drf-pydantic.svg\" alt=\"PyPI version\" height=\"20\">\n </a>\n</p>\n\n<p align=\"center\">\n <i>\n Use pydantic with Django REST framework\n </i>\n</p>\n\n- [Introduction](#introduction)\n - [Performance](#performance)\n- [Installation](#installation)\n- [Usage](#usage)\n - [General](#general)\n - [Pydantic Validation](#pydantic-validation)\n - [Updating Field Values](#updating-field-values)\n - [Validation Errors](#validation-errors)\n - [Existing Models](#existing-models)\n - [Nested Models](#nested-models)\n - [Manual Serializer Configuration](#manual-serializer-configuration)\n - [Per-Field Configuration](#per-field-configuration)\n - [Custom Serializer](#custom-serializer)\n- [Additional Properties](#additional-properties)\n\n# Introduction\n\n[Pydantic](https://pydantic-docs.helpmanual.io) is a Python library used to perform\ndata serialization and validation.\n\n[Django REST framework](https://www.django-rest-framework.org) is a framework built\non top of [Django](https://www.djangoproject.com/) used to write REST APIs.\n\nIf you develop DRF APIs and rely on pydantic for data validation/(de)serialization,\nthen `drf-pydantic` is for you :heart_eyes:.\n\n> [!NOTE]\n> The latest version of `drf_pydantic` only supports `pydantic` v2.\n> Support for `pydantic` v1 is available in the `1.*` version.\n\n## Performance\n\nTranslation between `pydantic` models and `DRF` serializers is done during class\ncreation (e.g., when you first import the model). This means there will be\nzero runtime impact when using `drf_pydantic` in your application.\n\n> [!NOTE]\n> There will be a minor penalty if `validate_pydantic` is set to `True` due to pydantic\n> model validation. This is minimal compared to an already-present overhead of DRF\n> itself because pydantic runs its validation in rust while DRF is pure python.\n\n# Installation\n\n```shell\npip install drf-pydantic\n```\n\n# Usage\n\n## General\n\nUse `drf_pydantic.BaseModel` instead of `pydantic.BaseModel` when creating your models:\n\n```python\nfrom drf_pydantic import BaseModel\n\nclass MyModel(BaseModel):\n name: str\n addresses: list[str]\n```\n\n`MyModel.drf_serializer` is equivalent to the following DRF Serializer class:\n\n```python\nclass MyModelSerializer:\n name = CharField(allow_null=False, required=True)\n addresses = ListField(\n allow_empty=True,\n allow_null=False,\n child=CharField(allow_null=False),\n required=True,\n )\n```\n\nWhenever you need a DRF serializer, you can get it from the model like this:\n\n```python\nmy_value = MyModel.drf_serializer(data={\"name\": \"Van\", \"addresses\": [\"Gym\"]})\nmy_value.is_valid(raise_exception=True)\n```\n\n> [!NOTE]\n> Models created using `drf_pydantic` are fully identical to those created by\n> `pydantic`. The only change is the addition of the `drf_serializer`\n> and `drf_config` attributes.\n\n## Pydantic Validation\n\nBy default, the generated serializer only uses DRF's validation; however, pydantic\nmodels are often more complex and their numerous validation rules cannot be fully\ntranslated to DRF. To enable pydantic validators to run whenever the generated\nDRF serializer validates its data (e.g., via `.is_valid()`),\nset `\"validate_pydantic\": True` within the `drf_config` property of your model:\n\n```python\nfrom drf_pydantic import BaseModel\n\nclass MyModel(BaseModel):\n name: str\n addresses: list[str]\n\n drf_config = {\"validate_pydantic\": True}\n\n\nmy_serializer = MyModel.drf_serializer(data={\"name\": \"Van\", \"addresses\": []})\nmy_serializer.is_valid() # this will also validate MyModel\n```\n\nWith this option enabled, every time you validate data using your DRF serializer,\nthe parent pydantic model is also validated. If it fails, its\n`ValidationError` exception will be wrapped within DRF's `ValidationError`.\nPer-field and non-field (object-level) errors are wrapped\nsimilarly to how DRF handles them. This ensures your complex pydantic validation logic\nis properly evaluated wherever a DRF serializer is used.\n\n> [!NOTE]\n> All `drf_config` values are properly inherited by child classes,\n> just like pydantic's `model_config`.\n\n### Updating Field Values\n\nBy default, `drf_pydantic` updates values in the DRF serializer\nwith those from the validated pydantic model:\n\n```python\nfrom drf_pydantic import BaseModel\n\nclass MyModel(BaseModel):\n name: str\n addresses: list[str]\n\n @pydantic.field_validator(\"name\")\n @classmethod\n def validate_name(cls, v):\n assert isinstance(v, str)\n return v.strip().title()\n\n drf_config = {\"validate_pydantic\": True}\n\n\nmy_serializer = MyModel.drf_serializer(data={\"name\": \"van herrington\", \"addresses\": []})\nmy_serializer.is_valid()\nprint(my_serializer.validated_data) # {\"name\": \"Van Herrington\", \"addresses\": []}\n```\n\nThis is handy when you dynamically modify field values within your\npydantic validators. You can disable this behavior by setting\n`\"backpopulate_after_validation\": False`:\n\n```python\nclass MyModel(BaseModel):\n ...\n\n drf_config = {\"validate_pydantic\": True, \"backpopulate_after_validation\": False}\n```\n\n### Validation Errors\n\nBy default, pydantic's `ValidationError` is wrapped within DRF's `ValidationError`.\nIf you want to raise pydantic's `ValidationError` directly,\nset `\"validation_error\": \"pydantic\"` in the `drf_config` property of your model:\n\n```python\nimport pydantic\n\nfrom drf_pydantic import BaseModel\n\nclass MyModel(BaseModel):\n name: str\n addresses: list[str]\n\n @pydantic.field_validator(\"name\")\n @classmethod\n def validate_name(cls, v):\n assert isinstance(v, str)\n if v != \"Billy\":\n raise ValueError(\"Wrong door\")\n return v\n\n drf_config = {\"validate_pydantic\": True, \"validation_error\": \"pydantic\"}\n\n\nmy_serializer = MyModel.drf_serializer(data={\"name\": \"Van\", \"addresses\": []})\nmy_serializer.is_valid() # this will raise pydantic.ValidationError\n```\n\n> [!NOTE]\n> When a model is invalid from both DRF's and pydantic's perspectives and\n> exceptions are enabled (`.is_valid(raise_exception=True)`),\n> DRF's `ValidationError` will be raised regardless of the `validation_error` setting,\n> because DRF validation always runs first.\n\n> [!CAUTION]\n> Setting `validation_error` to `pydantic` has side effects:\n>\n> 1. It may break your views because they expect DRF's `ValidationError`.\n> 2. Calling `.is_valid()` will always raise `pydantic.ValidationError` if the data\n> is invalid, even without setting `.is_valid(raise_exception=True)`.\n\n## Existing Models\n\nIf you have an existing code base and want to add the `drf_serializer`\nattribute only to some of your models, you can extend your existing pydantic models\nby adding `drf_pydantic.BaseModel` as a parent class to the models you want to extend.\n\nYour existing pydantic models:\n\n```python\nfrom pydantic import BaseModel\n\nclass Pet(BaseModel):\n name: str\n\nclass Dog(Pet):\n breed: str\n```\n\nUpdate your `Dog` model and get serializer via the `drf_serializer`:\n\n```python\nfrom drf_pydantic import BaseModel as DRFBaseModel\nfrom pydantic import BaseModel\n\nclass Pet(BaseModel):\n name: str\n\nclass Dog(DRFBaseModel, Pet):\n breed: str\n\nDog.drf_serializer\n```\n\n> [!IMPORTANT]\n> Inheritance order is important: `drf_pydantic.BaseModel` must always come before\n> `pydantic.BaseModel`.\n\n## Nested Models\n\nIf you have nested models and want to generate a serializer for only one of them,\nyou don't need to update all models. Simply update the model you need,\nand `drf_pydantic` will automatically generate serializers\nfor all standard nested pydantic models:\n\n```python\nfrom drf_pydantic import BaseModel as DRFBaseModel\nfrom pydantic import BaseModel\n\nclass Apartment(BaseModel):\n floor: int\n tenant: str\n\nclass Building(BaseModel):\n address: str\n apartments: list[Apartment]\n\nclass Block(DRFBaseModel):\n buildings: list[Building]\n\nBlock.drf_serializer\n```\n\n## Manual Serializer Configuration\n\nIf `drf_pydantic` doesn't generate the serializer you need,\nyou can configure the DRF serializer fields for each pydantic field manually,\nor create a custom serializer for the model altogether.\n\n> [!IMPORTANT]\n> When manually configuring the serializer, you are responsible for setting all\n> properties of the fields (e.g., `allow_null`, `required`, `default`, etc.).\n> `drf_pydantic` does not perform any introspection for fields that are manually\n> configured or for any fields if a custom serializer is used.\n\n### Per-Field Configuration\n\n```python\nfrom typing import Annotated\n\nfrom drf_pydantic import BaseModel\nfrom rest_framework.serializers import IntegerField\n\n\nclass Person(BaseModel):\n name: str\n age: Annotated[float, IntegerField(min_value=0, max_value=100)]\n```\n\n### Custom Serializer\n\nIn the example below, `Person` will use `MyCustomSerializer` as its DRF serializer.\n`Employee` will have its own serializer generated by `drf_pydantic` since it doesn't\ninherit a user-defined `drf_serializer` attribute.\n`Company` will use `Person`'s manually defined serializer for its `ceo` field.\n\n```python\nfrom drf_pydantic import BaseModel, DrfPydanticSerializer\nfrom rest_framework.serializers import CharField, IntegerField\n\n\nclass MyCustomSerializer(DrfPydanticSerializer):\n name = CharField(allow_null=False, required=True)\n age = IntegerField(allow_null=False, required=True)\n\n\nclass Person(BaseModel):\n name: str\n age: float\n\n drf_serializer = MyCustomSerializer\n\n\nclass Employee(Person):\n salary: float\n\n\nclass Company(BaseModel):\n ceo: Person\n```\n\n> [!IMPORTANT]\n> Added in version `v2.6.0`\n>\n> Manual `drf_serializer` must have base class of `DrfPydanticSerializer`\n> in order for [Pydantic Validation](#pydantic-validation) to work properly.\n> You can still use standard `Serializer` from `rest_framework`, but automatic\n> pydantic model validation will not work consistently and you will get a warning.\n\n# Additional Properties\n\nAdditional field properties are mapped as follows (`pydantic` -> `DRF`):\n\n- `description` -> `help_text`\n- `title` -> `label`\n- `StringConstraints` -> `min_length` and `max_length`\n- `pattern` -> Uses the specialized `RegexField` serializer field\n- `max_digits` and `decimal_places` are carried over\n (used for `Decimal` types, with the current decimal context precision)\n- `ge` / `gt` -> `min_value` (only for numeric types)\n- `le` / `lt` -> `max_value` (only for numeric types)\n",
"bugtrack_url": null,
"license": null,
"summary": "Use pydantic with the Django REST framework",
"version": "2.8.0",
"project_urls": {
"github": "https://github.com/georgebv/drf-pydantic",
"homepage": "https://github.com/georgebv/drf-pydantic"
},
"split_keywords": [
"api",
" django",
" drf",
" pydantic",
" rest",
" typing"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "53243d0e22356100eda57d8ef32c25f98c87d9ea0991ba7e7dbd7b71d5eaa2b7",
"md5": "d4724f3da04313d478e0c4b766af1b03",
"sha256": "99898da4a9acc24d7298ed5613cd4115156607be3aa39d5dfcde0be2045f5bff"
},
"downloads": -1,
"filename": "drf_pydantic-2.8.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "d4724f3da04313d478e0c4b766af1b03",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.9",
"size": 14241,
"upload_time": "2025-07-17T06:34:58",
"upload_time_iso_8601": "2025-07-17T06:34:58.712561Z",
"url": "https://files.pythonhosted.org/packages/53/24/3d0e22356100eda57d8ef32c25f98c87d9ea0991ba7e7dbd7b71d5eaa2b7/drf_pydantic-2.8.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "09cc10da0dfb667a40b92e4f6bce037b121b5911bc67dc1caa2f249d7a633bad",
"md5": "36f24650f2fcbcaa1534b401af88193b",
"sha256": "16c2dbead529311629f421bb360cf286a406878a5e882106a59876dc677666fe"
},
"downloads": -1,
"filename": "drf_pydantic-2.8.0.tar.gz",
"has_sig": false,
"md5_digest": "36f24650f2fcbcaa1534b401af88193b",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.9",
"size": 12262,
"upload_time": "2025-07-17T06:34:59",
"upload_time_iso_8601": "2025-07-17T06:34:59.727657Z",
"url": "https://files.pythonhosted.org/packages/09/cc/10da0dfb667a40b92e4f6bce037b121b5911bc67dc1caa2f249d7a633bad/drf_pydantic-2.8.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-07-17 06:34:59",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "georgebv",
"github_project": "drf-pydantic",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "drf-pydantic"
}
