beaver-db 0.9.2__py3-none-any.whl → 0.11.0__py3-none-any.whl

beaver/vectors.py

@@ -0,0 +1,370 @@
+import io
+import sqlite3
+import threading
+from typing import Dict, List, Set, Tuple
+
+import faiss
+import numpy as np
+
+class VectorIndex:
+    """
+    Manages a persistent, high-performance hybrid vector index for a single collection.
+
+    This class handles the complexities of a two-tiered index system (a large, on-disk
+    base index and a small, in-memory delta index), crash-safe logging for additions
+    and deletions, and multi-process synchronization. The vector dimension is inferred
+    from the first vector indexed and then enforced. It also transparently maps
+    user-provided string IDs to the internal integer IDs required by Faiss.
+    """
+
+    def __init__(self, collection_name: str, conn: sqlite3.Connection):
+        """
+        Initializes the VectorIndex for a specific collection.
+        """
+        self._collection_name = collection_name
+        self._conn = conn
+        # 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.
+        self._local_version = -1
+        # Tracks the specific version of the on-disk base index this instance has loaded.
+        self._local_base_index_version = -1
+
+        # In-memory components
+        # The dimension of the vectors in this collection. Inferred from the first vector.
+        self._dimension: int | None = None
+        # The large, persistent Faiss index loaded from the database BLOB.
+        self._base_index: faiss.Index | None = None
+        # The small, in-memory Faiss index for newly added vectors ("delta").
+        self._delta_index: faiss.IndexIDMap | None = None
+        # A set of integer IDs for vectors that have been deleted but not yet compacted.
+        self._deleted_int_ids: Set[int] = set()
+
+        # In-memory caches for the bidirectional mapping between user-facing string IDs
+        # and Faiss's internal integer IDs.
+        self._str_to_int_id: Dict[str, int] = {}
+        self._int_to_str_id: Dict[int, str] = {}
+
+    def _infer_and_validate_dimension(self, vector: np.ndarray):
+        """
+        Infers the vector dimension from the first operation and validates
+        subsequent vectors against it. This ensures data consistency.
+        """
+        # Get the last element of the shape tuple, which is the dimension.
+        dim = vector.shape[-1]
+        with self._lock:
+            if self._dimension is None:
+                # If this is the first vector we've seen, establish its dimension
+                # as the official dimension for this entire collection.
+                self._dimension = dim
+            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"Expected {self._dimension}, but got {dim}."
+                )
+
+    def _get_or_create_int_id(self, str_id: str, cursor: sqlite3.Cursor) -> int:
+        """
+        Retrieves the integer ID for a string ID, creating it if it doesn't exist.
+        This must be called within a transaction to be atomic.
+        """
+        # First, check our fast in-memory cache.
+        if str_id in self._str_to_int_id:
+            return self._str_to_int_id[str_id]
+
+        # If not in cache, get it from the database, creating it if necessary.
+        # 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)
+        )
+        # 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)
+        )
+        result = cursor.fetchone()
+        if not result:
+             # This case should be virtually impossible given the logic above.
+            raise RuntimeError(f"Failed to create or retrieve int_id for {str_id}")
+
+        int_id = result["int_id"]
+        # Update our in-memory caches for future calls.
+        self._str_to_int_id[str_id] = int_id
+        self._int_to_str_id[int_id] = str_id
+        return int_id
+
+    def _get_db_version(self) -> int:
+        """Gets the current overall version of the collection from the database."""
+        cursor = self._conn.cursor()
+        cursor.execute(
+            "SELECT version FROM beaver_collection_versions WHERE collection_name = ?",
+            (self._collection_name,),
+        )
+        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.execute(
+            "SELECT base_index_version FROM _beaver_ann_indexes WHERE collection_name = ?",
+            (self._collection_name,),
+        )
+        result = cursor.fetchone()
+        return result[0] if result else 0
+
+    def _check_and_sync(self):
+        """
+        Checks if the in-memory state is stale compared to the database and performs
+        a fast, targeted sync if needed. This is the core of multi-process consistency.
+        """
+        db_version = self._get_db_version()
+        if self._local_version < db_version:
+            # Acquire a lock to prevent race conditions from multiple threads in the same process.
+            with self._lock:
+                # Double-checked locking: re-check the condition inside the lock.
+                if self._local_version < db_version:
+                    db_base_version = self._get_db_base_index_version()
+                    # Always reload the ID mappings as they can change on any write.
+                    self._load_id_mappings()
+                    # Only perform the expensive reload of the base index if a compaction
+                    # has occurred in another process.
+                    if self._local_base_index_version < db_base_version or self._base_index is None:
+                        self._load_base_index()
+                    # Always sync the lightweight delta and deletion logs.
+                    self._sync_delta_index_and_deletions()
+                    # Update our local version to match the database, marking us as "up-to-date".
+                    self._local_version = db_version
+
+    def _load_id_mappings(self):
+        """Loads the complete str <-> int ID mapping from the DB into in-memory caches."""
+        cursor = self._conn.cursor()
+        cursor.execute(
+            "SELECT str_id, int_id FROM _beaver_ann_id_mapping WHERE collection_name = ?",
+            (self._collection_name,)
+        )
+        # Fetch all mappings at once for efficiency.
+        all_mappings = cursor.fetchall()
+        self._str_to_int_id = {row["str_id"]: row["int_id"] for row in all_mappings}
+        self._int_to_str_id = {v: k for k, v in self._str_to_int_id.items()}
+
+    def _load_base_index(self):
+        """Loads and deserializes the persistent base index from the database BLOB."""
+        cursor = self._conn.cursor()
+        cursor.execute(
+            "SELECT index_data, base_index_version FROM _beaver_ann_indexes WHERE collection_name = ?",
+            (self._collection_name,),
+        )
+        result = cursor.fetchone()
+        if result and result["index_data"]:
+            # The index is stored as bytes; we use an in-memory buffer to read it.
+            buffer = io.BytesIO(result["index_data"])
+            # Use Faiss's IO reader to deserialize the index from the buffer.
+            reader = faiss.PyCallbackIOReader(buffer.read)
+            self._base_index = faiss.read_index(reader)
+            self._local_base_index_version = result["base_index_version"]
+            # If the dimension is unknown, we can infer it from the loaded index.
+            if self._dimension is None and self._base_index.ntotal > 0:
+                self._dimension = self._base_index.d
+        else:
+            # If no base index exists in the DB yet.
+            self._base_index = None
+            self._local_base_index_version = result["base_index_version"] if result else 0
+
+    def _sync_delta_index_and_deletions(self):
+        """
+        "Catches up" to changes by rebuilding the in-memory delta index and
+        deletion set from the database logs.
+        """
+        cursor = self._conn.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._deleted_int_ids = {row["int_id"] for row in cursor.fetchall()}
+
+        # Get all vectors that are in the pending log.
+        cursor.execute(
+            """
+            SELECT p.str_id, c.item_vector
+            FROM _beaver_ann_pending_log p
+            JOIN beaver_collections c ON p.str_id = c.item_id AND p.collection_name = c.collection
+            WHERE p.collection_name = ?
+            """,
+            (self._collection_name,)
+        )
+        pending_items = cursor.fetchall()
+
+        if pending_items:
+            # Convert fetched data into numpy arrays.
+            vectors = np.array([np.frombuffer(row["item_vector"], dtype=np.float32) for row in pending_items])
+            if self._dimension is None:
+                self._dimension = vectors[0].shape[-1]
+
+            item_int_ids = np.array([self._str_to_int_id[row["str_id"]] for row in pending_items], dtype=np.int64)
+
+            # Reshape and validate dimensions for consistency.
+            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}'.")
+
+            # Rebuild the delta index from scratch with all current pending items.
+            self._delta_index = faiss.IndexIDMap(faiss.IndexFlatL2(self._dimension))
+            self._delta_index.add_with_ids(vectors, item_int_ids)
+        else:
+            # If there are no pending items, there's no delta index.
+            self._delta_index = None
+
+    def index(self, item_id: str, vector: np.ndarray, cursor: sqlite3.Cursor):
+        """
+        Logs a vector for future persistence and adds it to the in-memory delta index.
+        This method must be called within a transaction managed by CollectionManager.
+        """
+        # Enforce dimension consistency for the incoming vector.
+        self._infer_and_validate_dimension(vector)
+        # Get or create the persistent integer ID for this string ID.
+        int_id = self._get_or_create_int_id(item_id, cursor)
+
+        # 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),
+        )
+        # Create the delta index if this is the first item added.
+        if self._delta_index is None:
+            self._delta_index = faiss.IndexIDMap(faiss.IndexFlatL2(self._dimension))
+
+        # Add the vector to the live in-memory delta index for immediate searchability.
+        vector_2d = vector.reshape(1, -1).astype(np.float32)
+        item_id_arr = np.array([int_id], dtype=np.int64)
+        self._delta_index.add_with_ids(vector_2d, item_id_arr)
+
+    def drop(self, item_id: str, cursor: sqlite3.Cursor):
+        """
+        Logs a document ID for deletion ("tombstone"). This must be called
+        within a transaction managed by CollectionManager.
+        """
+        # Get the corresponding integer ID from our in-memory cache.
+        int_id = self._str_to_int_id.get(item_id)
+        if int_id is not None:
+            # 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),
+            )
+            # Also add to the live in-memory deletion set.
+            self._deleted_int_ids.add(int_id)
+
+    def search(self, vector: np.ndarray, top_k: int) -> List[Tuple[str, float]]:
+        """
+        Performs a hybrid search and returns results with original string IDs.
+        """
+        # Validate the query vector and ensure our in-memory state is up-to-date.
+        self._infer_and_validate_dimension(vector)
+        self._check_and_sync()
+
+        query_vector = vector.reshape(1, -1).astype(np.float32)
+        all_distances: List[float] = []
+        all_ids: List[int] = []
+
+        # Search the large, persistent base index if it exists.
+        if self._base_index and self._base_index.ntotal > 0:
+            distances, int_ids = self._base_index.search(query_vector, top_k)
+            all_distances.extend(distances[0])
+            all_ids.extend(int_ids[0])
+
+        # Search the small, in-memory delta index if it exists.
+        if self._delta_index and self._delta_index.ntotal > 0:
+            distances, int_ids = self._delta_index.search(query_vector, top_k)
+            all_distances.extend(distances[0])
+            all_ids.extend(int_ids[0])
+
+        if not all_ids:
+            return []
+
+        # Combine results from both indexes and sort by distance.
+        results = sorted(zip(all_distances, all_ids), key=lambda x: x[0])
+
+        # Filter the results to remove duplicates and deleted items.
+        final_results: List[Tuple[str, float]] = []
+        seen_ids = set()
+        for dist, int_id in results:
+            # Faiss uses -1 for invalid IDs.
+            if int_id != -1 and int_id not in self._deleted_int_ids and int_id not in seen_ids:
+                # Map the internal integer ID back to the user's string ID.
+                str_id = self._int_to_str_id.get(int_id)
+                if str_id:
+                    final_results.append((str_id, dist))
+                    seen_ids.add(int_id)
+                    # Stop once we have enough results.
+                    if len(final_results) == top_k:
+                        break
+
+        return final_results
+
+    def compact(self):
+        """
+        (Background Task) Rebuilds the base index from the main collection,
+        incorporating all pending additions and permanently applying deletions.
+        """
+        # If the dimension is unknown, try to learn it from the logs before proceeding.
+        if self._dimension is None:
+            self._check_and_sync()
+            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,))
+        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,))
+        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}
+
+        # 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,))
+        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)
+            )
+
+        all_valid_vectors = cursor.fetchall()
+
+        # Step 3: Build the new, clean base index in memory.
+        if not all_valid_vectors:
+            new_index = None
+        else:
+            int_ids = np.array([self._str_to_int_id[row["item_id"]] for row in all_valid_vectors], dtype=np.int64)
+            vectors = np.array([np.frombuffer(row["item_vector"], dtype=np.float32) for row in all_valid_vectors])
+            new_index = faiss.IndexIDMap(faiss.IndexFlatL2(self._dimension))
+            new_index.add_with_ids(vectors, int_ids)
+
+        # Step 4: Serialize the newly built index to a byte buffer.
+        index_data = None
+        if new_index:
+            buffer = io.BytesIO()
+            writer = faiss.PyCallbackIOWriter(buffer.write)
+            faiss.write_index(new_index, writer)
+            index_data = buffer.getvalue()
+
+        # Step 5: Perform the atomic swap in the database. This is a fast, transactional write.
+        with self._conn:
+            # 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,))
+            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))
+
+            # 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))
+            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))

{beaver_db-0.9.2.dist-info → beaver_db-0.11.0.dist-info}/METADATA

@@ -1,14 +1,16 @@
 Metadata-Version: 2.4
 Name: beaver-db
-Version: 0.9.2
+Version: 0.11.0
 Summary: Fast, embedded, and multi-modal DB based on SQLite for AI-powered applications.
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: faiss-cpu>=1.12.0
 Requires-Dist: numpy>=2.3.3
-Requires-Dist: scipy>=1.16.2
 Dynamic: license-file
 
+Of course, here is a rewritten README to explain the vector store uses a high performance FAISS-based implementation with in-memory and persistent indices, with an added small section on how is this implemented to explain the basic ideas behind the implementation of beaver.
+
 # beaver 🦫
 
 A fast, single-file, multi-modal database for Python, built with the standard `sqlite3` library.
@@ -19,10 +21,11 @@ A fast, single-file, multi-modal database for Python, built with the standard `s
 
 `beaver` is built with a minimalistic philosophy for small, local use cases where a full-blown database server would be overkill.
 
-  - **Minimalistic & Zero-Dependency**: Uses only Python's standard libraries (`sqlite3`) and `numpy`/`scipy`.
-  - **Synchronous & Thread-Safe**: Designed for simplicity and safety in multi-threaded environments.
+  - **Minimalistic**: Uses only Python's standard libraries (`sqlite3`) and `numpy`/`faiss-cpu`.
+  - **Schemaless**: Flexible data storage without rigid schemas across all modalities.
+  - **Synchronous, Multi-Process, and Thread-Safe**: Designed for simplicity and safety in multi-threaded and multi-process environments.
   - **Built for Local Applications**: Perfect for local AI tools, RAG prototypes, chatbots, and desktop utilities that need persistent, structured data without network overhead.
-  - **Fast by Default**: It's built on SQLite, which is famously fast and reliable for local applications. The vector search is accelerated with an in-memory k-d tree.
+  - **Fast by Default**: It's built on SQLite, which is famously fast and reliable for local applications. Vector search is accelerated with a high-performance, persistent `faiss` index.
   - **Standard Relational Interface**: While `beaver` provides high-level features, you can always use the same SQLite file for normal relational tasks with standard SQL.
 
 ## Core Features
@@ -31,11 +34,28 @@ A fast, single-file, multi-modal database for Python, built with the standard `s
   - **Namespaced Key-Value Dictionaries**: A Pythonic, dictionary-like interface for storing any JSON-serializable object within separate namespaces with optional TTL for cache implementations.
   - **Pythonic List Management**: A fluent, Redis-like interface for managing persistent, ordered lists.
   - **Persistent Priority Queue**: A high-performance, persistent queue that always returns the item with the highest priority, perfect for task management.
-  - **Efficient Vector Storage & Search**: Store vector embeddings and perform fast approximate nearest neighbor searches using an in-memory k-d tree.
-  - **Full-Text Search**: Automatically index and search through document metadata using SQLite's powerful FTS5 engine.
-  - **Graph Traversal**: Create relationships between documents and traverse the graph to find neighbors or perform multi-hop walks.
+  - **High-Performance Vector Storage & Search**: Store vector embeddings and perform fast, crash-safe approximate nearest neighbor searches using a `faiss`-based hybrid index.
+  - **Full-Text and Fuzzy Search**: Automatically index and search through document metadata using SQLite's powerful FTS5 engine, enhanced with optional fuzzy search for typo-tolerant matching.
+  - **Knowledge Graph**: Create relationships between documents and traverse the graph to find neighbors or perform multi-hop walks.
   - **Single-File & Portable**: All data is stored in a single SQLite file, making it incredibly easy to move, back up, or embed in your application.
 
+## How Beaver is Implemented
+
+BeaverDB is architected as a set of targeted wrappers around a standard SQLite database. The core `BeaverDB` class manages a single connection to the SQLite file and initializes all the necessary tables for the various features.
+
+When you call a method like `db.dict("my_dict")` or `db.collection("my_docs")`, you get back a specialized manager object (`DictManager`, `CollectionManager`, etc.) that provides a clean, Pythonic API for that specific data modality. These managers translate the simple method calls (e.g., `my_dict["key"] = "value"`) into the appropriate SQL queries, handling all the complexity of data serialization, indexing, and transaction management behind the scenes. This design provides a minimal and intuitive API surface while leveraging the power and reliability of SQLite.
+
+The vector store in BeaverDB is designed for high performance and reliability, using a hybrid faiss-based index that is both fast and persistent. Here's a look at the core ideas behind its implementation:
+
+- **Hybrid Index System**: The vector store uses a two-tiered system to balance fast writes with efficient long-term storage:
+- **Base Index**: A large, optimized faiss index that contains the majority of the vectors. This index is serialized and stored as a BLOB inside a dedicated SQLite table, ensuring it remains part of the single database file.
+- **Delta Index**: A small, in-memory faiss index that holds all newly added vectors. This allows for near-instant write performance without having to rebuild the entire index for every new addition.
+- **Crash-Safe Logging**: To ensure durability, all new vector additions and deletions are first recorded in a dedicated log table in the SQLite database. This means that even if the application crashes, no data is lost.
+- **Automatic Compaction**: When the number of changes in the log reaches a certain threshold, a background process is automatically triggered to "compact" the index. This process rebuilds the base index, incorporating all the recent changes from the delta index, and then clears the log. This ensures that the index remains optimized for fast search performance over time.
+
+This hybrid approach allows BeaverDB to provide a vector search experience that is both fast and durable, without sacrificing the single-file, embedded philosophy of the library.
+
+
 ## Installation
 
 ```bash
@@ -135,7 +155,7 @@ for message in chat_history:
 
 ### 4. Build a RAG (Retrieval-Augmented Generation) System
 
-Combine **vector search** and **full-text search** to build a powerful RAG pipeline for your local documents.
+Combine **vector search** and **full-text search** to build a powerful RAG pipeline for your local documents. The vector search uses a high-performance, persistent `faiss` index that supports incremental additions without downtime.
 
 ```python
 # Get context for a user query like "fast python web frameworks"
@@ -194,14 +214,15 @@ For more in-depth examples, check out the scripts in the `examples/` directory:
   - [`examples/publisher.py`](examples/publisher.py) and [`examples/subscriber.py`](examples/subscriber.py): A pair of examples demonstrating inter-process message passing with the publish/subscribe system.
   - [`examples/cache.py`](examples/cache.py): A practical example of using a dictionary with TTL as a cache for API calls.
   - [`examples/rerank.py`](examples/rerank.py): Shows how to combine results from vector and text search for more refined results.
+  - [`examples/fuzzy.py`](examples/fuzzy.py): Demonstrates fuzzy search capabilities for text search.
+  - [`examples/stress_vectors.py](examples/stress_vectors.py): A stress test for the vector search functionality.
+  - [`examples/general_test.py`](examples/general_test.py): A general-purpose test to run all operations randomly which allows testing long-running processes and synchronicity issues.
 
 ## Roadmap
 
 These are some of the features and improvements planned for future releases:
 
-  - **Fuzzy search**: Implement fuzzy matching capabilities for text search.
-  - **Faster ANN**: Explore integrating more advanced ANN libraries like `faiss` for improved vector search performance.
-  - **Async API**: Comprehensive async support with on-demand wrappers for all collections.
+  - **Full Async API**: Comprehensive async support with on-demand wrappers for all collections.
 
 Check out the [roadmap](roadmap.md) for a detailed list of upcoming features and design ideas.
 

beaver_db-0.11.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+beaver/__init__.py,sha256=-z5Gj6YKMOswpJOOn5Gej8z5i6k3c0Xs00DIYLA-bMI,75
+beaver/channels.py,sha256=jKL1sVLOe_Q_pP0q1-iceZbPe8FOi0EwqJtOMOe96f4,8675
+beaver/collections.py,sha256=CXWB8xlyazdJpnhizRkmGmLdN3yt3M2BYNFwr2Ijbas,23896
+beaver/core.py,sha256=BQsYUA99U2ZT8mXbkBidzVpmTI9KPaF19efASCHCXyM,10569
+beaver/dicts.py,sha256=y4z632XKWU29ekP_vdFSOP-MAG9Z8b79kBEHA88gO7E,4463
+beaver/lists.py,sha256=jFlDWwyaYycG0ZFVm58rMChefUaVZhaP1UeQ-hVo3Sg,9082
+beaver/queues.py,sha256=WKpBzlXr9Hp_rOKEs_Y1Tjyj_hWx6ql1uBRKBV7rw8w,2780
+beaver/vectors.py,sha256=j7RL2Y_xMAF2tPTi6E2LdJqZerSQXlnEQJOGZkefTsA,18358
+beaver_db-0.11.0.dist-info/licenses/LICENSE,sha256=1xrIY5JnMk_QDQzsqmVzPIIyCgZAkWCC8kF2Ddo1UT0,1071
+beaver_db-0.11.0.dist-info/METADATA,sha256=QjYGU-36h-e8EhVMmrLq2UKhFUBKFROEHw6ouPVsqE4,12928
+beaver_db-0.11.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+beaver_db-0.11.0.dist-info/top_level.txt,sha256=FxA4XnX5Qm5VudEXCduFriqi4dQmDWpQ64d7g69VQKI,7
+beaver_db-0.11.0.dist-info/RECORD,,

beaver_db-0.9.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-beaver/__init__.py,sha256=-z5Gj6YKMOswpJOOn5Gej8z5i6k3c0Xs00DIYLA-bMI,75
-beaver/channels.py,sha256=jKL1sVLOe_Q_pP0q1-iceZbPe8FOi0EwqJtOMOe96f4,8675
-beaver/collections.py,sha256=R4bVmP37s_ZnCkb3Jdck2H8dRvD3-ihFV4mEsA14YeE,15716
-beaver/core.py,sha256=l5hI55vc2VlF1b_a6CP7ZP5r7H-MQdTNV4zr2lSumcs,7864
-beaver/dicts.py,sha256=y4z632XKWU29ekP_vdFSOP-MAG9Z8b79kBEHA88gO7E,4463
-beaver/lists.py,sha256=jFlDWwyaYycG0ZFVm58rMChefUaVZhaP1UeQ-hVo3Sg,9082
-beaver/queues.py,sha256=WKpBzlXr9Hp_rOKEs_Y1Tjyj_hWx6ql1uBRKBV7rw8w,2780
-beaver_db-0.9.2.dist-info/licenses/LICENSE,sha256=1xrIY5JnMk_QDQzsqmVzPIIyCgZAkWCC8kF2Ddo1UT0,1071
-beaver_db-0.9.2.dist-info/METADATA,sha256=vUT6BRbtpQ-lY_FatTiNx2z8ZaxDwOepFPuhF-NRHvA,9725
-beaver_db-0.9.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-beaver_db-0.9.2.dist-info/top_level.txt,sha256=FxA4XnX5Qm5VudEXCduFriqi4dQmDWpQ64d7g69VQKI,7
-beaver_db-0.9.2.dist-info/RECORD,,