Remove Deprecated Config class support (#1528)

* Removed Deprecated Config class (on Schema) support
* FilterField instead of Field (+ deprecation warning)

Author: vitalik

docs/docs/guides/input/filtering.md

@@ -7,9 +7,10 @@ parameters into database queries.
 
 Start off with defining a subclass of `FilterSchema`:
 
-```python hl_lines="6 7 8"
-from ninja import FilterSchema, Field
+```python hl_lines="6 7 8 9"
+from ninja import FilterSchema
 from typing import Optional
+from datetime import datetime
 
 
 class BookFilterSchema(FilterSchema):
@@ -34,7 +35,7 @@ defined in `BookFilterSchema` into query parameters.
 You can use a shorthand one-liner `.filter()` to apply those filters to your queryset:
 ```python hl_lines="4"
 @api.get("/books")
-def list_books(request, filters: BookFilterSchema = Query(...)):
+def list_books(request, filters: Query[BookFilterSchema]):
     books = Book.objects.all()
     books = filters.filter(books)
     return books
@@ -47,7 +48,7 @@ Alternatively to using the `.filter` method, you can get the prepared `Q`-expres
 That can be useful, when you have some additional queryset filtering on top of what you expose to the user through the API:
 ```python hl_lines="5 8"
 @api.get("/books")
-def list_books(request, filters: BookFilterSchema = Query(...)):
+def list_books(request, filters: Query[BookFilterSchema]):
 
     # Never serve books from inactive publishers and authors
     q = Q(author__is_active=True) | Q(publisher__is_active=True)
@@ -73,20 +74,24 @@ class BookFilterSchema(FilterSchema):
 The `name` field will be converted into `Q(name=...)` expression.
 
 When your database lookups are more complicated than that, you can explicitly specify them in the field definition using a `"q"` kwarg:
-```python hl_lines="2"
+```python hl_lines="14"
+from ninja import FilterSchema
+
 class BookFilterSchema(FilterSchema):
-    name: Optional[str] = Field(None, q='name__icontains')
+    name: Optional[str] = FilterField(None, q='name__icontains')
 ```
 You can even specify multiple lookup keyword argument names as a list:
 ```python hl_lines="2 3 4"
 class BookFilterSchema(FilterSchema):
-    search: Optional[str] = Field(None, q=['name__icontains',
-                                     'author__name__icontains',
-                                     'publisher__name__icontains'])
+    search: Optional[str] = FilterField(None, q=['name__icontains',
+                                           'author__name__icontains',
+                                           'publisher__name__icontains'])
 ```
 And to make generic fields, you can make the field name implicit by skipping it:
 ```python hl_lines="2"
-IContainsField = Annotated[Optional[str], Field(None, q='__icontains')]
+from typing import Annotated
+
+IContainsField = Annotated[Optional[str], FilterField(None, q='__icontains')]
 
 class BookFilterSchema(FilterSchema):
     name: IContainsField
@@ -103,7 +108,7 @@ By default,
 So, with the following `FilterSchema`...
 ```python
 class BookFilterSchema(FilterSchema):
-    search: Optional[str] = Field(None, q=['name__icontains', 'author__name__icontains'])
+    search: Optional[str] = FilterField(None, q=['name__icontains', 'author__name__icontains'])
     popular: Optional[bool] = None
 ```
 ...and the following query parameters from the user
@@ -116,11 +121,11 @@ the `FilterSchema` instance will look for popular books that have `harry` in the
 You can customize this behavior using an `expression_connector` argument in field-level and class-level definition:
 ```python hl_lines="3 7"
 class BookFilterSchema(FilterSchema):
-    active: Optional[bool] = Field(None, q=['is_active', 'publisher__is_active'],
-                                   expression_connector='AND')
-    name: Optional[str] = Field(None, q='name__icontains')
+    active: Optional[bool] = FilterField(None, q=['is_active', 'publisher__is_active'],
+                                         expression_connector='AND')
+    name: Optional[str] = FilterField(None, q='name__icontains')
 
-    class Config:
+    class Meta:
         expression_connector = 'OR'
 ```
 
@@ -139,19 +144,19 @@ You can make the `FilterSchema` treat `None` as a valid value that should be fil
 This can be done on a field level with a `ignore_none` kwarg:
 ```python hl_lines="3"
 class BookFilterSchema(FilterSchema):
-    name: Optional[str] = Field(None, q='name__icontains')
-    tag: Optional[str] = Field(None, q='tag', ignore_none=False)
+    name: Optional[str] = FilterField(None, q='name__icontains')
+    tag: Optional[str] = FilterField(None, q='tag', ignore_none=False)
 ```
 
 This way when no other value for `"tag"` is provided by the user, the filtering will always include a condition `tag=None`.
 
 You can also specify this settings for all fields at the same time in the Config:
 ```python hl_lines="6"
 class BookFilterSchema(FilterSchema):
-    name: Optional[str] = Field(None, q='name__icontains')
-    tag: Optional[str] = Field(None, q='tag', ignore_none=False)
+    name: Optional[str] = FilterField(None, q='name__icontains')
+    tag: Optional[str] = FilterField(None, q='tag', ignore_none=False)
 
-    class Config:
+    class Meta:
         ignore_none = False
 ```
 
@@ -168,7 +173,7 @@ class BookFilterSchema(FilterSchema):
     def filter_popular(self, value: bool) -> Q:
         return Q(view_count__gt=1000) | Q(download_count__gt=100) if value else Q()
 ```
-Such field methods take precedence over what is specified in the `Field()` definition of the corresponding fields.
+Such field methods take precedence over what is specified in the `FilterField()` definition of the corresponding fields.
 
 If that is not enough, you can implement your own custom filtering logic for the entire `FilterSet` class in a `custom_expression` method:
 

docs/docs/guides/response/config-pydantic.md

@@ -1,7 +1,7 @@
 # Overriding Pydantic Config
 
 There are many customizations available for a **Django Ninja `Schema`**, via the schema's
-[Pydantic `Config` class](https://pydantic-docs.helpmanual.io/usage/model_config/). 
+[Pydantic `model_config`](https://docs.pydantic.dev/latest/api/config/). 
 
 !!! info
     Under the hood **Django Ninja** uses [Pydantic Models](https://pydantic-docs.helpmanual.io/usage/models/)
@@ -11,10 +11,11 @@ There are many customizations available for a **Django Ninja `Schema`**, via the
 
 ## Example Camel Case mode
 
-One interesting `Config` attribute is [`alias_generator`](https://pydantic-docs.helpmanual.io/usage/model_config/#alias-generator).
+One interesting config attribute is [`alias_generator`](https://docs.pydantic.dev/latest/api/config/?query=alias_generator#pydantic.config.ConfigDict.alias_generator).
 Using Pydantic's example in **Django Ninja** can look something like:
 
-```python hl_lines="12 13"
+```python hl_lines="10"
+from pydantic import ConfigDict
 from ninja import Schema
 
 
@@ -23,25 +24,25 @@ def to_camel(string: str) -> str:
     return words[0].lower() + ''.join(word.capitalize() for word in words[1:])
 
 class CamelModelSchema(Schema):
+    model_config = ConfigDict(alias_generator=to_camel)
     str_field_name: str
     float_field_name: float
-
-    class Config(Schema.Config):
-        alias_generator = to_camel
 ```
 
-!!! note
-    When overriding the schema's `Config`, it is necessary to inherit from the base `Config` class. 
-
 Keep in mind that when you want modify output for field names (like camel case) - you need to set as well  `populate_by_name` and `by_alias`
 
-```python hl_lines="6 9"
+```python hl_lines="6 14"
+from pydantic import ConfigDict
+
 class UserSchema(ModelSchema):
-    class Config:
-        model = User
-        model_fields = ["id", "email", "is_staff"]
+    model_config = ConfigDict(
         alias_generator = to_camel
-        populate_by_name = True  # !!!!!! <--------
+        populate_by_name = True,  # !!!!!! <--------
+    )
+    class Meta:
+        model = User
+        fields = ["id", "email", "is_staff"]
+
 
 
 @api.get("/users", response=list[UserSchema], by_alias=True) # !!!!!! <-------- by_alias
@@ -69,21 +70,4 @@ results:
 
 ```
 
-## Custom Config from Django Model
 
-When using [`create_schema`](django-pydantic-create-schema.md#create_schema), the resulting
-schema can be used to build another class with a custom config like:
-
-```python hl_lines="10"
-from django.contrib.auth.models import User
-from ninja.orm import create_schema
-
-
-BaseUserSchema = create_schema(User)
-
-
-class UserSchema(BaseUserSchema):
-
-    class Config(BaseUserSchema.Config):
-        ...
-```

docs/docs/tutorial/other/crud.md

@@ -176,14 +176,14 @@ To allow the user to make partial updates, use `payload.dict(exclude_unset=True)
 
 **Enforcing strict field validation**
 
-By default, any provided fields that don't exist in the schema will be silently ignored. To raise an error for these invalid fields, you can set `extra = "forbid"` in the schema's Config class. For example:
+By default, any provided fields that don't exist in the schema will be silently ignored. To raise an error for these invalid fields, you can set `extra = "forbid"` in the model_config. For example:
 
-```python hl_lines="4 5"
+```python hl_lines="5"
+from pydantic import ConfigDict
 class EmployeeIn(Schema):
     # your fields here...
 
-    class Config:
-        extra = "forbid"
+    model_config = ConfigDict(extra="forbid")
 ```
 
 ## Delete

ninja/__init__.py

@@ -6,7 +6,7 @@
 from pydantic import Field
 
 from ninja.files import UploadedFile
-from ninja.filter_schema import FilterSchema
+from ninja.filter_schema import FilterField, FilterSchema
 from ninja.main import NinjaAPI
 from ninja.openapi.docs import Redoc, Swagger
 from ninja.orm import ModelSchema
@@ -54,6 +54,7 @@
     "Schema",
     "ModelSchema",
     "FilterSchema",
+    "FilterField",
     "Swagger",
     "Redoc",
     "PatchDict",

ninja/conf.py

@@ -2,10 +2,11 @@
 from typing import Dict, Optional, Set
 
 from django.conf import settings as django_settings
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class Settings(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
     # Pagination
     PAGINATION_CLASS: str = Field(
         "ninja.pagination.LimitOffsetPagination", alias="NINJA_PAGINATION_CLASS"
@@ -29,9 +30,6 @@ class Settings(BaseModel):
         {"PUT", "PATCH", "DELETE"}, alias="NINJA_FIX_REQUEST_FILES_METHODS"
     )
 
-    class Config:
-        from_attributes = True
-
 
 settings = Settings.model_validate(django_settings)
 

ninja/filter_schema.py

@@ -1,7 +1,9 @@
-from typing import Any, TypeVar, cast
+import warnings
+from typing import Any, Dict, Optional, TypeVar, Union, cast
 
 from django.core.exceptions import ImproperlyConfigured
 from django.db.models import Q, QuerySet
+from pydantic import ConfigDict, Field
 from pydantic.fields import FieldInfo
 from typing_extensions import Literal
 
@@ -14,24 +16,36 @@
 # XOR is available only in Django 4.1+: https://docs.djangoproject.com/en/4.1/ref/models/querysets/#xor
 ExpressionConnector = Literal["AND", "OR", "XOR"]
 
-
-# class FilterConfig(BaseConfig):
-#     ignore_none: bool = DEFAULT_IGNORE_NONE
-#     expression_connector: ExpressionConnector = cast(
-#         ExpressionConnector, DEFAULT_CLASS_LEVEL_EXPRESSION_CONNECTOR
-#     )
+T = TypeVar("T", bound=QuerySet)
 
 
-T = TypeVar("T", bound=QuerySet)
+def FilterField(
+    default: Any = ...,
+    *,
+    q: Optional[Union[str, list]] = None,
+    ignore_none: Optional[bool] = None,
+    expression_connector: Optional[ExpressionConnector] = None,
+    **kwargs: Any,
+) -> Any:
+    """Custom Field function for FilterSchema that properly handles filter-specific parameters."""
+    json_schema_extra = kwargs.get("json_schema_extra", {})
+    if isinstance(json_schema_extra, dict):
+        if q is not None:
+            json_schema_extra["q"] = q
+        if ignore_none is not None:
+            json_schema_extra["ignore_none"] = ignore_none
+        if expression_connector is not None:
+            json_schema_extra["expression_connector"] = expression_connector
+    kwargs["json_schema_extra"] = json_schema_extra
+
+    return Field(default, **kwargs)
 
 
 class FilterSchema(Schema):
-    # if TYPE_CHECKING:
-    #     __config__: ClassVar[Type[FilterConfig]] = FilterConfig  # pragma: no cover
-
-    # Config = FilterConfig
+    model_config = ConfigDict(from_attributes=True)
 
-    class Config(Schema.Config):
+    class Meta:
+        # TODO: filters_ignore_none, filters_expression_connector
         ignore_none: bool = DEFAULT_IGNORE_NONE
         expression_connector: ExpressionConnector = cast(
             ExpressionConnector, DEFAULT_CLASS_LEVEL_EXPRESSION_CONNECTOR
@@ -64,6 +78,18 @@ def _resolve_field_expression(
 
         field_extra = field.json_schema_extra or {}
 
+        # Check if user is using pydantic Field with deprecated extra kwargs
+        # This check is for backwards compatibility during transition period
+        if hasattr(field, "extra") and field.extra:
+            warnings.warn(
+                f"Using pydantic Field with extra keyword arguments (q, ignore_none, expression_connector) "
+                f"in field '{field_name}' is deprecated. Please use ninja.FilterField instead:\n"
+                f"  from ninja import FilterField\n"
+                f"  {field_name}: Optional[...] = FilterField(..., q='...', ignore_none=...)",
+                DeprecationWarning,
+                stacklevel=4,
+            )
+
         q_expression = field_extra.get("q", None)  # type: ignore
         if not q_expression:
             return Q(**{field_name: field_value})
@@ -98,19 +124,27 @@ def _resolve_field_expression(
 
     def _connect_fields(self) -> Q:
         q = Q()
-        for field_name, field in self.model_fields.items():
+        model_config = self._model_config()
+        for field_name, field in self.__class__.model_fields.items():
             filter_value = getattr(self, field_name)
             field_extra = field.json_schema_extra or {}
             ignore_none = field_extra.get(  # type: ignore
                 "ignore_none",
-                self.model_config["ignore_none"],  # type: ignore
+                model_config["ignore_none"],
             )
 
             # Resolve q for a field even if we skip it due to None value
             # So that improperly configured fields are easier to detect
             field_q = self._resolve_field_expression(field_name, filter_value, field)
             if filter_value is None and ignore_none:
                 continue
-            q = q._combine(field_q, self.model_config["expression_connector"])  # type: ignore
+            q = q._combine(field_q, model_config["expression_connector"])  # type: ignore
 
         return q
+
+    @classmethod
+    def _model_config(cls) -> Dict[str, Any]:
+        return {
+            "ignore_none": cls.Meta.ignore_none,
+            "expression_connector": cls.Meta.expression_connector,
+        }