lqft-python-engine 0.1.3__tar.gz → 0.1.7__tar.gz

{lqft_python_engine-0.1.3/lqft_python_engine.egg-info → lqft_python_engine-0.1.7}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: lqft-python-engine
-Version: 0.1.3
+Version: 0.1.7
 Summary: Log-Quantum Fractal Tree: Pattern-Aware Deduplicating Data Structure
 Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
 Author: Parjad Minooei
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
+Requires-Dist: psutil
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -20,6 +20,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
 Dynamic: license-file
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

{lqft_python_engine-0.1.3 → lqft_python_engine-0.1.7}/lqft_engine.c

@@ -11,30 +11,29 @@
 #include <stdint.h>
 
 /**
- * LQFT C-Engine (Log-Quantum Fractal Tree) - V4.1 (Master Build)
+ * LQFT C-Engine - V4.3 (Dynamic Registry Build)
  * Architect: Parjad Minooei
- * * MAJOR FIX 1: Upgraded to 64-bit FNV-1a structural hashing (solves 32-bit collisions).
- * * MAJOR FIX 2: Added Segment Indexing `[i]` to branch hashing (solves Ghost Sibling merges).
- * * MAJOR FIX 3: Capped MAX_BITS to 64 to prevent Undefined Behavior bit-shifts.
+ * * BUGFIX: Added missing 'search' method to the native export table.
+ * * MEMORY: Moved Registry to HEAP (Dynamic) for zero-footprint reclamation.
  */
 
 #define BIT_PARTITION 5
-#define MAX_BITS 64 // 64-bit integer hashes passed from Python
+#define MAX_BITS 64 
 #define MASK 0x1F 
-#define REGISTRY_SIZE 8000009 // 8 Million prime slots to guarantee massive headroom
+#define REGISTRY_SIZE 8000009 
 
 typedef struct LQFTNode {
     void* value;
     uint64_t key_hash;
     struct LQFTNode* children[32]; 
-    char struct_hash[17]; // 16 Hex chars + 1 Null terminator for 64-bit hash
+    char struct_hash[17]; 
 } LQFTNode;
 
-LQFTNode* registry[REGISTRY_SIZE];
-int physical_node_count = 0;
-LQFTNode* global_root = NULL;
+// Registry is now a pointer allocated on the HEAP to allow full OS reclamation
+static LQFTNode** registry = NULL;
+static int physical_node_count = 0;
+static LQFTNode* global_root = NULL;
 
