collections-cache 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

collections_cache/collections_cache.py

@@ -1,28 +1,25 @@
+import pickle
 import sqlite3
-#from multiprocessing import Pool
-from os import cpu_count, path, makedirs, scandir
-from itertools import chain
 from random import choice
-#from threading import Thread as task
-import pickle
-from concurrent.futures import ProcessPoolExecutor as Pool
+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
 
 class Collection_Cache:
     def __init__(self, collection_name):
+        # Variables
         self.collection_name        = collection_name
         self.cpu_cores              = cpu_count()
         self.collection_dir         = path.join("./Collections", self.collection_name)
         self.databases_list         = []
         self.keys_databases         = {}
-
-        #print(f"Collection '{self.collection_name}' created!")
-        #print(f"Number of cpu cores: {self.cpu_cores}")
+        # 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)
@@ -30,7 +27,6 @@ class Collection_Cache:
     def initialize_databases(self, db_path):
         conn = sqlite3.connect(db_path)
         self.configure_connection(conn)
-        #conn.execute("PRAGMA journal_mode=WAL;")
         conn.execute("""
             CREATE TABLE IF NOT EXISTS data(
                 key     TEXT,
@@ -40,103 +36,92 @@ class Collection_Cache:
         conn.close()
 
     def get_all_databases(self):
-        #print("Obtaining all keys...")
         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)))
-        #print(self.keys_databases)
 
     def get_all_keys(self, database):
         conn    = sqlite3.connect(database)
         self.configure_connection(conn)
         cursor  = conn.cursor()
-        #cursor.execute("PRAGMA journal_mode=WAL;")
         cursor.execute("SELECT key FROM data;")
         result  = cursor.fetchall()
         keys    = [(line[0], database) for line in result]
         conn.close()
         return keys
 
-    def set_key(self, key, value):
+    def set_key(self, key: str, value: any):
         """Used to store values and associate a value with a key."""
         if key not in self.keys_databases:
             database_to_insert = choice(self.databases_list)
-            #print(f"Inserting in {database_to_insert}")
             conn = sqlite3.connect(database_to_insert)
             self.configure_connection(conn)
             cursor = conn.cursor()
-            #cursor.execute("PRAGMA journal_mode=WAL;")
             cursor.execute("INSERT INTO data(key, value) VALUES (?, ?);", (key, pickle.dumps(value)))
             conn.commit()
             conn.close()
             self.add_to_keys_database(key, database_to_insert)
-
         else:
-            #print(f"Updating key '{key}' in {self.keys_databases[key]}...")
             database_to_update = self.keys_databases[key]
             conn = sqlite3.connect(database_to_update)
             self.configure_connection(conn)
             cursor = conn.cursor()
-            #cursor.execute("PRAGMA journal_mode=WAL;")
             cursor.execute("UPDATE data SET value = ? WHERE key = ?;", (pickle.dumps(value), key))
             conn.commit()
             conn.close()
-            #print(f"Key '{key}' updated successfully in {database_to_update}")
+
+    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())
 
     def add_to_keys_database(self, key, database):
         self.keys_databases[key] = database
-        #print(self.keys_databases)
 
     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):
+    def get_key(self, key: str):
         """Used to obtain the value stored by the key"""
         try:
             database_to_search = self.keys_databases[key]
-            #print(database_to_search)
-
             conn = sqlite3.connect(database_to_search)
             self.configure_connection(conn)
             cursor = conn.cursor()
-            #cursor.execute("PRAGMA journal_mode=WAL;")
             cursor.execute("SELECT value FROM data WHERE key = ?", (key,))
             result = cursor.fetchall()
             conn.close()
             return pickle.loads(result[0][0])
-            
         except Exception as error:
             return error
 
-    def delete_key(self, key):
+    def delete_key(self, key: str):
         """Used to delete the value stored by the key"""
         try:
             database_to_delete = self.keys_databases[key]
-            #print(database_to_search)
-
             conn = sqlite3.connect(database_to_delete)
             self.configure_connection(conn)
             cursor = conn.cursor()
-            #cursor.execute("PRAGMA journal_mode=WAL;")
             cursor.execute("DELETE FROM data WHERE key = ?", (key,))
             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;")
 
     def keys(self):
         """Returns all stored keys"""

{collections_cache-0.2.0.dist-info → collections_cache-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: collections-cache
-Version: 0.2.0
+Version: 0.2.2
 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
@@ -63,7 +63,8 @@ print(products)  # Output: ['apple', 'orange', 'onion']
 
 ### Methods  
 
-- **`set_key(key, value)`**: Stores a key-value pair in the cache. If the key already exists, its value is updated.  
+- **`set_key(key, value)`**: Stores a key-value pair in the cache. If the key already exists, its value is updated.
+- **`set_multi_keys(key_and_value)`**: Stores a multi key-value pair in the cache. If the key already exists, its value is updated.  
 - **`get_key(key)`**: Retrieves the value associated with a key.  
 - **`delete_key(key)`**: Removes an existing key from the cache.  
 - **`keys`***: Returns all stored keys.

collections_cache-0.2.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+collections_cache/__init__.py,sha256=uUp8lhp-HnZRumnU_8MT6qVq95t0pOzn7oLW7ARbnvc,48
+collections_cache/collections_cache.py,sha256=8780rRG8U2R90Yit8k7Xu-yK5U-QAHY8vpoG6Q2FL8E,5126
+collections_cache-0.2.2.dist-info/LICENSE,sha256=RAIL-FmXSiNRgyiVlfhm2SvVI4XDVsN0jDt9207SJ8o,1168
+collections_cache-0.2.2.dist-info/METADATA,sha256=cMJlG1baO1jdptLgbN-enSI09rMBcFEJMtkhLrnwj6o,3408
+collections_cache-0.2.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+collections_cache-0.2.2.dist-info/RECORD,,

collections_cache-0.2.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-collections_cache/__init__.py,sha256=uUp8lhp-HnZRumnU_8MT6qVq95t0pOzn7oLW7ARbnvc,48
-collections_cache/collections_cache.py,sha256=c9RRmaObGEBu63BdxL3e6nYrtZh6SUsTpBUWIeWRgwk,5518
-collections_cache-0.2.0.dist-info/LICENSE,sha256=RAIL-FmXSiNRgyiVlfhm2SvVI4XDVsN0jDt9207SJ8o,1168
-collections_cache-0.2.0.dist-info/METADATA,sha256=lihDcWlsHWqD-oQMYZn1Cq7TShlBEEhRakL3s2B_OHE,3276
-collections_cache-0.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-collections_cache-0.2.0.dist-info/RECORD,,