features

Author: EugeneSukharev1988

montycat/store_classes/inmemory.py

@@ -9,7 +9,7 @@ class inmemory_kv:
     @classmethod
     async def _run_query(cls, query: str):
         return await send_data(cls.host, cls.port, query)
-    
+
     @classmethod
     async def do_snaphots_for_keyspace(cls):
         """
@@ -22,15 +22,15 @@ async def do_snaphots_for_keyspace(cls):
 
         query = orjson.dumps({
             "raw": [
-                "do-snapshots-for-keyspace", 
-                "store", cls.store, 
-                "keyspace", cls.keyspace, 
+                "do-snapshots-for-keyspace",
+                "store", cls.store,
+                "keyspace", cls.keyspace,
                 ],
             "credentials": [cls.username, cls.password]
         })
 
         return await cls._run_query(query)
-    
+
     @classmethod
     async def clean_snapshots_for_keyspace(cls):
         """
@@ -182,16 +182,20 @@ async def insert_bulk(cls, bulk_values: list, expire_sec: int = 0):
         return await cls._run_query(query)
 
     @classmethod
-    async def get_keys(cls):
+    async def get_keys(cls, volumes: list = [], latest_volume: bool = False):
         """
         Get all keys in the store.
 
         Returns:
             A list of keys in the store. Class 'str' if the get operation failed.
         """
+
+        if latest_volume and len(volumes) > 0:
+            raise ValueError("Select either latest volume or volumes list, not both.")
+
         cls.command = "get_keys"
 
-        query = convert_to_binary_query(cls)
+        query = convert_to_binary_query(cls, volumes=volumes, latest_volume=latest_volume)
         return await cls._run_query(query)
 
     @classmethod

montycat/store_classes/kv.py

@@ -100,7 +100,7 @@ async def remove_enforced_schema(cls, schema):
         return await cls._run_query(query)
 
     @classmethod
-    async def get_value(cls, key: Union[str, None] = None, custom_key: Union[str, None] = None, with_pointers: bool = False):
+    async def get_value(cls, key: Union[str, None] = None, custom_key: Union[str, None] = None, with_pointers: bool = False, key_included: bool = False, pointers_metadata: bool = False):
 
         """
         Args:
@@ -110,6 +110,9 @@ async def get_value(cls, key: Union[str, None] = None, custom_key: Union[str, No
         Returns:
             The value associated with the key or custom key. Class 'str' if the get operation failed.
         """
+        if pointers_metadata and with_pointers:
+            raise ValueError("You select both pointers value and pointers metadata. Choose one")
+
         if custom_key and len(custom_key) > 0:
             key = convert_custom_key(custom_key)
 
@@ -118,7 +121,7 @@ async def get_value(cls, key: Union[str, None] = None, custom_key: Union[str, No
 
         cls.command = "get_value"
 
-        query = convert_to_binary_query(cls, key=key, with_pointers=with_pointers)
+        query = convert_to_binary_query(cls, key=key, with_pointers=with_pointers, key_included=key_included, pointers_metadata=pointers_metadata)
         return await cls._run_query(query)
 
     @classmethod
@@ -167,6 +170,7 @@ async def delete_bulk(cls, bulk_keys: list = [], bulk_custom_keys: list = []):
 
         Raises:
             ValueError: If both `bulk_keys` and `bulk_custom_keys` are empty.
+            ValueError: If both `pointers_metadata` and `with_pointers` are True.
         """
         if len(bulk_custom_keys) > 0:
             bulk_custom_keys = convert_custom_keys(bulk_custom_keys)
@@ -180,7 +184,7 @@ async def delete_bulk(cls, bulk_keys: list = [], bulk_custom_keys: list = []):
         return await cls._run_query(query)  # Execute the query and return the result
 
     @classmethod
-    async def get_bulk(cls, bulk_keys: list = [], bulk_custom_keys: list = [], limit: list = [], with_pointers: bool = False):
+    async def get_bulk(cls, bulk_keys: list = [], bulk_custom_keys: list = [], limit: list = [], with_pointers: bool = False, key_included: bool = False, pointers_metadata: bool = False):
         """
         Retrieve multiple keys in bulk. Custom keys can be converted and added to the bulk retrieval list.
         Additionally, a limit on the number of records to retrieve can be applied, and whether to include pointers 
@@ -202,7 +206,12 @@ async def get_bulk(cls, bulk_keys: list = [], bulk_custom_keys: list = [], limit
 
         Raises:
             ValueError: If both `bulk_keys` and `bulk_custom_keys` are empty.
+            ValueError: If both `pointers_metadata` and `with_pointers` are True.
         """
+
+        if pointers_metadata and with_pointers:
+            raise ValueError("You select both pointers value and pointers metadata. Choose one")
+
         if len(bulk_custom_keys) > 0:
             bulk_custom_keys = convert_custom_keys(bulk_custom_keys)  # Convert custom keys if provided
             bulk_keys += bulk_custom_keys
@@ -212,7 +221,7 @@ async def get_bulk(cls, bulk_keys: list = [], bulk_custom_keys: list = [], limit
 
         cls.command = "get_bulk"
         cls.limit_output = handle_limit(limit)
-        query = convert_to_binary_query(cls, bulk_keys=bulk_keys, with_pointers=with_pointers)
+        query = convert_to_binary_query(cls, bulk_keys=bulk_keys, with_pointers=with_pointers, key_included=key_included, pointers_metadata=pointers_metadata)
         return await cls._run_query(query)
 
     @classmethod
@@ -276,7 +285,7 @@ async def lookup_keys_where(cls, limit: Union[int, list] = 0, schema: Union[str,
         return await cls._run_query(query)
 
     @classmethod
-    async def lookup_values_where(cls, limit: Union[int, list] = 0, with_pointers: bool = False, schema: Union[str, None] = None, **filters):
+    async def lookup_values_where(cls, limit: Union[int, list] = 0, with_pointers: bool = False, key_included: bool = False, pointers_metadata: bool = False, schema: Union[str, None] = None, **filters):
         """
         Perform a lookup for values matching the given filters, with options to apply a limit and include pointer information.
 
@@ -294,14 +303,17 @@ async def lookup_values_where(cls, limit: Union[int, list] = 0, with_pointers: b
         # if not filters: # Ensure filters are provided for the lookup
         #     raise ValueError("No criteria provided for the lookup.")
 
+        if pointers_metadata and with_pointers:
+            raise ValueError("You select both pointers value and pointers metadata. Choose one")
+
         if schema:
             cls.schema = str(schema)
         else:
             cls.schema = None
 
         cls.command = "lookup_values"
         cls.limit_output = handle_limit(limit)
-        query = convert_to_binary_query(cls, search_criteria=filters, with_pointers=with_pointers)
+        query = convert_to_binary_query(cls, search_criteria=filters, with_pointers=with_pointers, key_included=key_included, pointers_metadata=pointers_metadata)
         return await cls._run_query(query)
 
     @classmethod

montycat/store_classes/persistent.py

@@ -117,18 +117,22 @@ async def insert_bulk(cls, bulk_values: list):
         return await cls._run_query(query)
 
     @classmethod
-    async def get_keys(cls, limit: Union[list, int] = []):
+    async def get_keys(cls, limit: Union[list, int] = [], volumes: list = [], latest_volume: bool = False):
         """
         Args:
             Limit: A list of two integers that determine the range of keys to retrieve.
             Example: limit = [10, 20] will retrieve keys 10 to 20.
         Returns:
             A list of keys in the store. Class 'str' if the get operation failed.
         """
+
+        if latest_volume and len(volumes) > 0:
+            raise ValueError("Select either latest volume or volumes list, not both.")
+
         cls.limit_output = handle_limit(limit)
         cls.command = "get_keys"
 
-        query = convert_to_binary_query(cls)
+        query = convert_to_binary_query(cls, volumes=volumes, latest_volume=latest_volume)
         return await cls._run_query(query)
 
     @classmethod

montycat/store_functions/store_generic_functions.py

@@ -6,13 +6,13 @@
 def convert_custom_key(key: Union[int, str]) -> int:
     """
     Converts a custom key (either an integer or string) into a hash value using xxHash.
-    
+
     Args:
         key (int | str): The custom key to be hashed.
-    
+
     Returns:
         int: The xxHash digest of the provided key as an integer.
-    
+
     This function ensures that any input key, whether integer or string, is consistently 
     hashed into a unique integer for use as a custom key in further queries.
     """
@@ -21,13 +21,13 @@ def convert_custom_key(key: Union[int, str]) -> int:
 def convert_custom_keys(keys: list) -> list:
     """
     Converts a list of custom keys into their hashed equivalents.
-    
+
     Args:
         keys (list): A list of custom keys to be hashed.
-    
+
     Returns:
         list: A list of hashed keys as integers.
-    
+
     This function maps over the provided list of keys and applies `convert_custom_key` 
     to each one to ensure they are converted to hashed integers.
     """
@@ -43,14 +43,14 @@ def convert_custom_keys_values(keys_values: dict) -> dict:
     """
     Converts a dictionary of custom keys and their corresponding values into a new 
     dictionary with hashed keys.
-    
+
     Args:
         keys_values (dict): A dictionary where the keys are custom keys (either 
                              integers or strings) and the values are associated values.
-    
+
     Returns:
         dict: A dictionary where the custom keys have been hashed into integers.
-    
+
     This function maps over the dictionary and applies `convert_custom_key` to each 
     key while leaving the corresponding value unchanged.
     """
@@ -59,13 +59,13 @@ def convert_custom_keys_values(keys_values: dict) -> dict:
 def modify_pointers(value: dict) -> dict:
     """
     Modifies the pointers in the given value dictionary to ensure they are in the correct format.
-    
+
     Args:
         value (dict): The dictionary containing pointers to be modified.
-    
+
     Returns:
         dict: The modified dictionary with pointers in the correct format.
-    
+
     Raises:
         ValueError: If there is an error processing the pointers.
     """
@@ -88,7 +88,7 @@ def modify_pointers(value: dict) -> dict:
 
     except Exception as e:
         raise ValueError(f"Error processing pointers: {e}")
-    
+
     return value
 
 def normalize_bools(s: str) -> str:
@@ -104,10 +104,14 @@ def convert_to_binary_query(
     bulk_keys: List[str] = None,
     bulk_keys_values: Dict[str, Any] = None,
     with_pointers: bool = False,
+    volumes: List[int] = [],
+    latest_volume: bool = False,
+    key_included: bool = False,
+    pointers_metadata: bool = False,
 ) -> bytes:
     """
     Converts parameters into a binary query format suitable for transmission.
-    
+
     Args:
         cls: Query class containing connection details and command settings
         key: Single key for the query
@@ -118,10 +122,10 @@ def convert_to_binary_query(
         bulk_keys: List of keys for bulk operations
         bulk_keys_values: Dictionary of keys and values for bulk operations
         with_pointers: Flag to include pointers
-    
+
     Returns:
         bytes: Binary-encoded query in appropriate format
-        
+
     Raises:
         ValueError: If bulk values contain multiple schemas
     """
@@ -131,7 +135,7 @@ def convert_to_binary_query(
     bulk_values = bulk_values or []
     bulk_keys = bulk_keys or []
     bulk_keys_values = bulk_keys_values or {}
-    
+
     if value:
         value = modify_pointers(value)
 
@@ -142,32 +146,32 @@ def convert_to_binary_query(
                 schemas.extend([item['schema']])
             else:
                 schemas.extend([None])
-        
+
         unique_schemas = set(schemas)
         if len(unique_schemas) > 1:
             raise ValueError("Bulk values should fit only one schema")
-        
+
         cls.schema = schemas[0] if schemas else None
         bulk_values = [
             str(modify_pointers({k: v for k, v in item.items() if k != 'schema'}))
             for item in bulk_values
         ]
-    
+
     if bulk_keys_values:
         bulk_keys_values = {
-            k: str(modify_pointers(v)) 
+            k: str(modify_pointers(v))
             for k, v in bulk_keys_values.items()
         }
 
     if bulk_keys:
         bulk_keys = [str(k) for k in bulk_keys]
-    
+
     if 'schema' in value:
         cls.schema = value.pop('schema')
 
     search_criteria = handle_timestamps_and_pointers(search_criteria)
     value = handle_timestamps_and_pointers(value)
-    
+
     query_dict = {
         "schema": cls.schema,
         "username": cls.username,
@@ -186,8 +190,12 @@ def convert_to_binary_query(
         "bulk_keys_values": {k: normalize_bools(str(v)) for k, v in bulk_keys_values.items()},
         "search_criteria": normalize_bools(str(search_criteria)),
         "with_pointers": with_pointers,
+        "volumes": volumes,
+        "latest_volume": latest_volume,
+        "key_included": key_included,
+        "pointers_metadata": pointers_metadata,
     }
-        
+
     return orjson.dumps(query_dict)
 
 def handle_timestamps_and_pointers(search_criteria: dict) -> dict: