fastapi-rtk 2.17.0__tar.gz → 2.18.1__tar.gz

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-rtk
-Version: 2.17.0
+Version: 2.18.1
 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

fastapi_rtk-2.18.1/fastapi_rtk/_version.py

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

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/fastapi_rtk/agent_docs/guide/backend.md

@@ -551,7 +551,7 @@ The task runs later, possibly after the loop has advanced or the enclosing funct
 
 ### Sizing the `/download` stream
 
-`/download` exports every row matching the query, so it ignores `page` and `page_size` from the request; they reach the handler and are overwritten. It reads the rows in chunks, and `download_page_size` on the Api decides how large a chunk is (since the first release after v2.15.0). The default is an async method that counts the matching rows and takes a tenth of them, floored at the `API_DOWNLOAD_MIN_PAGE_SIZE` config key (default `100`).
+`/download` exports every row matching the query, so it ignores `page` and `page_size` from the request; they reach the handler and are overwritten. It reads the rows in chunks, and the `download_page_size` attribute on the Api decides how large a chunk is (since the first release after v2.15.0). It is either an int (a fixed chunk) or a resolver `(api, session, params) -> int`. It defaults to the `API_DOWNLOAD_PAGE_SIZE` config key, which is itself the built-in resolver: it counts the matching rows and takes a tenth of them, floored at the `API_DOWNLOAD_MIN_PAGE_SIZE` config key (default `100`) and capped at `API_DOWNLOAD_MAX_PAGE_SIZE` (default `1000`) so a large table cannot size the chunk into an out-of-memory read.
 
 Set it to an int for a fixed chunk, which also skips the count query the default runs:
 
@@ -561,16 +561,18 @@ class ReadingApi(ModelRestApi):
     download_page_size = 5000
 ```
 
-Override the method when the size depends on the query. It receives the session and the `DBQueryParams` the export runs with. Sync and async both work, resolved through `safe_call`, so a sync one runs inline rather than on a worker thread:
+Set it to a resolver when the size depends on the query. It receives the Api, the session, and the `DBQueryParams` the export runs with. Sync and async both work, resolved through `safe_call`, so a sync one runs inline rather than on a worker thread:
 
 ```python
 class ReadingApi(ModelRestApi):
     datamodel = SQLAInterface(Reading)
 
