tina4-python 3.13.43__tar.gz → 3.13.45__tar.gz

{tina4_python-3.13.43 → tina4_python-3.13.45}/PKG-INFO

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

{tina4_python-3.13.43 → tina4_python-3.13.45}/pyproject.toml

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

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/__init__.py

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

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/core/middleware.py

@@ -284,10 +284,13 @@ class CsrfMiddleware:
     @staticmethod
     def before_csrf(request, response):
         """Validate CSRF token before the route handler runs."""
-        # Check if CSRF is enabled via env (middleware registration bypasses this)
-        csrf_env = os.environ.get("TINA4_CSRF", "true").lower() not in ("false", "0", "no")
-        # When registered via Router.use(), this method always runs.
-        # The env check is only for auto-activation scenarios.
+        # TINA4_CSRF=false (or 0/no) disables all CSRF checks, even when the
+        # middleware is attached explicitly — this is the documented kill
+        # switch ("TINA4_CSRF=false disables all checks"). When unset the
+        # default is enabled (true).
+        csrf_enabled = os.environ.get("TINA4_CSRF", "true").lower() not in ("false", "0", "no")
+        if not csrf_enabled:
+            return request, response
 
         # Skip safe HTTP methods
         method = getattr(request, "method", "GET").upper()

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/core/request.py

@@ -72,7 +72,7 @@ class Request:
     __slots__ = (
         "method", "path", "url", "query_string", "params", "query", "headers",
         "body", "raw_body", "cookies", "files", "ip", "remote_ip",
-        "content_type", "session", "_route_params",
+        "content_type", "session", "_route_params", "_handler",
     )
 
     def __init__(self):
@@ -92,6 +92,10 @@ class Request:
         self.content_type: str = ""
         self.session = None             # Set by session middleware
         self._route_params: dict = {}   # Dynamic route params ({id}, etc.)
+        self._handler = None            # Matched route handler — set by dispatch
+                                        # before middleware runs, so before_*
+                                        # middleware (e.g. CsrfMiddleware) can read
+                                        # handler metadata like _noauth.
 
     @classmethod
     def from_scope(cls, scope: dict, body: bytes = b"") -> "Request":

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/core/server.py

@@ -1753,6 +1753,9 @@ async def handle(request: Request) -> Response:
     if route:
         request._route_params = params
         request.merge_route_params()
+        # Expose the matched handler on the request so before_* middleware
+        # (e.g. CsrfMiddleware) can read handler metadata such as _noauth.
+        request._handler = route.get("handler")
         try:
             skip = _check_auth(request, response, route)
             if not skip:

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/database/adapter.py

