lqft-python-engine 0.5.0__tar.gz → 0.7.0__tar.gz

{lqft_python_engine-0.5.0 → lqft_python_engine-0.7.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: lqft-python-engine
-Version: 0.5.0
-Summary: LQFT Engine: Native Disk Persistence & Cold Start Deserialization (v5.0 Stable)
+Version: 0.7.0
+Summary: LQFT Engine: Strict Native C-Core & Hardware Concurrency (v0.7.0 Stable)
 Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
 Author: Parjad Minooei
 License: MIT

{lqft_python_engine-0.5.0 → lqft_python_engine-0.7.0}/lqft_engine.c

@@ -10,13 +10,32 @@
 #include <string.h>
 #include <stdint.h>
 
+// --- PHASE 2: CROSS-PLATFORM HARDWARE LOCKS ---
+#ifdef _WIN32
+    #include <windows.h>
+    typedef SRWLOCK lqft_rwlock_t;
+    #define LQFT_RWLOCK_INIT(lock) InitializeSRWLock(lock)
+    #define LQFT_RWLOCK_RDLOCK(lock) AcquireSRWLockShared(lock)
+    #define LQFT_RWLOCK_WRLOCK(lock) AcquireSRWLockExclusive(lock)
+    #define LQFT_RWLOCK_UNLOCK_RD(lock) ReleaseSRWLockShared(lock)
+    #define LQFT_RWLOCK_UNLOCK_WR(lock) ReleaseSRWLockExclusive(lock)
+#else
+    #include <pthread.h>
+    typedef pthread_rwlock_t lqft_rwlock_t;
+    #define LQFT_RWLOCK_INIT(lock) pthread_rwlock_init(lock, NULL)
+    #define LQFT_RWLOCK_RDLOCK(lock) pthread_rwlock_rdlock(lock)
+    #define LQFT_RWLOCK_WRLOCK(lock) pthread_rwlock_wrlock(lock)
+    #define LQFT_RWLOCK_UNLOCK_RD(lock) pthread_rwlock_unlock(lock)
+    #define LQFT_RWLOCK_UNLOCK_WR(lock) pthread_rwlock_unlock(lock)
+#endif
+
 /**
- * LQFT C-Engine - V0.5.0 (Native Disk Persistence)
+ * LQFT C-Engine - V0.6.0 (Hardware Concurrency)
  * Architect: Parjad Minooei
  * * CHANGE LOG:
- * - Implemented Binary Serialization (save_to_disk).
- * - Implemented O(1) Cold Start Deserialization (load_from_disk).
- * - DAG Pointer Reconstruction Logic.
+ * - Implemented SRWLOCK / pthread_rwlock for true multi-core utilization.
+ * - Bypassed Python GIL using Py_BEGIN_ALLOW_THREADS.
+ * - Fixed Macro brace expansions for thread safe early returns.
  */
 
 #define BIT_PARTITION 5
@@ -37,6 +56,8 @@ typedef struct LQFTNode {
 static LQFTNode** registry = NULL;
 static int physical_node_count = 0;
 static LQFTNode* global_root = NULL;
+static lqft_rwlock_t engine_lock; // The Master Hardware Lock
+static int lock_initialized = 0;
 
 const uint64_t FNV_OFFSET_BASIS = 14695981039346656037ULL;
 const uint64_t FNV_PRIME = 1099511628211ULL;
@@ -63,6 +84,10 @@ char* portable_strdup(const char* s) {
 }
 
 static int init_registry() {
+    if (!lock_initialized) {
+        LQFT_RWLOCK_INIT(&engine_lock);
+        lock_initialized = 1;
+    }
     if (registry == NULL) {
         registry = (LQFTNode**)calloc(REGISTRY_SIZE, sizeof(LQFTNode*));
         if (registry == NULL) return 0;
@@ -108,6 +133,8 @@ void decref(LQFTNode* node) {
 }
 
 static PyObject* method_free_all(PyObject* self, PyObject* args) {
+    Py_BEGIN_ALLOW_THREADS
+    LQFT_RWLOCK_WRLOCK(&engine_lock);
     if (registry != NULL) {
         for (int i = 0; i < REGISTRY_SIZE; i++) {
             if (registry[i] != NULL && registry[i] != TOMBSTONE) {
@@ -121,6 +148,9 @@ static PyObject* method_free_all(PyObject* self, PyObject* args) {
     }
     physical_node_count = 0;
     global_root = NULL;
+    LQFT_RWLOCK_UNLOCK_WR(&engine_lock);
+    Py_END_ALLOW_THREADS
+
     Py_RETURN_NONE;
 }
 
@@ -130,46 +160,56 @@ static PyObject* method_free_all(PyObject* self, PyObject* args) {
 static PyObject* method_save_to_disk(PyObject* self, PyObject* args) {
     const char* filepath;
     if (!PyArg_ParseTuple(args, "s", &filepath)) return NULL;
-    if (!registry) Py_RETURN_NONE;
-
-    FILE* fp = fopen(filepath, "wb");
-    if (!fp) return PyErr_SetFromErrno(PyExc_IOError);
-
-    // Header: Magic Bytes, Count, Global Root Hash
-    char magic[4] = "LQFT";
-    fwrite(magic, 1, 4, fp);
-    fwrite(&physical_node_count, sizeof(int), 1, fp);
-    uint64_t root_hash = global_root ? global_root->full_hash_val : 0;
-    fwrite(&root_hash, sizeof(uint64_t), 1, fp);
-
-    // Dump Nodes
-    for (int i = 0; i < REGISTRY_SIZE; i++) {
-        LQFTNode* node = registry[i];
-        if (node != NULL && node != TOMBSTONE) {
-            fwrite(&node->full_hash_val, sizeof(uint64_t), 1, fp);
-            fwrite(&node->key_hash, sizeof(uint64_t), 1, fp);
-            fwrite(node->struct_hash, 1, 17, fp);
-            fwrite(&node->ref_count, sizeof(int), 1, fp);
-
-            // Payload
-            int has_val = (node->value != NULL) ? 1 : 0;
-            fwrite(&has_val, sizeof(int), 1, fp);
-            if (has_val) {
-                int v_len = (int)strlen((char*)node->value);
-                fwrite(&v_len, sizeof(int), 1, fp);
-                fwrite(node->value, 1, v_len, fp);
-            }
-
-            // Children pointers (saved as full_hash_val references)
-            uint64_t child_refs[32] = {0};
-            for (int c = 0; c < 32; c++) {
-                if (node->children[c]) child_refs[c] = node->children[c]->full_hash_val;
+    
+    int success = 1;
+    
+    // Release GIL, Lock Engine for Writing
+    Py_BEGIN_ALLOW_THREADS
+    LQFT_RWLOCK_WRLOCK(&engine_lock);
+    
+    if (!registry) {
+        success = 0;
+    } else {
+        FILE* fp = fopen(filepath, "wb");
+        if (!fp) {
+            success = 0;
+        } else {
+            char magic[4] = "LQFT";
+            fwrite(magic, 1, 4, fp);
+            fwrite(&physical_node_count, sizeof(int), 1, fp);
+            uint64_t root_hash = global_root ? global_root->full_hash_val : 0;
+            fwrite(&root_hash, sizeof(uint64_t), 1, fp);
+
+            for (int i = 0; i < REGISTRY_SIZE; i++) {
+                LQFTNode* node = registry[i];
+                if (node != NULL && node != TOMBSTONE) {
+                    fwrite(&node->full_hash_val, sizeof(uint64_t), 1, fp);
+                    fwrite(&node->key_hash, sizeof(uint64_t), 1, fp);
+                    fwrite(node->struct_hash, 1, 17, fp);
+                    fwrite(&node->ref_count, sizeof(int), 1, fp);
+
+                    int has_val = (node->value != NULL) ? 1 : 0;
+                    fwrite(&has_val, sizeof(int), 1, fp);
+                    if (has_val) {
+                        int v_len = (int)strlen((char*)node->value);
+                        fwrite(&v_len, sizeof(int), 1, fp);
+                        fwrite(node->value, 1, v_len, fp);
+                    }
+
+                    uint64_t child_refs[32] = {0};
+                    for (int c = 0; c < 32; c++) {
+                        if (node->children[c]) child_refs[c] = node->children[c]->full_hash_val;
+                    }
+                    fwrite(child_refs, sizeof(uint64_t), 32, fp);
+                }
             }
-            fwrite(child_refs, sizeof(uint64_t), 32, fp);
+            fclose(fp);
         }
     }
+    LQFT_RWLOCK_UNLOCK_WR(&engine_lock);
+    Py_END_ALLOW_THREADS
 
-    fclose(fp);
+    if (!success) return PyErr_SetFromErrno(PyExc_IOError);
     Py_RETURN_TRUE;
 }
 
@@ -191,75 +231,93 @@ static PyObject* method_load_from_disk(PyObject* self, PyObject* args) {
     const char* filepath;
     if (!PyArg_ParseTuple(args, "s", &filepath)) return NULL;
 
-    FILE* fp = fopen(filepath, "rb");
-    if (!fp) return PyErr_SetFromErrno(PyExc_IOError);
-
-    char magic[5] = {0};
-    fread(magic, 1, 4, fp);
-    if (strcmp(magic, "LQFT") != 0) {
-        fclose(fp);
-        PyErr_SetString(PyExc_ValueError, "Invalid LQFT binary file format.");
-        return NULL;
-    }
+    int success = 1;
+    int format_error = 0;
 
-    // Clear current state safely
-    method_free_all(self, NULL);
-    init_registry();
-
-    int total_nodes;
-    uint64_t root_hash;
-    fread(&total_nodes, sizeof(int), 1, fp);
-    fread(&root_hash, sizeof(uint64_t), 1, fp);
-
-    // Parallel array to store child hashes for Pass 2 (Pointer Reconstruction)
-    uint64_t* all_child_refs = (uint64_t*)malloc(total_nodes * 32 * sizeof(uint64_t));
-    LQFTNode** loaded_nodes = (LQFTNode**)malloc(total_nodes * sizeof(LQFTNode*));
-
-    // PASS 1: Read physical nodes into memory
-    for (int i = 0; i < total_nodes; i++) {
-        LQFTNode* node = create_node(NULL, 0);
-        fread(&node->full_hash_val, sizeof(uint64_t), 1, fp);
-        fread(&node->key_hash, sizeof(uint64_t), 1, fp);
-        fread(node->struct_hash, 1, 17, fp);
-        fread(&node->ref_count, sizeof(int), 1, fp);
-
-        int has_val;
-        fread(&has_val, sizeof(int), 1, fp);
-        if (has_val) {
-            int v_len;
-            fread(&v_len, sizeof(int), 1, fp);
-            char* val_str = (char*)malloc(v_len + 1);
-            fread(val_str, 1, v_len, fp);
-            val_str[v_len] = '\0';
-            node->value = val_str;
-        }
+    Py_BEGIN_ALLOW_THREADS
+    LQFT_RWLOCK_WRLOCK(&engine_lock);
+    
+    FILE* fp = fopen(filepath, "rb");
+    if (!fp) {
+        success = 0;
+    } else {
+        char magic[5] = {0};
+        fread(magic, 1, 4, fp);
+        if (strcmp(magic, "LQFT") != 0) {
+            fclose(fp);
+            format_error = 1;
+            success = 0;
+        } else {
+            // Internal clear
+            if (registry != NULL) {
+                for (int i = 0; i < REGISTRY_SIZE; i++) {
+                    if (registry[i] != NULL && registry[i] != TOMBSTONE) {
+                        if (registry[i]->value) free(registry[i]->value);
+                        free(registry[i]);
+                    }
+                    registry[i] = NULL;
+                }
+            }
+            physical_node_count = 0;
+            global_root = NULL;
+            init_registry();
+
+            int total_nodes;
+            uint64_t root_hash;
+            fread(&total_nodes, sizeof(int), 1, fp);
+            fread(&root_hash, sizeof(uint64_t), 1, fp);
+
+            uint64_t* all_child_refs = (uint64_t*)malloc(total_nodes * 32 * sizeof(uint64_t));
+            LQFTNode** loaded_nodes = (LQFTNode**)malloc(total_nodes * sizeof(LQFTNode*));
+
+            for (int i = 0; i < total_nodes; i++) {
+                LQFTNode* node = create_node(NULL, 0);
+                fread(&node->full_hash_val, sizeof(uint64_t), 1, fp);
+                fread(&node->key_hash, sizeof(uint64_t), 1, fp);
+                fread(node->struct_hash, 1, 17, fp);
+                fread(&node->ref_count, sizeof(int), 1, fp);
+
+                int has_val;
+                fread(&has_val, sizeof(int), 1, fp);
+                if (has_val) {
+                    int v_len;
+                    fread(&v_len, sizeof(int), 1, fp);
+                    char* val_str = (char*)malloc(v_len + 1);
+                    fread(val_str, 1, v_len, fp);
+                    val_str[v_len] = '\0';
+                    node->value = val_str;
+                }
 
-        fread(&all_child_refs[i * 32], sizeof(uint64_t), 32, fp);
+                fread(&all_child_refs[i * 32], sizeof(uint64_t), 32, fp);
 
-        // Insert directly into registry
-        uint32_t idx = node->full_hash_val % REGISTRY_SIZE;
-        while (registry[idx] != NULL) idx = (idx + 1) % REGISTRY_SIZE;
-        registry[idx] = node;
-        
-        loaded_nodes[i] = node;
-        physical_node_count++;
-    }
+                uint32_t idx = node->full_hash_val % REGISTRY_SIZE;
+                while (registry[idx] != NULL) idx = (idx + 1) % REGISTRY_SIZE;
+                registry[idx] = node;
+                loaded_nodes[i] = node;
+                physical_node_count++;
+            }
 
-    // PASS 2: Pointer Reconstruction (Relinking the DAG)
-    for (int i = 0; i < total_nodes; i++) {
-        for (int c = 0; c < 32; c++) {
-            uint64_t target_hash = all_child_refs[i * 32 + c];
-            if (target_hash != 0) {
-                loaded_nodes[i]->children[c] = find_in_registry(target_hash);
+            for (int i = 0; i < total_nodes; i++) {
+                for (int c = 0; c < 32; c++) {
+                    uint64_t target_hash = all_child_refs[i * 32 + c];
+                    if (target_hash != 0) loaded_nodes[i]->children[c] = find_in_registry(target_hash);
+                }
             }
+
+            global_root = find_in_registry(root_hash);
+            free(all_child_refs);
+            free(loaded_nodes);
+            fclose(fp);
         }
     }
+    LQFT_RWLOCK_UNLOCK_WR(&engine_lock);
+    Py_END_ALLOW_THREADS
 
-    global_root = find_in_registry(root_hash);
-
-    free(all_child_refs);
-    free(loaded_nodes);
-    fclose(fp);
+    if (format_error) {
+        PyErr_SetString(PyExc_ValueError, "Invalid LQFT binary file format.");
+        return NULL;
+    }
+    if (!success) return PyErr_SetFromErrno(PyExc_IOError);
 
     Py_RETURN_TRUE;
 }
@@ -329,8 +387,15 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
     char* val_str;
     if (!PyArg_ParseTuple(args, "Ks", &h, &val_str)) return NULL;
     
+    // Copy the string before dropping the GIL to prevent memory corruption
+    char* val_copy = portable_strdup(val_str);
+
+    // Bypass GIL & Lock Engine (Exclusive Write Lock)
+    Py_BEGIN_ALLOW_THREADS
+    LQFT_RWLOCK_WRLOCK(&engine_lock);
+    
     if (!global_root) {
-        if (!init_registry()) return PyErr_NoMemory();
+        init_registry();
         global_root = get_canonical(NULL, 0, NULL);
         global_root->ref_count++;
     }
@@ -354,9 +419,9 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
     
     LQFTNode* new_sub_node = NULL;
     if (curr == NULL) { 
-        new_sub_node = get_canonical(portable_strdup(val_str), h, NULL); 
+        new_sub_node = get_canonical(portable_strdup(val_copy), h, NULL); 
     } else if (curr->key_hash == h) { 
-        new_sub_node = get_canonical(portable_strdup(val_str), h, curr->children); 
+        new_sub_node = get_canonical(portable_strdup(val_copy), h, curr->children); 
     } else {
         unsigned long long old_h = curr->key_hash;
         char* old_val = portable_strdup((char*)curr->value);
@@ -366,7 +431,7 @@ 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(old_val, old_h, curr->children);
-                LQFTNode* c_new = get_canonical(portable_strdup(val_str), h, NULL);
+                LQFTNode* c_new = get_canonical(portable_strdup(val_copy), h, NULL);
                 LQFTNode* new_children[32] = {NULL};
                 new_children[s_old] = c_old;
                 new_children[s_new] = c_new;
@@ -379,7 +444,7 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
                 temp_depth += BIT_PARTITION; 
             }
         }
-        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_copy), h, curr->children);
     }
     
     for (int i = path_len - 1; i >= 0; i--) {
@@ -400,6 +465,10 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
     global_root = new_sub_node;
     global_root->ref_count++;
     if (old_root) decref(old_root); 
+    
+    free(val_copy);
+    LQFT_RWLOCK_UNLOCK_WR(&engine_lock);
+    Py_END_ALLOW_THREADS
 
     Py_RETURN_NONE;
 }
@@ -407,66 +476,86 @@ 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;
     
-    LQFTNode* curr = global_root;
-    int bit_depth = 0;
-    while (curr != NULL && curr->value == NULL) {
-        uint32_t segment = (h >> bit_depth) & MASK;
-        curr = curr->children[segment];
-        bit_depth += BIT_PARTITION;
+    char* result_str = NULL;
+
+    // Bypass GIL & Lock Engine (Shared Read Lock - Multiple threads can enter simultaneously!)
+    Py_BEGIN_ALLOW_THREADS
+    LQFT_RWLOCK_RDLOCK(&engine_lock);
+    
+    if (global_root) {
+        LQFTNode* curr = global_root;
+        int bit_depth = 0;
+        while (curr != NULL && curr->value == NULL) {
+            uint32_t segment = (h >> bit_depth) & MASK;
+            curr = curr->children[segment];
+            bit_depth += BIT_PARTITION;
+        }
+        if (curr != NULL && curr->key_hash == h) {
+            result_str = (char*)curr->value;
+        }
     }
     
-    if (curr != NULL && curr->key_hash == h) return PyUnicode_FromString((char*)curr->value);
+    LQFT_RWLOCK_UNLOCK_RD(&engine_lock);
+    Py_END_ALLOW_THREADS
+    
+    if (result_str) return PyUnicode_FromString(result_str);
     Py_RETURN_NONE;
 }
 
 static PyObject* method_delete(PyObject* self, PyObject* args) {
     unsigned long long h;
     if (!PyArg_ParseTuple(args, "K", &h)) return NULL;
-    if (!global_root) Py_RETURN_NONE;
 
-    LQFTNode* path_nodes[20]; 
-    uint32_t path_segs[20];
-    int path_len = 0;
-    LQFTNode* curr = global_root;
-    int bit_depth = 0;
-
-    while (curr != NULL && curr->value == NULL) {
-        uint32_t segment = (h >> bit_depth) & MASK;
-        path_nodes[path_len] = curr;
-        path_segs[path_len] = segment;
-        path_len++;
-        curr = curr->children[segment];
-        bit_depth += BIT_PARTITION;
-    }
-
-    if (curr == NULL || curr->key_hash != h) Py_RETURN_NONE;
+    Py_BEGIN_ALLOW_THREADS
+    LQFT_RWLOCK_WRLOCK(&engine_lock);
+    
+    if (global_root) {
+        LQFTNode* path_nodes[20]; 
+        uint32_t path_segs[20];
+        int path_len = 0;
+        LQFTNode* curr = global_root;
+        int bit_depth = 0;
+
+        while (curr != NULL && curr->value == NULL) {
+            uint32_t segment = (h >> bit_depth) & MASK;
+            path_nodes[path_len] = curr;
+            path_segs[path_len] = segment;
+            path_len++;
+            curr = curr->children[segment];
+            bit_depth += BIT_PARTITION;
+        }
 
-    LQFTNode* old_root = global_root;
-    LQFTNode* new_sub_node = NULL;
+        if (curr != NULL && curr->key_hash == h) {
+            LQFTNode* old_root = global_root;
+            LQFTNode* new_sub_node = NULL;
+
+            for (int i = path_len - 1; i >= 0; i--) {
+                LQFTNode* p_node = path_nodes[i];
+                uint32_t segment = path_segs[i];
+                LQFTNode* new_children[32];
+                int has_other_children = 0;
+
+                for (uint32_t j = 0; j < 32; j++) {
+                    if (j == segment) new_children[j] = new_sub_node;
+                    else {
+                        new_children[j] = p_node->children[j];
+                        if (new_children[j]) has_other_children = 1;
+                    }
+                }
 
-    for (int i = path_len - 1; i >= 0; i--) {
-        LQFTNode* p_node = path_nodes[i];
-        uint32_t segment = path_segs[i];
-        LQFTNode* new_children[32];
-        int has_other_children = 0;
-
-        for (uint32_t j = 0; j < 32; j++) {
-            if (j == segment) new_children[j] = new_sub_node;
-            else {
-                new_children[j] = p_node->children[j];
-                if (new_children[j]) has_other_children = 1;
+                if (!has_other_children && i > 0) new_sub_node = NULL;
+                else new_sub_node = get_canonical(NULL, 0, new_children);
             }
-        }
 
-        if (!has_other_children && i > 0) new_sub_node = NULL;
-        else new_sub_node = get_canonical(NULL, 0, new_children);
+            global_root = (new_sub_node) ? new_sub_node : get_canonical(NULL, 0, NULL);
+            if (global_root) global_root->ref_count++;
+            if (old_root) decref(old_root); 
+        }
     }
-
-    global_root = (new_sub_node) ? new_sub_node : get_canonical(NULL, 0, NULL);
-    if (global_root) global_root->ref_count++;
-    if (old_root) decref(old_root); 
+    
+    LQFT_RWLOCK_UNLOCK_WR(&engine_lock);
+    Py_END_ALLOW_THREADS
 
     Py_RETURN_NONE;
 }
@@ -487,4 +576,8 @@ static PyMethodDef 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) { 
+    LQFT_RWLOCK_INIT(&engine_lock);
+    lock_initialized = 1;
+    return PyModule_Create(&lqftmodule); 
+}

lqft_python_engine-0.7.0/lqft_engine.py

@@ -0,0 +1,109 @@
+import hashlib
+import psutil
+import os
+import sys
+
+# ---------------------------------------------------------
+# STRICT NATIVE ENTERPRISE ENGINE (v0.7.0)
+# ---------------------------------------------------------
+# Architect: Parjad Minooei
+# Status: Pure Python fallback removed. Strict C-Core interface.
+
+try:
+    import lqft_c_engine
+except ImportError:
+    print("\n[!] CRITICAL FATAL ERROR: Native C-Engine not found.")
+    print("[!] The LQFT is now a strictly native database. Pure Python fallback is disabled.")
+    print("[!] Run: python setup.py build_ext --inplace\n")
+    sys.exit(1)
+
+class LQFT:
+    def __init__(self):
+        self.is_native = True
+        self.auto_purge_enabled = True
+        self.max_memory_mb = 1000.0 
+        self.total_ops = 0
+        self._process = psutil.Process(os.getpid())
+
+    def _validate_type(self, key, value=None):
+        if not isinstance(key, str):
+            raise TypeError(f"LQFT keys must be strings. Received: {type(key).__name__}")
+        if value is not None and not isinstance(value, str):
+            raise TypeError(f"LQFT values must be strings. Received: {type(value).__name__}")
+
+    def _get_64bit_hash(self, key):
+        return int(hashlib.md5(key.encode()).hexdigest()[:16], 16)
+
+    def set_auto_purge_threshold(self, threshold: float):
+        self.max_memory_mb = threshold
+
+    def purge(self):
+        current_mb = self._process.memory_info().rss / (1024 * 1024)
+        print(f"\n[⚠️ CIRCUIT Breaker] Engine exceeded limit (Currently {current_mb:.1f} MB). Auto-Purging!")
+        self.clear()
+
+    # --- Native Disk Persistence ---
+    def save_to_disk(self, filepath: str):
+        lqft_c_engine.save_to_disk(filepath)
+
+    def load_from_disk(self, filepath: str):
+        if not os.path.exists(filepath):
+            raise FileNotFoundError(f"Missing LQFT database file: {filepath}")
+        lqft_c_engine.load_from_disk(filepath)
+
+    # --- Core Operations ---
+    def insert(self, key, value):
+        self._validate_type(key, value)
+        self.total_ops += 1
+        
+        # Memory Circuit Breaker
+        if self.auto_purge_enabled and self.total_ops % 5000 == 0:
+            current_mb = self._process.memory_info().rss / (1024 * 1024)
+            if current_mb >= self.max_memory_mb:
+                self.purge()
+
+        h = self._get_64bit_hash(key)
+        lqft_c_engine.insert(h, value)
+
+    def remove(self, key):
+        self._validate_type(key)
+        h = self._get_64bit_hash(key)
+        lqft_c_engine.delete(h)
+
+    def delete(self, key):
+        self.remove(key)
+
+    def search(self, key):
+        self._validate_type(key)
+        h = self._get_64bit_hash(key)
+        return lqft_c_engine.search(h)
+
+    # --- Pythonic Syntactic Sugar ---
+    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
+
+    def clear(self):
+        return lqft_c_engine.free_all()
+
+    def get_stats(self):
+        return lqft_c_engine.get_metrics()
+
+    def __del__(self):
+        try: self.clear()
+        except: pass
+
+    def status(self):
+        return {
+            "mode": "Strict Native C-Engine",
+            "items": lqft_c_engine.get_metrics().get('physical_nodes', 0),
+            "threshold": "DISABLED (Pure Hardware Mode)"
+        }
+
+# Alias mapping so older benchmark scripts don't crash
+AdaptiveLQFT = LQFT

{lqft_python_engine-0.5.0 → lqft_python_engine-0.7.0}/lqft_python_engine.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: lqft-python-engine
-Version: 0.5.0
-Summary: LQFT Engine: Native Disk Persistence & Cold Start Deserialization (v5.0 Stable)
+Version: 0.7.0
+Summary: LQFT Engine: Strict Native C-Core & Hardware Concurrency (v0.7.0 Stable)
 Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
 Author: Parjad Minooei
 License: MIT

{lqft_python_engine-0.5.0 → lqft_python_engine-0.7.0}/lqft_python_engine.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 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-0.5.0 → lqft_python_engine-0.7.0}/lqft_python_engine.egg-info/top_level.txt

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

{lqft_python_engine-0.5.0 → lqft_python_engine-0.7.0}/setup.py

@@ -27,15 +27,15 @@ lqft_extension = Extension(
 
 setup(
     name="lqft-python-engine",
-    version="0.5.0", 
-    description="LQFT Engine: Native Disk Persistence & Cold Start Deserialization (v5.0 Stable)",
+    version="0.7.0", 
+    description="LQFT Engine: Strict Native C-Core & Hardware Concurrency (v0.7.0 Stable)",
     long_description=long_description,
     long_description_content_type="text/markdown",
     author="Parjad Minooei",
     url="https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-",
     ext_modules=[lqft_extension],
     packages=find_packages(),
-    py_modules=["lqft_engine", "pure_python_ds"],
+    py_modules=["lqft_engine"], 
     install_requires=['psutil'],
     license="MIT",
     classifiers=[

lqft_python_engine-0.5.0/lqft_engine.py

@@ -1,244 +0,0 @@
-import hashlib
-import weakref
-import psutil
-import os
-import json
-
-# ---------------------------------------------------------
-# LEGACY PURE PYTHON LQFT (For reference/fallback)
-# ---------------------------------------------------------
-class LQFTNode:
-    __slots__ = ['children', 'value', 'key_hash', 'struct_hash', '__weakref__']
-    _registry = weakref.WeakValueDictionary()
-    _null_cache = {}
-
-    def __init__(self, value=None, children=None, key_hash=None):
-        self.value = value
-        self.key_hash = key_hash
-        self.children = children or {}
-        self.struct_hash = self._calculate_struct_hash()
-
-    def _calculate_struct_hash(self):
-        child_sigs = tuple(sorted([(k, v.struct_hash) for k, v in self.children.items()]))
-        k_identity = str(self.key_hash) if self.key_hash is not None else ""
-        data = f"v:{self.value}|k:{k_identity}|c:{child_sigs}".encode()
-        return hashlib.md5(data).hexdigest()
-
-    @classmethod
-    def get_canonical(cls, value, children, key_hash=None):
-        if children == {}: children = None
-        child_sigs = tuple(sorted([(k, v.struct_hash) for k, v in (children or {}).items()]))
-        k_identity = str(key_hash) if key_hash is not None else ""
-        lookup_hash = hashlib.md5(f"v:{value}|k:{k_identity}|c:{child_sigs}".encode()).hexdigest()
-        if lookup_hash in cls._registry: return cls._registry[lookup_hash]
-        new_node = cls(value, children, key_hash)
-        cls._registry[lookup_hash] = new_node
-        return new_node
-
-    @classmethod
-    def get_null(cls):
-        if 'null' not in cls._null_cache:
-            cls._null_cache['null'] = cls.get_canonical(None, None, None)
-        return cls._null_cache['null']
-
-class LQFT:
-    def __init__(self, bit_partition=5, max_bits=256):
-        self.partition = bit_partition 
-        self.max_bits = max_bits 
-        self.mask = (1 << bit_partition) - 1
-        self.root = LQFTNode.get_null()
-
-    def _get_hash(self, key):
-        return int(hashlib.sha256(str(key).encode()).hexdigest(), 16)
-
-    def insert(self, key, value):
-        h = self._get_hash(key)
-        null_node = LQFTNode.get_null()
-        path, curr, bit_depth = [], self.root, 0
-        
-        while curr is not null_node and curr.value is None:
-            segment = (h >> bit_depth) & self.mask
-            path.append((curr, segment))
-            if segment not in curr.children:
-                curr = null_node
-                break
-            curr = curr.children[segment]
-            bit_depth += self.partition
-            
-        new_sub_node = None
-        if curr is null_node:
-            new_sub_node = LQFTNode.get_canonical(value, None, h)
-        elif curr.key_hash == h:
-            new_sub_node = LQFTNode.get_canonical(value, curr.children, h)
-        else:
-            old_h, old_val, temp_depth = curr.key_hash, curr.value, bit_depth
-            while temp_depth < self.max_bits:
-                s_old, s_new = (old_h >> temp_depth) & self.mask, (h >> temp_depth) & self.mask
-                if s_old != s_new:
-                    c_old = LQFTNode.get_canonical(old_val, None, old_h)
-                    c_new = LQFTNode.get_canonical(value, None, h)
-                    new_sub_node = LQFTNode.get_canonical(None, {s_old: c_old, s_new: c_new}, None)
-                    break
-                else:
-                    path.append(("split", s_old))
-                    temp_depth += self.partition
-            if new_sub_node is None:
-                new_sub_node = LQFTNode.get_canonical(value, curr.children, h)
-                
-        for entry in reversed(path):
-            if entry[0] == "split":
-                new_sub_node = LQFTNode.get_canonical(None, {entry[1]: new_sub_node}, None)
-            else:
-                p_node, segment = entry
-                new_children = dict(p_node.children)
-                new_children[segment] = new_sub_node
-                new_sub_node = LQFTNode.get_canonical(p_node.value, new_children, p_node.key_hash)
-        self.root = new_sub_node
-
-    def search(self, key):
-        h, curr, null_node, bit_depth = self._get_hash(key), self.root, LQFTNode.get_null(), 0
-        while curr is not null_node:
-            if curr.value is not None: return curr.value if curr.key_hash == h else None
-            segment = (h >> bit_depth) & self.mask
-            if segment not in curr.children: return None
-            curr, bit_depth = curr.children[segment], bit_depth + self.partition
-            if bit_depth >= self.max_bits: break
-        return None
-
-# ---------------------------------------------------------
-# ADAPTIVE ENTERPRISE ENGINE (v0.5.0 - Disk Persistence)
-# ---------------------------------------------------------
-try:
-    import lqft_c_engine
-    C_ENGINE_READY = True
-except ImportError:
-    C_ENGINE_READY = False
-
-class AdaptiveLQFT:
-    def __init__(self, migration_threshold=50000):
-        self.threshold = migration_threshold
-        self.size = 0
-        self.is_native = False
-        self._light_store = {} 
-        
-        self.auto_purge_enabled = True
-        self.max_memory_mb = 1000.0 
-        self.total_ops = 0
-        self._process = psutil.Process(os.getpid())
-
-    def _validate_type(self, key, value=None):
-        if not isinstance(key, str):
-            raise TypeError(f"LQFT keys must be strings. Received: {type(key).__name__}")
-        if value is not None and not isinstance(value, str):
-            raise TypeError(f"LQFT values must be strings. Received: {type(value).__name__}")
-
-    def _get_64bit_hash(self, key):
-        return int(hashlib.md5(key.encode()).hexdigest()[:16], 16)
-
-    def set_auto_purge_threshold(self, threshold: float):
-        self.purge_threshold = threshold
-
-    def purge(self):
-        current_mb = self._process.memory_info().rss / (1024 * 1024)
-        if current_mb >= self.max_memory_mb:
-            print(f"\n[⚠️ CIRCUIT Breaker] Engine exceeded {self.max_memory_mb} MB limit (Currently {current_mb:.1f} MB). Auto-Purging!")
-        self.clear()
-
-    # --- Phase 1: Native Disk Persistence ---
-    def save_to_disk(self, filepath: str):
-        """Serializes the engine state to disk (O(1) Time context scaling)."""
-        if not self.is_native:
-            with open(filepath, 'w') as f:
-                json.dump(self._light_store, f)
-        else:
-            lqft_c_engine.save_to_disk(filepath)
-
-    def load_from_disk(self, filepath: str):
-        """Instantly reconstructs C-Pointers from a binary file."""
-        if not os.path.exists(filepath):
-            raise FileNotFoundError(f"Missing LQFT database file: {filepath}")
-            
-        if not self.is_native:
-            # Check if it's a C-Engine binary file (magic bytes "LQFT")
-            with open(filepath, 'rb') as f:
-                if f.read(4) == b'LQFT':
-                    self._migrate_to_native()
-                    lqft_c_engine.load_from_disk(filepath)
-                    return
-            with open(filepath, 'r') as f:
-                self._light_store = json.load(f)
-                self.size = len(self._light_store)
-        else:
-            lqft_c_engine.load_from_disk(filepath)
-
-    def _migrate_to_native(self):
-        if not C_ENGINE_READY:
-            self.threshold = float('inf') 
-            return
-        for key, val in self._light_store.items():
-            h = self._get_64bit_hash(key)
-            lqft_c_engine.insert(h, val)
-        self._light_store.clear()
-        self.is_native = True
-
-    def insert(self, key, value):
-        self._validate_type(key, value)
-        self.total_ops += 1
-        if self.auto_purge_enabled and self.total_ops % 5000 == 0:
-            current_mb = self._process.memory_info().rss / (1024 * 1024)
-            if current_mb >= self.max_memory_mb:
-                self.purge()
-
-        if not self.is_native:
-            if key not in self._light_store: 
-                self.size += 1
-            self._light_store[key] = value
-            if self.size >= self.threshold: 
-                self._migrate_to_native()
-        else:
-            h = self._get_64bit_hash(key)
-            lqft_c_engine.insert(h, value)
-
-    def remove(self, key):
-        self._validate_type(key)
-        if not self.is_native:
-            if key in self._light_store:
-                del self._light_store[key]
-                self.size -= 1
-        else:
-            h = self._get_64bit_hash(key)
-            lqft_c_engine.delete(h)
-
-    def delete(self, key):
-        self.remove(key)
-
-    def search(self, key):
-        self._validate_type(key)
-        if not self.is_native: 
-            return self._light_store.get(key, None)
-        else:
-            h = self._get_64bit_hash(key)
-            return lqft_c_engine.search(h)
-
-    def clear(self):
-        self._light_store.clear()
-        self.size = 0
-        if C_ENGINE_READY: 
-            return lqft_c_engine.free_all()
-        return 0
-
-    def get_stats(self):
-        if self.is_native and C_ENGINE_READY: 
-            return lqft_c_engine.get_metrics()
-        return {"physical_nodes": 0}
-
-    def __del__(self):
-        try: self.clear()
-        except: pass
-
-    def status(self):
-        return {
-            "mode": "Native Merkle-DAG" if self.is_native else "Lightweight C-Hash",
-            "items": self.size if not self.is_native else lqft_c_engine.get_metrics().get('physical_nodes', self.size),
-            "threshold": self.threshold
-        }

lqft_python_engine-0.5.0/pure_python_ds.py

@@ -1,139 +0,0 @@
-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