collections-cache 0.2.2__tar.gz → 2025.3.3__tar.gz

{collections_cache-0.2.2 → collections_cache-2025.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: collections-cache
-Version: 0.2.2
+Version: 2025.3.3
 Summary: collections-cache is a Python package for managing data collections across multiple SQLite databases. It allows efficient storage, retrieval, and updating of key-value pairs, supporting various data types serialized with pickle. The package uses parallel processing for fast access and manipulation of large collections.
 License: MIT
 Author: Luiz-Trindade

{collections_cache-0.2.2 → collections_cache-2025.3.3}/collections_cache/collections_cache.py

@@ -3,8 +3,8 @@ import sqlite3
 from random import choice
 from itertools import chain
 from os import cpu_count, path, makedirs, scandir
-#from concurrent.futures import ProcessPoolExecutor as Pool
-from concurrent.futures import ThreadPoolExecutor as Pool
+from concurrent.futures import ProcessPoolExecutor as Pool
+from concurrent.futures import ThreadPoolExecutor as Thread
 
 class Collection_Cache:
     def __init__(self, collection_name):
@@ -14,12 +14,14 @@ class Collection_Cache:
         self.collection_dir         = path.join("./Collections", self.collection_name)
         self.databases_list         = []
         self.keys_databases         = {}
+
         # Init methods
         self.create_collection()
         self.get_all_databases()
 
     def create_collection(self):
         makedirs(self.collection_dir, exist_ok=True)
+
         for core in range(self.cpu_cores):
             db_path = path.join(self.collection_dir, f"database_{core}.db")
             self.initialize_databases(db_path)
@@ -38,6 +40,7 @@ class Collection_Cache:
     def get_all_databases(self):
         with scandir(self.collection_dir) as contents:
             self.databases_list = [path.join(self.collection_dir, content.name) for content in contents]
+
         with Pool(self.cpu_cores) as pool:
             self.keys_databases = dict(chain.from_iterable(pool.map(self.get_all_keys, self.databases_list)))
 
@@ -62,6 +65,7 @@ class Collection_Cache:
             conn.commit()
             conn.close()
             self.add_to_keys_database(key, database_to_insert)
+
         else:
             database_to_update = self.keys_databases[key]
             conn = sqlite3.connect(database_to_update)
@@ -73,19 +77,22 @@ class Collection_Cache:
 
     def set_multi_keys(self, keys_and_values: dict[str, any]):
         """Experimental. Set multiple keys and values at the same time."""
-        with Pool(self.cpu_cores) as pool:
-            pool.map(lambda kv: self.set_key(kv[0], kv[1]), keys_and_values.items())
+
+        with Thread(self.cpu_cores) as thread:
+            thread.map(lambda kv: self.set_key(kv[0], kv[1]), keys_and_values.items())
 
     def add_to_keys_database(self, key, database):
         self.keys_databases[key] = database
 
     def delete_to_keys_database(self, key):
         """Removes the key from the dictionary of stored keys"""
+
         if key in self.keys_databases:
             del self.keys_databases[key]
 
     def get_key(self, key: str):
         """Used to obtain the value stored by the key"""
+
         try:
             database_to_search = self.keys_databases[key]
             conn = sqlite3.connect(database_to_search)
@@ -95,11 +102,13 @@ class Collection_Cache:
             result = cursor.fetchall()
             conn.close()
             return pickle.loads(result[0][0])
+
         except Exception as error:
             return error
 
     def delete_key(self, key: str):
         """Used to delete the value stored by the key"""
+
         try:
             database_to_delete = self.keys_databases[key]
             conn = sqlite3.connect(database_to_delete)
@@ -109,19 +118,23 @@ class Collection_Cache:
             conn.commit()
             conn.close()
             self.delete_to_keys_database(key)
+
         except KeyError:
             return f"Key '{key}' not found."
+
         except Exception as error:
             return error
 
     def configure_connection(self, conn):
-        conn.execute("PRAGMA auto_vacuum = FULL;")
-        conn.execute("PRAGMA journal_mode = WAL;")
-        conn.execute("PRAGMA synchronous = NORMAL;")
-        conn.execute("PRAGMA wal_autocheckpoint = 1000;")
-        conn.execute("PRAGMA cache_size = -2000;")
-        conn.execute("PRAGMA temp_store = MEMORY;")
-        conn.execute("PRAGMA optimize;")
+        conn.executescript("""
+            PRAGMA auto_vacuum = FULL;
+            PRAGMA journal_mode = WAL;
+            PRAGMA synchronous = NORMAL;
+            PRAGMA wal_autocheckpoint = 1000;
+            PRAGMA cache_size = -2000;
+            PRAGMA temp_store = MEMORY;
+            PRAGMA optimize;
+        """)
 
     def keys(self):
         """Returns all stored keys"""

{collections_cache-0.2.2 → collections_cache-2025.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "collections-cache"
-version = "0.2.2"
+version = "2025.3.3"
 description = "collections-cache is a Python package for managing data collections across multiple SQLite databases. It allows efficient storage, retrieval, and updating of key-value pairs, supporting various data types serialized with pickle. The package uses parallel processing for fast access and manipulation of large collections."
 authors = ["Luiz-Trindade <luiz.gabriel.m.trindade@gmail.com>"]
 license = "MIT"