add support for expression in sensor_attributes

virtualsensors.py

@@ -4,6 +4,7 @@ import smartvalue as SmartValue
 from kwargsparser import kwargsParser
 from expressionparser import ParsingException
 import time
+import re
 from logger_interface import LoggerInterface
 from ad_toolbox.eventhandler import EventHandler
 
@@ -65,21 +66,48 @@ class VirtualSensorBase:
 
     def generate_dependencies_list(self): return []
 
+    @staticmethod
+    def is_entity_reference(value):
+        # Keep plain entity IDs on the legacy path so their raw state type is preserved.
+        return isinstance(value, str) and re.fullmatch(r"[a-z_][a-z0-9_]*\.[a-z0-9_]+", value) is not None
+
     def generate_attributes_dependencies_list(self):
         dependencies = list()
         if 'sensor_attributes' in self.yaml_block:
-            for key,entity in self.yaml_block['sensor_attributes'].items():
-                dependencies.append(entity)
+            for expression in self.yaml_block['sensor_attributes'].values():
+                if self.is_entity_reference(expression):
+                    dependencies.append(expression)
+                else:
+                    evaluator = SmartValue.Evaluator(
+                        self.ad_api, expression, constants=self.constants,
+                        sensor_existence_validation=False, activated=False, log_init=False)
+                    self.extract_dependencies_from_entities_to_listen(
+                        evaluator.get_entities_to_listen_as_list(), dependencies)
         return dependencies
 
     def _initialize(self): 
+        self.attribute_expressions = dict()
         if 'sensor_attributes' in self.yaml_block:
-            for attribute_name,sensor_name in self.yaml_block['sensor_attributes'].items():
-                if not self.ad_api.entity_exists(sensor_name):
-                    self.log_error(f"Error in sensor_attribute. {attribute_name}:{sensor_name}. {sensor_name} doesn't exist")
+            for attribute_name,expression in self.yaml_block['sensor_attributes'].items():
+                if self.is_entity_reference(expression):
+                    if not self.ad_api.entity_exists(expression):
+                        self.log_error(f"Error in sensor_attribute. {attribute_name}:{expression}. {expression} doesn't exist")
+                    else:
+                        self.attributes[attribute_name] = self.ad_api.get_state(expression)
+                        self.ad_api.listen_state(self.on_attribute_sensor_state_change,expression)
                 else:
-                    self.attributes[attribute_name] = self.ad_api.get_state(sensor_name)
-                    self.ad_api.listen_state(self.on_attribute_sensor_state_change,sensor_name)
+                    try:
+                        evaluator = SmartValue.Evaluator(
+                            self.ad_api, expression, logger_interface=self.logger_interface,
+                            expression_name=f"{self.sensor_name}.{attribute_name}",
+                            constants=self.constants, sensor_existence_validation=False,
+                            trigger_callback_on_activation=False,
+                            on_change_cb=self.on_attribute_expression_change,
+                            pass_expression_name_to_cb=attribute_name)
+                        self.attribute_expressions[attribute_name] = evaluator
+                        self.attributes[attribute_name] = evaluator.evaluate(False)
+                    except ParsingException as error:
+                        self.log_error(error)
 
         try: self.initialize()
         except ParsingException as e: 
@@ -96,6 +124,10 @@ class VirtualSensorBase:
         if attributes_update:
             self.ad_api.set_state(self.sensor_name, attributes = self.attributes)
 
+    def on_attribute_expression_change(self, attribute_name, previous_value, value):
+        self.attributes[attribute_name] = value
+        self.ad_api.set_state(self.sensor_name, attributes=self.attributes)
+
     def initialize(self): assert False
 
     def extract_dependencies_from_entities_to_listen(self,entities_to_listen,dependencies):
@@ -712,4 +744,4 @@ class VirtualSensors():
 class VirtualSensorsApp(hass.Hass):
     def initialize(self):
         self.logger_interface = LoggerInterface(self.get_ad_api(),default_log = "virtualsensors_log")
-        self.virtual_sensors = VirtualSensors(ad_api = self.get_ad_api(),logger_interface = self.logger_interface,yaml_block = self.args,args_to_ignore_in_validation = ['module','class','global_dependencies','priority','name','config_path'],app_name = self.name)
+        self.virtual_sensors = VirtualSensors(ad_api = self.get_ad_api(),logger_interface = self.logger_interface,yaml_block = self.args,args_to_ignore_in_validation = ['module','class','global_dependencies','priority','name','config_path'],app_name = self.name)