fastapi-viewsets 1.5.1__tar.gz → 1.5.2__tar.gz

{fastapi_viewsets-1.5.1/fastapi_viewsets.egg-info → fastapi_viewsets-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi_viewsets
-Version: 1.5.1
+Version: 1.5.2
 Summary: DRF-style viewsets for FastAPI with SQLAlchemy/Tortoise/Peewee adapters and Pydantic v2 support.
 Author: Alexander Valenchits
 License: MIT
@@ -25,12 +25,10 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastapi>=0.110.0
-Requires-Dist: uvicorn>=0.17.6
-Requires-Dist: SQLAlchemy>=2.0.0
 Requires-Dist: pydantic<3,>=2.5
 Requires-Dist: python-dotenv>=0.19.0
 Provides-Extra: sqlalchemy
-Requires-Dist: SQLAlchemy>=2.0.0; extra == "sqlalchemy"
+Requires-Dist: SQLAlchemy[asyncio]>=2.0.0; extra == "sqlalchemy"
 Provides-Extra: tortoise
 Requires-Dist: tortoise-orm<1.0,>=0.20.0; extra == "tortoise"
 Requires-Dist: asyncpg>=0.28.0; extra == "tortoise"
@@ -43,6 +41,8 @@ Requires-Dist: pytest-cov>=4.0.0; extra == "test"
 Requires-Dist: httpx>=0.24.0; extra == "test"
 Requires-Dist: faker>=18.0.0; extra == "test"
 Requires-Dist: aiosqlite>=0.19.0; extra == "test"
+Requires-Dist: uvicorn>=0.17.6; extra == "test"
+Requires-Dist: SQLAlchemy[asyncio]>=2.0.0; extra == "test"
 Provides-Extra: lint
 Requires-Dist: ruff>=0.5; extra == "lint"
 Requires-Dist: black>=24; extra == "lint"
@@ -95,18 +95,21 @@ Django REST Framework-style ViewSets for FastAPI — auto-generate CRUD endpoint
 pip install fastapi-viewsets
 ```
 
-SQLAlchemy 2.0 or newer is installed automatically. For a local SQLite app,
-start with the [sync quickstart](#quickstart-sqlalchemy-sync); no separate database driver is needed.
-
-Optional extras (see `pyproject.toml`):
+The base install is ORM-agnostic: it pulls in only FastAPI, Pydantic and
+python-dotenv. Pick your ORM via an extra (see `pyproject.toml`):
 
 ```bash
-pip install "fastapi-viewsets[sqlalchemy]"
+pip install "fastapi-viewsets[sqlalchemy]"   # SQLAlchemy 2.x, incl. asyncio support (greenlet)
 pip install "fastapi-viewsets[tortoise]"
 pip install "fastapi-viewsets[peewee]"
 pip install "fastapi-viewsets[test]"   # pytest, httpx, coverage, etc.
 ```
 
+For a local SQLite app, start with the
+[sync quickstart](#quickstart-sqlalchemy-sync); no separate database driver is needed.
+To execute the quickstart's `python main.py` (or serve any app) you also
+need an ASGI server, e.g. `pip install uvicorn`.
+
 For async SQLAlchemy you still need a driver such as `aiosqlite`, `asyncpg`, or `aiomysql` alongside your database URL.
 
 ## Database connection examples
@@ -498,10 +501,23 @@ Notes:
   `model_config = ConfigDict(from_attributes=True)` instead of the v1
   `class Config: orm_mode = True`.
 - `PATCH` uses `model_dump(exclude_unset=True)` internally, so unset
-  fields are no longer overwritten with defaults.
+  fields are no longer overwritten with defaults. Since v1.5.2 the PATCH
+  body is validated against an auto-generated all-optional variant of
+  your `response_model`, so partial bodies pass validation even when the
+  schema has required fields, and an explicit JSON `null` clears a
+  nullable column.
+- `PUT` replaces exactly the fields present in the payload; model
+  columns that are not part of the `response_model` are left untouched.
+- `POST` never sends an explicit `NULL` primary key to the database —
+  `id: Optional[int] = None` in the schema is safe on every adapter.
+- Integrity violations (e.g. duplicate unique values) return
+  `409 Conflict` with a sanitized message; raw SQL and driver internals
+  are never exposed in the response body.
 - If the async driver (`aiosqlite` / `asyncpg` / `aiomysql`) is not
   installed, sync usage still works — only `get_async_session()` raises
-  a helpful `RuntimeError`.
+  a helpful `RuntimeError`. The `sqlalchemy` extra installs
+  `SQLAlchemy[asyncio]`, which already includes `greenlet` for async
+  sessions.
 
 ## Overriding `list` and `create_element` (custom LIST and POST)
 
@@ -509,8 +525,11 @@ Every CRUD handler is a regular method, so subclassing the viewset is
 the canonical way to add filtering, ordering, validation, conflict
 handling, and so on. The example below subclasses `AsyncBaseViewset`
 and overrides both `list` (case-insensitive search + simple ordering)
-and `create_element` (input normalization + map `IntegrityError` to
-409).
+and `create_element` (input normalization + custom conflict message).
+
+> Since v1.5.2 the adapters themselves map `IntegrityError` to
+> `409 Conflict`; override `create_element` only when you need a custom
+> error payload or extra normalization.
 
 ```python
 from typing import List, Optional
@@ -676,7 +695,7 @@ app.include_router(router)
 
 ## Pagination, filtering, ordering
 
-**Pagination** — `BaseViewset.list` maps `limit` and `offset` to query parameters on the LIST route.
+**Pagination** — `BaseViewset.list` maps `limit` and `offset` to query parameters on the LIST route. Defaults are `limit=10`, `offset=0`; negative values are rejected with `422`, and `limit` is capped at `10000`.
 
 ```python
 from fastapi_viewsets import BaseViewset
@@ -737,6 +756,34 @@ class ItemsWithStats(BaseViewset):
 
 ## What is new
 
+### v1.5.2
+
+Bugfix release for the CRUD write paths (see
+[RELEASE_1.5.2.md](https://github.com/svalench/fastapi_viewsets/blob/master/RELEASE_1.5.2.md)):
+
+- **Multi-viewset apps fixed**: `register()` no longer leaks one viewset's
+  body schema into other viewsets — every `POST`/`PUT`/`PATCH` endpoint
+  now validates against its own `response_model`.
+- **PATCH is truly partial**: the PATCH body is validated against an
+  auto-generated all-optional variant of the response schema, and an
+  explicit JSON `null` clears a nullable column.
+- **PUT no longer nulls columns** that are absent from the Pydantic
+  schema.
+- **Integrity violations return `409 Conflict`** with a sanitized message
+  instead of `400` with raw SQL/driver internals.
+- **Create never passes an explicit `NULL` primary key** — fixes Tortoise
+  `POST` and PostgreSQL inserts with `id: Optional[int] = None` schemas.
+- **Pagination validated**: negative `limit`/`offset` rejected with `422`.
+- **Filters advertised in OpenAPI**: whitelisted `ListConfig.filters`
+  fields and their `__op` variants show up in Swagger UI.
+- **Leaner dependencies**: the base install no longer requires SQLAlchemy
+  or uvicorn; the `sqlalchemy` extra installs `SQLAlchemy[asyncio]`
+  (includes `greenlet`).
+
+Earlier releases: v1.5.0 (server-side `search`, declarative ordering and
+filters — [RELEASE_1.5.0.md](https://github.com/svalench/fastapi_viewsets/blob/master/RELEASE_1.5.0.md)),
+v1.4.0 ([RELEASE_1.4.0.md](https://github.com/svalench/fastapi_viewsets/blob/master/RELEASE_1.4.0.md)).
+
 ### v1.3.0
 
 - **Declarative eager loading** via `RelatedConfig` inside Pydantic schemas.  

{fastapi_viewsets-1.5.1 → fastapi_viewsets-1.5.2}/README.md

@@ -40,18 +40,21 @@ Django REST Framework-style ViewSets for FastAPI — auto-generate CRUD endpoint
 pip install fastapi-viewsets
 ```
 
-SQLAlchemy 2.0 or newer is installed automatically. For a local SQLite app,
-start with the [sync quickstart](#quickstart-sqlalchemy-sync); no separate database driver is needed.
-
-Optional extras (see `pyproject.toml`):
+The base install is ORM-agnostic: it pulls in only FastAPI, Pydantic and
+python-dotenv. Pick your ORM via an extra (see `pyproject.toml`):
 
 ```bash
-pip install "fastapi-viewsets[sqlalchemy]"
+pip install "fastapi-viewsets[sqlalchemy]"   # SQLAlchemy 2.x, incl. asyncio support (greenlet)
 pip install "fastapi-viewsets[tortoise]"
 pip install "fastapi-viewsets[peewee]"
 pip install "fastapi-viewsets[test]"   # pytest, httpx, coverage, etc.
 ```
 
+For a local SQLite app, start with the
+[sync quickstart](#quickstart-sqlalchemy-sync); no separate database driver is needed.
+To execute the quickstart's `python main.py` (or serve any app) you also
+need an ASGI server, e.g. `pip install uvicorn`.
+
 For async SQLAlchemy you still need a driver such as `aiosqlite`, `asyncpg`, or `aiomysql` alongside your database URL.
 
 ## Database connection examples
@@ -443,10 +446,23 @@ Notes:
   `model_config = ConfigDict(from_attributes=True)` instead of the v1
   `class Config: orm_mode = True`.
 - `PATCH` uses `model_dump(exclude_unset=True)` internally, so unset
-  fields are no longer overwritten with defaults.
+  fields are no longer overwritten with defaults. Since v1.5.2 the PATCH
+  body is validated against an auto-generated all-optional variant of
+  your `response_model`, so partial bodies pass validation even when the
+  schema has required fields, and an explicit JSON `null` clears a
+  nullable column.
+- `PUT` replaces exactly the fields present in the payload; model
+  columns that are not part of the `response_model` are left untouched.
+- `POST` never sends an explicit `NULL` primary key to the database —
+  `id: Optional[int] = None` in the schema is safe on every adapter.
+- Integrity violations (e.g. duplicate unique values) return
+  `409 Conflict` with a sanitized message; raw SQL and driver internals
+  are never exposed in the response body.
 - If the async driver (`aiosqlite` / `asyncpg` / `aiomysql`) is not
   installed, sync usage still works — only `get_async_session()` raises
-  a helpful `RuntimeError`.
+  a helpful `RuntimeError`. The `sqlalchemy` extra installs
+  `SQLAlchemy[asyncio]`, which already includes `greenlet` for async
+  sessions.
 
 ## Overriding `list` and `create_element` (custom LIST and POST)
 
@@ -454,8 +470,11 @@ Every CRUD handler is a regular method, so subclassing the viewset is
 the canonical way to add filtering, ordering, validation, conflict
 handling, and so on. The example below subclasses `AsyncBaseViewset`
 and overrides both `list` (case-insensitive search + simple ordering)
-and `create_element` (input normalization + map `IntegrityError` to
-409).
+and `create_element` (input normalization + custom conflict message).
+
+> Since v1.5.2 the adapters themselves map `IntegrityError` to
+> `409 Conflict`; override `create_element` only when you need a custom
+> error payload or extra normalization.
 
 ```python
 from typing import List, Optional
@@ -621,7 +640,7 @@ app.include_router(router)
 
 ## Pagination, filtering, ordering
 
-**Pagination** — `BaseViewset.list` maps `limit` and `offset` to query parameters on the LIST route.
+**Pagination** — `BaseViewset.list` maps `limit` and `offset` to query parameters on the LIST route. Defaults are `limit=10`, `offset=0`; negative values are rejected with `422`, and `limit` is capped at `10000`.
 
 ```python
 from fastapi_viewsets import BaseViewset
@@ -682,6 +701,34 @@ class ItemsWithStats(BaseViewset):
 
 ## What is new
 
+### v1.5.2
+
+Bugfix release for the CRUD write paths (see
+[RELEASE_1.5.2.md](https://github.com/svalench/fastapi_viewsets/blob/master/RELEASE_1.5.2.md)):
+
+- **Multi-viewset apps fixed**: `register()` no longer leaks one viewset's
+  body schema into other viewsets — every `POST`/`PUT`/`PATCH` endpoint
+  now validates against its own `response_model`.
+- **PATCH is truly partial**: the PATCH body is validated against an
+  auto-generated all-optional variant of the response schema, and an
+  explicit JSON `null` clears a nullable column.
+- **PUT no longer nulls columns** that are absent from the Pydantic
+  schema.
+- **Integrity violations return `409 Conflict`** with a sanitized message
+  instead of `400` with raw SQL/driver internals.
+- **Create never passes an explicit `NULL` primary key** — fixes Tortoise
+  `POST` and PostgreSQL inserts with `id: Optional[int] = None` schemas.
+- **Pagination validated**: negative `limit`/`offset` rejected with `422`.
+- **Filters advertised in OpenAPI**: whitelisted `ListConfig.filters`
+  fields and their `__op` variants show up in Swagger UI.
+- **Leaner dependencies**: the base install no longer requires SQLAlchemy
+  or uvicorn; the `sqlalchemy` extra installs `SQLAlchemy[asyncio]`
+  (includes `greenlet`).
+
+Earlier releases: v1.5.0 (server-side `search`, declarative ordering and
+filters — [RELEASE_1.5.0.md](https://github.com/svalench/fastapi_viewsets/blob/master/RELEASE_1.5.0.md)),
+v1.4.0 ([RELEASE_1.4.0.md](https://github.com/svalench/fastapi_viewsets/blob/master/RELEASE_1.4.0.md)).
+
 ### v1.3.0
 
 - **Declarative eager loading** via `RelatedConfig` inside Pydantic schemas.  

{fastapi_viewsets-1.5.1 → fastapi_viewsets-1.5.2}/docs/getting-started.md

@@ -7,8 +7,8 @@
 | Python | >= 3.9 |
 | FastAPI | >= 0.110 |
 | Pydantic | >= 2.5, < 3 |
-| SQLAlchemy | >= 2.0.0 |
 | python-dotenv | >= 0.19 |
+| SQLAlchemy | >= 2.0.0 (only for the `sqlalchemy` extra / default `ORM_TYPE`) |
 
 ## Install from PyPI
 
@@ -18,8 +18,9 @@ pip install fastapi-viewsets
 
 ## Optional extras
 
-SQLAlchemy is a core dependency (installed automatically). The extras below
-add ORM-specific packages when you need Tortoise or Peewee:
+The base install is ORM-agnostic (FastAPI + Pydantic + python-dotenv only).
+Add the extra for your ORM — and an ASGI server such as `uvicorn` to run
+your app:
 
 === "SQLAlchemy"
 

{fastapi_viewsets-1.5.1 → fastapi_viewsets-1.5.2}/docs/pagination-filtering.md

@@ -10,8 +10,8 @@ GET /items?limit=10&offset=20
 
 | Parameter | Type | Default | Description |
 | --- | --- | --- | --- |
-| `limit` | `Optional[int]` | `10` | Maximum number of items to return |
-| `offset` | `Optional[int]` | `0` | Number of items to skip |
+| `limit` | `int` | `10` | Maximum number of items to return (must be `0..10000`, negative values are rejected with `422`) |
+| `offset` | `int` | `0` | Number of items to skip (negative values are rejected with `422`) |
 
 No additional configuration needed — pagination is built into the default `list()` handler.
 

{fastapi_viewsets-1.5.1 → fastapi_viewsets-1.5.2}/fastapi_viewsets/__init__.py

@@ -9,9 +9,8 @@ from __future__ import annotations
 
 from typing import Any, Callable, Dict, List, Optional, Type, TypeVar, Union
 
-from fastapi import APIRouter, Body, Depends, Request
+from fastapi import APIRouter, Body, Depends, Query, Request
 from pydantic import BaseModel
-from sqlalchemy.orm import Session
 
 from fastapi_viewsets._compat import model_to_dict
 from fastapi_viewsets._register import _RegisterMixin
@@ -82,7 +81,7 @@ class BaseViewset(_RegisterMixin, APIRouter):
         self.endpoint: Optional[str] = endpoint
         self.response_model: Optional[Type[ResponseModelType]] = response_model
         self.model: Optional[Type[ModelType]] = model
-        self.db_session: Optional[Callable[[], Session]] = db_session
+        self.db_session: Optional[Callable[[], Any]] = db_session
         self.orm_adapter: Optional[BaseORMAdapter] = orm_adapter or get_orm_adapter()
 
     # ------------------------------------------------------------------
@@ -91,8 +90,8 @@ class BaseViewset(_RegisterMixin, APIRouter):
 
     def list(
         self,
-        limit: Optional[int] = 10,
-        offset: Optional[int] = 0,
+        limit: int = Query(10, ge=0, le=10000),
+        offset: int = Query(0, ge=0),
         search: Optional[str] = None,
         ordering: Optional[str] = None,
         request: Request = None,
@@ -117,6 +116,13 @@ class BaseViewset(_RegisterMixin, APIRouter):
             parse_ordering_param,
         )
 
+        # FastAPI resolves ``Query`` defaults for HTTP calls; direct
+        # programmatic calls receive the unresolved ``Query`` object.
+        if not isinstance(limit, int):
+            limit = 10
+        if not isinstance(offset, int):
+            offset = 0
+
         config = get_list_config(self.response_model)
         return get_list_queryset(
             self.model,

fastapi_viewsets-1.5.2/fastapi_viewsets/_register.py

@@ -0,0 +1,245 @@
+"""Shared route registration logic for sync and async viewsets.
+
+Both ``BaseViewset`` and ``AsyncBaseViewset`` need to wire CRUD methods
+into FastAPI ``APIRouter`` routes in exactly the same way. The logic is
+collected here as a mixin to avoid two divergent copies.
+"""
+
+from __future__ import annotations
+
+import functools
+import types
+from collections.abc import Iterable
+from typing import Any, Dict, List, Optional, Type
+
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer
+from pydantic import BaseModel, create_model
+
+from fastapi_viewsets.constants import MAP_METHODS
+
+# Routing order matters: routes without path parameters must be added
+# before routes that use them, otherwise FastAPI may match LIST against
+# the ``/{id}`` route.
+_METHOD_ORDER = ("LIST", "POST", "GET", "PUT", "PATCH", "DELETE")
+
+# Cache of generated partial (all-optional) PATCH body models, keyed by
+# the source schema, so repeated ``register()`` calls reuse one model.
+_PARTIAL_MODEL_CACHE: Dict[type, type] = {}
+
+
+def _build_partial_model(model: Type[BaseModel]) -> Type[BaseModel]:
+    """Build an all-optional variant of a Pydantic schema for PATCH bodies.
+
+    PATCH semantics require that clients may send any subset of fields,
+    so required fields in the response schema must become optional in
+    the request body. Unset fields are excluded later via
+    ``model_dump(exclude_unset=True)``; explicitly sent ``null`` values
+    are preserved so nullable columns can be cleared.
+    """
+    cached = _PARTIAL_MODEL_CACHE.get(model)
+    if cached is not None:
+        return cached
+
+    if not hasattr(model, "model_fields"):  # pragma: no cover - pydantic v1 fallback
+        return model
+
+    fields: Dict[str, Any] = {}
+    for name, field_info in model.model_fields.items():
+        fields[name] = (Optional[field_info.annotation], None)
+
+    partial = create_model(f"{model.__name__}Patch", **fields)
+    _PARTIAL_MODEL_CACHE[model] = partial
+    return partial
+
+
+def _clone_bound_method(bound: Any, annotation_overrides: Dict[str, Any]) -> Any:
+    """Return a per-instance copy of a bound method with patched annotations.
+
+    ``register()`` is called once per viewset instance, but CRUD handlers
+    are functions defined once on the class. Mutating
+    ``handler.__annotations__`` directly would leak one viewset's body
+    schema into every other viewset in the process, so the function is
+    cloned first and the clone's annotations are patched instead.
+    """
+    func = getattr(bound, "__func__", None)
+    if func is None:
+        # Not a plain bound method (already a partial/closure): patch a
+        # fresh annotation dict on the object itself, best-effort.
+        try:
+            merged = {**getattr(bound, "__annotations__", {}), **annotation_overrides}
+            bound.__annotations__ = merged
+        except (AttributeError, TypeError):
+            pass
+        return bound
+
+    new_func = types.FunctionType(
+        func.__code__,
+        func.__globals__,
+        func.__name__,
+        func.__defaults__,
+        func.__closure__,
+    )
+    new_func.__dict__.update(func.__dict__)
+    new_func.__kwdefaults__ = func.__kwdefaults__
+    new_func.__annotations__ = {**func.__annotations__, **annotation_overrides}
+    new_func.__doc__ = func.__doc__
+    new_func.__module__ = func.__module__
+    new_func.__qualname__ = func.__qualname__
+    return types.MethodType(new_func, bound.__self__)
+
+
+class _RegisterMixin:
+    """Mixin providing :meth:`register` for CRUD endpoint wiring.
+
+    Subclasses are expected to expose ``self.endpoint``, ``self.tags``,
+    ``self.response_model`` and the CRUD handlers
+    (``list``, ``get_element``, ``create_element``, ``update_element``,
+    ``delete_element``) used by :data:`MAP_METHODS`.
+    """
+
+    ALLOWED_METHODS: List[str]
+
+    def register(
+        self,
+        methods: Optional[List[str]] = None,
+        oauth_protect: Optional[OAuth2PasswordBearer] = None,
+        protected_methods: Optional[List[str]] = None,
+    ) -> None:
+        """Register CRUD endpoints on this router.
+
+        Args:
+            methods: Logical methods to register. Defaults to all
+                allowed methods. Allowed values:
+                ``LIST``, ``GET``, ``POST``, ``PUT``, ``PATCH``,
+                ``DELETE``.
+            oauth_protect: ``OAuth2PasswordBearer`` instance used as a
+                FastAPI dependency on protected operations.
+            protected_methods: Subset of ``methods`` that should require
+                the bearer token. Ignored if ``oauth_protect`` is None.
+        """
+        protected_methods = list(protected_methods or [])
+
+        if methods is None:
+            methods = list(self.ALLOWED_METHODS)
+        if not isinstance(methods, Iterable):
+            raise ValueError(
+                'methods must be List of methods (e.g. ["GET"])'
+            )
+
+        # Sort so LIST is registered before GET/{id}.
+        sorted_methods = sorted(
+            methods,
+            key=lambda m: _METHOD_ORDER.index(m) if m in _METHOD_ORDER else len(_METHOD_ORDER),
+        )
+
+        for method in sorted_methods:
+            spec = MAP_METHODS.get(method)
+            if not spec:
+                raise ValueError(
+                    f"Unknown method: {method}. "
+                    f"Allowed methods: {list(MAP_METHODS.keys())}"
+                )
+
+            handler = getattr(self, spec["method"])
+
+            # Hint FastAPI/Pydantic about the body schema if the handler
+            # carries an ``item`` parameter. The handler is cloned first
+            # so patching never mutates the shared class-level function
+            # (which would leak this viewset's schema into other
+            # viewsets). PATCH gets an all-optional partial model so
+            # clients may send any subset of fields.
+            if self.response_model is not None and "item" in getattr(
+                handler, "__annotations__", {}
+            ):
+                body_model = self.response_model
+                if spec["http_method"] == "PATCH":
+                    body_model = _build_partial_model(self.response_model)
+                handler = _clone_bound_method(handler, {"item": body_model})
+
+            original_doc = handler.__doc__
+
+            # PUT vs PATCH share an underlying handler but differ in the
+            # ``partial`` flag.
+            if spec["method"] == "update_element":
+                handler = functools.partial(
+                    handler, partial=method == "PATCH"
+                )
+                handler.__doc__ = original_doc
+
+            if method in protected_methods and oauth_protect is not None:
+                handler = functools.partial(handler, token=Depends(oauth_protect))
+                handler.__doc__ = original_doc
+
+            endpoint = (self.endpoint or "") + spec.get("path", "")
+            response_model = self._build_response_model(spec)
+            route_name = self._build_route_name(method)
+            openapi_extra = self._build_openapi_extra(spec)
+
+            self.add_api_route(
+                endpoint,
+                handler,
+                response_model=response_model,
+                tags=self.tags,
+                methods=[spec["http_method"]],
+                name=route_name,
+                openapi_extra=openapi_extra,
+            )
+
+    # --- helpers ---------------------------------------------------
+
+    def _build_openapi_extra(self, spec) -> Optional[Dict[str, Any]]:
+        """Document dynamic LIST filter parameters in OpenAPI.
+
+        Filters are parsed from ``request.query_params`` at runtime, so
+        FastAPI cannot see them in the handler signature. Advertise the
+        whitelisted ``ListConfig.filters`` fields (and their ``__op``
+        variants) explicitly via ``openapi_extra``.
+        """
+        if not spec.get("is_list") or self.response_model is None:
+            return None
+
+        from fastapi_viewsets.filtering import FILTER_OPS, get_list_config
+
+        config = get_list_config(self.response_model)
+        if not config.filters:
+            return None
+
+        parameters: List[Dict[str, Any]] = []
+        for field_name in config.filters:
+            parameters.append(
+                {
+                    "name": field_name,
+                    "in": "query",
+                    "required": False,
+                    "schema": {"type": "string"},
+                    "description": f"Exact-match filter on `{field_name}`.",
+                }
+            )
+            for op in FILTER_OPS:
+                parameters.append(
+                    {
+                        "name": f"{field_name}__{op}",
+                        "in": "query",
+                        "required": False,
+                        "schema": {"type": "string"},
+                        "description": f"Comparison filter `{op}` on `{field_name}`.",
+                    }
+                )
+        return {"parameters": parameters}
+
+    def _build_response_model(self, spec):
+        """Compute the FastAPI ``response_model`` for a given method spec."""
+        if spec.get("http_method") == "DELETE":
+            return None
+        if self.response_model is None:
+            return None
+        if spec.get("is_list"):
+            return List[self.response_model]
+        return self.response_model
+
+    def _build_route_name(self, method: str) -> str:
+        """Build a stable route name for OpenAPI/url_path_for."""
+        endpoint = self.endpoint or ""
+        slug = endpoint.replace("/", "_").strip("_") or "root"
+        return f"{method.lower()}_{slug}"

{fastapi_viewsets-1.5.1 → fastapi_viewsets-1.5.2}/fastapi_viewsets/async_base.py

@@ -4,9 +4,8 @@ from __future__ import annotations
 
 from typing import Any, Callable, Dict, List, Optional, Type, TypeVar, Union
 
-from fastapi import APIRouter, Body, Depends, Request
+from fastapi import APIRouter, Body, Depends, Query, Request
 from pydantic import BaseModel
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from fastapi_viewsets._compat import model_to_dict
 from fastapi_viewsets._register import _RegisterMixin
@@ -51,7 +50,7 @@ class AsyncBaseViewset(_RegisterMixin, APIRouter):
         allowed_methods: Optional[List[str]] = None,
         endpoint: Optional[str] = None,
         model: Optional[Type[ModelType]] = None,
-        db_session: Optional[Callable[[], AsyncSession]] = None,
+        db_session: Optional[Callable[[], Any]] = None,
         response_model: Optional[Type[ResponseModelType]] = None,
         orm_adapter: Optional[BaseORMAdapter] = None,
         **kwargs,
@@ -73,7 +72,7 @@ class AsyncBaseViewset(_RegisterMixin, APIRouter):
         self.endpoint: Optional[str] = endpoint
         self.response_model: Optional[Type[ResponseModelType]] = response_model
         self.model: Optional[Type[ModelType]] = model
-        self.db_session: Optional[Callable[[], AsyncSession]] = db_session
+        self.db_session: Optional[Callable[[], Any]] = db_session
         self.orm_adapter: Optional[BaseORMAdapter] = orm_adapter or get_orm_adapter()
 
     # ------------------------------------------------------------------
@@ -82,8 +81,8 @@ class AsyncBaseViewset(_RegisterMixin, APIRouter):
 
     async def list(
         self,
-        limit: Optional[int] = 10,
-        offset: Optional[int] = 0,
+        limit: int = Query(10, ge=0, le=10000),
+        offset: int = Query(0, ge=0),
         search: Optional[str] = None,
         ordering: Optional[str] = None,
         request: Request = None,
@@ -108,6 +107,13 @@ class AsyncBaseViewset(_RegisterMixin, APIRouter):
             parse_ordering_param,
         )
 
+        # FastAPI resolves ``Query`` defaults for HTTP calls; direct
+        # programmatic calls receive the unresolved ``Query`` object.
+        if not isinstance(limit, int):
+            limit = 10
+        if not isinstance(offset, int):
+            offset = 0
+
         config = get_list_config(self.response_model)
         return await get_list_queryset(
             self.model,