montycat 0.1.1__tar.gz

montycat-0.1.1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: montycat
+Version: 0.1.1
+Summary: A Python client for MontyCat, NoSQL store utilizing Data Mesh architecture.
+Author: MontyGovernance
+Author-email: eugene.and.monty@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: orjson
+Requires-Dist: xxhash
+Requires-Dist: asyncio
+
+# MontyCat
+
+**MontyCat** is a Python client for **MontyCat**, a high-performance, distributed NoSQL store designed with a cutting-edge Data Mesh architecture. This client empowers developers to seamlessly manage and query their data while leveraging the unparalleled flexibility and scalability offered by NoSQL databases within a decentralized data ownership paradigm.
+
+## Key Features
+
+- **High Performance:** Harnesses MontyCat's advanced architecture for lightning-fast read and write operations.
+- **Distributed Architecture:** Effortlessly connects to a distributed NoSQL database, enabling dynamic horizontal scalability across diverse data domains.
+- **Data Mesh Design:** Innovatively utilizes a Data Mesh framework that empowers cross-functional teams to own, manage, and serve their own data, enhancing collaboration and eliminating bottlenecks.
+- **Asynchronous Support:** Built on `asyncio` for ultra-responsive, non-blocking operations, enabling high concurrency and real-time data processing.
+- **Meshing and Sharding:** Efficiently orchestrates data across multiple nodes with robust support for data meshing and sharding, optimizing resource utilization.
+- **Memory Safety:** Implements state-of-the-art memory management practices, minimizing the risk of memory-related issues and enhancing stability.
+- **Smart Data Governance:** Integrates intelligent governance features to ensure data quality and compliance across the distributed architecture.
+- **Seamless Integration:** Offers a simple and intuitive API for effortless integration with your Python applications, reducing time-to-value.
+- **Robust Documentation:** Comprehensive and user-friendly documentation to accelerate onboarding and maximize productivity.
+
+## Installation
+
+You can install MontyCat using pip:
+
+```bash
+pip install montycat

montycat-0.1.1/README.md

@@ -0,0 +1,22 @@
+# MontyCat
+
+**MontyCat** is a Python client for **MontyCat**, a high-performance, distributed NoSQL store designed with a cutting-edge Data Mesh architecture. This client empowers developers to seamlessly manage and query their data while leveraging the unparalleled flexibility and scalability offered by NoSQL databases within a decentralized data ownership paradigm.
+
+## Key Features
+
+- **High Performance:** Harnesses MontyCat's advanced architecture for lightning-fast read and write operations.
+- **Distributed Architecture:** Effortlessly connects to a distributed NoSQL database, enabling dynamic horizontal scalability across diverse data domains.
+- **Data Mesh Design:** Innovatively utilizes a Data Mesh framework that empowers cross-functional teams to own, manage, and serve their own data, enhancing collaboration and eliminating bottlenecks.
+- **Asynchronous Support:** Built on `asyncio` for ultra-responsive, non-blocking operations, enabling high concurrency and real-time data processing.
+- **Meshing and Sharding:** Efficiently orchestrates data across multiple nodes with robust support for data meshing and sharding, optimizing resource utilization.
+- **Memory Safety:** Implements state-of-the-art memory management practices, minimizing the risk of memory-related issues and enhancing stability.
+- **Smart Data Governance:** Integrates intelligent governance features to ensure data quality and compliance across the distributed architecture.
+- **Seamless Integration:** Offers a simple and intuitive API for effortless integration with your Python applications, reducing time-to-value.
+- **Robust Documentation:** Comprehensive and user-friendly documentation to accelerate onboarding and maximize productivity.
+
+## Installation
+
+You can install MontyCat using pip:
+
+```bash
+pip install montycat

montycat-0.1.1/montycat/__init__.py

@@ -0,0 +1,4 @@
+from .core.engine import Engine
+from .core.schema import Schema, Pointer
+from .core.limit import Limit
+from .core.store import Store

montycat-0.1.1/montycat/core/engine.py

