tina4-python 3.13.42__tar.gz → 3.13.44__tar.gz

{tina4_python-3.13.42 → tina4_python-3.13.44}/PKG-INFO

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

{tina4_python-3.13.42 → tina4_python-3.13.44}/pyproject.toml

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

{tina4_python-3.13.42 → tina4_python-3.13.44}/tina4_python/__init__.py

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

{tina4_python-3.13.42 → tina4_python-3.13.44}/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.42 → tina4_python-3.13.44}/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.42 → tina4_python-3.13.44}/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.42 → tina4_python-3.13.44}/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.42 → tina4_python-3.13.44}/tina4_python/database/mssql.py

@@ -116,7 +116,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 +159,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.42 → tina4_python-3.13.44}/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.42 → tina4_python-3.13.44}/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.42 → tina4_python-3.13.44}/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.42 → tina4_python-3.13.44}/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.42 → tina4_python-3.13.44}/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.42 → tina4_python-3.13.44}/tina4_python/queue/__init__.py

@@ -61,7 +61,7 @@ def _resolve_backend(topic: str, backend: str | None, max_retries: int,
         # Consumer-group offsets manage redelivery — framework timeout N/A.
         return KafkaBackend(topic, max_retries)
     elif chosen in ("mongodb", "mongo"):
-        return MongoBackend(topic, max_retries, visibility_timeout)
+        return MongoBackend(topic, max_retries, visibility_timeout, retry_backoff)
     else:
         raise ValueError(f"Unknown queue backend: {chosen!r}. Use 'file', 'rabbitmq', 'kafka', or 'mongodb'.")
 
@@ -82,9 +82,12 @@ class Queue:
                  visibility_timeout: float | None = None):
         self.topic = topic
         self.max_retries = max_retries
-        # Seconds to wait before a failed job is re-attempted (file backend).
+        # Seconds to wait before a failed job is re-attempted.
         # Default 0 = retry on the very next pop()/consume() iteration.
         self.retry_backoff = retry_backoff
+        # Remember an explicit backend= so retargeting a topic (produce/consume)
+        # does not silently fall back to the TINA4_QUEUE_BACKEND env default.
+        self._backend_choice = backend
         # Reservation/visibility timeout (seconds). A popped job is reserved for
         # this long; if the consumer dies before complete()/fail() the next
         # pop() reclaims it (at-least-once delivery). Falls back to
@@ -96,6 +99,24 @@ class Queue:
         self._backend = _resolve_backend(topic, backend, max_retries, retry_backoff,
                                          self.visibility_timeout)
 
+    def _retarget(self, topic: str) -> None:
+        """Point this queue (and its backend) at ``topic`` in place.
+
+        produce()/consume()/process() call this so a topic argument actually
+        changes which topic is read or written. Without it the argument was
+        accepted but ignored on the read path — pop() always used the
+        construction-time topic, so ``consume("other")`` silently drained the
+        wrong queue. Reuses the explicit backend choice (``_backend_choice``)
+        so an explicit ``backend=`` is preserved across the switch.
+        """
+        if topic == self.topic:
+            return
+        self.topic = topic
+        self._backend = _resolve_backend(
+            topic, self._backend_choice, self.max_retries,
+            self.retry_backoff, self.visibility_timeout,
+        )
+
     def push(self, data: dict, priority: int = 0, delay_seconds: int = 0):
         """Add a job to the queue. Returns job ID."""
         return self._backend.push(data, priority, delay_seconds)
