AbstractIntegratedModule 0.6.8__tar.gz → 0.7.0__tar.gz

{abstractintegratedmodule-0.6.8 → abstractintegratedmodule-0.7.0}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.6.8
+Version: 0.7.0
 Summary: Library for Advanced Integrated Non-LLM AI Models - Optimized Backend Framework For Non-LLM AI Agent
 Author: Micro-Novelty
 Author-email: hernikpuspita5@gmail.com
@@ -42,7 +42,7 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
 #### Note: The README here you are reading is a direct copy from my README Repository, to download the necessary files, you can visit my Repository with the provided link above.
 
 ### Library Short Description:
-- Development Stage: 0.6.8 Official Release.
+- Development Stage: 0.7.0 Official Release.
 - Maintainer: Micro-Novelty.
 - library Source-Code is Open-sourced on github.
 - Purpose: Specifically Designed for providing Non-LLM AI Agent Framework for edge Devices, Optimized for ARM64 architecture.
@@ -65,9 +65,10 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
    - Robust Advanced prediction capabilities proven effective on ARM64 Using MLP + LSTM Architectures.
    - Transformer Modules Optimized using Cython, to reduce Memory overhead and Reduce CPU Usage, With Reduced Training Time.
 - Changelog:
-     - v0.6.8:
+     - v0.7.0:
           - [=] New features: 
           - Added Rust specific compiled binary for handling complex weight matrices.
+          - added specific optimized weight saving handling with rust optimization.
 -----
 
 <img width="1280" height="600" alt="WhatsApp Image 2026-05-27 at 07 16 32" src="https://github.com/user-attachments/assets/4b58a556-45a3-419b-96fd-9c1b76cac574" />

{abstractintegratedmodule-0.6.8 → abstractintegratedmodule-0.7.0}/AbstractIntegratedModule.py

@@ -62,6 +62,15 @@ except ImportError as e:
     _OPT_AVAILABLE = False
     print(f'[=] Cython not available: {e}, using numpy fallback')
 
+try:
+    import abstract_weights_core as wc
+    _RUST_MODULE_AVAILABLE = True
+    print('[=] Rust weight storage loaded ✅')
+except ImportError as e:
+    _RUST_MODULE_AVAILABLE = False
+    print(f'[=] Rust weight storage unavailable due to: {e}, using Python sqlite3 fallback')
+
+
 # initial Setup logging for AgentDistributedInference and ModelStorage class logger and security logger
 logger = logging.getLogger(__name__)
 _integrated_pipeline_lock = threading.Lock()
@@ -4885,6 +4894,16 @@ class ModelStorage:
         }
         
         weight_json = json.dumps(weights, default=str)
+        if _RUST_MODULE_AVAILABLE:
+            try:
+                wc.save_lstm_weights(self.db_path, memory_name, weight_json)
+                print('[||] LSTM weights saved using Rust module !')
+                return
+            except Exception as e:
+                print(f'[!] Rust save failed, falling back to Python: {e}')
+        else:
+            print('[=] Rust module unavailable, using python sqlite3.')
+
         try:
             c.execute("""
                 INSERT INTO weight_storage 
@@ -4949,6 +4968,15 @@ class ModelStorage:
             output_bias     = tf.output_bias
         )
         binary_data = buf.getvalue()
+        if _RUST_MODULE_AVAILABLE:
+            try:
+                wc.save_transformer_weights(self.db_path, memory_name, binary_data)
+                print('[||] LSTM weights saved using Rust module for flexibility!')
+                return
+            except Exception as e:
+                print(f'[!] Rust save failed, falling back to Python: {e}')
+        else:
+            print('[=] Rust module unavailable, using python sqlite3.')
 
         try:
             c.execute("""
@@ -4988,21 +5016,48 @@ class ModelStorage:
         except:
             conn = sqlite3.connect(self.db_path)
 
-        c = conn.cursor()   
+        c = conn.cursor() 
+
 
         try:
-            c.execute("""
-                SELECT weights FROM weight_storage
-                WHERE memory_name = ? AND model_type = 'transformer' AND is_active = 1
-                ORDER BY id DESC LIMIT 1
-            """, (memory_name,))
-            row = c.fetchone()
-            if not row:
-                print(f'[=] No saved transformer weights for {memory_name}')
-                return False
+            if _RUST_MODULE_AVAILABLE:
+                try:
+                    binary = wc.load_transformer_weights(self.db_path, memory_name) 
+
+                    buf = io.BytesIO(bytes(row[0]))
+                    data = np.load(buf, allow_pickle=False)
 
-            buf = io.BytesIO(bytes(row[0]))
-            data = np.load(buf, allow_pickle=False)
+                    print('[+] Transformer weights data loaded using Rust module!')
+
+                except Exception as e:
+                    print(f'[=] Cant load Transformer weights: {e}, using python sqlite3 to handle weights.')
+                    time.sleep(3)
+                    c.execute("""
+                        SELECT weights FROM weight_storage
+                        WHERE memory_name = ? AND model_type = 'transformer' AND is_active = 1
+                        ORDER BY id DESC LIMIT 1
+                    """, (memory_name,))
+                    row = c.fetchone()
+                    if not row:
+                        print(f'[=] No saved transformer weights for {memory_name}')
+                        return False
+
+                    buf = io.BytesIO(bytes(row[0]))
+                    data = np.load(buf, allow_pickle=False)
+
+            else:
+                c.execute("""
+                    SELECT weights FROM weight_storage
+                    WHERE memory_name = ? AND model_type = 'transformer' AND is_active = 1
+                    ORDER BY id DESC LIMIT 1
+                """, (memory_name,))
+                row = c.fetchone()
+                if not row:
+                    print(f'[=] No saved transformer weights for {memory_name}')
+                    return False
+
+                buf = io.BytesIO(bytes(row[0]))
+                data = np.load(buf, allow_pickle=False)
 
             t = self.pipeline.model2
             t.token_embedding = data['token_embedding']
@@ -5035,7 +5090,15 @@ class ModelStorage:
 
     def load_weights(self, memory_name):
         """Load weights from database. Returns True if found."""
-        result = self.weight_retrieval(memory_name)
+        if _RUST_MODULE_AVAILABLE:
+            try:
+                result = wc.load_lstm_weights(self.db_path, memory_name)
+                print('[+] LSTM weights loaded via Rust module')
+            except:
+                result = self.weight_retrieval(memory_name)
+                print(f'[=] Cant load LSTM Weights due to: {e}, using python sqlite3 as fallback.')
+        else:
+            result = self.weight_retrieval(memory_name)           
     
         if not result:
             print(f'[=] No saved weights for {memory_name}')