tina4-python 3.13.97__tar.gz → 3.13.99__tar.gz

{tina4_python-3.13.97 → tina4_python-3.13.99}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: tina4-python
-Version: 3.13.97
+Version: 3.13.99
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.97 → tina4_python-3.13.99}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.97"
+version = "3.13.99"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.97 → tina4_python-3.13.99}/tina4_python/CLAUDE.md

@@ -238,7 +238,7 @@ Tina4 provides a full toolkit. Before writing custom code, check if the framewor
 | Static file serving | Put files in `src/public/` — auto-served |
 | Translations / i18n | `I18n` from `tina4_python.i18n` |
 | HTML generation in code | `HTMLElement` from `tina4_python.HtmlElement` |
-| Inline testing | `@tests`, `assert_equal`, `assert_raises` from `tina4_python.Testing` |
+| Inline testing | `@tests`, `expect_equal`, `expect_raises` from `tina4_python.Testing` |
 | Event system | `on`, `emit`, `once`, `off` from `tina4_python.core.events` |
 | AI assistant context | `detect_ai`, `install_context` from `tina4_python.ai` |
 | Response caching | `ResponseCache`, `cache_stats`, `clear_cache` from `tina4_python.cache` |
@@ -357,7 +357,7 @@ tina4_python/               # Core framework package (v3.0.0)
 ├── dotenv/                 # .env file loader
 ├── cli/                    # CLI commands
 ├── HtmlElement.py          # Programmatic HTML builder (HTMLElement, add_html_helpers)
-├── Testing.py              # Inline testing framework (tests, assert_equal, run_all)
+├── Testing.py              # Inline testing framework (tests, expect_equal, run_all)
 ├── templates/              # Built-in framework templates (Twig)
 ├── public/                 # Built-in static assets
 └── scss/                   # Built-in SCSS
@@ -973,7 +973,7 @@ uv run tina4python migrate
 - Files are executed in **numeric-prefix order** (`9_` before `10_`) and split on the `;` delimiter. A file without a numeric/timestamp prefix logs a warning — its order is undefined
 - State is tracked in the `tina4_migration` table (auto-created per engine, canonical columns `id, migration_name VARCHAR(500) NOT NULL UNIQUE, description VARCHAR(500), batch INTEGER NOT NULL DEFAULT 1, executed_at VARCHAR(50) NOT NULL, passed INTEGER NOT NULL DEFAULT 1` — identical across all four frameworks). A migration is **applied** when a row exists for it with `passed = 1` (the applied-read is `WHERE passed = 1`). `migrate()` writes **only `passed = 1` rows**: on a failure the file's transaction is rolled back and **no row is written** for it (it is NOT recorded as `passed=0`), and `migrate()` raises. The public `record_migration(name, batch, passed=...)` API can write a `passed=0` row; any `passed=0` row (including one carried over from a v2 table) is treated as **not applied**, so it is reported pending. A leftover `passed=0` row (a prior failure or a v2 carry-over) **re-applies cleanly**: on the next `migrate()` the success path deletes any existing row for that `migration_name` before writing the fresh `passed=1` row, so the migration runs again instead of colliding on the unique `migration_name` — the bookkeeping table holds at most one row per migration with its latest state. The v2->v3 upgrade logs a warning naming any `passed=0` rows so you know which ones will re-run.
 - **Each migration FILE is wrapped in its own transaction**: on a failure the file rolls back and `migrate()` **raises** (it does not write `passed=0`, delete anything, or `sys.exit`). Already-applied files stay applied — fix the bad file and re-run. The explicit `tina4 migrate` CLI surfaces the raise as a non-zero exit; startup auto-migration logs it and the service still boots (see TINA4_AUTO_MIGRATE above).
