beaver-db 0.16.6__py3-none-any.whl → 0.16.8__py3-none-any.whl

beaver/blobs.py

@@ -2,7 +2,7 @@ import json
 import sqlite3
 from typing import Any, Dict, Iterator, NamedTuple, Optional, Type, TypeVar
 
-from .types import JsonSerializable
+from .types import JsonSerializable, IDatabase
 
 
 class Blob[M](NamedTuple):
@@ -16,9 +16,9 @@ class Blob[M](NamedTuple):
 class BlobManager[M]:
     """A wrapper providing a Pythonic interface to a blob store in the database."""
 
-    def __init__(self, name: str, conn: sqlite3.Connection, model: Type[M] | None = None):
+    def __init__(self, name: str, db: IDatabase, model: Type[M] | None = None):
         self._name = name
-        self._conn = conn
+        self._db = db
         self._model = model
 
     def _serialize(self, value: M) -> str | None:
@@ -51,8 +51,8 @@ class BlobManager[M]:
 
         metadata_json = self._serialize(metadata) if metadata else None
 
-        with self._conn:
-            self._conn.execute(
+        with self._db.connection:
+            self._db.connection.execute(
                 "INSERT OR REPLACE INTO beaver_blobs (store_name, key, data, metadata) VALUES (?, ?, ?, ?)",
                 (self._name, key, data, metadata_json),
             )
@@ -67,7 +67,7 @@ class BlobManager[M]:
         Returns:
             A Blob object containing the data and metadata, or None if the key is not found.
         """
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT data, metadata FROM beaver_blobs WHERE store_name = ? AND key = ?",
             (self._name, key),
@@ -90,8 +90,8 @@ class BlobManager[M]:
         Raises:
             KeyError: If the key does not exist in the store.
         """
-        with self._conn:
-            cursor = self._conn.cursor()
+        with self._db.connection:
+            cursor = self._db.connection.cursor()
             cursor.execute(
                 "DELETE FROM beaver_blobs WHERE store_name = ? AND key = ?",
                 (self._name, key),
@@ -103,7 +103,7 @@ class BlobManager[M]:
         """
         Checks if a key exists in the blob store (e.g., `key in blobs`).
         """
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT 1 FROM beaver_blobs WHERE store_name = ? AND key = ? LIMIT 1",
             (self._name, key),
@@ -114,7 +114,7 @@ class BlobManager[M]:
 
     def __iter__(self) -> Iterator[str]:
         """Returns an iterator over the keys in the blob store."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT key FROM beaver_blobs WHERE store_name = ?", (self._name,)
         )

beaver/channels.py

@@ -6,7 +6,7 @@ import time
 from queue import Empty, Queue
 from typing import Any, AsyncIterator, Generic, Iterator, Set, Type, TypeVar
 
-from .types import JsonSerializable
+from .types import JsonSerializable, IDatabase
 
 # A special message object used to signal the listener to gracefully shut down.
 _SHUTDOWN_SENTINEL = object()
@@ -120,14 +120,12 @@ class ChannelManager[T]:
     def __init__(
         self,
         name: str,
-        conn: sqlite3.Connection,
-        db_path: str,
+        db: IDatabase,
         poll_interval: float = 0.1,
         model: Type[T] | None = None,
     ):
         self._name = name
-        self._conn = conn
-        self._db_path = db_path
+        self._db = db
         self._poll_interval = poll_interval
         self._model = model
         self._listeners: Set[Queue] = set()
@@ -197,8 +195,8 @@ class ChannelManager[T]:
 
         Useful for reducing the database once logs are not needed.
         """
-        with self._conn:
-            self._conn.execute("DELETE FROM beaver_pubsub_log WHERE channel_name = ?", (self._name,))
+        with self._db.connection:
+            self._db.connection.execute("DELETE FROM beaver_pubsub_log WHERE channel_name = ?", (self._name,))
 
     def _polling_loop(self):
         """
@@ -208,8 +206,7 @@ class ChannelManager[T]:
         to all registered listener queues.
         """
         # A separate SQLite connection is required for each thread.
-        thread_conn = sqlite3.connect(self._db_path, check_same_thread=False)
-        thread_conn.row_factory = sqlite3.Row
+        thread_conn = self._db.connection
 
         # The poller starts listening for messages from this moment forward.
         last_seen_timestamp = time.time()
@@ -256,8 +253,8 @@ class ChannelManager[T]:
         except TypeError as e:
             raise TypeError("Message payload must be JSON-serializable.") from e
 
-        with self._conn:
-            self._conn.execute(
+        with self._db.connection:
+            self._db.connection.execute(
                 "INSERT INTO beaver_pubsub_log (timestamp, channel_name, message_payload) VALUES (?, ?, ?)",
                 (time.time(), self._name, json_payload),
             )

beaver/collections.py

@@ -4,7 +4,7 @@ import threading
 import uuid
 from enum import Enum
 from typing import Any, Iterator, List, Literal, Tuple, Type, TypeVar
-from .types import Model, stub
+from .types import Model, stub, IDatabase
 
 try:
     import numpy as np
@@ -111,12 +111,12 @@ class CollectionManager[D: Document]:
     FTS, fuzzy search, graph traversal, and persistent vector search.
     """
 
-    def __init__(self, name: str, conn: sqlite3.Connection, model: Type[D] | None = None):
+    def __init__(self, name: str, db: IDatabase, model: Type[D] | None = None):
         self._name = name
-        self._conn = conn
+        self._db = db
         self._model = model or Document
         # All vector-related operations are now delegated to the VectorIndex class.
-        self._vector_index = VectorIndex(name, conn)
+        self._vector_index = VectorIndex(name, db)
         # A lock to ensure only one compaction thread runs at a time for this collection.
         self._compaction_lock = threading.Lock()
         self._compaction_thread: threading.Thread | None = None
@@ -134,7 +134,7 @@ class CollectionManager[D: Document]:
 
     def _needs_compaction(self, threshold: int = 1000) -> bool:
         """Checks if the total number of pending vector operations exceeds the threshold."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT COUNT(*) FROM _beaver_ann_pending_log WHERE collection_name = ?",
             (self._name,)
@@ -199,8 +199,8 @@ class CollectionManager[D: Document]:
         if not isinstance(document, Document):
             raise TypeError("Item to index must be a Document object.")
 
-        with self._conn:
-            cursor = self._conn.cursor()
+        with self._db.connection:
+            cursor = self._db.connection.cursor()
 
             # Step 1: Core Document and Vector Storage
             cursor.execute(
@@ -253,8 +253,8 @@ class CollectionManager[D: Document]:
         """Removes a document and all its associated data from the collection."""
         if not isinstance(document, Document):
             raise TypeError("Item to drop must be a Document object.")
-        with self._conn:
-            cursor = self._conn.cursor()
+        with self._db.connection:
+            cursor = self._db.connection.cursor()
             cursor.execute("DELETE FROM beaver_collections WHERE collection = ? AND item_id = ?", (self._name, document.id))
             cursor.execute("DELETE FROM beaver_fts_index WHERE collection = ? AND item_id = ?", (self._name, document.id))
             cursor.execute("DELETE FROM beaver_trigrams WHERE collection = ? AND item_id = ?", (self._name, document.id))
@@ -271,7 +271,7 @@ class CollectionManager[D: Document]:
 
     def __iter__(self) -> Iterator[D]:
         """Returns an iterator over all documents in the collection."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT item_id, item_vector, metadata FROM beaver_collections WHERE collection = ?",
             (self._name,),
@@ -306,7 +306,7 @@ class CollectionManager[D: Document]:
         placeholders = ",".join("?" for _ in result_ids)
         sql = f"SELECT item_id, item_vector, metadata FROM beaver_collections WHERE collection = ? AND item_id IN ({placeholders})"
 
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         rows = cursor.execute(sql, (self._name, *result_ids)).fetchall()
 
         doc_map = {
@@ -350,7 +350,7 @@ class CollectionManager[D: Document]:
         self, query: str, on: list[str] | None, top_k: int
     ) -> list[tuple[D, float]]:
         """Performs a standard FTS search."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         sql_query = """
             SELECT t1.item_id, t1.item_vector, t1.metadata, fts.rank
             FROM beaver_collections AS t1 JOIN (
@@ -390,7 +390,7 @@ class CollectionManager[D: Document]:
         if similarity_threshold == 0:
             return set()
 
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         sql = """
             SELECT item_id FROM beaver_trigrams
             WHERE collection = ? AND trigram IN ({}) {}
@@ -422,7 +422,7 @@ class CollectionManager[D: Document]:
         if not candidate_ids:
             return []
 
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         id_placeholders = ",".join("?" for _ in candidate_ids)
         sql_text = f"SELECT item_id, field_path, field_content FROM beaver_fts_index WHERE collection = ? AND item_id IN ({id_placeholders})"
         params_text: list[Any] = [self._name]
@@ -480,8 +480,8 @@ class CollectionManager[D: Document]:
         """Creates a directed edge between two documents."""
         if not isinstance(source, Document) or not isinstance(target, Document):
             raise TypeError("Source and target must be Document objects.")
-        with self._conn:
-            self._conn.execute(
+        with self._db.connection:
+            self._db.connection.execute(
                 "INSERT OR REPLACE INTO beaver_edges (collection, source_item_id, target_item_id, label, metadata) VALUES (?, ?, ?, ?, ?)",
                 (
                     self._name,
@@ -500,7 +500,7 @@ class CollectionManager[D: Document]:
             sql += " AND t2.label = ?"
             params.append(label)
 
-        rows = self._conn.cursor().execute(sql, tuple(params)).fetchall()
+        rows = self._db.connection.cursor().execute(sql, tuple(params)).fetchall()
         return [
             self._model(
                 id=row["item_id"],
@@ -549,7 +549,7 @@ class CollectionManager[D: Document]:
         """
         params = [source.id, self._name, depth] + labels + [self._name]
 
-        rows = self._conn.cursor().execute(sql, tuple(params)).fetchall()
+        rows = self._db.connection.cursor().execute(sql, tuple(params)).fetchall()
         return [
             self._model(
                 id=row["item_id"],
@@ -565,7 +565,7 @@ class CollectionManager[D: Document]:
 
     def __len__(self) -> int:
         """Returns the number of documents in the collection."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT COUNT(*) FROM beaver_collections WHERE collection = ?",
             (self._name,),

beaver/core.py

@@ -15,7 +15,7 @@ from .queues import QueueManager
 class BeaverDB:
     """
     An embedded, multi-modal database in a single SQLite file.
-    This class manages the database connection and table schemas.
+    This class manages thread-safe database connections and table schemas.
     """
 
     def __init__(self, db_path: str, timeout:float=30.0):
@@ -26,22 +26,44 @@ class BeaverDB:
             db_path: The path to the SQLite database file.
         """
         self._db_path = db_path
-        # Enable WAL mode for better concurrency between readers and writers
-        self._conn = sqlite3.connect(self._db_path, check_same_thread=False, timeout=timeout)
-        self._conn.execute("PRAGMA journal_mode=WAL;")
-        self._conn.row_factory = sqlite3.Row
+        self._timeout = timeout
+        # This object will store a different connection for each thread.
+        self._thread_local = threading.local()
+
         self._channels: dict[str, ChannelManager] = {}
         self._channels_lock = threading.Lock()
-        # Add a cache and lock for CollectionManager singletons
         self._collections: dict[str, CollectionManager] = {}
         self._collections_lock = threading.Lock()
 
-        # Initialize the schemas
+        # Initialize the schemas. This will implicitly create the first
+        # connection for the main thread via the `connection` property.
         self._create_all_tables()
 
+    @property
+    def connection(self) -> sqlite3.Connection:
+        """
+        Provides a thread-safe SQLite connection.
+
+        Each thread will receive its own dedicated connection object.
+        The connection is created on the first access and then reused for
+        all subsequent calls within the same thread.
+        """
+        # Check if a connection is already stored for this thread
+        conn = getattr(self._thread_local, 'conn', None)
+
+        if conn is None:
+            # No connection for this thread yet, so create one.
+            # We no longer need check_same_thread=False, restoring thread safety.
+            conn = sqlite3.connect(self._db_path, timeout=self._timeout)
+            conn.execute("PRAGMA journal_mode=WAL;")
+            conn.row_factory = sqlite3.Row
+            self._thread_local.conn = conn
+
+        return conn
+
     def _create_all_tables(self):
         """Initializes all required tables in the database file."""
-        with self._conn:
+        with self.connection:
             self._create_ann_deletions_log_table()
             self._create_ann_id_mapping_table()
             self._create_ann_indexes_table()
@@ -60,7 +82,7 @@ class BeaverDB:
 
     def _create_logs_table(self):
         """Creates the table for time-indexed logs."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS beaver_logs (
                 log_name TEXT NOT NULL,
@@ -70,7 +92,7 @@ class BeaverDB:
             )
             """
         )
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE INDEX IF NOT EXISTS idx_logs_timestamp
             ON beaver_logs (log_name, timestamp)
@@ -79,7 +101,7 @@ class BeaverDB:
 
     def _create_blobs_table(self):
         """Creates the table for storing named blobs."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS beaver_blobs (
                 store_name TEXT NOT NULL,
@@ -93,7 +115,7 @@ class BeaverDB:
 
     def _create_ann_indexes_table(self):
         """Creates the table to store the serialized base ANN index."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS _beaver_ann_indexes (
                 collection_name TEXT PRIMARY KEY,
@@ -105,7 +127,7 @@ class BeaverDB:
 
     def _create_ann_pending_log_table(self):
         """Creates the log for new vector additions."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS _beaver_ann_pending_log (
                 collection_name TEXT NOT NULL,
@@ -117,7 +139,7 @@ class BeaverDB:
 
     def _create_ann_deletions_log_table(self):
         """Creates the log for vector deletions (tombstones)."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS _beaver_ann_deletions_log (
                 collection_name TEXT NOT NULL,
@@ -129,7 +151,7 @@ class BeaverDB:
 
     def _create_ann_id_mapping_table(self):
         """Creates the table to map string IDs to integer IDs for Faiss."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS _beaver_ann_id_mapping (
                 collection_name TEXT NOT NULL,
@@ -142,7 +164,7 @@ class BeaverDB:
 
     def _create_priority_queue_table(self):
         """Creates the priority queue table and its performance index."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS beaver_priority_queues (
                 queue_name TEXT NOT NULL,
@@ -152,7 +174,7 @@ class BeaverDB:
             )
             """
         )
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE INDEX IF NOT EXISTS idx_priority_queue_order
             ON beaver_priority_queues (queue_name, priority ASC, timestamp ASC)
@@ -161,7 +183,7 @@ class BeaverDB:
 
     def _create_dict_table(self):
         """Creates the namespaced dictionary table."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS beaver_dicts (
                 dict_name TEXT NOT NULL,
@@ -175,7 +197,7 @@ class BeaverDB:
 
     def _create_pubsub_table(self):
         """Creates the pub/sub log table."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS beaver_pubsub_log (
                 timestamp REAL PRIMARY KEY,
@@ -184,7 +206,7 @@ class BeaverDB:
             )
         """
         )
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE INDEX IF NOT EXISTS idx_pubsub_channel_timestamp
             ON beaver_pubsub_log (channel_name, timestamp)
@@ -193,7 +215,7 @@ class BeaverDB:
 
     def _create_list_table(self):
         """Creates the lists table."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS beaver_lists (
                 list_name TEXT NOT NULL,
@@ -206,7 +228,7 @@ class BeaverDB:
 
     def _create_collections_table(self):
         """Creates the main table for storing documents and vectors."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS beaver_collections (
                 collection TEXT NOT NULL,
@@ -220,7 +242,7 @@ class BeaverDB:
 
     def _create_fts_table(self):
         """Creates the virtual FTS table for full-text search."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE VIRTUAL TABLE IF NOT EXISTS beaver_fts_index USING fts5(
                 collection,
@@ -234,7 +256,7 @@ class BeaverDB:
 
     def _create_trigrams_table(self):
         """Creates the table for the fuzzy search trigram index."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS beaver_trigrams (
                 collection TEXT NOT NULL,
@@ -245,7 +267,7 @@ class BeaverDB:
             )
             """
         )
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE INDEX IF NOT EXISTS idx_trigram_lookup
             ON beaver_trigrams (collection, trigram, field_path)
@@ -254,7 +276,7 @@ class BeaverDB:
 
     def _create_edges_table(self):
         """Creates the table for storing relationships between documents."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS beaver_edges (
                 collection TEXT NOT NULL,
@@ -269,7 +291,7 @@ class BeaverDB:
 
     def _create_versions_table(self):
         """Creates a table to track the version of each collection for caching."""
-        self._conn.execute(
+        self.connection.execute(
             """
             CREATE TABLE IF NOT EXISTS beaver_collection_versions (
                 collection_name TEXT PRIMARY KEY,
@@ -280,12 +302,12 @@ class BeaverDB:
 
     def close(self):
         """Closes the database connection."""
-        if self._conn:
+        if self.connection:
             # Cleanly shut down any active polling threads before closing
             with self._channels_lock:
                 for channel in self._channels.values():
                     channel.close()
-            self._conn.close()
+            self.connection.close()
 
     # --- Factory and Passthrough Methods ---
 
@@ -300,7 +322,7 @@ class BeaverDB:
         if model and not isinstance(model, JsonSerializable):
             raise TypeError("The model parameter must be a JsonSerializable class.")
 
-        return DictManager(name, self._conn, model)
+        return DictManager(name, self, model)
 
     def list[T](self, name: str, model: type[T] | None = None) -> ListManager[T]:
         """
@@ -313,7 +335,7 @@ class BeaverDB:
         if model and not isinstance(model, JsonSerializable):
             raise TypeError("The model parameter must be a JsonSerializable class.")
 
-        return ListManager(name, self._conn, model)
+        return ListManager(name, self, model)
 
     def queue[T](self, name: str, model: type[T] | None = None) -> QueueManager[T]:
         """
@@ -326,7 +348,7 @@ class BeaverDB:
         if model and not isinstance(model, JsonSerializable):
             raise TypeError("The model parameter must be a JsonSerializable class.")
 
-        return QueueManager(name, self._conn, model)
+        return QueueManager(name, self, model)
 
     def collection[D: Document](self, name: str, model: Type[D] | None = None) -> CollectionManager[D]:
         """
@@ -341,7 +363,7 @@ class BeaverDB:
         # of the vector index consistently.
         with self._collections_lock:
             if name not in self._collections:
-                self._collections[name] = CollectionManager(name, self._conn, model=model)
+                self._collections[name] = CollectionManager(name, self, model=model)
 
             return self._collections[name]
 
@@ -355,7 +377,7 @@ class BeaverDB:
         # Use a thread-safe lock to ensure only one Channel object is created per name.
         with self._channels_lock:
             if name not in self._channels:
-                self._channels[name] = ChannelManager(name, self._conn, self._db_path, model=model)
+                self._channels[name] = ChannelManager(name, self, model=model)
             return self._channels[name]
 
     def blobs[M](self, name: str, model: type[M] | None = None) -> BlobManager[M]:
@@ -363,7 +385,7 @@ class BeaverDB:
         if not isinstance(name, str) or not name:
             raise TypeError("Blob store name must be a non-empty string.")
 
-        return BlobManager(name, self._conn, model)
+        return BlobManager(name, self, model)
 
     def log[T](self, name: str, model: type[T] | None = None) -> LogManager[T]:
         """
@@ -376,4 +398,4 @@ class BeaverDB:
         if model and not isinstance(model, JsonSerializable):
             raise TypeError("The model parameter must be a JsonSerializable class.")
 
-        return LogManager(name, self._conn, self._db_path, model)
+        return LogManager(name, self, self._db_path, model)

beaver/dicts.py

@@ -3,15 +3,14 @@ import sqlite3
 import time
 from typing import Any, Iterator, Tuple, Type
 
-from .types import JsonSerializable
-
+from .types import JsonSerializable, IDatabase
 
 class DictManager[T]:
     """A wrapper providing a Pythonic interface to a dictionary in the database."""
 
-    def __init__(self, name: str, conn: sqlite3.Connection, model: Type[T] | None = None):
+    def __init__(self, name: str, db: IDatabase, model: Type[T] | None = None):
         self._name = name
-        self._conn = conn
+        self._db = db
         self._model = model
 
     def _serialize(self, value: T) -> str:
@@ -40,8 +39,8 @@ class DictManager[T]:
                 raise ValueError("ttl_seconds must be a positive integer.")
             expires_at = time.time() + ttl_seconds
 
-        with self._conn:
-            self._conn.execute(
+        with self._db.connection:
+            self._db.connection.execute(
                 "INSERT OR REPLACE INTO beaver_dicts (dict_name, key, value, expires_at) VALUES (?, ?, ?, ?)",
                 (self._name, key, self._serialize(value), expires_at),
             )
@@ -55,7 +54,7 @@ class DictManager[T]:
 
     def __getitem__(self, key: str) -> T:
         """Retrieves a value for a given key, raising KeyError if expired."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT value, expires_at FROM beaver_dicts WHERE dict_name = ? AND key = ?",
             (self._name, key),
@@ -70,7 +69,7 @@ class DictManager[T]:
 
         if expires_at is not None and time.time() > expires_at:
             # Expired: delete the key and raise KeyError
-            with self._conn:
+            with self._db.connection:
                 cursor.execute(
                     "DELETE FROM beaver_dicts WHERE dict_name = ? AND key = ?",
                     (self._name, key),
@@ -94,8 +93,8 @@ class DictManager[T]:
 
     def __delitem__(self, key: str):
         """Deletes a key-value pair (e.g., `del my_dict[key]`)."""
-        with self._conn:
-            cursor = self._conn.cursor()
+        with self._db.connection:
+            cursor = self._db.connection.cursor()
             cursor.execute(
                 "DELETE FROM beaver_dicts WHERE dict_name = ? AND key = ?",
                 (self._name, key),
@@ -105,7 +104,7 @@ class DictManager[T]:
 
     def __len__(self) -> int:
         """Returns the number of items in the dictionary."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT COUNT(*) FROM beaver_dicts WHERE dict_name = ?", (self._name,)
         )
@@ -119,7 +118,7 @@ class DictManager[T]:
 
     def keys(self) -> Iterator[str]:
         """Returns an iterator over the dictionary's keys."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT key FROM beaver_dicts WHERE dict_name = ?", (self._name,)
         )
@@ -129,7 +128,7 @@ class DictManager[T]:
 
     def values(self) -> Iterator[T]:
         """Returns an iterator over the dictionary's values."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT value FROM beaver_dicts WHERE dict_name = ?", (self._name,)
         )
@@ -139,7 +138,7 @@ class DictManager[T]:
 
     def items(self) -> Iterator[Tuple[str, T]]:
         """Returns an iterator over the dictionary's items (key-value pairs)."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT key, value FROM beaver_dicts WHERE dict_name = ?", (self._name,)
         )

beaver/lists.py

@@ -2,15 +2,15 @@ import json
 import sqlite3
 from typing import Any, Iterator, Type, Union
 
-from .types import JsonSerializable
+from .types import JsonSerializable, IDatabase
 
 
 class ListManager[T]:
     """A wrapper providing a Pythonic, full-featured interface to a list in the database."""
 
-    def __init__(self, name: str, conn: sqlite3.Connection, model: Type[T] | None = None):
+    def __init__(self, name: str, db: IDatabase, model: Type[T] | None = None):
         self._name = name
-        self._conn = conn
+        self._db = db
         self._model = model
 
     def _serialize(self, value: T) -> str:
@@ -27,7 +27,7 @@ class ListManager[T]:
 
     def __len__(self) -> int:
         """Returns the number of items in the list (e.g., `len(my_list)`)."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT COUNT(*) FROM beaver_lists WHERE list_name = ?", (self._name,)
         )
@@ -40,7 +40,7 @@ class ListManager[T]:
         Retrieves an item or slice from the list (e.g., `my_list[0]`, `my_list[1:3]`).
         """
         if isinstance(key, slice):
-            with self._conn:
+            with self._db.connection:
                 start, stop, step = key.indices(len(self))
                 if step != 1:
                     raise ValueError("Slicing with a step is not supported.")
@@ -49,7 +49,7 @@ class ListManager[T]:
                 if limit <= 0:
                     return []
 
-                cursor = self._conn.cursor()
+                cursor = self._db.connection.cursor()
                 cursor.execute(
                     "SELECT item_value FROM beaver_lists WHERE list_name = ? ORDER BY item_order ASC LIMIT ? OFFSET ?",
                     (self._name, limit, start),
@@ -59,14 +59,14 @@ class ListManager[T]:
                 return results
 
         elif isinstance(key, int):
-            with self._conn:
+            with self._db.connection:
                 list_len = len(self)
                 if key < -list_len or key >= list_len:
                     raise IndexError("List index out of range.")
 
                 offset = key if key >= 0 else list_len + key
 
-                cursor = self._conn.cursor()
+                cursor = self._db.connection.cursor()
                 cursor.execute(
                     "SELECT item_value FROM beaver_lists WHERE list_name = ? ORDER BY item_order ASC LIMIT 1 OFFSET ?",
                     (self._name, offset),
@@ -83,14 +83,14 @@ class ListManager[T]:
         if not isinstance(key, int):
             raise TypeError("List indices must be integers.")
 
-        with self._conn:
+        with self._db.connection:
             list_len = len(self)
             if key < -list_len or key >= list_len:
                 raise IndexError("List index out of range.")
 
             offset = key if key >= 0 else list_len + key
 
-            cursor = self._conn.cursor()
+            cursor = self._db.connection.cursor()
             # Find the rowid of the item to update
             cursor.execute(
                 "SELECT rowid FROM beaver_lists WHERE list_name = ? ORDER BY item_order ASC LIMIT 1 OFFSET ?",
@@ -112,14 +112,14 @@ class ListManager[T]:
         if not isinstance(key, int):
             raise TypeError("List indices must be integers.")
 
-        with self._conn:
+        with self._db.connection:
             list_len = len(self)
             if key < -list_len or key >= list_len:
                 raise IndexError("List index out of range.")
 
             offset = key if key >= 0 else list_len + key
 
-            cursor = self._conn.cursor()
+            cursor = self._db.connection.cursor()
             # Find the rowid of the item to delete
             cursor.execute(
                 "SELECT rowid FROM beaver_lists WHERE list_name = ? ORDER BY item_order ASC LIMIT 1 OFFSET ?",
@@ -135,7 +135,7 @@ class ListManager[T]:
 
     def __iter__(self) -> Iterator[T]:
         """Returns an iterator for the list."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT item_value FROM beaver_lists WHERE list_name = ? ORDER BY item_order ASC",
             (self._name,)
@@ -146,7 +146,7 @@ class ListManager[T]:
 
     def __contains__(self, value: T) -> bool:
         """Checks for the existence of an item in the list (e.g., `'item' in my_list`)."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT 1 FROM beaver_lists WHERE list_name = ? AND item_value = ? LIMIT 1",
             (self._name, self._serialize(value))
@@ -161,7 +161,7 @@ class ListManager[T]:
 
     def _get_order_at_index(self, index: int) -> float:
         """Helper to get the float `item_order` at a specific index."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT item_order FROM beaver_lists WHERE list_name = ? ORDER BY item_order ASC LIMIT 1 OFFSET ?",
             (self._name, index),
@@ -176,8 +176,8 @@ class ListManager[T]:
 
     def push(self, value: T):
         """Pushes an item to the end of the list."""
-        with self._conn:
-            cursor = self._conn.cursor()
+        with self._db.connection:
+            cursor = self._db.connection.cursor()
             cursor.execute(
                 "SELECT MAX(item_order) FROM beaver_lists WHERE list_name = ?",
                 (self._name,),
@@ -192,8 +192,8 @@ class ListManager[T]:
 
     def prepend(self, value: T):
         """Prepends an item to the beginning of the list."""
-        with self._conn:
-            cursor = self._conn.cursor()
+        with self._db.connection:
+            cursor = self._db.connection.cursor()
             cursor.execute(
                 "SELECT MIN(item_order) FROM beaver_lists WHERE list_name = ?",
                 (self._name,),
@@ -208,7 +208,7 @@ class ListManager[T]:
 
     def insert(self, index: int, value: T):
         """Inserts an item at a specific index."""
-        with self._conn:
+        with self._db.connection:
             list_len = len(self)
             if index <= 0:
                 self.prepend(value)
@@ -222,15 +222,15 @@ class ListManager[T]:
             order_after = self._get_order_at_index(index)
             new_order = order_before + (order_after - order_before) / 2.0
 
-            self._conn.execute(
+            self._db.connection.execute(
                 "INSERT INTO beaver_lists (list_name, item_order, item_value) VALUES (?, ?, ?)",
                 (self._name, new_order, self._serialize(value)),
             )
 
     def pop(self) -> T | None:
         """Removes and returns the last item from the list."""
-        with self._conn:
-            cursor = self._conn.cursor()
+        with self._db.connection:
+            cursor = self._db.connection.cursor()
             cursor.execute(
                 "SELECT rowid, item_value FROM beaver_lists WHERE list_name = ? ORDER BY item_order DESC LIMIT 1",
                 (self._name,),
@@ -247,8 +247,8 @@ class ListManager[T]:
 
     def deque(self) -> T | None:
         """Removes and returns the first item from the list."""
-        with self._conn:
-            cursor = self._conn.cursor()
+        with self._db.connection:
+            cursor = self._db.connection.cursor()
             cursor.execute(
                 "SELECT rowid, item_value FROM beaver_lists WHERE list_name = ? ORDER BY item_order ASC LIMIT 1",
                 (self._name,),

beaver/logs.py

@@ -8,7 +8,7 @@ from datetime import datetime, timedelta, timezone
 from queue import Empty, Queue
 from typing import Any, AsyncIterator, Callable, Iterator, Type, TypeVar
 
-from .types import JsonSerializable
+from .types import JsonSerializable, IDatabase
 
 
 # A special message object used to signal the iterator to gracefully shut down.
@@ -23,14 +23,14 @@ class LiveIterator[T,R]:
 
     def __init__(
         self,
-        db_path: str,
+        db: IDatabase,
         log_name: str,
         window: timedelta,
         period: timedelta,
         aggregator: Callable[[list[T]], R],
         deserializer: Callable[[str], T],
     ):
-        self._db_path = db_path
+        self._db = db
         self._log_name = log_name
         self._window_duration_seconds = window.total_seconds()
         self._sampling_period_seconds = period.total_seconds()
@@ -43,9 +43,7 @@ class LiveIterator[T,R]:
     def _polling_loop(self):
         """The main loop for the background thread that queries and aggregates data."""
         # Each thread needs its own database connection.
-        thread_conn = sqlite3.connect(self._db_path, check_same_thread=False)
-        thread_conn.row_factory = sqlite3.Row
-
+        thread_conn = self._db.connection
         window_deque: collections.deque[tuple[float, T]] = collections.deque()
         last_seen_timestamp = 0.0
 
@@ -179,13 +177,11 @@ class LogManager[T]:
     def __init__(
         self,
         name: str,
-        conn: sqlite3.Connection,
-        db_path: str,
+        db,
         model: Type[T] | None = None,
     ):
         self._name = name
-        self._conn = conn
-        self._db_path = db_path
+        self._db = db
         self._model = model
 
     def _serialize(self, value: T) -> str:
@@ -215,8 +211,8 @@ class LogManager[T]:
         ts = timestamp or datetime.now(timezone.utc)
         ts_float = ts.timestamp()
 
-        with self._conn:
-            self._conn.execute(
+        with self._db.connection:
+            self._db.connection.execute(
                 "INSERT INTO beaver_logs (log_name, timestamp, data) VALUES (?, ?, ?)",
                 (self._name, ts_float, self._serialize(data)),
             )
@@ -235,7 +231,7 @@ class LogManager[T]:
         start_ts = start.timestamp()
         end_ts = end.timestamp()
 
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT data FROM beaver_logs WHERE log_name = ? AND timestamp BETWEEN ? AND ? ORDER BY timestamp ASC",
             (self._name, start_ts, end_ts),
@@ -265,7 +261,7 @@ class LogManager[T]:
             An iterator that yields the results of the aggregator.
         """
         return LiveIterator(
-            db_path=self._db_path,
+            db=self._db,
             log_name=self._name,
             window=window,
             period=period,

beaver/queues.py

@@ -4,7 +4,7 @@ import sqlite3
 import time
 from typing import Any, Literal, NamedTuple, Type, overload
 
-from .types import JsonSerializable
+from .types import JsonSerializable, IDatabase
 
 
 class QueueItem[T](NamedTuple):
@@ -25,6 +25,12 @@ class AsyncQueueManager[T]:
         """Asynchronously adds an item to the queue with a specific priority."""
         await asyncio.to_thread(self._queue.put, data, priority)
 
+    async def peek(self) -> QueueItem[T] | None:
+        """
+        Asynchronously returns the first item without removing it, if any, otherwise returns None.
+        """
+        return await asyncio.to_thread(self._queue.peek)
+
     @overload
     async def get(self, block: Literal[True] = True, timeout: float | None = None) -> QueueItem[T]: ...
     @overload
@@ -44,9 +50,9 @@ class QueueManager[T]:
     producer-consumer priority queue.
     """
 
-    def __init__(self, name: str, conn: sqlite3.Connection, model: Type[T] | None = None):
+    def __init__(self, name: str, db: IDatabase, model: Type[T] | None = None):
         self._name = name
-        self._conn = conn
+        self._db = db
         self._model = model
 
     def _serialize(self, value: T) -> str:
@@ -71,19 +77,19 @@ class QueueManager[T]:
             data: The JSON-serializable data to store.
             priority: The priority of the item (lower numbers are higher priority).
         """
-        with self._conn:
-            self._conn.execute(
+        with self._db.connection:
+            self._db.connection.execute(
                 "INSERT INTO beaver_priority_queues (queue_name, priority, timestamp, data) VALUES (?, ?, ?, ?)",
                 (self._name, priority, time.time(), self._serialize(data)),
             )
 
-    def _get_item_atomically(self) -> QueueItem[T] | None:
+    def _get_item_atomically(self, pop:bool=True) -> QueueItem[T] | None:
         """
         Performs a single, atomic attempt to retrieve and remove the
         highest-priority item from the queue. Returns None if the queue is empty.
         """
-        with self._conn:
-            cursor = self._conn.cursor()
+        with self._db.connection:
+            cursor = self._db.connection.cursor()
             cursor.execute(
                 """
                 SELECT rowid, priority, timestamp, data
@@ -100,11 +106,20 @@ class QueueManager[T]:
                 return None
 
             rowid, priority, timestamp, data = result
-            cursor.execute("DELETE FROM beaver_priority_queues WHERE rowid = ?", (rowid,))
 
-            return QueueItem(
-                priority=priority, timestamp=timestamp, data=self._deserialize(data)
-            )
+            if pop:
+                self._db.connection.execute("DELETE FROM beaver_priority_queues WHERE rowid = ?", (rowid,))
+
+        return QueueItem(
+            priority=priority, timestamp=timestamp, data=self._deserialize(data)
+        )
+
+    def peek(self) -> QueueItem[T] | None:
+        """
+        Retrieves the first item of the queue.
+        If the queue is empy, returns None.
+        """
+        return self._get_item_atomically(pop=False)
 
     @overload
     def get(self, block: Literal[True] = True, timeout: float | None = None) -> QueueItem[T]: ...
@@ -154,7 +169,7 @@ class QueueManager[T]:
 
     def __len__(self) -> int:
         """Returns the current number of items in the queue."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT COUNT(*) FROM beaver_priority_queues WHERE queue_name = ?",
             (self._name,),

beaver/types.py

@@ -1,4 +1,5 @@
 import json
+import sqlite3
 from typing import Protocol, Type, runtime_checkable, Self
 
 
@@ -49,3 +50,9 @@ def stub(msg: str):
             raise TypeError(msg)
 
     return Stub()
+
+
+class IDatabase(Protocol):
+    @property
+    def connection(self) -> sqlite3.Connection:
+        ...

beaver/vectors.py

@@ -3,6 +3,8 @@ import sqlite3
 import threading
 from typing import Dict, List, Set, Tuple
 
+from .types import IDatabase
+
 try:
     import faiss
     import numpy as np
@@ -23,12 +25,12 @@ class VectorIndex:
     user-provided string IDs to the internal integer IDs required by Faiss.
     """
 
-    def __init__(self, collection_name: str, conn: sqlite3.Connection):
+    def __init__(self, collection_name: str, db: IDatabase):
         """
         Initializes the VectorIndex for a specific collection.
         """
-        self._collection_name = collection_name
-        self._conn = conn
+        self._collection = collection_name
+        self._db = db
         # A lock to ensure thread safety for in-memory operations and synchronization checks.
         self._lock = threading.Lock()
         # Tracks the overall version of the collection this instance is aware of.
@@ -66,7 +68,7 @@ class VectorIndex:
             elif self._dimension != dim:
                 # If a dimension is already set, all subsequent vectors must match.
                 raise ValueError(
-                    f"Vector dimension mismatch for collection '{self._collection_name}'. "
+                    f"Vector dimension mismatch for collection '{self._collection}'. "
                     f"Expected {self._dimension}, but got {dim}."
                 )
 
@@ -83,12 +85,12 @@ class VectorIndex:
         # INSERT OR IGNORE is an atomic and safe way to create a new mapping only if it's missing.
         cursor.execute(
             "INSERT OR IGNORE INTO _beaver_ann_id_mapping (collection_name, str_id) VALUES (?, ?)",
-            (self._collection_name, str_id)
+            (self._collection, str_id)
         )
         # Retrieve the now-guaranteed-to-exist integer ID.
         cursor.execute(
             "SELECT int_id FROM _beaver_ann_id_mapping WHERE collection_name = ? AND str_id = ?",
-            (self._collection_name, str_id)
+            (self._collection, str_id)
         )
         result = cursor.fetchone()
         if not result:
@@ -103,20 +105,20 @@ class VectorIndex:
 
     def _get_db_version(self) -> int:
         """Gets the current overall version of the collection from the database."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT version FROM beaver_collection_versions WHERE collection_name = ?",
-            (self._collection_name,),
+            (self._collection,),
         )
         result = cursor.fetchone()
         return result[0] if result else 0
 
     def _get_db_base_index_version(self) -> int:
         """Gets the version of the persistent on-disk base index from the database."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT base_index_version FROM _beaver_ann_indexes WHERE collection_name = ?",
-            (self._collection_name,),
+            (self._collection,),
         )
         result = cursor.fetchone()
         return result[0] if result else 0
@@ -146,10 +148,10 @@ class VectorIndex:
 
     def _load_id_mappings(self):
         """Loads the complete str <-> int ID mapping from the DB into in-memory caches."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT str_id, int_id FROM _beaver_ann_id_mapping WHERE collection_name = ?",
-            (self._collection_name,)
+            (self._collection,)
         )
         # Fetch all mappings at once for efficiency.
         all_mappings = cursor.fetchall()
@@ -158,10 +160,10 @@ class VectorIndex:
 
     def _load_base_index(self):
         """Loads and deserializes the persistent base index from the database BLOB."""
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         cursor.execute(
             "SELECT index_data, base_index_version FROM _beaver_ann_indexes WHERE collection_name = ?",
-            (self._collection_name,),
+            (self._collection,),
         )
         result = cursor.fetchone()
         if result and result["index_data"]:
@@ -184,11 +186,11 @@ class VectorIndex:
         "Catches up" to changes by rebuilding the in-memory delta index and
         deletion set from the database logs.
         """
-        cursor = self._conn.cursor()
+        cursor = self._db.connection.cursor()
         # Sync the set of deleted integer IDs.
         cursor.execute(
             "SELECT int_id FROM _beaver_ann_deletions_log WHERE collection_name = ?",
-            (self._collection_name,)
+            (self._collection,)
         )
         self._deleted_int_ids = {row["int_id"] for row in cursor.fetchall()}
 
@@ -200,7 +202,7 @@ class VectorIndex:
             JOIN beaver_collections c ON p.str_id = c.item_id AND p.collection_name = c.collection
             WHERE p.collection_name = ?
             """,
-            (self._collection_name,)
+            (self._collection,)
         )
         pending_items = cursor.fetchall()
 
@@ -216,7 +218,7 @@ class VectorIndex:
             if vectors.ndim == 1:
                 vectors = vectors.reshape(-1, self._dimension)
             if vectors.shape[1] != self._dimension:
-                raise ValueError(f"Inconsistent vector dimensions in pending log for '{self._collection_name}'.")
+                raise ValueError(f"Inconsistent vector dimensions in pending log for '{self._collection}'.")
 
             # Rebuild the delta index from scratch with all current pending items.
             self._delta_index = faiss.IndexIDMap(faiss.IndexFlatL2(self._dimension))
@@ -238,7 +240,7 @@ class VectorIndex:
         # Add the string ID to the log for other processes to sync.
         cursor.execute(
             "INSERT OR IGNORE INTO _beaver_ann_pending_log (collection_name, str_id) VALUES (?, ?)",
-            (self._collection_name, item_id),
+            (self._collection, item_id),
         )
         # Create the delta index if this is the first item added.
         if self._delta_index is None:
@@ -260,7 +262,7 @@ class VectorIndex:
             # Add the integer ID to the deletion log.
             cursor.execute(
                 "INSERT INTO _beaver_ann_deletions_log (collection_name, int_id) VALUES (?, ?)",
-                (self._collection_name, int_id),
+                (self._collection, int_id),
             )
             # Also add to the live in-memory deletion set.
             self._deleted_int_ids.add(int_id)
@@ -323,10 +325,10 @@ class VectorIndex:
             if self._dimension is None: return # Nothing to compact.
 
         # Step 1: Take a snapshot of the logs. This defines the scope of this compaction run.
-        cursor = self._conn.cursor()
-        cursor.execute("SELECT str_id FROM _beaver_ann_pending_log WHERE collection_name = ?", (self._collection_name,))
+        cursor = self._db.connection.cursor()
+        cursor.execute("SELECT str_id FROM _beaver_ann_pending_log WHERE collection_name = ?", (self._collection,))
         pending_str_ids = {row["str_id"] for row in cursor.fetchall()}
-        cursor.execute("SELECT int_id FROM _beaver_ann_deletions_log WHERE collection_name = ?", (self._collection_name,))
+        cursor.execute("SELECT int_id FROM _beaver_ann_deletions_log WHERE collection_name = ?", (self._collection,))
         deleted_int_ids_snapshot = {row["int_id"] for row in cursor.fetchall()}
 
         deleted_str_ids_snapshot = {self._int_to_str_id[int_id] for int_id in deleted_int_ids_snapshot if int_id in self._int_to_str_id}
@@ -334,11 +336,11 @@ class VectorIndex:
         # Step 2: Fetch all vectors from the main table that haven't been marked for deletion.
         # This is the long-running part that happens "offline" in a background thread.
         if not deleted_str_ids_snapshot:
-            cursor.execute("SELECT item_id, item_vector FROM beaver_collections WHERE collection = ?", (self._collection_name,))
+            cursor.execute("SELECT item_id, item_vector FROM beaver_collections WHERE collection = ?", (self._collection,))
         else:
             cursor.execute(
                 f"SELECT item_id, item_vector FROM beaver_collections WHERE collection = ? AND item_id NOT IN ({','.join('?' for _ in deleted_str_ids_snapshot)})",
-                (self._collection_name, *deleted_str_ids_snapshot)
+                (self._collection, *deleted_str_ids_snapshot)
             )
 
         all_valid_vectors = cursor.fetchall()
@@ -361,16 +363,16 @@ class VectorIndex:
             index_data = buffer.getvalue()
 
         # Step 5: Perform the atomic swap in the database. This is a fast, transactional write.
-        with self._conn:
+        with self._db.connection:
             # Increment the overall collection version to signal a change.
-            self._conn.execute("INSERT INTO beaver_collection_versions (collection_name, version) VALUES (?, 1) ON CONFLICT(collection_name) DO UPDATE SET version = version + 1", (self._collection_name,))
+            self._db.connection.execute("INSERT INTO beaver_collection_versions (collection_name, version) VALUES (?, 1) ON CONFLICT(collection_name) DO UPDATE SET version = version + 1", (self._collection,))
             new_version = self._get_db_version()
 
             # Update the on-disk base index and its version number.
-            self._conn.execute("INSERT INTO _beaver_ann_indexes (collection_name, index_data, base_index_version) VALUES (?, ?, ?) ON CONFLICT(collection_name) DO UPDATE SET index_data = excluded.index_data, base_index_version = excluded.base_index_version", (self._collection_name, index_data, new_version))
+            self._db.connection.execute("INSERT INTO _beaver_ann_indexes (collection_name, index_data, base_index_version) VALUES (?, ?, ?) ON CONFLICT(collection_name) DO UPDATE SET index_data = excluded.index_data, base_index_version = excluded.base_index_version", (self._collection, index_data, new_version))
 
             # Atomically clear the log entries that were included in this compaction run.
             if pending_str_ids:
-                self._conn.execute(f"DELETE FROM _beaver_ann_pending_log WHERE collection_name = ? AND str_id IN ({','.join('?' for _ in pending_str_ids)})", (self._collection_name, *pending_str_ids))
+                self._db.connection.execute(f"DELETE FROM _beaver_ann_pending_log WHERE collection_name = ? AND str_id IN ({','.join('?' for _ in pending_str_ids)})", (self._collection, *pending_str_ids))
             if deleted_int_ids_snapshot:
-                self._conn.execute(f"DELETE FROM _beaver_ann_deletions_log WHERE collection_name = ? AND int_id IN ({','.join('?' for _ in deleted_int_ids_snapshot)})", (self._collection_name, *deleted_int_ids_snapshot))
+                self._db.connection.execute(f"DELETE FROM _beaver_ann_deletions_log WHERE collection_name = ? AND int_id IN ({','.join('?' for _ in deleted_int_ids_snapshot)})", (self._collection, *deleted_int_ids_snapshot))

{beaver_db-0.16.6.dist-info → beaver_db-0.16.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beaver-db
-Version: 0.16.6
+Version: 0.16.8
 Summary: Fast, embedded, and multi-modal DB based on SQLite for AI-powered applications.
 License-File: LICENSE
 Classifier: License :: OSI Approved :: MIT License
@@ -26,6 +26,8 @@ A fast, single-file, multi-modal database for Python, built with the standard `s
 
 `beaver` is the **B**ackend for **E**mbedded, **A**ll-in-one **V**ector, **E**ntity, and **R**elationship storage. It's a simple, local, and embedded database designed to manage complex, modern data types without requiring a database server, built on top of SQLite.
 
+> If you like beaver's minimalist, no-bullshit philosophy, check out [castor](https://github.com/apiad/castor) for an equally minimalistic approach to task orchestration.
+
 ## Design Philosophy
 
 `beaver` is built with a minimalistic philosophy for small, local use cases where a full-blown database server would be overkill.

beaver_db-0.16.8.dist-info/RECORD

@@ -0,0 +1,15 @@
+beaver/__init__.py,sha256=qyEzF1Os7w4b4Hijgz0Y0R4zTrRBrHIGT1mEkZFl2YM,101
+beaver/blobs.py,sha256=YkIEskHD6oHRaJTF0P25HrTT8LqM-REyV_UBPVQxeqQ,4055
+beaver/channels.py,sha256=kIuwKMDBdDQObaKT23znsMXzfpKfE7pXSxvf-u4LlpY,9554
+beaver/collections.py,sha256=Wm684pGp-E89PCq9gcbbmRC9VMtTxolRVXnrxKlw2m8,24615
+beaver/core.py,sha256=68vjuEbkJTHv4SltCLCrgs34BpLCeL602oJZ6CJ34Zo,14560
+beaver/dicts.py,sha256=Xp8lPfQt08O8zCbptQLWQLO79OxG6uAVER6ryj3SScQ,5495
+beaver/lists.py,sha256=rfJ8uTNLkMREYc0uGx0z1VKt2m3eR9hvbdvDD58EbmQ,10140
+beaver/logs.py,sha256=a5xenwl5NZeegIU0dWVEs67lvaHzzw-JRAZtEzNNO3E,9529
+beaver/queues.py,sha256=Fr3oie63EtceSoiC8EOEDSLu1tDI8q2MYLXd8MEeC3g,6476
+beaver/types.py,sha256=WZLINf7hy6zdKdAFQK0EVMSl5vnY_KnrHXNdXgAKuPg,1582
+beaver/vectors.py,sha256=qvI6RwUOGrhVH5d6PUmI3jKDaoDotMy0iy-bHyvmXks,18496
+beaver_db-0.16.8.dist-info/METADATA,sha256=SN90Fv3zk6_Xa38nkVDdWNr6mifgnfi_6dJtfEeg7PA,18240
+beaver_db-0.16.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+beaver_db-0.16.8.dist-info/licenses/LICENSE,sha256=1xrIY5JnMk_QDQzsqmVzPIIyCgZAkWCC8kF2Ddo1UT0,1071
+beaver_db-0.16.8.dist-info/RECORD,,

beaver_db-0.16.6.dist-info/RECORD

@@ -1,15 +0,0 @@
-beaver/__init__.py,sha256=qyEzF1Os7w4b4Hijgz0Y0R4zTrRBrHIGT1mEkZFl2YM,101
-beaver/blobs.py,sha256=5cmcvlJLY9jaftIRuNbdEryZxI47sw_pYpysYli23NY,3996
-beaver/channels.py,sha256=VBXJDw_be-bSY76kRVzFdMZFoy4CepSMwJACc9NJgpc,9658
-beaver/collections.py,sha256=860bYpchokjleDIebJaNU1jcGTCMIbg0t4MasEVVbOk,24486
-beaver/core.py,sha256=t_UzpqcbF2U8BjmQ9aIWTvUzPuVuOLcPzTrZQ2htjn4,13706
-beaver/dicts.py,sha256=1BQ9A_cMkJ7l5ayWbDG-4Wi3WtQ-9BKd7Wj_CB7dGlU,5410
-beaver/lists.py,sha256=Q7xjyReBWFg47nBrXbt09GvBJkEmXvpW9ptL9xCnXC8,9946
-beaver/logs.py,sha256=mlJizZU0emlqLwuNeBJSPlict35Vyi35L4eIl5orv-M,9673
-beaver/queues.py,sha256=IQoeNhcYrVZTuH_4bWhtiEa-EYbFx_2iVKkR254XPnE,5953
-beaver/types.py,sha256=bR1bfLgemcySy9mnVL_hxAtog4wN8EmgfF2OonOWjQA,1464
-beaver/vectors.py,sha256=grwiRdusa39s-J9c8nK8LO7duhuYTaLR2Az6wHKs4rU,18487
-beaver_db-0.16.6.dist-info/METADATA,sha256=8SDSyQv8WgaEmMXIzWLvSr8EoQjj82457-rdINHnprY,18068
-beaver_db-0.16.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-beaver_db-0.16.6.dist-info/licenses/LICENSE,sha256=1xrIY5JnMk_QDQzsqmVzPIIyCgZAkWCC8kF2Ddo1UT0,1071
-beaver_db-0.16.6.dist-info/RECORD,,