AbstractIntegratedModule 0.9.5__tar.gz → 0.9.6__tar.gz

{abstractintegratedmodule-0.9.5 → abstractintegratedmodule-0.9.6}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.9.5
+Version: 0.9.6
 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.9.5 Official Release.
+- Development Stage: 0.9.6 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.

{abstractintegratedmodule-0.9.5 → abstractintegratedmodule-0.9.6}/AbstractIntegratedModule.py

@@ -2034,7 +2034,7 @@ class MLP:
             gradient = np.gradient(subnet.flatten())
 
         val = [np.linalg.norm(v) for v in gradient]
-        anisotropy = np.std(val) / np.mean(val) + eps
+        anisotropy = np.std(val) + eps / np.mean(val) 
         return anisotropy
 
     def adapt_predict_shape(self, y_pred, y_true):
@@ -6171,54 +6171,65 @@ class AsyncMessageQueue:
 
 
 class ThreadedMessageQueue:
-    # Thread-based message queue for synchronous code
+    # Thread-based message queue for synchronous code.
     def __init__(self, max_size=1000, worker_threads=4):
-        self.queue = queue.Queue(maxsize=max_size)
-        self.results = {}
-        self.handlers = {}
-        self._running = False
-        self._workers = []
+        self.queue          = queue.Queue(maxsize=max_size)
+        self.results        = {}
+        self.handlers       = {}
+        self._running       = False
+        self._workers       = []
         self._worker_threads = worker_threads
         self._stats = {
             'messages_processed': 0,
-            'messages_failed': 0,
-            'active_workers': 0
+            'messages_failed'   : 0,
+            'active_workers'    : 0
         }
         self._lock = threading.Lock()
-        
+
+
     def register_handler(self, message_type: str, handler: Callable):
-        # Register a handler for specific message type
         self.handlers[message_type] = handler
         logger.info(f"[=] Registered handler for {message_type}")
-    
+
+
     def publish(self, message: Message, timeout: float = 30.0) -> Any:
-        # Publish a message and wait for response
-        result_container = {'result': None, 'error': None, 'ready': False}
-        
+        # threading.Event.
+        done_event      = threading.Event()
+        result_container = {'result': None, 'error': None}
+
         def callback_wrapper(res):
-            result_container['result'] = res
-            result_container['ready'] = True
-        
+            # distinguish success from failure
+            if isinstance(res, Exception):
+                result_container['error'] = res
+            else:
+                result_container['result'] = res
+            done_event.set()
+
         message.callback = callback_wrapper
-        self.queue.put(message)
-        
-        start_time = time.time()
-        while not result_container['ready'] and (time.time() - start_time) < timeout:
-            time.sleep(0.01)
 
-        if not result_container['ready']:
+        try:
+            self.queue.put(message, timeout=timeout)
+        except queue.Full:
+            raise TimeoutError(f"[!] Queue full, could not enqueue message {message.id}")
+
+        signaled = done_event.wait(timeout=timeout)
+
+        if not signaled:
+            with self._lock:
+                self._stats['messages_failed'] += 1   # actually tracked now
             raise TimeoutError(f"[!] Message {message.id} timed out")
-        
-        if result_container['error']:
-            raise result_container['error']
-        
+
+        if result_container['error'] is not None:
+            with self._lock:
+                self._stats['messages_failed'] += 1
+            raise result_container['error']   # now actually raises
+
         with self._lock:
             self._stats['messages_processed'] += 1
-        
+
         return result_container['result']
-    
+
     def publish_async(self, message: Message, callback: Optional[Callable] = None):
-        # Publish without waiting
         message.callback = callback
         try:
             self.queue.put(message, block=False)
@@ -6226,15 +6237,16 @@ class ThreadedMessageQueue:
         except queue.Full:
             logger.error(f"[=] Queue full, cannot publish message {message.id}")
             return False
-    
-    def _worker(self, worker_id: int):
-        # Worker thread processing messages.
 
-        print(f'[=] Worker started: {worker_id}')
-        while self._running:
+
+
+    def _worker(self, worker_id: int, stop_event: threading.Event):
+        logger.info(f'[=] Worker started: {worker_id}')
+
+        while self._running and not stop_event.is_set():
             try:
                 message = self.queue.get(timeout=1)
-           
+
                 if message.type in self.handlers:
                     try:
                         result = self.handlers[message.type](message)
@@ -6242,57 +6254,90 @@ class ThreadedMessageQueue:
                             message.callback(result)
                     except Exception as e:
                         logger.error(f"[=] Worker {worker_id} handler failed: {e}")
+                        with self._lock:
+                            self._stats['messages_failed'] += 1
                         if message.callback:
+                            # callback_wrapper 
                             message.callback(e)
                 else:
                     logger.warning(f"[=] No handler for message type: {message.type}")
-                    
+
             except queue.Empty:
                 continue
             except Exception as e:
                 logger.error(f"[=] Worker {worker_id} error: {e}")
-    
+                # track that this worker degraded, without killing loop entirely
+                with self._lock:
+                    self._stats.setdefault('worker_errors', {})
+                    self._stats['worker_errors'][worker_id] = \
+                        self._stats['worker_errors'].get(worker_id, 0) + 1
+
+        logger.info(f'[=] Worker {worker_id} exiting cleanly')
+        with self._lock:
+            self._stats['active_workers'] = max(0, self._stats['active_workers'] - 1)
+
+
     def start(self):
-        # Start worker threads.
         if self._running:
+            logger.warning('[=] ThreadedMessageQueue already running — ignoring duplicate start')
             return
-            
-        self._running = True
+
+        self._running   = True
+        self._stop_event = threading.Event()   # allows prompt wake-up on stop
+        self._workers   = []
+
         for i in range(self._worker_threads):
-            thread = threading.Thread(target=self._worker, args=(i,), daemon=True)
+            thread = threading.Thread(
+                target=self._worker, args=(i, self._stop_event), daemon=True
+            )
             thread.start()
             self._workers.append(thread)
-        
+
         with self._lock:
             self._stats['active_workers'] = len(self._workers)
-        
+
         logger.info(f"[=] Threaded message queue started with {self._worker_threads} workers")
-    
-    async def stop(self):
-        # Stop worker threads gracefully.
-        await self.result_queue.stop()
 
-        # cancel and wait for all workers to exit cleanly
+    def stop(self, timeout: float = 5.0):
+        """
+        completely rewritten. This is a threading-based class.
+        """
+        if not self._running:
+            return
+
+        logger.info("[=] Stopping threaded message queue...")
+        self._running = False
+        self._stop_event.set()   # signal immediately
+
         for worker in self._workers:
-            worker.cancel()
+            worker.join(timeout=timeout)
+            if worker.is_alive():
+                logger.warning(
+                    f'[!] Worker thread {worker.name} did not stop within '
+                    f'{timeout}s — it will be abandoned as a daemon thread '
+                    f'(Python cannot forcibly kill threads)'
+                )
 
-        if self._workers:
-            await asyncio.gather(*self._workers, return_exceptions=True)
+        self._workers.clear()   # clear references regardless,
+                                # any stragglers are daemon threads that
+                                # die automatically when the process exits
 
-        self._workers.clear()
+        with self._lock:
+            self._stats['active_workers'] = 0
 
         logger.info("[=] Threaded message queue stopped")
-    
+
+
     def get_stats(self) -> Dict:
-        # Get queue statistics.
         with self._lock:
             return {
                 **self._stats,
                 'queue_size': self.queue.qsize(),
-                'workers': len(self._workers),
+                'workers'   : len(self._workers),
                 'is_running': self._running
             }
 
