tina4-python 3.13.30__tar.gz → 3.13.32__tar.gz

{tina4_python-3.13.30 → tina4_python-3.13.32}/PKG-INFO

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

{tina4_python-3.13.30 → tina4_python-3.13.32}/pyproject.toml

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

{tina4_python-3.13.30 → tina4_python-3.13.32}/tina4_python/CLAUDE.md

@@ -492,10 +492,9 @@ return response.stream(generator)          # SSE/streaming response (text/event-
 
 `response()` auto-serializes a domain object — an ORM model, a list of models, or a `DatabaseResult` — to JSON with no manual `to_dict()` / `to_json()`. A single model becomes a JSON object; a list of models or a `DatabaseResult` becomes a JSON array. Dicts, lists and strings behave exactly as before (purely additive).
 
-Add custom headers before returning:
+Add custom headers by calling `add_header` on the `response` object in your handler:
 ```python
-from tina4_python.core.response import Response
-Response.add_header("X-Custom", "value")
+response.add_header("X-Custom", "value")
 ```
 
 ## Sessions
@@ -1042,8 +1041,7 @@ class AuthMiddleware:
     @staticmethod
     def after_headers(request, response):
         """Add custom headers to every response."""
-        from tina4_python.core.response import Response
-        Response.add_header("X-Powered-By", "Tina4")
+        response.add_header("X-Powered-By", "Tina4")
         return request, response
 
 @middleware(AuthMiddleware)

{tina4_python-3.13.30 → tina4_python-3.13.32}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.13.30"
+__version__ = "3.13.32"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.13.30 → tina4_python-3.13.32}/tina4_python/cache/__init__.py

@@ -880,7 +880,10 @@ class ResponseCache:
                 self._hits += 1
                 # Move to end (most recently used)
                 self._store.move_to_end(cache_key)
-                return request, response(entry.body, entry.status_code)
+                remaining = max(0, int(round(entry.expires_at - time.monotonic())))
+                hit_response = response(entry.body, entry.status_code)
+                self._set_cache_headers(hit_response, "HIT", remaining)
+                return request, hit_response
 
             self._misses += 1
 
@@ -930,6 +933,11 @@ class ResponseCache:
             self._store[cache_key] = entry
             self._store.move_to_end(cache_key)
 
+        # The handler ran for this request → MISS. Advertise the TTL the
+        # entry was just stored with so clients can see how long the next
+        # HIT will live.
+        self._set_cache_headers(response, "MISS", cache_ttl)
+
         return request, response
 
     # ── Public API ───────────────────────────────────────────────
@@ -965,6 +973,31 @@ class ResponseCache:
 
     # ── Internal helpers ─────────────────────────────────────────
 
+    @staticmethod
+    def _set_cache_headers(response, status: str, ttl: int) -> None:
+        """Set ``X-Cache`` / ``X-Cache-TTL`` on the outgoing response.
+
+        ``status`` is ``"HIT"`` (served from cache) or ``"MISS"`` (handler
+        ran). ``ttl`` is the entry's remaining seconds on a HIT, or the
+        configured TTL on a MISS. We deliberately do NOT emit
+        ``Cache-Control`` — browser-cache directives are the app's call.
+
+        Works with the framework ``Response`` (``add_header``) and with any
+        object exposing a ``headers`` dict, so middleware stubs and other
+        response shapes keep working.
+        """
+        if response is None:
+            return
+        headers = {"X-Cache": status, "X-Cache-TTL": str(int(ttl))}
+        setter = getattr(response, "add_header", None) or getattr(response, "header", None)
+        if callable(setter):
+            for name, value in headers.items():
+                setter(name, value)
+            return
+        existing = getattr(response, "headers", None)
+        if isinstance(existing, dict):
+            existing.update(headers)
+
     @staticmethod
     def _get_route_ttl(request) -> int | None:
         """Check for a per-route cache TTL set via the @cached decorator."""

{tina4_python-3.13.30 → tina4_python-3.13.32}/tina4_python/database/connection.py

@@ -519,7 +519,7 @@ class Database:
         return adapter.execute_many(sql, params_list)
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 100, offset: int = 0) -> DatabaseResult:
+              limit: int = 100, offset: int = 0, no_cache: bool = False) -> DatabaseResult:
         """Fetch rows with pagination.
 
         v3.13.11 (issue #49 Gap 3): mirror :meth:`execute` and capture
@@ -527,25 +527,32 @@ class Database:
         ``db.get_error()`` returning ``None`` even though the adapter
         had stored the failure on its own ``last_error``. Callers had
         no way to read the cause via the public API.
+
+        ``no_cache=True`` bypasses the query cache for this one call — no
+        lookup and no store — and runs the query straight against the DB.
+        Works in either cache mode (request-scoped auto-cache or persistent
+        DB cache). The default (``False``) preserves today's behaviour.
         """
-        if self._cache_enabled:
+        if self._cache_enabled and not no_cache:
             key = self._cache_key(sql + f":L{limit}:S{offset}", params)
             cached = self._cache_get(key)
             if cached is not None:
                 with self._cache_lock:
                     self._cache_hits += 1
                 return cached
-            adapter = self._get_adapter()
-            try:
-                result = adapter.fetch(sql, params, limit, offset)
-                self.last_error = None
-            except Exception:
-                self.last_error = getattr(adapter, "last_error", None) or self.last_error
-                raise
+            result = self._fetch_direct(sql, params, limit, offset)
             self._cache_set(key, result)
             with self._cache_lock:
                 self._cache_misses += 1
             return result
+        return self._fetch_direct(sql, params, limit, offset)
+
+    def _fetch_direct(self, sql: str, params: list, limit: int, offset: int) -> DatabaseResult:
+        """Run a fetch straight against the adapter — no cache lookup or store.
+
+        Shared by the cached and ``no_cache`` paths so error capture stays
+        identical regardless of caching.
+        """
         adapter = self._get_adapter()
         try:
             result = adapter.fetch(sql, params, limit, offset)
@@ -556,7 +563,7 @@ class Database:
             raise
 
     def fetch_all(self, sql: str, params: list = None,
-                  limit: int = 0, offset: int = 0) -> list[dict]:
+                  limit: int = 0, offset: int = 0, no_cache: bool = False) -> list[dict]:
         """Fetch ALL rows and return the records list directly.
 
         Symmetric with ``fetch_one``. For the common case where you just
@@ -572,26 +579,32 @@ class Database:
         name says ``fetch_all``, so it returns all matching rows. Pre-v3.13.12
         silently truncated to 100. Pass an explicit ``limit=N`` to cap.
 
-        Returns ``[]`` (not ``None``) when no rows match.
+        ``no_cache=True`` bypasses the query cache for this one call (see
+        :meth:`fetch`). Returns ``[]`` (not ``None``) when no rows match.
         """
-        return self.fetch(sql, params, limit, offset).records
+        return self.fetch(sql, params, limit, offset, no_cache=no_cache).records
 
-    def fetch_one(self, sql: str, params: list = None) -> dict | None:
-        if self._cache_enabled:
+    def fetch_one(self, sql: str, params: list = None, no_cache: bool = False) -> dict | None:
+        """Fetch a single row as a dict, or ``None`` when no row matches.
+
+        ``no_cache=True`` bypasses the query cache for this one call — no
+        lookup and no store — and runs the query straight against the DB
+        (see :meth:`fetch`). The default (``False``) preserves today's
+        behaviour.
+        """
+        if self._cache_enabled and not no_cache:
             key = self._cache_key(sql + ":ONE", params)
             cached = self._cache_get(key)
             if cached is not None:
                 with self._cache_lock:
                     self._cache_hits += 1
                 return cached
-            adapter = self._get_adapter()
-            result = adapter.fetch_one(sql, params)
+            result = self._get_adapter().fetch_one(sql, params)
             self._cache_set(key, result)
             with self._cache_lock:
                 self._cache_misses += 1
             return result
-        adapter = self._get_adapter()
-        return adapter.fetch_one(sql, params)
+        return self._get_adapter().fetch_one(sql, params)
 
     def insert(self, table: str, data: dict | list) -> DatabaseResult:
         if self._cache_enabled: