AbstractIntegratedModule 0.3.7__tar.gz → 0.3.9__tar.gz

{abstractintegratedmodule-0.3.7 → abstractintegratedmodule-0.3.9/AbstractIntegratedModule.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.3.7
+Version: 0.3.9
 Summary: Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework
 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: Beta, 0.3.7.
+- Development Stage: Beta, 0.3.9.
 - 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.
@@ -66,7 +66,7 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
 -----
 
 <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" />
-
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/abstractintegratedmodule?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/abstractintegratedmodule)
 
 ## [+] MANN Intro
 [=] Memory augmented Neural network (MANN) is a neural network architecture coupled with an external, dynamic memory module, allowing it to store, retrieve, and update information similarly to a computer's RAM. Unlike traditional networks that store knowledge only in weight parameters, MANNs excel at fast learning, long-term dependency handling, and episodic recall, In IntegratedPipeline, Its memory is stored in a custom database inside your local machine, then later used for memory retrieval, transfered to the AI Dictionary where it can finnaly recall its memory when input condition matched with memory. 

{abstractintegratedmodule-0.3.7 → abstractintegratedmodule-0.3.9}/AbstractIntegratedModule.py

@@ -295,6 +295,7 @@ class Singleton(metaclass=SingletonMeta):
 #  allowing it to better process data with varying geometric complexity, and providing a more stable training process in scarce data environment. 
 # It can be used as a general weight initialization and shaping method for various models, especially in scenarios where data geometry is complex and data is scarce.
 
+
 class GeometricWeightShaping:
     def __init__(self, input_size, output_size):
         self.input_size = input_size
@@ -313,7 +314,7 @@ class GeometricWeightShaping:
 
         anisotropy = self.anisotropy_measurement(raw_X)
 
-        structured_noise = np.random.uniform(0, mag, size=raw_X.shape)
+        structured_noise = np.random.uniform(eps, mag, size=raw_X.shape)
         X = np.vstack((raw_X, structured_noise))
         if X.ndim == 2 and X.shape[1] == 1:
             X = np.hstack((raw_X, structured_noise))
@@ -334,9 +335,9 @@ class GeometricWeightShaping:
         trC = (1/6 + K_G) / (trB**2 - 1.0)
 
         if np.isnan(trC) or np.isinf(trC):
-            trC = anisotropy * (1.0 - mag_G) + eps
+            trC = anisotropy * (1.0 - np.std(x)) + eps
 
-        floating_point = np.random.uniform(0, trC, size=X.shape)        
+        floating_point = np.random.uniform(1e-10, trC, size=X.shape)        
         return k, floating_point, structured_noise
 
 
@@ -417,7 +418,7 @@ class GeometricWeightShaping:
         if np.isnan(efficient_distributed_energy) or np.isinf(efficient_distributed_energy):
             efficient_distributed_energy = (1 - AMR) + eps
 
-        floating_context = rng.uniform(0, efficient_distributed_energy, size=(input_size, output_size)) 
+        floating_context = rng.uniform(1e-10, efficient_distributed_energy, size=(input_size, output_size)) 
         self.floating_context = floating_context
 
         return floating_context
@@ -439,7 +440,6 @@ class GeometricWeightShaping:
         return floating_context
 
 
-
 # ________ UTILITY functions for activations and losses, can be used across different models and architectures _________
 
 def sigmoid(x):
@@ -1710,6 +1710,7 @@ class LSTMEngine:
                                         # cell state c is untouched —
                                         # preserves long-term memory
             if self.model.Wy is None:
+
                 self.model.Wy = self.model.weight_shaper.weight_shaping(x_seq)
 
             pred = h @ self.model.Wy.T + self.model.by
@@ -4755,11 +4756,19 @@ class ThreadedMessageQueue:
         
         logger.info(f"[=] Threaded message queue started with {self._worker_threads} workers")
     
-    def stop(self, timeout: float = 5.0):
+    async def stop(self):
         # Stop worker threads gracefully.
-        self._running = False
-        for thread in self._workers:
-            thread.join(timeout=timeout)
+        await self.result_queue.stop()
+
+        # cancel and wait for all workers to exit cleanly
+        for worker in self._workers:
+            worker.cancel()
+
+        if self._workers:
+            await asyncio.gather(*self._workers, return_exceptions=True)
+
+        self._workers.clear()
+
         logger.info("[=] Threaded message queue stopped")
     
     def get_stats(self) -> Dict:
@@ -4856,6 +4865,7 @@ class AgentDistributedInference:
         self.message_timeout = 30.0 
         self.CHUNK_SIZE = 8192
         self.predict_manager = predict_manager
+        self._health_check_interval = 30  # seconds
 
         self.use_async = use_async
         
@@ -4875,7 +4885,6 @@ class AgentDistributedInference:
         # Queue for outgoing messages (buffered with retry)
         self.outgoing_queue = deque()
         self.queue_processor_thread = None
-        self._health_check_interval = 10  # seconds
         self._last_health_check = time.time()       
             
         # Trust configuration
@@ -4886,7 +4895,6 @@ class AgentDistributedInference:
         
         self.pending_requests = {}  # request_id -> Future
         self.request_lock = threading.Lock()        
-     
 
     # ============ SECURITY FEATURES ============
 
@@ -5191,6 +5199,8 @@ class AgentDistributedInference:
         self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         self.socket.bind(('0.0.0.0', self.port))
+
+        self.socket.settimeout(1.0)
         self.socket.listen(5)
         self.running = True
         logger.info(f"[=] Server started on port {self.port} with SSL={'enabled' if self.enable_ssl else 'disabled'}")
@@ -5248,7 +5258,10 @@ class AgentDistributedInference:
                 thread = threading.Thread(target=self._handle_client, args=(client, addr))
                 thread.daemon = True
                 thread.start()
-                
+
+            except socket.timeout:
+                continue 
+
             except Exception as e:
                 if self.running:
                     print(f"[-] Accept error: {e}")
@@ -5272,18 +5285,26 @@ class AgentDistributedInference:
 
 
     def stop_server(self):
-        self.running = False
-        if self.socket:
-            self.socket.close()
-        
+        self.running = False   
         # Close all connections
         for conn in self.connections:
-            try:
+            try:    
                 self._send_message(conn, {'type': self.MSG_TYPES['DISCONNECT']})
+
+                conn.shutdown(socket.SHUT_RDWR)
                 conn.close()
-            except:
+            except Exception as e:
+                print(f'[= ERROR =] Socket cant be shutdown due to: {e}')
                 pass
-        
+
+        self.connections.clear()
+        if self.socket:
+            try:
+                self.socket.close()  
+            except Exception as e:
+                print(f'[= ERROR =] Socket cant be closed due to: {e}')
+                pass
+
         print("[🛑] Server stopped")
     
     # ============ CLIENT METHODS ============
@@ -5803,9 +5824,13 @@ class AgentDistributedInference:
     def _start_health_checker(self):
         # Start background health checker for async mode.
         def health_check_loop():
-            while self.running:
-                time.sleep(self._health_check_interval)
-                self._check_health()
+            for _ in range(self._health_check_interval * 10):
+                if not self.running:
+                    return
+                time.sleep(0.1)
+
+            if self.running:
+                self._check_agent_health()
         
         self._health_thread = threading.Thread(target=health_check_loop, daemon=True)
         self._health_thread.start()
@@ -5842,7 +5867,18 @@ class AgentDistributedInference:
         # Graceful shutdown.
         logger.info("[=] Shutting down AgentDistributedInference...")
         self.running = False
-        asyncio.create_task(self.message_queue.stop())
+
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                loop.call_soon_threadsafe(
+                    lambda: asyncio.ensure_future(self.message_queue.stop())
+                )
+            else:
+                loop.run_until_complete(self.message_queue.stop())
+        except Exception as e:
+            logger.warning(f"[=] Message queue stop warning: {e}")
+        
         logger.info("[=] Shutdown complete")
 
     # ============ MESSAGE HANDLING ============
@@ -7448,12 +7484,21 @@ class IntegratedPipeline:
         
         print("✅ Async shutdown complete")
     
