fastapi-rtk 2.11.2__tar.gz → 2.11.4__tar.gz

{fastapi_rtk-2.11.2 → fastapi_rtk-2.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: fastapi-rtk
-Version: 2.11.2
+Version: 2.11.4
 Summary: A package that provides a set of tools to build a FastAPI application with a Class-Based CRUD API.
 Project-URL: Homepage, https://codeberg.org/datatactics/fastapi-rtk
 Project-URL: Issues, https://codeberg.org/datatactics/fastapi-rtk/issues
@@ -24,7 +24,7 @@ Requires-Dist: marshmallow-sqlalchemy>=1.4.2
 Requires-Dist: pip-licenses>=5.5.1
 Requires-Dist: polib>=1.2.0
 Requires-Dist: prometheus-fastapi-instrumentator>=7.1.0
-Requires-Dist: secweb>=1.25.2
+Requires-Dist: secweb<2,>=1.25.2
 Requires-Dist: sqlalchemy-utils>=0.42.0
 Requires-Dist: werkzeug>=3.1.5
 Provides-Extra: audit-bg

fastapi_rtk-2.11.4/fastapi_rtk/_version.py

@@ -0,0 +1 @@
+__version__ = "2.11.4"

{fastapi_rtk-2.11.2 → fastapi_rtk-2.11.4}/fastapi_rtk/api/model_rest_api/__init__.py

@@ -24,6 +24,7 @@ the usual ``class MyApi(ModelRestApi): list_columns = [...]`` idiom.
 
 import collections.abc
 import enum
+import inspect
 import typing
 
 import fastapi
@@ -31,7 +32,7 @@ import pydantic
 
 from ...backends.sqla.filters import BaseFilter, BaseOprFilter
 from ...backends.sqla.interface import SQLAInterface
-from ...bases import DBQueryParams
+from ...bases import AbstractInterface, DBQueryParams
 from ...const import AVAILABLE_ROUTES
 from ...dependencies import current_permissions
 from ...exceptions import HTTPWithValidationException, raise_exception
@@ -1062,6 +1063,22 @@ class ModelRestApi(
     DO NOT MODIFY.
     """
 
+    def __init_subclass__(cls, **kwargs):
+        """
+        Gives the subclass its own copy of an inherited datamodel.
+
+        A datamodel declared in the class body is left untouched, so sharing one interface between Api classes stays possible.
+
+        Args:
+            **kwargs: Forwarded to the parent implementation.
+        """
+        super().__init_subclass__(**kwargs)
+        if "datamodel" in cls.__dict__:
+            return
+        inherited = inspect.getattr_static(cls, "datamodel", None)
+        if isinstance(inherited, AbstractInterface):
+            cls.datamodel = inherited.clone()
+
     def __init__(self):
         if not self.datamodel:
             raise Exception(  # pragma: no cover
@@ -1098,11 +1115,18 @@ class ModelRestApi(
 
         for key, value in self.search_filters.items():
             datamodel, _ = self._get_datamodel_and_column(key)
-            self.datamodel.filters[key].extend([v(datamodel) for v in value])
+            # One interface can still be assigned to several Api classes, or one
+            # Api instantiated twice, so skip filter classes it already carries
+            # instead of stacking duplicates.
+            registered = {type(x) for x in self.datamodel.filters[key]}
+            self.datamodel.filters[key].extend(
+                [v(datamodel) for v in value if v not in registered]
+            )
 
         for key, value in self.search_exclude_filters.items():
             value = [v.arg_name if isinstance(v, BaseFilter) else v for v in value]
-            self.datamodel.exclude_filters[key].extend(value)
+            excluded = self.datamodel.exclude_filters[key]
+            excluded.extend([v for v in value if v not in excluded])
             self.datamodel.filters[key] = [
                 x for x in self.datamodel.filters[key] if x.arg_name not in value
             ]
@@ -1157,25 +1181,33 @@ class ModelRestApi(
             "search_query_rel_fields",
         ]
         for key in field_keys:
-            filter_dict = getattr(self, key)
-            for field, filters in filter_dict.items():
-                filter_dict[field] = self._init_filters(
-                    self.datamodel.get_related_interface(field), filters
-                )
+            # Build a new dict bound to the instance: the source may be a class
+            # attribute shared with subclasses, and instantiating in place turns
+            # the filter classes into instances the next Api cannot call.
+            setattr(
+                self,
+                key,
+                {
+                    field: self._init_filters(
+                        self.datamodel.get_related_interface(field), filters
+                    )
+                    for field, filters in getattr(self, key).items()
+                },
+            )
 
     def _init_routes(self):
         """
         Init routes for the API.
         """
-        is_image_column_exist = len(self.datamodel.get_image_column_list()) > 0
-        if not is_image_column_exist:
-            if "image" in self.routes:
-                self.routes.remove("image")
-
-        is_file_column_exist = len(self.datamodel.get_file_column_list()) > 0
-        if not is_file_column_exist:
-            if "file" in self.routes:
-                self.routes.remove("file")
+        unavailable = []
+        if not self.datamodel.get_image_column_list():
+            unavailable.append("image")
+        if not self.datamodel.get_file_column_list():
+            unavailable.append("file")
+
+        # Rebind on the instance instead of removing in place: `routes` may be a
+        # class attribute shared with subclasses.
+        self.routes = [x for x in self.routes if x not in unavailable]
 
         for route in self.routes:
             getattr(self, route)()

{fastapi_rtk-2.11.2 → fastapi_rtk-2.11.4}/fastapi_rtk/api/model_rest_api/_info_mixin.py

@@ -205,7 +205,7 @@ class InfoMixin(_TypedModelRestApi):
 
             filters = self.cache.get(f"info_filters_{col}", None)
             if not filters:
-                filters = datamodel.filters[col_to_get]
+                filters = list(datamodel.filters[col_to_get])
                 # Add search filters and search exclude filters to the filters
                 if "." in col:
                     filters.extend(self.datamodel.filters[col])

{fastapi_rtk-2.11.2 → fastapi_rtk-2.11.4}/fastapi_rtk/backends/sqla/db.py

@@ -140,15 +140,18 @@ class SQLAQueryBuilder(AbstractQueryBuilder[sqlalchemy.Select[tuple[T]]]):
         if "." in col:
             col, rel_col = col.split(".", 1)
             rel_interface = self.datamodel.get_related_interface(col)
-            rel_interface.filters[rel_col].extend(
-                self.datamodel.filters.get(filter.col, [])
-            )
-            rel_interface.filters[rel_col] = [
+            # The related interface is shared by every Api and query touching
+            # that relation, so resolve into a local list instead of growing its
+            # own.
+            excluded = self.datamodel.exclude_filters.get(filter.col, [])
+            filter_classes = [
                 f
-                for f in rel_interface.filters[rel_col]
-                if f.arg_name not in self.datamodel.exclude_filters.get(filter.col, [])
+                for f in [
+                    *rel_interface.filters[rel_col],
+                    *self.datamodel.filters.get(filter.col, []),
+                ]
+                if f.arg_name not in excluded
             ]
-            filter_classes = rel_interface.filters.get(rel_col, [])
         else:
             filter_classes = self.datamodel.filters.get(col, [])
         filter_class = None

{fastapi_rtk-2.11.2 → fastapi_rtk-2.11.4}/fastapi_rtk/backends/sqla/extensions/audit/_lifecycle_mixin.py

@@ -19,7 +19,7 @@ from ._logger import logger
 from .types import AuditEntry
 
 if typing.TYPE_CHECKING:
-    import collections
+    import weakref
 
     from .types import SQLAModel
 
@@ -51,11 +51,11 @@ class LifecycleMixin:
                 None | collections.abc.Coroutine[typing.Any, typing.Any, None],
             ]
         ]
-        _session_pending_entries: collections.defaultdict[
+        _session_pending_entries: weakref.WeakKeyDictionary[
             sqlalchemy.orm.Session, list[AuditEntry]
         ]
-        _session_is_commited: collections.defaultdict[SQLASession, bool]
-        _session_callbacks_after_commit: collections.defaultdict[
+        _session_is_commited: weakref.WeakKeyDictionary[sqlalchemy.orm.Session, bool]
+        _session_callbacks_after_commit: weakref.WeakKeyDictionary[
             sqlalchemy.orm.Session,
             list[
                 collections.abc.Callable[
@@ -194,13 +194,18 @@ class LifecycleMixin:
             e: The exception raised during the insert.
         """
         try:
-            is_commited = cls._session_is_commited[session]
+            session_key = _session_key(session) if session else None
+            is_commited = (
+                cls._session_is_commited.get(session_key, False)
+                if session_key
+                else False
+            )
             if is_commited:
                 logger.warning(
                     "Session has already been committed, creating a new session to insert audit entries."
                 )
                 commit = is_commited
-                del cls._session_is_commited[session]
+                del cls._session_is_commited[session_key]
                 session = None
             if not session:
                 async with db.session(cls.model.__bind_key__) as session:
@@ -242,7 +247,9 @@ class LifecycleMixin:
                         cls._run_callbacks, entries=entries
                     )
 
-                cls._session_callbacks_after_commit[session].append(callback_for_commit)
+                cls._session_callbacks_after_commit.setdefault(session_key, []).append(
+                    callback_for_commit
+                )
         except Exception as e:
             logger.error(f"Error inserting audit entries: {e}")
             if not raise_exception:
@@ -268,9 +275,10 @@ class LifecycleMixin:
             logger.debug("No models to be audited in `after_flush`.")
             return
 
-        pending_entries = cls._session_pending_entries[session]
+        session_key = _session_key(session)
+        pending_entries = cls._session_pending_entries.setdefault(session_key, [])
         pending_entries.extend(audit_entries)
-        cls._session_pending_entries[session] = (
+        cls._session_pending_entries[session_key] = (
             cls._merge_update_entries(pending_entries)
             if cls._coalesce_updates
             else pending_entries
@@ -284,7 +292,8 @@ class LifecycleMixin:
         Args:
             session (sqlalchemy.orm.Session): The SQLAlchemy session that is about to be committed.
         """
-        entries = cls._session_pending_entries.pop(session, [])
+        session_key = _session_key(session)
+        entries = cls._session_pending_entries.pop(session_key, [])
         if not entries:
             return
 
@@ -298,7 +307,9 @@ class LifecycleMixin:
                     name=f"{cls.__name__}.insert_entries",
                 )
 
-            cls._session_callbacks_after_commit[session].append(callback_for_commit)
+            cls._session_callbacks_after_commit.setdefault(session_key, []).append(
+                callback_for_commit
+            )
             return
 
         existing_session = (
@@ -329,7 +340,9 @@ class LifecycleMixin:
                 commit=True,
             )
 
-        cls._session_callbacks_after_commit[session].append(callback_for_commit)
+        cls._session_callbacks_after_commit.setdefault(session_key, []).append(
+            callback_for_commit
+        )
 
     @classmethod
     def _after_commit(cls, session: sqlalchemy.orm.Session):
@@ -339,9 +352,10 @@ class LifecycleMixin:
         Args:
             session (sqlalchemy.orm.Session): The SQLAlchemy session that was committed.
         """
-        cls._session_is_commited[session] = True
-        callbacks = cls._session_callbacks_after_commit.pop(session, [])
-        cls._session_pending_entries.pop(session, None)
+        session_key = _session_key(session)
+        cls._session_is_commited[session_key] = True
+        callbacks = cls._session_callbacks_after_commit.pop(session_key, [])
+        cls._session_pending_entries.pop(session_key, None)
         if not callbacks:
             logger.debug("No callbacks to run in `after_commit`.")
             return
@@ -356,8 +370,9 @@ class LifecycleMixin:
         Args:
             session (sqlalchemy.orm.Session): The SQLAlchemy session that was rolled back.
         """
-        cls._session_callbacks_after_commit.pop(session, None)
-        cls._session_pending_entries.pop(session, None)
+        session_key = _session_key(session)
+        cls._session_callbacks_after_commit.pop(session_key, None)
+        cls._session_pending_entries.pop(session_key, None)
         logger.debug("Rolled back changes in session, clearing callbacks.")
 
     """
@@ -419,3 +434,18 @@ class LifecycleMixin:
                 logger.error(
                     f"Error running async function {async_function.__name__} in threadpool and no AsyncTaskRunner is available to delegate the task to: {e}"
                 )
+
+
+def _session_key(session: SQLASession) -> sqlalchemy.orm.Session:
+    """
+    Resolve the object a session is keyed by in the session-keyed class state.
+
+    The session event handlers always receive the sync session, so an async caller must be reduced to the same object or its lookups never match.
+
+    Args:
+        session (SQLASession): The session held by the caller.
+
+    Returns:
+        sqlalchemy.orm.Session: The sync session the event handlers see.
+    """
+    return getattr(session, "sync_session", session)

{fastapi_rtk-2.11.2 → fastapi_rtk-2.11.4}/fastapi_rtk/backends/sqla/extensions/audit/audit.py

@@ -19,6 +19,7 @@ import collections
 import collections.abc
 import datetime
 import typing
+import weakref
 
 import pydantic
 import sqlalchemy.dialects.postgresql
@@ -35,7 +36,6 @@ from .....utils import (
 from ...column import mapped_column
 from ...interface import SQLAInterface
 from ...model import Model
-from ...session import SQLASession
 from ._decorators_mixin import DecoratorsMixin
 from ._lifecycle_mixin import LifecycleMixin
 from ._processing_mixin import ProcessingMixin
@@ -220,26 +220,26 @@ class Audit(
     The scheduler for running audit inserts and callbacks in the background.
     """
 
-    _session_callbacks_after_commit = collections.defaultdict[
+    _session_callbacks_after_commit = weakref.WeakKeyDictionary[
         sqlalchemy.orm.Session,
         list[
             collections.abc.Callable[
                 [], None | collections.abc.Coroutine[typing.Any, typing.Any, None]
             ]
-        ](),
-    ](list)
+        ],
+    ]()
     """
-    Dictionary mapping SQLAlchemy sessions to their commit callbacks.
+    Dictionary mapping SQLAlchemy sessions to their commit callbacks. Weakly keyed, so an entry cannot outlive its session.
     """
-    _session_is_commited = collections.defaultdict[SQLASession, bool](bool)
+    _session_is_commited = weakref.WeakKeyDictionary[sqlalchemy.orm.Session, bool]()
     """
-    Dictionary mapping SQLAlchemy sessions to a flag indicating if they have been committed.
+    Dictionary mapping SQLAlchemy sessions to a flag indicating if they have been committed. Weakly keyed, so an entry cannot outlive its session.
     """
-    _session_pending_entries = collections.defaultdict[
+    _session_pending_entries = weakref.WeakKeyDictionary[
         sqlalchemy.orm.Session, list[AuditEntry]
-    ](list)
+    ]()
     """
-    Dictionary mapping SQLAlchemy sessions to pending audit entries collected across flushes.
+    Dictionary mapping SQLAlchemy sessions to pending audit entries collected across flushes. Weakly keyed, so an entry cannot outlive its session.
     """
     _coalesce_updates = True
     """

{fastapi_rtk-2.11.2 → fastapi_rtk-2.11.4}/fastapi_rtk/bases/interface.py

@@ -2,6 +2,7 @@ import abc
 import asyncio
 import collections
 import collections.abc
+import copy
 import enum
 import inspect
 import typing
@@ -14,6 +15,7 @@ from ..exceptions import FastAPIReactToolkitException, raise_exception
 from ..globals import g
 from ..schemas import PRIMARY_KEY, ColumnEnumInfo, ColumnInfo, ColumnRelationInfo
 from ..utils import AsyncTaskRunner, C, T, deep_merge, lazy_self, smart_run
+from ..utils import lazy as o_lazy
 from .db import DBQueryParams
 from .file_manager import AbstractFileManager, AbstractImageManager
 from .filter import AbstractBaseFilter, AbstractBaseOprFilter
@@ -222,6 +224,20 @@ class AbstractInterface(abc.ABC, typing.Generic[T, C, CT]):
         self.obj = obj
         self.with_fk = with_fk
 
+    def clone(self) -> typing.Self:
+        """
+        Returns a copy of this interface with its cached lazy attributes reset.
+
+        Cached lazy attributes hold per-owner state, so a copy that kept them would still be mutated by every owner.
+
+        Returns:
+            typing.Self: A copy bound to the same model, with its cached lazy attributes unset.
+        """
+        clone = copy.copy(self)
+        for name in [x for x in clone.__dict__ if o_lazy.is_lazy(type(self), x)]:
+            del clone.__dict__[name]
+        return clone
+
     """
     --------------------------------------------------------------------------------------------------------
         DEPENDENCIES METHODS - to be implemented

{fastapi_rtk-2.11.2 → fastapi_rtk-2.11.4}/pyproject.toml

@@ -37,7 +37,7 @@ dependencies = [
   "pip-licenses>=5.5.1",
   "polib>=1.2.0",
   "prometheus-fastapi-instrumentator>=7.1.0",
-  "secweb>=1.25.2",
+  "secweb>=1.25.2,<2",
   "sqlalchemy-utils>=0.42.0",
   "werkzeug>=3.1.5",
 ]

{fastapi_rtk-2.11.2 → fastapi_rtk-2.11.4}/tests/unit/api/model_rest_api/test_init.py

@@ -62,6 +62,79 @@ class TestConstructor:
         assert called == ["ps"]
 
 
+class TestDatamodelClonedPerSubclass:
+    """A subclass that inherits ``datamodel`` gets its own copy of the
+    interface, so per-owner state (e.g. ``opr_filters``) is never shared."""
+
+    def test_subclass_without_datamodel_gets_own_interface(self, Widget_cls):
+        class TierDMBaseApi(ModelRestApi):
+            datamodel = SQLAInterface(Widget_cls)
+
+        class TierDMChildApi(TierDMBaseApi):
+            pass
+
+        class TierDMGrandchildApi(TierDMChildApi):
+            pass
+
+        assert TierDMChildApi.datamodel is not TierDMBaseApi.datamodel
+        assert TierDMChildApi.datamodel.obj is Widget_cls
+        assert TierDMGrandchildApi.datamodel is not TierDMChildApi.datamodel
+        assert TierDMGrandchildApi.datamodel is not TierDMBaseApi.datamodel
+        assert TierDMGrandchildApi.datamodel.obj is Widget_cls
+
+    def test_subclass_declaring_datamodel_keeps_identity(self, Widget_cls):
+        shared = SQLAInterface(Widget_cls)
+
+        class TierDMSharedAApi(ModelRestApi):
+            datamodel = shared
+
+        class TierDMSharedBApi(ModelRestApi):
+            datamodel = shared
+
+        assert TierDMSharedAApi.datamodel is shared
+        assert TierDMSharedBApi.datamodel is shared
+
+    def test_subclass_with_no_datamodel_anywhere_does_not_crash_at_definition(self):
+        class TierDMNoDatamodelApi(ModelRestApi):
+            pass
+
+        with pytest.raises(Exception, match="datamodel must be set"):
+            TierDMNoDatamodelApi()
+
+    def test_per_class_opr_filters_isolation(self, Widget_cls):
+        from fastapi_rtk.backends.sqla.filters import BaseOprFilter
+
+        class OprFilterA(BaseOprFilter):
+            name = "A"
+            arg_name = "opr_a"
+
+            def apply(self, statement, value):
+                return statement
+
+        class OprFilterB(BaseOprFilter):
+            name = "B"
+            arg_name = "opr_b"
+
+            def apply(self, statement, value):
+                return statement
+
+        class TierDMOprBaseApi(ModelRestApi):
+            datamodel = SQLAInterface(Widget_cls)
+
+        class TierDMOprAApi(TierDMOprBaseApi):
+            opr_filters = [OprFilterA]
+
+        class TierDMOprBApi(TierDMOprBaseApi):
+            opr_filters = [OprFilterB]
+
+        api_a = TierDMOprAApi()
+        api_b = TierDMOprBApi()
+
+        assert api_a.datamodel is not api_b.datamodel
+        assert [type(f) for f in api_a.datamodel.opr_filters] == [OprFilterA]
+        assert [type(f) for f in api_b.datamodel.opr_filters] == [OprFilterB]
+
+
 class TestRoutesList:
     def test_default_routes(self, Widget_cls):
         class TierRApi(ModelRestApi):
@@ -354,3 +427,157 @@ class TestInitPropertiesBranches:
         api = Api()
         # Filters should be initialized (instantiated)
         assert len(api.add_query_rel_fields["country"]) == 1
+
+
+class TestSubclassIdempotency:
+    """Instantiating several Api classes of one inheritance chain must not stack
+    state on the shared datamodel or rewrite shared class attributes."""
+
+    def test_search_filters_not_stacked_by_subclasses(self, Widget_cls):
+        from fastapi_rtk.backends.sqla.filters import FilterEqual
+
+        class Parent(ModelRestApi):
+            datamodel = SQLAInterface(Widget_cls)
+            search_filters = {"name": [FilterEqual]}
+
+        class Child(Parent):
+            pass
+
+        class GrandChild(Child):
+            pass
+
+        parent = Parent()
+
+        def count():
+            return sum(
+                isinstance(f, FilterEqual) for f in parent.datamodel.filters["name"]
+            )
+
+        expected = count()
+        assert expected >= 1
+
+        Child()
+        GrandChild()
+        Parent()
+        assert count() == expected
+
+    def test_search_exclude_filters_not_stacked_by_subclasses(self, Widget_cls):
+        class Parent(ModelRestApi):
+            datamodel = SQLAInterface(Widget_cls)
+            search_exclude_filters = {"name": ["eq"]}
+
+        class Child(Parent):
+            pass
+
+        Parent()
+        Child()
+        Child()
+        assert Parent.datamodel.exclude_filters["name"] == ["eq"]
+        assert Child.datamodel.exclude_filters["name"] == ["eq"]
+
+    def test_query_rel_fields_survive_second_instantiation(self, WidgetWithCountry_cls):
+        from fastapi_rtk.backends.sqla.filters import FilterEqual
+
+        class Parent(ModelRestApi):
+            datamodel = SQLAInterface(WidgetWithCountry_cls)
+            add_query_rel_fields = {"country": [["name", FilterEqual, "Germany"]]}
+            edit_query_rel_fields = {"country": [["name", FilterEqual, "Germany"]]}
+            search_query_rel_fields = {"country": [["name", FilterEqual, "Germany"]]}
+
+        class Child(Parent):
+            pass
+
+        Parent()
+        assert Parent.add_query_rel_fields["country"][0][1] is FilterEqual
+
+        child = Child()
+        assert isinstance(child.add_query_rel_fields["country"][0][1], FilterEqual)
+        assert isinstance(child.edit_query_rel_fields["country"][0][1], FilterEqual)
+        assert isinstance(child.search_query_rel_fields["country"][0][1], FilterEqual)
+
+    def test_routes_class_attribute_not_mutated(self, Widget_cls):
+        class Parent(ModelRestApi):
+            datamodel = SQLAInterface(Widget_cls)
+            routes = ["info", "get_list", "image"]
+
+        class Child(Parent):
+            pass
+
+        Parent()
+        assert Parent.routes == ["info", "get_list", "image"]
+
+        child = Child()
+        assert "image" not in child.routes
+        assert Parent.routes == ["info", "get_list", "image"]
+
+    def test_routes_and_permissions_are_per_instance(self, Widget_cls):
+        class Parent(ModelRestApi):
+            datamodel = SQLAInterface(Widget_cls)
+
+        class Child(Parent):
+            pass
+
+        parent = Parent()
+        child = Child()
+        assert len(child.routes_to_register) == len(parent.routes_to_register)
+        assert len(child.permissions) == len(parent.permissions)
+
+
+class TestInfoSchemaDottedSearchFiltersNotStacked:
+    """``_generate_info_schema`` builds the ``/_info`` filter list for a dotted
+    search column from ``related_interface.filters[rel_col]``, a list shared by
+    every Api instance touching that relation. Aliasing it instead of copying
+    let repeated instantiation of Api classes on one inheritance chain grow it
+    by one duplicate operator each time.
+    """
+
+    @pytest.fixture
+    def dotted_search_api_cls(self, WidgetWithCountry_cls):
+        from fastapi_rtk.backends.sqla.filters import FilterEqual
+
+        class Api(ModelRestApi):
+            datamodel = SQLAInterface(WidgetWithCountry_cls)
+            search_columns = ["country.name"]
+            # `search_filters` on a dotted key lands on the root datamodel's own
+            # ``filters["country.name"]`` entry, which `_generate_info_schema`
+            # then extends the related interface's list with.
+            search_filters = {"country.name": [FilterEqual]}
+
+        return Api
+
+    async def test_related_filter_list_not_grown_across_instances(
+        self, dotted_search_api_cls
+    ):
+        api1 = dotted_search_api_cls()
+        rel_interface = api1.datamodel.get_related_interface("country")
+        before = len(rel_interface.filters["name"])
+
+        info1 = await api1._generate_info_schema([], None, None)
+        after_first = len(rel_interface.filters["name"])
+        assert after_first == before
+
+        api2 = dotted_search_api_cls()
+        info2 = await api2._generate_info_schema([], None, None)
+        after_second = len(rel_interface.filters["name"])
+        assert after_second == before
+
+        assert (
+            info1.filters["country.name"]["filters"]
+            == (info2.filters["country.name"]["filters"])
+        )
+
+    async def test_search_exclude_filters_still_removes_excluded_operator(
+        self, WidgetWithCountry_cls
+    ):
+        from fastapi_rtk.backends.sqla.filters import FilterEqual
+
+        class Api(ModelRestApi):
+            datamodel = SQLAInterface(WidgetWithCountry_cls)
+            search_columns = ["country.name"]
+            search_filters = {"country.name": [FilterEqual]}
+            search_exclude_filters = {"country.name": ["eq"]}
+
+        api = Api()
+        info = await api._generate_info_schema([], None, None)
+        operators = [f["operator"] for f in info.filters["country.name"]["filters"]]
+        assert "eq" not in operators