Merge pull request #615 from powerapi-ng/refactor/cleanup-unused-report-attrs

refactor: Cleanup unused attributes in actor message types

Author: gfieni

src/powerapi/actor/actor.py

@@ -286,13 +286,13 @@ def soft_kill(self):
         <powerapi.message.message.PoisonPillMessage>`
 
         """
-        self.send_control(PoisonPillMessage(soft=True, sender_name='system'))
+        self.send_control(PoisonPillMessage())
         self.socket_interface.close()
 
     def hard_kill(self):
         """Kill this actor by sending a hard :class:`PoisonPillMessage
         <powerapi.message.message.PoisonPillMessage>`
 
         """
-        self.send_control(PoisonPillMessage(soft=False, sender_name='system'))
+        self.send_control(PoisonPillMessage(soft=False))
         self.socket_interface.close()

src/powerapi/actor/supervisor.py

@@ -107,7 +107,7 @@ def launch_actor(self, actor, start_message=True):
         actor.connect_data()
 
         if start_message:
-            actor.send_control(StartMessage(SUPERVISOR_NAME))
+            actor.send_control(StartMessage())
             msg = actor.receive_control(2000)
             if isinstance(msg, ErrorMessage):
                 raise ActorInitError(msg.error_message)

src/powerapi/handler/start_handler.py

@@ -44,8 +44,7 @@ def handle(self, msg):
         :param powerapi.StartMessage msg: Message that initialize the actor
         """
         if self.state.initialized:
-            self.state.actor.send_control(
-                ErrorMessage(self.state.actor.name, 'Actor already initialized'))
+            self.state.actor.send_control(ErrorMessage('Actor already initialized'))
             return
 
         if not isinstance(msg, StartMessage):
@@ -55,7 +54,7 @@ def handle(self, msg):
 
         if self.state.alive:
             self.state.initialized = True
-            self.state.actor.send_control(OKMessage(self.state.actor.name))
+            self.state.actor.send_control(OKMessage())
 
     def initialization(self):
         """

src/powerapi/message.py

@@ -30,82 +30,41 @@
 
 class Message:
     """
-    Abstract Message class
+    Abstract actor Message class.
     """
 
-    def __init__(self, sender_name: str):
-        self.sender_name = sender_name
-
-    def __str__(self):
-        raise NotImplementedError()
-
 
 class OKMessage(Message):
     """
-    Message sends to acknowledge last received message
+    Message sent by an actor after a successful startup.
     """
 
-    def __init__(self, sender_name: str):
-        Message.__init__(self, sender_name)
-
-    def __str__(self):
-        return "OKMessage"
-
 
 class ErrorMessage(Message):
     """
-    Message used to indicate that an error as occuried
+    Message sent by an actor when an error occurs during startup.
     """
 
-    def __init__(self, sender_name: str, error_message: str):
+    def __init__(self, error_message: str):
         """
-        :param str error_code: message associated to the error
+        :param error_message: Message associated to the encountered error.
         """
-        Message.__init__(self, sender_name)
         self.error_message = error_message
 
-    def __str__(self):
-        return "ErrorMessage : " + self.error_message
-
 
 class StartMessage(Message):
     """
-    Message that asks the actor to launch its initialisation process
+    Message sent to an actor to initiate its startup.
     """
 
-    def __init__(self, sender_name: str):
-        Message.__init__(self, sender_name)
-
-    def __str__(self):
-        return "StartMessage"
-
-
-class EndMessage(Message):
-    """
-    Message sent by actor to its parent when it terminates itself
-    """
-
-    def __init__(self, sender_name: str):
-        Message.__init__(self, sender_name)
-
-    def __str__(self):
-        return "EndMessage"
-
 
 class PoisonPillMessage(Message):
     """
-    Message which allow to kill an actor
+    Message sent to an actor to initiate its shutdown.
     """
 
-    def __init__(self, soft: bool = True, sender_name: str = ''):
-        Message.__init__(self, sender_name=sender_name)
+    def __init__(self, soft: bool = True):
+        """
+        :param bool soft: Indicate whether the actor should process all its messages before shutting down.
+        """
         self.is_soft = soft
-        self.is_hard = not soft
-
-    def __str__(self):
-        return "PoisonPillMessage"
-
-    def __eq__(self, other):
-        if isinstance(other, PoisonPillMessage):
-            return other.is_soft == self.is_soft and other.is_hard == self.is_hard
-        return False

src/powerapi/puller/handlers.py

@@ -76,7 +76,7 @@ def run(self):
                     dispatcher.send_data(raw_report)
 
             except FilterUselessError:
-                self.handler.handle_internal_msg(PoisonPillMessage(False, self.name))
+                self.handler.handle_internal_msg(PoisonPillMessage(False))
                 return
 
             except BadInputData as exn:
@@ -86,7 +86,7 @@ def run(self):
             except StopIteration:
                 time.sleep(self.state.timeout_puller / 1000)
                 if not self.state.stream_mode:
-                    self.handler.handle_internal_msg(PoisonPillMessage(False, self.name))
+                    self.handler.handle_internal_msg(PoisonPillMessage(False))
                     return
 
 
@@ -141,11 +141,11 @@ def handle(self, msg: Message):
         try:
             StartHandler.handle(self, msg)
         except PullerInitializationException as e:
-            self.state.actor.send_control(ErrorMessage(self.state.actor.name, e.msg))
+            self.state.actor.send_control(ErrorMessage(e.msg))
 
         self.pull_db()
 
-        self.handle_internal_msg(PoisonPillMessage(False, self.state.actor.name))
+        self.handle_internal_msg(PoisonPillMessage(False))
 
     def pull_db(self):
         """
@@ -166,4 +166,4 @@ def _connect_database(self):
             self.state.database_it = self.state.database.iter(self.state.stream_mode)
         except DBError as error:
             self.state.alive = False
-            self.state.actor.send_control(ErrorMessage(self.state.actor.name, error.msg))
+            self.state.actor.send_control(ErrorMessage(error.msg))

src/powerapi/pusher/handlers.py

@@ -47,7 +47,7 @@ def initialization(self):
         try:
             self.state.database.connect()
         except DBError as error:
-            self.state.actor.send_control(ErrorMessage(self.state.actor.name, error.msg))
+            self.state.actor.send_control(ErrorMessage(error.msg))
             self.state.alive = False
 
 

src/powerapi/report/control_report.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2021, INRIA
+# Copyright (c) 2021, Inria
 # Copyright (c) 2021, University of Lille
 # All rights reserved.
 #
@@ -41,21 +41,21 @@ class ControlReport(Report):
     This is useful to control external tools via a producer/consumer job queue.
     """
 
-    def __init__(self, timestamp: datetime, sensor: str, target: str, action: str, parameters: list, metadata: dict[str, Any] = {}):
+    def __init__(self, timestamp: datetime, sensor: str, target: str, action: str, parameters: list, metadata: dict[str, Any] | None = None):
         """
-        Initialize a Control Event report using the given parameters.
         :param timestamp: Report timestamp
         :param sensor: Sensor name
         :param target: Target name
         :param action: Action name
         :param parameters: Parameter values
         """
-        Report.__init__(self, timestamp, sensor, target, metadata)
+        super().__init__(timestamp, sensor, target, metadata)
+
         self.action = action
         self.parameters = parameters
 
     def __repr__(self) -> str:
-        return f'ControlReport({self.timestamp}, {self.sensor}, {self.target}, {self.action}, {self.parameters}, {self.metadata})'
+        return f'ControlReport({self.timestamp}, {self.sensor}, {self.target}, {self.action}, {self.parameters})'
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, ControlReport):
@@ -83,4 +83,4 @@ def to_mongodb(report: ControlReport) -> dict:
         """
         :return: a dictionary, that can be stored into a mongodb, from a given ControlReport
         """
-        return report.__dict__
+        return vars(report)

src/powerapi/report/formula_report.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2022, INRIA
+# Copyright (c) 2022, Inria
 # Copyright (c) 2022, University of Lille
 # All rights reserved.
 #
@@ -44,18 +44,14 @@ class FormulaReport(Report):
     This is useful to gather information about a running formula in order to debug or compute statistics.
     """
 
-    def __init__(self, timestamp: datetime, sensor: str, target: str, metadata: dict[str, Any]):
+    def __init__(self, timestamp: datetime, sensor: str, target: str, metadata: dict[str, Any] | None = None):
         """
-        Initialize a Formula report using the given parameters.
         :param timestamp: Report timestamp
         :param sensor: Sensor name
         :param target: Target name
         :param metadata: Metadata values, can be anything but should be json serializable
         """
-        Report.__init__(self, timestamp, sensor, target, metadata)
-
-    def __repr__(self) -> str:
-        return f'FormulaReport({self.timestamp}, {self.sensor}, {self.target}, {self.metadata})'
+        super().__init__(timestamp, sensor, target, metadata)
 
     @staticmethod
     def to_csv_lines(report: FormulaReport, **_) -> (list[str], dict[str, Any]):
@@ -100,3 +96,10 @@ def to_influxdb(report: FormulaReport, **_) -> dict[str, Any]:
         }
 
         return document
+
+    @staticmethod
+    def to_json(report: FormulaReport) -> dict[str, Any]:
+        """
+        Convert a Formula report into a json document that can be stored into json.
+        """
+        return vars(report)

src/powerapi/report/hwpc_report.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2021, INRIA
+# Copyright (c) 2021, Inria
 # Copyright (c) 2021, University of Lille
 # All rights reserved.
 #
@@ -69,22 +69,19 @@ class HWPCReport(Report):
         }
     """
 
-    def __init__(self, timestamp: datetime, sensor: str, target: str, groups: dict[str, dict],
-                 metadata: dict[str, Any] = {}):
+    def __init__(self, timestamp: datetime, sensor: str, target: str, groups: dict[str, dict], metadata: dict[str, Any] | None = None):
         """
-        Initialize an HWPC report using the given parameters.
-        :param datetime timestamp: Timestamp of the report
-        :param str sensor: Sensor name
-        :param str target: Target name
-        :param Dict groups: Events groups
+        :param timestamp: Timestamp of the report
+        :param sensor: Sensor name
+        :param target: Target name
+        :param groups: Events groups
         """
-        Report.__init__(self, timestamp, sensor, target, metadata)
+        super().__init__(timestamp, sensor, target, metadata)
 
-        #: (dict): Events groups
         self.groups = groups
 
     def __repr__(self) -> str:
-        return f'HWPCReport({self.timestamp}, {self.sensor}, {self.target}, {sorted(self.groups.keys())}, {self.metadata})'
+        return f'HWPCReport({self.timestamp}, {self.sensor}, {self.target}, {sorted(self.groups.keys())})'
 
     def __eq__(self, other) -> bool:
         if not isinstance(other, HWPCReport):
@@ -112,7 +109,7 @@ def from_json(data: dict) -> HWPCReport:
 
     @staticmethod
     def to_json(report: HWPCReport) -> dict:
-        return report.__dict__
+        return vars(report)
 
     @staticmethod
     def from_mongodb(data: dict) -> HWPCReport:

src/powerapi/report/power_report.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2021, INRIA
+# Copyright (c) 2021, Inria
 # Copyright (c) 2021, University of Lille
 # All rights reserved.
 #
@@ -42,21 +42,20 @@ class PowerReport(Report):
     PowerReport stores the power estimation information.
     """
 
-    def __init__(self, timestamp: datetime, sensor: str, target: str, power: float, metadata: dict[str, Any] = {}):
+    def __init__(self, timestamp: datetime, sensor: str, target: str, power: float, metadata: dict[str, Any] | None = None):
         """
-        Initialize a Power report using the given parameters.
         :param datetime timestamp: Report timestamp
         :param str sensor: Sensor name
         :param str target: Target name
         :param float power: Power value
         :param dict metadata: Metadata values, can be anything that add useful information
         """
-        Report.__init__(self, timestamp, sensor, target, metadata)
+        super().__init__(timestamp, sensor, target, metadata)
 
         self.power = power
 
     def __repr__(self) -> str:
-        return f'PowerReport({self.timestamp}, {self.sensor}, {self.target}, {self.power}, {self.metadata})'
+        return f'PowerReport({self.timestamp}, {self.sensor}, {self.target}, {self.power})'
 
     def __eq__(self, other) -> bool:
         if not isinstance(other, PowerReport):