-    def shutdown(self):
-        # Synchronous shutdown (for non-async contexts).
+    async def shutdown(self):
         if self.distribution:
-            self.distribution.stop()
-
+            self.distribution.stop()      # sync call
+            self.distribution.stop_server()
+            
+            
+            if hasattr(self, '_shutdown_event'):
+                self._shutdown_event.set()
 
+            # cancel async tasks
+            if self._async_tasks:
+                for task in self._async_tasks:
+                    if not task.done():
+                        task.cancel()
+                await asyncio.gather(*self._async_tasks, return_exceptions=True)
 
 
     def cosine_similarity(self, a, b):
@@ -9792,16 +9837,31 @@ class WorkerPool:
     async def stop(self):
         # Stop all workers
         self._running = False
+        await self.result_queue.stop()
+
+        # cancel and wait for all workers to exit cleanly
         for worker in self._workers:
             worker.cancel()
-        await asyncio.gather(*self._workers, return_exceptions=True)
-    
+
+        if self._workers:
+            await asyncio.gather(*self._workers, return_exceptions=True)
+
+        self._workers.clear()
+
+
     async def _worker(self, predict_func):
         # Worker that processes requests
         while self._running:
             try:
                 # Get next pending request
-                request = await self.result_queue.get_pending()
+                try:
+                    request = await asyncio.wait_for(
+                        self.result_queue.get_pending(), 
+                        timeout=1.0
+                    )
+                except asyncio.TimeoutError:
+                    continue   # no request yet, re-check self._running
+
                 if not request:
                     continue
                 
@@ -9811,20 +9871,29 @@ class WorkerPool:
                 
                 try:
                     # Execute prediction (run sync function in thread pool)
