tina4-python 3.12.0__tar.gz → 3.12.2__tar.gz

{tina4_python-3.12.0 → tina4_python-3.12.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.12.0
-Summary: Tina4 for Python — 54 built-in features, zero dependencies
+Version: 3.12.2
+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.12.0 → tina4_python-3.12.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "tina4-python"
-dynamic = ["version"]
-description = "Tina4 for Python — 54 built-in features, zero dependencies"
+version = "3.12.2"
+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.12.0 → tina4_python-3.12.2}/tina4_python/__init__.py

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

{tina4_python-3.12.0 → tina4_python-3.12.2}/tina4_python/database/firebird.py

@@ -6,10 +6,68 @@ Firebird adapter using firebird-driver (preferred) or fdb (fallback).
 
 Requires: pip install firebird-driver  (or pip install fdb for legacy)
 """
+import os
 import re
 from urllib.parse import urlparse, unquote
 from tina4_python.database.adapter import DatabaseAdapter, DatabaseResult, SQLTranslator
 
+
+# Detects a Windows drive-letter prefix like "C:/" or "C:\". The leading-slash
+# variant ("/C:/...") shows up after a URL parse strips one slash off
+# "firebird://host:port/C:/...".
+_WIN_DRIVE_RE = re.compile(r"^/?[A-Za-z]:[/\\]")
+
+
+def _normalize_firebird_db_identifier(raw_path: str) -> str:
+    """Turn the URL path component into a Firebird database identifier.
+
+    Firebird is the awkward one — it needs either an absolute file path
+    on the server, a Windows drive-letter path, or an alias name. The
+    classic URI form uses a double-slash to keep the leading "/" of an
+    absolute path through ``urlparse``::
+
+        firebird://host:port//firebird/data/app.fdb   →  /firebird/data/app.fdb
+
+    But that double slash is unintuitive to anyone used to the way
+    postgres / mysql / mssql encode the database name. We accept five
+    equivalent forms and normalise all of them:
+
+    * ``//abs/path/db.fdb``    → ``/abs/path/db.fdb``    (classic double-slash)
+    * ``/abs/path/db.fdb``     → ``/abs/path/db.fdb``    (single-slash, what most people type)
+    * ``/C:/Data/db.fdb``      → ``C:/Data/db.fdb``      (Windows, leading URL slash dropped)
+    * ``/C%3A/Data/db.fdb``    → ``C:/Data/db.fdb``      (Windows with URL-encoded colon)
+    * ``/employee``            → ``employee``            (alias — single token)
+
+    Aliases are detected as the leftover case: a single token with no
+    slashes. Anything path-like is kept as a path.
+    """
+    decoded = unquote(raw_path)
+
+    # Classic double-slash form: //abs/path → /abs/path
+    if decoded.startswith("//"):
+        decoded = decoded[1:]
+
+    # Windows drive-letter — drop the URL-introduced leading slash.
+    # /C:/Data/db.fdb → C:/Data/db.fdb
+    if _WIN_DRIVE_RE.match(decoded):
+        if decoded.startswith("/"):
+            decoded = decoded[1:]
+        return decoded
+
+    # Look at the content after stripping the leading slash. If it's a
+    # single token with no separators, it's a Firebird alias — return
+    # WITHOUT the leading slash (the alias name itself is the identifier).
+    body = decoded[1:] if decoded.startswith("/") else decoded
+    if body and "/" not in body and "\\" not in body:
+        return body
+
+    # Otherwise it's a file path. If it already has a leading slash,
+    # keep it. If it's a relative-looking path (slash-separated but no
+    # leading "/") promote it to absolute — Firebird needs absolute paths
+    # and we don't know the server's CWD anyway.
+    return decoded if decoded.startswith("/") else "/" + decoded
+
+
 # Try modern firebird-driver first, fall back to legacy fdb
 _driver = None
 _driver_name = None
@@ -28,10 +86,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.
@@ -48,34 +123,101 @@ class FirebirdAdapter(DatabaseAdapter):
         parsed = urlparse(connection_string)
         host = parsed.hostname or "localhost"
         port = parsed.port or 3050
-        # Firebird database path — decode URL-encoded characters
-        db_path = unquote(parsed.path[1:]) if parsed.path.startswith("/") else unquote(parsed.path)
+
+        # Firebird database identifier resolution — two layers:
+        #
+        # 1. ``TINA4_DATABASE_FIREBIRD_PATH`` env override wins if set.
+        #    Useful for Windows users with raw backslash paths (no URL
+        #    encoding required) and for ops setups that keep server URL
+        #    and DB location in separate config layers.
+        # 2. Otherwise normalise the URL path component — accepts every
+        #    sensible variant (single/double slash, drive letter, alias).
+        env_override = os.environ.get("TINA4_DATABASE_FIREBIRD_PATH", "")
+        if env_override:
+            db_path = env_override
+        else:
+            db_path = _normalize_firebird_db_identifier(parsed.path)
+
         user = parsed.username or username or "SYSDBA"
         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 +234,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 +287,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 +310,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: