brawny 0.1.13__py3-none-any.whl → 0.1.22__py3-none-any.whl

brawny/db/queries.py

@@ -1,11 +1,4 @@
-"""Canonical SQL queries for brawny database operations.
-
-All queries use :name placeholder style.
-- SQLite: Supports :name natively with dict params
-- Postgres: Rewritten to %(name)s in postgres.py
-
-Dialect-specific queries use dict format: {"postgres": "...", "sqlite": "..."}
-"""
+"""Canonical SQL queries for brawny database operations (SQLite-only)."""
 
 from __future__ import annotations
 
@@ -70,7 +63,11 @@ GET_OLDEST_BLOCK_IN_HISTORY = """
 
 GET_JOB = "SELECT * FROM jobs WHERE job_id = :job_id"
 
-GET_ENABLED_JOBS = "SELECT * FROM jobs WHERE enabled = 1 ORDER BY job_id"
+GET_ENABLED_JOBS = (
+    "SELECT * FROM jobs WHERE enabled = 1 "
+    "AND (drain_until IS NULL OR drain_until <= CURRENT_TIMESTAMP) "
+    "ORDER BY job_id"
+)
 
 LIST_ALL_JOBS = "SELECT * FROM jobs ORDER BY job_id"
 
@@ -231,19 +228,11 @@ UPDATE_NONCE_RESERVATION_STATUS_WITH_INTENT = """
     WHERE chain_id = :chain_id AND signer_address = :address AND nonce = :nonce
 """
 
-# Dialect-specific: lock signer for nonce reservation
-# Postgres uses FOR UPDATE, SQLite doesn't need it (uses BEGIN IMMEDIATE)
-LOCK_SIGNER_FOR_UPDATE = {
-    "postgres": """
-        SELECT * FROM signers
-        WHERE chain_id = :chain_id AND signer_address = :address
-        FOR UPDATE
-    """,
-    "sqlite": """
-        SELECT * FROM signers
-        WHERE chain_id = :chain_id AND signer_address = :address
-    """,
-}
+# Lock signer for nonce reservation (SQLite uses BEGIN IMMEDIATE in caller).
+LOCK_SIGNER_FOR_UPDATE = """
+    SELECT * FROM signers
+    WHERE chain_id = :chain_id AND signer_address = :address
+"""
 
 ENSURE_SIGNER_EXISTS = """
     INSERT INTO signers (chain_id, signer_address, next_nonce, last_synced_chain_nonce)
@@ -251,21 +240,13 @@ ENSURE_SIGNER_EXISTS = """
     ON CONFLICT(chain_id, signer_address) DO NOTHING
 """
 
-# Dialect-specific: cleanup orphaned nonces
-CLEANUP_ORPHANED_NONCES = {
-    "postgres": """
-        DELETE FROM nonce_reservations
-        WHERE chain_id = :chain_id
-          AND status = 'orphaned'
-          AND updated_at < NOW() - make_interval(hours => :hours)
-    """,
-    "sqlite": """
-        DELETE FROM nonce_reservations
-        WHERE chain_id = :chain_id
-          AND status = 'orphaned'
-          AND updated_at < datetime('now', :hours_offset)
-    """,
-}
+# Cleanup orphaned nonces (SQLite).
+CLEANUP_ORPHANED_NONCES = """
+    DELETE FROM nonce_reservations
+    WHERE chain_id = :chain_id
+      AND status = 'orphaned'
+      AND updated_at < datetime('now', :hours_offset)
+"""
 
 # =============================================================================
 # Intents
@@ -298,43 +279,24 @@ GET_INTENT_BY_IDEMPOTENCY_KEY = """
       AND idempotency_key = :idempotency_key
 """
 
-# Dialect-specific: claim next intent (uses FOR UPDATE SKIP LOCKED on Postgres)
-CLAIM_NEXT_INTENT = {
-    "postgres": """
-        WITH claimed AS (
-            SELECT intent_id FROM tx_intents
-            WHERE status = 'created'
-            AND (deadline_ts IS NULL OR deadline_ts > CURRENT_TIMESTAMP)
-            AND (retry_after IS NULL OR retry_after <= CURRENT_TIMESTAMP)
-            ORDER BY created_at ASC
-            FOR UPDATE SKIP LOCKED
-            LIMIT 1
-        )
-        UPDATE tx_intents
-        SET status = 'claimed', claim_token = :claim_token,
-            claimed_at = CURRENT_TIMESTAMP, claimed_by = :claimed_by,
-            retry_after = NULL,
-            updated_at = CURRENT_TIMESTAMP
-        WHERE intent_id = (SELECT intent_id FROM claimed)
-        RETURNING *
-    """,
-    "sqlite": """
-        UPDATE tx_intents
-        SET status = 'claimed', claim_token = :claim_token,
-            claimed_at = CURRENT_TIMESTAMP, claimed_by = :claimed_by,
-            retry_after = NULL,
-            updated_at = CURRENT_TIMESTAMP
-        WHERE intent_id = (
-            SELECT intent_id FROM tx_intents
-            WHERE status = 'created'
-            AND (deadline_ts IS NULL OR deadline_ts > CURRENT_TIMESTAMP)
-            AND (retry_after IS NULL OR retry_after <= CURRENT_TIMESTAMP)
-            ORDER BY created_at ASC
-            LIMIT 1
-        )
-        RETURNING *
-    """,
-}
+# Claim next intent (SQLite).
+CLAIM_NEXT_INTENT = """
+    UPDATE tx_intents
+    SET status = 'claimed', claim_token = :claim_token,
+        claimed_at = CURRENT_TIMESTAMP, claimed_by = :claimed_by,
+        lease_expires_at = datetime(CURRENT_TIMESTAMP, :lease_offset),
+        retry_after = NULL,
+        updated_at = CURRENT_TIMESTAMP
+    WHERE intent_id = (
+        SELECT intent_id FROM tx_intents
+        WHERE status = 'created'
+        AND (deadline_ts IS NULL OR deadline_ts > CURRENT_TIMESTAMP)
+        AND (retry_after IS NULL OR retry_after <= CURRENT_TIMESTAMP)
+        ORDER BY created_at ASC
+        LIMIT 1
+    )
+    RETURNING *
+"""
 
 UPDATE_INTENT_STATUS = """
     UPDATE tx_intents
@@ -414,10 +376,12 @@ GET_BACKING_OFF_INTENT_COUNT = """
 CREATE_ATTEMPT = """
     INSERT INTO tx_attempts (
         attempt_id, intent_id, nonce, tx_hash, gas_params_json,
-        status, broadcast_block, broadcast_at, broadcast_group, endpoint_url
+        status, broadcast_block, broadcast_at, broadcast_group, endpoint_url,
+        endpoint_binding_id
     ) VALUES (
         :attempt_id, :intent_id, :nonce, :tx_hash, :gas_params_json,
-        :status, :broadcast_block, :broadcast_at, :broadcast_group, :endpoint_url
+        :status, :broadcast_block, :broadcast_at, :broadcast_group, :endpoint_url,
+        :endpoint_binding_id
     )
     RETURNING *
 """
@@ -562,21 +526,13 @@ LIST_ALL_JOB_LOGS = """
     LIMIT :limit
 """
 
-LIST_LATEST_JOB_LOGS = {
-    "postgres": """
-        SELECT DISTINCT ON (job_id) *
-        FROM job_logs
-        WHERE chain_id = :chain_id
-        ORDER BY job_id, ts DESC
-    """,
-    "sqlite": """
-        SELECT * FROM job_logs l1
-        WHERE chain_id = :chain_id
-        AND ts = (SELECT MAX(ts) FROM job_logs l2
-                  WHERE l2.job_id = l1.job_id AND l2.chain_id = :chain_id)
-        ORDER BY job_id
-    """,
-}
+LIST_LATEST_JOB_LOGS = """
+    SELECT * FROM job_logs l1
+    WHERE chain_id = :chain_id
+    AND ts = (SELECT MAX(ts) FROM job_logs l2
+              WHERE l2.job_id = l1.job_id AND l2.chain_id = :chain_id)
+    ORDER BY job_id
+"""
 
 DELETE_OLD_JOB_LOGS = """
     DELETE FROM job_logs

brawny/db/serialized.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import threading
+from contextlib import contextmanager
+from typing import Any, Iterator
+
+from brawny.model.errors import DatabaseError
+
+
+class SerializedDatabase:
+    """Serialize all DB access with a single process-wide lock."""
+
+    def __init__(self, inner: Any) -> None:
+        self._inner = inner
+        self._lock = threading.RLock()
+        self._closed = False
+
+    @property
+    def dialect(self) -> str:
+        return self._inner.dialect
+
+    def _ensure_open(self) -> None:
+        if self._closed:
+            raise DatabaseError("Database is closed")
+
+    def connect(self) -> None:
+        self._ensure_open()
+        with self._lock:
+            self._ensure_open()
+            self._inner.connect()
+
+    def close(self) -> None:
+        with self._lock:
+            if not self._closed:
+                self._inner.close()
+                self._closed = True
+
+    def is_connected(self) -> bool:
+        if self._closed:
+            return False
+        with self._lock:
+            return self._inner.is_connected()
+
+    @contextmanager
+    def transaction(self, isolation_level: str | None = None) -> Iterator[None]:
+        self._ensure_open()
+        with self._lock:
+            self._ensure_open()
+            with self._inner.transaction(isolation_level):
+                yield
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("_"):
+            raise AttributeError(name)
+        attr = getattr(self._inner, name)
+        if not callable(attr):
+            return attr
+
+        def _wrapped(*args: Any, **kwargs: Any) -> Any:
+            self._ensure_open()
+            with self._lock:
+                self._ensure_open()
+                return attr(*args, **kwargs)
+
+        return _wrapped