-                    result = await asyncio.to_thread(
-                        predict_func,
-                        texts=request.texts,
-                        api_key=request.api_key,
-                        client_ip=request.client_ip
+                    result = await asyncio.wait_for(
+                        asyncio.to_thread(
+                            predict_func,
+                            texts=request.texts,
+                            api_key=request.api_key,
+                            client_ip=request.client_ip
+                        ),
+                        timeout=30.0
                     )
                     
                     # Mark as completed
                     await self.result_queue.complete(request.request_id, result)
-                    
+                except asyncio.TimeoutError:
+                    await self.result_queue._mark_failed(request.request_id, 'timeout')      
+                except asyncio.CancelledError:
+                    # shutdown mid-prediction — mark failed and exit cleanly
+                    await self.result_queue._mark_failed(request.request_id, 'cancelled')
+                    break     
+
                 except Exception as e:
                     # Mark as failed
                     await self.result_queue._mark_failed(request.request_id, str(e))
-                    
+              
             except asyncio.CancelledError:
                 break
             except Exception as e:
@@ -11038,8 +11107,8 @@ class PipelineAsyncManager:
             self._thread = None
             self._queue_worker = None
             self._health_thread = None
-        
-        logger.info("[-] PipelineAsyncWrapper stopped")
+        print('[=] PipelineAsync Wrapper stopped')
+        logger.info("[-] PipelineAsync Wrapper stopped")
         return True
     
     def __enter__(self):
@@ -12352,6 +12421,7 @@ class ConsecutivePeerAgent:
         self.stats['predictions'] += 1
         return best_result
     
+
     def start_server(self):
         """Start server to accept peer connections"""
         
@@ -12359,8 +12429,12 @@ class ConsecutivePeerAgent:
             self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
             self.server_socket.bind(('0.0.0.0', self.port))
-
+            self.server_socket.settimeout(1.0)           
             self.server_socket.listen(5)
+
+            if self.pipeline.distribution.enable_ssl and self.pipeline.distribution.ssl_context:
+                self.server_socket = self.pipeline.distribution.ssl_context.wrap_socket(self.server_socket, server_side=True)
+
             self.running = True
             
             print(f"[ConsecutivePeerAgent] Server listening on port {self.port}!")
@@ -12379,14 +12453,22 @@ class ConsecutivePeerAgent:
                     thread = threading.Thread(target=self._handle_client, args=(client, addr))
                     thread.daemon = True
                     thread.start()
-                    
+                except socket.timeout:
+                    continue                         
                 except Exception as e:
                     if self.running:
-                        print(f"[ConsecutivePeerAgent] Server error: {e}")
+                            print(f"[ConsecutivePeerAgent] Server error: {e}")
+            try:
+                self.server_socket.close()
+            except:
+                pass
+            
+        print("[ConsecutivePeerAgent] Server Successfully Stopped listening !")
         
         thread = threading.Thread(target=server_loop, daemon=True)
         thread.start()
-    
+
+
     def _handle_client(self, client, addr):
         # Handle incoming peer connection
         print(f"[ConsecutivePeerAgent] Client connected from {addr}")
@@ -12452,21 +12534,32 @@ class ConsecutivePeerAgent:
     def stop_server(self):
         self.running = False
 
-        print('[ConsecutivePeerAgent] Server shutdown initiated...')
-        if self.server_socket:
-            self.server_socket.close()
-        
+        print('[ConsecutivePeerAgent] Initiating Server shutdown...')   
         # Close all peer connections
-        with self._lock:
-            for key, info in self.connected_peers.items():
-                try:
-                    info['sock'].close()
-                except:
-                    pass
-            
-            self.connected_peers.clear()
-            print('[ConsecutivePeerAgent] Server Successfully Stopped listening !')
-    
+        try:
+            with self._lock:
+                for key, info in self.connected_peers.items():
+                    try:
+                        info['sock'].shutdown(socket.SHUT_RDWR)
+                        info['sock'].close()
+                    except:
+                        pass
+                
+                self.connected_peers.clear()
+                if self.server_socket:
+                    try:
+                        self.server_socket.close()  
+                    except Exception as e:
+                        print(f'[ConsecutivePeerAgent] Cant close socket: {e}')
+                        pass  
+                                
+                print('[ConsecutivePeerAgent] Server Successfully Stopped listening !')
+
+        except Exception as e:
+            print(f'[ConsecutivePeerAgent] Error closing socket: {e}')
+            pass
+
+
     def get_stats(self) -> Dict:
         # Get statistics
         return {
@@ -13654,23 +13747,40 @@ class CohesiveAgentDeployment:
         # Graceful shutdown of all components
         logger.info("🛑 Shutting down agent...")
         
-        # Signal shutdown
+        # signal shutdown to all loops
         self._shutdown_event.set()
+
+        # stop worker pool.
+        if hasattr(self, 'worker_pool'):
+            await self.worker_pool.stop()
+
+        if hasattr(self, 'result_queue'):
+            await self.result_queue.stop()   
+
+        # cancel peer tasks
+        if self._peer_tasks:
+            for task in self._peer_tasks:
+                task.cancel()
+            await asyncio.gather(*self._peer_tasks, return_exceptions=True)
         
-        # Cancel peer tasks
-        for task in self._peer_tasks:
-            task.cancel()
-        
-        # Stop distribution server
+        # stop peer agent server
+        if hasattr(self, '_peer_agent'):
+            self._peer_agent.stop_server()
+
+        # stop distribution server
         if self.enable_peers:
             self.pipeline.distribution.stop_server()
-        
-        # Stop async manager
-        self.async_manager.stop(timeout=10, force=False)
-        
-        # Wait for cleanup
-        await asyncio.sleep(2)
-        
+
+        # FIX 1 — offload blocking stop() to thread so event loop stays free
+        print('[=] Stopping Asynchronous manager setup...')
+        await asyncio.get_event_loop().run_in_executor(
+            None, 
+            lambda: self.async_manager.stop(timeout=5, force=True)
+        )
+
+        await asyncio.sleep(0.5)
+        print('✅ Agent shutdown complete')
+
         logger.info("✅ Agent shutdown complete")
     
     def get_api_key(self) -> str:
@@ -13767,19 +13877,19 @@ async def run_secure_agent_cluster(pipeline,test_titles, label_map, rules, agent
         print(f"   Second Confidence: {result2.get('confidence', 0):.2%}")
 
         # Keep running briefly
-        print("\n⏳ Cluster stable. Waiting 5 seconds before shutdown...")
-        await asyncio.sleep(5)
+        print("\n⏳ Cluster stable. Waiting 30 seconds before shutdown...")
+        await asyncio.sleep(30)
+        agent1._peer_agent.stop_server()
         agent2._peer_agent.stop_server()
         
     except Exception as e:
         print(f"\n❌ Error in cluster: {e}")
         traceback.print_exc()
         
-    finally:
-        print("\n🛑 Shutting down cluster...")
-        await agent1.shutdown()
-        await agent2.shutdown()
-        print("✅ Cluster shutdown complete")
+    print("\n🛑 Shutting down cluster...")
+    await agent1.shutdown()
+    await agent2.shutdown()
+    print("✅ Cluster shutdown complete")
 
 
 
@@ -13788,12 +13898,14 @@ async def example_async_with_result_queue(pipeline, test_titles, label_map, rule
     # Example using the proper result queue
     
     agent = CohesiveAgentDeployment(
+        pipeline=pipeline,
         memory_name="test_agent",
         filename=filename,
         target_title=title_name,
         label_name=label_name,
         security_level="DEVELOPMENT",
-        enable_peers=False
+        enable_peers=False,
+        peer_discovery_port=5558
     )
     
     await agent.start()
@@ -13911,7 +14023,7 @@ def initiate_graceful_shutdown(pipeline, wrapper):
         print("[!] Some requests still pending")
     
     # Graceful shutdown
-    wrapper.stop(timeout=10)
+    wrapper.stop()
 
 def AsyncWrappertest(pipeline, prediction_manager, test_titles, label_map, rules):
     print("\n" + "="*60)

{abstractintegratedmodule-0.3.7/AbstractIntegratedModule.egg-info → abstractintegratedmodule-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.3.7
+Version: 0.3.9
 Summary: Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework
 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: Beta, 0.3.7.
+- Development Stage: Beta, 0.3.9.
 - 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.
@@ -66,7 +66,7 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
 -----
 
 <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" />
-
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/abstractintegratedmodule?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/abstractintegratedmodule)
 
 ## [+] MANN Intro
 [=] Memory augmented Neural network (MANN) is a neural network architecture coupled with an external, dynamic memory module, allowing it to store, retrieve, and update information similarly to a computer's RAM. Unlike traditional networks that store knowledge only in weight parameters, MANNs excel at fast learning, long-term dependency handling, and episodic recall, In IntegratedPipeline, Its memory is stored in a custom database inside your local machine, then later used for memory retrieval, transfered to the AI Dictionary where it can finnaly recall its memory when input condition matched with memory. 

{abstractintegratedmodule-0.3.7 → abstractintegratedmodule-0.3.9}/README.md

@@ -10,7 +10,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: Beta, 0.3.7.
+- Development Stage: Beta, 0.3.9.
 - 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.
@@ -34,7 +34,7 @@ https://github.com/Micro-Novelty/IntegratedPipeline-Specialized-Non-LLM-AI-Agent
 -----
 
 <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" />
-
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/abstractintegratedmodule?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/abstractintegratedmodule)
 
 ## [+] MANN Intro
 [=] Memory augmented Neural network (MANN) is a neural network architecture coupled with an external, dynamic memory module, allowing it to store, retrieve, and update information similarly to a computer's RAM. Unlike traditional networks that store knowledge only in weight parameters, MANNs excel at fast learning, long-term dependency handling, and episodic recall, In IntegratedPipeline, Its memory is stored in a custom database inside your local machine, then later used for memory retrieval, transfered to the AI Dictionary where it can finnaly recall its memory when input condition matched with memory. 

{abstractintegratedmodule-0.3.7 → abstractintegratedmodule-0.3.9}/setup.py

@@ -8,7 +8,7 @@ class BinaryDistribution(Distribution):
 
 setup(
     name="AbstractIntegratedModule",
-    version="0.3.7",
+    version="0.3.9",
     description="Framework for Advanced Integrated Non-LLM AI Module library - Backend Framework for Non-LLM AI Agent Framework",
     long_description=open("README.md", encoding="utf-8").read(),
     long_description_content_type="text/markdown",