tina4-python 3.13.12__tar.gz → 3.13.15__tar.gz

{tina4_python-3.13.12 → tina4_python-3.13.15}/PKG-INFO

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

{tina4_python-3.13.12 → tina4_python-3.13.15}/pyproject.toml

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

{tina4_python-3.13.12 → tina4_python-3.13.15}/tina4_python/__init__.py

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

{tina4_python-3.13.12 → tina4_python-3.13.15}/tina4_python/core/middleware.py

@@ -361,9 +361,15 @@ class RequestLoggerMiddleware:
     """Request logger — stamps start time before the handler and logs elapsed time after.
 
     Mirrors the PHP, Ruby and Node.js RequestLogger classes.
+
+    v3.13.14: routes through the Tina4 ``Log`` class (was stdlib
+    ``logging.getLogger``, whose ``info()`` is silently dropped by an
+    unconfigured root logger — so these lines never reached stdout).
+    The dev server also logs every request globally (see
+    ``server._finalize_response``); this middleware remains for callers
+    that want per-route request logging.
     """
 
-    _logger = logging.getLogger("tina4.request")
     _start_times: dict = {}
     _lock = threading.Lock()
 
@@ -385,7 +391,6 @@ class RequestLoggerMiddleware:
         method = getattr(request, "method", "?")
         path = getattr(request, "url", None) or getattr(request, "path", "/")
         status = getattr(response, "status_code", None) or getattr(response, "status", 0)
-        RequestLoggerMiddleware._logger.info(
-            "[RequestLogger] %s %s -> %s (%sms)", method, path, status, elapsed_ms
-        )
+        from tina4_python.debug import Log
+        Log.info(f"{method} {path} -> {status} ({elapsed_ms}ms)")
         return request, response

{tina4_python-3.13.12 → tina4_python-3.13.15}/tina4_python/core/server.py

@@ -1404,6 +1404,21 @@ def _handle_no_route(request: Request, response: Response, request_id: str) -> R
     return response
 
 