@@ -351,13 +351,32 @@ class DatabaseAdapter:
                 ["Alice"], ["Bob"], ["Eve"]
             ])
         """
+        rows = params_list or []
+        if not rows:
+            return DatabaseResult(affected_rows=0)
+        # Run the whole batch in ONE transaction on ONE connection so it is
+        # atomic AND affected_rows/last_id are reliable. In autocommit mode each
+        # standalone execute() commits on its own (possibly different, pooled)
+        # connection, which scattered the per-row rowcount / last_insert_id and
+        # made the aggregate non-deterministic. When already inside an explicit
+        # transaction we just join it (never nest).
+        owns_txn = self._autocommit and not getattr(self, "_in_transaction", False)
+        if owns_txn:
+            self.start_transaction()
         total_affected = 0
         last_id = None
-        for params in (params_list or []):
-            result = self.execute(sql, params)
-            total_affected += result.affected_rows
-            if result.last_id is not None:
-                last_id = result.last_id
+        try:
+            for params in rows:
+                result = self.execute(sql, params)
+                total_affected += result.affected_rows
+                if result.last_id is not None:
+                    last_id = result.last_id
+            if owns_txn:
+                self.commit()
+        except Exception:
+            if owns_txn:
+                self.rollback()
+            raise
         return DatabaseResult(
             affected_rows=total_affected,
             last_id=last_id,
@@ -389,6 +408,47 @@ class DatabaseAdapter:
             stripped = stripped[:-1].rstrip()
         return stripped
 
+    @staticmethod
+    def _strip_trailing_order_by(sql: str) -> str:
+        """Strip a trailing top-level ``ORDER BY`` so the SQL can be safely
+        wrapped in ``SELECT COUNT(*) FROM (<sql>)`` for the row-count probe.
+
+        SQL Server rejects an ``ORDER BY`` inside a derived-table subquery
+        unless it carries ``TOP``/``OFFSET``/``FETCH`` (error 20018), which
+        silently zeroed the MSSQL count probe for any query ending in
+        ``ORDER BY`` (issue #262 -- the bug existed in this master adapter too,
+        not only the mirrors). ``ORDER BY`` does not affect ``COUNT(*)``, so
+        dropping it for the probe ONLY is safe; the paginated query keeps its
+        ``ORDER BY`` for ``OFFSET/FETCH``. An ``ORDER BY`` nested in a subquery,
+        or one already legalised by a following ``OFFSET``/``FETCH``/``FOR``, is
+        left intact. Parity with PHP ``SqlNormalizerTrait::stripTrailingOrderBy``.
+        """
+        if not sql or not re.search(r"\bORDER\s+BY\b", sql, re.IGNORECASE):
+            return sql
+        last_top_level = -1
+        for match in re.finditer(r"\bORDER\s+BY\b", sql, re.IGNORECASE):
+            pos = match.start()
+            before = sql[:pos]
+            balanced_before = before.count("(") == before.count(")")
+            depth = 0
+            balanced_after = True
+            for ch in sql[pos:]:
+                if ch == "(":
+                    depth += 1
+                elif ch == ")":
+                    depth -= 1
+                    if depth < 0:
+                        balanced_after = False
+                        break
+            if balanced_before and balanced_after:
+                last_top_level = pos
+        if last_top_level == -1:
+            return sql
+        tail = sql[last_top_level:]
+        if re.search(r"\b(?:OFFSET|FETCH|FOR)\b", tail, re.IGNORECASE):
+            return sql
+        return sql[:last_top_level].rstrip()
+
     @staticmethod
     def _split_schema(name: str) -> tuple[str | None, str]:
         """Split a possibly-qualified table name into (schema, table).

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/database/mssql.py

@@ -64,6 +64,14 @@ class MSSQLAdapter(DatabaseAdapter):
         cursor = self._conn.cursor(as_dict=True)
         cursor.execute(sql, tuple(params) if params else ())
 
+        # Capture the affected-row count from the MAIN statement NOW, before any
+        # follow-up SELECT (SCOPE_IDENTITY / RETURNING fetch) runs on the SAME
+        # cursor and overwrites cursor.rowcount. Reading it at the end reflected
+        # the SCOPE_IDENTITY SELECT instead of the INSERT, so every INSERT
+        # reported affected_rows=0 (a batch insert summed to 0 even though the
+        # rows landed — surfaced by the live MySQL/MSSQL batch test).
+        affected = cursor.rowcount if cursor.rowcount is not None and cursor.rowcount >= 0 else 0
+
         records = []
         last_id = None
 
@@ -89,8 +97,6 @@ class MSSQLAdapter(DatabaseAdapter):
             if row:
                 records = [dict(row)]
 
-        affected = cursor.rowcount if cursor.rowcount >= 0 else 0
-
         if not self._in_transaction and self.autocommit:
             self._conn.commit()
 
@@ -116,7 +122,11 @@ class MSSQLAdapter(DatabaseAdapter):
         # the main cursor half-consumed, and the main query below is
         # deliberately NOT wrapped so its error FAILS LOUD (parity with
         # execute()) instead of looking like "no rows".
-        count_sql = f"SELECT COUNT(*) AS cnt FROM ({sql}) AS _count_subquery"
+        # Strip a trailing top-level ORDER BY before wrapping: SQL Server rejects
+        # ORDER BY in a derived-table subquery without TOP/OFFSET/FETCH (#262),
+        # which otherwise zeroed the count for any query ending in ORDER BY. The
+        # paginated query below keeps its ORDER BY.
+        count_sql = f"SELECT COUNT(*) AS cnt FROM ({self._strip_trailing_order_by(sql)}) AS _count_subquery"
         probe = self._conn.cursor(as_dict=True)
         try:
             probe.execute(count_sql, tuple(params) if params else ())
@@ -155,7 +165,14 @@ class MSSQLAdapter(DatabaseAdapter):
         row = cursor.fetchone()
         return dict(row) if row else None
 
