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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: lqft-python-engine
-Version: 0.3.0
-Summary: LQFT Engine: Memory Circuit Breaker & Strict Type Safety (v5.0 Stable)
+Version: 0.5.0
+Summary: LQFT Engine: Native Disk Persistence & Cold Start Deserialization (v5.0 Stable)
 Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
 Author: Parjad Minooei
 License: MIT

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

@@ -11,28 +11,27 @@
 #include <stdint.h>
 
 /**
- * LQFT C-Engine - V5.0 (Active ARC Deletion & Full CRUD)
+ * LQFT C-Engine - V0.5.0 (Native Disk Persistence)
  * Architect: Parjad Minooei
  * * CHANGE LOG:
- * - Implemented Automatic Reference Counting (ARC).
- * - Added cascading `decref` for immediate RAM reclamation on deletion.
- * - Added Open-Addressing Tombstones to the Global Registry.
- * - Resolved all GCC -Wsign-compare warnings for production-grade builds.
+ * - Implemented Binary Serialization (save_to_disk).
+ * - Implemented O(1) Cold Start Deserialization (load_from_disk).
+ * - DAG Pointer Reconstruction Logic.
  */
 
 #define BIT_PARTITION 5
 #define MAX_BITS 64 
 #define MASK 0x1F 
 #define REGISTRY_SIZE 8000009 
-#define TOMBSTONE ((LQFTNode*)1) // Special pointer for freed registry slots
+#define TOMBSTONE ((LQFTNode*)1)
 
 typedef struct LQFTNode {
     void* value;
     uint64_t key_hash;
     struct LQFTNode* children[32]; 
     char struct_hash[17]; 
-    uint64_t full_hash_val; // Cached for O(1) registry removal
-    int ref_count;          // Tracks active branch dependencies
+    uint64_t full_hash_val;
+    int ref_count;
 } LQFTNode;
 
 static LQFTNode** registry = NULL;
@@ -43,7 +42,7 @@ const uint64_t FNV_OFFSET_BASIS = 14695981039346656037ULL;
 const uint64_t FNV_PRIME = 1099511628211ULL;
 
 // -------------------------------------------------------------------
-// Core Hashing & Memory Utilities
+// Utilities
 // -------------------------------------------------------------------
 uint64_t fnv1a_update(uint64_t hash, const void* data, size_t len) {
     const uint8_t* p = (const uint8_t*)data;
@@ -77,32 +76,23 @@ LQFTNode* create_node(void* value, uint64_t key_hash) {
     node->value = value;
     node->key_hash = key_hash;
     node->full_hash_val = 0;
-    node->ref_count = 0; // Starts at 0 until adopted by a parent
+    node->ref_count = 0;
     for (int i = 0; i < 32; i++) node->children[i] = NULL;
     return node;
 }
 
 // -------------------------------------------------------------------
-// Active ARC Deletion Logic
+// Memory Management (ARC)
 // -------------------------------------------------------------------
 void decref(LQFTNode* node) {
     if (!node) return;
-    
     node->ref_count--;
-    
-    // If no branches point to this node anymore, obliterate it.
     if (node->ref_count <= 0) {
-        // 1. Cascade destruction to children
         for (int i = 0; i < 32; i++) {
-            if (node->children[i]) {
-                decref(node->children[i]);
-            }
+            if (node->children[i]) decref(node->children[i]);
         }
-        
-        // 2. Remove from global registry (Replace with Tombstone)
         uint32_t idx = node->full_hash_val % REGISTRY_SIZE;
         uint32_t start_idx = idx;
-        
         while (registry[idx] != NULL) {
             if (registry[idx] == node) {
                 registry[idx] = TOMBSTONE;
@@ -111,16 +101,171 @@ void decref(LQFTNode* node) {
             idx = (idx + 1) % REGISTRY_SIZE;
             if (idx == start_idx) break;
         }
-        
-        // 3. Physically free memory back to the OS
         if (node->value) free(node->value);
         free(node);
         physical_node_count--;
     }
 }
 
+static PyObject* method_free_all(PyObject* self, PyObject* args) {
+    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;
+        }
+        free(registry);
+        registry = NULL;
+    }
+    physical_node_count = 0;
+    global_root = NULL;
+    Py_RETURN_NONE;
+}
+
+// -------------------------------------------------------------------
+// Disk Persistence (Binary Serialization)
+// -------------------------------------------------------------------
+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;
+            }
+            fwrite(child_refs, sizeof(uint64_t), 32, fp);
+        }
+    }
+
+    fclose(fp);
+    Py_RETURN_TRUE;
+}
+
+LQFTNode* find_in_registry(uint64_t full_hash) {
+    if (full_hash == 0) return NULL;
+    uint32_t idx = full_hash % REGISTRY_SIZE;
+    uint32_t start_idx = idx;
+    while (registry[idx] != NULL) {
+        if (registry[idx] != TOMBSTONE && registry[idx]->full_hash_val == full_hash) {
+            return registry[idx];
+        }
+        idx = (idx + 1) % REGISTRY_SIZE;
+        if (idx == start_idx) break;
+    }
+    return NULL;
+}
+
+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;
+    }
+
+    // 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;
+        }
+
+        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++;
+    }
+
+    // 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);
+            }
+        }
+    }
+
+    global_root = find_in_registry(root_hash);
+
+    free(all_child_refs);
+    free(loaded_nodes);
+    fclose(fp);
+
+    Py_RETURN_TRUE;
+}
+
 // -------------------------------------------------------------------
-// Merkle-DAG Deduplication
+// Merkle-DAG Core (Standard Operations)
 // -------------------------------------------------------------------
 LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
     if (!init_registry()) return NULL;
@@ -148,26 +293,23 @@ LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
     uint32_t start_idx = idx;
     int first_tombstone = -1;
 
-    // Search registry (Skipping Tomestones)
     while (registry[idx] != NULL) {
         if (registry[idx] == TOMBSTONE) {
             if (first_tombstone == -1) first_tombstone = (int)idx;
         } else if (registry[idx]->full_hash_val == full_hash && strcmp(registry[idx]->struct_hash, lookup_hash) == 0) {
-            if (value) free(value); // Free duplicate string payload
+            if (value) free(value);
             return registry[idx];
         }
         idx = (idx + 1) % REGISTRY_SIZE;
         if (idx == start_idx) break; 
     }
 
-    // Create a physical new node if identity doesn't exist
     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];
-            // Anchor the child to this new parent
             if (children[i]) children[i]->ref_count++; 
         }
     }
@@ -175,8 +317,6 @@ LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
     strcpy(new_node->struct_hash, lookup_hash);
     new_node->full_hash_val = full_hash;
     
-    // Insert into registry (Reusing tombstones if possible)
-    // SYSTEM FIX: Explicitly cast first_tombstone to uint32_t to match idx
     uint32_t insert_idx = (first_tombstone != -1) ? (uint32_t)first_tombstone : idx;
     registry[insert_idx] = new_node;
     physical_node_count++;
@@ -184,62 +324,6 @@ LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
     return new_node;
 }
 
-// -------------------------------------------------------------------
-// Python Wrapper API
-// -------------------------------------------------------------------
-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;
-    }
-
-    // Key not found, abort
-    if (curr == NULL || curr->key_hash != h) Py_RETURN_NONE;
-
-    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;
-
-        // SYSTEM FIX: Use uint32_t for j to safely compare with segment
-        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);
-    }
-
-    // Anchor new root and release the old one
-    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); // Trigger Active Deletion Cascade
-
-    Py_RETURN_NONE;
-}
-
 static PyObject* method_insert(PyObject* self, PyObject* args) {
     unsigned long long h;
     char* val_str;
@@ -313,10 +397,9 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
         }
     }
     
-    // Anchor new root and release the old one
     global_root = new_sub_node;
     global_root->ref_count++;
-    if (old_root) decref(old_root); // Trigger Active Deletion Cascade
+    if (old_root) decref(old_root); 
 
     Py_RETURN_NONE;
 }
@@ -338,20 +421,53 @@ static PyObject* method_search(PyObject* self, PyObject* args) {
     Py_RETURN_NONE;
 }
 
-static PyObject* method_free_all(PyObject* self, PyObject* args) {
-    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]);
+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;
+
+    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;
             }
-            registry[i] = NULL;
         }
-        free(registry);
-        registry = NULL;
+
+        if (!has_other_children && i > 0) new_sub_node = NULL;
+        else new_sub_node = get_canonical(NULL, 0, new_children);
     }
-    physical_node_count = 0;
-    global_root = NULL;
+
+    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); 
+
     Py_RETURN_NONE;
 }
 