-// Upgraded to 64-bit FNV-1a Hash to prevent structural collisions at massive scales
 uint64_t fnv1a_64(const char* str) {
     uint64_t hash = 14695981039346656037ULL;
     while (*str) {
@@ -44,8 +43,27 @@ uint64_t fnv1a_64(const char* str) {
     return hash;
 }
 
+char* portable_strdup(const char* s) {
+    if (!s) return NULL;
+#ifdef _WIN32
+    return _strdup(s);
+#else
+    return strdup(s);
+#endif
+}
+
+static int init_registry() {
+    if (registry == NULL) {
+        // Use calloc to initialize all pointer slots to NULL safely
+        registry = (LQFTNode**)calloc(REGISTRY_SIZE, sizeof(LQFTNode*));
+        if (registry == NULL) return 0;
+    }
+    return 1;
+}
+
 LQFTNode* create_node(void* value, uint64_t key_hash) {
     LQFTNode* node = (LQFTNode*)malloc(sizeof(LQFTNode));
+    if (!node) return NULL;
     node->value = value;
     node->key_hash = key_hash;
     for (int i = 0; i < 32; i++) node->children[i] = NULL;
@@ -53,6 +71,8 @@ LQFTNode* create_node(void* value, uint64_t key_hash) {
 }
 
 LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
+    if (!init_registry()) return NULL;
+
     char buffer[8192] = { 0 };
     if (value != NULL) {
         sprintf(buffer, "leaf:%s:%llu", (char*)value, (unsigned long long)key_hash);
@@ -61,23 +81,21 @@ LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
         for (int i = 0; i < 32; i++) {
             if (children && children[i]) {
                 char seg_buf[32];
-                // FIX: Adding [%d] prevents identically hashed children in different slots from merging
                 sprintf(seg_buf, "[%d]%s", i, children[i]->struct_hash);
                 strcat(buffer, seg_buf);
             }
         }
     }
     
-    // 64-bit structural hash formatting
     uint64_t full_hash = fnv1a_64(buffer);
     char lookup_hash[17];
     sprintf(lookup_hash, "%016llx", (unsigned long long)full_hash);
     uint32_t idx = full_hash % REGISTRY_SIZE;
 
-    // Linear Probing logic
     uint32_t start_idx = idx;
     while (registry[idx] != NULL) {
         if (strcmp(registry[idx]->struct_hash, lookup_hash) == 0) {
+            if (value) free(value); 
             return registry[idx];
         }
         idx = (idx + 1) % REGISTRY_SIZE;
@@ -85,6 +103,7 @@ LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
     }
 
     LQFTNode* new_node = create_node(value, key_hash);
+    if (!new_node) return NULL;
     if (children) {
         for (int i = 0; i < 32; i++) new_node->children[i] = children[i];
     }
@@ -94,24 +113,33 @@ LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
     return new_node;
 }
 
-char* portable_strdup(const char* s) {
-    if (!s) return NULL;
-#ifdef _WIN32
-    return _strdup(s);
-#else
-    return strdup(s);
-#endif
+static PyObject* method_free_all(PyObject* self, PyObject* args) {
+    int freed_count = 0;
+    if (registry != NULL) {
+        for (int i = 0; i < REGISTRY_SIZE; i++) {
+            if (registry[i] != NULL) {
+                if (registry[i]->value) free(registry[i]->value);
+                free(registry[i]);
+                registry[i] = NULL;
+                freed_count++;
+            }
+        }
+        // Dynamic reclamation: Free the registry array itself
+        free(registry);
+        registry = NULL;
+    }
+    physical_node_count = 0;
+    global_root = NULL;
+    return PyLong_FromLong(freed_count);
 }
 
-// --- PYTHON API BRIDGE ---
-
 static PyObject* method_insert(PyObject* self, PyObject* args) {
     unsigned long long h;
     char* val_str;
     if (!PyArg_ParseTuple(args, "Ks", &h, &val_str)) return NULL;
 
     if (!global_root) {
-        for (int i = 0; i < REGISTRY_SIZE; i++) registry[i] = NULL;
+        if (!init_registry()) return PyErr_NoMemory();
         global_root = get_canonical(NULL, 0, NULL);
     }
 
@@ -122,7 +150,6 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
     LQFTNode* curr = global_root;
     int bit_depth = 0;
 
-    // 1. Traversal
     while (curr != NULL && curr->value == NULL) {
         uint32_t segment = (h >> bit_depth) & MASK;
         path_nodes[path_len] = curr;
@@ -137,16 +164,14 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
         bit_depth += BIT_PARTITION;
     }
 
-    // 2. Node Update / Collision Logic
     LQFTNode* new_sub_node = NULL;
-
     if (curr == NULL) {
         new_sub_node = get_canonical(portable_strdup(val_str), h, NULL);
     } else if (curr->key_hash == h) {
         new_sub_node = get_canonical(portable_strdup(val_str), h, curr->children);
     } else {
         unsigned long long old_h = curr->key_hash;
-        char* old_val = (char*)curr->value;
+        char* old_val = portable_strdup((char*)curr->value);
         int temp_depth = bit_depth;
 
         while (temp_depth < MAX_BITS) {
@@ -154,30 +179,23 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
             uint32_t s_new = (h >> temp_depth) & MASK;
 
             if (s_old != s_new) {
-                LQFTNode* c_old = get_canonical(portable_strdup(old_val), old_h, curr->children);
+                LQFTNode* c_old = get_canonical(old_val, old_h, curr->children);
                 LQFTNode* c_new = get_canonical(portable_strdup(val_str), h, NULL);
-
                 LQFTNode* new_children[32] = {NULL};
                 new_children[s_old] = c_old;
                 new_children[s_new] = c_new;
-
                 new_sub_node = get_canonical(NULL, 0, new_children);
                 break;
             } else {
-                path_nodes[path_len] = NULL; // Marker for split
+                path_nodes[path_len] = NULL; 
                 path_segs[path_len] = s_old;
                 path_len++;
                 temp_depth += BIT_PARTITION;
             }
         }
-        
-        // Absolute Hash Collision (Rare)
-        if (new_sub_node == NULL) {
-            new_sub_node = get_canonical(portable_strdup(val_str), h, curr->children);
-        }
+        if (new_sub_node == NULL) new_sub_node = get_canonical(portable_strdup(val_str), h, curr->children);
     }
 
-    // 3. Iterative Back-Propagation
     for (int i = path_len - 1; i >= 0; i--) {
         if (path_nodes[i] == NULL) {
             LQFTNode* new_children[32] = {NULL};
@@ -200,22 +218,24 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
 static PyObject* method_search(PyObject* self, PyObject* args) {
     unsigned long long h;
     if (!PyArg_ParseTuple(args, "K", &h)) return NULL;
-    if (!global_root) { Py_RETURN_NONE; }
+
+    if (!global_root || registry == NULL) {
+        Py_RETURN_NONE;
+    }
 
     LQFTNode* curr = global_root;
     int bit_depth = 0;
 
-    while (curr != NULL) {
-        if (curr->value != NULL) {
-            if (curr->key_hash == h) return PyUnicode_FromString((char*)curr->value);
-            Py_RETURN_NONE;
-        }
+    while (curr != NULL && curr->value == NULL) {
         uint32_t segment = (h >> bit_depth) & MASK;
-        if (curr->children[segment] == NULL) { Py_RETURN_NONE; }
         curr = curr->children[segment];
         bit_depth += BIT_PARTITION;
-        if (bit_depth >= MAX_BITS) break;
     }
+
+    if (curr != NULL && curr->key_hash == h) {
+        return PyUnicode_FromString((char*)curr->value);
+    }
+
     Py_RETURN_NONE;
 }
 
@@ -224,16 +244,13 @@ static PyObject* method_get_metrics(PyObject* self, PyObject* args) {
 }
 
 static PyMethodDef LQFTMethods[] = {
-    {"insert", method_insert, METH_VARARGS, "Insert into C LQFT"},
-    {"search", method_search, METH_VARARGS, "Search C LQFT"},
-    {"get_metrics", method_get_metrics, METH_VARARGS, "Get memory metrics"},
+    {"insert", method_insert, METH_VARARGS, "Insert"},
+    {"search", method_search, METH_VARARGS, "Search"},
+    {"get_metrics", method_get_metrics, METH_VARARGS, "Metrics"},
+    {"free_all", method_free_all, METH_VARARGS, "Reclaim"},
     {NULL, NULL, 0, NULL}
 };
 
-static struct PyModuleDef lqftmodule = {
-    PyModuleDef_HEAD_INIT, "lqft_c_engine", "LQFT Performance Engine", -1, LQFTMethods
-};
+static struct PyModuleDef lqftmodule = { PyModuleDef_HEAD_INIT, "lqft_c_engine", NULL, -1, LQFTMethods };
 
-PyMODINIT_FUNC PyInit_lqft_c_engine(void) {
-    return PyModule_Create(&lqftmodule);
-}
+PyMODINIT_FUNC PyInit_lqft_c_engine(void) { return PyModule_Create(&lqftmodule); }

{lqft_python_engine-0.1.3 → lqft_python_engine-0.1.7}/lqft_engine.py

@@ -138,7 +138,6 @@ class AdaptiveLQFT:
             self.threshold = float('inf') # Prevent continuous upgrade attempts
             return
             
-        # print("\n[⚙️] AdaptiveLQFT: Threshold reached. Migrating to Native C-Engine...")
         for key, val in self._light_store.items():
             h = self._get_64bit_hash(key)
             lqft_c_engine.insert(h, val)
@@ -149,16 +148,16 @@ class AdaptiveLQFT:
 
     def insert(self, key, value):
         if not self.is_native:
-            # Phase 1: Small Data Operations (Lightning fast, $O(N)$ Space)
+            # Phase 1: Small Data Operations
             if key not in self._light_store:
                 self.size += 1
             self._light_store[key] = value
             
-            # Check if we need to upgrade to the big guns
+            # Check for migration threshold
             if self.size >= self.threshold:
                 self._migrate_to_native()
         else:
-            # Phase 2: Massive Data Operations ($O(Entropy)$ Space Folding)
+            # Phase 2: Massive Data Operations (Native C-Heap)
             h = self._get_64bit_hash(key)
             lqft_c_engine.insert(h, value)
 
@@ -169,6 +168,28 @@ class AdaptiveLQFT:
             h = self._get_64bit_hash(key)
             return lqft_c_engine.search(h)
 
+    def clear(self):
+        """
+        Memory Reclamation: Manually trigger C-level heap cleanup.
+        In the Adaptive model, this handles both the Python dict and the C-Registry.
+        """
+        self._light_store.clear()
+        self.size = 0
+        if C_ENGINE_READY:
+            return lqft_c_engine.free_all()
+        return 0
+
+    def __del__(self):
+        """
+        Finalizer: Reclaims unmanaged C memory when the Python object is deleted.
+        Crucial for preventing memory leaks in long-running systems.
+        """
+        try:
+            self.clear()
+        except:
+            # Silence errors during late interpreter shutdown/garbage collection
+            pass
+
     def status(self):
         """Returns the current state of the engine."""
         return {

{lqft_python_engine-0.1.3 → lqft_python_engine-0.1.7/lqft_python_engine.egg-info}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: lqft-python-engine
-Version: 0.1.3
+Version: 0.1.7
 Summary: Log-Quantum Fractal Tree: Pattern-Aware Deduplicating Data Structure
 Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
 Author: Parjad Minooei
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
+Requires-Dist: psutil
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -20,6 +20,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
 Dynamic: license-file
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

{lqft_python_engine-0.1.3 → lqft_python_engine-0.1.7}/lqft_python_engine.egg-info/SOURCES.txt

@@ -1,9 +1,11 @@
 LICENSE.md
 lqft_engine.c
 lqft_engine.py
+pure_python_ds.py
 pyproject.toml
 setup.py
 lqft_python_engine.egg-info/PKG-INFO
 lqft_python_engine.egg-info/SOURCES.txt
 lqft_python_engine.egg-info/dependency_links.txt
+lqft_python_engine.egg-info/requires.txt
 lqft_python_engine.egg-info/top_level.txt

lqft_python_engine-0.1.7/lqft_python_engine.egg-info/requires.txt

@@ -0,0 +1 @@
+psutil

{lqft_python_engine-0.1.3 → lqft_python_engine-0.1.7}/lqft_python_engine.egg-info/top_level.txt

@@ -1,2 +1,3 @@
 lqft_c_engine
 lqft_engine
+pure_python_ds

lqft_python_engine-0.1.7/pure_python_ds.py

@@ -0,0 +1,139 @@
+import struct
+
+# ---------------------------------------------------------
+# 1. DETERMINISTIC HASHING (FNV-1a 64-bit)
+# ---------------------------------------------------------
+def fnv1a_64(key: str) -> int:
+    """Generates a strict 64-bit deterministic hash for O(1) routing."""
+    hval = 0xcbf29ce484222325
+    fnv_prime = 0x100000001b3
+    for byte in key.encode('utf-8'):
+        hval ^= byte
+        hval = (hval * fnv_prime) & 0xFFFFFFFFFFFFFFFF
+    return hval
+
+def combine_hashes(hashes: list) -> int:
+    """Combines child Merkle hashes to generate a parent's structural hash."""
+    hval = 0
+    for h in hashes:
+        if h is not None:
+            hval ^= h
+            hval = (hval * 0x100000001b3) & 0xFFFFFFFFFFFFFFFF
+    return hval
+
+# ---------------------------------------------------------
+# 2. GLOBAL C-REGISTRY MOCK (Structural Folding)
+# ---------------------------------------------------------
+# Maps a Merkle Hash -> Physical Node Instance
+NODE_REGISTRY = {}
+
+class LQFTNode:
+    """A fixed 32-way routing node."""
+    __slots__ = ('children', 'value', 'merkle_hash')
+
+    def __init__(self, value=None):
+        self.children = [None] * 32
+        self.value = value
+        self.merkle_hash = None
+
+def get_deduplicated_node(node: LQFTNode) -> LQFTNode:
+    """
+    The core of O(Σ) Space Complexity. 
+    If a node with this exact structure exists, return the existing memory pointer.
+    Otherwise, register this new node.
+    """
+    # Calculate structural Merkle Hash
+    child_hashes = [c.merkle_hash if c else None for c in node.children]
+    base_hash = fnv1a_64(str(node.value)) if node.value is not None else 0
+    node.merkle_hash = (base_hash ^ combine_hashes(child_hashes)) & 0xFFFFFFFFFFFFFFFF
+
+    # Structural Folding (Deduplication)
+    if node.merkle_hash in NODE_REGISTRY:
+        return NODE_REGISTRY[node.merkle_hash]
+    
+    NODE_REGISTRY[node.merkle_hash] = node
+    return node
+
+# ---------------------------------------------------------
+# 3. THE LQFT ARCHITECTURE (Strictly Iterative)
+# ---------------------------------------------------------
+class LQFT:
+    def __init__(self):
+        self.root = get_deduplicated_node(LQFTNode())
+
+    def insert(self, key: str, value: any):
+        """
+        O(1) Insertion. Capped at exactly 13 hops.
+        STRICTLY ITERATIVE. NO RECURSION ALLOWED.
+        """
+        key_hash = fnv1a_64(key)
+        
+        # Step 1: Iterative Traversal Down
+        # We store the path to allow bottom-up Merkle folding without recursion
+        path_stack = []
+        current = self.root
+        
+        for level in range(13): # Fixed 64-bit space (13 chunks of 5 bits)
+            index = (key_hash >> (level * 5)) & 0x1F # Mask 5 bits
+            path_stack.append((current, index))
+            
+            if current.children[index] is None:
+                current = LQFTNode() # Create empty node for routing
+            else:
+                current = current.children[index]
+
+        # Step 2: Create the Leaf Node
+        new_leaf = LQFTNode(value=value)
+        current = get_deduplicated_node(new_leaf)
+
+        # Step 3: Iterative Bottom-Up Folding (Copy-on-Write)
+        while path_stack:
+            parent_node, index = path_stack.pop()
+            
+            # Create a copy of the parent to ensure immutability/versioning
+            new_parent = LQFTNode()
+            new_parent.children = list(parent_node.children) # Copy references
+            new_parent.children[index] = current # Attach the new folded child
+            
+            # Deduplicate the new parent
+            current = get_deduplicated_node(new_parent)
+            
+        # The final deduplicated node becomes the new root
+        self.root = current
+
+    def search(self, key: str) -> any:
+        """O(1) Search. Guaranteed max 13 hops. Iterative."""
+        key_hash = fnv1a_64(key)
+        current = self.root
+        
+        for level in range(13):
+            index = (key_hash >> (level * 5)) & 0x1F
+            current = current.children[index]
+            if current is None:
+                return None # Key not found
+                
+        # FIXED: This return statement is now outside the loop!
+        return current.value
+
+    # Make it easy to use like standard Python Dicts
+    def __setitem__(self, key, value):
+        self.insert(key, value)
+
+    def __getitem__(self, key):
+        res = self.search(key)
+        if res is None:
+            raise KeyError(key)
+        return res
+
+# ---------------------------------------------------------
+# 4. EASY API (The "Heapify" Equivalent)
+# ---------------------------------------------------------
+def build_lqft(iterable) -> LQFT:
+    """
+    Instantiates and builds an LQFT in O(1) interface time.
+    Usage: tree = build_lqft([("user1", "dataA"), ("user2", "dataB")])
+    """
+    tree = LQFT()
+    for key, value in iterable:
+        tree.insert(key, value)
+    return tree

{lqft_python_engine-0.1.3 → lqft_python_engine-0.1.7}/setup.py

@@ -13,7 +13,7 @@ if os.name == 'nt':
 else:
     extra_compile_args = ['-O3']
 
-# Load README for PyPI long_description (Bulletproof File Check)
+# Load README for PyPI long_description
 long_description = "Log-Quantum Fractal Tree Engine"
 if os.path.exists("readme.md"):
     with open("readme.md", "r", encoding="utf-8") as fh:
@@ -31,7 +31,7 @@ lqft_extension = Extension(
 
 setup(
     name="lqft-python-engine",
-    version="0.1.3", # Bumped version for clean PyPI upload
+    version="0.1.7", 
     description="Log-Quantum Fractal Tree: Pattern-Aware Deduplicating Data Structure",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -39,13 +39,12 @@ setup(
     url="https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-",
     ext_modules=[lqft_extension],
     packages=find_packages(),
-    py_modules=["lqft_engine"],
-    install_requires=[],
-    license="MIT",
+    py_modules=["lqft_engine", "pure_python_ds"],
+    install_requires=['psutil'],
+    license="MIT", 
     classifiers=[
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3.12",
-        "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
         "Topic :: Software Development :: Libraries :: Python Modules",
     ],