-- **Atomicity caveat:** per-file transactions are truly atomic only on engines with **transactional DDL (PostgreSQL)**. MySQL, Firebird, and SQLite auto-commit DDL, so a multi-statement migration that fails midway on those engines leaves earlier statements applied — keep one logical change per file. CREATE TABLE / ALTER-ADD are made idempotent on Firebird/MSSQL (existence-checked) so a re-run doesn't error.
+- **Atomicity caveat:** per-file transactions are truly atomic on engines with **transactional DDL (PostgreSQL, and SQLite)**. SQLite's DDL is transactional too (autocommit is off inside `start_transaction()`), so a multi-statement migration that fails midway on SQLite rolls back cleanly, including any `CREATE TABLE` that already ran in the same file — proven by `tests/test_migration.py::TestMigratePositive::test_partial_failure_rolls_back`. MySQL and Firebird **auto-commit DDL**, so the same failure on those two engines leaves earlier statements applied — keep one logical change per file there. CREATE TABLE / ALTER-ADD are made idempotent on Firebird/MSSQL (existence-checked) so a re-run doesn't error.
 
 ### Engine-specific DDL patterns
 
@@ -1369,11 +1369,11 @@ Supports all HTML tags, void tags (`<br>`, `<img>`, `<input>`, etc.), and auto-e
 Tina4 includes a decorator-based test framework for inline test cases:
 
 ```python
-from tina4_python.Testing import tests, assert_equal, assert_raises
+from tina4_python.Testing import tests, expect_equal, expect_raises
 
 @tests(
-    assert_equal((5, 3), 8),
-    assert_raises(ValueError, (None,))
+    expect_equal((5, 3), 8),
+    expect_raises(ValueError, (None,))
 )
 def add(a, b=None):
     if b is None:
@@ -1383,7 +1383,7 @@ def add(a, b=None):
 
 Run all decorated tests:
 ```bash
-uv run tina4python test                     # Discovers @tests in src/**/*.py
+uv run tina4python test                     # Discovers @tests in src/**/*.py, real exit code
 ```
 
 Or programmatically:
@@ -1542,16 +1542,14 @@ container.get("unknown")           # KeyError: service not registered: unknown
 Rich, syntax-highlighted HTML error overlay for development mode. Shows stack traces with source code context, request details, and environment info.
 
 ```python
-from tina4_python.debug.error_overlay import render_error_overlay, render_production_error, is_debug_mode
+from tina4_python.debug.error_overlay import render_error_overlay, is_debug_mode
 
-# Check if overlay should be shown
+# Dev only — the caller gates the overlay on is_debug_mode()
 if is_debug_mode():    # True when TINA4_DEBUG is true
-    html = render_error_overlay(exception, request=request)
-else:
-    html = render_production_error(status_code=500, message="Internal Server Error")
+    html = render_error_overlay(exception, request)
 ```
 
-The error overlay is automatically activated when `TINA4_DEBUG=true`. In production, `render_production_error()` returns a safe, generic error page with no stack traces or source code.
+The error overlay is dev-only (gated on `is_debug_mode()`/`TINA4_DEBUG`). The production 500 is NOT rendered here — the server dispatch renders `errors/500.twig` with an empty `error_message` (CWE-209), so the exception detail stays in the server log only. Sensitive request fields (Authorization / Cookie / Set-Cookie headers and password-like body/param keys) are redacted even in the overlay, the frame count is capped, and the caller guards the render.
 
 ## HtmlElement — Programmatic HTML Builder
 
@@ -1587,14 +1585,14 @@ HTMLElement("img", {"src": "/logo.png"})  # <img src="/logo.png">
 Attach test assertions directly to functions with the `@tests` decorator. Tests are registered globally and run via CLI or programmatically.
 
 ```python
-from tina4_python.Testing import tests, assert_equal, assert_raises, assert_true, assert_false, run_all
+from tina4_python.Testing import tests, expect_equal, expect_raises, expect_true, expect_false, run_all
 
 @tests(
-    assert_equal((5, 3), 8),           # add(5, 3) == 8
-    assert_equal((0, 0), 0),           # add(0, 0) == 0
-    assert_raises(ValueError, (None,)), # add(None) raises ValueError
-    assert_true((1, 1)),               # add(1, 1) is truthy
-    assert_false((0, 0)),              # add(0, 0) is falsy
+    expect_equal((5, 3), 8),           # add(5, 3) == 8
+    expect_equal((0, 0), 0),           # add(0, 0) == 0
+    expect_raises(ValueError, (None,)), # add(None) raises ValueError
+    expect_true((1, 1)),               # add(1, 1) is truthy
+    expect_false((0, 0)),              # add(0, 0) is falsy
 )
 def add(a, b=None):
     if b is None:

{tina4_python-3.13.97 → tina4_python-3.13.99}/tina4_python/Testing.py

@@ -3,14 +3,14 @@
 # License: MIT https://opensource.org/licenses/MIT
 """
 Inline testing framework — decorate functions with test assertions
-that run alongside the code.
+that run alongside the code, and run them with ``tina4 test``.
 
 Usage:
-    from tina4_python.Testing import tests, assert_equal, assert_raises
+    from tina4_python.Testing import tests, expect_equal, expect_raises
 
     @tests(
-        assert_equal((5, 3), 8),
-        assert_raises(ValueError, (None,))
+        expect_equal((5, 3), 8),
+        expect_raises(ValueError, (None,))
     )
     def add(a, b=None):
         if b is None:
@@ -20,6 +20,15 @@ Usage:
 Run all tests:
     from tina4_python.Testing import run_all
     run_all()
+
+The builders are named ``expect_*`` — deliberately distinct from the xUnit
+``assert_*`` assertions in ``tina4_python.test`` (which take positional
+``(actual, expected, message)`` and assert immediately). ``expect_*`` are
+DESCRIPTORS: ``expect_equal((args,), expected)`` records "call the decorated
+function with ``args`` and check the result equals ``expected``" for the
+runner to execute later. Keeping the two surfaces' names apart means importing
+the wrong one is a loud ``ImportError``/``AttributeError``, never a silent
+change of call semantics.
 """
 
 import sys
@@ -32,23 +41,23 @@ _registry: list[dict] = []
 
 # ── Assertion builders ──────────────────────────────────────────────
 
-def assert_equal(args: tuple, expected):
-    """Assert that calling the decorated function with *args* returns *expected*."""
+def expect_equal(args: tuple, expected):
+    """Expect that calling the decorated function with *args* returns *expected*."""
     return {"type": "equal", "args": args, "expected": expected}
 
 
-def assert_raises(exception_class: type, args: tuple):
-    """Assert that calling the decorated function with *args* raises *exception_class*."""
+def expect_raises(exception_class: type, args: tuple):
+    """Expect that calling the decorated function with *args* raises *exception_class*."""
     return {"type": "raises", "exception": exception_class, "args": args}
 
 
-def assert_true(args: tuple):
-    """Assert that calling the decorated function with *args* returns a truthy value."""
+def expect_true(args: tuple):
+    """Expect that calling the decorated function with *args* returns a truthy value."""
     return {"type": "true", "args": args}
 
 
-def assert_false(args: tuple):
-    """Assert that calling the decorated function with *args* returns a falsy value."""
+def expect_false(args: tuple):
+    """Expect that calling the decorated function with *args* returns a falsy value."""
     return {"type": "false", "args": args}
 
 

{tina4_python-3.13.97 → tina4_python-3.13.99}/tina4_python/__init__.py

@@ -51,7 +51,7 @@ def _resolve_version() -> str:
     #
     # test_version_constant.py now asserts this literal equals the pyproject
     # version, so the release bump cannot leave it behind again.
-    return "3.13.97"
+    return "3.13.99"
 
 
 __version__ = _resolve_version()
