AbstractIntegratedModule 0.6.4__tar.gz → 0.6.5__tar.gz

{abstractintegratedmodule-0.6.4 → abstractintegratedmodule-0.6.5/AbstractIntegratedModule.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 0.6.4
+Version: 0.6.5
 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.4 Official Release.
+- Development Stage: 0.6.5 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.
@@ -67,11 +67,11 @@ 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.4:
+     - v0.6.5:
           - [=] New features: 
-          - Ensure proper shape handling before shape alignment in Transformer Training.
-          - Fixed Silent bugs that can cause single scalar to bypass shape conditions gate in training step for Transformer.
-          - Ensure Robustness in LSTM Training step and prevent division by zero.
+          - New architecture: AccuracyAnswerCache
+            - Purpose: Storing correct answered problem for better reliability in Non-dynamic environment, triggered after the model answered correctly and initiate a new prediction, the model will choose the previous correct answer when samples match.
+          - Fixed edge case where shape mismatch bug happens during MLP Training.
 -----
 
 <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.4 → abstractintegratedmodule-0.6.5}/AbstractIntegratedModule.py

@@ -408,6 +408,7 @@ class GeometricWeightShaping:
     def anisotropy_measurement(self, x):
         eps = 1e-5
         if _OPT_AVAILABLE:
+            x = np.asarray(x)            
             x = x.reshape(x.shape[0], -1)
             return optimized_anisotropy(np.asarray(x, dtype=np.float64))
 
@@ -521,26 +522,68 @@ class Loss:
     @staticmethod
     def categorical_crossentropy(y_true, y_pred):
         eps = 1e-9
+        y_true = np.asarray(y_true, dtype=np.float64)
+        y_pred = np.asarray(y_pred, dtype=np.float64)
+
+        # normalize to 2D
+        if y_true.ndim == 1:
+            y_true = y_true[np.newaxis, :]
+        if y_pred.ndim == 1:
+            y_pred = y_pred[np.newaxis, :]
+
+        # align both batch dim (axis=0) and class dim (axis=1)
+        min_batch = min(y_true.shape[0], y_pred.shape[0])
+        min_class = min(y_true.shape[1], y_pred.shape[1])
+
+        if y_true.shape != y_pred.shape:
+            print(f'[!] Shape mismatch in crossentropy: '
+                  f'y_true={y_true.shape} y_pred={y_pred.shape} '
+                  f'— aligning to ({min_batch}, {min_class})')
+            y_true = y_true[:min_batch, :min_class]
+            y_pred = y_pred[:min_batch, :min_class]
+
         y_pred = np.clip(y_pred, eps, 1 - eps)
-        try:
-            loss = -np.mean(np.sum(y_true * np.log(y_pred), axis=1))
-        except:
-            subnet_y_pred = y_pred[:, :y_true.shape[1]]
-            subnet_y_true = y_true[:, :subnet_y_pred.shape[1]]
 
-            loss = -np.mean(np.sum(subnet_y_true * np.log(subnet_y_pred + eps), axis=1))
-        
-        return loss
+        # guard against empty result after alignment
+        if y_true.size == 0 or y_pred.size == 0:
+            print('[!] Empty arrays after alignment — returning safe default loss')
+            return 1.0
+
+        loss = -np.mean(np.sum(y_true * np.log(y_pred), axis=1))
+
+        # guard against NaN/Inf from degenerate alignment
+        if not np.isfinite(loss):
+            print(f'[!] Non-finite loss detected ({loss}) — returning safe default')
+            return 1.0
+
+        return float(loss)
 
     @staticmethod
     def softmax_crossentropy_derivative(y_true, y_pred):
-        try:
-            cross_ent = (y_pred - y_true) / y_true.shape[0]
-        except:
-            subnet_y_pred = y_pred[:, :y_true.shape[1]]
-            subnet_y_true = y_true[:, :subnet_y_pred.shape[1]]
+        y_true = np.asarray(y_true, dtype=np.float64)
+        y_pred = np.asarray(y_pred, dtype=np.float64)
+
+        if y_true.ndim == 1:
+            y_true = y_true[np.newaxis, :]
+        if y_pred.ndim == 1:
+            y_pred = y_pred[np.newaxis, :]
+
+        # align both dimensions consistently
+        min_batch = min(y_true.shape[0], y_pred.shape[0])
+        min_class = min(y_true.shape[1], y_pred.shape[1])
+
+        if y_true.shape != y_pred.shape:
+            print(f'[!] Shape mismatch in crossentropy derivative: '
+                  f'y_true={y_true.shape} y_pred={y_pred.shape} '
+                  f'— aligning to ({min_batch}, {min_class})')
+            y_true = y_true[:min_batch, :min_class]
+            y_pred = y_pred[:min_batch, :min_class]
+
+        if y_true.size == 0 or y_pred.size == 0:
+            print('[!] Empty arrays after alignment — returning zero gradient')
+            return np.zeros((1, 1))
 
-            cross_ent = (subnet_y_pred - subnet_y_true) / subnet_y_true.shape[0]
+        cross_ent = (y_pred - y_true) / y_true.shape[0]
         return cross_ent
 
 
@@ -1378,6 +1421,7 @@ class Transformer:
 
     def AME_Encoder(self, x):
         # Optimized AME_Encoder for Transformer
+        x = np.asarray(x)        
         if _OPT_AVAILABLE and np.asarray(x).ndim == 2:
             return optimized_ame_encoder(np.asarray(x, dtype=np.float64))     
 
@@ -1396,6 +1440,7 @@ class Transformer:
     def anisotropy_measurement(self, x):
         eps = 1e-5
         if _OPT_AVAILABLE:
+            x = np.asarray(x)            
             x = x.reshape(x.shape[0], -1)
             return optimized_anisotropy(np.asarray(x, dtype=np.float64))
 
@@ -1427,7 +1472,7 @@ class Transformer:
             row_sums     = attn_weights.sum(axis=-1, keepdims=True) + eps
             attn_weights = attn_weights / row_sums
 