@@ -0,0 +1,101 @@
+import asyncio
+import orjson
+
+class Engine:
+    def __init__(self, host: str, port: int, username: str, password: str, store_name: str):
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.store_name = store_name
+
+async def send_data(host: str, port: int, string: str):
+    resp = None
+    writer = None
+
+    try:
+        reader, writer = await asyncio.open_connection(host, port)
+        writer.write(string + b"\n")
+        await writer.drain()
+
+        try:
+            resp = await asyncio.wait_for(reader.readuntil(b"\n"), timeout=120)
+            resp = resp.decode().strip()
+
+            try:
+                resp = recursive_parse_orjson(resp)
+            except Exception as parse_error:
+                print(f"Failed to parse response: {parse_error}")
+
+        except asyncio.TimeoutError:
+            resp = "Operation timed out"
+
+    except ConnectionRefusedError:
+        resp = "Connection refused"
+    except Exception as e:
+        resp = f"An unexpected error occurred: {e}"
+    finally:
+        if writer:
+            writer.close()
+            await writer.wait_closed()
+    return resp
+
+
+def recursive_parse_orjson(data):
+    """
+    Recursively parses nested JSON strings in the provided data using orjson for faster parsing.
+    
+    Args:
+        data: A Python object that may contain JSON strings, including nested structures.
+        
+    Returns:
+        A fully parsed Python object with all nested JSON strings converted.
+    """
+    if isinstance(data, dict):
+        return {
+            key: recursive_parse_orjson(value)
+            for key, value in data.items()
+        }
+    elif isinstance(data, tuple):
+        return tuple(recursive_parse_orjson(element) if not element.isdigit() else element for element in data)
+    elif isinstance(data, list):
+        return [recursive_parse_orjson(element) if not element.isdigit() else element for element in data]
+    elif isinstance(data, str):
+        try:
+            parsed_data = orjson.loads(data)
+            return recursive_parse_orjson(parsed_data)
+        except orjson.JSONDecodeError:
+            return data
+    
+    elif isinstance(data, (int, float)):
+        return data
+    
+    else:
+        return data
+
+# def recursive_parse_orjson(data):
+#     """
+#     Recursively parses nested JSON strings in the provided data using orjson for faster parsing.
+    
+#     Args:
+#         data: A Python object that may contain JSON strings, including nested structures.
+    
+#     Returns:
+#         A fully parsed Python object with all nested JSON strings converted.
+#     """
+#     if isinstance(data, dict):
+#         return {key: recursive_parse_orjson(value) for key, value in data.items()}
+#     elif isinstance(data, tuple):
+#         return tuple(recursive_parse_orjson(element) for element in data)
+#     elif isinstance(data, list):
+#         return [recursive_parse_orjson(element) for element in data]
+#     elif isinstance(data, str):
+#         try:
+#             # Attempt to parse the string as JSON
+#             parsed_data = orjson.loads(data)
+#             return recursive_parse_orjson(parsed_data)
+#         except orjson.JSONDecodeError:
+#             # Return the original string if it can't be parsed
+#             return data
+#     else:
+#         return data

montycat-0.1.1/montycat/core/limit.py

@@ -0,0 +1,7 @@
+class Limit:
+    def __init__(self, start: int = 0, stop: int = 0):
+        self.start = start
+        self.stop = stop
+
+    def return_limit(self):
+        return {"start": self.start, "stop": self.stop}

montycat-0.1.1/montycat/core/schema.py

@@ -0,0 +1,75 @@
+from typing import get_origin, get_args, get_type_hints, Union
+
+class Pointer:
+    def __init__(self, **kwargs):
+
+        for key, value in kwargs.items():
+            setattr(self, key, [value[0].store_namespace, value[1]])
+
+    def __str__(self):
+        return str(self.__dict__)
+    
+    def serialize(self):
+        return self.__dict__
+
+class Schema:
+    def __init__(self, **kwargs):
+        hints = get_type_hints(self.__class__)
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+        for attribute in hints:
+            if not hasattr(self, attribute):
+                setattr(self, attribute, None)
+        self.validate_types()
+
+    def __repr__(self):
+        return str(self.__dict__)
+    
+    def __str__(self):
+        return str(self.__dict__)
+    
+    def serialize(self):
+        if hasattr(self, "pointers"):
+            self.pointers = self.pointers.serialize()
+            for k, v in self.pointers.items():
+                if v[1].isdigit():
+                    self.pointers[k] = [v[0].store_namespace, str(v[1])]
+
+        return self.__dict__
+
+    def validate_types(self):
+        hints = get_type_hints(self.__class__)
+        for attribute, expected_type in hints.items():
+            actual_value = getattr(self, attribute)
+            
+            origin = get_origin(expected_type)
+
+
+            if origin is Union:
+
+                expected_types = get_args(expected_type)
+                if not isinstance(actual_value, expected_types) and actual_value is not None:
+                    raise TypeError(
+                        f"Attribute '{attribute}' should be one of types {expected_types}, "
+                        f"but got '{type(actual_value).__name__}'"
+                    )
+                                
+            elif origin is Pointer:
+                if not isinstance(actual_value, Pointer) and actual_value is not None:
+                    raise TypeError(
+                        f"Attribute '{attribute}' should be of type '{expected_type.__name__}', "
+                        f"but got '{type(actual_value).__name__}'"
+                    )
+
+            elif origin is None:
+                if not isinstance(actual_value, expected_type) and actual_value is not None:
+                    raise TypeError(
+                        f"Attribute '{attribute}' should be of type '{expected_type.__name__}', "
+                        f"but got '{type(actual_value).__name__}'"
+                    )
+            else:
+                if not isinstance(actual_value, origin) and actual_value is not None:
+                    raise TypeError(
+                        f"Attribute '{attribute}' should be of type '{expected_type}', "
+                        f"but got '{type(actual_value).__name__}'"
+                    )

