update codebase to support fastapi>=0.100.0 and pydantic>=2.0.0

.gitignore

@@ -8,3 +8,4 @@ fastapi_filter.sqlite
 poetry.toml
 .pytest_cache/
 .ruff_cache/
+__pycache__

docs/index.md

@@ -5,7 +5,6 @@ Add querystring filters to your api endpoints and show them in the swagger UI.
 The supported backends are [SQLAlchemy](https://github.com/sqlalchemy/sqlalchemy) and
 [MongoEngine](https://github.com/MongoEngine/mongoengine).
 
-
 ## Example
 
 ![Swagger UI](./swagger-ui.png)
@@ -25,16 +24,16 @@ as well as the type of operator, then tie your filter to a specific model.
 
 By default, **fastapi_filter** supports the following operators:
 
-  - `neq`
-  - `gt`
-  - `gte`
-  - `in`
-  - `isnull`
-  - `lt`
-  - `lte`
-  - `not`/`ne`
-  - `not_in`/`nin`
-  - `like`/`ilike`
+- `neq`
+- `gt`
+- `gte`
+- `in`
+- `isnull`
+- `lt`
+- `lte`
+- `not`/`ne`
+- `not_in`/`nin`
+- `like`/`ilike`
 
 _**Note:** Mysql excludes `None` values when using `in` filter_
 
@@ -89,7 +88,6 @@ Wherever you would use a `Depends`, replace it with `FilterDepends` if you are p
 that `FilterDepends` converts the `list` filter fields to `str` so that they can be displayed and used in swagger.
 It also handles turning `ValidationError` into `HTTPException(status_code=422)`.
 
-
 ### with_prefix
 
 [link](https://github.com/arthurio/fastapi-filter/blob/main/fastapi_filter/base/filter.py#L21)
@@ -133,12 +131,11 @@ There is a specific field on the filter class that can be used for ordering. The
 takes a list of string. From an API call perspective, just like the `__in` filters, you simply pass a comma separated
 list of strings.
 
-You can change the **direction** of the sorting (*asc* or *desc*) by prefixing with `-` or `+` (Optional, it's the
+You can change the **direction** of the sorting (_asc_ or _desc_) by prefixing with `-` or `+` (Optional, it's the
 default behavior if omitted).
 
 If you don't want to allow ordering on your filter, just don't add `order_by` (or custom `ordering_field_name`) as a field and you are all set.
 
-
 ## Search
 
 There is a specific field on the filter class that can be used for searching. The default name is `search` and it takes
@@ -148,7 +145,6 @@ You have to define what fields/columns to search in with the `search_model_field
 
 If you don't want to allow searching on your filter, just don't add `search` (or custom `search_field_name`) as a field and you are all set.
 
-
 ### Example - Basic
 
 ```python
@@ -215,17 +211,17 @@ curl /users?custom_order_by=+id
 
 ### Restrict the `order_by` values
 
-Add the following validator to your filter class:
+Add the following field_validator to your filter class:
 
 ```python
 from typing import Optional
 from fastapi_filter.contrib.sqlalchemy import Filter
-from pydantic import validator
+from pydantic import field_validator
 
 class MyFilter(Filter):
     order_by: Optional[list[str]]
 
-    @validator("order_by")
+    @field_validator("order_by")
     def restrict_sortable_fields(cls, value):
         if value is None:
             return None
@@ -241,7 +237,7 @@ class MyFilter(Filter):
 ```
 
 1. If you want to restrict only on specific directions, like `-created_at` and `name` for example, you can remove this
-line. Your `allowed_field_names` would be something like `["age", "-age", "-created_at"]`.
+   line. Your `allowed_field_names` would be something like `["age", "-age", "-created_at"]`.
 
 ### Example - Search
 

fastapi_filter/base/filter.py

@@ -1,15 +1,23 @@
 from collections import defaultdict
-from collections.abc import Iterable
 from copy import deepcopy
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+from types import UnionType
+from typing import Annotated, Any, Dict, Iterable, List, Optional, Tuple, Type, Union, get_args, get_origin
 
 from fastapi import Depends
 from fastapi.exceptions import RequestValidationError
-from pydantic import BaseModel, Extra, ValidationError, create_model, fields, validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    FieldValidationInfo,
+    PlainValidator,
+    ValidationError,
+    create_model,
+    field_validator,
+)
 from pydantic.fields import FieldInfo
 
 
-class BaseFilterModel(BaseModel, extra=Extra.forbid):
+class BaseFilterModel(BaseModel, extra="forbid"):
     """Abstract base filter class.
 
     Provides the interface for filtering and ordering.
@@ -48,7 +56,7 @@ def filter(self, query):  # pragma: no cover
 
     @property
     def filtering_fields(self):
-        fields = self.dict(exclude_none=True, exclude_unset=True)
+        fields = self.model_dump(exclude_none=True, exclude_unset=True)
         fields.pop(self.Constants.ordering_field_name, None)
         return fields.items()
 
@@ -66,13 +74,9 @@ def ordering_values(self):
                 "Make sure to add it to your filter class."
             ) from e
 
-    @validator("*", pre=True)
-    def split_str(cls, value, field):  # pragma: no cover
-        ...
-
-    @validator("*", pre=True, allow_reuse=True, check_fields=False)
-    def strip_order_by_values(cls, value, values, field):
-        if field.name != cls.Constants.ordering_field_name:
+    @field_validator("*", mode="before", check_fields=False)
+    def strip_order_by_values(cls, value, field: FieldValidationInfo):
+        if field.field_name != cls.Constants.ordering_field_name:
             return value
 
         if not value:
@@ -86,9 +90,9 @@ def strip_order_by_values(cls, value, values, field):
 
         return stripped_values
 
-    @validator("*", allow_reuse=True, check_fields=False)
-    def validate_order_by(cls, value, values, field):
-        if field.name != cls.Constants.ordering_field_name:
+    @field_validator("*", mode="before", check_fields=False)
+    def validate_order_by(cls, value, field: FieldValidationInfo):
+        if field.field_name != cls.Constants.ordering_field_name:
             return value
 
         if not value:
@@ -135,9 +139,10 @@ def with_prefix(prefix: str, Filter: Type[BaseFilterModel]):
         class NumberFilter(BaseModel):
             count: Optional[int]
 
+        number_filter_prefixed, Annotation = with_prefix("number_filter", Filter)
         class MainFilter(BaseModel):
             name: str
-            number_filter: Optional[Filter] = FilterDepends(with_prefix("number_filter", Filter))
+            number_filter: Optional[Annotation] = FilterDepends(number_filter_prefixed)
         ```
 
     As a result, you'll get the following filters:
@@ -156,9 +161,10 @@ class MainFilter(BaseModel):
         class NumberFilter(BaseModel):
             count: Optional[int] = Query(default=10, alias=counter)
 
+        number_filter_prefixed, Annotation = with_prefix("number_filter", Filter)
         class MainFilter(BaseModel):
             name: str
-            number_filter: Optional[Filter] = FilterDepends(with_prefix("number_filter", Filter))
+            number_filter: Optional[Annotation] = FilterDepends(number_filter_prefixed)
         ```
 
     As a result, you'll get the following filters:
@@ -167,32 +173,51 @@ class MainFilter(BaseModel):
     """
 
     class NestedFilter(Filter):  # type: ignore[misc, valid-type]
-        class Config:
-            extra = Extra.forbid
-
-            @classmethod
-            def alias_generator(cls, string: str) -> str:
-                return f"{prefix}__{string}"
+        model_config = ConfigDict(extra="forbid", alias_generator=lambda string: f"{prefix}__{string}")
 
         class Constants(Filter.Constants):  # type: ignore[name-defined]
             ...
 
     NestedFilter.Constants.prefix = prefix
 
-    return NestedFilter
+    def plain_validator(value):
+        # Make sure we validate Model.
+        # Probably would be better if this was subclass of specific Filter but
+        if issubclass(value.__class__, BaseModel):
+            value = value.model_dump()
+
+        if isinstance(value, dict):
+            stripped = {k.removeprefix(NestedFilter.Constants.prefix): v for k, v in value.items()}
+            return Filter(**stripped)
+
+        raise ValueError(f"Unexpected type: {type(value)}")
+
+    annotation = Annotated[Filter, PlainValidator(plain_validator)]
+
+    return NestedFilter, annotation
 
 
 def _list_to_str_fields(Filter: Type[BaseFilterModel]):
     ret: Dict[str, Tuple[Union[object, Type], Optional[FieldInfo]]] = {}
-    for f in Filter.__fields__.values():
-        field_info = deepcopy(f.field_info)
-        if f.shape == fields.SHAPE_LIST:
+    for name, f in Filter.model_fields.items():
+        field_info = deepcopy(f)
+        annotation = f.annotation
+
+        if get_origin(annotation) in [UnionType, Union]:
+            annotation_args: list = list(get_args(f.annotation))
+            if type(None) in annotation_args:
+                annotation_args.remove(type(None))
+            if len(annotation_args) == 1:
+                annotation = annotation_args[0]
+            # Not sure what to do if there is more then 1 value 🤔
+            # Do we need to handle Optional[Annotated[...]] ?
+
+        if annotation is list or get_origin(annotation) is list:
             if isinstance(field_info.default, Iterable):
                 field_info.default = ",".join(field_info.default)
-            ret[f.name] = (str if f.required else Optional[str], field_info)
+            ret[name] = (str if f.is_required() else Optional[str], field_info)
         else:
-            field_type = Filter.__annotations__.get(f.name, f.outer_type_)
-            ret[f.name] = (field_type if f.required else Optional[field_type], field_info)
+            ret[name] = (f.annotation, field_info)
 
     return ret
 
@@ -214,16 +239,16 @@ def FilterDepends(Filter: Type[BaseFilterModel], *, by_alias: bool = False, use_
     class FilterWrapper(GeneratedFilter):  # type: ignore[misc,valid-type]
         def filter(self, *args, **kwargs):
             try:
-                original_filter = Filter(**self.dict(by_alias=by_alias))
+                original_filter = Filter(**self.model_dump(by_alias=by_alias))
             except ValidationError as e:
-                raise RequestValidationError(e.raw_errors) from e
+                raise RequestValidationError(e.errors()) from e
             return original_filter.filter(*args, **kwargs)
 
         def sort(self, *args, **kwargs):
             try:
-                original_filter = Filter(**self.dict(by_alias=by_alias))
+                original_filter = Filter(**self.model_dump(by_alias=by_alias))
             except ValidationError as e:
-                raise RequestValidationError(e.raw_errors) from e
+                raise RequestValidationError(e.errors()) from e
             return original_filter.sort(*args, **kwargs)
 
     return Depends(FilterWrapper)

fastapi_filter/contrib/mongoengine/filter.py

@@ -1,6 +1,6 @@
 from mongoengine import QuerySet
 from mongoengine.queryset.visitor import Q
-from pydantic import validator
+from pydantic import FieldValidationInfo, field_validator
 
 from ...base.filter import BaseFilterModel
 
@@ -33,21 +33,24 @@ def sort(self, query: QuerySet) -> QuerySet:
             return query
         return query.order_by(*self.ordering_values)
 
-    @validator("*", pre=True)
-    def split_str(cls, value, field):
+    @field_validator("*", mode="before")
+    def split_str(cls, value, field: FieldValidationInfo):
         if (
-            field.name == cls.Constants.ordering_field_name
-            or field.name.endswith("__in")
-            or field.name.endswith("__nin")
+            field.field_name == cls.Constants.ordering_field_name
+            or field.field_name.endswith("__in")
+            or field.field_name.endswith("__nin")
         ) and isinstance(value, str):
-            return [field.type_(v) for v in value.split(",")]
+            if not value:
+                # Empty string should return [] not ['']
+                return []
+            return [v for v in value.split(",")]
         return value
 
     def filter(self, query: QuerySet) -> QuerySet:
         for field_name, value in self.filtering_fields:
             field_value = getattr(self, field_name)
             if isinstance(field_value, Filter):
-                if not field_value.dict(exclude_none=True, exclude_unset=True):
+                if not field_value.model_dump(exclude_none=True, exclude_unset=True):
                     continue
 
                 query = query.filter(**{f"{field_name}__in": field_value.filter(field_value.Constants.model.objects())})

fastapi_filter/contrib/sqlalchemy/filter.py

@@ -3,7 +3,7 @@
 from typing import Union
 from warnings import warn
 
-from pydantic import validator
+from pydantic import FieldValidationInfo, field_validator
 from sqlalchemy import or_
 from sqlalchemy.orm import Query
 from sqlalchemy.sql.selectable import Select
@@ -87,14 +87,17 @@ class Direction(str, Enum):
         asc = "asc"
         desc = "desc"
 
-    @validator("*", pre=True)
-    def split_str(cls, value, field):
+    @field_validator("*", mode="before")
+    def split_str(cls, value, field: FieldValidationInfo):
         if (
-            field.name == cls.Constants.ordering_field_name
-            or field.name.endswith("__in")
-            or field.name.endswith("__not_in")
+            field.field_name == cls.Constants.ordering_field_name
+            or field.field_name.endswith("__in")
+            or field.field_name.endswith("__not_in")
         ) and isinstance(value, str):
-            return [field.type_(v) for v in value.split(",")]
+            if not value:
+                # Empty string should return [] not ['']
+                return []
+            return [v for v in value.split(",")]
         return value
 
     def filter(self, query: Union[Query, Select]):