add recurrence on export json (for object inherited of object) and add structure for Character

Author: Zat-Code

deploy/docker-compose.yaml

@@ -6,14 +6,14 @@ services:
       ZOOKEEPER_CLIENT_PORT: 2181
       ZOOKEEPER_TICK_TIME: 2000
     ports:
-      - 22181:2181
+      - 22182:2181
 
   kafka:
     image: confluentinc/cp-kafka:latest
     depends_on:
       - zookeeper
     ports:
-      - 29092:29092
+      - 29093:29092
     environment:
       KAFKA_BROKER_ID: 1
       KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181

src/log_analyser/log_analyser.py

@@ -15,20 +15,24 @@ def __init__(self, path_csv, name) -> None:
 
         self.actions = {"match_start": self.process_match_start,
                         "round_start": self.process_round_start,
-                        "hero_spawn": self.process_hero_spawn}
+                        "hero_spawn": self.process_hero_spawn,
+                        "hero_swap": self.process_hero_swap
+                        }
 
     def run(self):
 
         with open(self.path_csv, encoding='utf-8') as my_file:
-            line = my_file.read()
-            line_split = line.split(",")
-            # print(line_split)
+            file = my_file.read()
+            lines = file.split("\n")
+            for line in lines:
+                line_split = line.split(",")
 
-            timestamp = line_split[0]
-            type = line_split[1]
-            
-            if type in self.actions:
-                self.actions[type](line_split)
+                if len(line_split) > 1:
+                    type = line_split[1]
+                    if type in self.actions:
+                        self.actions[type](line_split)
+
+        self.match.export_json()
 
 
     def name2datetime(self):
@@ -46,10 +50,10 @@ def process_kill(self):
     def process_ultimate_charged(self):
         pass
 
-    def process_round_start(self):
+    def process_round_start(self, data):
 
         self.match.add_round()
-    
+        # self.match.export_json()
     def process_round_stop(self):
         pass
 
@@ -62,11 +66,17 @@ def process_match_start(self, data):
                        "team1_name": data[5],
                        "team2_name": data[6]
                        })
-        
+
     def process_hero_spawn(self, data):
-        pass
-        
-        
 
-la = LogAnalyser('src/logs/Log-2023-12-22-21-12-32.txt', "Log-2023-12-22-21-12-32.txt")
+        player_data = {"team_name": data[3], "player_name": data[4], "character_name": data[5]}
+        self.match.add_player(player_data)
+
+    def process_hero_swap(self, data):
+
+        hero_data = {"team_name": data[3], "player_name": data[4], "character_name": data[6]}
+        self.match.add_player(hero_data)
+
+
+la = LogAnalyser('../logs/Log-2023-12-22-21-12-32.txt', "Log-2023-12-22-21-12-32.txt")
 la.run()

src/log_analyser/objects/character.py

@@ -5,14 +5,35 @@ class Character(Object):
 
     def __init__(self, **kwargs):
 
-        data_schema = {"name": str, 
-                       "damage": int, 
-                       "heal": int,
-                       "ultimate_use": int}
+        data_schema = {"name": str}
 
         super().__init__(data_schema, **kwargs)
-    
-    
-# character = Character.from_json({"name": "ok", "age": 3})
-# character.__print__()
-# print(character.export_json())
+
+        self.stats = {}
+        self.kills = []
+        self.deads = []
+        self.offensive_assists = []
+        self.defensive_assists = []
+        self.ultimate_charged = []
+        self.ultimate_use = []
+
+    def add_kill(self, data):
+        self.kills.append(data)
+
+    def add_dead(self, data):
+        self.deads.append(data)
+
+    def add_offensive_assist(self, data):
+        self.offensive_assists.append(data)
+
+    def add_defensive_assist(self, data):
+        self.defensive_assists.append(data)
+
+    def add_ultimate_charged(self, data):
+        self.ultimate_charged.append(data)
+    def add_ultimate_start(self, data):
+        self.ultimate_use.append(data)
+    def add_ultimate_stop(self, data):
+        self.ultimate_end[-1]["end"] = data["date"]
+    def add_character_stats(self, data):
+        self.stats = data

src/log_analyser/objects/match.py

@@ -3,51 +3,49 @@
 from objects.team import Team
 from datetime import datetime
 
+
 class Match(Object):
-    
+
     def __init__(self, **kwargs):
-        
-        data_schema = {"rounds": list, 
+
+        data_schema = {"rounds": list,
                        "date": datetime,
                        "map_name": str,
                        "map_type": str,
                        "team1_name": str,
                        "team2_name": str
                        }
-        
+
         super().__init__(data_schema, **kwargs)
-        
+
         self.actual_round = -1
-        
-        
+
     def add_round(self):
-        
-        teams = []
-        teams.append(Team.from_json({"name":self.team1_name, "players": {}}))
-        teams.append(Team.from_json({"name":self.team2_name, "players": {}}))
+
+        teams = {}
+        teams[self.team1_name] = Team.from_json({"name": self.team1_name, "players": {}})
+        teams[self.team2_name] = Team.from_json({"name": self.team2_name, "players": {}})
         self.rounds.append(Round.from_json({"teams": teams}))
-        
+
         self.actual_round += 1
-        
+
     def add_player(self, data):
-        
-        for name_team, team in self.rounds[self.actual_round].teams:
-            
-            for player in team.players:
-                
-                if player.name == data["name"]:
-                    return -1
-        
-        self.rounds[self.actual_round].teams[data["team_number"]].add_player(data)
-        
-                    
+
+        if data["player_name"] in self.rounds[self.actual_round].teams[data["team_name"]].players:
+            print("player already exist")
+            self.add_character(data)
+            return -1
+        else:
+            self.rounds[self.actual_round].teams[data["team_name"]].add_player(
+                {"name": data["player_name"], "characters": {}})
+            self.add_character(data)
+            return 0
+
+
     def add_character(self, data):
-        
-        for team in self.rounds[self.actual_round].teams:
-            for player in team.players:
-                for character in player.characters:
-                
-                    if character.name == data["name_character"]:
-                        return -1
-        
-        self.rounds[self.actual_round].teams[data["team_number"]].player["player_name"].add_character(data)
+
+        if data["character_name"] in self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].characters:
+            print("character already exist")
+            return -2
+        else:
+            self.rounds[self.actual_round].teams[data["team_name"]].players[data["player_name"]].add_character({"name": data["character_name"]})

src/log_analyser/objects/object.py

@@ -1,14 +1,14 @@
 import json
-
+from datetime import datetime
 
 class Object:
     def __init__(self, class_model, **kwargs):   
 
         self.from_json_ok = True
+        self.class_name = self.__class__.__name__
 
         for key, value in kwargs.items():
             if key in class_model:
-                print(type(value), class_model[key])
                 if type(value) == class_model[key]:
                     setattr(self, key, value)
                 else:
@@ -17,17 +17,37 @@ def __init__(self, class_model, **kwargs):
             else:
                 print("key {} not find in dataschema".format(key))
                 self.from_json_ok = False
-                
+
+    def export_json_recursive(self, data):
+        if issubclass(type(data), Object):
+            dict_class = data.__dict__.copy()
+            dict_class.pop("from_json_ok")
+            return data.export_json_recursive(dict_class)
+        elif isinstance(data, datetime):
+            return data.strftime("%Y-%m-%d %H:%M:%S")
+        elif isinstance(data, list):
+            return [self.export_json_recursive(item) for item in data]
+        elif isinstance(data, dict):
+            return {key: self.export_json_recursive(value) for key, value in data.items()}
+        else:
+            return data
+
     def export_json(self):
 
-        dict_class = self.__dict__
+        dict_class = self.__dict__.copy()
         dict_class.pop("from_json_ok")
+        for key, value in dict_class.items():
+            dict_class[key] = self.export_json_recursive(value)
+
         return json.dumps(dict_class)
-    
+
+
+
     @classmethod
     def from_json(self, data):
         object = self(**data)
         if object.from_json_ok:
             return object
         else:
-            return None
+            return None
+

src/log_analyser/objects/player.py

@@ -4,17 +4,15 @@
 
 
 class Player(Object):
-    
-    def __init__(self, name, team) -> None:
-        
-        data_schema = {"name": str, 
-                       "characters": list}
-        
+
+    def __init__(self, **kwargs) -> None:
+        data_schema = {"name": str,
+                       "characters": dict}
+
         super().__init__(data_schema, **kwargs)
-        
-            
+
     def add_event(self, event):
         pass
-    
-    def add_character(self, character):
-        self.character.append(character)
+
+    def add_character(self, data):
+        self.characters[data["name"]] = Character.from_json(data)

src/log_analyser/objects/team.py

@@ -13,4 +13,4 @@ def __init__(self, **kwargs):
 
     def add_player(self, data):
 
-        self.players.append(Player.from_json(data))
+        self.players[data["name"]] = Player.from_json(data)

src/main.py

@@ -10,9 +10,9 @@ def __init__(self):
         self.running = True
 
 
-        self.producer_thread = ProducerThread("localhost:29092")
+        self.producer_thread = ProducerThread("localhost:29093")
 
-        self.consumer_thread = ConsumerThread("localhost:29092")
+        self.consumer_thread = ConsumerThread("localhost:29093")
         self.consumer_thread.add_topics("test", self.on_callback_test)
 
         self.consumer_thread.start()