fastapi-rtk 2.16.0__tar.gz → 2.18.0__tar.gz

{fastapi_rtk-2.16.0 → fastapi_rtk-2.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-rtk
-Version: 2.16.0
+Version: 2.18.0
 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.16.0 → fastapi_rtk-2.18.0}/fastapi_rtk/__init__.py

@@ -37,6 +37,19 @@ __all__ = [
     # .api
     "BaseApi",
     "ModelRestApi",
+    "Params",
+    "P_ID",
+    "P_IDS",
+    "P_Q",
+    "P_SESSION",
+    "P_BODY",
+    "P_ITEM",
+    "P_ITEMS",
+    "PARAM_Q",
+    "PARAM_IDS_Q_SESSION_ITEMS",
+    "PARAM_ID_SESSION",
+    "PARAM_ID_SESSION_ITEM",
+    "PARAM_BODY_SESSION",
     # .auth
     "FABPasswordHelper",
     "Authenticator",

fastapi_rtk-2.18.0/fastapi_rtk/_version.py

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

{fastapi_rtk-2.16.0 → fastapi_rtk-2.18.0}/fastapi_rtk/agent_docs/guide/backend.md

@@ -268,7 +268,7 @@ class ItemApi(ModelRestApi):
     async def post_delete(self, item: Item, params): ...
 ```
 
-To reject a request from a pre-hook, `raise fastapi.HTTPException(...)` (a bare `raise ValueError(...)` becomes HTTP 500; there is no auto-translation). To override the response without rejecting, return a non-`Model` value from the hook, and the dispatcher treats that value as the response and skips the rest of the pipeline (see `_add_mixin.py:75-81` and `_edit_mixin.py:100-106`).
+To reject a request from a pre-hook, `raise fastapi.HTTPException(...)` (a bare `raise ValueError(...)` becomes HTTP 500; there is no auto-translation). To override the response without rejecting, return a non-`Model` value from the hook, and the dispatcher treats that value as the response and skips the rest of the pipeline (see `services/_add_service.py:66-72` and `services/_edit_service.py:90-96`).
 
 Use hooks for normalization, cross-field validation, audit logging, cache invalidation: anything policy, not wire format (use Pydantic for that at the schema level).
 
@@ -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 `10000`) 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
@@ -634,7 +636,7 @@ Reach for the builtin-role inspectors only when the answer must be synchronous a
 | Every role's grants, or the role names | `sm.get_role_and_api_permission_tuples_from_builtin_roles()`, `sm.get_roles_from_builtin_roles()`     |
 | The resolved roles dict                | `sm.builtin_roles` (a caching `lazy` over `Setting.ROLES`)                                            |
 
-Two properties to plan around. A role absent from `ROLES` reads as no access from every one of them, the admin role and any runtime-created role included, which is exactly the gap `check_user_access` closes by falling through to the DB. And `builtin_roles` is a caching `lazy` (`security_manager/__init__.py:84`; `cache=True` is the default, `utils/lazy.py`), so a mutation of the config dict after first access is not picked up: an override file loaded at startup is fine, and a test that varies the roles patches the resolved `sm.builtin_roles` attribute instead.
+Two properties to plan around. A role absent from `ROLES` reads as no access from every one of them, the admin role and any runtime-created role included, which is exactly the gap `check_user_access` closes by falling through to the DB. And `builtin_roles` is a caching `lazy` (`security_manager/security_manager.py:84`; `cache=True` is the default, `utils/lazy.py`), so a mutation of the config dict after first access is not picked up: an override file loaded at startup is fine, and a test that varies the roles patches the resolved `sm.builtin_roles` attribute instead.
 
 `current_permissions(api)` (`dependencies.py:68`) answers a wider question: every permission name the CURRENT user holds on one Api, intersected with that Api's `base_permissions`. It is a dependency factory, so calling it directly is `await current_permissions(self)()` inside `async with db.session():` (it reads `db.current_session`, which that context manager sets). Use it to hand a whole permission set to a template or a response; use `check_user_access` for a single yes/no on a user you already hold.
 

{fastapi_rtk-2.16.0 → fastapi_rtk-2.18.0}/fastapi_rtk/api/__init__.py

@@ -5,5 +5,18 @@ from .model_rest_api import *
 __all__ = [
     "BaseApi",
     "ModelRestApi",
+    "Params",
+    "P_ID",
+    "P_IDS",
+    "P_Q",
+    "P_SESSION",
+    "P_BODY",
+    "P_ITEM",
+    "P_ITEMS",
+    "PARAM_Q",
+    "PARAM_IDS_Q_SESSION_ITEMS",
+    "PARAM_ID_SESSION",
+    "PARAM_ID_SESSION_ITEM",
+    "PARAM_BODY_SESSION",
     "SQLAInterface",  # Just for backward compatibility, not recommended to use directly
 ]

{fastapi_rtk-2.16.0 → fastapi_rtk-2.18.0}/fastapi_rtk/api/base_api.py

@@ -74,13 +74,13 @@ class BaseApi:
     Example:
         base_permissions = ["can_get", "can_post"]
     """
-    permissions: list[str] = lazy(lambda self: [])
+    permissions: list[str] = lazy(list[str], with_target=False)
     """
     List of permissions for the API.
 
     DO NOT MODIFY UNLESS YOU KNOW WHAT YOU ARE DOING.
     """
-    messages: list[str] = lazy(lambda self: [])
+    messages: list[str] = lazy(list[str], with_target=False)
     """
     List of messages to log when the API is added to the toolkit.
 
@@ -93,7 +93,17 @@ class BaseApi:
             collections.abc.Callable,
             dict[str, typing.Any],
         ]
-    ] = lazy(lambda self: [])
+    ] = lazy(
+        list[
+            tuple[
+                collections.abc.Callable,
+                dict[str, typing.Any],
+                collections.abc.Callable,
+                dict[str, typing.Any],
+            ]
+        ],
+        with_target=False,
+    )
     """
     List of routes to register. Each item is a tuple of (router_func, router_parameters, route_function, metadata). When the API Router is integrated into the FastAPI app, these routes will be registered.
 
@@ -103,7 +113,7 @@ class BaseApi:
     """
     The FastAPIReactToolkit object. Automatically set when the API is added to the toolkit.
     """
-    cache: dict[str, typing.Any] = lazy(lambda self: dict())
+    cache: dict[str, typing.Any] = lazy(dict[str, typing.Any], with_target=False)
     """
     The cache for the API.
     

fastapi_rtk-2.18.0/fastapi_rtk/api/model_rest_api/__init__.py

@@ -0,0 +1,19 @@
+from .model_rest_api import ModelRestApi
+from .params import *
+
+__all__ = [
+    "ModelRestApi",
+    "Params",
+    "P_ID",
+    "P_IDS",
+    "P_Q",
+    "P_SESSION",
+    "P_BODY",
+    "P_ITEM",
+    "P_ITEMS",
+    "PARAM_Q",
+    "PARAM_IDS_Q_SESSION_ITEMS",
+    "PARAM_ID_SESSION",
+    "PARAM_ID_SESSION_ITEM",
+    "PARAM_BODY_SESSION",
+]