-    def insert(self, table: str, data: dict) -> DatabaseResult:
+    def insert(self, table: str, data: dict | list) -> DatabaseResult:
+        # A list of dicts is a batch insert — delegate to the base class, which
+        # builds one parameterised INSERT and runs it per row via execute_many.
+        # (Database.insert / the docs advertise ``data: dict | list``; without
+        # this branch a list crashed with ``'list' object has no attribute
+        # 'keys'`` because this override only handled the single-dict case.)
+        if isinstance(data, list):
+            return super().insert(table, data)
         columns = ", ".join(data.keys())
         placeholders = ", ".join(["%s"] * len(data))
         sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/database/mysql.py

@@ -140,7 +140,14 @@ class MySQLAdapter(DatabaseAdapter):
         row = cursor.fetchone()
         return dict(row) if row else None
 
-    def insert(self, table: str, data: dict) -> DatabaseResult:
+    def insert(self, table: str, data: dict | list) -> DatabaseResult:
+        # A list of dicts is a batch insert — delegate to the base class, which
+        # builds one parameterised INSERT and runs it per row via execute_many.
+        # (Database.insert / the docs advertise ``data: dict | list``; without
+        # this branch a list crashed with ``'list' object has no attribute
+        # 'keys'`` because this override only handled the single-dict case.)
+        if isinstance(data, list):
+            return super().insert(table, data)
         columns = ", ".join(data.keys())
         placeholders = ", ".join(["%s"] * len(data))
         sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/database/postgres.py

@@ -283,6 +283,12 @@ class PostgreSQLAdapter(DatabaseAdapter):
         cursor = self._conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
         self._exec_with_handling(cursor, sql, params)
 
+        # Capture rowcount NOW, before the lastval()/SAVEPOINT probes below run
+        # their own cursor.execute() calls and overwrite cursor.rowcount. A
+        # no-RETURNING INSERT was reporting affected_rows=0 because those probe
+        # statements clobbered the INSERT's rowcount before it was read at the end.
+        affected = cursor.rowcount if cursor.rowcount >= 0 else 0
+
         records = []
         last_id = None
 
@@ -317,7 +323,10 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 except Exception:
                     cursor.execute("ROLLBACK TO SAVEPOINT _t4_lastval_probe")
 
-        affected = cursor.rowcount if cursor.rowcount >= 0 else 0
+        # NOTE: affected_rows was captured right after the main statement above,
+        # before the lastval()/SAVEPOINT probes ran their own cursor.execute()
+        # calls (which reset cursor.rowcount). Do not recompute it from
+        # cursor.rowcount here or a no-RETURNING INSERT reports 0.
 
         if not self._in_transaction and self.autocommit:
             self._conn.commit()
@@ -417,7 +426,14 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 row[key] = bytes(value)
         return row
 
-    def insert(self, table: str, data: dict) -> DatabaseResult:
+    def insert(self, table: str, data: dict | list) -> DatabaseResult:
+        # A list of dicts is a batch insert — delegate to the base class, which
+        # builds one parameterised INSERT and runs it per row via execute_many.
+        # (Database.insert / the docs advertise ``data: dict | list``; without
+        # this branch a list crashed with ``'list' object has no attribute
+        # 'keys'`` because this override only handled the single-dict case.)
+        if isinstance(data, list):
+            return super().insert(table, data)
         columns = ", ".join(data.keys())
         placeholders = ", ".join(["%s"] * len(data))
         sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders}) RETURNING *"

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/database/sqlite.py

@@ -95,15 +95,25 @@ class SQLiteAdapter(DatabaseAdapter):
     def execute_many(self, sql: str, params_list: list[list] = None) -> DatabaseResult:
         """Optimized batch execute using SQLite's executemany."""
         sql = self._translate_sql(sql)