+def _request_logging_enabled(is_dev: bool) -> bool:
+    """Whether to emit a per-request log line (v3.13.14).
+
+    ``TINA4_LOG_REQUESTS`` is the explicit control (true/false). When unset,
+    request logging follows dev mode: on under ``TINA4_DEBUG``, off in
+    production (so prod doesn't pay the per-request logging cost unless the
+    operator opts in). Same contract across all four frameworks.
+    """
+    from tina4_python.dotenv import is_truthy
+    val = os.environ.get("TINA4_LOG_REQUESTS")
+    if val is not None and val != "":
+        return is_truthy(val)
+    return is_dev
+
+
 def _finalize_response(
     request: Request, response: Response, route: dict | None,
     request_id: str, is_dev: bool, req_start: float,
@@ -1444,6 +1459,22 @@ def _finalize_response(
         except Exception:
             pass
 
+    # Request log line (v3.13.14). The dev dashboard's RequestInspector above
+    # only feeds the /__dev UI — it never reached stdout, so `tina4 serve`
+    # printed the startup banner then went silent even as requests flowed.
+    # Emit a per-request line through the Tina4 Log so it lands on stdout
+    # (docker logs / k8s) like every other log. On by default in dev; opt-in
+    # in production via TINA4_LOG_REQUESTS to avoid per-request overhead.
+    if _request_logging_enabled(is_dev):
+        try:
+            import time as _time
+            elapsed_ms = round((_time.perf_counter() - req_start) * 1000, 3)
+            Log.info(
+                f"{request.method} {request.path} -> {response.status_code} ({elapsed_ms}ms)"
+            )
+        except Exception:
+            pass
+
     # Session save + cookie.
     # Skip saving if this was a brand-new session that the route never wrote to —
     # that prevents empty orphaned session files accumulating on disk.
@@ -2081,7 +2112,12 @@ def run(host: str | None = None, port: int | None = None, no_browser: bool = Fal
 
     # Init logger
     is_production = os.environ.get("TINA4_ENV", "development") == "production"
-    log_level = os.environ.get("TINA4_LOG_LEVEL", "error" if not is_production else "error")
+    # v3.13.14: default level is INFO (was ERROR). ERROR-by-default meant a
+    # deployed app that logged at info/debug appeared silent — operators
+    # "weren't getting logs". INFO shows request/startup/warn/error without
+    # debug noise, and matches PHP/Ruby/Node defaults. Override per-deploy
+    # with TINA4_LOG_LEVEL.
+    log_level = os.environ.get("TINA4_LOG_LEVEL", "info")
     Log.configure(level=log_level, production=is_production)
 
     # Install a top-level exception hook so uncaught exceptions bubbling

{tina4_python-3.13.12 → tina4_python-3.13.15}/tina4_python/database/adapter.py

@@ -375,6 +375,27 @@ class DatabaseAdapter:
             stripped = stripped[:-1].rstrip()
         return stripped
 
+    @staticmethod
+    def _split_schema(name: str) -> tuple[str | None, str]:
+        """Split a possibly-qualified table name into (schema, table).
+
+        v3.13.14 (#48): a model whose ``table_name`` is qualified —
+        PostgreSQL ``gift_cards.gift_card``, MSSQL ``dbo.widget``,
+        MySQL ``otherdb.table``, SQLite ``attached.table`` — lives in
+        that schema/catalog, not the default. Each adapter's
+        ``table_exists`` / ``get_columns`` use this to query the right
+        namespace instead of matching the whole dotted string as one
+        flat table name. Returns ``(None, name)`` for a bare name so
+        callers default to the engine's current namespace. Splits on the
+        first dot; quoted identifiers with embedded dots aren't supported
+        (they weren't before either). Firebird has no schemas, so its
+        adapter ignores this.
+        """
+        if "." in name:
+            schema, _, table = name.partition(".")
+            return schema, table
+        return None, name
+
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
         """Execute a read query and return multiple rows."""

{tina4_python-3.13.12 → tina4_python-3.13.15}/tina4_python/database/mssql.py

@@ -190,10 +190,17 @@ class MSSQLAdapter(DatabaseAdapter):
         self._in_transaction = False
 
     def table_exists(self, name: str) -> bool:
+        # v3.13.14 (#48): honour a schema-qualified name ("dbo.widget",
+        # "sales.orders"). Schemas are everyday in SQL Server; pre-fix this
+        # had no schema filter and matched the whole dotted string as a flat
+        # TABLE_NAME, so any qualified table_name was invisible. A bare name
+        # still matches in any schema (unchanged behaviour).
+        schema, tbl = self._split_schema(name)
         row = self.fetch_one(
             "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES "
-            "WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME = %s",
-            [name],
+            "WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME = %s "
+            "AND (%s IS NULL OR TABLE_SCHEMA = %s)",
+            [tbl, schema, schema],
         )
         return row is not None
 
@@ -206,6 +213,9 @@ class MSSQLAdapter(DatabaseAdapter):
         return [r["TABLE_NAME"] for r in result.records]
 
     def get_columns(self, table: str) -> list[dict]:
+        # v3.13.14 (#48): honour a schema-qualified name; a bare name matches
+        # in any schema (unchanged).
+        schema, tbl = self._split_schema(table)
         sql = """
             SELECT c.COLUMN_NAME, c.DATA_TYPE, c.IS_NULLABLE, c.COLUMN_DEFAULT,
                    CASE WHEN pk.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END AS is_primary
@@ -215,12 +225,13 @@ class MSSQLAdapter(DatabaseAdapter):
                 FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
                 JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE ku
                   ON tc.CONSTRAINT_NAME = ku.CONSTRAINT_NAME
-                WHERE tc.TABLE_NAME = %s AND tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+                WHERE tc.TABLE_NAME = %s AND (%s IS NULL OR tc.TABLE_SCHEMA = %s)
+                  AND tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
             ) pk ON c.COLUMN_NAME = pk.COLUMN_NAME
-            WHERE c.TABLE_NAME = %s
+            WHERE c.TABLE_NAME = %s AND (%s IS NULL OR c.TABLE_SCHEMA = %s)
             ORDER BY c.ORDINAL_POSITION
         """
-        result = self.fetch(sql, [table, table], limit=10000)
+        result = self.fetch(sql, [tbl, schema, schema, tbl, schema, schema], limit=10000)
         return [
             {
                 "name": r["COLUMN_NAME"],

{tina4_python-3.13.12 → tina4_python-3.13.15}/tina4_python/database/mysql.py

@@ -174,10 +174,16 @@ class MySQLAdapter(DatabaseAdapter):
         self._in_transaction = False
 
     def table_exists(self, name: str) -> bool:
+        # v3.13.14 (#48): honour a database-qualified name ("otherdb.table").
+        # In MySQL "schema" == database; default to the connected database.
+        # Pre-fix this matched the whole dotted string as a flat TABLE_NAME
+        # under DATABASE() only, so a cross-database qualified name was never
+        # found and create_table()/migrations misfired.
+        schema, tbl = self._split_schema(name)
         row = self.fetch_one(
             "SELECT TABLE_NAME FROM information_schema.TABLES "
-            "WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = %s",
-            [name],
+            "WHERE TABLE_SCHEMA = COALESCE(%s, DATABASE()) AND TABLE_NAME = %s",
+            [schema, tbl],
         )
         return row is not None
 

{tina4_python-3.13.12 → tina4_python-3.13.15}/tina4_python/database/postgres.py

@@ -207,6 +207,35 @@ class PostgreSQLAdapter(DatabaseAdapter):
         except Exception:
             pass
 
+    def _end_read_txn(self):
+        """v3.13.15 (issue #51): close the implicit transaction a read
+        opens, so the connection doesn't leak as ``idle in transaction``.
+
+        psycopg2 runs with ``autocommit = False`` (the framework's safe
+        default — writes must be committed explicitly). A bare ``SELECT``
+        therefore opens a transaction too, and with nothing to commit it
+        sits ``idle in transaction`` for the life of the connection,
+        holding a pool slot and any locks it touched. Short-lived boot
+        connections (the migration runner's ``MAX(batch)`` lookup) leak
+        one each, eventually exhausting ``max_connections`` — at which
+        point module autodiscovery fails mid-boot and every route 404s
+        while ``/health-check`` still passes ("ready but broken").
+
+        A read has nothing to persist, so a ROLLBACK is the safe close.
+        Inside an explicit ``start_transaction()`` the caller owns the
+        transaction, so we defer (mirrors the heal / error-path guards).
+        Writes go through :meth:`execute`, which is deliberately left
+        untouched — with autocommit off they must be committed explicitly,
+        so auto-closing them here would silently drop data.
+        """
+        if self._in_transaction or self._conn is None:
+            return
+        try:
+            self._conn.rollback()
+        except Exception:
+            # Never let bookkeeping mask the rows we already fetched.
+            pass
+
     def connect(self, connection_string: str, username: str = "", password: str = "", **kwargs):
         """Connect to PostgreSQL.
 
@@ -357,6 +386,10 @@ class PostgreSQLAdapter(DatabaseAdapter):
         self._exec_with_handling(cursor, paginated_sql, paginated_params)
         rows = [self._decode_blobs(dict(row)) for row in cursor.fetchall()]
 
+        # v3.13.15 (#51): rows are materialised above — close the implicit
+        # read transaction so the connection doesn't sit idle-in-transaction.
+        self._end_read_txn()
+
         return DatabaseResult(records=rows, count=total, limit=limit, offset=offset, sql=sql, adapter=self)
 
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
@@ -368,7 +401,13 @@ class PostgreSQLAdapter(DatabaseAdapter):
         cursor = self._conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
         self._exec_with_handling(cursor, sql, params)
         row = cursor.fetchone()
-        return self._decode_blobs(dict(row)) if row else None
+        result = self._decode_blobs(dict(row)) if row else None
+        # v3.13.15 (#51): close the implicit read transaction so the
+        # connection doesn't sit 'idle in transaction' (psycopg2 autocommit
+        # is off). This is the path the migration runner's MAX(batch)
+        # lookup leaked through.
+        self._end_read_txn()
+        return result
 
     @staticmethod
     def _decode_blobs(row: dict) -> dict:
@@ -423,20 +462,40 @@ class PostgreSQLAdapter(DatabaseAdapter):
         self._in_transaction = False
 
     def table_exists(self, name: str) -> bool:
-        row = self.fetch_one(
-            "SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename = %s",
-            [name],
-        )
-        return row is not None
+        # v3.13.x (#48): support schema-qualified names ("schema.table") and the
+        # connection search_path. to_regclass() resolves a (possibly qualified)
+        # relation name to its OID using the SAME rules Postgres applies to a
+        # FROM clause, returning NULL when absent. Pre-fix this hardcoded
+        # schemaname='public' AND matched the whole dotted string as a flat
+        # tablename, so a table in a non-public schema was invisible —
+        # table_exists() always returned False, so create_table()/migrations
+        # misfired and ORM introspection saw nothing.
+        row = self.fetch_one("SELECT to_regclass(%s) AS oid", [name])
+        return bool(row and row.get("oid") is not None)
 
     def get_tables(self) -> list[str]:
+        # v3.13.x (#48): list tables from every user schema, not just public.
+        # public tables stay bare ("users"); tables in other schemas are
+        # returned schema-qualified ("gift_cards.gift_card") so the names round
+        # -trip back through table_exists()/get_columns().
         result = self.fetch(
-            "SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename",
+            """
+            SELECT schemaname, tablename FROM pg_tables
+            WHERE schemaname NOT IN ('pg_catalog', 'information_schema')
+            ORDER BY schemaname, tablename
+            """,
             limit=10000,
         )
-        return [r["tablename"] for r in result.records]
+        return [
+            r["tablename"] if r["schemaname"] == "public"
+            else f"{r['schemaname']}.{r['tablename']}"
+            for r in result.records
+        ]
 
     def get_columns(self, table: str) -> list[dict]:
+        # v3.13.x (#48): honour a schema-qualified name; default to public.
+        schema, tbl = self._split_schema(table)
+        schema = schema or "public"
         sql = """
             SELECT c.column_name, c.data_type, c.is_nullable, c.column_default,
                    CASE WHEN pk.column_name IS NOT NULL THEN true ELSE false END AS is_primary
@@ -446,12 +505,12 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 FROM information_schema.table_constraints tc
                 JOIN information_schema.key_column_usage ku
                   ON tc.constraint_name = ku.constraint_name
-                WHERE tc.table_name = %s AND tc.constraint_type = 'PRIMARY KEY'
+                WHERE tc.table_name = %s AND tc.table_schema = %s AND tc.constraint_type = 'PRIMARY KEY'
             ) pk ON c.column_name = pk.column_name
-            WHERE c.table_name = %s AND c.table_schema = 'public'
+            WHERE c.table_name = %s AND c.table_schema = %s
             ORDER BY c.ordinal_position
         """
-        result = self.fetch(sql, [table, table], limit=10000)
+        result = self.fetch(sql, [tbl, schema, tbl, schema], limit=10000)
         return [
             {
                 "name": r["column_name"],

{tina4_python-3.13.12 → tina4_python-3.13.15}/tina4_python/database/sqlite.py

@@ -179,9 +179,16 @@ class SQLiteAdapter(DatabaseAdapter):
         self._in_transaction = False
 
     def table_exists(self, name: str) -> bool:
+        # v3.13.14 (#48): honour an attached-database prefix ("attached.table").
+        # SQLite's "schema" is an ATTACH alias; each has its own sqlite_master.
+        # Bare names use the main database (unchanged). The alias must be a
+        # plain identifier (it's developer-supplied, but guard against the dot
+        # being part of an odd name).
+        schema, tbl = self._split_schema(name)
+        master = f"{schema}.sqlite_master" if schema and schema.isidentifier() else "sqlite_master"
         row = self.fetch_one(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
-            [name]
+            f"SELECT name FROM {master} WHERE type='table' AND name=?",
+            [tbl if (schema and schema.isidentifier()) else name]
         )
         return row is not None
 
@@ -193,7 +200,13 @@ class SQLiteAdapter(DatabaseAdapter):
         return [r["name"] for r in result.records]
 
     def get_columns(self, table: str) -> list[dict]:
-        cursor = self._conn.execute(f"PRAGMA table_info({table})")
+        # v3.13.14 (#48): honour an attached-database prefix via
+        # `PRAGMA <schema>.table_info(<table>)`.
+        schema, tbl = self._split_schema(table)
+        if schema and schema.isidentifier() and tbl.isidentifier():
+            cursor = self._conn.execute(f"PRAGMA {schema}.table_info({tbl})")
+        else:
+            cursor = self._conn.execute(f"PRAGMA table_info({table})")
         return [
             {
                 "name": row["name"],

{tina4_python-3.13.12 → tina4_python-3.13.15}/tina4_python/debug/__init__.py

@@ -412,10 +412,18 @@ class Log:
         # File always gets ALL levels (no filtering for file output)
         line = cls._format_line(level, message, **kwargs)
 
-        # Console output respects TINA4_LOG_LEVEL and the stdout toggle
-        if cls._stdout_enabled and not cls._is_production and cls._should_log(level):
-            color = cls.COLORS.get(level, "")
-            print(f"{color}{line}{cls.RESET}")
+        # Console output respects TINA4_LOG_LEVEL and the stdout toggle.
+        # v3.13.14: stdout is NOT suppressed in production — containers
+        # treat stdout as the canonical log sink (docker logs / k8s read
+        # PID 1 stdout), and the pre-v3.13.14 `not _is_production` gate
+        # meant deployed containers got nothing. Production still emits
+        # JSON (see _format_line / _is_production), just on stdout now.
+        # flush=True so logs appear immediately on a non-TTY pipe rather
+        # than sitting in Python's block buffer until the process exits.
+        if cls._stdout_enabled and cls._should_log(level):
+            color = "" if cls._is_production else cls.COLORS.get(level, "")
+            reset = "" if cls._is_production else cls.RESET
+            print(f"{color}{line}{reset}", flush=True)
 
         # Always write ALL levels to the main file (raw log, no filtering)
         if cls._writer: