Migrate from Pydantic V1 compat layer to native Pydantic V2 API (#198)

- Replace all pydantic.v1 imports with direct pydantic imports
- Migrate V1 APIs: .dict() -> .model_dump(), .__fields__ -> .model_fields,
  .from_orm() -> .model_validate(), .schema() -> .model_json_schema()
- Convert class Config to model_config = ConfigDict(...)
  (orm_mode -> from_attributes, allow_population_by_field_name -> populate_by_name)
- Update OpenAPI schema generation for V2 output ($defs, anyOf for Optional)
- Update test assertions to match V2 error messages and schema format
- Update README with Pydantic V2 docs links and examples
- Bump version to 0.2.0a1

Made-with: Cursor

Author: pexflex

README.md

@@ -390,15 +390,28 @@ class ListModelMixin(BaseListModelMixin):
 
 ### PydanticSerializer
 
-Для использования сериализатор на основе [pydantic](https://pydantic-docs.helpmanual.io/) необходимо наследовать
+Для использования сериализатор на основе [pydantic](https://docs.pydantic.dev/) (V2) необходимо наследовать
 сериализатор от `PydanticSerializer`, указать в `Meta` `pydantic_model` и `pydantic_use_aliases` (при необходимости).
 
-Параметр `pydantic_use_aliases` позволяет использовать [алиасы pydantic моделей](https://pydantic-docs.helpmanual.io/usage/model_config/#alias-precedence) для сериализации.
+Параметр `pydantic_use_aliases` позволяет использовать [алиасы pydantic моделей](https://docs.pydantic.dev/latest/concepts/fields/#field-aliases) для сериализации.
+
+Для работы с Django-моделями используйте `model_config = ConfigDict(from_attributes=True)` в pydantic-модели.
+
 ```python
+from pydantic import BaseModel, ConfigDict
+from restdoctor.rest_framework.serializers import PydanticSerializer
+
+
+class MyPydanticModel(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    name: str
+    value: int
+
 
-class PydanticSerializer(PydanticSerializer):
+class MyPydanticSerializer(PydanticSerializer):
     class Meta:
-        pydantic_model = PydanticModel
+        pydantic_model = MyPydanticModel
         pydantic_use_aliases = True
 ```
 

restdoctor/__init__.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
 
-__version__ = '0.1.0'
+__version__ = '0.2.0a1'
 
 default_app_config = 'restdoctor.apps.AppConfig'

restdoctor/rest_framework/schema/serializers.py

@@ -5,7 +5,6 @@
 
 from django.conf import settings
 from django.utils.encoding import force_str
-from pydantic.v1.schema import schema as pydantic_schema
 from rest_framework.fields import HiddenField
 from rest_framework.serializers import BaseSerializer
 
@@ -69,7 +68,7 @@ def get_serializer_schema(
         required: bool = True,
     ) -> OpenAPISchema:
         if isinstance(serializer, PydanticSerializer):
-            return fix_pydantic_title(serializer.pydantic_model_class.schema())
+            return fix_pydantic_title(serializer.pydantic_model_class.model_json_schema())
 
         properties, required_list = self.map_serializer_fields(
             serializer, include_write_only=write_only, include_read_only=read_only
@@ -122,18 +121,24 @@ def get_pydantic_ref_name(self, serializer_class_name: str) -> str:
 
     def map_pydantic_serializer(self, serializer: PydanticSerializer) -> OpenAPISchema:
         if not self.view_schema.generator:
-            return fix_pydantic_title(serializer.pydantic_model_class.schema())
+            return fix_pydantic_title(serializer.pydantic_model_class.model_json_schema())
 
-        schema = {}
-        ref_repo = pydantic_schema([serializer.pydantic_model_class], ref_prefix=OPENAPI_REF_PREFIX)
-        for class_name, definition in ref_repo['definitions'].items():
+        full_schema = serializer.pydantic_model_class.model_json_schema(
+            ref_template=OPENAPI_REF_PREFIX + '{model}'
+        )
+
+        defs = full_schema.pop('$defs', {})
+        for class_name, definition in defs.items():
             definition = fix_pydantic_title(definition)
             ref = self.get_pydantic_ref_name(class_name)
             self.view_schema.generator.local_refs_registry.put_local_ref(ref, definition)
-            if class_name == serializer.pydantic_model_class.__name__:
-                schema = {'$ref': ref}
 
-        return schema
+        root_schema = fix_pydantic_title(full_schema)
+        root_class_name = serializer.pydantic_model_class.__name__
+        ref = self.get_pydantic_ref_name(root_class_name)
+        self.view_schema.generator.local_refs_registry.put_local_ref(ref, root_schema)
+
+        return {'$ref': ref}
 
     def map_serializer(
         self,
@@ -184,7 +189,9 @@ def map_pydantic_query_serializer(
     ) -> typing.List[OpenAPISchema]:
         props = []
         schema_dict = fix_pydantic_title(
-            serializer.pydantic_model_class.schema(ref_template=OPENAPI_REF_PREFIX + '{model}')
+            serializer.pydantic_model_class.model_json_schema(
+                ref_template=OPENAPI_REF_PREFIX + '{model}'
+            )
         )
         required_fields = schema_dict.get('required', [])
         for field_name, field_schema in schema_dict['properties'].items():

restdoctor/rest_framework/serializers.py

@@ -11,8 +11,8 @@
 
 from django.core.exceptions import ImproperlyConfigured
 from django.db.models import Model as DjangoModel
-from pydantic.v1 import BaseModel
-from pydantic.v1 import ValidationError as PydanticValidationError
+from pydantic import BaseModel
+from pydantic import ValidationError as PydanticValidationError
 from rest_framework.exceptions import ValidationError
 from rest_framework.fields import empty
 from rest_framework.serializers import BaseSerializer as BaseDRFSerializer
@@ -200,7 +200,7 @@ def _validate_django_model(cls) -> None:
 
     @classmethod
     def _validate_django_model_fields(cls, model: DjangoModel) -> None:
-        pydantic_fields_set = set(cls._get_pydantic_model().__fields__.keys())
+        pydantic_fields_set = set(cls._get_pydantic_model().model_fields.keys())
         model_info = model_meta.get_field_info(model)
         model_fields = list(model_info.fields.keys())
         model_fields.extend(model_info.relations.keys())
@@ -217,23 +217,28 @@ def _validate_meta_fields_not_exist(cls) -> None:
 
     @classmethod
     def _validate_orm_mode_enabled(cls) -> None:
-        if not getattr(cls._get_pydantic_model().Config, 'orm_mode', False):
+        if not cls._get_pydantic_model().model_config.get('from_attributes', False):
             raise ImproperlyConfigured(
-                'pydantic_model.Config.orm_mode must be True for this serializer'
+                'pydantic_model.model_config "from_attributes" must be True for this serializer'
             )
 
     def query_dict_to_dict(self, data: QueryDict) -> dict:
         model_class = self.pydantic_model_class
-        model_fields = model_class.__fields__
+        pydantic_model_fields = model_class.model_fields
         to_dict: dict[str, typing.Any] = {}
         for key, orig_value in data.items():
             field_key = next(
-                (name for (name, field_obj) in model_fields.items() if field_obj.alias == key), key
+                (
+                    name
+                    for (name, field_obj) in pydantic_model_fields.items()
+                    if field_obj.alias == key
+                ),
+                key,
             )
-            if field_key not in model_fields:
+            if field_key not in pydantic_model_fields:
                 to_dict[key] = orig_value
                 continue
-            field_type = model_fields[field_key].annotation
+            field_type = pydantic_model_fields[field_key].annotation
             if orig_value in ('', b'') and not self._is_string_like_field(field_type=field_type):
                 continue
             if self._is_sequence_field(field_type=field_type):
@@ -244,7 +249,7 @@ def query_dict_to_dict(self, data: QueryDict) -> dict:
         return to_dict
 
     def get_fields(self) -> dict[str, None]:
-        return {field_name: None for field_name in self.pydantic_model_class.__fields__.keys()}
+        return {field_name: None for field_name in self.pydantic_model_class.model_fields.keys()}
 
     def to_internal_value(self, data: dict[str, typing.Any]) -> TPydanticModel:
         try:
@@ -260,12 +265,12 @@ def to_representation(  # noqa: CAC001
         # Типы аргумента instance были выяснены экспериментальным путем
         # в ходе тестирования
         if isinstance(instance, dict):
-            value = self.to_internal_value(instance).dict(by_alias=self.pydantic_use_aliases)
+            value = self.to_internal_value(instance).model_dump(by_alias=self.pydantic_use_aliases)
         elif isinstance(instance, BaseModel):
-            value = instance.dict(by_alias=self.pydantic_use_aliases)
+            value = instance.model_dump(by_alias=self.pydantic_use_aliases)
         elif isinstance(instance, PydanticSerializer):
             instance.is_valid(raise_exception=True)
-            value = instance._pydantic_instance.dict(by_alias=self.pydantic_use_aliases)  # type: ignore
+            value = instance._pydantic_instance.model_dump(by_alias=self.pydantic_use_aliases)  # type: ignore
         elif isinstance(instance, DjangoModel):
             value = self._django_model_to_representation(instance)
         else:
@@ -282,7 +287,7 @@ def is_valid(self, raise_exception: bool = False) -> bool:
             try:
                 pydantic_instance = self.pydantic_model_class(**self.initial_data)
                 self._pydantic_instance = pydantic_instance
-                self._validated_data = pydantic_instance.dict(by_alias=self.pydantic_use_aliases)
+                self._validated_data = pydantic_instance.model_dump(by_alias=self.pydantic_use_aliases)
             except PydanticValidationError as exc:
                 self._validated_data = {}
                 self._errors = convert_pydantic_errors_to_drf_errors(exc.errors())
@@ -296,7 +301,7 @@ def is_valid(self, raise_exception: bool = False) -> bool:
 
     def _django_model_to_representation(self, instance: DjangoModel) -> GenericRepresentation:
         try:
-            value = self.pydantic_model_class.from_orm(instance).dict(
+            value = self.pydantic_model_class.model_validate(instance).model_dump(
                 by_alias=self.pydantic_use_aliases
             )
         except PydanticValidationError as exc:

tests/test_unit/test_schema/test_pydantic_schema.py

@@ -6,7 +6,7 @@
 from uuid import UUID
 
 import pytest
-from pydantic.v1 import BaseModel, Field, StrictInt, StrictStr
+from pydantic import BaseModel, Field, StrictInt, StrictStr
 
 from restdoctor.rest_framework.schema.generators import RefsSchemaGenerator
 from restdoctor.rest_framework.schema.openapi import RestDoctorSchema
@@ -23,10 +23,10 @@ class PydanticTestModel(BaseModel):
 
 
 class PydanticTestQueryModel(BaseModel):
-    boolean_param: typing.Optional[bool] = Field(description='Boolean filter param')
+    boolean_param: typing.Optional[bool] = Field(default=None, description='Boolean filter param')
     string_param: str
-    integer_param: typing.Optional[int]
-    uuid_list_param: typing.Optional[typing.List[UUID]]
+    integer_param: typing.Optional[int] = None
+    uuid_list_param: typing.Optional[typing.List[UUID]] = None
     text_choices_param: TestTextChoices
 
 
@@ -79,8 +79,8 @@ def test_nested_model_schema_without_definitions():
 @pytest.fixture()
 def test_nested_model_schema(test_model_schema, test_nested_model_schema_without_definitions):
     schema = copy.deepcopy(test_nested_model_schema_without_definitions)
-    schema['properties']['nested_field'] = {'$ref': '#/definitions/PydanticTestModel'}
-    schema['definitions'] = {'PydanticTestModel': test_model_schema}
+    schema['properties']['nested_field'] = {'$ref': '#/$defs/PydanticTestModel'}
+    schema['$defs'] = {'PydanticTestModel': test_model_schema}
     return schema
 
 
@@ -142,7 +142,11 @@ def test__serializer_schema():
             'in': 'query',
             'name': 'boolean_param',
             'required': False,
-            'schema': {'description': 'Boolean filter param', 'type': 'boolean'},
+            'schema': {
+                'anyOf': [{'type': 'boolean'}, {'type': 'null'}],
+                'default': None,
+                'description': 'Boolean filter param',
+            },
         },
         {
             'in': 'query',
@@ -154,16 +158,23 @@ def test__serializer_schema():
             'in': 'query',
             'name': 'integer_param',
             'required': False,
-            'schema': {'description': 'Integer Param', 'type': 'integer'},
+            'schema': {
+                'anyOf': [{'type': 'integer'}, {'type': 'null'}],
+                'default': None,
+                'description': 'Integer Param',
+            },
         },
         {
             'in': 'query',
             'name': 'uuid_list_param',
             'required': False,
             'schema': {
+                'anyOf': [
+                    {'items': {'format': 'uuid', 'type': 'string'}, 'type': 'array'},
+                    {'type': 'null'},
+                ],
+                'default': None,
                 'description': 'Uuid List Param',
-                'items': {'format': 'uuid', 'type': 'string'},
-                'type': 'array',
             },
         },
         {

tests/test_unit/test_serializers/test_pydantic_serializer/conftest.py

@@ -6,14 +6,13 @@
 
 import pytest
 from django.db import models
-from pydantic.v1 import BaseModel, Field, Json, StrictInt, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, Json, StrictInt, StrictStr
 
 from restdoctor.rest_framework.serializers import PydanticSerializer
 
 
 class PydanticTestModel(BaseModel):
-    class Config:
-        orm_mode = True
+    model_config = ConfigDict(from_attributes=True)
 
     created_at: datetime.datetime = Field(default_factory=datetime.datetime.utcnow)
     field_a: StrictStr
@@ -23,7 +22,7 @@ class Config:
 class PydanticWithQueryParamsTestModel(BaseModel):
     any_int: int = Field(alias='my_int')
     any_str: str = Field(alias='any_str')
-    any_json: Json
+    any_json: Json[typing.Any]
     any_list: list
     any_str_list: typing.List[str]
     any_bool: bool
@@ -35,15 +34,13 @@ class PydanticWithQueryParamsShortTestModel(BaseModel):
 
 
 class PydanticObjectTestModel(BaseModel):
-    class Config:
-        allow_population_by_field_name = True
+    model_config = ConfigDict(populate_by_name=True)
 
     object_id: int = Field(alias='id')
 
 
 class PydanticTestModelWithAliases(PydanticTestModel):
-    class Config:
-        allow_population_by_field_name = True
+    model_config = ConfigDict(populate_by_name=True, protected_namespaces=())
 
     object_type: str = Field(alias='type')
     model_object: PydanticObjectTestModel = Field(alias='object')
@@ -211,21 +208,21 @@ def pydantic_test_model_with_aliases_data(pydantic_test_model_data) -> dict[str,
 def serialized_pydantic_test_model_data(
     pydantic_test_model_data, pydantic_test_model
 ) -> dict[str, str | datetime.datetime]:
-    return pydantic_test_model(**pydantic_test_model_data).dict()
+    return pydantic_test_model(**pydantic_test_model_data).model_dump()
 
 
 @pytest.fixture()
 def serialized_pydantic_test_with_query(
     pydantic_test_query_data, pydantic_test_with_query_model
 ) -> dict[str, str | datetime.datetime]:
-    return pydantic_test_with_query_model(**pydantic_test_query_data).dict()
+    return pydantic_test_with_query_model(**pydantic_test_query_data).model_dump()
 
 
 @pytest.fixture()
 def serialized_pydantic_test_model_with_aliases_data(
     pydantic_test_model_with_aliases_data, pydantic_test_model_with_aliases
 ) -> dict[str, str | datetime.datetime]:
-    return pydantic_test_model_with_aliases(**pydantic_test_model_with_aliases_data).dict(
+    return pydantic_test_model_with_aliases(**pydantic_test_model_with_aliases_data).model_dump(
         by_alias=True
     )
 

tests/test_unit/test_serializers/test_pydantic_serializer/parameters.py

@@ -2,7 +2,7 @@
 
 import typing
 
-from pydantic.v1.types import Json
+from pydantic import Json
 
 PARAMETRIZE_TYPES = [
     (str, False),

tests/test_unit/test_serializers/test_pydantic_serializer/parameters_38.py

@@ -2,7 +2,7 @@
 
 import typing
 
-from pydantic.v1.types import Json
+from pydantic import Json
 
 PARAMETRIZE_TYPES = [
     (str, False),