tina4-python 3.12.14__tar.gz → 3.13.0__tar.gz

{tina4_python-3.12.14 → tina4_python-3.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.12.14
+Version: 3.13.0
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT
@@ -452,7 +452,7 @@ request.session.set("user_id", 42)
 user_id = request.session.get("user_id")
 ```
 
-Backends: file (default), Redis, Valkey, MongoDB, database. Set via `TINA4_SESSION_HANDLER` in `.env`.
+Backends: file (default), Redis, Valkey, MongoDB, database. Set via `TINA4_SESSION_BACKEND` in `.env`.
 
 ### Queues
 
@@ -699,7 +699,7 @@ TINA4_DATABASE_URL=sqlite:///data/app.db
 TINA4_DEBUG=true                     # Enable dev toolbar, error overlay
 TINA4_LOG_LEVEL=ALL                  # ALL, DEBUG, INFO, WARNING, ERROR
 TINA4_LOCALE=en                      # en, fr, af, zh, ja, es
-TINA4_SESSION_HANDLER=SessionFileHandler
+TINA4_SESSION_BACKEND=SessionFileHandler
 SWAGGER_TITLE=My API
 ```
 

{tina4_python-3.12.14 → tina4_python-3.13.0}/README.md

@@ -420,7 +420,7 @@ request.session.set("user_id", 42)
 user_id = request.session.get("user_id")
 ```
 
-Backends: file (default), Redis, Valkey, MongoDB, database. Set via `TINA4_SESSION_HANDLER` in `.env`.
+Backends: file (default), Redis, Valkey, MongoDB, database. Set via `TINA4_SESSION_BACKEND` in `.env`.
 
 ### Queues
 
@@ -667,7 +667,7 @@ TINA4_DATABASE_URL=sqlite:///data/app.db
 TINA4_DEBUG=true                     # Enable dev toolbar, error overlay
 TINA4_LOG_LEVEL=ALL                  # ALL, DEBUG, INFO, WARNING, ERROR
 TINA4_LOCALE=en                      # en, fr, af, zh, ja, es
-TINA4_SESSION_HANDLER=SessionFileHandler
+TINA4_SESSION_BACKEND=SessionFileHandler
 SWAGGER_TITLE=My API
 ```
 

{tina4_python-3.12.14 → tina4_python-3.13.0}/pyproject.toml

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

{tina4_python-3.12.14 → tina4_python-3.13.0}/tina4_python/CLAUDE.md

@@ -498,7 +498,7 @@ TINA4_TOKEN_LIMIT is used to set the session time, default 60 minutes
 
 ### Session Backends
 
-Set `TINA4_SESSION_HANDLER` to choose a backend:
+Set `TINA4_SESSION_BACKEND` to choose a backend:
 
 | Handler | Backend | Required package |
 |---------|---------|-----------------|
@@ -510,7 +510,7 @@ Set `TINA4_SESSION_HANDLER` to choose a backend:
 #### MongoDB session env vars
 
 ```bash
-TINA4_SESSION_HANDLER=SessionMongoHandler
+TINA4_SESSION_BACKEND=SessionMongoHandler
 TINA4_SESSION_MONGO_HOST=localhost        # default
 TINA4_SESSION_MONGO_PORT=27017            # default
 TINA4_SESSION_MONGO_URI=                  # full URI (overrides host/port)
@@ -1411,7 +1411,7 @@ async def products(request, response):
     return response(expensive_query())
 
 # Per-route TTL override via @cached decorator
-@cached(True, max_age=120)
+@cached(max_age=120)
 @get("/api/slow")
 async def slow(request, response):
     return response(very_slow_query())
@@ -1578,7 +1578,7 @@ TINA4_OVERRIDE_CLIENT=false       # Set to true to allow running without tina4 C
 HOST_NAME=localhost:7145
 
 # Sessions
-TINA4_SESSION_HANDLER=SessionFileHandler  # SessionFileHandler, SessionRedisHandler, SessionValkeyHandler, SessionMongoHandler
+TINA4_SESSION_BACKEND=SessionFileHandler  # SessionFileHandler, SessionRedisHandler, SessionValkeyHandler, SessionMongoHandler
 TINA4_SESSION_SAMESITE=Lax               # SameSite attribute for session cookies (default: Lax)
 
 # Swagger/OpenAPI

{tina4_python-3.12.14 → tina4_python-3.13.0}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.12.14"
+__version__ = "3.13.0"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401
@@ -61,3 +61,26 @@ from tina4_python.container import Container  # noqa: E402, F401
 
 # ── Server ──
 from tina4_python.core.server import run, background  # noqa: E402, F401
+
+# ── HTTP Client ──
+from tina4_python.api import Api  # noqa: E402, F401
+
+# ── SOAP / WSDL ──
+from tina4_python.wsdl import WSDL, wsdl_operation  # noqa: E402, F401
+
+# ── GraphQL ──
+from tina4_python.graphql import GraphQL  # noqa: E402, F401
+
+# ── Auto-CRUD scaffolder ──
+from tina4_python.crud import AutoCrud  # noqa: E402, F401
+
+# ── Events (decoupled communication) ──
+from tina4_python.core.events import on, emit, once, off  # noqa: E402, F401
+
+# ── Email (Messenger) ──
+from tina4_python.messenger import Messenger  # noqa: E402, F401
+
+# ── Inline testing (@tests + assertions for inline test cases) ──
+# Class-based xUnit testing lives in tina4_python.test (a separate module).
+# Keep both surfaces re-exported so users can write either style.
+from tina4_python.Testing import tests, assert_equal as assert_equal_inline  # noqa: E402, F401

{tina4_python-3.12.14 → tina4_python-3.13.0}/tina4_python/ai/__init__.py

@@ -1,9 +1,14 @@
-# Tina4 AI — Install AI coding assistant context files.
+# Tina4 AI — Detect and install AI coding assistant context files.
 """
-Simple menu-driven installer for AI tool context files.
-The user picks which tools they use, we install the appropriate files.
+Detect which AI tools are present in a project and install Tina4-aware
+context files so any assistant understands the framework.
 
-    from tina4_python.ai import show_menu, install_selected
+    from tina4_python.ai import detect_ai, install_context, status_report
+
+    tools = detect_ai(".")          # → [{"name": "claude-code", "installed": True, ...}, ...]
+    install_context(".")             # install for all known tools
+    install_context(".", tools=["claude-code", "cursor"])
+    print(status_report("."))        # human-readable summary
 """
 import os
 import shutil
@@ -29,6 +34,47 @@ def is_installed(root: str, tool: dict) -> bool:
     return (Path(root).resolve() / tool["context_file"]).exists()
 
 
+# ── Detection API (docs-friendly names) ────────────────────────────────────
+
+
+def detect_ai(root: str = ".") -> list[dict]:
+    """Detect which AI coding tools are installed in ``root``.
+
+    Returns a list of tool dicts, one per known AI tool, with an
+    ``installed`` boolean added. The list mirrors ``AI_TOOLS`` order.
+
+        from tina4_python.ai import detect_ai
+        tools = detect_ai(".")
+        installed = [t for t in tools if t["installed"]]
+    """
+    return [{**t, "installed": is_installed(root, t)} for t in AI_TOOLS]
+
+
+def detect_ai_names(root: str = ".") -> list[str]:
+    """Return only the names of detected (installed) AI tools.
+
+        names = detect_ai_names(".")   # → ["claude-code", "cursor"]
+    """
+    return [t["name"] for t in AI_TOOLS if is_installed(root, t)]
+
+
+def status_report(root: str = ".") -> str:
+    """Human-readable summary of AI-tool installation state in ``root``.
+
+    Returns a multi-line string suitable for printing — lists each tool
+    along with installed/not-installed and the path of the context file.
+    """
+    root = str(Path(root).resolve())
+    lines = [f"AI tool status — {root}", ""]
+    for tool in AI_TOOLS:
+        marker = "✓ installed" if is_installed(root, tool) else "  not present"
+        lines.append(f"  {marker}  {tool['description']:<24s} → {tool['context_file']}")
+    installed_count = sum(1 for t in AI_TOOLS if is_installed(root, t))
+    lines.append("")
+    lines.append(f"  {installed_count}/{len(AI_TOOLS)} tools have Tina4 context.")
+    return "\n".join(lines)
+
+
 def show_menu(root: str = ".") -> str:
     """Print the numbered menu and return user input."""
     root = str(Path(root).resolve())
@@ -89,9 +135,30 @@ def install_selected(root: str, selection: str) -> list[str]:
     return created
 
 
-def install_all(root: str = ".") -> list[str]:
-    """Install context for all AI tools (non-interactive)."""
-    return install_selected(root, "all")
+def install_context(root: str = ".", tools: "list[str] | None" = None) -> list[str]:
+    """Install Tina4 context files for AI tools (non-interactive).
+
+    Args:
+        root: Project root directory.
+        tools: Optional list of tool names. When omitted, installs for all
+               known AI tools.
+
+    Returns a list of relative paths to the files that were created.
+
+        install_context(".")                          # all tools
+        install_context(".", tools=["claude-code"])   # just one
+    """
+    if tools is None:
+        selection = "all"
+    else:
+        # Translate names → indices for install_selected's CSV input
+        index_map = {t["name"]: str(i + 1) for i, t in enumerate(AI_TOOLS)}
+        try:
+            selection = ",".join(index_map[name] for name in tools)
+        except KeyError as e:
+            known = ", ".join(t["name"] for t in AI_TOOLS)
+            raise ValueError(f"Unknown AI tool: {e!s}. Known: {known}") from e
+    return install_selected(root, selection)
 
 
 def _install_for_tool(root: Path, tool: dict, context: str) -> list[str]:

{tina4_python-3.12.14 → tina4_python-3.13.0}/tina4_python/api/__init__.py

@@ -20,13 +20,50 @@ class Api:
     """HTTP client using urllib — zero external dependencies."""
 
     def __init__(self, base_url: str = "", auth_header: str = "",
-                 ignore_ssl: bool = False, timeout: int = 30):
+                 ignore_ssl: bool = False, timeout: int = 30,
+                 bearer_token: str | None = None,
+                 username: str | None = None,
+                 password: str | None = None,
+                 headers: dict[str, str] | None = None,
+                 verify_ssl: bool | None = None):
+        """HTTP client.
+
+        Constructor accepts ergonomic kwargs the documentation has long
+        described — every modern Python HTTP library (requests, httpx)
+        accepts these directly rather than requiring post-construction
+        setter calls.
+
+            api = Api("https://api.example.com", bearer_token="sk-...")
+            api = Api("https://api.example.com", username="u", password="p")
+            api = Api("https://api.example.com", headers={"X-Tenant": "acme"})
+            api = Api("https://self-signed.local", verify_ssl=False)
+
+        The setter-based API (``set_bearer_token``, ``set_basic_auth``,
+        ``add_headers``) continues to work; pick whichever reads better.
+
+        ``verify_ssl`` is the docs-friendly inverse of ``ignore_ssl`` —
+        ``verify_ssl=False`` is equivalent to ``ignore_ssl=True``. If
+        both are supplied, ``ignore_ssl`` wins (legacy precedence).
+        """
         self.base_url = base_url.rstrip("/")
         self.auth_header = auth_header
         self.timeout = timeout
         self._headers: dict[str, str] = {}
         self._ssl_context = None
-        if ignore_ssl:
+
+        # ── kwarg sugar ────────────────────────────────────────────────
+        # Bearer token wins over basic auth if both are passed.
+        if bearer_token is not None:
+            self.set_bearer_token(bearer_token)
+        elif username is not None and password is not None:
+            self.set_basic_auth(username, password)
+
+        if headers:
+            self._headers.update(headers)
+
+        # ignore_ssl is the existing flag; verify_ssl=False is the same thing
+        # expressed positively. Honour ignore_ssl when both are set.
+        if ignore_ssl or (verify_ssl is False):
             self._ssl_context = ssl.create_default_context()
             self._ssl_context.check_hostname = False
             self._ssl_context.verify_mode = ssl.CERT_NONE
@@ -68,9 +105,14 @@ class Api:
         """HTTP DELETE request."""
         return self._request("DELETE", self._url(path), body)
 
-    def send_request(self, method: str, path: str = "", body=None,
+    def send(self, method: str, path: str = "", body=None,
              content_type: str = "application/json") -> dict:
-        """Generic request method."""
+        """Generic request method — pick HTTP verb at call time.
+
+        Renamed from ``send_request`` in 3.13.0 for parity with the
+        documentation and conciseness (``api.send("PATCH", ...)`` reads
+        cleaner than ``api.send_request("PATCH", ...)``).
+        """
         return self._request(method.upper(), self._url(path), body, content_type)
 
     def _url(self, path: str) -> str:

{tina4_python-3.12.14 → tina4_python-3.13.0}/tina4_python/auth/__init__.py

@@ -62,8 +62,14 @@ class Auth:
         """
         self.secret = secret or os.environ.get("TINA4_SECRET", "tina4-default-secret")
         self.algorithm = algorithm
+        # JWT expiry env var:
+        # - TINA4_TOKEN_EXPIRES_IN (preferred — matches docs and the
+        #   form-token expiry env var used by Frond)
+        # - TINA4_TOKEN_LIMIT (legacy — accepted for backward compat)
+        # Constructor arg wins over both env vars.
         self.expires_in = expires_in or int(
-            os.environ.get("TINA4_TOKEN_LIMIT", "60")
+            os.environ.get("TINA4_TOKEN_EXPIRES_IN")
+            or os.environ.get("TINA4_TOKEN_LIMIT", "60")
         )
 
     # ── JWT ────────────────────────────────────────────────────────
@@ -98,26 +104,42 @@ class Auth:
         return f"{h}.{p}.{signature}"
 
     @_DualMethod
-    def valid_token(self, token: str) -> bool:
-        """Validate a JWT signature and expiry. Returns True if valid, False otherwise."""
+    def valid_token(self, token: str) -> "dict | None":
+        """Validate a JWT signature + expiry. Returns the decoded payload
+        on success, or ``None`` if invalid / expired / malformed.
+
+        The payload dict is truthy for valid tokens and ``None`` is falsy,
+        so the legacy ``if Auth.valid_token(t):`` boolean-style usage keeps
+        working unchanged. Callers that want the payload can now read it
+        directly instead of a separate ``get_payload(t)`` call::
+
+            payload = Auth.valid_token(token)
+            if payload is None:
+                return response("Unauthorized", 401)
+            user_id = payload["user_id"]
+
+        Matches the convention used by PyJWT, python-jose, and authlib —
+        validity check returns the payload because the validation IS the
+        payload decode. Returning bare True/False discarded that information.
+        """
         try:
             parts = token.split(".")
             if len(parts) != 3:
-                return False
+                return None
 
             h, p, sig = parts
             expected = self._sign(f"{h}.{p}")
             if not hmac.compare_digest(sig, expected):
-                return False
+                return None
 
             payload = json.loads(_b64url_decode(p))
 
             if "exp" in payload and time.time() > payload["exp"]:
-                return False
+                return None
 
-            return True
+            return payload
         except Exception:
-            return False
+            return None
 
     @_DualMethod
     def get_payload(self, token: str) -> dict | None:
@@ -137,9 +159,7 @@ class Auth:
         Args:
             expires_in: Lifetime in minutes (default: self.expires_in).
         """
-        if not self.valid_token(token):
-            return None
-        payload = self.get_payload(token)
+        payload = self.valid_token(token)
         if payload is None:
             return None
         payload.pop("iat", None)
@@ -166,8 +186,11 @@ class Auth:
         return auth.get_token(payload)
 
     @classmethod
-    def valid_token_static(cls, token: str) -> bool:
-        """Validate a JWT without instantiating Auth — reads SECRET from env."""
+    def valid_token_static(cls, token: str) -> "dict | None":
+        """Validate a JWT without instantiating Auth — reads SECRET from env.
+
+        Returns the decoded payload on success, ``None`` on failure.
+        """
         secret = os.environ.get("TINA4_SECRET", "tina4-default-secret")
         auth = cls(secret=secret)
         return auth.valid_token(token)
@@ -307,8 +330,13 @@ def get_token(payload: dict, expires_in: int = 60, secret: str = None) -> str:
     return Auth.get_token_static(payload, expires_in=expires_in)
 
 
-def valid_token(token: str) -> bool:
-    """Validate a JWT signature and expiry — reads SECRET from env. Returns True if valid."""
+def valid_token(token: str) -> "dict | None":
+    """Validate a JWT signature and expiry — reads SECRET from env.
+
+    Returns the decoded payload dict on success, ``None`` on failure.
+    The truthy/falsy split keeps legacy ``if valid_token(t):`` code working
+    while letting new code read the payload directly.
+    """
     return Auth.valid_token_static(token)
 
 

{tina4_python-3.12.14 → tina4_python-3.13.0}/tina4_python/cli/__init__.py

@@ -399,9 +399,9 @@ def _init(args):
         )
 
     # AI context
-    from tina4_python.ai import install_all
+    from tina4_python.ai import install_context
     if "--ai" in args:
-        created = install_all(str(target))
+        created = install_context(str(target))
         if created:
             print("\nAI context installed for all supported tools:")
             for f in created:
@@ -602,10 +602,10 @@ def _build(args):
 
 def _ai(args):
     """Install AI coding assistant context files."""
-    from tina4_python.ai import show_menu, install_selected, install_all
+    from tina4_python.ai import show_menu, install_selected, install_context
 
     if args and args[0].lower() == "all":
-        install_all(".")
+        install_context(".")
     else:
         selection = show_menu(".")
         if selection:
@@ -743,8 +743,14 @@ async def list_{route_path}(request, response):
     page = int(request.params.get("page", 1))
     per_page = int(request.params.get("per_page", 20))
     offset = (page - 1) * per_page
-    results = {model}().select(limit=per_page, offset=offset)
-    return response(results.to_paginate(page=page, per_page=per_page))
+    records, total = {model}.where("1=1", limit=per_page, offset=offset, with_count=True)
+    return response({{
+        "records": [r.to_dict() for r in records],
+        "count": total,
+        "page": page,
+        "per_page": per_page,
+        "total_pages": max(1, -(-total // per_page)),
+    }})
 
 
 @noauth()

{tina4_python-3.12.14 → tina4_python-3.13.0}/tina4_python/container/__init__.py

@@ -27,7 +27,8 @@ class Container:
       subsequent calls return the memoised instance.
     - ``get(name)``                — resolve a dependency by name.
     - ``has(name)``                — check if a name is registered.
-    - ``reset()``                  — clear all registrations.
+    - ``reset()``                  — clear cached singletons; keep factories.
+    - ``reset_all()``              — clear both singletons AND factories.
     """
 
     def __init__(self):
@@ -80,6 +81,24 @@ class Container:
             return name in self._factories
 
     def reset(self) -> None:
-        """Clear all registrations."""
+        """Clear cached singleton instances; keep factory registrations.
+
+        Common test-fixture pattern: reset to drop cached state between
+        tests while keeping the DI graph wired. Transient registrations
+        are unaffected (they have no cache to clear).
+
+        For the old behaviour (clear everything including factories) use
+        ``reset_all()``.
+        """
+        with self._lock:
+            for entry in self._factories.values():
+                if entry.get("singleton"):
+                    entry["instance"] = None
+
+    def reset_all(self) -> None:
+        """Clear ALL registrations — both factories and cached singletons.
+
+        Tear-down for end-of-suite / process-shutdown scenarios.
+        """
         with self._lock:
             self._factories.clear()

{tina4_python-3.12.14 → tina4_python-3.13.0}/tina4_python/core/response.py

@@ -87,18 +87,26 @@ class Response:
         self._is_streaming: bool = False
         self._stream_source = None
 
-    def __call__(self, data=None, status_code: int = 200, content_type: str = None) -> "Response":
+    def __call__(self, data=None, status_code: int = 200, content_type: str = None,
+                 headers: dict | None = None) -> "Response":
         """Smart callable — auto-detects content type from data.
 
         Usage:
-            return response({"key": "value"})              # JSON
-            return response({"ok": True}, HTTP_CREATED)     # JSON with status
-            return response("<h1>Hello</h1>")               # HTML
-            return response("plain text", HTTP_OK)          # Plain text
-            return response(data, HTTP_OK, APPLICATION_JSON)  # Explicit
+            return response({"key": "value"})                       # JSON
+            return response({"ok": True}, HTTP_CREATED)              # JSON with status
+            return response("<h1>Hello</h1>")                        # HTML
+            return response("plain text", HTTP_OK)                   # Plain text
+            return response(data, HTTP_OK, APPLICATION_JSON)         # Explicit
+            return response(data, headers={"X-Tenant": "acme"})      # One-shot headers
         """
         self.status_code = status_code
 
+        # Optional one-shot headers — equivalent to chaining .header(k, v)
+        # for each entry, but lets call sites stay on a single expression.
+        if headers:
+            for k, v in headers.items():
+                self._headers.append((k, v))
+
         if content_type:
             # Explicit content type provided
             self.content_type = content_type
@@ -149,15 +157,48 @@ class Response:
         """Add a response header (chainable). Alias for header()."""
         return self.header(name, value)
 
-    def cookie(self, name: str, value: str, path: str = "/",
-               max_age: int = 3600, http_only: bool = True,
-               secure: bool = False, same_site: str = "Lax") -> "Response":
-        """Set a cookie (chainable)."""
-        parts = [f"{name}={value}", f"Path={path}", f"Max-Age={max_age}",
-                 f"SameSite={same_site}"]
-        if http_only:
+    def cookie(self, name: str, value: str, options=None, *,
+               path: str = None, max_age: int = None, http_only: bool = None,
+               secure: bool = None, same_site: str = None) -> "Response":
+        """Set a cookie (chainable). Two equivalent forms:
+
+            # Kwarg form (original)
+            response.cookie("session", token, max_age=3600, http_only=True)
+
+            # Dict-options form (when config comes from a settings object)
+            COOKIE_OPTS = {"max_age": 3600, "http_only": True, "secure": True}
+            response.cookie("session", token, COOKIE_OPTS)
+
+        When ``options`` is a dict, its values become the defaults; any
+        explicit kwarg passed afterwards overrides individual entries.
+        """
+        # Defaults
+        _path = "/"
+        _max_age = 3600
+        _http_only = True
+        _secure = False
+        _same_site = "Lax"
+
+        # Dict-options form
+        if isinstance(options, dict):
+            _path      = options.get("path", _path)
+            _max_age   = options.get("max_age", _max_age)
+            _http_only = options.get("http_only", _http_only)
+            _secure    = options.get("secure", _secure)
+            _same_site = options.get("same_site", _same_site)
+
+        # Explicit kwargs win over dict
+        if path      is not None: _path = path
+        if max_age   is not None: _max_age = max_age
+        if http_only is not None: _http_only = http_only
+        if secure    is not None: _secure = secure
+        if same_site is not None: _same_site = same_site
+
+        parts = [f"{name}={value}", f"Path={_path}", f"Max-Age={_max_age}",
+                 f"SameSite={_same_site}"]
+        if _http_only:
             parts.append("HttpOnly")
-        if secure:
+        if _secure:
             parts.append("Secure")
         self._cookies.append("; ".join(parts))
         return self
@@ -252,19 +293,28 @@ class Response:
             )
         return self
 
-    def render(self, template: str, data: dict = None) -> "Response":
+    def render(self, template: str, data: dict = None, status_code: int = None) -> "Response":
         """Render a Frond/Twig template with data.
 
         Uses the global Frond engine (registered via set_frond()) so that
         custom filters and globals are available in all templates.
         Falls back to framework templates if not found in user dir.
+
+        The optional ``status_code`` lets error-page handlers render the
+        page and set the response status in one call::
+
+            return response.render("errors/404.twig", {}, 404)
+            return response.render("errors/500.twig", {"err": str(e)}, 500)
         """
         engine = get_frond()
 
         # Try user templates first (the global engine's directory)
         try:
             html = engine.render(template, data or {})
-            return self.html(html)
+            rendered = self.html(html)
+            if status_code is not None:
+                rendered.status_code = status_code
+            return rendered
         except FileNotFoundError:
             pass
         except Exception as e:
@@ -275,7 +325,10 @@ class Response:
         if fw_engine is not None:
             try:
                 html = fw_engine.render(template, data or {})
-                return self.html(html)
+                rendered = self.html(html)
+                if status_code is not None:
+                    rendered.status_code = status_code
+                return rendered
             except FileNotFoundError:
                 pass
             except Exception as e: