tina4-python 3.13.21__tar.gz → 3.13.23__tar.gz

{tina4_python-3.13.21 → tina4_python-3.13.23}/PKG-INFO

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

{tina4_python-3.13.21 → tina4_python-3.13.23}/pyproject.toml

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

{tina4_python-3.13.21 → tina4_python-3.13.23}/tina4_python/CLAUDE.md

@@ -1836,10 +1836,10 @@ async def dashboard(request, response):
 ## v3 Features Summary
 
 - **55 built-in features**, zero third-party dependencies
-- **2,857 tests** passing across all modules
+- **2,866 tests** passing across all modules
 - **Production server auto-detect**: `tina4python serve --production` auto-installs uvicorn
 - **`tina4python generate`**: model, route, migration, middleware scaffolding
-- **Database**: 5 engines (SQLite, PostgreSQL, MySQL, MSSQL, Firebird), query caching (`TINA4_DB_CACHE=true`, `cache_stats()`, `cache_clear()`)
+- **Database**: 5 engines (SQLite, PostgreSQL, MySQL, MSSQL, Firebird), DB query caching — request-scoped auto cache **on by default** (`TINA4_AUTO_CACHING=true`, TTL `TINA4_AUTO_CACHING_TTL=5`s) dedupes identical reads within a request and flushes on writes; persistent cross-request cache opt-in via `TINA4_DB_CACHE=true` (TTL `TINA4_DB_CACHE_TTL=30`s); `cache_stats()` reports `mode` (request/persistent/off), `cache_clear()`
 - **Sessions**: 4 backends (file, Redis/Valkey, MongoDB, database)
 - **Queue**: file/RabbitMQ/Kafka/MongoDB backends, configured via env vars
 - **Cache**: memory/Redis/file backends

{tina4_python-3.13.21 → tina4_python-3.13.23}/tina4_python/__init__.py

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

{tina4_python-3.13.21 → tina4_python-3.13.23}/tina4_python/core/server.py

@@ -1563,6 +1563,15 @@ async def handle(request: Request) -> Response:
         if swagger_resp is not None:
             return swagger_resp
 
+    # Reset the request-scoped query cache so identical SELECTs are deduped
+    # within this request but never served across requests (zero cross-request
+    # staleness). No-op when TINA4_DB_CACHE=true (persistent mode) or disabled.
+    try:
+        from tina4_python.database.connection import Database as _Db
+        _Db.reset_request_caches()
+    except Exception:
+        pass
+
     # Route matching and dispatch
     route, params = Router.match(request.method, request.path)
 

{tina4_python-3.13.21 → tina4_python-3.13.23}/tina4_python/database/connection.py

@@ -13,6 +13,7 @@ import hashlib
 import os
 import threading
 import time
+import weakref
 from urllib.parse import urlparse
 from tina4_python.database.adapter import DatabaseAdapter, DatabaseResult
 
@@ -139,6 +140,10 @@ class Database:
     operations to the adapter. This is what the rest of the framework uses.
     """
 
+    #: Live Database instances, so the request dispatcher can reset the
+    #: request-scoped query cache on every connection at the start of a request.
+    _instances: "weakref.WeakSet[Database]" = weakref.WeakSet()
+
     @classmethod
     def get_connection(cls, url: str = None, username: str = "", password: str = "", pool: int = 0, **kwargs) -> "Database":
         """Open a database connection — convention name matching SQLAlchemy
@@ -205,14 +210,27 @@ class Database:
         # pool can't rotate mid-transaction and silently break atomicity.
         self._tx_local = threading.local()
 
-        # Query cache — off by default, opt-in via TINA4_DB_CACHE=true
+        # Query cache. One store, two layers:
+        #   • request-scoped (DEFAULT ON) — dedupes identical SELECTs to protect
+        #     the DB from rapid repeat reads. Cleared at the start of every HTTP
+        #     request (so it never serves data across requests) and on any write,
+        #     with a short safety TTL for non-request contexts (scripts/workers).
+        #     Off-switch: TINA4_AUTO_CACHING=false.
+        #   • persistent (opt-in, TINA4_DB_CACHE=true) — cross-request TTL cache
+        #     that is NOT cleared per request; entries expire by TINA4_DB_CACHE_TTL.
         from tina4_python.dotenv import is_truthy
-        self._cache_enabled: bool = is_truthy(os.environ.get("TINA4_DB_CACHE", "false"))
-        self._cache_ttl: int = int(os.environ.get("TINA4_DB_CACHE_TTL", "30"))
+        self._cache_persistent: bool = is_truthy(os.environ.get("TINA4_DB_CACHE", "false"))
+        self._cache_request_scoped: bool = is_truthy(os.environ.get("TINA4_AUTO_CACHING", "true"))
+        self._cache_enabled: bool = self._cache_persistent or self._cache_request_scoped
+        if self._cache_persistent:
+            self._cache_ttl: int = int(os.environ.get("TINA4_DB_CACHE_TTL", "30"))
+        else:
+            self._cache_ttl = int(os.environ.get("TINA4_AUTO_CACHING_TTL", "5"))
         self._query_cache: dict[str, tuple[float, object]] = {}  # key -> (expires_at, result)
         self._cache_hits: int = 0
         self._cache_misses: int = 0
         self._cache_lock = threading.Lock()
+        Database._instances.add(self)
 
     def _create_adapter(self) -> DatabaseAdapter:
         """Select adapter based on URL scheme."""
@@ -326,11 +344,37 @@ class Database:
         with self._cache_lock:
             self._query_cache.clear()
 
+    def cache_new_request(self):
+        """Clear the request-scoped query cache at the start of an HTTP request.
+
+        No-op in persistent mode (TINA4_DB_CACHE=true) so cross-request entries
+        survive up to their TTL. Cumulative hit/miss counters are preserved.
+        """
+        if self._cache_request_scoped and not self._cache_persistent:
+            with self._cache_lock:
+                self._query_cache.clear()
+
+    @classmethod
+    def reset_request_caches(cls):
+        """Clear the request-scoped query cache on every live Database instance.
+
+        The request dispatcher calls this at the start of each HTTP request so
+        request-scoped caching never serves rows across requests (zero
+        cross-request staleness). Persistent-mode connections are left alone.
+        """
+        for inst in list(cls._instances):
+            try:
+                inst.cache_new_request()
+            except Exception:
+                pass
+
     def cache_stats(self) -> dict:
         """Return query cache statistics."""
         with self._cache_lock:
             return {
                 "enabled": self._cache_enabled,
+                "mode": ("persistent" if self._cache_persistent
+                         else "request" if self._cache_request_scoped else "off"),
                 "hits": self._cache_hits,
                 "misses": self._cache_misses,
                 "size": len(self._query_cache),

{tina4_python-3.13.21 → tina4_python-3.13.23}/tina4_python/session/__init__.py

@@ -163,7 +163,7 @@ class Session:
 
     def __init__(self, handler: SessionHandler = None, ttl: int = None):
         self._handler = handler or self._resolve_handler()
-        self._ttl = ttl or int(os.environ.get("TINA4_SESSION_TTL", "1800"))  # 30 min
+        self._ttl = ttl or int(os.environ.get("TINA4_SESSION_TTL", "3600"))  # 60 min
         self._session_id: str | None = None
         self._data: dict = {}
         self._dirty: bool = False