tina4-python 3.13.75__tar.gz → 3.13.77__tar.gz

{tina4_python-3.13.75 → tina4_python-3.13.77}/PKG-INFO

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

{tina4_python-3.13.75 → tina4_python-3.13.77}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.75"
+version = "3.13.77"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}
@@ -64,6 +64,9 @@ tina4python = "tina4_python.cli:main"
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]
+markers = [
+    "slow: a test that needs real wall-clock time to reproduce a timing bug (deselect with -m 'not slow')",
+]
 
 [tool.ruff]
 target-version = "py312"

{tina4_python-3.13.75 → tina4_python-3.13.77}/tina4_python/core/server.py

@@ -49,6 +49,58 @@ def background(callback, interval: float = 1.0):
     _background_tasks.append({"callback": callback, "interval": interval})
 
 
+async def background_tick_loop(callback, interval: float, executor, shutdown):
+    """Run one registered background task on its interval until shutdown.
+
+    A task NEVER overlaps itself: each run is awaited to completion before the
+    interval sleep and the next tick. That is the only sound reading of an
+    interval scheduler, and it is what makes the one-worker-per-task pool sizing
+    in `_serve` safe.
+
+    Args:
+        callback: The registered callable (sync or async, no arguments).
+        interval: Seconds to sleep between runs.
+        executor: ThreadPoolExecutor used for sync callbacks.
+        shutdown: asyncio.Event that ends the loop when set.
+    """
+    timeout = max(interval * 2, 5.0)
+    loop = asyncio.get_running_loop()
+    while not shutdown.is_set():
+        try:
+            if asyncio.iscoroutinefunction(callback):
+                # A coroutine IS cancellable, so the timeout really interrupts it.
+                await asyncio.wait_for(callback(), timeout=timeout)
+            else:
+                # Run sync callback in a thread pool — never blocks the event loop.
+                #
+                # A callable already running in a ThreadPoolExecutor CANNOT be
+                # cancelled: Future.cancel() returns False once it has started and
+                # there is no way to interrupt the thread. So this must NOT use
+                # wait_for() — that abandons the wrapper future while the thread
+                # keeps running, and the next tick then starts a SECOND copy
+                # alongside the first (silent double-execution of a slow sweep,
+                # with every later tick piling on another). Wait for the run to
+                # finish and only WARN about the overrun.
+                fut = loop.run_in_executor(executor, callback)
+                done, _pending = await asyncio.wait({fut}, timeout=timeout)
+                if not done:
+                    Log.warning(
+                        f"Background task is still running after {timeout:.1f}s. "
+                        f"The next run is deferred until it finishes (a running sync "
+                        f"task cannot be interrupted). Use non-blocking calls "
+                        f"(e.g. queue.pop() instead of queue.consume())."
+                    )
+                await fut  # never overlap; re-raises the callback's error
+        except asyncio.TimeoutError:
+            Log.warning(
+                f"Background task exceeded {timeout:.1f}s timeout and was interrupted. "
+                f"Use non-blocking calls (e.g. queue.pop() instead of queue.consume())."
+            )
+        except Exception as e:
+            Log.error(f"Background task error: {e}")
+        await asyncio.sleep(interval)
+
+
 # module_name → source-file mtime at the last (re)import. Drives the
 # changed-file detection in ``_auto_discover``: a file whose mtime is newer
 # than the recorded value is re-executed in place, so editing an existing
@@ -2743,7 +2795,9 @@ def run(host: str | None = None, port: int | None = None, no_browser: bool = Fal
 
         # Start registered background tasks as asyncio tasks.
         # Sync callbacks run in a thread pool so they CANNOT block the event loop.
-        # A timeout (2x interval, min 5s) cancels runaway tasks.
+        # max_workers is one per registered task — sound only because a task never
+        # overlaps itself (see background_tick_loop), so tasks cannot starve each
+        # other of workers.
         import concurrent.futures
         _executor = concurrent.futures.ThreadPoolExecutor(
             max_workers=max(len(_background_tasks), 2),
@@ -2751,31 +2805,11 @@ def run(host: str | None = None, port: int | None = None, no_browser: bool = Fal
         )
         bg_tasks = []
         for task_def in _background_tasks:
-            cb = task_def["callback"]
-            iv = task_def["interval"]
-
-            async def _tick_loop(_cb=cb, _iv=iv):
-                timeout = max(_iv * 2, 5.0)
-                while not shutdown.is_set():
-                    try:
-                        if asyncio.iscoroutinefunction(_cb):
-                            await asyncio.wait_for(_cb(), timeout=timeout)
-                        else:
-                            # Run sync callback in thread pool — never blocks the event loop
-                            await asyncio.wait_for(
-                                loop.run_in_executor(_executor, _cb),
-                                timeout=timeout,
-                            )
-                    except asyncio.TimeoutError:
-                        Log.warning(
-                            f"Background task exceeded {timeout:.1f}s timeout and was interrupted. "
-                            f"Use non-blocking calls (e.g. queue.pop() instead of queue.consume())."
-                        )
-                    except Exception as e:
-                        Log.error(f"Background task error: {e}")
-                    await asyncio.sleep(_iv)
-
-            bg_tasks.append(asyncio.create_task(_tick_loop()))
+            bg_tasks.append(asyncio.create_task(
+                background_tick_loop(
+                    task_def["callback"], task_def["interval"], _executor, shutdown,
+                )
+            ))
 
         await shutdown.wait()
 

{tina4_python-3.13.75 → tina4_python-3.13.77}/tina4_python/migration/runner.py

@@ -296,7 +296,11 @@ def _ensure_tracking_table(db, migration_folder: str | None = None):
     # and copy the values across so already-applied migrations are still seen as
     # applied — without this the `migration_name`-based read below finds nothing
     # and every migration re-runs. The old `migration_id` column is left in
-    # place (harmless, ignored from now on).
+    # place: it cannot be dropped portably (SQLite cannot drop a NOT NULL or a
+    # column without a full table rebuild). It is ignored on READS, but it is
+    # NOT ignorable on WRITES — it is NOT NULL on that table, so
+    # `_record_applied` must keep populating it (see there). Leaving it unwritten
+    # is what broke every migration on an upgraded database in 3.13.55-3.13.75.
     if "migration_id" in cols and "migration_name" not in cols:
         col_type = "VARCHAR(500)" if _is_firebird(db) else "TEXT"
         try:
@@ -641,18 +645,36 @@ def _record_applied(db, name: str, desc: str, batch: int, passed: int = 1) -> No
     """
     now = datetime.now(timezone.utc).isoformat()
     db.execute("DELETE FROM tina4_migration WHERE migration_name = ?", [name])
+
+    # Build the column list from the columns that ACTUALLY exist on this table,
+    # so a legacy column an earlier in-place upgrade left behind is populated
+    # rather than defaulted to NULL. A table created by v3 <= 3.13.54 carries
+    # `migration_id NOT NULL UNIQUE`; the rename upgrade adds `migration_name`
+    # beside it but cannot drop the NOT NULL portably (SQLite cannot drop it at
+    # all without a table rebuild), so this insert has to satisfy it or every
+    # migration on that database fails and none can ever apply.
+    cols = _column_names(db)
+    insert_cols = ["migration_name", "description", "batch", "executed_at", "passed"]
+    values = [name, desc, batch, now, passed]
+
+    # v3 <= 3.13.54: `migration_id` held exactly the value `migration_name` holds
+    # now, so writing `name` restores that invariant. Safe against its UNIQUE:
+    # the DELETE above removed this migration's own row first, so a re-run
+    # replaces its row instead of colliding.
+    if "migration_id" in cols:
+        insert_cols.append("migration_id")
+        values.append(name)
+
     if _is_firebird(db):
         row = db.fetch_one("SELECT GEN_ID(GEN_TINA4_MIGRATION_ID, 1) AS next_id FROM RDB$DATABASE")
-        next_id = row["next_id"] if row else 1
-        db.execute(
-            "INSERT INTO tina4_migration (id, migration_name, description, batch, executed_at, passed) VALUES (?, ?, ?, ?, ?, ?)",
-            [next_id, name, desc, batch, now, passed],
-        )
-    else:
-        db.execute(
-            "INSERT INTO tina4_migration (migration_name, description, batch, executed_at, passed) VALUES (?, ?, ?, ?, ?)",
-            [name, desc, batch, now, passed],
-        )
+        insert_cols.insert(0, "id")
+        values.insert(0, row["next_id"] if row else 1)
+
+    placeholders = ", ".join("?" for _ in insert_cols)
+    db.execute(
+        f"INSERT INTO tina4_migration ({', '.join(insert_cols)}) VALUES ({placeholders})",
+        values,
+    )
 
 
 def _migrate(db, migration_folder: str = "migrations", delimiter: str = ";") -> list[str]: