device logging improved for functional visibility at loglevel info

devices/base.py

         # initialisations
         mqtt_client.add_callback(topic=self.topic, callback=self.receive_callback)
         mqtt_client.add_callback(topic=self.topic+"/#", callback=self.receive_callback)
+        #
+        self.add_callback(None, None, self.__state_logging__, on_change_only=True)
 
     def set(self, key, data, block_callback=[]):
         if key in self.RX_IGNORE_KEYS:

devices/brennenstuhl.py

         self.add_callback(self.KEY_BATTERY, None, self.__warning__, True)
         self.__battery_warning__ = False
 
+    def __state_logging__(self, inst, key, data):
+        if key in [self.KEY_HEATING_SETPOINT, self.KEY_CHILD_LOCK, self.KEY_WINDOW_DETECTION, self.KEY_VALVE_DETECTION]:
+            self.logger.info("State change of '%s' to '%s'", key, repr(data))
+
     #
     # WARNING CALL
     #
         self.send_command(self.KEY_HEATING_SETPOINT, setpoint)
 
     def set_heating_setpoint_mcb(self, device, key, data):
-        self.logger.info("Changing heating setpoint to %s", str(data))
         self.set_heating_setpoint(data)

devices/mydevices.py

     #
     RX_KEYS = [KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_OUTPUT_2, KEY_OUTPUT_3]
 
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
+    def __state_logging__(self, inst, key, data):
+        if key in self.KEY_OUTPUT_LIST:
+            self.logger.info("State change of '%s' to '%s'", key, repr(data))
 
     #
     # RX
         self.send_command(self.KEY_OUTPUT_0, state)
 
     def set_output_0_mcb(self, device, key, data):
-        self.logger.log(logging.INFO if data != self.output_0 else logging.DEBUG, "Changing output 0 to %s", str(data))
         self.set_output_0(data)
 
     def toggle_output_0_mcb(self, device, key, data):
-        self.logger.info("Toggeling output 0")
         self.set_output_0(not self.output_0)
 
     def set_output_1(self, state):
         self.send_command(self.KEY_OUTPUT_1, state)
 
     def set_output_1_mcb(self, device, key, data):
-        self.logger.log(logging.INFO if data != self.output_1 else logging.DEBUG, "Changing output 1 to %s", str(data))
         self.set_output_1(data)
 
     def toggle_output_1_mcb(self, device, key, data):
-        self.logger.info("Toggeling output 1")
         self.set_output_1(not self.output_1)
 
     def set_output_2(self, state):
         self.send_command(self.KEY_OUTPUT_2, state)
 
     def set_output_2_mcb(self, device, key, data):
-        self.logger.log(logging.INFO if data != self.output_2 else logging.DEBUG, "Changing output 2 to %s", str(data))
         self.set_output_2(data)
 
     def toggle_output_2_mcb(self, device, key, data):
-        self.logger.info("Toggeling output 2")
         self.set_output_2(not self.output_2)
 
     def set_output_3(self, state):
         self.send_command(self.KEY_OUTPUT_3, state)
 
     def set_output_3_mcb(self, device, key, data):
-        self.logger.log(logging.INFO if data != self.output_3 else logging.DEBUG, "Changing output 3 to %s", str(data))
         self.set_output_3(data)
 
     def toggle_output_3_mcb(self, device, key, data):
-        self.logger.info("Toggeling output 3")
         self.set_output_3(not self.output_3)
 
     def set_output_all(self, state):
         self.send_command(self.KEY_OUTPUT_ALL, state)
 
     def set_output_all_mcb(self, device, key, data):
-        self.logger.info("Changing all outputs to %s", str(data))
         self.set_output_all(data)
 
     def all_off(self):
     #
     RX_IGNORE_TOPICS = [KEY_CD, KEY_LINE1, KEY_LINE3, KEY_MUTE, KEY_POWER, KEY_VOLUP, KEY_VOLDOWN]
 
+    def __state_logging__(self, inst, key, data):
+        pass    # This is just a TX device using self.set_*
+
     def set_cd(self, device=None, key=None, data=None):
+        self.logger.info("Changing amplifier source to CD")
         self.send_command(self.KEY_CD, None)
 
     def set_line1(self, device=None, key=None, data=None):
+        self.logger.info("Changing amplifier source to LINE1")
         self.send_command(self.KEY_LINE1, None)
 
     def set_line3(self, device=None, key=None, data=None):
+        self.logger.info("Changing amplifier source to LINE3")
         self.send_command(self.KEY_LINE3, None)
 
     def set_mute(self, device=None, key=None, data=None):
+        self.logger.info("Muting / Unmuting amplifier")
         self.send_command(self.KEY_MUTE, None)
 
     def set_power(self, device=None, key=None, data=None):
+        self.logger.info("Power on/off amplifier")
         self.send_command(self.KEY_POWER, None)
 
     def set_volume_up(self, data=False):
         """data: [True, False]"""
+        self.logger.info("Increasing amplifier volume")
         self.send_command(self.KEY_VOLUP, data)
 
     def set_volume_down(self, data=False):
         """data: [True, False]"""
+        self.logger.info("Decreasing amplifier volume")
         self.send_command(self.KEY_VOLDOWN, data)
 
     def default_inc(self, device=None, key=None, data=None):
     #
     RX_KEYS = [KEY_STATE, KEY_TITLE]
 
+    def __state_logging__(self, inst, key, data):
+        if key in [self.KEY_STATE, self.KEY_TITLE]:
+            self.logger.info("State change of '%s' to '%s'", key, repr(data))
+
     def set_state(self, num, data):
         """data: [True, False]"""
         self.send_command(self.KEY_STATE + "/" + str(num), data)
 
     def set_state_mcb(self, device, key, data):
-        self.logger.info("Changing state to %s", str(data))
         self.set_state(data)

devices/shelly.py

         #
         self.all_off_requested = False
 
+    def __state_logging__(self, inst, key, data):
+        if key in [self.KEY_OUTPUT_0, self.KEY_OUTPUT_1]:
+            self.logger.info("State change of '%s' to '%s'", key, repr(data))
+        elif key in [self.KEY_INPUT_0, self.KEY_INPUT_1, self.KEY_LONGPUSH_0, self.KEY_LONGPUSH_1]:
+            self.logger.info("Input action '%s' with '%s'", key, repr(data))
+
     def flash_task(self, *args):
         if self.flash_active:
             self.send_command(self.output_key_delayed, not self.get(self.output_key_delayed))
         self.send_command(self.KEY_OUTPUT_0, state)
 
     def set_output_0_mcb(self, device, key, data):
-        self.logger.log(logging.INFO if data != self.output_0 else logging.DEBUG, "Changing output 0 to %s", str(data))
         self.set_output_0(data)
 
     def toggle_output_0_mcb(self, device, key, data):
-        self.logger.info("Toggeling output 0")
         self.set_output_0(not self.output_0)
 
     def set_output_1(self, state):
         self.send_command(self.KEY_OUTPUT_1, state)
 
     def set_output_1_mcb(self, device, key, data):
-        self.logger.log(logging.INFO if data != self.output_1 else logging.DEBUG, "Changing output 1 to %s", str(data))
         self.set_output_1(data)
 
     def toggle_output_1_mcb(self, device, key, data):
-        self.logger.info("Toggeling output 1")
         self.set_output_1(not self.output_1)
 
     def flash_0_mcb(self, device, key, data):

devices/silvercrest.py

     RX_KEYS = [KEY_LINKQUALITY, KEY_OUTPUT_0]
     RX_FILTER_DATA_KEYS = [KEY_OUTPUT_0]
 
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
+    def __state_logging__(self, inst, key, data):
+        if key in [self.KEY_OUTPUT_0]:
+            self.logger.info("State change of '%s' to '%s'", key, repr(data))
 
     #
     # RX
         self.send_command(self.KEY_OUTPUT_0, state)
 
     def set_output_0_mcb(self, device, key, data):
-        self.logger.log(logging.INFO if data != self.output_0 else logging.DEBUG, "Changing output 0 to %s", str(data))
         self.set_output_0(data)
 
     def toggle_output_0_mcb(self, device, key, data):
-        self.logger.info("Toggeling output 0")
         self.set_output_0(not self.output_0)
 
     def all_off(self):
         #
         self.add_callback(self.KEY_BATTERY_LOW, True, self.__warning__, True)
 
+    def __state_logging__(self, inst, key, data):
+        if key in [self.KEY_OCCUPANCY, self.KEY_UNMOUNTED]:
+            self.logger.info("State change of '%s' to '%s'", key, repr(data))
+
     #
     # WARNING CALL
     #

devices/tradfri.py

     RX_IGNORE_KEYS = ['update', 'color_mode', 'color_temp_startup']
     RX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
 
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
+    def __state_logging__(self, inst, key, data):
+        if key in [self.KEY_OUTPUT_0, self.KEY_BRIGHTNESS, self.KEY_COLOR_TEMP, self.KEY_BRIGHTNESS_FADE]:
+            self.logger.info("State change of '%s' to '%s'", key, repr(data))
 
     def __device_to_instance_filter__(self, key, data):
         if key == self.KEY_BRIGHTNESS:
         self.send_command(self.KEY_OUTPUT_0, state)
 
     def set_output_0_mcb(self, device, key, data):
-        self.logger.log(logging.INFO if data != self.output_0 else logging.DEBUG, "Changing output 0 to %s", str(data))
         self.set_output_0(data)
 
     def toggle_output_0_mcb(self, device, key, data):
-        self.logger.info("Toggeling output 0")
         self.set_output_0(not self.output_0)
 
     def set_brightness(self, brightness):
         self.send_command(self.KEY_BRIGHTNESS, brightness)
 
     def set_brightness_mcb(self, device, key, data):
-        self.logger.log(logging.INFO if data != self.brightness else logging.DEBUG, "Changing brightness to %s", str(data))
         self.set_brightness(data)
 
     def default_inc(self, speed=40):
         self.send_command(self.KEY_COLOR_TEMP, color_temp)
 
     def set_color_temp_mcb(self, device, key, data):
-        self.logger.log(logging.INFO if data != self.color_temp else logging.DEBUG, "Changing color temperature to %s", str(data))
         self.set_color_temp(data)
 
     def all_off(self):
         self.add_callback(self.KEY_BATTERY, None, self.__warning__, True)
         self.__battery_warning__ = False
 
+    def __state_logging__(self, inst, key, data):
+        if key in [self.KEY_ACTION]:
+            self.logger.info("Input '%s' with '%s'", key, repr(data))
+
     #
     # WARNING CALL
     #