add Dockefile and add data agglomerate for dynamic graph (in front).

deploy/Dockerfile

@@ -0,0 +1,26 @@
+FROM debian:bullseye
+
+RUN apt-get update -y \
+    && apt-get upgrade -y \
+    && apt-get -y install build-essential \
+        zlib1g-dev \
+        libncurses5-dev \
+        libgdbm-dev \ 
+        libnss3-dev \
+        libssl-dev \
+        libreadline-dev \
+        libffi-dev \
+        libsqlite3-dev \
+        libbz2-dev \
+        wget \
+    && export DEBIAN_FRONTEND=noninteractive \
+    && apt-get purge -y imagemagick imagemagick-6-common 
+
+RUN cd /usr/src \
+    && wget https://www.python.org/ftp/python/3.11.0/Python-3.11.0.tgz \
+    && tar -xzf Python-3.11.0.tgz \
+    && cd Python-3.11.0 \
+    && ./configure --enable-optimizations \
+    && make altinstall
+
+RUN update-alternatives --install /usr/bin/python python /usr/local/bin/python3.11 1

src/log_analyser/log_analyser.py

@@ -30,8 +30,7 @@ def run(self):
                     if type in self.actions:
                         self.actions[type](line_split)
 
-        # with open("../logs_process/{}.json".format(self.name.split(".")[0]), "w") as file:
-        #     file.write(self.map.export_json())
+        self.map.aggregate_stats()
 
 
     def name2datetime(self):
@@ -43,6 +42,7 @@ def name2datetime(self):
 
     def process_map_start(self, data):
 
+        print("New map : {}".format(data[3]))
         self.map = Map.from_json({"rounds": [],
                        "date": self.date,
                        "map_name": data[3],
@@ -52,7 +52,8 @@ def process_map_start(self, data):
                        "team1_score": 0,
                        "team2_score": 0,
                        "team_id": self.team_id,
-                       "events": []
+                       "events": [],
+                       "stats_graph": {},
                        })
 
         self.actions = {"match_start": self.process_map_start,

src/log_analyser/objects/map.py

@@ -18,6 +18,7 @@ def __init__(self, **kwargs):
                        "team2_score": int,
                        "team_id": str,
                        "events": list,
+                       "stats_graph": dict,
                        }
 
         super().__init__(data_schema, **kwargs)
@@ -102,7 +103,9 @@ def add_player_stat(self, data):
                        "offensive_assists": data[19], "ultimated_earn": data[20], "ultimates_used": data[21], "solo_kills": data[24],
                        "critical_hits_accuracy": data[29], "weapon_accuracy": data[38], "hero_time_played": data[39]}
 
-        if player_data["hero_time_played"] != "0" and data[6] in self.rounds[self.actual_round].teams[data[4]].players[data[5]].characters:
+        if player_data["hero_time_played"] != "0":
+            if not data[6] in self.rounds[self.actual_round].teams[data[4]].players[data[5]].characters:
+                self.add_character({"time": data[2], "team_name": data[4], "player_name": data[5], "character_name": data[6]})
             self.rounds[self.actual_round].teams[data[4]].players[data[5]].characters[data[6]].add_character_stats(player_data)
 
     def add_hero_swap(self, data):
@@ -111,6 +114,8 @@ def add_hero_swap(self, data):
         if data["character_swap"] in self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].characters:
             self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].characters[data["character_swap"]].add_played_time({"end": data["time"]})
 
+        self.events.append({"type": "hero_swap", "timestamp": data["time"], "player": data["player_name"],
+                            "description": "{} swap on {}".format(data["player_name"], data["character_swap"])})
 
     def create_if_player_and_caracter_not_exist(self, team, player_name, character_name):
 
@@ -189,4 +194,31 @@ def find_team_for_player(self, player_name):
             if player_name in self.rounds[self.actual_round].teams[team].players:
                 return team
 
-        return None
+        return None
+
+    def aggregate_stats(self):
+        players_data = {}
+
+        for index, round_data in enumerate(self.rounds):
+            print("### Round {} ###".format(index))
+            for _, team in round_data.teams.items():
+                for _, player in team.players.items():
+
+                    aggregated_stats = {}
+
+                    for character in player.characters.values():
+                        if character.stats:
+                            for key, value in character.stats.items():
+                                try:
+                                    numeric_value = float(value)
+                                    aggregated_stats[key] = aggregated_stats.get(key, 0) + numeric_value
+                                except ValueError:
+                                    print("ValueError: ", value, player.name, character.name, key)
+                                    aggregated_stats[key] = value
+
+                    if any(isinstance(value, (int, float)) and value == value for value in aggregated_stats.values()):
+                        player_name = player.name
+                        players_data[player_name] = players_data.get(player_name, [])
+                        players_data[player_name].append({"round": index, "stats": aggregated_stats})
+
+        self.stats_graph = players_data