AbstractIntegratedModule 1.0.3__tar.gz → 1.0.4__tar.gz

{abstractintegratedmodule-1.0.3 → abstractintegratedmodule-1.0.4}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.0.3
+Version: 1.0.4
 Summary: Integrated Pipeline with Specialized Non-LLM AI Agent Framework for ARM64 architecture
 Author: Micro-Novelty
 Author-email: Micro-Novelty <hernikpuspita5@gmail.com>

{abstractintegratedmodule-1.0.3 → abstractintegratedmodule-1.0.4}/AbstractIntegratedModule.py

@@ -8125,7 +8125,7 @@ class AgentDistributedInference:
                     continue
 
                 if message.get('type') == 2:  # PREDICT_RESPONSE
-                    continue  # Skip, we'll read it in request_prediction_method
+                    continue  # Skipped
 
                 message = self._receive_message(client) 
                 self.temporary_message = message
@@ -8630,7 +8630,7 @@ class AgentDistributedInference:
                 return response['prediction'], response['text']
             return None, None
         except Exception as e:
-            print(f"Vote request failed: {e}")
+            print(f"[-] Vote request failed: {e}")
             return None, None
     
     def sync_memory_with_agent(self, agent_id, memory_name, timeout=10):
@@ -17367,7 +17367,7 @@ class PipelinePredictionManager:
                 if 'sec_predicted' in result:
                     sec_status = ": ✅" if result['sec_predicted'] == result['expected'] else ": ❌"                
                     print(f"[=] Second Expectation: {result['expected']} || Model Answer: {sec_status}")    
-                    if result['sec_predicted'] == result['expected']:
+                    if 'sec_predicted' in result and 'sec_confidence' in result and result['sec_predicted'] == result['expected']:
                         self.pipeline.accurate_cache_lookup.add_verified(
                             X_samples, input_ids, 
                             result['sec_predicted'], result['sec_confidence'], result['sec_index'],
@@ -17734,7 +17734,17 @@ class ConsecutivePeerAgent:
                     print(f'[==] Peer result: {result['prediction']} With Confidence: {result['confidence']}')
 
             if peer_results:
-                best_peer = max(peer_results, key=lambda x: x['confidence'])                                   
+                best_peer = max(peer_results, key=lambda x: x['confidence']) 
+                if isinstance(peer_results[0], dict):
+                    total_weight = len(peer_addresses) + 1
+                    best_result = best_peer.get('prediction') 
+                    best_confidence = min(best_peer.get('confidence') / total_weight, 1.0)
+                    
+                    print(f"[ConsecutivePeerAgent] Using Ensemble prediction result is: {best_result} || With Confidence: ({best_confidence:.1%})")
+                    self.stats['predictions'] += 1
+
+                    return best_peer  
+
                 if best_peer['confidence'] > local_result['confidence']:
                     best_result = best_peer
                     print(f"[ConsecutivePeerAgent] Using peer result: {best_peer['prediction']} || Confidence: ({best_peer['confidence']:.1%})")
@@ -18104,7 +18114,7 @@ class CohesiveAgentDeployment:
         
     async def _prediction_worker(self, texts: list, api_key: str = None, client_ip: str = None) -> dict:
         # Worker function for processing predictions
-        # This runs in a thread pool via asyncio.to_thread
+        # runs in a thread pool via asyncio.to_thread
         return self.async_manager.predict(
             texts=texts,
             timeout=self.pipeline.timeout,
@@ -18340,30 +18350,10 @@ class CohesiveAgentDeployment:
             sock.close()
 
     
-    async def _peer_health_monitor(self):
-        # Monitor peer health and reconnect if needed
-        logger.info("[💓] Peer health monitor started")
-        
-        while not self._shutdown_event.is_set():
-            await asyncio.sleep(30)
-            
-            try:
-                # Ping all connected peers
-                alive_agents = self.pipeline.distribution.broadcast_ping()
-                logger.info(f"[=+=] Connected peers: {len(alive_agents)}")
-                
-                # Reconnect to known peers that went offline
-                for peer_key, peer_info in self._known_peers.items():
-                    if not peer_info.get('connected', False):
-                        logger.info(f"[==] Attempting to reconnect to {peer_key}")
-                        await self._connect_to_peer(peer_info['host'], peer_info['port'])
-                        
-            except Exception as e:
-                logger.error(f"[❌] Peer health monitor error: {e}")
-       
     
     async def _health_monitor(self):
         # Background health monitoring
+        print("[💓] Peer health monitor started")
         while not self._shutdown_event.is_set():
             await asyncio.sleep(30)
             
@@ -18719,7 +18709,7 @@ class CohesiveAgentDeployment:
             if already_connected:
                 continue
             
-            # ✅ Step 4: Single connection attempt (NO RETRY)
+            # ✅ 4: Single connection attempt (NO RETRYS)
             print(f"[=] Connecting to {peer_key}...")
             
             try:
@@ -18792,35 +18782,6 @@ class CohesiveAgentDeployment:
             logger.warning(f"[=-] Peer {agent_id} failed: {e}")
             return None
 
-    def _ensemble_predictions(self, local: dict, peers: list) -> dict:
-        # Combine predictions from multiple agents
-        try:
-            print('[=+=] Initiating Ensemble weighting with: {peers} peers total')
-            votes = defaultdict(float)
-            votes[local.get('prediction', 'unknown')] += local.get('confidence', 0)
-            
-            for peer in peers:
-                if peer and isinstance(peer, dict):
-                    votes[peer.get('prediction', 'unknown')] += peer.get('confidence', 0)
-            
-            best_pred = max(votes.items(), key=lambda x: x[1])
-            
-            total_weight = len(peers) + 1
-            return {
-                'prediction': best_pred[0],
-                'confidence': min(best_pred[1] / total_weight, 1.0),
-                'local_prediction': local.get('prediction'),
-                'local_confidence': local.get('confidence'),
-                'peer_count': len(peers),
-                'ensemble_votes': dict(votes)
-            }
-        except Exception as e:
-            print(f'[-] Error in ensemble weighting; {e}, returning local prediction with 0.0 confidence')
-            return {
-                'prediction': local,
-                'confidence': 0.0,
-                'peer_count': 0.0,
-            }
      
 
     async def predict_batch_async(self, texts: List[str], api_key: str = None, client_ip: str = None) -> List[dict]: