AbstractIntegratedModule 0.3.6__tar.gz → 0.3.8__tar.gz

{abstractintegratedmodule-0.3.6 → abstractintegratedmodule-0.3.8/AbstractIntegratedModule.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.3.6
+Version: 0.3.8
 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.6.
+- Development Stage: Beta, 0.3.8.
 - 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.

{abstractintegratedmodule-0.3.6 → abstractintegratedmodule-0.3.8}/AbstractIntegratedModule.py

@@ -333,8 +333,11 @@ class GeometricWeightShaping:
         trB = (1/2 + mag_G) / (1.0 + trA**2)
         trC = (1/6 + K_G) / (trB**2 - 1.0)
 
+        if np.isnan(trC) or np.isinf(trC):
+            trC = anisotropy * (1.0 - np.std(x)) + eps
+
         floating_point = np.random.uniform(0, trC, size=X.shape)        
-        return trC, k, floating_point, structured_noise
+        return k, floating_point, structured_noise
 
 
     def spectral_signature(self, x, structured_noise, k=5):
@@ -400,11 +403,10 @@ class GeometricWeightShaping:
         anisotropy = self.anisotropy_measurement(x)
         mag = np.mean(np.linalg.norm(x))
 
-        trC, k, floating_point, structured_noise = self.eigenvalue_encoder(x)
+        k, floating_point, structured_noise = self.eigenvalue_encoder(x)
         AME = self.AME_Encoder(x)
         AMR = 1.0 / (1.0 + np.exp(-AME)) # abstract modelling rate        
-        if np.isnan(trC) or np.isinf(trC):
-            trC = (1.0 - AMR) + eps
+    
 
         spectral_similarity = self.spectral_similarity(x, floating_point, structured_noise)
 
@@ -4753,11 +4755,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:
@@ -4854,6 +4864,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
         
@@ -4873,7 +4884,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
@@ -4884,7 +4894,6 @@ class AgentDistributedInference:
         
         self.pending_requests = {}  # request_id -> Future
         self.request_lock = threading.Lock()        
-     
 
     # ============ SECURITY FEATURES ============
 
@@ -5189,6 +5198,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'}")
@@ -5246,7 +5257,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}")
@@ -5270,18 +5284,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 ============
@@ -5801,9 +5823,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()
@@ -5840,7 +5866,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 ============
@@ -7446,12 +7483,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):
@@ -9790,16 +9836,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
                 
@@ -9809,20 +9870,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:
@@ -11036,8 +11106,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):
@@ -12350,6 +12420,7 @@ class ConsecutivePeerAgent:
         self.stats['predictions'] += 1
         return best_result
     
+
     def start_server(self):
         """Start server to accept peer connections"""
         
@@ -12357,8 +12428,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}!")
@@ -12377,14 +12452,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}")
@@ -12450,21 +12533,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 {
@@ -13652,23 +13746,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:
@@ -13765,19 +13876,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")
 
 
 
@@ -13786,12 +13897,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()
@@ -13909,7 +14022,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.6/AbstractIntegratedModule.egg-info → abstractintegratedmodule-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.3.6
+Version: 0.3.8
 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.6.
+- Development Stage: Beta, 0.3.8.
 - 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.

{abstractintegratedmodule-0.3.6 → abstractintegratedmodule-0.3.8}/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.6.
+- Development Stage: Beta, 0.3.8.
 - 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.

{abstractintegratedmodule-0.3.6 → abstractintegratedmodule-0.3.8}/setup.py

@@ -8,7 +8,7 @@ class BinaryDistribution(Distribution):
 
 setup(
     name="AbstractIntegratedModule",
-    version="0.3.6",
+    version="0.3.8",
     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",