montycat-0.1.1/montycat/core/store.py

@@ -0,0 +1,33 @@
+from ..store_classes.kv import generic_kv
+
+class Store:
+    class InMemory(generic_kv):
+        persistent = False
+        distributed = False
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+
+        class Distributed(generic_kv):
+            persistent = False
+            distributed = True
+
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+
+    class Persistent(generic_kv):
+        persistent = True
+        distributed = False
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+
+        class Distributed(generic_kv):
+            persistent = True
+            distributed = True
+
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+
+
+

montycat-0.1.1/montycat/store_classes/kv.py

@@ -0,0 +1,221 @@
+from ..core.engine import Engine, send_data
+from ..core.schema import Pointer
+from ..store_functions.store_generic_functions import handle_limit, connect_engine_, create_namespace_, drop_namespace_, drop_store_, show_store_properties_, convert_to_binary_query, convert_custom_key, convert_custom_keys, convert_custom_keys_values
+import asyncio
+
+class generic_kv:
+    store_name: str = ""
+    command: str = ""
+    persistent: bool = False
+    request: str = "store"
+    blockchain: bool = False
+    limit_output: dict = {}
+
+    @classmethod
+    def _run_query(cls, query: str):
+        return asyncio.run(send_data(cls.host, cls.port, query))
+    
+    @classmethod
+    def insert_custom_key(cls, custom_key: str, expire_sec: int = 0):
+        """       
+        Args:
+            custom_key: A custom key to insert into the store. This key can be used to retrieve the value later.
+            expire_sec: The number of seconds before the inserted value expires.
+        Returns:
+            True if the insert operation was successful. Class 'str' if the insert operation failed.
+        """
+        custom_key_converted = convert_custom_key(custom_key)
+        cls.command = "insert_custom_key"
+        query = convert_to_binary_query(cls, key=custom_key_converted, expire_sec=expire_sec)
+        return cls._run_query(query)
+    
+    @classmethod
+    def insert_custom_key_value(cls, custom_key: str, value: dict, expire_sec: int = 0):
+        """       
+        Args:
+            custom_key: A custom key to insert into the store. This key can be used to retrieve the value later.
+            value: A Python class / dict to insert into the store.
+            expire_sec: The number of seconds before the inserted value expires.
+        Returns:
+            True if the insert operation was successful. Class 'str' if the insert operation failed.
+
+            custom_key = "some_value"
+            value = {
+                "operation": 1,
+                "amount": 4500.0
+            }
+            
+        """
+        custom_key_converted = convert_custom_key(custom_key)
+        cls.command = "insert_custom_key_value"
+        query = convert_to_binary_query(cls, key=custom_key_converted, value=value, expire_sec=expire_sec)
+        return cls._run_query(query)
+    
+    @classmethod
+    def insert_value(cls, value: dict, expire_sec: int = 0):
+        """       
+        Args:
+            value: A Python class / dict to insert into the store.
+            expire_sec: The number of seconds before the inserted value expires.
+        Returns:
+            Key number if the insert operation was successful. Class 'str' if the insert operation failed.
+        """
+        cls.command = "insert_value"
+        query = convert_to_binary_query(cls, value=value, expire_sec=expire_sec)
+        return cls._run_query(query)
+    
+    @classmethod
+    def get_value(cls, key: int | str = "", custom_key: str = "", with_pointers: bool = False):
+
+        """
+        Args:
+            key: The key number of the value to retrieve.
+            custom_key: The custom key of the value to retrieve.
+            with_pointers: A boolean value that determines whether to include pointers (foreign values) in the output.
+        Returns:
+            The value associated with the key or custom key. Class 'str' if the get operation failed.
+        """
+        if len(custom_key) > 0:
+            key = convert_custom_key(custom_key)
+        cls.command = "get_value"
+        query = convert_to_binary_query(cls, key=key, with_pointers=with_pointers)
+        return cls._run_query(query)
+        
+    @classmethod
+    def get_keys(cls, limit: list = []):
+        """
+        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.
+        """
+        lim = handle_limit(limit)
+        cls.command = "get_keys"
+        cls.limit_output = lim
+        query = convert_to_binary_query(cls)
+        return cls._run_query(query)
+    
+    @classmethod
+    def delete_key(cls, key: int | str = "", custom_key: str = ""):
+
+        if len(custom_key) > 0:
+            key = convert_custom_key(custom_key)
+
+        cls.command = "delete_key"
+        query = convert_to_binary_query(cls, key=key)
+        return cls._run_query(query)
+
+    @classmethod
+    def update_value(cls, key: int | str = "", custom_key: str = "", **filters):
+
+        if len(custom_key) > 0:
+            key = convert_custom_key(custom_key)
+
+        cls.command = "update_value"
+        query = convert_to_binary_query(cls, key=key, value=filters)
+        print(query)
+        return cls._run_query(query)
+    
+    @classmethod
+    def insert_bulk(cls, bulk_values: list, expire_sec: int = 0):
+        # bulk_values = [str(item) for item in bulk if len(bulk) > 0]
+        """       
+        Args:
+            bulk_values: A list of Python objects to insert into the store.
+            expire_sec: The number of seconds before the inserted values expire.
+            
+        Returns:
+            True if the bulk insert operation was successful.
+            List of values that were not inserted.
+        """
+        cls.command = "insert_bulk"
+        query = convert_to_binary_query(cls, bulk_values=bulk_values, expire_sec=expire_sec)
+        return cls._run_query(query)
+    
+    @classmethod
+    def delete_bulk(cls, bulk_keys: list = [], bulk_custom_keys: list = []):
+
+        if len(bulk_custom_keys) > 0:
+            bulk_custom_keys = convert_custom_keys(bulk_custom_keys)
+            bulk_keys += bulk_custom_keys
+
+        cls.command = "delete_bulk"
+        query = convert_to_binary_query(cls, bulk_keys=bulk_keys)
+        return cls._run_query(query)
+    
+    @classmethod
+    def get_bulk(cls, bulk_keys: list = [], bulk_custom_keys: list = [], limit: list = [], with_pointers: bool = False):
+
+        lim = handle_limit(limit)
+
+        if len(bulk_custom_keys) > 0:
+            bulk_custom_keys = convert_custom_keys(bulk_custom_keys)
+            bulk_keys += bulk_custom_keys
+        
+        cls.command = "get_bulk"
+        cls.limit_output = lim
+        query = convert_to_binary_query(cls, bulk_keys=bulk_keys, with_pointers=with_pointers)
+        return cls._run_query(query)
+    
+    @classmethod
+    def update_bulk(cls, bulk_keys_values: dict = {}, bulk_custom_keys_values: dict = {}):
+
+        if len(bulk_custom_keys_values) > 0:
+            bulk_custom_keys_values = convert_custom_keys_values(bulk_custom_keys_values)
+            bulk_keys_values = bulk_keys_values | bulk_custom_keys_values
+
+            # print(bulk_keys_values)
+
+        cls.command = "update_bulk"
+        query = convert_to_binary_query(cls, bulk_keys_values=bulk_keys_values)
+        return cls._run_query(query)
+    
+    @classmethod
+    def lookup_keys_where(cls, limit: int = 0, **filters):
+
+        lim = handle_limit(limit)
+
+        cls.command = "lookup_keys"
+        cls.limit_output = lim
+        query = convert_to_binary_query(cls, search_criteria=filters)
+        return cls._run_query(query)
+    
+    @classmethod
+    def lookup_values_where(cls, limit = 0, with_pointers: bool = False, **filters):
+
+        lim = handle_limit(limit)
+
+        cls.command = "lookup_values"
+        cls.limit_output = lim
+        query = convert_to_binary_query(cls, search_criteria=filters, with_pointers=with_pointers)
+        return cls._run_query(query)
+    
+    @classmethod
+    def to_blockchain(cls, key: int):
+        cls.command = "blockchain"
+        cls.persistent = True
+        cls.blockchain = True
+        query = convert_to_binary_query(cls, key=key)
+        return cls._run_query(query)
+    
+    @classmethod
+    def connect_engine(cls, engine: Engine) -> None:
+        connect_engine_(cls, engine)
+
+    @classmethod  
+    def create_namespace(cls):
+        return create_namespace_(cls)
+    
+    @classmethod  
+    def drop_namespace(cls):
+        return drop_namespace_(cls)
+    
+    @classmethod
+    def drop_store(cls):
+        drop_store_(cls)
+
+    @classmethod
+    def show_store_properties(cls):
+        show_store_properties_(cls)
+