-        # FIX 2 — fuse AME and anisotropy into single gradient pass
+        # fuse AME and anisotropy into single gradient pass
         # instead of calling AME_Encoder + anisotropy_measurement separately
         # both call np.gradient internally — compute once, reuse
         unsuitable_shape_condition = (
@@ -1456,7 +1501,7 @@ class Transformer:
         # anisotropy inline — reuses grad_norms, no second gradient call
         anisotropy_val = grad_norms.std() / (grad_norms.mean() + eps)
 
-        # FIX 3 — fuse entropy + max + var into single pass over attn_weights
+        # fuse entropy + max + var into single pass over attn_weights
         # avoids 3 separate scans of same array
         flat        = attn_weights.reshape(batch * heads * seq_len, seq_len)
 
@@ -1674,12 +1719,7 @@ class MLP:
     def prediction(self, X):
         y_pred = self.forward(X)   
         return y_pred      
-
-
-    def score(self, X, y):
-        y_pred = self.prediction(X)
-        acc = np.mean(np.argmax(y_pred, axis=1) == np.argmax(y, axis=1))
-        return acc         
+     
          
     def AME_Encoder(self, x):
         X = np.asarray(x)
@@ -1701,6 +1741,7 @@ class MLP:
     def anisotropy_measurement(self, x):
         eps = 1e-5
         if _OPT_AVAILABLE:
+            x = np.asarray(x)            
             x = x.reshape(x.shape[0], -1)
             return optimized_anisotropy(np.asarray(x, dtype=np.float64))
 
@@ -1714,22 +1755,55 @@ class MLP:
         anisotropy = np.std(val) / np.mean(val) + eps
         return anisotropy
 
+    def adapt_predict_shape(self, y_pred, y_true):
+        try:
+            y_pred_arr = np.asarray(y_pred)
+            y_arr      = np.asarray(y_true)
+
+            # normalize to 2D
+            if y_pred_arr.ndim == 1:
+                y_pred_arr = y_pred_arr[np.newaxis, :]
+            if y_arr.ndim == 1:
+                y_arr = y_arr[np.newaxis, :]
+
+            # align batch and class dims — same approach as Loss
+            min_batch = min(y_pred_arr.shape[0], y_arr.shape[0])
+            min_class = min(y_pred_arr.shape[1], y_arr.shape[1])
+
+            y_pred_aligned = y_pred_arr[:min_batch, :min_class]
+            y_aligned      = y_arr[:min_batch, :min_class]
+
+            if y_pred_aligned.size == 0 or y_aligned.size == 0:
+                print(f'[!] Cannot compute accuracy — empty after alignment')
+                acc = 0.0
+            else:
+                preds = np.argmax(y_pred_aligned, axis=1)
+                true  = np.argmax(y_aligned, axis=1)
+                acc   = float(np.mean(preds == true))
+
+            return y_pred_aligned, y_aligned
+
+        except Exception as e:
+            print(f'[!] Cant adapt shape of Y sample arrays due to: {e}')
+            return y_pred, y_true
 
     def train(self, X, y, epochs=1000, lr=0.01, verbose=True):
         focused_fit_condition = len(self.feed_layers) > 0 and self.anisotropy_measurement(X) > 0.25 and self.AME_Encoder(X) > 0.25
         print(f'[+] Focused fit condition: {focused_fit_condition} || Anisotropy: {self.anisotropy_measurement(X):.4f} || AME: {self.AME_Encoder(X):.4f}')
+
         for epoch in range(epochs):
             if not focused_fit_condition:
                 y_pred = self.forward(X)
             else:
                 y_pred = self.focused_forward(X)
 
-            loss = Loss.categorical_crossentropy(y, y_pred)
-            grad = Loss.softmax_crossentropy_derivative(y, y_pred)
+            y_pred, y_true = self.adapt_predict_shape(y_pred, y)
+            loss = Loss.categorical_crossentropy(y_true, y_pred)
+            grad = Loss.softmax_crossentropy_derivative(y_true, y_pred)
             _ = self.backward(grad, self.lr)
 
             if verbose and epoch % 100 == 0:
-                acc = np.mean(np.argmax(y_pred, axis=1) == np.argmax(y, axis=1))
+                acc = np.mean(np.argmax(y_pred, axis=1) == np.argmax(y_true, axis=1))
                 print(f"[=] Epoch {epoch} | Loss: {loss:.4f} | Acc: {acc:.2f}")
               
 # ─────────────────────────────────────────────
@@ -2836,6 +2910,7 @@ class WeightedEnsemblePredictor:
     def anisotropy_measurement(self, x):
         eps = 1e-5
         if _OPT_AVAILABLE:
+            x = np.asarray(x)            
             x = x.reshape(x.shape[0], -1)            
             return optimized_anisotropy(np.asarray(x, dtype=np.float64))
 
@@ -7830,6 +7905,7 @@ class IntegratedPipeline:
         self.output_size = 1
         self.dropout_rate = 0.1
         self.transformer_training_epochs = 100
+        self.max_size = 500
 
         # Main component setup
         self.standard_scaler = StandardScaler()
@@ -7846,6 +7922,7 @@ class IntegratedPipeline:
         self.session_automation = CrossSessionAutomation(self)
         self.batcher = AutoBatcherAutomation(self)
         self.query_node = QueryNode(self, memory_name, self.storage)
+        self.accurate_cache_lookup = AccurateAnswerCache(self, similarity_threshold=0.85, max_size=self.max_size)
 
         self._agent_mode = os.environ.get('AGENT_MODE', 'single')
         self._agent_port = int(os.environ.get('AGENT_PORT', 5555))
@@ -8544,6 +8621,7 @@ class IntegratedPipeline:
                 )   
 
         if _OPT_AVAILABLE:
+            x = np.asarray(x)
             x = x.reshape(-1, 1)
             return optimized_anisotropy(np.asarray(x, dtype=np.float64))
 
