PyPI - tina4-python - Versions diffs - 3.11.32__tar.gz → 3.11.35__tar.gz - Mend

tina4-python 3.11.32tar.gz → 3.11.35tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (153) hide show

{tina4_python-3.11.32 → tina4_python-3.11.35}/.gitignore RENAMED Viewed

@@ -74,7 +74,3 @@ example/store/__pycache__/
 example/store/src/**/__pycache__/
 .claude/settings.local.json
 .claude/worktrees/
-/nonexistent_path/
-/data/store.db
-/example/store/
-/example/uv.lock

{tina4_python-3.11.32 → tina4_python-3.11.35}/PKG-INFO RENAMED Viewed

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.11.32
-Summary: Tina4 for Python — 54 built-in features, zero dependencies
+Version: 3.11.35
+Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT
 Requires-Python: >=3.12

{tina4_python-3.11.32 → tina4_python-3.11.35}/pyproject.toml RENAMED Viewed

@@ -1,7 +1,7 @@
 [project]
 name = "tina4-python"
-dynamic = ["version"]
-description = "Tina4 for Python — 54 built-in features, zero dependencies"
+version = "3.11.35"
+description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}
 ]
@@ -55,9 +55,6 @@ dev = [
 requires = ["hatchling"]
 build-backend = "hatchling.build"
-[tool.hatch.version]
-path = "tina4_python/__init__.py"
 [tool.hatch.build]
 include = ["tina4_python/**/*"]

{tina4_python-3.11.32 → tina4_python-3.11.35}/tina4_python/__init__.py RENAMED Viewed

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

{tina4_python-3.11.32 → tina4_python-3.11.35}/tina4_python/core/server.py RENAMED Viewed

@@ -837,10 +837,7 @@ async def _handle_dev_admin(request: Request, response: Response) -> Response:
     """Serve the /__dev dashboard and API routes."""
     from tina4_python.dev_admin import get_api_handlers
     if request.path in ("/__dev/", "/__dev", "/__dev/v2", "/__dev/v2/"):
-        # Unified SPA dev admin. The bundle derives its WS URL from
-        # `location.host` directly, so no environment shim is needed —
-        # the framework serves /__dev_reload on its own port and the
-        # SPA reaches it as `ws://<page-host>/__dev_reload`.
+        # Unified SPA dev admin
         response.html("""<!DOCTYPE html>
 <html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1.0"><title>Tina4 Dev Admin</title></head>
 <body><div id="app" data-framework="python" data-color="#3b82f6"></div>
@@ -850,19 +847,8 @@ async def _handle_dev_admin(request: Request, response: Response) -> Response:
         handler_info = handlers.get(request.path)
         if handler_info and request.method == handler_info[0]:
             try:
-                def _resp(data, code=200, content_type=None):
-                    # content_type overrides the auto-detected MIME —
-                    # lets handlers stream binary with an explicit
-                    # Content-Type (e.g. /__dev/api/file/raw).
-                    if content_type is not None:
-                        response.status(code)
-                        response.content_type = content_type
-                        response.content = data if isinstance(data, (bytes, bytearray)) else str(data).encode("utf-8")
-                    elif isinstance(data, (bytes, bytearray)):
-                        response.status(code)
-                        response.content_type = "application/octet-stream"
-                        response.content = data
-                    elif isinstance(data, str):
+                def _resp(data, code=200):
+                    if isinstance(data, str):
                         response.status(code).html(data)
                     else:
                         response.status(code).json(data)
@@ -1196,14 +1182,8 @@ async def handle(request: Request) -> Response:
     from tina4_python.dotenv import is_truthy
     _is_dev = is_truthy(os.environ.get("TINA4_DEBUG", ""))
-    # Dev admin — also catches /ai/api/chat (SPA's ollama proxy) and the
-    # bare /ai /vision /embed /image /rag service-health probes that
-    # drive the "SERVICES ●●●●●" dots in the dev-admin UI.
-    _dev_extra_paths = {"/ai/api/chat", "/ai", "/vision", "/embed", "/image", "/rag"}
-    if _is_dev and (
-        request.path.startswith("/__dev")
-        or request.path in _dev_extra_paths
-    ):
+    # Dev admin
+    if _is_dev and request.path.startswith("/__dev"):
         return await _handle_dev_admin(request, response)
     # Swagger
@@ -1635,38 +1615,6 @@ def run(host: str | None = None, port: int | None = None, no_browser: bool = Fal
     log_level = os.environ.get("TINA4_LOG_LEVEL", "error" if not is_production else "error")
     Log.configure(level=log_level, production=is_production)
-    # Install a top-level exception hook so uncaught exceptions bubbling
-    # out of anything (a route handler, a background task, the event
-    # loop itself on startup) land in logs/error.log. Without this,
-    # an uncaught exception surfaces only via Python's default stderr
-    # writer and never touches Log — the same gap PHP had before its
-    # set_exception_handler fix. Chains to the previous hook so any
-    # debugger / IDE hook already in place still fires.
-    import sys as _sys
-    import traceback as _traceback
-    _prior_excepthook = _sys.excepthook
-    def _tina4_excepthook(exc_type, exc_value, exc_tb):
-        # KeyboardInterrupt is a user-initiated Ctrl+C, not an error —
-        # defer to the prior hook (which prints a clean traceback).
-        if issubclass(exc_type, KeyboardInterrupt):
-            _prior_excepthook(exc_type, exc_value, exc_tb)
-            return
-        try:
-            trace_text = "".join(_traceback.format_exception(exc_type, exc_value, exc_tb))
-            Log.error(
-                f"Uncaught {exc_type.__name__}: {exc_value}",
-                trace=trace_text,
-            )
-        except Exception:
-            # If logging itself fails (disk full, permissions, logger
-            # not initialised yet), fall through to the prior hook so
-            # the user still sees something in stderr.
-            pass
-        _prior_excepthook(exc_type, exc_value, exc_tb)
-    _sys.excepthook = _tina4_excepthook
     # Ensure folders
     _ensure_folders()

{tina4_python-3.11.32 → tina4_python-3.11.35}/tina4_python/database/connection.py RENAMED Viewed

@@ -166,11 +166,6 @@ class Database:
             self._adapter: DatabaseAdapter = self._create_adapter()
             self._adapter.connect(self._connection_path(), username=self.username, password=self.password, **kwargs)
-        # Per-thread transaction adapter pin. While set, every operation
-        # on this thread routes to the same adapter — so the round-robin
-        # 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
         from tina4_python.dotenv import is_truthy
         self._cache_enabled: bool = is_truthy(os.environ.get("TINA4_DB_CACHE", "false"))
@@ -313,25 +308,7 @@ class Database:
     # ── Pool-aware adapter access ─────────────────────────────
     def _get_adapter(self) -> DatabaseAdapter:
-        """Get an adapter for the next operation.
-        With pooling enabled, ordinary calls round-robin through the pool.
-        Inside a transaction, however, all calls must land on the SAME
-        adapter — otherwise start_transaction(), execute() and commit()
-        each rotate to a different connection and the transaction is
-        meaningless (executes autocommit on whatever adapter they hit;
-        the final commit lands on yet another adapter that has nothing
-        to commit; rollback() is silently no-op'd).
-        We pin the adapter to the calling thread for the duration of the
-        transaction. start_transaction() sets the pin, commit()/rollback()
-        clear it. While pinned, _get_adapter() returns that same adapter
-        for every call so the whole transaction is atomic on one
-        connection.
-        """
-        pinned = getattr(self._tx_local, "adapter", None)
-        if pinned is not None:
-            return pinned
+        """Get an adapter — from pool (round-robin) or single connection."""
         if self._pool is not None:
             return self._pool.checkout()
         return self._adapter
@@ -445,24 +422,16 @@ class Database:
         return adapter.delete(table, filter_sql, params)
     def start_transaction(self):
-        """Begin a transaction. Pins the adapter to this thread for the
-        whole transaction so executes and the final commit/rollback all
-        run on the same connection."""
         adapter = self._get_adapter()
-        self._tx_local.adapter = adapter
         adapter.start_transaction()
     def commit(self):
-        """Commit the current transaction and release the adapter pin."""
         adapter = self._get_adapter()
         adapter.commit()
-        self._tx_local.adapter = None
     def rollback(self):
-        """Roll back the current transaction and release the adapter pin."""
         adapter = self._get_adapter()
         adapter.rollback()
-        self._tx_local.adapter = None
     def table_exists(self, name: str) -> bool:
         adapter = self._get_adapter()

{tina4_python-3.11.32 → tina4_python-3.11.35}/tina4_python/database/firebird.py RENAMED Viewed

@@ -28,10 +28,27 @@ except ImportError:
 class FirebirdAdapter(DatabaseAdapter):
     """Firebird database driver using firebird-driver or fdb."""
+    # Substring markers (lowercased) that identify a dead-socket Firebird
+    # error worth reconnecting for. Idle Firebird connections die silently
+    # behind NAT timeouts, server-side ConnectionIdleTimeout, or Docker
+    # network rotation; without this the next prepare() crashes the request.
+    _DEAD_CONN_MARKERS = (
+        "error writing data to the connection",
+        "error reading data from the connection",
+        "connection shutdown",
+        "connection lost",
+        "network error",
+        "connection is not active",
+        "broken pipe",
+    )
     def __init__(self):
         super().__init__()
         self._conn = None
         self._in_transaction: bool = False
+        # Remembered connection params — populated by connect(), used by
+        # _reconnect() when a dead socket is detected mid-request.
+        self._connect_params: dict | None = None
     def connect(self, connection_string: str, username: str = "", password: str = "", **kwargs):
         """Connect to Firebird.
@@ -54,28 +71,82 @@ class FirebirdAdapter(DatabaseAdapter):
         password = parsed.password or password or "masterkey"
         charset = kwargs.pop("charset", "UTF8")
+        # Cache for transparent reconnect — never logged, lives only in
+        # adapter memory alongside the connection it owns.
+        self._connect_params = {
+            "host": host, "port": port, "db_path": db_path,
+            "user": user, "password": password, "charset": charset,
+            "extra": dict(kwargs),
+        }
+        self._open()
+    def _open(self) -> None:
+        """Open the underlying Firebird connection from cached params."""
+        p = self._connect_params
+        if p is None:
+            raise RuntimeError("FirebirdAdapter._open called before connect()")
         if _driver_name == "firebird-driver":
             # Modern firebird-driver uses dsn format: host/port:path
-            dsn = f"{host}/{port}:{db_path}" if port != 3050 else f"{host}:{db_path}"
+            dsn = f"{p['host']}/{p['port']}:{p['db_path']}" if p['port'] != 3050 else f"{p['host']}:{p['db_path']}"
             self._conn = _driver.connect(
                 dsn,
-                user=user,
-                password=password,
-                charset=charset,
-                **kwargs,
+                user=p["user"],
+                password=p["password"],
+                charset=p["charset"],
+                **p["extra"],
             )
         else:
             # Legacy fdb
             self._conn = _driver.connect(
-                host=host,
-                port=port,
-                database=db_path,
-                user=user,
-                password=password,
-                charset=charset,
-                **kwargs,
+                host=p["host"],
+                port=p["port"],
+                database=p["db_path"],
+                user=p["user"],
+                password=p["password"],
+                charset=p["charset"],
+                **p["extra"],
             )
+    @classmethod
+    def _is_dead_connection(cls, exc: BaseException) -> bool:
+        """Match dead-socket error messages from firebird-driver / fdb.
+        Substring + case-insensitive so we catch both driver wording variants.
+        """
+        msg = str(exc).lower()
+        return any(m in msg for m in cls._DEAD_CONN_MARKERS)
+    def _reconnect(self) -> None:
+        """Force-close any stale handle and reopen. Safe to call repeatedly;
+        idempotent on a dead connection."""
+        try:
+            if self._conn is not None:
+                self._conn.close()
+        except Exception:
+            pass  # connection already gone — nothing to clean up
+        self._conn = None
+        self._in_transaction = False
+        self._open()
+    def _safe_cursor_execute(self, cursor, sql: str, params: list | None):
+        """Execute on a cursor with one transparent reconnect+retry on
+        dead-connection errors. Skipped inside an explicit transaction —
+        atomicity beats resilience there; the caller handles rollback.
+        Returns the cursor (possibly a fresh one after reconnect) so the
+        caller can fetch results from it.
+        """
+        try:
+            cursor.execute(sql, params or [])
+            return cursor
+        except Exception as e:
+            if not self._is_dead_connection(e) or self._in_transaction:
+                raise
+            self._reconnect()
+            cursor = self._conn.cursor()
+            cursor.execute(sql, params or [])
+            return cursor
     def close(self):
         if self._conn:
             self._conn.close()
@@ -92,7 +163,7 @@ class FirebirdAdapter(DatabaseAdapter):
             sql = sql[:returning_match.start()]
         cursor = self._conn.cursor()
-        cursor.execute(sql, params or [])
+        cursor = self._safe_cursor_execute(cursor, sql, params)
         records = []
         last_id = None
@@ -145,16 +216,19 @@ class FirebirdAdapter(DatabaseAdapter):
         # Count total rows
         count_sql = f"SELECT COUNT(*) FROM ({sql})"
         try:
-            cursor.execute(count_sql, params or [])
+            cursor = self._safe_cursor_execute(cursor, count_sql, params)
             total = cursor.fetchone()[0]
         except Exception:
             total = 0
+            # Reconnect may have just happened — get a fresh cursor for the
+            # paginated query below regardless of whether count succeeded.
+            cursor = self._conn.cursor()
         # Apply Firebird pagination — ROWS start TO end
         start = offset + 1
         end = offset + limit
         paginated_sql = f"{sql} ROWS {start} TO {end}"
-        cursor.execute(paginated_sql, params or [])
+        cursor = self._safe_cursor_execute(cursor, paginated_sql, params)
         desc = cursor.description
         col_names = [d[0].strip().lower() for d in desc] if desc else []
@@ -165,7 +239,7 @@ class FirebirdAdapter(DatabaseAdapter):
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor()
-        cursor.execute(sql, params or [])
+        cursor = self._safe_cursor_execute(cursor, sql, params)
         desc = cursor.description
         row = cursor.fetchone()
         if row is None:

{tina4_python-3.11.32 → tina4_python-3.11.35}/tina4_python/debug/__init__.py RENAMED Viewed

@@ -200,15 +200,12 @@ class Log:
             color = cls.COLORS.get(level, "")
             print(f"{color}{line}{cls.RESET}")
-        # Always write ALL levels to the main file (raw log, no filtering)
+        # Always write ALL levels to file (raw log, no filtering)
         if cls._writer:
             cls._writer.write(line)
-        # Mirror WARNING and ERROR into the dedicated error log so
-        # `tail -f logs/error.log` gives just the stuff worth looking
-        # at, without wading through DEBUG / INFO noise. Parity with
-        # tina4-php's Log class.
-        if cls._error_writer and cls.LEVELS.get(level, 0) >= cls.LEVELS["warning"]:
+        # Write errors to separate file
+        if level == "error" and cls._error_writer:
             cls._error_writer.write(line)
     @classmethod

tina4-python 3.11.32__tar.gz → 3.11.35__tar.gz

tina4-python 3.11.32tar.gz → 3.11.35tar.gz