Did some logs improvement

virtualsensors.py

@@ -56,13 +56,19 @@ class VirtualSensorBase:
         # assert len(splitted_name) == 2,f"Invalid virtual sensor name : {virtual_sensor_name}"
         # return f"sensor.{splitted_name[1]}"
 
-    def log(self,message): self.logger_interface.log_info(f"[{self.sensor_name}]{message}")
+    # def log(self,message): self.logger_interface.log_info(f"[{self.sensor_name}]{message}")
 
-    def log_info(self,message): self.logger_interface.log_info(f"[{self.sensor_name}]{message}")
+    # def log_info(self,message): self.logger_interface.log_info(f"[{self.sensor_name}]{message}")
 
-    def log_warning(self,message): self.logger_interface.log_warning(f"[{self.sensor_name}]{message}")
+    # def log_warning(self,message): self.logger_interface.log_warning(f"[{self.sensor_name}]{message}")
 
-    def log_error(self,message): self.logger_interface.log_error(f"[{self.sensor_name}]{message}")
+    # def log_error(self,message): self.logger_interface.log_error(f"[{self.sensor_name}]{message}")
+
+    def log_info(self,message): self.logger_interface.log_info(message)
+    
+    def log_warning(self,message): self.logger_interface.log_warning(message)
+
+    def log_error(self,message): self.logger_interface.log_error(message)
 
     def generate_dependencies_list(self): return []
 
@@ -329,7 +335,7 @@ class ValueSelector(VirtualSensorBase):
 
     def process_config(self) -> list[SelectorConfig]:
         configs = list()
-        #self.log(f"yaml_block:{self.yaml_block}")
+        #self.log_info(f"yaml_block:{self.yaml_block}")
         if 'values' in self.yaml_block: values_block = self.yaml_block['values']
         else: values_block = self.yaml_block
 
@@ -354,7 +360,7 @@ class ValueSelector(VirtualSensorBase):
         selectors_config = self.process_config()
 
         for config in selectors_config:
-            #self.log(f"config: name = {config.name},conditions = {config.conditions},value = {config.value}")
+            #self.log_info(f"config: name = {config.name},conditions = {config.conditions},value = {config.value}")
             conditions = SmartCondition.Evaluator(self.ad_api,config.conditions, logger_interface = self.logger_interface,condition_name = config.name, sensor_existence_validation = False, constants = self.constants, log_init = False)
             self.extract_dependencies_from_entities_to_listen(conditions.get_entities_to_listen_as_list(),dependencies)
             
@@ -374,20 +380,23 @@ class ValueSelector(VirtualSensorBase):
             self.output_sensor.set_state(state = value)
 
     def update_value(self):
-        previous_value = str(self.output_sensor.get_state())
+        with self.logger_interface.log_group(self.sensor_name):
+            previous_value = str(self.output_sensor.get_state())
 
-        for selector in self.value_selectors:
+            for selector in self.value_selectors:
-            if selector.conditions.evaluate(False) == SmartCondition.Result.Succeeded:
+                if selector.conditions.evaluate(False) == SmartCondition.Result.Succeeded:
-                new_value = selector.compute_value()
+                    new_value = selector.compute_value()
-                if previous_value != str(new_value):
+                    if previous_value != str(new_value):
-                    #TODO: find a way to know wether if it's the condition or the value that trigger the update
+                        #TODO: find a way to know wether if it's the condition or the value that trigger the update
-                    selector.conditions.log_callback_trigger_reason()
+                        selector.conditions.log_callback_trigger_reason()
-                    selector.conditions.log_evaluation_result()
+                        selector.conditions.log_evaluation_result()
-                    if selector.value:
+                        if selector.value:
-                        selector.value.log_callback_trigger_reason()
+                            selector.value.log_callback_trigger_reason()
-                        selector.value.log_evaluation_result()
+                            selector.value.log_evaluation_result()
-                    self.set_value(new_value)
+                        self.set_value(new_value)
-                break
+                    break
+
+            self.log_info(f"{self.sensor_name} = {self.output_sensor.get_state()}")
 
 class ContinuousCondition(VirtualSensorBase):
     def initialize(self):
@@ -397,19 +406,19 @@ class ContinuousCondition(VirtualSensorBase):
         except KeyError: self.ignore_unavailable_condition = False
         try: self.invert = self.yaml_block['invert']
         except KeyError: self.invert = False
-        self.log(f"Initializing continuous condition for {self.sensor_name}")
+        self.log_info(f"Initializing continuous condition for {self.sensor_name}")
         self.output_sensor = self.ad_api.get_entity(self.sensor_name)
 
         if not self.output_sensor.exists():
-            self.log(f"{self.sensor_name} does not exist")
+            self.log_info(f"{self.sensor_name} does not exist")
             try: 
                 self.output_sensor.set_state(state = self.yaml_block['default_value'])
-                self.log(f"adding {self.sensor_name} with default state {self.yaml_block['default_value']}")
+                self.log_info(f"adding {self.sensor_name} with default state {self.yaml_block['default_value']}")
             except KeyError: 
                 self.output_sensor.set_state(state = 'off')
-                self.log(f"adding {self.sensor_name} with default state off")
+                self.log_info(f"adding {self.sensor_name} with default state off")
         else:
-            self.log(f"{self.sensor_name} already exist with state = {self.output_sensor.get_state()}")
+            self.log_info(f"{self.sensor_name} already exist with state = {self.output_sensor.get_state()}")
 
         if self.invert:
             succeed_cb = self.on_condition_fail
@@ -466,19 +475,19 @@ class RetainCondition(VirtualSensorBase):
         self.retain_time = self.yaml_block['retain_time']
         try: self.reset_retain_time_on_new_success = self.yaml_block['reset_retain_time_on_new_success']
         except KeyError: self.reset_retain_time_on_new_success = True
-        self.log(f"Initializing retain condition for {self.sensor_name}")
+        self.log_info(f"Initializing retain condition for {self.sensor_name}")
         self.output_sensor = self.ad_api.get_entity(self.sensor_name)
 
         if not self.output_sensor.exists():
-            self.log(f"{self.sensor_name} does not exist")
+            self.log_info(f"{self.sensor_name} does not exist")
             try: 
                 self.output_sensor.set_state(state = self.yaml_block['default_value'])
-                self.log(f"adding {self.sensor_name} with default state {self.yaml_block['default_value']}")
+                self.log_info(f"adding {self.sensor_name} with default state {self.yaml_block['default_value']}")
             except KeyError: 
                 self.output_sensor.set_state(state = 'off')
-                self.log(f"adding {self.sensor_name} with default state off")
+                self.log_info(f"adding {self.sensor_name} with default state off")
         else:
-            self.log(f"{self.sensor_name} already exist with state = {self.output_sensor.get_state()}")
+            self.log_info(f"{self.sensor_name} already exist with state = {self.output_sensor.get_state()}")
 
         self.condition = SmartCondition.Evaluator(self.ad_api,self.yaml_block['conditions'], logger_interface = self.logger_interface,condition_name = self.sensor_name,on_succeed_cb = self.on_condition_succeed, on_fail_cb = self.on_condition_fail, constants = self.constants, templates_library = self.templates_library)
         # new_value = 'on' if self.condition.evaluate() == SmartCondition.Result.Succeeded else 'off'
@@ -537,7 +546,7 @@ class BinarySensor(VirtualSensorBase):
             self.output_sensor.set_state(state = 'off',attributes = self.attributes)
         
         #self.ad_api.log(f"Creating Binary Sensor: binary_sensor = {self.virtual_sensor_name}, yaml_block = {self.yaml_block}")
-        self.condition = SmartCondition.Evaluator(self.ad_api,self.get_expression_yaml(), logger_interface = self.logger_interface, unavaibility_result = SmartCondition.Result.Unavailable,condition_name = self.virtual_sensor_name,on_change_cb = self.on_sensor_change, constants = self.constants, templates_library = self.templates_library)
+        self.condition = SmartCondition.Evaluator(self.ad_api,self.get_expression_yaml(), logger_interface = self.logger_interface, unavaibility_result = SmartCondition.Result.Unavailable,condition_name = self.virtual_sensor_name,on_change_cb = self.on_sensor_change, constants = self.constants, templates_library = self.templates_library, log_group = self.sensor_name)
         new_value = 'on' if self.condition.evaluate() == SmartCondition.Result.Succeeded else 'off'
         self.output_sensor.set_state(state = new_value)