@@ -9689,7 +9767,10 @@ class IntegratedPipeline:
 
                 else:
                     if attn_weights is not None:
-                        score_quality = 1.0 / (1.0 + np.exp(-attn_weights[i]))
+                        if i <= len(attn_weights):
+                            score_quality = 1.0 / (1.0 + np.exp(-attn_weights[i]))
+                        else:
+                            score_quality = 1.0 / (1.0 + np.exp(-attn_weights[0]))                            
                     else:
                         score_quality = 1.0 / (1.0 + np.exp(-mlp_target))
 
@@ -10279,7 +10360,124 @@ class IntegratedPipeline:
         y_true = self.initialize_model_encoding(self.X, y_raw)
         self.utility_MLP_set(self.X, y_true)       
         print('✅ Done Training MLP Model! ')
-         
+
+class AccurateAnswerCache:
+    def __init__(self, pipeline, similarity_threshold=0.85, max_size=500):
+        self.pipeline = pipeline
+        self.similarity_threshold = similarity_threshold
+        self.max_size = max_size
+        self.cache = {}
+        self.exact_hash_index = {}   # O(1) exact match lookup
+
+    def add_verified(self, x_mlp, input_ids, prediction, confidence, 
+                     source='user_confirmed'):
+        key = self._make_key(x_mlp)
+
+        # hash input_ids for fast exact-match 
+        ids_hash = self._hash_ids(input_ids) if input_ids is not None else None
+
+        entry = {
+            'x_mlp'      : np.asarray(x_mlp, dtype=np.float64).ravel(),
+            'input_ids'  : np.asarray(input_ids).copy() if input_ids is not None else None,
+            'ids_hash'   : ids_hash,
+            'prediction' : prediction,
+            'confidence' : float(confidence),
+            'source'     : source,
+            'hit_count'  : 0,
+            'added_at'   : datetime.now().isoformat(),
+            'last_hit'   : None
+        }
+
+        self.cache[key] = entry
+
+        # maintain O(1) exact match index
+        if ids_hash is not None:
+            self.exact_hash_index[ids_hash] = key
+
+        if len(self.cache) > self.max_size:
+            self._evict_lru()
+
+        print(f'[💎] Verified answer cached: {prediction} (source={source})')
+
+    def lookup(self, x_mlp, input_ids=None):
+        if not self.cache:
+            return None
+
+        # FAST PATH — O(1) hash lookup 
+        if input_ids is not None:
+            ids_hash = self._hash_ids(input_ids)
+            if ids_hash in self.exact_hash_index:
+                key   = self.exact_hash_index[ids_hash]
+                entry = self.cache.get(key)
+                if entry:
+                    entry['hit_count'] += 1
+                    entry['last_hit']   = datetime.now().isoformat()
+                    return {
+                        'prediction' : entry['prediction'],
+                        'confidence' : entry['confidence'],
+                        'similarity' : 1.0,
+                        'source'     : entry['source'],
+                        'hit_count'  : entry['hit_count'],
+                        'match_type' : 'exact_ids'
+                    }
+
+        # SIMILARITY PATH — same as before, x_mlp + input_ids combined
+        x_mlp = np.asarray(x_mlp, dtype=np.float64).ravel()
+        best_match = None
+        best_combined_sim = 0.0
+
+        for entry in self.cache.values():
+            mlp_sim = self.pipeline.cosine_robust_similarity(x_mlp, entry['x_mlp'])
+
+            seq_sim = 1.0
+            if input_ids is not None and entry['input_ids'] is not None:
+                ids_a = np.asarray(input_ids).ravel()
+                ids_b = entry['input_ids'].ravel()
+                min_len = min(len(ids_a), len(ids_b))
+                if min_len > 0:
+                    seq_sim = float(np.mean(ids_a[:min_len] == ids_b[:min_len]))
+
+            combined_sim = mlp_sim * 0.7 + seq_sim * 0.3
+            if combined_sim > best_combined_sim:
+                best_combined_sim = combined_sim
+                best_match = entry
+
+        if best_match and best_combined_sim >= self.similarity_threshold:
+            best_match['hit_count'] += 1
+            best_match['last_hit']   = datetime.now().isoformat()
+            return {
+                'prediction' : best_match['prediction'],
+                'confidence' : best_match['confidence'],
+                'similarity' : float(best_combined_sim),
+                'source'     : best_match['source'],
+                'hit_count'  : best_match['hit_count'],
+                'match_type' : 'feature_similarity'
+            }
+
+        return None
+
+    def _hash_ids(self, input_ids):
+        """Fast hash of token ids — order-sensitive, exact match only."""
+        ids = np.asarray(input_ids, dtype=np.int32).ravel()
+        return hashlib.md5(ids.tobytes()).hexdigest()
+
+    def _make_key(self, x_mlp):
+        x = np.asarray(x_mlp, dtype=np.float64).ravel()
+        return hashlib.md5(x.tobytes()).hexdigest()
+
+    def _evict_lru(self):
+        if not self.cache:
+            return
+        lru_key = min(
+            self.cache.keys(),
+            key=lambda k: (self.cache[k]['hit_count'], self.cache[k]['added_at'])
+        )
+        entry = self.cache[lru_key]
+        if entry.get('ids_hash'):
+            self.exact_hash_index.pop(entry['ids_hash'], None)
+        del self.cache[lru_key]
+
+
 class RateLimiter:
     # Token bucket rate limiter
     
@@ -12618,6 +12816,7 @@ class PipelinePredictionManager:
 
         except Exception as e:
             print(f"[=] Error during prediction: {e}")
+            traceback.print_exc()
             results = []
 
         return results
@@ -12867,7 +13066,7 @@ class PipelinePredictionManager:
 
             self.pipeline.transformer_utilities(rules, dataset, X, y_true=y, batch_size=batch_size)
             input_ids, _ = self.pipeline.input_encoding(dataset)
-          
+
             if use_transformer and hasattr(self.pipeline, 'vocab') and self.pipeline.vocab:
                 use_embedded = False
                 print("\n[🔄] Running dual predictions (MLP + Transformer)")
@@ -12909,7 +13108,7 @@ class PipelinePredictionManager:
                                     
                 X = self.pipeline.tfidf.transform(mlp_titles).toarray()
 
-            # MLP forward pass
+            # MLP forward pass  
             if hasattr(self.pipeline.mlp, 'predict_proba'):
                 mlp_probs = self.pipeline.mlp.predict_proba(X)
             else:
@@ -12936,6 +13135,31 @@ class PipelinePredictionManager:
                 print("\n[🔍] Using sequence encoding for transformer input due to low anisotropy.")
                 input_ids = sequence_ids.copy()
 
+            # verify samples for accurate answer from cache
+            print('[🔍] Verifying Samples for possible predicted output in cache for accurate answer...')
+            cached = self.pipeline.accurate_cache_lookup.lookup(
+                x_mlp=X, 
+                input_ids=input_ids)
+
+            if cached is not None:
+                if cached['similarity'] >= 0.95:                
+                    print(f"[💎] Using verified cache "
+                    f"(combined_sim={cached['similarity']:.1%}, "
+                    f"hits={cached['hit_count']})")
+                    result = {
+                        'predicted': cached['prediction'],
+                        'confidence': float(cached['confidence']),
+                        'models_agree': True,
+                        }    
+
+                    print(f"\n[💎] Verified chosen label for samples: {cached['prediction']} || Confidence: {cached['confidence']:.1%}")  
+                    
+                    return result, cached['prediction'], cached['confidence']
+                else:
+                    print(f'[!] Similarity: {cached['similarity']} is low, Cannot pick label due to low certainty, Initiating advanced prediction...')
+            else:
+                print('[=] No verified output from cache available that matched samples, starting advanced prediction...')
+
             target_probs = self.pipeline.predict_proba(input_ids, X, type='Hybrid', embedded=True)
             target_probs = target_probs[:mlp_probs.shape[0], :mlp_probs.shape[1]] 
             target_pred_indices = np.argmax(target_probs, axis=1)    
@@ -13110,6 +13334,9 @@ class PipelinePredictionManager:
             confidence = results[0]['confidence'] if results else None
             if isinstance(chosen_label, int) or isinstance(chosen_label, np.integer):
                 chosen_label = str(chosen_label)
+                
+            if isinstance(confidence, (np.ndarray, list)):
+                confidence = np.mean(confidence)
 
             print(f"\n[🎯] Initial chosen label for input: {chosen_label} || Confidence: {confidence:.1%}")
             time.sleep(3)
@@ -13312,7 +13539,12 @@ class PipelinePredictionManager:
                 try:
                     sec_confidence = float(consecutive_probs[0][sec_final_idx])   
                 except:
-                    sec_confidence = float(consecutive_probs[0][len(reverse_map)-1]) if isinstance(consecutive_probs[0], (float, int)) else self.pipeline.confidence_threshold         
+                    sec_confidence = float(consecutive_probs[0][len(reverse_map)-1]) if isinstance(consecutive_probs[0], (float, int)) else self.pipeline.confidence_threshold  
+
+                if isinstance(confidence, (np.ndarray, list)):
+                    confidence = np.mean(confidence)
+                if isinstance(sec_confidence, (np.ndarray, list)):
+                    sec_confidence = np.mean(sec_confidence) 
 
                 print('========== Second Prediction Initiative ==========')
                 print(f'[⚡] My Second Prediction: {sec_chosen_label}') 
@@ -13348,8 +13580,12 @@ class PipelinePredictionManager:
                 results, chosen_label, confidence = None, None, 0.0
                 time.sleep(5)
 
-        print('[=] Displaying Results....')     
-        correct, sec_correct = self.display_hybrid_results(results, top_k, verbose=True)
+        print('[=] Displaying Results....')
+        payload = {
+            'X_samples': X,
+            'input_ids': input_ids
+        }         
+        correct, sec_correct = self.display_hybrid_results(payload, results, top_k, verbose=True)
         if sec_chosen_label and sec_correct > correct:
             print(f'[⚡] Second Prediction: {sec_chosen_label} has higher accuracies, relying on: {sec_chosen_label} as final label.')
             chosen_label = sec_chosen_label # overrides previous chosen label if accuracy is higher
@@ -13364,7 +13600,7 @@ class PipelinePredictionManager:
         return results, chosen_label, confidence
         
         
-    def display_hybrid_results(self, results, top_k=3, verbose=False):
+    def display_hybrid_results(self, payload, results, top_k=3, verbose=False):
         print("\n" + "="*80)
         print("[🎯] == PREDICTION RESULTS == ")
         print("="*80)
@@ -13372,7 +13608,8 @@ class PipelinePredictionManager:
         correct = 0
         sec_correct = 0
         total_with_expected = 0
-        
+        X_samples, input_ids = payload['X_samples'], payload['input_ids']   
+
         for idx, result in enumerate(results):
             print(f"\n{idx+1}. 📌 '{result['title']}'")
             
@@ -13384,9 +13621,19 @@ class PipelinePredictionManager:
                     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']:
+                        self.pipeline.accurate_cache_lookup.add_verified(
+                            X_samples, input_ids, 
+                            result['sec_predicted'], result['sec_confidence'],
+                            source='automatic_verified')
+
                         sec_correct += 1
 
                 if result['predicted'] == result['expected']:
+                    self.pipeline.accurate_cache_lookup.add_verified(
+                        X_samples, input_ids, 
+                        result['predicted'], result['confidence'],
+                        source='automatic_verified')      
+
                     correct += 1
             
             # Agreement indicator
@@ -13415,7 +13662,7 @@ class PipelinePredictionManager:
 class ConsecutivePeerAgent:
     """
     Robust PeerAgent with security layer.
-    Used as fallback when main system fails.
+    Used as fallback when main system fails during P2P.
     """
     
     def __init__(self, peer_id: str, port: int, secret_key: str,