Update agreggate and fix for publish

Author: Bojan131

scripts/print_aggregated_errors.py

@@ -12,6 +12,41 @@ def safe_rate(success, fail):
 def avg(times):
     return round(sum(times) / len(times), 2) if times else 0.0
 
+def create_aggregated_error_file():
+    """Create aggregated error_stats.json from individual node files"""
+    aggregated_errors = {}
+    
+    # Define all possible nodes
+    testnet_nodes = [
+        "Node 01", "Node 04", "Node 05", "Node 06", "Node 07", "Node 08", 
+        "Node 09", "Node 10", "Node 13", "Node 14", "Node 21", "Node 23", "Node 37"
+    ]
+    
+    mainnet_nodes = [
+        "Node 25", "Node 26", "Node 27", "Node 28", "Node 29", "Node 30"
+    ]
+    
+    all_nodes = testnet_nodes + mainnet_nodes
+    
+    # Read each individual node error file
+    for node_name in all_nodes:
+        node_file = os.path.join(ERROR_DIR, f"errors_{node_name.replace(' ', '_')}.json")
+        if os.path.exists(node_file):
+            try:
+                with open(node_file, 'r') as f:
+                    node_errors = json.load(f)
+                    if node_errors:  # Only add if there are errors
+                        aggregated_errors[node_name] = node_errors
+            except Exception as e:
+                print(f"⚠️ Warning: Could not read {node_file}: {e}")
+    
+    # Write aggregated file
+    aggregated_file = os.path.join(ERROR_DIR, "error_stats.json")
+    with open(aggregated_file, 'w') as f:
+        json.dump(aggregated_errors, f, indent=2)
+    
+    return aggregated_errors
+
 def get_all_errors_for_node(node_name):
     """Get all errors for a specific node from multiple sources"""
     all_errors = {}
@@ -56,6 +91,9 @@ def get_all_errors_for_node(node_name):
 def print_all_errors():
     print("\n📊 Error Breakdown by Node:\n")
 
+    # Create aggregated error file from individual files
+    aggregated_errors = create_aggregated_error_file()
+    
     # Define all possible nodes for both testnet and mainnet
     testnet_nodes = [
         "Node 01", "Node 04", "Node 05", "Node 06", "Node 07", "Node 08", 
@@ -68,19 +106,10 @@ def print_all_errors():
 
     all_nodes = testnet_nodes + mainnet_nodes
 
-    # Check for aggregated error file first
-    aggregated_file = os.path.join(ERROR_DIR, "error_stats.json")
-    nodes_with_errors = []
-    
-    if os.path.exists(aggregated_file):
-        try:
-            with open(aggregated_file, "r") as f:
-                error_data = json.load(f)
-                nodes_with_errors = list(error_data.keys())
-        except Exception:
-            pass
+    # Get nodes that have errors
+    nodes_with_errors = list(aggregated_errors.keys())
 
-    # If no aggregated file or no errors, check individual files
+    # If no aggregated errors, check individual files
     if not nodes_with_errors:
         for node_name in all_nodes:
             node_file = os.path.join(ERROR_DIR, f"errors_{node_name.replace(' ', '_')}.json")

tests/mainnet/Base_Mainnet.py

@@ -116,38 +116,29 @@ def log_error(error, node_name, step='unknown', remote_node=None):
     else:
         error_stats[node_name][key] = 1
 
-    # Also store in a temporary file to ensure persistence across test session
-    error_file = "test_output/error_stats.json"
+    # Write to individual node error file (parallel-safe)
+    node_error_file = f"test_output/errors_{node_name.replace(' ', '_')}.json"
     os.makedirs("test_output", exist_ok=True)
 
-    # Load existing errors - merge instead of overwrite
-    if os.path.exists(error_file):
-        with open(error_file, 'r') as f:
+    # Load existing errors for this node
+    if os.path.exists(node_error_file):
+        with open(node_error_file, 'r') as f:
             try:
-                error_data = json.load(f)
+                node_errors = json.load(f)
             except:
-                error_data = {}
+                node_errors = {}
     else:
-        error_data = {}
-    
-    # Update errors - merge instead of overwrite
-    if node_name not in error_data:
-        error_data[node_name] = {}
+        node_errors = {}
 
-    if key in error_data[node_name]:
-        error_data[node_name][key] += 1
+    # Update errors for this node
+    if key in node_errors:
+        node_errors[key] += 1
     else:
-        error_data[node_name][key] = 1
+        node_errors[key] = 1
 
-    # Save back to file immediately
-    f = open(error_file, 'w')
-    try:
-        json.dump(error_data, f, indent=2)
-        # Force flush to ensure file is written
-        f.flush()
-        os.fsync(f.fileno())
-    finally:
-        f.close()
+    # Save back to individual node file
+    with open(node_error_file, 'w') as f:
+        json.dump(node_errors, f, indent=2)
 
 def safe_rate(success, fail):
     total = success + fail

tests/mainnet/Gnosis_Mainnet.py

@@ -116,38 +116,29 @@ def log_error(error, node_name, step='unknown', remote_node=None):
     else:
         error_stats[node_name][key] = 1
 
-    # Also store in a temporary file to ensure persistence across test session
-    error_file = "test_output/error_stats.json"
+    # Write to individual node error file (parallel-safe)
+    node_error_file = f"test_output/errors_{node_name.replace(' ', '_')}.json"
     os.makedirs("test_output", exist_ok=True)
 
-    # Load existing errors - merge instead of overwrite
-    if os.path.exists(error_file):
-        with open(error_file, 'r') as f:
+    # Load existing errors for this node
+    if os.path.exists(node_error_file):
+        with open(node_error_file, 'r') as f:
             try:
-                error_data = json.load(f)
+                node_errors = json.load(f)
             except:
-                error_data = {}
+                node_errors = {}
     else:
-        error_data = {}
-    
-    # Update errors - merge instead of overwrite
-    if node_name not in error_data:
-        error_data[node_name] = {}
+        node_errors = {}
 
-    if key in error_data[node_name]:
-        error_data[node_name][key] += 1
+    # Update errors for this node
+    if key in node_errors:
+        node_errors[key] += 1
     else:
-        error_data[node_name][key] = 1
+        node_errors[key] = 1
 
-    # Save back to file immediately
-    f = open(error_file, 'w')
-    try:
-        json.dump(error_data, f, indent=2)
-        # Force flush to ensure file is written
-        f.flush()
-        os.fsync(f.fileno())
-    finally:
-        f.close()
+    # Save back to individual node file
+    with open(node_error_file, 'w') as f:
+        json.dump(node_errors, f, indent=2)
 
 def safe_rate(success, fail):
     total = success + fail

tests/mainnet/Neuroweb_Mainnet.py

@@ -25,7 +25,7 @@
 # https://positron.origin-trail.network - public node
 
 nodes = [
-    {"name": "Node 25", "hostname": "https://v6-pegasus-node-25.origin-trail.network"},
+    {"name": "Node 25", "hostname": "https://positron.origin-trail.network"},
     {"name": "Node 26", "hostname": "https://v6-pegasus-node-26.origin-trail.network"},
     {"name": "Node 27", "hostname": "https://v6-pegasus-node-27.origin-trail.network"},
     {"name": "Node 28", "hostname": "https://v6-pegasus-node-28.origin-trail.network"},
@@ -116,38 +116,29 @@ def log_error(error, node_name, step='unknown', remote_node=None):
     else:
         error_stats[node_name][key] = 1
 
-    # Also store in a temporary file to ensure persistence across test session
-    error_file = "test_output/error_stats.json"
+    # Write to individual node error file (parallel-safe)
+    node_error_file = f"test_output/errors_{node_name.replace(' ', '_')}.json"
     os.makedirs("test_output", exist_ok=True)
 
-    # Load existing errors - merge instead of overwrite
-    if os.path.exists(error_file):
-        with open(error_file, 'r') as f:
+    # Load existing errors for this node
+    if os.path.exists(node_error_file):
+        with open(node_error_file, 'r') as f:
             try:
-                error_data = json.load(f)
+                node_errors = json.load(f)
             except:
-                error_data = {}
+                node_errors = {}
     else:
-        error_data = {}
-    
-    # Update errors - merge instead of overwrite
-    if node_name not in error_data:
-        error_data[node_name] = {}
+        node_errors = {}
 
-    if key in error_data[node_name]:
-        error_data[node_name][key] += 1
+    # Update errors for this node
+    if key in node_errors:
+        node_errors[key] += 1
     else:
-        error_data[node_name][key] = 1
+        node_errors[key] = 1
 
-    # Save back to file immediately
-    f = open(error_file, 'w')
-    try:
-        json.dump(error_data, f, indent=2)
-        # Force flush to ensure file is written
-        f.flush()
-        os.fsync(f.fileno())
-    finally:
-        f.close()
+    # Save back to individual node file
+    with open(node_error_file, 'w') as f:
+        json.dump(node_errors, f, indent=2)
 
 def safe_rate(success, fail):
     total = success + fail

tests/testnet/Base_Testnet.py

@@ -121,38 +121,29 @@ def log_error(error, node_name, step='unknown', remote_node=None):
     else:
         error_stats[node_name][key] = 1
 
-    # Also store in a temporary file to ensure persistence across test session
-    error_file = "test_output/error_stats.json"
+    # Write to individual node error file (parallel-safe)
+    node_error_file = f"test_output/errors_{node_name.replace(' ', '_')}.json"
     os.makedirs("test_output", exist_ok=True)
 
-    # Load existing errors - merge instead of overwrite
-    if os.path.exists(error_file):
-        with open(error_file, 'r') as f:
+    # Load existing errors for this node
+    if os.path.exists(node_error_file):
+        with open(node_error_file, 'r') as f:
             try:
-                error_data = json.load(f)
+                node_errors = json.load(f)
             except:
-                error_data = {}
+                node_errors = {}
     else:
-        error_data = {}
-    
-    # Update errors - merge instead of overwrite
-    if node_name not in error_data:
-        error_data[node_name] = {}
+        node_errors = {}
 
-    if key in error_data[node_name]:
-        error_data[node_name][key] += 1
+    # Update errors for this node
+    if key in node_errors:
+        node_errors[key] += 1
     else:
-        error_data[node_name][key] = 1
+        node_errors[key] = 1
 
-    # Save back to file immediately
-    f = open(error_file, 'w')
-    try:
-        json.dump(error_data, f, indent=2)
-        # Force flush to ensure file is written
-        f.flush()
-        os.fsync(f.fileno())
-    finally:
-        f.close()
+    # Save back to individual node file
+    with open(node_error_file, 'w') as f:
+        json.dump(node_errors, f, indent=2)
 
 def safe_rate(success, fail):
     total = success + fail

tests/testnet/Gnosis_Testnet.py

@@ -121,38 +121,29 @@ def log_error(error, node_name, step='unknown', remote_node=None):
     else:
         error_stats[node_name][key] = 1
 
-    # Also store in a temporary file to ensure persistence across test session
-    error_file = "test_output/error_stats.json"
+    # Write to individual node error file (parallel-safe)
+    node_error_file = f"test_output/errors_{node_name.replace(' ', '_')}.json"
     os.makedirs("test_output", exist_ok=True)
 
-    # Load existing errors - merge instead of overwrite
-    if os.path.exists(error_file):
-        with open(error_file, 'r') as f:
+    # Load existing errors for this node
+    if os.path.exists(node_error_file):
+        with open(node_error_file, 'r') as f:
             try:
-                error_data = json.load(f)
+                node_errors = json.load(f)
             except:
-                error_data = {}
+                node_errors = {}
     else:
-        error_data = {}
-    
-    # Update errors - merge instead of overwrite
-    if node_name not in error_data:
-        error_data[node_name] = {}
+        node_errors = {}
 
-    if key in error_data[node_name]:
-        error_data[node_name][key] += 1
+    # Update errors for this node
+    if key in node_errors:
+        node_errors[key] += 1
     else:
-        error_data[node_name][key] = 1
+        node_errors[key] = 1
 
-    # Save back to file immediately
-    f = open(error_file, 'w')
-    try:
-        json.dump(error_data, f, indent=2)
-        # Force flush to ensure file is written
-        f.flush()
-        os.fsync(f.fileno())
-    finally:
-        f.close()
+    # Save back to individual node file
+    with open(node_error_file, 'w') as f:
+        json.dump(node_errors, f, indent=2)
 
 def safe_rate(success, fail):
     total = success + fail