-    def download_page_size(self, session, params):
+    def download_page_size(api, session, params):
         return 1000 if params.get("filters") else 250
 ```
 
+Set the `API_DOWNLOAD_PAGE_SIZE` config key (an int or a `(api, session, params)` resolver) to change the default for every Api at once.
+
 The chunk size is a read size, not a limit: every matching row is exported whatever it is set to.
 
 ## 14. Permissions, roles, and auth

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/fastapi_rtk/api/model_rest_api/model_rest_api.py

@@ -15,7 +15,7 @@ plus one shared column / schema / body service:
 - ``put`` route + ``pre_update_merge`` / ``pre_update`` / ``post_update`` live on ``ModelRestApi``, backed by :class:`~.services.EditService` (``edit_service``).
 - ``delete`` route + ``pre_delete`` / ``post_delete`` live on ``ModelRestApi``, backed by :class:`~.services.DeleteService` (``delete_service``).
 - ``bulk`` route + ``bulk_handler`` stub live on ``ModelRestApi``, backed by :class:`~.services.BulkService` (``bulk_service``).
-- ``download`` route + ``download_page_size`` heuristic + CSV ``_export_data`` / ``_import_data`` helpers live on ``ModelRestApi``, backed by :class:`~.services.DownloadService` (``download_service``).
+- ``download`` route + CSV ``_export_data`` / ``_import_data`` helpers live on ``ModelRestApi``, backed by :class:`~.services.DownloadService` (``download_service``); the ``download_page_size`` config attribute holds an int or a ``(api, session, params)`` resolver, defaulting to ``default_download_page_size``.
 - Column / schema / body delegators (``_process_body``, ``_generate_jsonforms_schema``, ...) live on ``ModelRestApi``, backed by :class:`~.services.SchemaService` (``schema_service``).
 
 Class attributes (datamodel, ``*_columns``, ``*_schema``, lifecycle hooks)
@@ -87,6 +87,9 @@ from .services import (
     ShowService,
 )
 
+if typing.TYPE_CHECKING:
+    from .services._download_service import DownloadPageSizeResolver
+
 __all__ = ["ModelRestApi"]
 
 
@@ -166,6 +169,12 @@ class ModelRestApi(BaseApi):
     """
     The maximum page size for the related fields in add_columns, edit_columns, and search_columns properties.
     """
+    download_page_size: "int | DownloadPageSizeResolver" = lazy(
+        lambda: Setting.API_DOWNLOAD_PAGE_SIZE
+    )
+    """
+    How many rows the download stream reads per chunk. An int fixes the chunk size and skips the count query; a resolver `(api, session, params) -> int` computes it per request. Defaults to the `API_DOWNLOAD_PAGE_SIZE` config key, itself the built-in heuristic (a tenth of the matching rows, bounded by `API_DOWNLOAD_MIN_PAGE_SIZE` / `API_DOWNLOAD_MAX_PAGE_SIZE`).
+    """
     routes: list[AVAILABLE_ROUTES] = lazy(
         lambda self: [
             x
@@ -1944,21 +1953,6 @@ class ModelRestApi(BaseApi):
             q, session, export_mode, delimiter, quotechar, label, check_validity
         )
 
-    async def download_page_size(self, session: SQLASession, params: DBQueryParams):
-        """
-        Decide how many rows the download stream reads per chunk.
-
-        Set the attribute to an int instead to fix the chunk size and skip the count query this default runs.
-
-        Args:
-            session (SQLASession): A database scoped session.
-            params (DBQueryParams): The query parameters the export runs with.
-
-        Returns:
-            int: The number of rows to read per chunk.
-        """
-        return await self.download_service.download_page_size(session, params)
-
     def _export_data(
         self,
         data: list[Model],

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/fastapi_rtk/api/model_rest_api/services/_download_service.py

@@ -7,6 +7,7 @@ Reachable as ``self.download_service`` on the manager. Holds the
 streamer, and the disabled ``import_data`` upload helper.
 """
 
+import collections.abc
 import csv
 import typing
 
@@ -27,6 +28,12 @@ if typing.TYPE_CHECKING:
     from .. import ModelRestApi
 
 
+DownloadPageSizeResolver = collections.abc.Callable[
+    ["ModelRestApi", SQLASession, DBQueryParams],
+    "int | collections.abc.Awaitable[int]",
+]
+
+
 class DownloadService:
     """
     Download-route logic shared by the download route.
@@ -103,7 +110,7 @@ class DownloadService:
             params = self.api._handle_query_params(q)
             page_size = self.api.download_page_size
             if callable(page_size):
-                page_size = await safe_call(page_size(session, params))
+                page_size = await safe_call(page_size(self.api, session, params))
             params["page_size"] = page_size
             return fastapi.responses.StreamingResponse(
                 self.api._export_data(
@@ -121,22 +128,6 @@ class DownloadService:
                 },
             )
 
-    async def download_page_size(self, session: SQLASession, params: DBQueryParams):
-        """
-        Decide how many rows the download stream reads per chunk.
-
-        Set the attribute to an int instead to fix the chunk size and skip the count query this default runs.
-
-        Args:
-            session (SQLASession): A database scoped session.
-            params (DBQueryParams): The query parameters the export runs with.
-
-        Returns:
-            int: The number of rows to read per chunk.
-        """
-        count = await smart_run(self.api.datamodel.count, session, params)
-        return max(count // 10, Setting.API_DOWNLOAD_MIN_PAGE_SIZE)
-
     async def export_data(
         self,
         data: list[Model],
@@ -286,3 +277,26 @@ class DownloadService:
         await smart_run(self.api.datamodel.commit, session)
 
         return list_data
+
+
+async def default_download_page_size(
+    api: "ModelRestApi", session: SQLASession, params: DBQueryParams
+) -> int:
+    """
+    Decide how many rows the download stream reads per chunk.
+
+    Takes a tenth of the matching rows, floored at `API_DOWNLOAD_MIN_PAGE_SIZE` and capped at `API_DOWNLOAD_MAX_PAGE_SIZE` so a large table cannot size the chunk into an out-of-memory read. Set `download_page_size` to an int to fix the chunk size and skip the count query this runs, or to another resolver with this signature to replace the heuristic.
+
+    Args:
+        api (ModelRestApi): The manager whose datamodel the export runs against.
+        session (SQLASession): A database scoped session.
+        params (DBQueryParams): The query parameters the export runs with.
+
+    Returns:
+        int: The number of rows to read per chunk.
+    """
+    count = await smart_run(api.datamodel.count, session, params)
+    return min(
+        max(count // 10, Setting.API_DOWNLOAD_MIN_PAGE_SIZE),
+        Setting.API_DOWNLOAD_MAX_PAGE_SIZE,
+    )

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/fastapi_rtk/backends/sqla/filters.py

@@ -145,6 +145,30 @@ class BaseFilter(AbstractBaseFilter[sqlalchemy.Select[Model]]):
             )
             return value
 
+    def _upper_bound(self, value: typing.Any, original_value: typing.Any):
+        """
+        Extend an already-cast value to its inclusive upper bound.
+
+        A datetime cast from a date-only string reaches the end of its day
+        (23:59:59.999999); any other value is its own upper bound.
+
+        Args:
+            value (typing.Any): The value already cast by `_cast_value`.
+            original_value (typing.Any): The raw filter value before casting.
+
+        Returns:
+            typing.Any: The upper bound value.
+        """
+        if not isinstance(value, datetime.datetime) or not isinstance(
+            original_value, str
+        ):
+            return value
+        try:
+            datetime.date.fromisoformat(original_value)
+        except ValueError:
+            return value
+        return value.replace(hour=23, minute=59, second=59, microsecond=999999)
+
 
 class BaseFilterTextContains(BaseFilter):
     def _build_concat_expr(self, col_objs: list[sqlalchemy.ColumnElement]):
@@ -297,8 +321,12 @@ class FilterEqual(BaseFilter):
     arg_name = "eq"
 
     def apply(self, statement, col: str, value):
-        col, value = self._cast_col_and_value(col, value)
-        return statement.filter(col == value)
+        lower = self._cast_value(col, value)
+        upper = self._upper_bound(lower, value)
+        col_obj = self._cast_column(col, lower)
+        if lower == upper:
+            return statement.filter(col_obj == lower)
+        return statement.filter(col_obj.between(lower, upper))
 
 
 class FilterNotEqual(BaseFilter):
@@ -306,8 +334,12 @@ class FilterNotEqual(BaseFilter):
     arg_name = "neq"
 
     def apply(self, statement, col: str, value):
-        col, value = self._cast_col_and_value(col, value)
-        return statement.filter(col != value)
+        lower = self._cast_value(col, value)
+        upper = self._upper_bound(lower, value)
+        col_obj = self._cast_column(col, lower)
+        if lower == upper:
+            return statement.filter(col_obj != lower)
+        return statement.filter(~col_obj.between(lower, upper))
 
 
 class FilterStartsWith(BaseFilter):
@@ -396,8 +428,9 @@ class FilterSmallerEqual(BaseFilter):
     arg_name = "le"
 
     def apply(self, statement, col: str, value):
-        col, value = self._cast_col_and_value(col, value)
-        return statement.filter(col <= value)
+        upper = self._upper_bound(self._cast_value(col, value), value)
+        col_obj = self._cast_column(col, upper)
+        return statement.filter(col_obj <= upper)
 
 
 class FilterIn(BaseFilter):
@@ -427,12 +460,13 @@ class FilterBetween(BaseFilter):
                 value,
             )
 
-        value = [self._cast_value(col, v) for v in value]
-        if value[0] is None or value[1] is None:
+        lower = self._cast_value(col, value[0])
+        upper = self._upper_bound(self._cast_value(col, value[1]), value[1])
+        if lower is None or upper is None:
             return statement
 
-        col = self._cast_column(col, value)
-        return statement.filter(col.between(value[0], value[1]))
+        col = self._cast_column(col, [lower, upper])
+        return statement.filter(col.between(lower, upper))
 
 
 class FilterRelationOneToOneOrManyToOneEqual(

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/fastapi_rtk/backends/sqla/interface.py

@@ -157,6 +157,14 @@ class SQLAInterface(
             if not chunk:
                 break
             yield chunk
+
+            # Expunge consumed rows one by one; expunge_all() swaps the identity
+            # map the streaming result still holds, killing mid-stream fetches.
+            def expunge_chunk() -> None:
+                for item in chunk:
+                    session.expunge(item)
+
+            await smart_run(expunge_chunk)
         await safe_call(self.close(session))
 
     async def add(self, session, item, *, flush=True, commit=True, refresh=True):

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/fastapi_rtk/const.py

@@ -73,6 +73,7 @@ DEFAULT_PUBLIC_ROLE = "Public"
 DEFAULT_API_PAGE_SIZE = 25
 DEFAULT_API_MAX_PAGE_SIZE = 25
 DEFAULT_API_DOWNLOAD_MIN_PAGE_SIZE = 100
+DEFAULT_API_DOWNLOAD_MAX_PAGE_SIZE = 1000
 DEFAULT_TOKEN_URL = "/api/v1/auth/jwt/login"
 DEFAULT_SECRET = "SUPERSECRET"
 DEFAULT_COOKIE_NAME = "dataTactics"

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/fastapi_rtk/setting.py

@@ -2,6 +2,7 @@ import typing
 
 from .const import (
     DEFAULT_ADMIN_ROLE,
+    DEFAULT_API_DOWNLOAD_MAX_PAGE_SIZE,
     DEFAULT_API_DOWNLOAD_MIN_PAGE_SIZE,
     DEFAULT_API_MAX_PAGE_SIZE,
     DEFAULT_API_PAGE_SIZE,
@@ -21,6 +22,9 @@ from .exceptions import FastAPIReactToolkitException
 from .globals import g
 
 if typing.TYPE_CHECKING:
+    from .api.model_rest_api.services._download_service import (
+        DownloadPageSizeResolver,
+    )
     from .bases.file_manager import AbstractFileManager, AbstractImageManager
     from .bases.loop_manager import AbstractLoopManager
     from .bases.user_cache import AbstractUserSerializer
@@ -90,6 +94,20 @@ class _Setting:
             "API_DOWNLOAD_MIN_PAGE_SIZE", DEFAULT_API_DOWNLOAD_MIN_PAGE_SIZE
         )
 
+    @property
+    def API_DOWNLOAD_MAX_PAGE_SIZE(self) -> int:
+        return g.config.get(
+            "API_DOWNLOAD_MAX_PAGE_SIZE", DEFAULT_API_DOWNLOAD_MAX_PAGE_SIZE
+        )
+
+    @property
+    def API_DOWNLOAD_PAGE_SIZE(self) -> "int | DownloadPageSizeResolver":
+        from .api.model_rest_api.services._download_service import (
+            default_download_page_size,
+        )
+
+        return g.config.get("API_DOWNLOAD_PAGE_SIZE", default_download_page_size)
+
     @property
     def TEXT_FILTER_SEPARATOR(self) -> str:
         return g.config.get("TEXT_FILTER_SEPARATOR", ";")

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/tests/integration/api/test_model_rest_api.py

@@ -15,7 +15,10 @@ import types
 import pytest
 import sqlalchemy
 
-from fastapi_rtk.const import DEFAULT_API_DOWNLOAD_MIN_PAGE_SIZE
+from fastapi_rtk.const import (
+    DEFAULT_API_DOWNLOAD_MAX_PAGE_SIZE,
+    DEFAULT_API_DOWNLOAD_MIN_PAGE_SIZE,
+)
 from fastapi_rtk.schemas import GeneralResponse
 from fastapi_rtk.utils import smart_run
 
@@ -713,6 +716,26 @@ class TestDownloadPageSize:
         assert response.status_code == 200
         assert streamed_params["page_size"] == 500
 
+    async def test_page_size_is_capped_at_maximum(
+        self,
+        client,
+        admin_token,
+        seeded_widgets,
+        widgets_api,
+        monkeypatch,
+        streamed_params,
+    ):
+        async def count(session, params=None):
+            return 200000
+
+        monkeypatch.setattr(widgets_api.datamodel, "count", count)
+        response = await client.get(
+            "/api/v1/widgets/download",
+            headers={"Authorization": f"Bearer {admin_token}"},
+        )
+        assert response.status_code == 200
+        assert streamed_params["page_size"] == DEFAULT_API_DOWNLOAD_MAX_PAGE_SIZE
+
     async def test_int_page_size_skips_the_count(
         self,
         client,
@@ -754,8 +777,8 @@ class TestDownloadPageSize:
             counted.append(params)
             return 5000
 
-        def download_page_size(session, params):
-            seen.append((session, params))
+        def download_page_size(api, session, params):
+            seen.append((api, session, params))
             return 42
 
         monkeypatch.setattr(widgets_api.datamodel, "count", count)
@@ -767,7 +790,8 @@ class TestDownloadPageSize:
         assert response.status_code == 200
         assert streamed_params["page_size"] == 42
         assert counted == []
-        assert seen[0][0] is not None and "list_columns" in seen[0][1]
+        assert seen[0][0] is widgets_api
+        assert seen[0][1] is not None and "list_columns" in seen[0][2]
 
     async def test_async_callable_page_size(
         self,
@@ -778,8 +802,8 @@ class TestDownloadPageSize:
         monkeypatch,
         streamed_params,
     ):
-        async def download_page_size(session, params):
-            return await smart_run(widgets_api.datamodel.count, session, params) + 7
+        async def download_page_size(api, session, params):
+            return await smart_run(api.datamodel.count, session, params) + 7
 
         monkeypatch.setattr(widgets_api, "download_page_size", download_page_size)
         response = await client.get(

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/tests/unit/api/model_rest_api/test_service_delegators.py

@@ -51,7 +51,6 @@ DELEGATOR_PARITY.append(("bulk_headless", BulkService, "dispatch"))
 from fastapi_rtk.api.model_rest_api.services._download_service import DownloadService
 
 DELEGATOR_PARITY.append(("download_headless", DownloadService, "download"))
-DELEGATOR_PARITY.append(("download_page_size", DownloadService, "download_page_size"))
 DELEGATOR_PARITY.append(("_export_data", DownloadService, "export_data"))
 DELEGATOR_PARITY.append(("_import_data", DownloadService, "import_data"))
 

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/tests/unit/backends/sqla/conftest.py

@@ -4,6 +4,8 @@ Models defined once at module load to avoid SAWarning on re-declaration
 and to keep relationship registry consistent across tests.
 """
 
+import datetime
+
 import pytest
 import sqlalchemy
 import sqlalchemy.orm
@@ -24,6 +26,7 @@ class Person(Model):
     name = sqlalchemy.Column(sqlalchemy.String(50), nullable=False)
     age = sqlalchemy.Column(sqlalchemy.Integer)
     active = sqlalchemy.Column(sqlalchemy.Boolean, default=True)
+    born_at = sqlalchemy.Column(sqlalchemy.DateTime)
     country_id = sqlalchemy.Column(
         sqlalchemy.Integer, sqlalchemy.ForeignKey("tier8_country.id")
     )
@@ -109,9 +112,30 @@ def session(engine):
         )
         s.add_all(
             [
-                Person(id=1, name="Alice", age=20, active=True, country_id=1),
-                Person(id=2, name="Bob", age=30, active=True, country_id=1),
-                Person(id=3, name="Carol", age=40, active=False, country_id=2),
+                Person(
+                    id=1,
+                    name="Alice",
+                    age=20,
+                    active=True,
+                    country_id=1,
+                    born_at=datetime.datetime(2026, 9, 10, 9, 0, 0),
+                ),
+                Person(
+                    id=2,
+                    name="Bob",
+                    age=30,
+                    active=True,
+                    country_id=1,
+                    born_at=datetime.datetime(2026, 9, 10, 23, 30, 0),
+                ),
+                Person(
+                    id=3,
+                    name="Carol",
+                    age=40,
+                    active=False,
+                    country_id=2,
+                    born_at=datetime.datetime(2026, 9, 11, 12, 0, 0),
+                ),
             ]
         )
         s.commit()

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/tests/unit/backends/sqla/test_filters.py

@@ -1,3 +1,4 @@
+import datetime
 import unittest.mock
 
 import pytest
@@ -131,6 +132,75 @@ class TestFilterBetween:
         assert len(result) == 3  # NULL bounds skip filter
 
 
+class TestFilterDatetimeDaySpan:
+    """A date-only value on a datetime column spans the whole day; a value
+    carrying a time stays an exact instant. Alice=2026-09-10 09:00, Bob=2026-09-10
+    23:30, Carol=2026-09-11 12:00."""
+
+    def test_equal_date_only_spans_day(self, session, iface):
+        result = _exec(session, iface, FilterEqual, "born_at", "2026-09-10")
+        assert sorted(p.name for p in result) == ["Alice", "Bob"]
+
+    def test_equal_with_time_is_exact(self, session, iface):
+        result = _exec(session, iface, FilterEqual, "born_at", "2026-09-10T09:00:00")
+        assert [p.name for p in result] == ["Alice"]
+
+    def test_not_equal_date_only_excludes_whole_day(self, session, iface):
+        result = _exec(session, iface, FilterNotEqual, "born_at", "2026-09-10")
+        assert [p.name for p in result] == ["Carol"]
+
+    def test_between_date_only_upper_includes_end_of_day(self, session, iface):
+        result = _exec(
+            session, iface, FilterBetween, "born_at", ["2026-09-01", "2026-09-10"]
+        )
+        assert sorted(p.name for p in result) == ["Alice", "Bob"]
+
+    def test_between_upper_with_time_does_not_span(self, session, iface):
+        result = _exec(
+            session,
+            iface,
+            FilterBetween,
+            "born_at",
+            ["2026-09-10", "2026-09-10T20:00:00"],
+        )
+        assert [p.name for p in result] == ["Alice"]
+
+    def test_smaller_equal_date_only_includes_end_of_day(self, session, iface):
+        result = _exec(session, iface, FilterSmallerEqual, "born_at", "2026-09-10")
+        assert sorted(p.name for p in result) == ["Alice", "Bob"]
+
+    def test_greater_equal_date_only_starts_at_midnight(self, session, iface):
+        result = _exec(session, iface, FilterGreaterEqual, "born_at", "2026-09-11")
+        assert [p.name for p in result] == ["Carol"]
+
+
+class TestUpperBound:
+    def test_date_only_string_reaches_end_of_day(self, iface):
+        f = FilterSmallerEqual(iface)
+        cast = datetime.datetime(2026, 9, 10, 0, 0, 0)
+        assert f._upper_bound(cast, "2026-09-10") == datetime.datetime(
+            2026, 9, 10, 23, 59, 59, 999999
+        )
+
+    def test_datetime_string_is_exact(self, iface):
+        f = FilterSmallerEqual(iface)
+        cast = datetime.datetime(2026, 9, 10, 9, 0, 0)
+        assert f._upper_bound(cast, "2026-09-10T09:00:00") == cast
+
+    def test_non_string_original_value_is_not_spanned(self, iface):
+        f = FilterSmallerEqual(iface)
+        cast = datetime.datetime(2026, 9, 10, 9, 0, 0)
+        assert f._upper_bound(cast, cast) == cast
+
+    def test_none_value_returns_none(self, iface):
+        f = FilterSmallerEqual(iface)
+        assert f._upper_bound(None, "NULL") is None
+
+    def test_non_datetime_value_is_unchanged(self, iface):
+        f = FilterSmallerEqual(iface)
+        assert f._upper_bound(30, "30") == 30
+
+
 class TestFilterTextContains:
     def test_basic(self, session, iface):
         result = _exec(session, iface, FilterTextContains, "name", "lic")

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/tests/unit/backends/sqla/test_interface.py

@@ -4,6 +4,7 @@ import enum
 
 import pytest
 import sqlalchemy
+import sqlalchemy.ext.asyncio
 import sqlalchemy.orm
 
 from fastapi_rtk import (
@@ -35,6 +36,12 @@ class _RichModel(Model):
     score: Mapped[float | None] = mapped_column(sqlalchemy.Float)
 
 
+class _StreamRow(Model):
+    __tablename__ = "tier8_stream"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str | None] = mapped_column(sqlalchemy.String(50))
+
+
 @pytest.fixture
 def rich_iface():
     return SQLAInterface(_RichModel)
@@ -372,6 +379,38 @@ class TestCRUD:
         total = sum(len(c) for c in chunks)
         assert total == 3
 
+    async def test_yield_per_expunges_consumed_rows(self, session, iface, monkeypatch):
+        expunged = []
+        original = session.expunge
+
+        def expunge(item):
+            expunged.append(item)
+            original(item)
+
+        monkeypatch.setattr(session, "expunge", expunge)
+        async for _chunk in iface.yield_per(session, {"page_size": 2}):
+            pass
+        assert len(expunged) == 3
+
+    async def test_yield_per_async_survives_chunk_boundary(self):
+        engine = sqlalchemy.ext.asyncio.create_async_engine("sqlite+aiosqlite://")
+        try:
+            async with engine.begin() as conn:
+                await conn.run_sync(_StreamRow.__table__.create)
+            interface = SQLAInterface(_StreamRow)
+            async with sqlalchemy.ext.asyncio.AsyncSession(engine) as write_session:
+                write_session.add_all(
+                    [_StreamRow(id=i, name=f"n{i}") for i in range(1, 7)]
+                )
+                await write_session.commit()
+            async with sqlalchemy.ext.asyncio.AsyncSession(engine) as read_session:
+                total = 0
+                async for chunk in interface.yield_per(read_session, {"page_size": 2}):
+                    total += len(chunk)
+            assert total == 6
+        finally:
+            await engine.dispose()
+
     async def test_add(self, session, iface, Person_cls):
         new = Person_cls(id=99, name="Dave", age=50, country_id=1)
         await iface.add(session, new)

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/tests/unit/test_const.py

@@ -59,6 +59,7 @@ class TestDefaults:
         assert const.DEFAULT_API_PAGE_SIZE == 25
         assert const.DEFAULT_API_MAX_PAGE_SIZE == 25
         assert const.DEFAULT_API_DOWNLOAD_MIN_PAGE_SIZE == 100
+        assert const.DEFAULT_API_DOWNLOAD_MAX_PAGE_SIZE == 1000
 
     def test_default_token_url(self):
         assert const.DEFAULT_TOKEN_URL.startswith("/")

{fastapi_rtk-2.17.0 → fastapi_rtk-2.18.1}/tests/unit/test_setting.py

@@ -2,6 +2,7 @@ import pytest
 
 from fastapi_rtk.const import (
     DEFAULT_ADMIN_ROLE,
+    DEFAULT_API_DOWNLOAD_MAX_PAGE_SIZE,
     DEFAULT_API_DOWNLOAD_MIN_PAGE_SIZE,
     DEFAULT_API_MAX_PAGE_SIZE,
     DEFAULT_API_PAGE_SIZE,
@@ -62,6 +63,24 @@ class TestGeneralDefaults:
     def test_api_download_min_page_size_default(self):
         assert Setting.API_DOWNLOAD_MIN_PAGE_SIZE == DEFAULT_API_DOWNLOAD_MIN_PAGE_SIZE
 
+    def test_api_download_max_page_size(self, config_setter):
+        config_setter("API_DOWNLOAD_MAX_PAGE_SIZE", 5000)
+        assert Setting.API_DOWNLOAD_MAX_PAGE_SIZE == 5000
+
+    def test_api_download_max_page_size_default(self):
+        assert Setting.API_DOWNLOAD_MAX_PAGE_SIZE == DEFAULT_API_DOWNLOAD_MAX_PAGE_SIZE
+
+    def test_api_download_page_size_default_is_builtin_resolver(self):
+        from fastapi_rtk.api.model_rest_api.services._download_service import (
+            default_download_page_size,
+        )
+
+        assert Setting.API_DOWNLOAD_PAGE_SIZE is default_download_page_size
+
+    def test_api_download_page_size_override(self, config_setter):
+        config_setter("API_DOWNLOAD_PAGE_SIZE", 1234)
+        assert Setting.API_DOWNLOAD_PAGE_SIZE == 1234
+
     def test_text_filter_separator_default(self):
         assert Setting.TEXT_FILTER_SEPARATOR == ";"
 

fastapi_rtk-2.17.0/fastapi_rtk/_version.py

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