Add fp counting

.github/workflows/python-checks.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.12"]
+        python-version: ["3.12"]
 
     steps:
       - uses: actions/checkout@v3
@@ -22,7 +22,7 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install ruff pytest
-          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+          if [ -f pyproject.toml ]; then pip install .[dev] ; fi
       - name: Test with pytest
         run: |
           tests/run_all_tests.sh

AIDojoCoordinator/game_components.py

@@ -130,11 +130,12 @@ class Data():
     """
     owner: str
     id: str
-    size: int = 0
+    size: int = field(compare=False, hash=False, default=0)
     type: str = ""
-
+    content: str = field(compare=False, hash=False, repr=False, default_factory=str)
+
     def __hash__(self) -> int:
-        return hash((self.owner, self.id, self.size, self.type))
+        return hash((self.owner, self.id, self.type))
     @classmethod
     def from_dict(cls, data: dict):
         return cls(**data)
@@ -379,7 +380,7 @@ def from_dict(cls, data_dict:dict):
             controlled_hosts = {IP(x["ip"]) for x in data_dict["controlled_hosts"]},
             known_services = {IP(k):{Service(s["name"], s["type"], s["version"], s["is_local"])
                 for s in services} for k,services in data_dict["known_services"].items()},  
-            known_data = {IP(k):{Data(v["owner"], v["id"]) for v in values} for k,values in data_dict["known_data"].items()},
+            known_data = {IP(k):{Data(v["owner"], v["id"], v["size"], v["type"], v["content"]) for v in values} for k,values in data_dict["known_data"].items()},
             known_blocks = known_blocks
                 )
         return state
@@ -396,7 +397,7 @@ def from_json(cls, json_string):
             controlled_hosts = {IP(x["ip"]) for x in json_data["controlled_hosts"]},
             known_services = {IP(k):{Service(s["name"], s["type"], s["version"], s["is_local"])
                 for s in services} for k,services in json_data["known_services"].items()},  
-            known_data = {IP(k):{Data(v["owner"], v["id"]) for v in values} for k,values in json_data["known_data"].items()},
+            known_data = {IP(k):{Data(v["owner"], v["id"], v["size"], v["type"], v["content"]) for v in values} for k,values in json_data["known_data"].items()},
             known_blocks = {IP(target_host):{IP(blocked_host) for blocked_host in blocked_hosts} for target_host, blocked_hosts in json_data["known_blocks"].items()}
             )
         return state

AIDojoCoordinator/netsecenv_conf.yaml

@@ -102,10 +102,12 @@ env:
   use_dynamic_addresses: False
   use_firewall: True
   save_trajectories: False
+  required_players: 1
   rewards:
     success: 100
     step: -1
     fail: -10
+    false_positive: -5
   actions:
     scan_network:
       prob_success: 1.0

AIDojoCoordinator/utils/aidojo_log_colorizer.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""
+A simple log processor that colorizes log entries by agent and component,
+interprets JSON payloads into readable summaries,
+pretty-prints key fields, and highlights actions & agents.
+
+Usage:
+    python log_processor.py path/to/logfile.log
+If no file is given, reads from stdin.
+"""
+import sys
+import re
+import json
+from itertools import cycle
+from rich import print
+from rich.console import Console
+from rich.text import Text
+
+# Force ANSI colors even when output is piped
+console = Console(force_terminal=True, color_system="truecolor")
+
+# Cycle of colors to assign to different agents (background colors to avoid clashes)
+# We'll use text in black on these backgrounds so they're distinct from other log colors
+COLOR_CYCLE = ["cyan", "magenta", "green", "yellow", "blue", "red"]
+agent_colors = {}
+color_picker = cycle(COLOR_CYCLE)
+agent_names = {}  # map ip:port -> agent name
+
+# Regex patterns
+timestamp_re = re.compile(r"^(?P<ts>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})")
+line_re = re.compile(
+    r"^(?P<ts>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (?P<source>\S+) (?P<level>\S+)\s+(?P<msg>.*)$"
+)
+agent_id_re = re.compile(r"\('(?P<ip>[\d\.]+)', (?P<port>\d+)\)")
+agent_reg_re = re.compile(
+    r"Agent (?P<name>\S+) \(\('(?P<ip>[\d\.]+)', (?P<port>\d+)\)\)"
+)
+action_re = re.compile(r"ActionType\.[A-Za-z]+")
+
+
+def get_agent_color(agent_id: str) -> str:
+    """Assign or retrieve a consistent background style for an agent."""
+    if agent_id not in agent_colors:
+        base = next(color_picker)
+        agent_colors[agent_id] = f"black on {base}"
+    return agent_colors[agent_id]
+
+
+def summarize_json(ts, source_styled, level_styled, prefix: str, parsed: dict):
+    """Interpret and display key fields from a JSON payload."""
+    console.print(f"[bold]{ts}[/bold] ", source_styled, level_styled, f"{prefix}:" )
+    indent = "    "
+    # Status
+    status = parsed.get('status')
+    if status is not None:
+        console.print(Text(f"{indent}Status: {status}", style="bold green"))
+
+    # To agent
+    to_agent = parsed.get('to_agent')
+    if to_agent:
+        console.print(Text(f"{indent}To Agent: {to_agent[0]}:{to_agent[1]}", style="bold cyan"))
+
+    # Message payload (optional)
+    msg_block = parsed.get('message')
+    if isinstance(msg_block, dict):
+        text = msg_block.get('message')
+        if text:
+            console.print(Text(f"{indent}Message: {text}", style="bold"))
+        max_steps = msg_block.get('max_steps')
+        if max_steps is not None:
+            console.print(f"{indent}Max Steps: {max_steps}")
+        goal = msg_block.get('goal_description')
+        if goal:
+            console.print(f"{indent}Goal: {goal}")
+        actions = msg_block.get('actions')
+        if actions:
+            console.print(f"{indent}Actions: {', '.join(actions)}")
+        conf = msg_block.get('configuration_hash')
+        if conf:
+            console.print(f"{indent}Config Hash: {conf}")
+
+    # Observation state: networks, hosts, services, data, blocks
+    obs = parsed.get('observation', {})
+    state = obs.get('state', {})
+    if state:
+        nets = state.get('known_networks', [])
+        if nets:
+            items = [f"{n['ip']}/{n['mask']}" for n in nets]
+            console.print(f"{indent}Known Networks: {', '.join(items)}")
+        hosts = state.get('known_hosts', [])
+        if hosts:
+            items = [h['ip'] for h in hosts]
+            console.print(f"{indent}Known Hosts: {', '.join(items)}")
+        ctrl = state.get('controlled_hosts', [])
+        if ctrl:
+            items = [h['ip'] for h in ctrl]
+            console.print(f"{indent}Controlled Hosts: {', '.join(items)}")
+        services = state.get('known_services', {})
+        if services:
+            for host, svcs in services.items():
+                names = [s['name'] for s in svcs]
+                console.print(f"{indent}Services on {host}: {', '.join(names)}")
+        data = state.get('known_data', {})
+        if data:
+            for host, entries in data.items():
+                ids = [e.get('id') for e in entries]
+                console.print(f"{indent}Data on {host}: {', '.join(ids)}")
+        # Known blocks
+        blocks = state.get('known_blocks', {})
+        if isinstance(blocks, dict):
+            ips = list(blocks.keys())
+        elif isinstance(blocks, list):
+            ips = [b.get('ip') for b in blocks]
+        else:
+            ips = []
+        if ips:
+            console.print(f"{indent}Blocked Hosts: {', '.join(ips)}")
+        else:
+            console.print(f"{indent}Blocked Hosts: None")
+
+    # Reward & End: top-level or under observation
+    reward = parsed.get('reward', obs.get('reward'))
+    if reward is not None:
+        console.print(Text(f"{indent}Reward: {reward}", style="bold magenta"))
+    end = parsed.get('end', obs.get('end'))
+    if end is not None:
+        console.print(Text(f"{indent}End: {end}", style="bold red"))
+
+    # End Reason: after End
+    info = parsed.get('info', {})
+    obs_info = obs.get('info', {})
+    end_reason = info.get('end_reason') or obs_info.get('end_reason')
+    if end_reason:
+        console.print(Text(f"{indent}End Reason: {end_reason}", style="bold yellow"))
+
+
+def process_line(line: str):
+    raw = line.rstrip("\n")
+    m = line_re.match(raw)
+    if not m:
+        print(raw)
+        return
+
+    ts = m.group('ts')
+    source = m.group('source')
+    level = m.group('level')
+    msg = m.group('msg').strip()
+
+    # Capture agent registration
+    reg = agent_reg_re.search(msg)
+    if reg:
+        aid = f"{reg.group('ip')}:{reg.group('port')}"
+        agent_names[aid] = reg.group('name')
+
+    # Style source
+    if 'GameCoordinator' in source:
+        source_styled = Text(source, style='bold red')
+    elif 'AgentServer' in source:
+        source_styled = Text(source, style='bold blue')
+    else:
+        source_styled = Text(source, style='bold white')
+
+    # Style level
+    level_style = 'dim white' if level == 'INFO' else 'bold red'
+    level_styled = Text(level, style=level_style)
+
+    # Highlight actions
+    msg = action_re.sub(lambda m: f"[bold magenta]{m.group(0)}[/bold magenta]", msg)
+
+    # Annotate agents
+    def repl_agent(m):
+        aid = f"{m.group('ip')}:{m.group('port')}"
+        style = get_agent_color(aid)
+        name = agent_names.get(aid)
+        label = f"{name} {aid}" if name else aid
+        # Use background style for agent label
+        return f"[{style}]{label}[/{style}]"
+    msg_markup = agent_id_re.sub(repl_agent, msg)
+
+    # Detect JSON and interpret
+    if '{' in msg and (msg.strip().startswith('{') or ': {' in msg):
+        idx = msg.find('{')
+        prefix = msg[:idx].rstrip(': ')
+        json_part = msg[idx:]
+        try:
+            parsed = json.loads(json_part)
+            summarize_json(ts, source_styled, level_styled, prefix, parsed)
+            return
+        except json.JSONDecodeError:
+            pass
+
+    # Default print
+    console.print(Text(ts, style='bold'), source_styled, level_styled, Text.from_markup(msg_markup))
+
+
+def main():
+    if len(sys.argv) > 1:
+        with open(sys.argv[1], 'r') as f:
+            for line in f:
+                process_line(line)
+    else:
+        for line in sys.stdin:
+            process_line(line)
+
+
+if __name__ == '__main__':
+    main()

AIDojoCoordinator/utils/utils.py

@@ -8,7 +8,7 @@
 from AIDojoCoordinator.scenarios import smaller_scenario_configuration
 from AIDojoCoordinator.scenarios import tiny_scenario_configuration
 from AIDojoCoordinator.scenarios import three_net_scenario
-from AIDojoCoordinator.game_components import IP, Data, Network, Service, GameState, Action, Observation
+from AIDojoCoordinator.game_components import IP, Data, Network, Service, GameState, Action, Observation, ActionType
 import netaddr
 import logging
 import csv
@@ -114,6 +114,22 @@ def observation_as_dict(observation:Observation)->dict:
     }
     return observation_dict
 
+def parse_log_content(log_content:str)->list:
+    try:
+        logs = []
+        data = json.loads(log_content)
+        for item in data:
+            ip = IP(item["source_host"])
+            action_type = ActionType.from_string(item["action_type"])
+            logs.append({"source_host":ip, "action_type":action_type})
+        return logs
+    except json.JSONDecodeError as e:
+        print(f"Error decoding JSON: {e}")
+        return None
+    except TypeError as e:
+        print(f"Error decoding JSON: {e}")
+        return None
+
 class ConfigParser():
     """
     Class to deal with the configuration file