@@ -106,6 +106,7 @@ _LAZY: dict[str, tuple[str, str]] = {
     "TextField": ("tina4_python.orm", "TextField"),
     "BlobField": ("tina4_python.orm", "BlobField"),
     "NumericField": ("tina4_python.orm", "NumericField"),
+    "DecimalField": ("tina4_python.orm", "DecimalField"),
     "JSONField": ("tina4_python.orm", "JSONField"),
     "ForeignKeyField": ("tina4_python.orm", "ForeignKeyField"),
     "IntField": ("tina4_python.orm", "IntField"),
@@ -148,9 +149,12 @@ _LAZY: dict[str, tuple[str, str]] = {
     "StorageBackend": ("tina4_python.realtime.storage", "StorageBackend"),
     "LocalStorage": ("tina4_python.realtime.storage", "LocalStorage"),
     "S3Storage": ("tina4_python.realtime.storage", "S3Storage"),
-    # Inline testing
+    # Inline testing (decorator/descriptor surface — expect_* builders)
     "tests": ("tina4_python.Testing", "tests"),
-    "assert_equal_inline": ("tina4_python.Testing", "assert_equal"),
+    "expect_equal": ("tina4_python.Testing", "expect_equal"),
+    "expect_raises": ("tina4_python.Testing", "expect_raises"),
+    "expect_true": ("tina4_python.Testing", "expect_true"),
+    "expect_false": ("tina4_python.Testing", "expect_false"),
 }
 
 

{tina4_python-3.13.97 → tina4_python-3.13.99}/tina4_python/api/__init__.py

@@ -24,6 +24,12 @@ from urllib.parse import urlencode, urlparse
 from urllib.request import Request, HTTPRedirectHandler, HTTPSHandler, build_opener
 from urllib.error import HTTPError, URLError
 
+# Safe: importing the tina4_python.api submodule always fully initializes the
+# tina4_python package first, and __version__ is set near the very top of
+# tina4_python/__init__.py, well before Api (a LAZY-loaded name) is ever
+# touched -- no circular import.
+from tina4_python import __version__
+
 
 # Statuses that warrant an automatic retry when ``max_retries`` > 0: rate-limit
 # (429) plus the transient server-side 5xx family. 4xx client errors (401,
@@ -382,7 +388,14 @@ class Api:
 
     def _build_request(self, method: str, url: str, body, content_type: str,
                        extra_headers: dict | None = None) -> Request:
-        headers = dict(self._headers)
+        # VERSION-DEC-03 (feature 130): every outbound request carries a
+        # default ``Tina4/<version>`` User-Agent. ``self._headers`` is merged
+        # in AFTER the default, and ``extra_headers`` after that, so a
+        # caller-supplied User-Agent (via the constructor's ``headers=``,
+        # ``add_headers()``, or a per-call ``extra_headers``) always wins --
+        # this is a default, never a clobber.
+        headers = {"User-Agent": f"Tina4/{__version__}"}
+        headers.update(self._headers)
         if self.auth_header:
             headers["Authorization"] = self.auth_header
 

{tina4_python-3.13.97 → tina4_python-3.13.99}/tina4_python/auth/__init__.py

@@ -783,7 +783,11 @@ class AuthMiddleware:
         token = auth_header[7:]
         if not Auth.valid_token_static(token):
             return request, response({"error": "Invalid token"}, 401)
-        request.auth = Auth.get_payload_static(token)
+        # Stash the payload on request.user (REQ-PY-NO-USER, 3.13.99 — the
+        # field every other framework already exposes). This used to assign
+        # request.auth, which __slots__ has never declared, so this branch
+        # raised AttributeError on every SUCCESSFUL authentication.
+        request.user = Auth.get_payload_static(token)
         return request, response
 
 

{tina4_python-3.13.97 → tina4_python-3.13.99}/tina4_python/cli/__init__.py

@@ -128,8 +128,8 @@ def _fields_or_default(fields_str: str) -> list[tuple[str, str]]:
 def _parse_flags(args: list[str]) -> tuple[dict, list[str]]:
     """Parse --key value and --flag from args. Returns (flags, positional)."""
     # Boolean-only flags that never take a value argument
-    boolean_flags = {"no-browser", "no-reload", "production", "managed", "all", "clear", "json",
-                     "public", "no-migration", "once"}
+    boolean_flags = {"no-browser", "no-reload", "no-kill", "production", "managed", "all", "clear",
+                     "json", "public", "no-migration", "once"}
 
     flags = {}
     positional = []
@@ -221,87 +221,37 @@ def _parse_every(every: str) -> int:
         return 60
 
 
-def _in_container() -> bool:
-    """True when this process is running inside a container.
-
-    Reclaiming a port makes sense on a dev machine, where a previous
-    ``tina4 serve`` may still hold it. Inside a container the server IS the
-    container, so there is never a stale sibling to reclaim from -- and trying
-    is actively dangerous (see ``_kill_process_on_port``).
-    """
-    if os.path.exists("/.dockerenv") or os.path.exists("/run/.containerenv"):
-        return True
-    try:
-        with open("/proc/1/cgroup", "r", encoding="utf-8", errors="replace") as fh:
-            blob = fh.read()
-        return "docker" in blob or "containerd" in blob or "kubepods" in blob
-    except OSError:
-        return False
-
-
-def selectable_pids(lsof_output: str, me: int, my_group: int | None = None) -> list[int]:
-    """The PIDs from ``lsof -ti`` output that are safe to signal.
-
-    Pure so the safety rule can be tested directly. An unvalidated parse is a
-    footgun with real teeth: when ``lsof`` is present but prints a different
-    shape than ``-ti`` implies, a non-numeric field coerces to 0, and
-    signalling PID 0 sends the signal to EVERY process in the caller's own
-    process group -- the server kills itself. That is exactly what happened in
-    a container, where the log read "Killed existing process on port 7148
-    (PID: 1 ...)" and the container exited 143.
-
-    So: accept only all-digit tokens, and never PID 0 (our process group),
-    PID 1 (init), ourselves, or our own process group.
-    """
-    pids = []
-    for token in lsof_output.split():
-        if not token.isdigit():
-            continue              # never coerce junk into a PID
-        pid = int(token)
-        if pid <= 1 or pid == me:
-            continue              # 0 = our process group, 1 = init, me = suicide
-        if my_group is not None and pid == my_group:
-            continue
-        if pid not in pids:
-            pids.append(pid)
-    return pids
+# The port-takeover safety logic (identity check, PID safety filter, container
+# guard, dev gate, opt-out) lives in ONE shared module so the CLI path here and
+# the runtime bind-failure fallback in core/server.py cannot diverge
+# (TAKEOVER-DEC-02). `selectable_pids` and `_in_container` are re-exported so
+# their existing callers/tests keep resolving `tina4_python.cli.selectable_pids`.
+from tina4_python.core.port_takeover import (  # noqa: E402
+    selectable_pids,
+    in_container as _in_container,
+    take_over_port,
+    is_dev,
+    no_takeover_opted_out,
+)
 
 
 def _kill_process_on_port(port: int) -> bool:
-    """Kill any process listening on the given port. Returns True if killed.
+    """Reclaim *port* from a stale Tina4 dev server, only when it is safe.
 
-    Skipped entirely in a container, where the server IS the container and
-    there is no stale sibling to reclaim from. The PID safety rule lives in
-    :func:`selectable_pids`.
-    """
-    if _in_container():
-        return False
-    try:
-        result = subprocess.run(
-            ["lsof", "-ti", f":{port}"],
-            capture_output=True, text=True, timeout=5,
-        )
-        if result.returncode != 0 or not result.stdout.strip():
-            return False
+    Routes through the shared identity-checked takeover (TAKEOVER-DEC-01/02):
+    a holder is signalled ONLY when a Tina4 dev server recorded its PID in the
+    per-port PID file. A foreign holder is left running and a clear message is
+    printed; takeover is also skipped in a container, outside dev mode, and when
+    opted out (`TINA4_NO_TAKEOVER` / `tina4 serve --no-kill`).
 
-        me = os.getpid()
-        my_group = os.getpgrp() if hasattr(os, "getpgrp") else None
-        killed = []
-        for pid in selectable_pids(result.stdout, me, my_group):
-            try:
-                os.kill(pid, signal.SIGTERM)
-                killed.append(str(pid))
-            except (ProcessLookupError, PermissionError):
-                pass
-
-        if not killed:
-            return False
-        import time
-        time.sleep(0.5)
-        print(f"  ⚠ Killed existing process on port {port} (PID: {', '.join(killed)})")
+    Returns True only when a Tina4 holder was actually signalled.
+    """
+    result = take_over_port(port, dev=is_dev(), no_takeover=no_takeover_opted_out())
+    if result.reclaimed:
+        print(f"  ⚠ {result.message}")
         return True
-    except (FileNotFoundError, subprocess.TimeoutExpired):
-        pass
+    if result.refused and result.message:
+        print(f"  {result.message}")
     return False
 
 
@@ -834,7 +784,12 @@ def _serve(args):
     # --no-reload flag
     no_reload = "no-reload" in flags
 
-    # Kill existing process on port
+    # --no-kill opts out of port takeover for the whole process, so the CLI path
+    # here AND the runtime bind-failure fallback both honour it (TAKEOVER-DEC-03).
+    if "no-kill" in flags:
+        os.environ["TINA4_NO_TAKEOVER"] = "true"
+
+    # Reclaim the port from a stale Tina4 dev server only (identity-checked).
     port = cli_port or int(os.environ.get("PORT", os.environ.get("TINA4_PORT", "7146")))
     _kill_process_on_port(port)
 
@@ -907,14 +862,14 @@ def _migrate_status(args):
     if completed:
         print("\nCompleted migrations:")
         for m in completed:
-            print(f"  [batch {m['batch']}] {m['migration_id']}  ({m['executed_at']})")
+            print(f"  [batch {m['batch']}] {m['migration_name']}  ({m['executed_at']})")
     else:
         print("\nNo completed migrations.")
 
     if pending:
         print("\nPending migrations:")
         for m in pending:
-            print(f"  {m['migration_id']}  ({m['description']})")
+            print(f"  {m['migration_name']}  ({m['description']})")
     else:
         print("\nNo pending migrations.")
 
@@ -977,10 +932,70 @@ def _routes(args):
     print(f"\n{len(routes)} route(s) registered.")
 
 
+def _run_inline_tests(root: Path) -> bool:
+    """Discover ``@tests``-decorated functions under ``src/`` and run them.
+
+    Returns True if any inline test FAILED or ERRORED (so the caller can exit
+    non-zero), False if everything passed or there were no inline tests.
+
+    Only files whose text contains ``@tests`` are imported — a source file
+    without an inline test is never executed, so ``tina4 test`` cannot run a
+    scanned file's arbitrary side effect. This is the ``@tests`` decorator
+    surface wired to a real exit code (INLINE-DEC-01).
+    """
+    import importlib.util
+
+    from tina4_python.Testing import reset, run_all
+
+    src = root / "src"
+    if not src.is_dir():
+        return False
+
+    reset()
+    discovered = 0
+    for path in sorted(src.rglob("*.py")):
+        try:
+            text = path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        if "@tests" not in text:
+            continue
+        discovered += 1
+        module_name = "tina4_inline_" + re.sub(r"\W", "_", str(path.relative_to(root)))
+        spec = importlib.util.spec_from_file_location(module_name, str(path))
+        if spec is None or spec.loader is None:
+            continue
+        try:
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+        except Exception as exc:  # noqa: BLE001 — report and keep going
+            print(f"  ! could not import {path.relative_to(root)}: {exc}")
+
+    if discovered == 0:
+        return False
+
+    results = run_all()
+    return (results["failed"] + results["errors"]) > 0
+
+
 def _test(args):
-    """Run the test suite."""
-    result = subprocess.run([sys.executable, "-m", "pytest", "tests/"] + args)
-    sys.exit(result.returncode)
+    """Run the inline ``@tests`` suite AND the pytest suite; exit non-zero if either fails.
+
+    The inline stage discovers ``@tests``-decorated functions under ``src/`` and
+    runs them with a real exit code (INLINE-DEC-01) — the batteries-included flow
+    the docs advertise. The pytest stage still runs the ``tests/`` suite when that
+    directory exists (preserving the python#96 exit-code contract), so a project
+    that keeps its tests in ``tests/`` is unaffected.
+    """
+    inline_failed = _run_inline_tests(Path.cwd())
+
+    pytest_code = 0
+    if Path("tests").is_dir():
+        pytest_code = subprocess.run(
+            [sys.executable, "-m", "pytest", "tests/"] + args
+        ).returncode
+
+    sys.exit(1 if (inline_failed or pytest_code) else 0)
 
 
 def _build(args):
@@ -1211,8 +1226,8 @@ def _gen_route(name: str, flags: dict, *, emit_test: bool = True):
 @get("/api/{route_path}")
 async def list_{route_path}(request, response):
     """List all {route_path} with pagination."""
-    page = int(request.params.get("page", 1))
-    per_page = int(request.params.get("per_page", 20))
+    page = int(request.query.get("page", 1))
+    per_page = int(request.query.get("per_page", 20))
     offset = (page - 1) * per_page
     records, total = {model}.where("1=1", limit=per_page, offset=offset, with_count=True)
     return response({{