montycat-0.1.1/montycat/store_functions/store_generic_functions.py

@@ -0,0 +1,123 @@
+from ..core.engine import Engine, send_data
+from ..core.limit import Limit
+from ..core.schema import Pointer
+import asyncio
+import orjson
+import xxhash
+
+def connect_engine_(cls: type, engine: Engine) -> None:
+    cls.username = engine.username
+    cls.password = engine.password
+    cls.host = engine.host
+    cls.port = engine.port
+    cls.store_name = engine.store_name
+
+def convert_custom_key(key: int | str) -> int:
+    return str(xxhash.xxh32(str(key)).intdigest())
+
+def convert_custom_keys(keys: list) -> list:
+    return [convert_custom_key(key) for key in keys]
+
+def convert_custom_keys_values(keys_values: dict) -> dict:
+    return {convert_custom_key(key): value for key, value in keys_values.items()}
+
+def modify_pointers(value: dict):
+    if "pointers" in value:
+        try:
+            for k, v in value['pointers'].items():
+                if v[1].isdigit():
+                    value['pointers'][k] = [v[0], str(v[1])]
+                else:
+                    value['pointers'][k] = [v[0], convert_custom_key(v[1])]
+            return value
+        except:
+            raise ValueError("Pointer should be a valid hash key or custom key")
+    return value
+    
+        
+
+def convert_to_binary_query(
+        cls: type, 
+        key: str = "", 
+        search_criteria: dict = {}, 
+        value: dict = {}, 
+        expire_sec: int = 0, 
+        bulk_values: list = [], 
+        bulk_keys: list = [],
+        bulk_keys_values: dict = {},
+        with_pointers: bool = False
+        ):
+    
+    if len(value) > 0:
+        value = modify_pointers(value)
+
+    if len(bulk_values) > 0:
+        bulk_values = [str(modify_pointers(value)) for value in bulk_values]
+
+    if len(bulk_keys_values) > 0:
+        bulk_keys_values = {key: str(modify_pointers(value)) for key, value in bulk_keys_values.items()}
+            
+    return orjson.dumps({
+        "request": cls.request,
+        "username": cls.username,
+        "password": cls.password,
+        "store_namespace": cls.store_namespace,
+        "store_name": cls.store_name,
+        "persistent": cls.persistent,
+        "distributed": cls.distributed,
+        "limit_output": cls.limit_output,
+        "key": str(key),
+        "value": str(value).replace("True", "true").replace("False", "false"),
+        "command": cls.command, 
+        "expire": expire_sec,
+        "bulk_values": [str(value).replace("True", "true").replace("False", "false") for value in bulk_values],
+        "bulk_keys": bulk_keys,
+        "bulk_keys_values": {key: str(value).replace("True", "true").replace("False", "false") for key, value in bulk_keys_values.items()},
+        "blockchain": cls.blockchain,
+        "search_criteria": str(search_criteria).replace("True", "true").replace("False", "false"),
+        'with_pointers': with_pointers,
+    })
+
+def run_query(cls: type):
+    query = convert_to_binary_query(cls)
+    return asyncio.run(send_data(cls.host, cls.port, query))
+
+def handle_limit(limit: list) -> dict:
+
+    limit_class = Limit()
+
+    if type(limit) == list:
+        if len(limit) > 1:
+            limit_class.start = limit[0]
+            limit_class.stop = limit[1]
+        elif len(limit) == 1:
+            limit_class.stop = limit[0]
+
+    return limit_class.return_limit()
+
+def create_namespace_(cls: type) -> None:
+    cls.command = "create_namespace"
+    cls.request = "utils"
+    return run_query(cls)
+
+def drop_namespace_(cls: type) -> None:
+    cls.command = "drop_namespace"
+    cls.request = "utils"
+    return run_query(cls)
+
+def drop_store_(cls: type) -> None:
+    cls.command = "drop_store"
+    cls.request = "utils"
+    return print('DROP', cls.store_name)
+
+def show_store_properties_(cls: type) -> None:
+    return print(
+        f"Store Name: {cls.store_name}\n"
+        f"Store Namespace: {cls.store_namespace}\n"
+        f"Persistent: {cls.persistent}\n"
+        f"Distributed: {cls.distributed}\n"
+        f"Host: {cls.host}\n"
+        f"Port: {cls.port}\n"
+        f"Username: {cls.username}\n"
+        f"Password: {cls.password}\n"
+    )

montycat-0.1.1/montycat.egg-info/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: montycat
+Version: 0.1.1
+Summary: A Python client for MontyCat, NoSQL store utilizing Data Mesh architecture.
+Author: MontyGovernance
+Author-email: eugene.and.monty@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: orjson
+Requires-Dist: xxhash
+Requires-Dist: asyncio
+
+# MontyCat
+
+**MontyCat** is a Python client for **MontyCat**, a high-performance, distributed NoSQL store designed with a cutting-edge Data Mesh architecture. This client empowers developers to seamlessly manage and query their data while leveraging the unparalleled flexibility and scalability offered by NoSQL databases within a decentralized data ownership paradigm.
+
+## Key Features
+
+- **High Performance:** Harnesses MontyCat's advanced architecture for lightning-fast read and write operations.
+- **Distributed Architecture:** Effortlessly connects to a distributed NoSQL database, enabling dynamic horizontal scalability across diverse data domains.
+- **Data Mesh Design:** Innovatively utilizes a Data Mesh framework that empowers cross-functional teams to own, manage, and serve their own data, enhancing collaboration and eliminating bottlenecks.
+- **Asynchronous Support:** Built on `asyncio` for ultra-responsive, non-blocking operations, enabling high concurrency and real-time data processing.
+- **Meshing and Sharding:** Efficiently orchestrates data across multiple nodes with robust support for data meshing and sharding, optimizing resource utilization.
+- **Memory Safety:** Implements state-of-the-art memory management practices, minimizing the risk of memory-related issues and enhancing stability.
+- **Smart Data Governance:** Integrates intelligent governance features to ensure data quality and compliance across the distributed architecture.
+- **Seamless Integration:** Offers a simple and intuitive API for effortless integration with your Python applications, reducing time-to-value.
+- **Robust Documentation:** Comprehensive and user-friendly documentation to accelerate onboarding and maximize productivity.
+
+## Installation
+
+You can install MontyCat using pip:
+
+```bash
+pip install montycat

montycat-0.1.1/montycat.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+setup.py
+montycat/__init__.py
+montycat.egg-info/PKG-INFO
+montycat.egg-info/SOURCES.txt
+montycat.egg-info/dependency_links.txt
+montycat.egg-info/not-zip-safe
+montycat.egg-info/requires.txt
+montycat.egg-info/top_level.txt
+montycat/core/__init__.py
+montycat/core/engine.py
+montycat/core/limit.py
+montycat/core/schema.py
+montycat/core/store.py
+montycat/store_classes/__init__.py
+montycat/store_classes/kv.py
+montycat/store_functions/__init__.py
+montycat/store_functions/store_generic_functions.py

montycat-0.1.1/montycat.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

montycat-0.1.1/montycat.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

montycat-0.1.1/montycat.egg-info/requires.txt

@@ -0,0 +1,3 @@
+orjson
+xxhash
+asyncio

montycat-0.1.1/montycat.egg-info/top_level.txt

@@ -0,0 +1 @@
+montycat

montycat-0.1.1/pyproject.toml

@@ -0,0 +1,4 @@
+# pyproject.toml
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

montycat-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

montycat-0.1.1/setup.py

@@ -0,0 +1,22 @@
+# setup.py
+from setuptools import setup, find_packages
+
+setup(
+    name='montycat',
+    version='0.1.1',
+    description='A Python client for MontyCat, NoSQL store utilizing Data Mesh architecture.',
+    packages=find_packages(),
+    zip_safe=False,
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    author='MontyGovernance',
+    author_email='eugene.and.monty@gmail.com',
+    include_package_data=True,
+    install_requires=['orjson', 'xxhash', 'asyncio'],
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.9',
+)