@@ -361,13 +477,14 @@ static PyObject* method_get_metrics(PyObject* self, PyObject* args) {
 
 static PyMethodDef LQFTMethods[] = {
     {"insert", method_insert, METH_VARARGS, "Insert key-value"},
-    {"delete", method_delete, METH_VARARGS, "Active ARC Delete key"},
+    {"delete", method_delete, METH_VARARGS, "Delete key"},
     {"search", method_search, METH_VARARGS, "Search key"},
-    {"get_metrics", method_get_metrics, METH_VARARGS, "Get engine stats"},
+    {"save_to_disk", method_save_to_disk, METH_VARARGS, "Serialize to .bin"},
+    {"load_from_disk", method_load_from_disk, METH_VARARGS, "Deserialize from .bin"},
+    {"get_metrics", method_get_metrics, METH_VARARGS, "Get stats"},
     {"free_all", method_free_all, METH_VARARGS, "Total memory wipe"},
     {NULL, NULL, 0, NULL}
 };
 
 static struct PyModuleDef lqftmodule = { PyModuleDef_HEAD_INIT, "lqft_c_engine", NULL, -1, LQFTMethods };
-
 PyMODINIT_FUNC PyInit_lqft_c_engine(void) { return PyModule_Create(&lqftmodule); }

{lqft_python_engine-0.3.0 → lqft_python_engine-0.5.0}/lqft_engine.py

@@ -2,6 +2,7 @@ import hashlib
 import weakref
 import psutil
 import os
+import json
 
 # ---------------------------------------------------------
 # LEGACY PURE PYTHON LQFT (For reference/fallback)
@@ -104,9 +105,8 @@ class LQFT:
             if bit_depth >= self.max_bits: break
         return None
 
-
 # ---------------------------------------------------------
-# ADAPTIVE ENTERPRISE ENGINE (v0.3.0)
+# ADAPTIVE ENTERPRISE ENGINE (v0.5.0 - Disk Persistence)
 # ---------------------------------------------------------
 try:
     import lqft_c_engine
@@ -115,62 +115,74 @@ except ImportError:
     C_ENGINE_READY = False
 
 class AdaptiveLQFT:
-    """
-    A polymorphic, heuristic-driven data structure wrapper.
-    - Scale < threshold: Acts as an ultra-lightweight C-Hash (Python Dict).
-    - Scale > threshold: Automatically migrates to the Native C-Engine LQFT 
-      for Merkle-DAG deduplication and folding.
-    """
     def __init__(self, migration_threshold=50000):
         self.threshold = migration_threshold
         self.size = 0
         self.is_native = False
         self._light_store = {} 
         
-        # --- Systems Architecture: Process Memory Limit ---
         self.auto_purge_enabled = True
-        # Instead of global OS RAM, we set a hard cap for THIS specific process.
-        self.max_memory_mb = 1000.0 # 1 Gigabyte Limit
+        self.max_memory_mb = 1000.0 
         self.total_ops = 0
         self._process = psutil.Process(os.getpid())
 
     def _validate_type(self, key, value=None):
-        """Strict type guarding to prevent arbitrary objects from bleeding into C-Memory."""
         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):
-        """Generates a 64-bit unsigned hash for the C-Engine."""
         return int(hashlib.md5(key.encode()).hexdigest()[:16], 16)
 
+    def set_auto_purge_threshold(self, threshold: float):
+        self.purge_threshold = threshold
+
     def purge(self):
-        """Manual Purge Override to instantly free RAM."""
         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):
-        """The 'Curve Flip' mechanism: moves all data to the Heavy Engine."""
         if not C_ENGINE_READY:
-            print("[!] Warning: C-Engine missing. Staying in lightweight mode.")
-            self.threshold = float('inf') # Prevent continuous upgrade attempts
+            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):
-        # 1. Type Guard (Blocks the Poison Pill test)
         self._validate_type(key, value)
-
-        # 2. Performance Safety: Process Memory Check
         self.total_ops += 1
         if self.auto_purge_enabled and self.total_ops % 5000 == 0:
             current_mb = self._process.memory_info().rss / (1024 * 1024)
@@ -181,7 +193,6 @@ class AdaptiveLQFT:
             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:
@@ -190,7 +201,6 @@ class AdaptiveLQFT:
 
     def remove(self, key):
         self._validate_type(key)
-        
         if not self.is_native:
             if key in self._light_store:
                 del self._light_store[key]
@@ -204,7 +214,6 @@ class AdaptiveLQFT:
 
     def search(self, key):
         self._validate_type(key)
-        
         if not self.is_native: 
             return self._light_store.get(key, None)
         else:
@@ -224,10 +233,8 @@ class AdaptiveLQFT:
         return {"physical_nodes": 0}
 
     def __del__(self):
-        try: 
-            self.clear()
-        except: 
-            pass
+        try: self.clear()
+        except: pass
 
     def status(self):
         return {

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: lqft-python-engine
-Version: 0.3.0
-Summary: LQFT Engine: Memory Circuit Breaker & Strict Type Safety (v5.0 Stable)
+Version: 0.5.0
+Summary: LQFT Engine: Native Disk Persistence & Cold Start Deserialization (v5.0 Stable)
 Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
 Author: Parjad Minooei
 License: MIT

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

@@ -27,8 +27,8 @@ lqft_extension = Extension(
 
 setup(
     name="lqft-python-engine",
-    version="0.3.0", 
-    description="LQFT Engine: Memory Circuit Breaker & Strict Type Safety (v5.0 Stable)",
+    version="0.5.0", 
+    description="LQFT Engine: Native Disk Persistence & Cold Start Deserialization (v5.0 Stable)",
     long_description=long_description,
     long_description_content_type="text/markdown",
     author="Parjad Minooei",