+
 # Integrated inference module that allows multiple agents to connect and share their predictions, attention maps, and confidence scores for ensemble decision making.
 # while also providing security features like authentication, rate limiting, and message validation.
 class AgentDistributedInference:
@@ -8735,73 +8780,145 @@ class QueryNode:
 # It collects requests over a short time window or until a maximum batch size is reached, then processes them together through the pipeline. This allows for improved throughput while still providing timely responses to individual requests.
 class AutoBatcherAutomation:
     def __init__(self, pipeline, max_batch_size=32, max_wait_ms=50):
-        self.pipeline = pipeline
-        self.dataset = None
+        self.pipeline       = pipeline
         self.max_batch_size = max_batch_size
-        self.max_wait_ms = max_wait_ms
-        
-        self.request_queue = deque()
-        self.processing = False
-        self.results = {}
-        self.next_id = 0
-    
+        self.max_wait_ms    = max_wait_ms
+
+        self.request_queue  = deque()
+        self.processing     = False
+        self.results        = {}
+        self.result_events  = {}   # per-request Event 
+        self.next_id        = 0
+
+        self._state_lock = threading.Lock()   # FIX 1 — guards processing flag + next_id
+
     def add_request(self, text, callback=None):
-        request_id = self.next_id
-        self.next_id += 1
-        
-        self.request_queue.append({
-            'id': request_id,
-            'text': text,
-            'callback': callback,
-            'timestamp': time.time()
-        })
-        
-        if not self.processing:
+        with self._state_lock:
+            request_id    = self.next_id
+            self.next_id += 1
+
+            event = threading.Event()
+            self.result_events[request_id] = event
+
+            self.request_queue.append({
+                'id'       : request_id,
+                'text'     : text,
+                'callback' : callback,
+                'timestamp': time.time()
+            })
+
+            # check-and-set happens atomically under the same lock
+            should_start = not self.processing
+            if should_start:
+                self.processing = True
+
+        if should_start:
             self._start_processing()
-        
+
         return request_id
-    
+
     def _start_processing(self):
-        self.processing = True
         thread = threading.Thread(target=self._process_batches, daemon=True)
         thread.start()
-    
+
     def _process_batches(self):
-        while self.request_queue:
-            # Wait for more requests or max wait time
-            time.sleep(self.max_wait_ms / 1000)
-            dataset = self.dataset
-            
-            # Collect batch
-            batch = []
-            while self.request_queue and len(batch) < self.max_batch_size:
-                batch.append(self.request_queue.popleft())
-            
-            if batch:
-                self._process_batch(batch)
-        
-        self.processing = False
-    
+        try:
+            while True:
+                with self._state_lock:
+                    if not self.request_queue:
+                        break
+
+                time.sleep(self.max_wait_ms / 1000)
+
+                batch = []
+                with self._state_lock:
+                    while self.request_queue and len(batch) < self.max_batch_size:
+                        batch.append(self.request_queue.popleft())
+
+                if batch:
+                    # never let one bad batch kill the worker permanently here.
+                    try:
+                        self._process_batch(batch)
+                    except Exception as e:
+                        logger.error(f'[!] Batch processing failed: {e}')
+                        # deliver the failure to every waiter in this batch
+                        # instead of leaving them hanging forever
+                        for req in batch:
+                            self._deliver_result(req, None, error=e)
+        finally:
+            # always reset processing, even if something above
+            # raised unexpectedly
+            with self._state_lock:
+                self.processing = False
+
+            # need catch the case where requests arrived after the
+            # while-loop's last empty check but before processing=False landed
+            with self._state_lock:
+                still_pending = bool(self.request_queue)
+                if still_pending and not self.processing:
+                    self.processing = True
+                    restart = True
+                else:
+                    restart = False
+            if restart:
+                self._start_processing()
+
     def _process_batch(self, batch):
-        texts = [req['text'] for req in batch]
-        
+        texts   = [req['text'] for req in batch]
         results = self.pipeline.prediction_batch(texts)
-        
-        # Send results back
+
         for i, req in enumerate(batch):
             result = results[i] if i < len(results) else None
-            if req['callback']:
-                req['callback'](result)
-            else:
-                self.results[req['id']] = result
-    
+            self._deliver_result(req, result)
+
+    def _deliver_result(self, req, result, error=None):
+        """Single delivery path — callback or stored result, always signals."""
+        if req['callback']:
+            try:
+                req['callback'](result if error is None else error)
+            except Exception as cb_err:
+                logger.error(f'[!] Callback failed for request {req["id"]}: {cb_err}')
+        else:
+            with self._state_lock:
+                self.results[req['id']] = result if error is None else None
+
+        # signal the waiting event 
+        event = self.result_events.get(req['id'])
+        if event:
+            event.set()
+
     def get_result(self, request_id, timeout=5):
-        start = time.time()
-        while request_id not in self.results:
-            if time.time() - start > timeout:
-                return None
-            time.sleep(0.01)
-        return self.results.pop(request_id)
+        event = self.result_events.get(request_id)
+        if event is None:
+            return None
+
+        # blocks efficiently 
+        signaled = event.wait(timeout=timeout)
+
+        with self._state_lock:
+            # always need clean up
+            result = self.results.pop(request_id, None)
+            self.result_events.pop(request_id, None)
+
+        return result if signaled else None
+
+    def cleanup_stale(self, max_age_seconds=300):
+        """
+        periodic sweep for requests that were never collected
+        via get_result (e.g. caller crashed or forgot to call it).
+        Call this periodically from a health check loop.
+        """
+        with self._state_lock:
+            now = time.time()
+            stale_ids = [
+                rid for rid, event in self.result_events.items()
+                if event.is_set()   # already delivered but never collected
+            ]
+            for rid in stale_ids:
+                self.results.pop(rid, None)
+                self.result_events.pop(rid, None)
+            if stale_ids:
+                logger.info(f'[=] Cleaned up {len(stale_ids)} stale results')
 
 
 # The IntegratedPipeline class serves as the central component that integrates all the different modules and functionalities of the system. 
@@ -13359,63 +13476,74 @@ class AsyncResultQueue:
         }
 
 class WorkerPool:
-    """
-    Worker pool that processes requests from the result queue.
-    """
-    
-    def __init__(self, result_queue: AsyncResultQueue, num_workers: int = 4):
+    """Worker pool that processes requests from the result queue."""
+
+    def __init__(self, result_queue: AsyncResultQueue, num_workers: int = 4,
+                max_consecutive_errors: int = 10):
         self.result_queue = result_queue
-        self.num_workers = num_workers
+        self.num_workers   = num_workers
         self._workers: List[asyncio.Task] = []
-        self._running = False
-    
+        self._running       = False
+        self._start_lock    = asyncio.Lock()   # FIX 1 — prevent double-start
+        self.max_consecutive_errors = max_consecutive_errors
+
+        # per-worker health tracking — FIX 4
+        self._worker_error_counts = [0] * num_workers
+        self._worker_last_active  = [0.0] * num_workers
+
     async def start(self, predict_func):
-        # Start worker pool with prediction function
-        self._running = True
-        self._workers = [
-            asyncio.create_task(self._worker(predict_func))
-            for _ in range(self.num_workers)
-        ]
+        # guard against double-start leaking orphaned tasks
+        async with self._start_lock:
+            if self._running:
+                logger.warning('[=] WorkerPool.start() called while already '
+                              'running — ignoring duplicate start')
+                return
+
+            self._running = True
+            self._worker_error_counts = [0] * self.num_workers
+            self._worker_last_active  = [time.time()] * self.num_workers
+
+            self._workers = [
+                asyncio.create_task(self._worker(predict_func, worker_idx=i))
+                for i in range(self.num_workers)
+            ]
+            await self.result_queue.start()
+            logger.info(f'[=] WorkerPool started with {self.num_workers} workers')
 
-        await self.result_queue.start()
-        
     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()
 
         if self._workers:
             await asyncio.gather(*self._workers, return_exceptions=True)
 
-        self._workers.clear()
+        self._workers.clear()   # always clear, no stale references remain
+        logger.info('[=] WorkerPool stopped, all workers cleared')
 
+    async def _worker(self, predict_func, worker_idx: int):
+        consecutive_errors = 0
 
-    async def _worker(self, predict_func):
-        # Worker that processes requests
         while self._running:
             try:
-                # Get next pending request
                 try:
                     request = await asyncio.wait_for(
-                        self.result_queue.get_pending(), 
-                        timeout=1.0
+                        self.result_queue.get_pending(), timeout=1.0
                     )
                 except asyncio.TimeoutError:
-                    continue   # no request yet, re-check self._running
+                    continue
 
                 if not request:
                     continue
-                
-                # Mark as processing
+
+                self._worker_last_active[worker_idx] = time.time()
+
                 async with self.result_queue._lock:
                     request.status = RequestStatus.PROCESSING
-                
+
                 try:
-                    # Execute prediction (run sync function in thread pool)
                     result = await asyncio.wait_for(
                         asyncio.to_thread(
                             predict_func,
@@ -13425,25 +13553,69 @@ class WorkerPool:
                         ),
                         timeout=30.0
                     )
-                    
-                    # Mark as completed
                     await self.result_queue.complete(request.request_id, result)
+                    consecutive_errors = 0   
+
                 except asyncio.TimeoutError:
-                    await self.result_queue._mark_failed(request.request_id, 'timeout')      
+                    # log that the underlying thread may still be
+                    # running; can't force-kill it, but need at least
+                    # that this is a known limitation rather than silent
+                    logger.warning(
+                        f'[!] Worker {worker_idx}: request {request.request_id} '
+                        f'timed out after 30s. The underlying OS thread may '
+                        f'still be running in the background (Python threads '
+                        f'cannot be forcibly cancelled) — consider making '
+                        f'predict_func more responsive to avoid thread buildup.'
+                    )
+
+                    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     
+                    break
 
                 except Exception as e:
-                    # Mark as failed
                     await self.result_queue._mark_failed(request.request_id, str(e))
-              
+                    consecutive_errors = 0   # per-request errors don't count
+                                             # toward the outer circuit breaker
+
             except asyncio.CancelledError:
                 break
+
             except Exception as e:
-                logger.error(f"[=] Worker error: {e}")
-                await asyncio.sleep(0.1)
+                consecutive_errors += 1
+                self._worker_error_counts[worker_idx] = consecutive_errors
+
+                logger.error(f'[=] Worker {worker_idx} error '
+                           f'({consecutive_errors}/{self.max_consecutive_errors}): {e}')
+
+                # circuit breaker with exponential backoff
+                if consecutive_errors >= self.max_consecutive_errors:
+                    logger.error(
+                        f'[!!] Worker {worker_idx} exceeded '
+                        f'{self.max_consecutive_errors} consecutive errors — '
+                        f'stopping this worker to avoid runaway resource use. '
+                        f'Pool now running with reduced capacity.'
+                    )
+                    break   
+
+                backoff = min(0.1 * (2 ** consecutive_errors), 5.0)
+                await asyncio.sleep(backoff)
+
+    def get_health(self) -> Dict:
+        """visibility into worker pool health"""
+        now = time.time()
+        return {
+            'num_workers'       : self.num_workers,
+            'active_workers'    : sum(1 for t in self._workers if not t.done()),
+            'dead_workers'      : sum(1 for t in self._workers if t.done()),
+            'worker_error_counts': list(self._worker_error_counts),
+            'worker_idle_seconds': [
+                round(now - t, 1) for t in self._worker_last_active
+            ],
+            'is_running'        : self._running,
+        }
+
 
 class PipelineAsyncManager:
     """