@@ -134,6 +155,8 @@ class Queue:
             batch_size: Number of jobs to pass to handler at once (default 1).
                         When > 1, handler receives a list of Jobs.
         """
+        if topic is not None:
+            self._retarget(topic)
         processed = 0
         while max_jobs is None or processed < max_jobs:
             if batch_size > 1:
@@ -235,15 +258,11 @@ class Queue:
             delay_seconds = max(0, offset)
 
         old_topic = self.topic
-        self.topic = topic
-        self._backend = _resolve_backend(topic, None, self.max_retries, self.retry_backoff,
-                                         self.visibility_timeout)
+        self._retarget(topic)
         try:
             return self.push(data, priority, delay_seconds)
         finally:
-            self.topic = old_topic
-            self._backend = _resolve_backend(old_topic, None, self.max_retries, self.retry_backoff,
-                                             self.visibility_timeout)
+            self._retarget(old_topic)
 
     def consume(self, topic: str = None, job_id: str = None, poll_interval: float = 1.0,
                 iterations: int = 0, batch_size: int = 1):
@@ -282,6 +301,10 @@ class Queue:
         import time
 
         topic = topic or self.topic
+        # Honor the topic argument: point the queue (and the backend that
+        # pop()/job.complete()/job.fail() route through) at it. Previously the
+        # argument was ignored and consume() drained the construction-time topic.
+        self._retarget(topic)
 
         if job_id is not None:
             # Consume a specific job by ID — single yield, no polling

{tina4_python-3.13.42 → tina4_python-3.13.44}/tina4_python/queue/kafka_backend.py

@@ -54,16 +54,21 @@ class KafkaBackend:
     def purge(self, status: str = "completed"):
         pass  # Kafka does not support purging
 
-    def retry_failed(self) -> int:
-        jobs = self.failed()
+    def retry_failed(self, max_retries: int = None) -> int:
+        jobs = self.failed(max_retries)
         count = 0
         for job in jobs:
             if self.retry_job(job.get("id", "")):
                 count += 1
         return count
 
-    def failed(self) -> list[dict]:
-        """Consume dead_letter topic, republish, return jobs under max_retries."""
+    def failed(self, max_retries: int = None) -> list[dict]:
+        """Consume dead_letter topic, republish, return jobs under max_retries.
+
+        Accepts max_retries to match the LiteBackend contract — Queue.retry_failed()
+        passes it as a kwarg, so without this signature the call raised TypeError.
+        """
+        mr = max_retries if max_retries is not None else self._max_retries
         dl_topic = f"{self._topic}.dead_letter"
         results = []
         requeue = []
@@ -73,7 +78,7 @@ class KafkaBackend:
                 break
             payload = msg.get("payload", msg)
             attempts = msg.get("attempts", 0)
-            if attempts < self._max_retries:
+            if attempts < mr:
                 results.append({"id": msg.get("id"), "data": payload,
                                  "attempts": attempts, "error": msg.get("error")})
             requeue.append(msg)
@@ -81,8 +86,13 @@ class KafkaBackend:
             self._backend.enqueue(dl_topic, msg)
         return results
 
-    def dead_letters(self) -> list[dict]:
-        """Consume dead_letter topic, republish, return jobs at/over max_retries."""
+    def dead_letters(self, max_retries: int = None) -> list[dict]:
+        """Consume dead_letter topic, republish, return jobs at/over max_retries.
+
+        Accepts max_retries to match the LiteBackend contract — Queue.dead_letters()
+        passes it as a kwarg, so without this signature the call raised TypeError.
+        """
+        mr = max_retries if max_retries is not None else self._max_retries
         dl_topic = f"{self._topic}.dead_letter"
         results = []
         requeue = []
@@ -92,7 +102,7 @@ class KafkaBackend:
                 break
             payload = msg.get("payload", msg)
             attempts = msg.get("attempts", 0)
-            if attempts >= self._max_retries:
+            if attempts >= mr:
                 results.append({"id": msg.get("id"), "data": payload,
                                  "attempts": attempts, "error": msg.get("error")})
             requeue.append(msg)

{tina4_python-3.13.42 → tina4_python-3.13.44}/tina4_python/queue/mongo_backend.py

@@ -23,11 +23,12 @@ def _future(seconds: int) -> str:
 class MongoBackend:
     """Backend adapter wrapping MongoBackend for the unified Queue API."""
 
-    def __init__(self, topic: str, max_retries: int, visibility_timeout: float = 300.0):
+    def __init__(self, topic: str, max_retries: int, visibility_timeout: float = 300.0,
+                 retry_backoff: float = 0):
         from tina4_python.queue_backends import MongoConnector as _MongoBackend
 
         url = os.environ.get("TINA4_QUEUE_URL", "")
-        config = {"visibility_timeout": visibility_timeout}
+        config = {"visibility_timeout": visibility_timeout, "retry_backoff": retry_backoff}
         if url:
             config["uri"] = url
         self._backend = _MongoBackend(**config)
@@ -70,12 +71,19 @@ class MongoBackend:
         if status == "pending":
             self._backend.clear(self._topic)
 
-    def retry_failed(self) -> int:
+    def retry_failed(self, max_retries: int = None) -> int:
+        # Accept max_retries to match the LiteBackend contract (Queue passes it
+        # as a kwarg) — without this signature, Queue.retry_failed() raised
+        # TypeError on MongoDB.
+        mr = max_retries if max_retries is not None else self._max_retries
         self._backend._ensure_connected()
         result = self._backend._collection.update_many(
             {"topic": self._topic, "status": "failed",
-             "attempts": {"$lt": self._max_retries}},
-            {"$set": {"status": "pending", "error": None}},
+             "attempts": {"$lt": mr}},
+            # Reset available_at so re-queued failed jobs are visible again
+            # (they were reserved with available_at in the future at dequeue).
+            {"$set": {"status": "pending", "error": None, "available_at": _now(),
+                      "reserved_at": None}},
         )
         return result.modified_count
 
@@ -90,8 +98,13 @@ class MongoBackend:
                  "attempts": d.get("attempts", 0), "error": d.get("error")}
                 for d in docs]
 
-    def dead_letters(self) -> list[dict]:
-        """Query the dead_letter collection in MongoDB."""
+    def dead_letters(self, max_retries: int = None) -> list[dict]:
+        """Query the dead_letter collection in MongoDB.
+
+        Accepts max_retries (unused — dead letters are terminal) to match the
+        LiteBackend contract; Queue.dead_letters() passes it as a kwarg, so
+        without this parameter the call raised TypeError on MongoDB.
+        """
         self._backend._ensure_connected()
         dl_topic = f"{self._topic}.dead_letter"
         docs = self._backend._collection.find({"topic": dl_topic})