-        cursor = self._conn.executemany(sql, params_list or [])
+        rows = params_list or []
+        self._conn.executemany(sql, rows)
+
+        # cursor.rowcount / cursor.lastrowid are unreliable after executemany()
+        # in sqlite3 (rowcount can come back 0 or -1, lastrowid is not set) and
+        # were non-deterministic across pooled connections. The batch is
+        # all-or-raise, so every supplied row was applied; the last inserted id
+        # is read deterministically from last_insert_rowid() on this connection.
+        affected = len(rows)
+        last_row = self._conn.execute("SELECT last_insert_rowid()").fetchone()
+        last_id = last_row[0] if last_row and last_row[0] else None
 
         if not self._in_transaction and self.autocommit:
             if self._conn.in_transaction:
                 self._conn.execute("COMMIT")
 
         return DatabaseResult(
-            affected_rows=cursor.rowcount,
-            last_id=cursor.lastrowid,
+            affected_rows=affected,
+            last_id=last_id,
         )
 
     def fetch(self, sql: str, params: list = None,
@@ -144,7 +154,14 @@ class SQLiteAdapter(DatabaseAdapter):
         row = cursor.fetchone()
         return dict(row) if row else None
 
-    def insert(self, table: str, data: dict) -> DatabaseResult:
+    def insert(self, table: str, data: dict | list) -> DatabaseResult:
+        # A list of dicts is a batch insert — delegate to the base class, which
+        # builds one parameterised INSERT and runs it per row via execute_many.
+        # (Database.insert / the docs advertise ``data: dict | list``; without
+        # this branch a list crashed with ``'list' object has no attribute
+        # 'keys'`` because this override only handled the single-dict case.)
+        if isinstance(data, list):
+            return super().insert(table, data)
         columns = ", ".join(data.keys())
         placeholders = ", ".join(["?"] * len(data))
         sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/dev_admin/__init__.py

@@ -159,10 +159,10 @@ class BrokenTracker:
 
         if filepath.exists():
             try:
-                existing = json.loads(filepath.read_text())
+                existing = json.loads(filepath.read_text(encoding="utf-8"))
                 existing["count"] = existing.get("count", 1) + 1
                 existing["last_seen"] = datetime.now(timezone.utc).isoformat()
-                filepath.write_text(json.dumps(existing, indent=2))
+                filepath.write_text(json.dumps(existing, indent=2), encoding="utf-8")
                 return sig_hash
             except (json.JSONDecodeError, OSError):
                 pass
@@ -178,7 +178,7 @@ class BrokenTracker:
             "last_seen": datetime.now(timezone.utc).isoformat(),
             "resolved": False,
         }
-        filepath.write_text(json.dumps(entry, indent=2))
+        filepath.write_text(json.dumps(entry, indent=2), encoding="utf-8")
         return sig_hash
 
     @classmethod
@@ -190,7 +190,7 @@ class BrokenTracker:
         entries = []
         for f in sorted(broken_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True):
             try:
-                entries.append(json.loads(f.read_text()))
+                entries.append(json.loads(f.read_text(encoding="utf-8")))
             except (json.JSONDecodeError, OSError):
                 continue
         return entries
@@ -202,9 +202,9 @@ class BrokenTracker:
         if not filepath.exists():
             return False
         try:
-            entry = json.loads(filepath.read_text())
+            entry = json.loads(filepath.read_text(encoding="utf-8"))
             entry["resolved"] = True
-            filepath.write_text(json.dumps(entry, indent=2))
+            filepath.write_text(json.dumps(entry, indent=2), encoding="utf-8")
             return True
         except (json.JSONDecodeError, OSError):
             return False
@@ -217,7 +217,7 @@ class BrokenTracker:
             return
         for f in broken_dir.glob("*.json"):
             try:
-                entry = json.loads(f.read_text())
+                entry = json.loads(f.read_text(encoding="utf-8"))
                 if entry.get("resolved"):
                     f.unlink()
             except (json.JSONDecodeError, OSError):
@@ -1791,7 +1791,7 @@ async def _api_connections(request, response):
     username = ""
     password = ""
     if env_path.exists():
-        for line in env_path.read_text().splitlines():
+        for line in env_path.read_text(encoding="utf-8").splitlines():
             line = line.strip()
             if line.startswith("#") or "=" not in line:
                 continue
@@ -1863,7 +1863,7 @@ async def _api_connections_save(request, response):
         env_path = Path(".env")
         lines = []
         if env_path.exists():
-            lines = env_path.read_text().splitlines()
+            lines = env_path.read_text(encoding="utf-8").splitlines()
         keys_found = {"TINA4_DATABASE_URL": False, "TINA4_DATABASE_USERNAME": False, "TINA4_DATABASE_PASSWORD": False}
         new_lines = []
         for line in lines:
@@ -1891,7 +1891,7 @@ async def _api_connections_save(request, response):
             if not found:
                 val = {"TINA4_DATABASE_URL": url, "TINA4_DATABASE_USERNAME": username, "TINA4_DATABASE_PASSWORD": password}[key]
                 new_lines.append(f"{key}={val}")
-        env_path.write_text("\n".join(new_lines) + "\n")
+        env_path.write_text("\n".join(new_lines) + "\n", encoding="utf-8")
         return response({"success": True})
     except Exception as e:
         return response({"success": False, "error": str(e)})
@@ -1906,7 +1906,7 @@ async def _api_gallery_list(request, response):
         for entry in sorted(gallery_dir.iterdir()):
             meta_file = entry / "meta.json"
             if entry.is_dir() and meta_file.exists():
-                meta = json.loads(meta_file.read_text())
+                meta = json.loads(meta_file.read_text(encoding="utf-8"))
                 meta["id"] = entry.name
                 # List the files that would be deployed
                 src_dir = entry / "src"

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/migration/runner.py

@@ -95,13 +95,26 @@ def _create_v3_table(db) -> None:
             )
         """)
     else:
-        db.execute("""
+        # Engine-aware bookkeeping DDL. Each engine spells an auto-increment
+        # integer PK differently (SQLite AUTOINCREMENT, PostgreSQL SERIAL, MySQL
+        # AUTO_INCREMENT, MSSQL IDENTITY), and a TEXT column cannot carry a UNIQUE
+        # constraint on MySQL -- so migration_id is VARCHAR. (SQLite gives VARCHAR
+        # TEXT affinity, so this stays behaviour-identical there.) Mirrors the
+        # engine-aware DDL in ORM.create_table; without it `migrate()` died with
+        # "syntax error at AUTOINCREMENT" on PostgreSQL/MySQL/MSSQL.
+        engine = (db.get_database_type() or "sqlite").lower()
+        id_column = {
+            "postgresql": "id SERIAL PRIMARY KEY",
+            "mysql": "id INTEGER PRIMARY KEY AUTO_INCREMENT",
+            "mssql": "id INTEGER IDENTITY(1,1) PRIMARY KEY",
+        }.get(engine, "id INTEGER PRIMARY KEY AUTOINCREMENT")
+        db.execute(f"""
             CREATE TABLE tina4_migration (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                migration_id TEXT NOT NULL UNIQUE,
-                description TEXT,
+                {id_column},
+                migration_id VARCHAR(500) NOT NULL UNIQUE,
+                description VARCHAR(500),
                 batch INTEGER NOT NULL DEFAULT 1,
-                executed_at TEXT NOT NULL,
+                executed_at VARCHAR(50) NOT NULL,
                 passed INTEGER NOT NULL DEFAULT 1
             )
         """)

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/queue_backends/kafka_backend.py

@@ -17,6 +17,7 @@ import os
 import secrets
 import socket
 import struct
+import time
 import zlib
 
 
@@ -86,11 +87,29 @@ class KafkaConnector:
         self._ensure_connected()
 
         if self._use_confluent:
-            if topic not in self._subscribed_topics:
+            first = topic not in self._subscribed_topics
+            if first:
                 self._consumer.subscribe([topic])
                 self._subscribed_topics.add(topic)
-            msg = self._consumer.poll(timeout=1.0)
-            if msg is None or msg.error():
+            # The FIRST poll after subscribing must drive the consumer-group
+            # join + partition assignment, which takes several seconds on a cold
+            # broker. Until partitions are assigned, poll() returns None even
+            # when the topic already has messages -- so a single short poll made
+            # dequeue() return None right after enqueue(). Poll in a bounded loop
+            # on first subscribe (deadline TINA4_KAFKA_ASSIGN_TIMEOUT, default
+            # 15s); steady state stays a single ~1s poll.
+            deadline = time.monotonic() + (
+                float(os.environ.get("TINA4_KAFKA_ASSIGN_TIMEOUT", "15")) if first else 1.0
+            )
+            msg = None
+            while True:
+                candidate = self._consumer.poll(timeout=0.5)
+                if candidate is not None and not candidate.error():
+                    msg = candidate
+                    break
+                if time.monotonic() >= deadline:
+                    break
+            if msg is None:
                 return None
             self._last_message = msg
             try:

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/queue_backends/rabbitmq_backend.py

@@ -135,7 +135,14 @@ class RabbitMQConnector:
         self._ensure_connected()
 
         if self._use_pika:
-            result = self._channel.queue_declare(queue=topic, durable=True, passive=True)
+            # Declare durably (idempotent — creates the queue if missing) rather
+            # than passive=True. A passive declare raises ChannelClosedByBroker
+            # (404 NOT_FOUND) when the queue does not yet exist, so size() on a
+            # fresh topic crashed on the pika path. The raw-AMQP path already
+            # declares-then-counts and returns 0 for an unseen queue; this brings
+            # the pika path to the same behaviour.
+            self._ensure_queue_pika(topic)
+            result = self._channel.queue_declare(queue=topic, durable=True)
             return result.method.message_count
         else:
             return self._queue_size_raw(topic)
@@ -200,11 +207,13 @@ class RabbitMQConnector:
         # Connection.StartOk
         self._send_connection_start_ok()
 
-        # Connection.Tune
-        self._read_frame()
+        # Connection.Tune (the broker proposes channel-max, frame-max, heartbeat)
+        tune = self._read_frame()
 
-        # Connection.TuneOk
-        self._send_connection_tune_ok()
+        # Connection.TuneOk — negotiate from the broker's proposal (never exceed
+        # its channel-max; a hardcoded channel-max of 0 = "no limit" is treated as
+        # greater than the proposed 2047 and RabbitMQ aborts the handshake).
+        self._send_connection_tune_ok(tune)
 
         # Connection.Open
         self._send_connection_open()
@@ -299,8 +308,37 @@ class RabbitMQConnector:
         )
         self._write_method(0, 10, 11, args)
 
-    def _send_connection_tune_ok(self):
-        args = struct.pack("!HIH", 0, 131072, 60)
+    def _send_connection_tune_ok(self, tune: dict | None = None):
+        """Send Connection.TuneOk negotiated from the broker's Connection.Tune.
+
+        AMQP 0-9-1 requires the client's TuneOk values to not exceed the server's
+        proposal. The Tune payload (after the 4-byte class+method) is
+        channel-max:short, frame-max:long, heartbeat:short. We echo channel-max
+        (the server's cap; 0 = unlimited), clamp frame-max to min(desired, server)
+        treating 0 as unlimited, and choose a heartbeat. Hardcoding channel-max=0
+        means "no limit", which RabbitMQ treats as exceeding its proposed 2047 and
+        aborts the connection right after Open.
+        """
+        desired_frame_max = 131072
+        desired_heartbeat = 60
+
+        channel_max = 2047
+        frame_max = desired_frame_max
+        heartbeat = desired_heartbeat
+
+        if tune is not None and len(tune.get("payload", b"")) >= 12:
+            # payload: class_id(2) + method_id(2) + channel-max(2) + frame-max(4) + heartbeat(2)
+            _cls, _method, server_channel_max, server_frame_max, server_heartbeat = struct.unpack(
+                "!HHHIH", tune["payload"][:12]
+            )
+            # channel-max: never exceed the server's proposal (echo its value).
+            channel_max = server_channel_max
+            # frame-max: min(desired, server), treating 0 as unlimited on either side.
+            frame_max = desired_frame_max if server_frame_max == 0 else min(desired_frame_max, server_frame_max)
+            # heartbeat: our choice, clamped to the server's if it proposed a non-zero one.
+            heartbeat = desired_heartbeat if server_heartbeat == 0 else min(desired_heartbeat, server_heartbeat)
+
+        args = struct.pack("!HIH", channel_max, frame_max, heartbeat)
         self._write_method(0, 10, 31, args)
 
     def _send_connection_open(self):

{tina4_python-3.13.43 → tina4_python-3.13.45}/tina4_python/session/__init__.py

@@ -195,7 +195,11 @@ class Session:
             from tina4_python.session_handlers import MongoDBSessionHandler
             return MongoDBSessionHandler()
         elif backend in ("database", "db"):
-            return DatabaseSessionHandler()
+            # Resolve the same connection the ORM uses (global bound db, then
+            # TINA4_DATABASE_URL). DatabaseSessionHandler "uses whatever DB is
+            # connected" — so reuse the single ORM resolver rather than guess.
+            from tina4_python.orm.model import ORM
+            return DatabaseSessionHandler(ORM._get_db())
         else:
             return FileSessionHandler()