graph-crawler 5.3.6__tar.gz → 5.3.7__tar.gz

{graph_crawler-5.3.6 → graph_crawler-5.3.7}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+## 5.3.7 — 2026-10
+
+### Fixed
+
+- **A crawl worker no longer dies on a canonical redirect while another SQLite statement is running.**
+  `SQLiteBackend._sync_execute` treated `sqlite3.OperationalError: cannot commit transaction - SQL statements in
+  progress` as a failed write, although the DELETE/UPDATE had already run in the open transaction of the shared
+  connection. The fallback `_run_async` then ran the coroutine on a new loop in a thread (`asyncio.Lock ... is bound to
+  a different event loop`) and, catching that `RuntimeError`, called `asyncio.run()` inside the running loop — the
+  worker failed (`Graph.remove_node` → `delete_node_sync`). Now:
+  - a commit refused because of in-progress statements is deferred: the change stays in the open transaction and is
+    committed by the next async commit or by `close()`;
+  - `_run_async` inside a running loop schedules the write as a task on that loop (errors are logged) instead of
+    blocking on a foreign loop; outside a loop it still runs synchronously;
+  - `close()` awaits scheduled writes and commits before closing.
+- Tests: `tests/test_sqlite_sync_write_in_loop.py`.
+
 ## 5.3.6 — 2026-06
 
 ### Fixed

{graph_crawler-5.3.6/graph_crawler.egg-info → graph_crawler-5.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-crawler
-Version: 5.3.6
+Version: 5.3.7
 Summary: Web crawler that builds a graph of a site. HTTP → TLS → browser escalation with pluggable browser engines.
 Author: 0-EternalJunior-0
 Maintainer: 0-EternalJunior-0

{graph_crawler-5.3.6 → graph_crawler-5.3.7}/graph_crawler/data/backends/sqlite.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
+import sqlite3
 from collections import OrderedDict, defaultdict
 from collections.abc import Mapping
 from contextlib import asynccontextmanager
@@ -275,6 +276,8 @@ class SQLiteBackend:
         # Task, що тримає transaction(); методи з цього task
         # не беруть lock повторно (asyncio.Lock не reentrant → deadlock)
         self._transaction_task: asyncio.Task | None = None
+        # Записи, заплановані *_sync-методами задачами на робочому event loop.
+        self._pending_writes: set[asyncio.Task] = set()
 
         # Stats
         self._use_cache = True  # Use in-memory cache for fast reads
@@ -425,7 +428,13 @@ class SQLiteBackend:
     def _sync_execute(self, statements: list[tuple[str, tuple]]) -> int | None:
         """Синхронний запис через спільне з'єднання (без ``_run_async``
         і cross-loop ``asyncio.Lock``). None → з'єднання немає; інакше rowcount
-        першого statement-у."""
+        першого statement-у.
+
+        Якщо на з'єднанні саме відкритий курсор aiosqlite-воркера, SQLite відмовляє
+        у commit («SQL statements in progress»). Зміни вже лежать у відкритій
+        транзакції цього ж з'єднання й фіксуються найближчим async-commit-ом
+        (або в ``close()``), тож запис вважається успішним.
+        """
         conn = self._conn
         raw = getattr(conn, "_connection", None) if conn is not None else None
         if raw is None:
@@ -436,7 +445,12 @@ class SQLiteBackend:
                 cur = raw.execute(sql, params)
                 if rowcount is None:
                     rowcount = cur.rowcount
-            raw.commit()
+            try:
+                raw.commit()
+            except sqlite3.OperationalError:
+                if not raw.in_transaction:
+                    raise
+                logger.debug("SQLiteBackend sync write: commit deferred (statements in progress)")
             return rowcount if rowcount is not None else 0
         except Exception:
             logger.warning("SQLiteBackend sync write failed", exc_info=True)
@@ -580,7 +594,10 @@ class SQLiteBackend:
 
     async def close(self) -> None:
         """Закриває з'єднання."""
+        if self._pending_writes:
+            await asyncio.gather(*self._pending_writes, return_exceptions=True)
         if self._conn:
+            await self._conn.commit()
             await self._conn.close()
             self._conn = None
         self._is_open = False
@@ -1597,20 +1614,28 @@ class SQLiteBackend:
     # SYNC WRAPPERS
     # ═══════════════════════════════════════════════════════════════════════════
 
-    def _run_async(self, coro):
-        """Запускає coroutine синхронно."""
+    def _run_async(self, coro, result_in_loop: Any):
+        """Виконує async-запис із sync-коду.
+
+        Поза event loop — синхронно через ``asyncio.run``. Усередині робочого loop
+        дочекатися coroutine неможливо: ``self._lock`` і з'єднання aiosqlite
+        прив'язані до цього loop, а окремий loop у потоці падає з «bound to a
+        different event loop». Тому запис планується задачею на поточному loop,
+        а викликачу повертається ``result_in_loop``.
+        """
         try:
             loop = asyncio.get_running_loop()
-            if loop.is_running():
-                # Already in async context - use cache directly
-                import concurrent.futures
-
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(asyncio.run, coro)
-                    return future.result()
-            return loop.run_until_complete(coro)
         except RuntimeError:
             return asyncio.run(coro)
+        task = loop.create_task(coro)
+        self._pending_writes.add(task)
+        task.add_done_callback(self._on_pending_write_done)
+        return result_in_loop
+
+    def _on_pending_write_done(self, task: asyncio.Task) -> None:
+        self._pending_writes.discard(task)
+        if not task.cancelled() and task.exception() is not None:
+            logger.warning("SQLiteBackend scheduled write failed", exc_info=task.exception())
 
     def insert_node_sync(self, node: Any) -> Any:
         # Use cache directly for sync calls
@@ -1656,7 +1681,7 @@ class SQLiteBackend:
         if url is None:
             rows = self._sync_fetchall("SELECT url FROM nodes WHERE node_id = ?", (node_id,))
             if rows is None:
-                return self._run_async(self.delete_node(node_id))
+                return self._run_async(self.delete_node(node_id), result_in_loop=True)
             if not rows:
                 return False
             url = rows[0][0]
@@ -1670,7 +1695,7 @@ class SQLiteBackend:
             ]
         )
         if deleted is None:
-            return self._run_async(self.delete_node(node_id))
+            return self._run_async(self.delete_node(node_id), result_in_loop=True)
         if self._use_cache:
             self._cache_remove(node_id, url)
             self._edges = [
@@ -1764,8 +1789,8 @@ class SQLiteBackend:
 
         Проблема залишається на рівні **диску**: SQLite-рядок не оновлюється,
         поки ніхто явно не викличе ``update_node``. Цей метод вирішує проблему:
-        викликає ``update_node(node)`` синхронно через ``_run_async`` так само,
-        як це робиться у ``iter_nodes_sync`` / ``insert_node_sync``.
+        пише рядок напряму через ``_sync_execute``; якщо це неможливо — передає
+        ``update_node(node)`` у ``_run_async``.
 
         Args:
             node: Ноду з оновленими полями (``node_id`` має існувати у БД).
@@ -1813,7 +1838,7 @@ class SQLiteBackend:
             ]
         )
         if rowcount is None:
-            return self._run_async(self.update_node(node))
+            return self._run_async(self.update_node(node), result_in_loop=True)
         if rowcount > 0:
             self._dirty_node_ids.discard(node.node_id)
             return True

{graph_crawler-5.3.6 → graph_crawler-5.3.7/graph_crawler.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-crawler
-Version: 5.3.6
+Version: 5.3.7
 Summary: Web crawler that builds a graph of a site. HTTP → TLS → browser escalation with pluggable browser engines.
 Author: 0-EternalJunior-0
 Maintainer: 0-EternalJunior-0

{graph_crawler-5.3.6 → graph_crawler-5.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graph-crawler"
-version = "5.3.6"
+version = "5.3.7"
 description = "Web crawler that builds a graph of a site. HTTP → TLS → browser escalation with pluggable browser engines."
 readme = "README.md"
 requires-python = ">=3.11"