Fix summer/winter mode (identification of rooms / room_collection)

.gitmodules

@@ -13,3 +13,6 @@
 [submodule "devdi"]
 	path = devdi
 	url = https://git.mount-mockery.de/smarthome/smart_devdi.git
+[submodule "smart_devices"]
+	path = smart_devices
+	url = https://git.mount-mockery.de/smarthome/smart_devices.git

__make.d__/coverage.mk

@@ -8,5 +8,5 @@ COV3_CMD=venv/bin/coverage
 
 coverage:
 	$(COV3_CMD) erase
-	$(COV3_CMD) run -a --branch --source=devdi,devices,function smart_brain.py
+	$(COV3_CMD) run -a --branch --source=devdi,smart_devices,devices,function smart_brain.py
 	$(COV3_CMD) xml -o ../smart_brain_test/testresults/coverage.xml

__test__/devices/module.py

@@ -1,35 +0,0 @@
-import json
-from mqtt import mqtt_client
-import time
-
-TEST_CLIENT_ID = "__test_device_tester__"
-
-
-mqtt_test_client = mqtt_client(TEST_CLIENT_ID, "localhost")
-
-
-def init_state(all_state_keys, device):
-    for state_topic in all_state_keys:
-        assert device.get(state_topic, 0) == None
-
-
-def state_change_by_mqtt(all_state_keys, num_states, mqtt_test_client, base_topic, device, mqtt_data, state_data, warning_condition, mqtt_signal_time):
-    tm_warning = None
-
-    for i in range(num_states):
-        for state_topic in all_state_keys:
-            if device.TX_TYPE == device.TX_VALUE:
-                data = json.dumps(mqtt_data(state_topic)[i])
-                mqtt_test_client.send(base_topic + '/' + state_topic, data)
-            elif device.TX_TYPE == device.TX_DICT:
-                mqtt_test_client.send(base_topic, json.dumps({state_topic: mqtt_data(state_topic)[i]}))
-            else:
-                raise TypeError("Unknown TX_TYPE for device.")
-            if callable(warning_condition):
-                if warning_condition(state_topic, mqtt_data(state_topic)[i]):
-                    tm_warning = int(time.time())
-        time.sleep(mqtt_signal_time)
-        for state_topic in all_state_keys:
-            assert device.get(state_topic) == state_data(state_topic)[i]
-
-    return tm_warning

__test__/devices/test_my_powerplug.py

@@ -1,45 +0,0 @@
-from module import mqtt_test_client, init_state, state_change_by_mqtt
-from devices import my_powerplug as test_device
-from devices.base import warning
-from mqtt import mqtt_client
-import pytest
-import time
-
-DUT_CLIENT_ID = "__%s__" % __name__
-TOPIC = "__test__/%s" % __name__
-#
-MQTT_SIGNAL_TIME = 0.2
-
-
-ALL_STATE_KEYS = ["output/1", "output/2", "output/3", "output/4", ]
-BOOL_KEYS = ALL_STATE_KEYS
-
-
-@pytest.fixture
-def this_device():
-    mc = mqtt_client(DUT_CLIENT_ID, 'localhost')
-    return test_device(mc, TOPIC)
-
-
-def test_initial_states(this_device: test_device):
-    # test all initial values
-    init_state(ALL_STATE_KEYS, this_device)
-
-
-def test_state_change_by_mqtt(this_device: test_device):
-    def state_data(key):
-        return (True, False)
-
-    def mqtt_data(key):
-        return state_data(key)
-
-    # test state changes
-    tm_warning = state_change_by_mqtt(ALL_STATE_KEYS, 2, mqtt_test_client, TOPIC, this_device,
-                                      mqtt_data, state_data, None, MQTT_SIGNAL_TIME)
-
-
-def test_specific_get_functions(this_device: test_device):
-    assert this_device.output_0 == this_device.get(this_device.KEY_OUTPUT_0)
-    assert this_device.output_1 == this_device.get(this_device.KEY_OUTPUT_1)
-    assert this_device.output_2 == this_device.get(this_device.KEY_OUTPUT_2)
-    assert this_device.output_3 == this_device.get(this_device.KEY_OUTPUT_3)

__test__/devices/test_shelly.py

@@ -1,250 +0,0 @@
-from module import mqtt_test_client, init_state, state_change_by_mqtt
-from devices import shelly_sw1 as test_device
-from devices.base import warning
-from mqtt import mqtt_client
-import pytest
-import time
-
-DUT_CLIENT_ID = "__%s__" % __name__
-TOPIC = "__test__/%s" % __name__
-#
-MQTT_SIGNAL_TIME = 0.2
-
-
-ALL_STATE_KEYS = ["relay/0", "relay/1", "input/0", "input/1", "longpush/0", "longpush/1", "temperature", "overtemperature"]
-BOOL_KEYS = ["relay/0", "relay/1", "input/0", "input/1", "longpush/0", "longpush/1", "overtemperature"]
-
-
-@pytest.fixture
-def this_device():
-    mc = mqtt_client(DUT_CLIENT_ID, 'localhost')
-    return test_device(mc, TOPIC)
-
-
-def test_initial_states(this_device: test_device):
-    # test all initial values
-    init_state(ALL_STATE_KEYS, this_device)
-
-
-def test_state_change_by_mqtt(this_device: test_device):
-    def state_data(key):
-        if key in BOOL_KEYS:
-            return (True, False)
-        elif key == "temperature":
-            return (85.3, 20.1)
-        else:
-            raise IndexError("No return value defined for key %s" % key)
-
-    def mqtt_data(key):
-        if key in ["relay/0", "relay/1"]:
-            return ('on', 'off')
-        elif key in ["input/0", "input/1", "longpush/0", "longpush/1", "overtemperature"]:
-            return (1, 0)
-        else:
-            return state_data(key)
-
-    def warning_condition(state_topic, value):
-        return state_topic == "overtemperature" and value == 1
-
-    # test state changes
-    tm_warning = state_change_by_mqtt(ALL_STATE_KEYS, 2, mqtt_test_client, TOPIC, this_device,
-                                      mqtt_data, state_data, warning_condition, MQTT_SIGNAL_TIME)
-
-    # test warning
-    w: warning = this_device.get(this_device.KEY_WARNING)
-    assert w.get(w.KEY_ID) == TOPIC
-    assert w.get(w.KEY_TYPE) == w.TYPE_OVERTEMPERATURE
-    wt = time.mktime(w.get(w.KEY_TM))
-    wt_min = tm_warning
-    wt_max = tm_warning + 2
-    assert wt >= wt_min and wt <= wt_max
-
-
-def test_specific_get_functions(this_device: test_device):
-    assert this_device.output_0 == this_device.get(this_device.KEY_OUTPUT_0)
-    assert this_device.output_1 == this_device.get(this_device.KEY_OUTPUT_1)
-    assert this_device.input_0 == this_device.get(this_device.KEY_INPUT_0)
-    assert this_device.input_1 == this_device.get(this_device.KEY_INPUT_1)
-    assert this_device.longpush_0 == this_device.get(this_device.KEY_LONGPUSH_0)
-    assert this_device.longpush_1 == this_device.get(this_device.KEY_LONGPUSH_1)
-    assert this_device.temperature == this_device.get(this_device.KEY_TEMPERATURE)
-
-
-def test_send_command(this_device: test_device):
-    this_device.set_output_0(True)
-    this_device.set_output_0(False)
-
-
-'''
-class shelly(base):
-    """ Communication (MQTT)
-
-        shelly
-            +- relay
-            |      +- 0 ["on" / "off"]              <- status 
-            |      |  +- command ["on"/ "off"]      <- command
-            |      |  +- energy [numeric]           <- status
-            |      +- 1 ["on" / "off"]              <- status
-            |         +- command ["on"/ "off"]      <- command
-            |         +- energy [numeric]           <- status
-            +- input
-            |      +- 0 [0 / 1]                     <- status
-            |      +- 1 [0 / 1]                     <- status
-            +- input_event
-            |      +- 0                             <- status
-            |      +- 1                             <- status
-            +- logpush
-            |      +- 0 [0 / 1]                     <- status
-            |      +- 1 [0 / 1]                     <- status
-            +- temperature [numeric] °C             <- status
-            +- temperature_f [numeric] F            <- status
-            +- overtemperature [0 / 1]              <- status
-            +- id                                   <- status
-            +- model                                <- status
-            +- mac                                  <- status
-            +- ip                                   <- status
-            +- new_fw                               <- status
-            +- fw_ver                               <- status
-    """
-    KEY_OUTPUT_0 = "relay/0"
-    KEY_OUTPUT_1 = "relay/1"
-    KEY_INPUT_0 = "input/0"
-    KEY_INPUT_1 = "input/1"
-    KEY_LONGPUSH_0 = "longpush/0"
-    KEY_LONGPUSH_1 = "longpush/1"
-    KEY_TEMPERATURE = "temperature"
-    KEY_OVERTEMPERATURE = "overtemperature"
-    KEY_ID = "id"
-    KEY_MODEL = "model"
-    KEY_MAC = "mac"
-    KEY_IP = "ip"
-    KEY_NEW_FIRMWARE = "new_fw"
-    KEY_FIRMWARE_VERSION = "fw_ver"
-    #
-    TX_TOPIC = "command"
-    TX_TYPE = base.TX_VALUE
-    TX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_OUTPUT_1]
-    #
-    RX_KEYS = [KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_INPUT_0, KEY_INPUT_1, KEY_LONGPUSH_0, KEY_LONGPUSH_1, KEY_OVERTEMPERATURE, KEY_TEMPERATURE,
-               KEY_ID, KEY_MODEL, KEY_MAC, KEY_IP, KEY_NEW_FIRMWARE, KEY_FIRMWARE_VERSION]
-    RX_IGNORE_TOPICS = [KEY_OUTPUT_0 + '/' + "energy", KEY_OUTPUT_1 + '/' + "energy", 'input_event/0', 'input_event/1']
-    RX_IGNORE_KEYS = ['temperature_f']
-    RX_FILTER_DATA_KEYS = [KEY_INPUT_0, KEY_INPUT_1, KEY_LONGPUSH_0, KEY_LONGPUSH_1, KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_OVERTEMPERATURE]
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-        #
-        self.output_key_delayed = None
-        self.delayed_flash_task = task.delayed(0.3, self.flash_task)
-        self.delayed_off_task = task.delayed(0.3, self.off_task)
-        #
-        self.add_callback(self.KEY_OVERTEMPERATURE, True, self.__warning__, True)
-        #
-        self.all_off_requested = False
-
-    def flash_task(self, *args):
-        if self.flash_active:
-            self.send_command(self.output_key_delayed, not self.get(self.output_key_delayed))
-            self.output_key_delayed = None
-            if self.all_off_requested:
-                self.delayed_off_task.run()
-
-    def off_task(self, *args):
-        self.all_off()
-
-    @property
-    def flash_active(self):
-        return self.output_key_delayed is not None
-
-    #
-    # WARNING CALL
-    #
-    def __warning__(self, client, key, data):
-        w = warning(self.topic, warning.TYPE_OVERTEMPERATURE, "Temperature to high (%.1f°C)", self.get(self.KEY_TEMPERATURE) or math.nan)
-        self.logger.warning(w)
-        self.set(self.KEY_WARNING, w)
-
-    #
-    # RX
-    #
-    @property
-    def output_0(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_0)
-
-    @property
-    def output_1(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_1)
-
-    @property
-    def input_0(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_INPUT_0)
-
-    @property
-    def input_1(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_INPUT_1)
-
-    @property
-    def longpush_0(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_LONGPUSH_0)
-
-    @property
-    def longpush_1(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_LONGPUSH_1)
-
-    @property
-    def temperature(self):
-        """rv: numeric value"""
-        return self.get(self.KEY_TEMPERATURE)
-
-    #
-    # TX
-    #
-    def set_output_0(self, state):
-        """state: [True, False]"""
-        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):
-        """state: [True, False]"""
-        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):
-        self.output_key_delayed = self.KEY_OUTPUT_0
-        self.toggle_output_0_mcb(device, key, data)
-        self.delayed_flash_task.run()
-
-    def flash_1_mcb(self, device, key, data):
-        self.output_key_delayed = self.KEY_OUTPUT_1
-        self.toggle_output_1_mcb(device, key, data)
-        self.delayed_flash_task.run()
-
-    def all_off(self):
-        if self.flash_active:
-            self.all_off_requested = True
-        else:
-            if self.output_0:
-                self.set_output_0(False)
-            if self.output_1:
-                self.set_output_1(False)
-'''

__test__/devices/test_silvercrest_motion_sensor.py

@@ -1,55 +0,0 @@
-from module import mqtt_test_client, init_state, state_change_by_mqtt
-from devices import silvercrest_motion_sensor as test_device
-from devices.base import warning
-from mqtt import mqtt_client
-import pytest
-import time
-
-DUT_CLIENT_ID = "__%s__" % __name__
-TOPIC = "__test__/%s" % __name__
-#
-MQTT_SIGNAL_TIME = 0.2
-
-
-ALL_STATE_KEYS = ["battery", "battery_low", "linkquality", "occupancy", "tamper", "voltage"]
-BOOL_KEYS = ["battery_low", "occupancy", "tamper"]
-
-
-@pytest.fixture
-def this_device():
-    mc = mqtt_client(DUT_CLIENT_ID, 'localhost')
-    return test_device(mc, TOPIC)
-
-
-def test_initial_states(this_device: test_device):
-    # test all initial values
-    init_state(ALL_STATE_KEYS, this_device)
-
-
-def test_state_change_by_mqtt(this_device: test_device):
-    def state_data(key):
-        if key in BOOL_KEYS:
-            return (True, False)
-        elif key == "battery":
-            return (2, 87)
-        elif key == "linkquality":
-            return (1, 217)
-        elif key == "voltage":
-            return (1.17, 2.53)
-        else:
-            raise IndexError("No return value defined for key %s" % key)
-
-    def mqtt_data(key):
-        return state_data(key)
-
-    def warning_condition(state_topic, value):
-        return state_topic == "battery_low" and value is True
-
-    # test state changes
-    tm_warning = state_change_by_mqtt(ALL_STATE_KEYS, 2, mqtt_test_client, TOPIC, this_device,
-                                      mqtt_data, state_data, None, MQTT_SIGNAL_TIME)
-
-
-def test_specific_get_functions(this_device: test_device):
-    assert this_device.linkquality == this_device.get(this_device.KEY_LINKQUALITY)
-    assert this_device.battery == this_device.get(this_device.KEY_BATTERY)

__test__/devices/test_silvercrest_powerplug.py

@@ -1,49 +0,0 @@
-from module import mqtt_test_client, init_state, state_change_by_mqtt
-from devices import silvercrest_powerplug as test_device
-from devices.base import warning
-from mqtt import mqtt_client
-import pytest
-import time
-
-DUT_CLIENT_ID = "__%s__" % __name__
-TOPIC = "__test__/%s" % __name__
-#
-MQTT_SIGNAL_TIME = 0.2
-
-
-ALL_STATE_KEYS = ["state"]
-BOOL_KEYS = ["state"]
-
-
-@pytest.fixture
-def this_device():
-    mc = mqtt_client(DUT_CLIENT_ID, 'localhost')
-    return test_device(mc, TOPIC)
-
-
-def test_initial_states(this_device: test_device):
-    # test all initial values
-    init_state(ALL_STATE_KEYS, this_device)
-
-
-def test_state_change_by_mqtt(this_device: test_device):
-    def state_data(key):
-        if key in BOOL_KEYS:
-            return (True, False)
-        else:
-            raise IndexError("No return value defined for key %s" % key)
-
-    def mqtt_data(key):
-        if key in BOOL_KEYS:
-            return ('ON', 'OFF')
-        else:
-            return state_data(key)
-
-    # test state changes
-    tm_warning = state_change_by_mqtt(ALL_STATE_KEYS, 2, mqtt_test_client, TOPIC, this_device,
-                                      mqtt_data, state_data, None, MQTT_SIGNAL_TIME)
-
-
-def test_specific_get_functions(this_device: test_device):
-    assert this_device.linkquality == this_device.get(this_device.KEY_LINKQUALITY)
-    assert this_device.output_0 == this_device.get(this_device.KEY_OUTPUT_0)

__test__/function/modules/test_heating_function.py

@@ -1,40 +0,0 @@
-from function.modules import heating_function as test_class
-
-"""
-config.DEFAULT_TEMPERATURE[heating_valve.topic],
-db_data = get_radiator_data(heating_valve.topic)
-**{
-        test_class.KEY_USER_TEMPERATURE_SETPOINT: db_data[2],
-        test_class.KEY_TEMPERATURE_SETPOINT: db_data[3],
-        test_class.KEY_AWAY_MODE: db_data[0],
-        test_class.KEY_SUMMER_MODE: db_data[1],
-    })
-"""
-
-
-def test_initial_states():
-
-    class heating_valve(object):
-        KEY_HEATING_SETPOINT = 'hsp'
-        KEY_TEMPERATURE = 'temp'
-
-        def set_heating_setpoint(self, value):
-            pass
-
-        def add_callback(self, key, value, callback):
-            pass
-    #
-    #
-    #
-    tc = test_class(
-        heating_valve(),
-        21, **{
-            test_class.KEY_USER_TEMPERATURE_SETPOINT: 22,
-            test_class.KEY_TEMPERATURE_SETPOINT: 17,
-            test_class.KEY_AWAY_MODE: True,
-            test_class.KEY_SUMMER_MODE: False,
-        })
-    assert tc.get(test_class.KEY_USER_TEMPERATURE_SETPOINT) == 22
-    assert tc.get(test_class.KEY_TEMPERATURE_SETPOINT) == 17
-    assert tc.get(test_class.KEY_AWAY_MODE) == True
-    assert tc.get(test_class.KEY_SUMMER_MODE) == False

__test__/requirements.txt

@@ -1,2 +0,0 @@
-pytest
-pytest-cov

base.py

@@ -1,146 +0,0 @@
-import json
-import logging
-import task
-
-try:
-    from config import APP_NAME as ROOT_LOGGER_NAME
-except ImportError:
-    ROOT_LOGGER_NAME = 'root'
-
-
-class common_base(dict):
-    DEFAULT_VALUES = {}
-    DEVICENAME = "DEFAULT"
-
-    def __init__(self, default_values=None):
-        super().__init__(default_values or self.DEFAULT_VALUES)
-        #
-        self.__callback_list__ = []
-        self.ch_names = {}
-        self.logger = logging.getLogger(ROOT_LOGGER_NAME).getChild("devices")
-
-    def set_ch_name(self, key, name):
-        self.ch_names[key] = name
-
-    def get_name(self, key, default=None):
-        return self.DEVICENAME + "." + self.ch_names.get(key, key) + " (" + ".".join(self.topic.split('/')[1:]) + ")"
-
-    def add_callback(self, key, data, callback, on_change_only=False, init_now=False):
-        """
-        key: key or None for all keys
-        data: data or None for all data
-        """
-        cb_tup = (key, data, callback, on_change_only)
-        if cb_tup not in self.__callback_list__:
-            self.__callback_list__.append(cb_tup)
-        if init_now and self.get(key) is not None:
-            callback(self, key, self[key])
-
-    def set(self, key, data, block_callback=[]):
-        if key in self.keys():
-            value_changed = self[key] != data
-            self[key] = data
-            for cb_key, cb_data, callback, on_change_only in self.__callback_list__:
-                if cb_key is None or key == cb_key:                 # key fits to callback definition
-                    if cb_data is None or cb_data == self[key]:     # data fits to callback definition
-                        if value_changed or not on_change_only:     # change status fits to callback definition
-                            if not callback in block_callback:      # block given callbacks
-                                callback(self, key, self[key])
-        else:
-            self.logger.warning("Unexpected key %s", key)
-
-
-class mqtt_base(common_base):
-    def __init__(self, mqtt_client, topic, default_values=None):
-        super().__init__(default_values)
-        #
-        self.mqtt_client = mqtt_client
-        self.topic = topic
-        for entry in self.topic.split('/'):
-            self.logger = self.logger.getChild(entry)
-
-
-class videv_base(mqtt_base):
-    KEY_INFO = '__info__'
-    #
-    SET_TOPIC = "set"
-
-    def __init__(self, mqtt_client, topic, default_values=None):
-        super().__init__(mqtt_client, topic, default_values=default_values)
-        self.__display_dict__ = {}
-        self.__control_dict__ = {}
-        self.__periodic__ = task.periodic(300, self.send_all)
-        self.__periodic__.run()
-
-    def send_all(self, rt):
-        try:
-            for key in self:
-                if self[key] is not None:
-                    self.__tx__(key, self[key])
-        except RuntimeError:
-            self.logger.warning("Runtimeerror while sending cyclic videv information. This may happen on startup.")
-
-    def add_display(self, my_key, ext_device, ext_key, on_change_only=True):
-        """
-        listen to data changes of ext_device and update videv information
-        """
-        if my_key not in self.keys():
-            self[my_key] = None
-        if ext_device.__class__.__name__ == "group":
-            # store information to identify callback from ext_device
-            self.__display_dict__[(id(ext_device[0]), ext_key)] = my_key
-            # register a callback to listen for data from external device
-            ext_device[0].add_callback(ext_key, None, self.__rx_ext_device_data__, on_change_only, init_now=True)
-        else:
-            # store information to identify callback from ext_device
-            self.__display_dict__[(id(ext_device), ext_key)] = my_key
-            # register a callback to listen for data from external device
-            ext_device.add_callback(ext_key, None, self.__rx_ext_device_data__, on_change_only, init_now=True)
-        # send initial display data to videv interface
-        data = ext_device.get(ext_key)
-        if data is not None:
-            self.__tx__(my_key, data)
-
-    def __rx_ext_device_data__(self, ext_device, ext_key, data):
-        my_key = self.__display_dict__[(id(ext_device), ext_key)]
-        self.set(my_key, data)
-        self.__tx__(my_key, data)
-
-    def __tx__(self, key, data):
-        if type(data) not in (str, ):
-            data = json.dumps(data)
-        self.mqtt_client.send('/'.join([self.topic, key]), data)
-
-    def add_control(self, my_key, ext_device, ext_key, on_change_only=True):
-        """
-        listen to videv information and pass data to ext_device
-        """
-        if my_key not in self.keys():
-            self[my_key] = None
-        # store information to identify callback from videv
-        self.__control_dict__[my_key] = (ext_device, ext_key, on_change_only)
-        # add callback for videv changes
-        self.mqtt_client.add_callback('/'.join([self.topic, my_key, self.SET_TOPIC]), self.__rx_videv_data__)
-
-    def __rx_videv_data__(self, client, userdata, message):
-        my_key = message.topic.split('/')[-2]
-        try:
-            data = json.loads(message.payload)
-        except json.decoder.JSONDecodeError:
-            data = message.payload
-        ext_device, ext_key, on_change_only = self.__control_dict__[my_key]
-        if my_key in self.keys():
-            if data != self[my_key] or not on_change_only:
-                ext_device.send_command(ext_key, data)
-        else:
-            self.logger.info("Ignoring rx message with topic %s", message.topic)
-
-    def add_routing(self, my_key, ext_device, ext_key, on_change_only_disp=True, on_change_only_videv=True):
-        """
-        listen to data changes of ext_device and update videv information
-        and
-        listen to videv information and pass data to ext_device
-        """
-        # add display
-        self.add_display(my_key, ext_device, ext_key, on_change_only_disp)
-        self.add_control(my_key, ext_device, ext_key, on_change_only_videv)

config_example/config.j2

@@ -1,6 +1,5 @@
 import geo
 import logging
-from topics import *
 
 DEBUG = False
 #

devdi

@@ -1 +1 @@
-Subproject commit f0b994ef9c3a0526c4b699c491ccb478bc3847d0
+Subproject commit 5a5679b0baa9ba978f75d8581cb0dc7c13158e34

device_development.py

@@ -1,114 +0,0 @@
-import config
-import mqtt
-import readline
-import sys
-import report
-import logging
-import devices
-import json
-
-
-if __name__ == "__main__":
-    report.stdoutLoggingConfigure([[config.APP_NAME, logging.INFO], ], fmt=report.SHORT_FMT)
-    mc = mqtt.mqtt_client(
-        host=config.MQTT_SERVER,
-        port=config.MQTT_PORT,
-        username=config.MQTT_USER,
-        password=config.MQTT_PASSWORD,
-        name=config.APP_NAME + '_devicetest'
-    )
-    #
-    devicedict = {}
-    for device in [
-        # devices.shelly_pro3(mc, "shellies/gfw/pro3"),
-        # devices.brennenstuhl_heatingvalve(mc, "zigbee_raspi/heatvlv"),
-        # devices.silvercrest_button(mc, "zigbee_raspi/button"),
-        devices.hue_sw_br_ct(mc, "zigbee_ffe/kitchen/main_light_1"),
-    ]:
-        devicedict[device.topic.replace("/", "_")] = device
-    #
-    COMMANDS = ['quit', 'help', 'action']
-    for key in devicedict:
-        device = devicedict[key]
-        for cmd in device.__class__.__dict__:
-            obj = getattr(device, cmd)
-            if callable(obj) and not cmd.startswith("_"):
-                COMMANDS.append(key + "." + cmd)
-    #
-
-    def reduced_list(text):
-        """
-        Create reduced completation list
-        """
-        reduced_list = {}
-        for cmd in COMMANDS:
-            next_dot = cmd[len(text):].find('.')
-            if next_dot >= 0:
-                reduced_list[cmd[:len(text) + next_dot + 1]] = None
-            else:
-                reduced_list[cmd] = None
-        return reduced_list.keys()
-
-    def completer(text, state):
-        """
-        Our custom completer function
-        """
-        options = [x for x in reduced_list(text) if x.startswith(text)]
-        return options[state]
-
-    def complete(text, state):
-        for cmd in COMMANDS:
-            if cmd.startswith(text):
-                if not state:
-                    hit = ""
-                    index = 0
-                    sub_list = cmd.split('.')
-                    while len(text) >= len(hit):
-                        hit += sub_list[index] + '.'
-                    return hit  # cmd
-                else:
-                    state -= 1
-
-    if len(sys.argv) == 1:
-        readline.parse_and_bind("tab: complete")
-        readline.set_completer(completer)
-        print("\nEnter command: ")
-        while True:
-            userfeedback = input('')
-            command = userfeedback.split(' ')[0]
-            if userfeedback == 'quit':
-                break
-            elif userfeedback == 'help':
-                print("Help is not yet implemented!")
-            else:
-                try:
-                    key, command = userfeedback.split(".", 1)
-                except ValueError:
-                    print("Unknown device.")
-                else:
-                    device = devicedict[key]
-                    try:
-                        command, params = command.split(" ", 1)
-                    except ValueError:
-                        params = None
-                    try:
-                        obj = getattr(device, command)
-                    except AttributeError:
-                        print("Unknown command.")
-                    else:
-                        if params is not None:
-                            params = params.replace("True", "true")
-                            params = params.replace("False", "false")
-                            params = params.replace("None", "null")
-                            params = params.replace(",", " ")
-                            params = params.split(" ")
-                            params = " ".join([p for p in params if p])
-                            try:
-                                params = json.loads("[" + params.replace(" ", ", ") + "]")
-                            except json.decoder.JSONDecodeError:
-                                print("You need to give python like parameters (e.g. 'test' for a string containing test).")
-                                params = None
-                        try:
-                            obj(*params)
-                        except TypeError:
-                            print("Give the correct parameters to execute.")

devices/__init__.py

@@ -1,58 +1,34 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-"""
-devices (DEVICES)
-=================
-
-**Author:**
-
-* Dirk Alders <sudo-dirk@mount-mockery.de>
-
-**Description:**
-
-    This Module supports smarthome devices
-
-**Submodules:**
-
-* :mod:`shelly`
-* :mod:`silvercrest_powerplug`
-
-**Unittest:**
-
-        See also the :download:`unittest <devices/_testresults_/unittest.pdf>` documentation.
-
-**Module Documentation:**
-
-"""
 import logging
 
-from devices.shelly import shelly as shelly_sw1
-from devices.shelly import shelly_rpc as shelly_pro3
-from devices.hue import hue_light as hue_sw_br_ct
-from devices.tradfri import tradfri_light as tradfri_sw
-from devices.tradfri import tradfri_light as tradfri_sw_br
-from devices.tradfri import tradfri_light as tradfri_sw_br_ct
-from devices.tradfri import tradfri_button as tradfri_button
-from devices.tradfri import tradfri_light as livarno_sw_br_ct
-from devices.brennenstuhl import brennenstuhl_heatingvalve
-from devices.silvercrest import silvercrest_button
-from devices.silvercrest import silvercrest_powerplug
-from devices.silvercrest import silvercrest_motion_sensor
-from devices.mydevices import powerplug as my_powerplug
-from devices.mydevices import audio_status
-from devices.mydevices import remote
-
-from function.videv import videv_switching as videv_sw
-from function.videv import videv_switch_brightness as videv_sw_br
-from function.videv import videv_switch_brightness_color_temp as videv_sw_br_ct
-from function.videv import videv_switching_timer as videv_sw_tm
-from function.videv import videv_switching_motion as videv_sw_mo
-from function.videv import videv_heating as videv_hea
-from function.videv import videv_pure_switch
-from function.videv import videv_multistate
-from function.videv import videv_audio_player
+from smart_devices.shelly import shelly as shelly_sw1
+from smart_devices.shelly import shelly_rpc as shelly_pro3
+from smart_devices.hue import hue_light as hue_sw_br_ct
+from smart_devices.tradfri import tradfri_light as tradfri_sw
+from smart_devices.tradfri import tradfri_light as tradfri_sw_br
+from smart_devices.tradfri import tradfri_light as tradfri_sw_br_ct
+from smart_devices.tradfri import tradfri_button as tradfri_button
+from smart_devices.tradfri import tradfri_light as livarno_sw_br_ct
+from smart_devices.brennenstuhl import brennenstuhl_heatingvalve
+from smart_devices.silvercrest import silvercrest_button
+from smart_devices.silvercrest import silvercrest_powerplug
+from smart_devices.silvercrest import silvercrest_motion_sensor
+from smart_devices.mydevices import powerplug as my_powerplug
+from smart_devices.mydevices import audio_status
+from smart_devices.mydevices import remote
 
+from smart_devices.videv import videv_switching as videv_sw
+from smart_devices.videv import videv_switch_brightness as videv_sw_br
+from smart_devices.videv import videv_switch_brightness_color_temp as videv_sw_br_ct
+from smart_devices.videv import videv_switching_timer as videv_sw_tm
+from smart_devices.videv import videv_switching_motion as videv_sw_mo
+from smart_devices.videv import videv_heating as videv_hea
+from smart_devices.videv import videv_pure_switch
+from smart_devices.videv import videv_multistate
+from smart_devices.videv import videv_audio_player
+from smart_devices.videv import videv_all_off
 try:
     from config import APP_NAME as ROOT_LOGGER_NAME
 except ImportError:

devices/base.py

@@ -1,235 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-from base import mqtt_base
-from base import videv_base
-import json
-
-
-def is_json(data):
-    try:
-        json.loads(data)
-    except json.decoder.JSONDecodeError:
-        return False
-    else:
-        return True
-
-
-class base(mqtt_base):
-    TX_TOPIC = "set"
-    TX_VALUE = 0
-    TX_DICT = 1
-    TX_TYPE = -1
-    TX_FILTER_DATA_KEYS = []
-    #
-    RX_KEYS = []
-    RX_IGNORE_TOPICS = []
-    RX_IGNORE_KEYS = []
-    RX_FILTER_DATA_KEYS = []
-    #
-    CFG_DATA = {}
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic, default_values=dict.fromkeys(self.RX_KEYS))
-        # data storage
-        self.__cfg_by_mid__ = None
-        # 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 __cfg_callback__(self, key, value, mid):
-        if self.CFG_DATA.get(key) != value and self.__cfg_by_mid__ != mid and mid is not None:
-            self.__cfg_by_mid__ = mid
-            self.logger.warning("Differing configuration identified: Sending default configuration to defice: %s", repr(self.CFG_DATA))
-            if self.TX_TYPE == self.TX_DICT:
-                self.mqtt_client.send(self.topic + '/' + self.TX_TOPIC, json.dumps(self.CFG_DATA))
-            else:
-                for key in self.CFG_DATA:
-                    self.send_command(key, self.CFG_DATA.get(key))
-
-    def set(self, key, data, mid=None, block_callback=[]):
-        if key in self.CFG_DATA:
-            self.__cfg_callback__(key, data, mid)
-        if key in self.RX_IGNORE_KEYS:
-            pass    # ignore these keys
-        elif key in self.RX_KEYS:
-            return super().set(key, data, block_callback)
-        else:
-            self.logger.warning("Unexpected key %s", key)
-
-    def receive_callback(self, client, userdata, message):
-        if message.topic != self.topic + '/' + videv_base.KEY_INFO:
-            content_key = message.topic[len(self.topic) + 1:]
-            if content_key not in self.RX_IGNORE_TOPICS and (not message.topic.endswith(self.TX_TOPIC) or len(self.TX_TOPIC) == 0):
-                self.logger.debug("Unpacking content_key \"%s\" from message.", content_key)
-                if is_json(message.payload):
-                    data = json.loads(message.payload)
-                    if type(data) is dict:
-                        for key in data:
-                            self.set(key, self.__device_to_instance_filter__(key, data[key]), message.mid)
-                    else:
-                        self.set(content_key, self.__device_to_instance_filter__(content_key, data), message.mid)
-                # String
-                else:
-                    self.set(content_key, self.__device_to_instance_filter__(content_key, message.payload.decode('utf-8')), message.mid)
-            else:
-                self.logger.debug("Ignoring topic %s", content_key)
-
-    def __device_to_instance_filter__(self, key, data):
-        if key in self.RX_FILTER_DATA_KEYS:
-            if data in [1, 'on', 'ON']:
-                return True
-            elif data in [0, 'off', 'OFF']:
-                return False
-        return data
-
-    def __instance_to_device_filter__(self, key, data):
-        if key in self.TX_FILTER_DATA_KEYS:
-            if data is True:
-                return "on"
-            elif data is False:
-                return "off"
-        return data
-
-    def send_command(self, key, data):
-        data = self.__instance_to_device_filter__(key, data)
-        if self.TX_TOPIC is not None:
-            if self.TX_TYPE < 0:
-                self.logger.error("Unknown tx type. Set TX_TYPE of class to a known value")
-            else:
-                self.logger.debug("Sending data for %s - %s", key, str(data))
-                if self.TX_TYPE == self.TX_DICT:
-                    try:
-                        self.mqtt_client.send('/'.join([self.topic, self.TX_TOPIC]), json.dumps({key: data}))
-                    except TypeError:
-                        print(self.topic)
-                        print(key.__dict__)
-                        print(key)
-                        print(data)
-                        raise TypeError
-                else:
-                    if type(data) not in [str, bytes]:
-                        data = json.dumps(data)
-                    self.mqtt_client.send('/'.join([self.topic, key, self.TX_TOPIC] if len(self.TX_TOPIC) > 0 else [self.topic, key]), data)
-        else:
-            self.logger.error("Unknown tx toptic. Set TX_TOPIC of class to a known value")
-
-
-class base_rpc(mqtt_base):
-    SRC_RESPONSE = "/response"
-    SRC_NULL = "/null"
-    #
-    EVENTS_TOPIC = "/events/rpc"
-    TX_TOPIC = "/rpc"
-    RESPONSE_TOPIC = SRC_RESPONSE + "/rpc"
-    NULL_TOPIC = SRC_NULL + "/rpc"
-    #
-    RPC_ID_GET_STATUS = 1
-    RPC_ID_SET = 1734
-    #
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic, default_values=dict.fromkeys(self.RX_KEYS))
-        # data storage
-        self.__cfg_by_mid__ = None
-        # 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=False)
-        #
-        self.rpc_get_status()
-
-    def receive_callback(self, client, userdata, message):
-        data = json.loads(message.payload)
-        #
-        if message.topic == self.topic + self.EVENTS_TOPIC:
-            self.events(data)
-        elif message.topic == self.topic + self.RESPONSE_TOPIC:
-            self.response(data)
-        elif message.topic == self.topic + self.NULL_TOPIC or message.topic == self.topic + self.TX_TOPIC or message.topic == self.topic + "/online":
-            pass    # Ignore response
-        else:
-            self.logger.warning("Unexpected message received: %s::%s", message.topic, json.dumps(data, sort_keys=True, indent=4))
-
-    def events(self, data):
-        for rx_key in data["params"]:
-            if rx_key == "events":
-                for evt in data["params"]["events"]:
-                    key = evt["component"]
-                    event = evt["event"]
-                    if key in self.RX_KEYS:
-                        if event == "btn_down":
-                            self.set(key, True)
-                        elif event == "btn_up":
-                            self.set(key, False)
-                        else:
-                            key = key + ":" + event
-                            if key in self.RX_KEYS:
-                                self.set(key, True)
-                            else:
-                                self.logger.warning("Unexpected event with data=%s", json.dumps(data, sort_keys=True, indent=4))
-            elif rx_key in self.RX_KEYS:
-                state = data["params"][rx_key].get("output")
-                if state is not None:
-                    self.set(rx_key, state)
-
-    def response(self, data):
-        try:
-            rpc_id = data.get("id")
-        except AttributeError:
-            rpc_id = None
-        try:
-            rpc_method = data.get("method")
-        except AttributeError:
-            rpc_method = None
-        if rpc_id == self.RPC_ID_GET_STATUS:
-            #
-            # Shelly.GetStatus
-            #
-            for rx_key in data.get("result", []):
-                if rx_key in self.RX_KEYS:
-                    key_data = data["result"][rx_key]
-                    state = key_data.get("output", key_data.get("state"))
-                    if state is not None:
-                        self.set(rx_key, state)
-        else:
-            self.logger.warning("Unexpected response with data=%s", json.dumps(data, sort_keys=True, indent=4))
-
-    def rpc_tx(self, **kwargs):
-        if not "id" in kwargs:
-            raise AttributeError("'id' is missing in keyword arguments")
-        self.mqtt_client.send(self.topic + self.TX_TOPIC, json.dumps(kwargs))
-
-    def rpc_get_status(self):
-        self.rpc_tx(
-            id=self.RPC_ID_GET_STATUS,
-            src=self.topic + self.SRC_RESPONSE,
-            method="Shelly.GetStatus"
-        )
-
-    def rpc_switch_set(self, key, state: bool):
-        self.rpc_tx(
-            id=self.RPC_ID_SET,
-            src=self.topic + self.SRC_NULL,
-            method="Switch.Set",
-            params={"id": int(key[-1]), "on": state}
-        )
-
-
-class base_output(base):
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-        self.__all_off_enabled__ = True
-
-    def disable_all_off(self, state=True):
-        self.__all_off_enabled__ = not state
-
-    def all_off(self):
-        if self.__all_off_enabled__:
-            try:
-                self.__all_off__()
-            except (AttributeError, TypeError) as e:
-                self.logger.warning("Method all_off was used, but __all_off__ method wasn't callable: %s", repr(e))

devices/brennenstuhl.py

@@ -1,118 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-from devices.base import base
-import task
-import time
-
-
-class brennenstuhl_heatingvalve(base):
-    """ Communication (MQTT)
-
-        brennenstuhl_heatingvalve {
-                                |      "away_mode": ["ON", "OFF"]
-                                |      "battery": [0...100] %
-                                |      "child_lock": ["LOCK", "UNLOCK"]
-                                |      "current_heating_setpoint": [5...30] °C
-                                |      "linkquality": [0...255] lqi
-                                |      "local_temperature": [numeric] °C
-                                |      "preset": ["manual", ...]
-                                |      "system_mode": ["heat", ...]
-                                |      "valve_detection": ["ON", "OFF"]
-                                |      "window_detection": ["ON", "OFF"]
-                                | }
-                                +- set {
-                                           "away_mode": ["ON", "OFF", "TOGGLE"]
-                                           "child_lock": ["LOCK", "UNLOCK"]
-                                           "current_heating_setpoint": [5...30] °C
-                                           "preset": ["manual", ...]
-                                           "system_mode": ["heat", ...]
-                                           "valve_detection": ["ON", "OFF", "TOGGLE"]
-                                           "window_detection": ["ON", "OFF", "TOGGLE"]
-                                       }
-    """
-    KEY_LINKQUALITY = "linkquality"
-    KEY_BATTERY = "battery"
-    KEY_HEATING_SETPOINT = "current_heating_setpoint"
-    KEY_TEMPERATURE = "local_temperature"
-    #
-    KEY_AWAY_MODE = "away_mode"
-    KEY_CHILD_LOCK = "child_lock"
-    KEY_PRESET = "preset"
-    KEY_SYSTEM_MODE = "system_mode"
-    KEY_VALVE_DETECTION = "valve_detection"
-    KEY_WINDOW_DETECTION = "window_detection"
-    #
-    RETRY_CYCLE_TIME = 2.5
-    MAX_TX_RETRIES = 20
-    RETRY_TIMEOUT = RETRY_CYCLE_TIME * MAX_TX_RETRIES
-    #
-    TX_TYPE = base.TX_DICT
-    #
-    RX_KEYS = [KEY_LINKQUALITY, KEY_BATTERY, KEY_HEATING_SETPOINT, KEY_TEMPERATURE]
-    RX_IGNORE_KEYS = [KEY_AWAY_MODE, KEY_CHILD_LOCK, KEY_PRESET, KEY_SYSTEM_MODE, KEY_VALVE_DETECTION, KEY_WINDOW_DETECTION]
-    #
-    CFG_DATA = {
-        KEY_WINDOW_DETECTION: "ON",
-        KEY_VALVE_DETECTION: "ON",
-        KEY_SYSTEM_MODE: "heat",
-        KEY_PRESET: "manual"
-    }
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-        self.add_callback(self.KEY_HEATING_SETPOINT, None, self.__valave_temp_rx__)
-        self.__tx_temperature__ = None
-        self.__rx_temperature__ = None
-        self.__tx_timestamp__ = 0
-        #
-        self.task = task.periodic(self.RETRY_CYCLE_TIME, self.__task__)
-        self.task.run()
-
-    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))
-
-    def send_command(self, key, data):
-        if key == self.KEY_HEATING_SETPOINT:
-            self.__tx_temperature__ = data
-            self.__tx_timestamp__ = time.time()
-        base.send_command(self, key, data)
-
-    def __valave_temp_rx__(self, inst, key, data):
-        if key == self.KEY_HEATING_SETPOINT:
-            self.__rx_temperature__ = data
-
-    def __task__(self, rt):
-        if self.__tx_temperature__ is not None and self.__tx_timestamp__ is not None:   # Already send a setpoint
-            if self.__tx_temperature__ != self.__rx_temperature__:                      # Setpoint and valve feedback are unequal
-                if time.time() - self.__tx_timestamp__ < self.RETRY_TIMEOUT:            # Timeout condition allows resend of setpoint
-                    self.logger.warning("Setpoint not yet acknoledged by device. Sending setpoint again")
-                    self.set_heating_setpoint(self.__tx_temperature__)
-                    return
-            else:
-                self.__tx_timestamp__ = None                                            # Disable resend logic, if setpoint and valve setpoint are equal
-
-    #
-    # RX
-    #
-    @property
-    def linkqulity(self):
-        return self.get(self.KEY_LINKQUALITY)
-
-    @property
-    def heating_setpoint(self):
-        return self.get(self.KEY_HEATING_SETPOINT)
-
-    @property
-    def temperature(self):
-        return self.get(self.KEY_TEMPERATURE)
-
-    #
-    # TX
-    #
-    def set_heating_setpoint(self, setpoint):
-        self.send_command(self.KEY_HEATING_SETPOINT, setpoint)
-
-    def set_heating_setpoint_mcb(self, device, key, data):
-        self.set_heating_setpoint(data)

devices/hue.py

@@ -1,118 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-from devices.base import base, base_output
-import logging
-
-
-class hue_light(base_output):
-    """ Communication (MQTT)
-
-        hue_light {
-                |      "state": ["ON" / "OFF" / "TOGGLE"]
-                |      "linkquality": [0...255] lqi
-                |      "brightness": [0...254]
-                |      "color_mode": ["color_temp"]
-                |      "color_temp": ["coolest", "cool", "neutral", "warm", "warmest", 250...454]
-                | }
-                +- get {
-                |           "state": ""
-                |      }
-                +- set {
-                            "state": ["ON" / "OFF"]
-                            "brightness": [0...256]
-                            "color_temp": [250...454]
-                            "transition": [0...] seconds
-                            "brightness_move": [-X...0...X] X/s
-                            "brightness_step": [-X...0...X]
-                            "color_temp_move": [-X...0...X] X/s
-                            "color_temp_step": [-X...0...X]
-                        }
-    """
-    KEY_LINKQUALITY = "linkquality"
-    KEY_OUTPUT_0 = "state"
-    KEY_BRIGHTNESS = "brightness"
-    KEY_COLOR_TEMP = "color_temp"
-    #
-    TX_TYPE = base.TX_DICT
-    TX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
-    STATE_KEYS = TX_FILTER_DATA_KEYS
-    #
-    RX_KEYS = [KEY_LINKQUALITY, KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
-    RX_IGNORE_KEYS = ['update', 'color_mode']
-    RX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
-
-    def __state_logging__(self, inst, key, data):
-        if key in [self.KEY_OUTPUT_0, self.KEY_BRIGHTNESS, self.KEY_COLOR_TEMP]:
-            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:
-            return int(round((data - 1) * 100 / 253, 0))
-        elif key == self.KEY_COLOR_TEMP:
-            return int(round((data - 250) * 10 / 204, 0))
-        return super().__device_to_instance_filter__(key, data)
-
-    def __instance_to_device_filter__(self, key, data):
-        if key == self.KEY_BRIGHTNESS:
-            return int(round(data * 253 / 100 + 1, 0))
-        elif key == self.KEY_COLOR_TEMP:
-            return int(round(data * 204 / 10 + 250, 0))
-        return super().__instance_to_device_filter__(key, data)
-
-    #
-    # RX
-    #
-    @property
-    def output_0(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_0, False)
-
-    @property
-    def linkquality(self):
-        """rv: numeric value"""
-        return self.get(self.KEY_LINKQUALITY, 0)
-
-    @property
-    def brightness(self):
-        """rv: numeric value [0%, ..., 100%]"""
-        return self.get(self.KEY_BRIGHTNESS, 0)
-
-    @property
-    def color_temp(self):
-        """rv: numeric value [0, ..., 10]"""
-        return self.get(self.KEY_COLOR_TEMP, 0)
-
-    #
-    # TX
-    #
-    def request_data(self, device=None, key=None, data=None):
-        self.mqtt_client.send(self.topic + "/set", '{"hue_power_on_behavior": "recover"}')
-
-    def set_output_0(self, state):
-        """state: [True, False]"""
-        self.send_command(self.KEY_OUTPUT_0, state)
-
-    def set_output_0_mcb(self, device, key, data):
-        self.set_output_0(data)
-
-    def toggle_output_0_mcb(self, device, key, data):
-        self.set_output_0(not self.output_0)
-
-    def set_brightness(self, brightness):
-        """brightness: [0, ..., 100]"""
-        self.send_command(self.KEY_BRIGHTNESS, brightness)
-
-    def set_brightness_mcb(self, device, key, data):
-        self.set_brightness(data)
-
-    def set_color_temp(self, color_temp):
-        """color_temp: [0, ..., 10]"""
-        self.send_command(self.KEY_COLOR_TEMP, color_temp)
-
-    def set_color_temp_mcb(self, device, key, data):
-        self.set_color_temp(data)
-
-    def __all_off__(self):
-        if self.output_0:
-            self.set_output_0(False)

devices/mydevices.py

@@ -1,262 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-from devices.base import base, base_output
-import logging
-
-
-class powerplug(base_output):
-    """ Communication (MQTT)
-
-        my_powerplug
-                   +- output
-                           +- 1 [True, False]                   <- status
-                           |  +- set [True, False, "toggle"]    <- command
-                           +- 2 [True, False]                   <- status
-                           |  +- set [True, False, "toggle"]    <- command
-                           +- 3 [True, False]                   <- status
-                           |  +- set [True, False, "toggle"]    <- command
-                           +- 4 [True, False]                   <- status
-                           |  +- set [True, False, "toggle"]    <- command
-                           +- all
-                              +- set [True, False, "toggle"]    <- command
-    """
-    KEY_OUTPUT_0 = "output/1"
-    KEY_OUTPUT_1 = "output/2"
-    KEY_OUTPUT_2 = "output/3"
-    KEY_OUTPUT_3 = "output/4"
-    KEY_OUTPUT_ALL = "output/all"
-    KEY_OUTPUT_LIST = [KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_OUTPUT_2, KEY_OUTPUT_3]
-    #
-    TX_TYPE = base.TX_VALUE
-    #
-    RX_KEYS = [KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_OUTPUT_2, KEY_OUTPUT_3]
-
-    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
-    #
-    @property
-    def output_0(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_0)
-
-    @property
-    def output_1(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_1)
-
-    @property
-    def output_2(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_2)
-
-    @property
-    def output_3(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_3)
-
-    #
-    # TX
-    #
-    def set_output(self, key, state):
-        if key in self.KEY_OUTPUT_LIST:
-            self.send_command(key, state)
-        else:
-            logging.error("Unknown key to set the output!")
-
-    def set_output_0(self, state):
-        """state: [True, False]"""
-        self.send_command(self.KEY_OUTPUT_0, state)
-
-    def set_output_0_mcb(self, device, key, data):
-        self.set_output_0(data)
-
-    def toggle_output_0_mcb(self, device, key, data):
-        self.set_output_0(not self.output_0)
-
-    def set_output_1(self, state):
-        """state: [True, False]"""
-        self.send_command(self.KEY_OUTPUT_1, state)
-
-    def set_output_1_mcb(self, device, key, data):
-        self.set_output_1(data)
-
-    def toggle_output_1_mcb(self, device, key, data):
-        self.set_output_1(not self.output_1)
-
-    def set_output_2(self, state):
-        """state: [True, False]"""
-        self.send_command(self.KEY_OUTPUT_2, state)
-
-    def set_output_2_mcb(self, device, key, data):
-        self.set_output_2(data)
-
-    def toggle_output_2_mcb(self, device, key, data):
-        self.set_output_2(not self.output_2)
-
-    def set_output_3(self, state):
-        """state: [True, False]"""
-        self.send_command(self.KEY_OUTPUT_3, state)
-
-    def set_output_3_mcb(self, device, key, data):
-        self.set_output_3(data)
-
-    def toggle_output_3_mcb(self, device, key, data):
-        self.set_output_3(not self.output_3)
-
-    def set_output_all(self, state):
-        """state: [True, False, 'toggle']"""
-        self.send_command(self.KEY_OUTPUT_ALL, state)
-
-    def set_output_all_mcb(self, device, key, data):
-        self.set_output_all(data)
-
-    def __all_off__(self):
-        self.set_output_all(False)
-
-
-class remote(base):
-    """ Communication (MQTT)
-
-        remote (RAS5)                               <- command
-             +- CD [dc]
-             +- LINE1 [dc]
-             +- LINE2 [dc]
-             +- LINE3 [dc]
-             +- MUTE [dc]
-             +- POWER [dc]
-             +- VOLDOWN [dc]
-             +- VOLUP [dc]
-             +- PHONO [dc]
-             +- DOCK [dc]
-
-        remote (EUR642100)                          <- command
-             +- OPEN_CLOSE [dc]
-             +- VOLDOWN [dc]
-             +- VOLUP [dc]
-             +- ONE [dc]
-             +- TWO [dc]
-             +- THREE [dc]
-             +- FOUR [dc]
-             +- FIVE [dc]
-             +- SIX [dc]
-             +- SEVEN [dc]
-             +- EIGHT [dc]
-             +- NINE [dc]
-             +- ZERO [dc]
-             +- TEN [dc]
-             +- TEN_PLUS [dc]
-             +- PROGRAM [dc]
-             +- CLEAR [dc]
-             +- RECALL [dc]
-             +- TIME_MODE [dc]
-             +- A_B_REPEAT [dc]
-             +- REPEAT [dc]
-             +- RANDOM [dc]
-             +- AUTO_CUE [dc]
-             +- TAPE_LENGTH [dc]
-             +- SIDE_A_B [dc]
-             +- TIME_FADE [dc]
-             +- PEAK_SEARCH [dc]
-             +- SEARCH_BACK [dc]
-             +- SEARCH_FOR [dc]
-             +- TRACK_NEXT [dc]
-             +- TRACK_PREV [dc]
-             +- STOP [dc]
-             +- PAUSE [dc]
-             +- PLAY [dc]
-    """
-    KEY_CD = "CD"
-    KEY_LINE1 = "LINE1"
-    KEY_LINE2 = "LINE2"
-    KEY_LINE3 = "LINE3"
-    KEY_PHONO = "PHONO"
-    KEY_MUTE = "MUTE"
-    KEY_POWER = "POWER"
-    KEY_VOLDOWN = "VOLDOWN"
-    KEY_VOLUP = "VOLUP"
-    #
-    TX_TOPIC = ''
-    TX_TYPE = base.TX_VALUE
-    #
-    RX_IGNORE_TOPICS = [KEY_CD, KEY_LINE1, KEY_LINE2, KEY_LINE3, KEY_PHONO, 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_line2(self, device=None, key=None, data=None):
-        self.logger.info("Changing amplifier source to LINE2")
-        self.send_command(self.KEY_LINE2, 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_phono(self, device=None, key=None, data=None):
-        self.logger.info("Changing amplifier source to PHONO")
-        self.send_command(self.KEY_PHONO, 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):
-        self.set_volume_up(True)
-
-    def default_dec(self, device=None, key=None, data=None):
-        self.set_volume_down(True)
-
-    def default_stop(self, device=None, key=None, data=None):
-        self.set_volume_up(False)
-
-
-class audio_status(base):
-    """ Communication (MQTT)
-
-        audio_status
-            +- state [True, False]                  <- status
-            +- title [text]                         <- status
-    """
-    KEY_STATE = "state"
-    KEY_TITLE = "title"
-    #
-    TX_TYPE = base.TX_VALUE
-    #
-    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.set_state(data)

devices/shelly.py

@@ -1,238 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-from devices.base import base_output
-from devices.base import base_rpc
-import task
-
-
-class shelly(base_output):
-    """ Communication (MQTT)
-
-        shelly
-            +- relay
-            |      +- 0 ["on" / "off"]              <- status 
-            |      |  +- command ["on"/ "off"]      <- command
-            |      |  +- energy [numeric]           <- status
-            |      +- 1 ["on" / "off"]              <- status
-            |         +- command ["on"/ "off"]      <- command
-            |         +- energy [numeric]           <- status
-            +- input
-            |      +- 0 [0 / 1]                     <- status
-            |      +- 1 [0 / 1]                     <- status
-            +- input_event
-            |      +- 0                             <- status
-            |      +- 1                             <- status
-            +- logpush
-            |      +- 0 [0 / 1]                     <- status
-            |      +- 1 [0 / 1]                     <- status
-            +- temperature [numeric] °C             <- status
-            +- temperature_f [numeric] F            <- status
-            +- overtemperature [0 / 1]              <- status
-            +- id                                   <- status
-            +- model                                <- status
-            +- mac                                  <- status
-            +- ip                                   <- status
-            +- new_fw                               <- status
-            +- fw_ver                               <- status
-    """
-    KEY_OUTPUT_0 = "relay/0"
-    KEY_OUTPUT_1 = "relay/1"
-    KEY_INPUT_0 = "input/0"
-    KEY_INPUT_1 = "input/1"
-    KEY_LONGPUSH_0 = "longpush/0"
-    KEY_LONGPUSH_1 = "longpush/1"
-    KEY_TEMPERATURE = "temperature"
-    KEY_OVERTEMPERATURE = "overtemperature"
-    KEY_ID = "id"
-    KEY_MODEL = "model"
-    KEY_MAC = "mac"
-    KEY_IP = "ip"
-    KEY_NEW_FIRMWARE = "new_fw"
-    KEY_FIRMWARE_VERSION = "fw_ver"
-    #
-    TX_TOPIC = "command"
-    TX_TYPE = base_output.TX_VALUE
-    TX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_OUTPUT_1]
-    #
-    RX_KEYS = [KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_INPUT_0, KEY_INPUT_1, KEY_LONGPUSH_0, KEY_LONGPUSH_1, KEY_OVERTEMPERATURE, KEY_TEMPERATURE,
-               KEY_ID, KEY_MODEL, KEY_MAC, KEY_IP, KEY_NEW_FIRMWARE, KEY_FIRMWARE_VERSION]
-    RX_IGNORE_TOPICS = [KEY_OUTPUT_0 + '/' + "energy", KEY_OUTPUT_1 + '/' + "energy", 'input_event/0', 'input_event/1']
-    RX_IGNORE_KEYS = ['temperature_f']
-    RX_FILTER_DATA_KEYS = [KEY_INPUT_0, KEY_INPUT_1, KEY_LONGPUSH_0, KEY_LONGPUSH_1, KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_OVERTEMPERATURE]
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-        #
-        self.output_key_delayed = None
-        self.delayed_flash_task = task.delayed(0.75, self.flash_task)
-        self.delayed_off_task = task.delayed(0.75, self.off_task)
-        #
-        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.output_key_delayed = None
-            if self.all_off_requested:
-                self.delayed_off_task.run()
-
-    def off_task(self, *args):
-        self.all_off()
-
-    @property
-    def flash_active(self):
-        return self.output_key_delayed is not None
-
-    #
-    # RX
-    #
-    @property
-    def output_0(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_0)
-
-    @property
-    def output_1(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_1)
-
-    @property
-    def input_0(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_INPUT_0)
-
-    @property
-    def input_1(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_INPUT_1)
-
-    @property
-    def longpush_0(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_LONGPUSH_0)
-
-    @property
-    def longpush_1(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_LONGPUSH_1)
-
-    @property
-    def temperature(self):
-        """rv: numeric value"""
-        return self.get(self.KEY_TEMPERATURE)
-
-    #
-    # TX
-    #
-    def set_output_0(self, state):
-        """state: [True, False]"""
-        self.send_command(self.KEY_OUTPUT_0, state)
-
-    def set_output_0_mcb(self, device, key, data):
-        self.set_output_0(data)
-
-    def toggle_output_0_mcb(self, device, key, data):
-        self.set_output_0(not self.output_0)
-
-    def set_output_1(self, state):
-        """state: [True, False]"""
-        self.send_command(self.KEY_OUTPUT_1, state)
-
-    def set_output_1_mcb(self, device, key, data):
-        self.set_output_1(data)
-
-    def toggle_output_1_mcb(self, device, key, data):
-        self.set_output_1(not self.output_1)
-
-    def flash_0_mcb(self, device, key, data):
-        self.output_key_delayed = self.KEY_OUTPUT_0
-        self.toggle_output_0_mcb(device, key, data)
-        self.delayed_flash_task.run()
-
-    def flash_1_mcb(self, device, key, data):
-        self.output_key_delayed = self.KEY_OUTPUT_1
-        self.toggle_output_1_mcb(device, key, data)
-        self.delayed_flash_task.run()
-
-    def __all_off__(self):
-        if self.flash_active:
-            self.all_off_requested = True
-        else:
-            if self.output_0:
-                self.set_output_0(False)
-            if self.output_1:
-                self.set_output_1(False)
-
-
-class shelly_rpc(base_rpc):
-    KEY_OUTPUT_0 = "switch:0"
-    KEY_OUTPUT_1 = "switch:1"
-    KEY_OUTPUT_2 = "switch:2"
-    KEY_INPUT_0 = "input:0"
-    KEY_INPUT_1 = "input:1"
-    KEY_INPUT_2 = "input:2"
-    KEY_LONGPUSH_0 = "input:0:long_push"
-    KEY_LONGPUSH_1 = "input:1:long_push"
-    KEY_LONGPUSH_2 = "input:2:long_push"
-    KEY_SINGLEPUSH_0 = "input:0:single_push"
-    KEY_SINGLEPUSH_1 = "input:1:single_push"
-    KEY_SINGLEPUSH_2 = "input:2:single_push"
-    KEY_DOUBLEPUSH_0 = "input:0:double_push"
-    KEY_DOUBLEPUSH_1 = "input:1:double_push"
-    KEY_DOUBLEPUSH_2 = "input:2:double_push"
-    KEY_TRIPLEPUSH_0 = "input:0:triple_push"
-    KEY_TRIPLEPUSH_1 = "input:1:triple_push"
-    KEY_TRIPLEPUSH_2 = "input:2:triple_push"
-
-    RX_KEYS = [KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_OUTPUT_2, KEY_INPUT_0, KEY_INPUT_1, KEY_INPUT_2,
-               KEY_LONGPUSH_0, KEY_LONGPUSH_1, KEY_LONGPUSH_2, KEY_SINGLEPUSH_0, KEY_SINGLEPUSH_1, KEY_SINGLEPUSH_2,
-               KEY_DOUBLEPUSH_0, KEY_DOUBLEPUSH_1, KEY_DOUBLEPUSH_2, KEY_TRIPLEPUSH_0, KEY_TRIPLEPUSH_1, KEY_TRIPLEPUSH_2]
-
-    def __state_logging__(self, inst, key, data):
-        if key in [self.KEY_OUTPUT_0, self.KEY_OUTPUT_1, self.KEY_OUTPUT_2]:
-            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_INPUT_2]:
-            self.logger.info("Input action '%s' with '%s'", key, repr(data))
-        elif key in [self.KEY_LONGPUSH_0, self.KEY_LONGPUSH_1, self.KEY_LONGPUSH_2,
-                     self.KEY_SINGLEPUSH_0, self.KEY_SINGLEPUSH_1, self.KEY_SINGLEPUSH_2,
-                     self.KEY_DOUBLEPUSH_0, self.KEY_DOUBLEPUSH_1, self.KEY_DOUBLEPUSH_2,
-                     self.KEY_TRIPLEPUSH_0, self.KEY_TRIPLEPUSH_1, self.KEY_TRIPLEPUSH_2]:
-            self.logger.info("Input action '%s'", key)
-
-    def set_output_0(self, state):
-        """state: [True, False]"""
-        self.rpc_switch_set(self.KEY_OUTPUT_0, state)
-
-    def set_output_0_mcb(self, device, key, data):
-        self.set_output_0(data)
-
-    def toggle_output_0_mcb(self, device, key, data):
-        self.set_output_0(not self.get(self.KEY_OUTPUT_0))
-
-    def set_output_1(self, state):
-        """state: [True, False]"""
-        self.rpc_switch_set(self.KEY_OUTPUT_1, state)
-
-    def set_output_1_mcb(self, device, key, data):
-        self.set_output_1(data)
-
-    def toggle_output_1_mcb(self, device, key, data):
-        print(self.get(self.KEY_OUTPUT_1))
-        self.set_output_1(not self.get(self.KEY_OUTPUT_1))
-
-    def set_output_2(self, state):
-        """state: [True, False]"""
-        self.rpc_switch_set(self.KEY_OUTPUT_2, state)
-
-    def set_output_2_mcb(self, device, key, data):
-        self.set_output_2(data)
-
-    def toggle_output_2_mcb(self, device, key, data):
-        self.set_output_2(not self.get(self.KEY_OUTPUT_2))

devices/silvercrest.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-from devices.base import base, base_output
-import logging
-
-
-class silvercrest_button(base):
-    """ Communication (MQTT)
-
-        tradfri_button {
-                            "action": ["pressed"]
-                            "battery": [0...100] %
-                            "battery_low": [true | false]
-                            "tamper": [true | false]
-                            "linkquality": [0...255] lqi
-                            "update": []
-                       }
-    """
-    ACTION_PRESSED = "pressed"
-    #
-    KEY_LINKQUALITY = "linkquality"
-    KEY_BATTERY = "battery"
-    KEY_BATTERY_LOW = "battery_low"
-    KEY_TAMPER = "tamper"
-    KEY_ACTION = "action"
-    #
-    RX_KEYS = [KEY_LINKQUALITY, KEY_BATTERY, KEY_ACTION, KEY_BATTERY_LOW, KEY_TAMPER]
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-
-    def __state_logging__(self, inst, key, data):
-        if key == self.KEY_ACTION:
-            self.logger.info("Input '%s' with '%s'", key, repr(data))
-            self[self.KEY_ACTION] = None
-        elif key in [self.KEY_BATTERY_LOW, self.KEY_TAMPER]:
-            self.logger.info("Input '%s' with '%s'", key, repr(data))
-
-    #
-    # RX
-    #
-    @property
-    def action(self):
-        """rv: action_txt"""
-        return self.get(self.KEY_ACTION)
-
-
-class silvercrest_powerplug(base_output):
-    """ Communication (MQTT)
-
-        silvercrest_powerplug {
-                            |      "state": ["ON" / "OFF"]
-                            |      "linkquality": [0...255] lqi
-                            | }
-                            +- get {
-                            |           "state": ""
-                            |      }
-                            +- set {
-                                        "state": ["ON" / "OFF"]
-                                   }
-    """
-    KEY_LINKQUALITY = "linkquality"
-    KEY_OUTPUT_0 = "state"
-    #
-    TX_TYPE = base.TX_DICT
-    TX_FILTER_DATA_KEYS = [KEY_OUTPUT_0]
-    #
-    RX_KEYS = [KEY_LINKQUALITY, KEY_OUTPUT_0]
-    RX_FILTER_DATA_KEYS = [KEY_OUTPUT_0]
-
-    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
-    #
-    @property
-    def output_0(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_0)
-
-    @property
-    def linkquality(self):
-        """rv: numeric value"""
-        return self.get(self.KEY_LINKQUALITY)
-
-    #
-    # TX
-    #
-    def set_output_0(self, state):
-        """state: [True, False]"""
-        self.send_command(self.KEY_OUTPUT_0, state)
-
-    def set_output_0_mcb(self, device, key, data):
-        self.set_output_0(data)
-
-    def toggle_output_0_mcb(self, device, key, data):
-        self.set_output_0(not self.output_0)
-
-    def __all_off__(self):
-        if self.output_0:
-            self.set_output_0(False)
-
-
-class silvercrest_motion_sensor(base):
-    """ Communication (MQTT)
-
-        silvercrest_motion_sensor {
-                                      battery: [0...100] %
-                                      battery_low: [True, False]
-                                      linkquality: [0...255] lqi
-                                      occupancy: [True, False]
-                                      tamper: [True, False]
-                                      voltage: [0...] mV
-                                  }
-    """
-    KEY_BATTERY = "battery"
-    KEY_BATTERY_LOW = "battery_low"
-    KEY_LINKQUALITY = "linkquality"
-    KEY_OCCUPANCY = "occupancy"
-    KEY_UNMOUNTED = "tamper"
-    KEY_VOLTAGE = "voltage"
-    #
-    TX_TYPE = base.TX_DICT
-    #
-    RX_KEYS = [KEY_BATTERY, KEY_BATTERY_LOW, KEY_LINKQUALITY, KEY_OCCUPANCY, KEY_UNMOUNTED, KEY_VOLTAGE]
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-
-    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))
-
-    #
-    # RX
-    #
-    @property
-    def linkquality(self):
-        """rv: numeric value"""
-        return self.get(self.KEY_LINKQUALITY)
-
-    @property
-    def battery(self):
-        """rv: numeric value"""
-        return self.get(self.KEY_BATTERY)

devices/tradfri.py

@@ -1,192 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-from devices.base import base, base_output
-import logging
-
-
-class tradfri_light(base_output):
-    """ Communication (MQTT)
-
-        tradfri_light {
-                    |      "state": ["ON" / "OFF" / "TOGGLE"]
-                    |      "linkquality": [0...255] lqi
-                    |      "brightness": [0...254]
-                    |      "color_mode": ["color_temp"]
-                    |      "color_temp": ["coolest", "cool", "neutral", "warm", "warmest", 250...454]
-                    |      "color_temp_startup": ["coolest", "cool", "neutral", "warm", "warmest", "previous", 250...454]
-                    |      "update": []
-                    | }
-                    +- get {
-                    |           "state": ""
-                    |      }
-                    +- set {
-                                "state": ["ON" / "OFF"]
-                                "brightness": [0...256]
-                                "color_temp": [250...454]
-                                "transition": [0...] seconds
-                                "brightness_move": [-X...0...X] X/s
-                                "brightness_step": [-X...0...X]
-                                "color_temp_move": [-X...0...X] X/s
-                                "color_temp_step": [-X...0...X]
-                            }
-    """
-    KEY_LINKQUALITY = "linkquality"
-    KEY_OUTPUT_0 = "state"
-    KEY_BRIGHTNESS = "brightness"
-    KEY_COLOR_TEMP = "color_temp"
-    KEY_BRIGHTNESS_FADE = "brightness_move"
-    #
-    TX_TYPE = base.TX_DICT
-    TX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP, KEY_BRIGHTNESS_FADE]
-    #
-    RX_KEYS = [KEY_LINKQUALITY, KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
-    RX_IGNORE_KEYS = ['update', 'color_mode', 'color_temp_startup']
-    RX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
-
-    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:
-            return int(round((data - 1) * 100 / 253, 0))
-        elif key == self.KEY_COLOR_TEMP:
-            return int(round((data - 250) * 10 / 204, 0))
-        return super().__device_to_instance_filter__(key, data)
-
-    def __instance_to_device_filter__(self, key, data):
-        if key == self.KEY_BRIGHTNESS:
-            return int(round(data * 253 / 100 + 1, 0))
-        elif key == self.KEY_COLOR_TEMP:
-            return int(round(data * 204 / 10 + 250, 0))
-        return super().__instance_to_device_filter__(key, data)
-
-    #
-    # RX
-    #
-    @property
-    def output_0(self):
-        """rv: [True, False]"""
-        return self.get(self.KEY_OUTPUT_0, False)
-
-    @property
-    def linkquality(self):
-        """rv: numeric value"""
-        return self.get(self.KEY_LINKQUALITY, 0)
-
-    @property
-    def brightness(self):
-        """rv: numeric value [0%, ..., 100%]"""
-        return self.get(self.KEY_BRIGHTNESS, 0)
-
-    @property
-    def color_temp(self):
-        """rv: numeric value [0, ..., 10]"""
-        return self.get(self.KEY_COLOR_TEMP, 0)
-
-    #
-    # TX
-    #
-    def request_data(self, device=None, key=None, data=None):
-        self.mqtt_client.send(self.topic + "/get", '{"%s": ""}' % self.KEY_OUTPUT_0)
-
-    def set_output_0(self, state):
-        """state: [True, False]"""
-        self.send_command(self.KEY_OUTPUT_0, state)
-
-    def set_output_0_mcb(self, device, key, data):
-        self.set_output_0(data)
-
-    def toggle_output_0_mcb(self, device, key, data):
-        self.set_output_0(not self.output_0)
-
-    def set_brightness(self, brightness):
-        """brightness: [0, ..., 100]"""
-        self.send_command(self.KEY_BRIGHTNESS, brightness)
-
-    def set_brightness_mcb(self, device, key, data):
-        self.set_brightness(data)
-
-    def default_inc(self, speed=40):
-        self.send_command(self.KEY_BRIGHTNESS_FADE, speed)
-
-    def default_dec(self, speed=-40):
-        self.default_inc(speed)
-
-    def default_stop(self):
-        self.default_inc(0)
-
-    def set_color_temp(self, color_temp):
-        """color_temp: [0, ..., 10]"""
-        self.send_command(self.KEY_COLOR_TEMP, color_temp)
-
-    def set_color_temp_mcb(self, device, key, data):
-        self.set_color_temp(data)
-
-    def __all_off__(self):
-        if self.output_0:
-            self.set_output_0(False)
-
-
-class tradfri_button(base):
-    """ Communication (MQTT)
-
-        tradfri_button {
-                            "action": [
-                                           "arrow_left_click",
-                                           "arrow_left_hold",
-                                           "arrow_left_release",
-                                           "arrow_right_click",
-                                           "arrow_right_hold",
-                                           "arrow_right_release",
-                                           "brightness_down_click",
-                                           "brightness_down_hold",
-                                           "brightness_down_release",
-                                           "brightness_up_click",
-                                           "brightness_up_hold",
-                                           "brightness_up_release",
-                                           "toggle"
-                                      ]
-                            "action_duration": [0...] s
-                            "battery": [0...100] %
-                            "linkquality": [0...255] lqi
-                            "update": []
-                       }
-    """
-    ACTION_TOGGLE = "toggle"
-    ACTION_BRIGHTNESS_UP = "brightness_up_click"
-    ACTION_BRIGHTNESS_DOWN = "brightness_down_click"
-    ACTION_RIGHT = "arrow_right_click"
-    ACTION_LEFT = "arrow_left_click"
-    ACTION_BRIGHTNESS_UP_LONG = "brightness_up_hold"
-    ACTION_BRIGHTNESS_UP_RELEASE = "brightness_up_release"
-    ACTION_BRIGHTNESS_DOWN_LONG = "brightness_down_hold"
-    ACTION_BRIGHTNESS_DOWN_RELEASE = "brightness_down_release"
-    ACTION_RIGHT_LONG = "arrow_right_hold"
-    ACTION_RIGHT_RELEASE = "arrow_right_release"
-    ACTION_LEFT_LONG = "arrow_left_hold"
-    ACTION_LEFT_RELEASE = "arrow_left_release"
-    #
-    KEY_LINKQUALITY = "linkquality"
-    KEY_BATTERY = "battery"
-    KEY_ACTION = "action"
-    KEY_ACTION_DURATION = "action_duration"
-    #
-    RX_KEYS = [KEY_LINKQUALITY, KEY_BATTERY, KEY_ACTION]
-    RX_IGNORE_KEYS = ['update', KEY_ACTION_DURATION]
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-
-    def __state_logging__(self, inst, key, data):
-        if key in [self.KEY_ACTION]:
-            self.logger.info("Input '%s' with '%s'", key, repr(data))
-
-    #
-    # RX
-    #
-    @property
-    def action(self):
-        """rv: action_txt"""
-        return self.get(self.KEY_ACTION)

function/__init__.py

@@ -2,15 +2,14 @@
 # -*- coding: utf-8 -*-
 #
 import config
+from devdi import rooms as devdi_rooms
 from devdi.topic import STOP_EXECUTION_TOPIC
-import devices
 from function.garden import garden
 from function.stairway import stairway
 from function.ground_floor_west import ground_floor_west
 from function.first_floor_west import first_floor_west
 from function.first_floor_east import first_floor_east
 from function.rooms import room_collection
-from function.videv import all_off, videv_pure_switch
 import json
 import logging
 import mqtt
@@ -22,9 +21,10 @@ except ImportError:
 logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
 
 
-class all_functions(room_collection):
+class all_functions(room_collection, devdi_rooms.collection):
     def __init__(self, mqtt_client: mqtt.mqtt_client):
         super().__init__(mqtt_client)
+        devdi_rooms.collection.__init__(self, mqtt_client)
         #
         self.run = True
         if config.DEBUG:
@@ -72,7 +72,7 @@ class all_functions(room_collection):
 
     def init_off_functionality(self):
         # ALL OFF - Virtual device
-        self.videv_all_off = all_off(self.mqtt_client, config.TOPIC_ALL_OFF_VIDEV, self)
+        self.videv_all_off.connect_room_collection(self)
 
         # ALL OFF - Long push stairway
         self.stw.stairway.switch_main_light.add_callback(self.stw.stairway.switch_main_light.KEY_LONGPUSH_0,
@@ -85,7 +85,8 @@ class all_functions(room_collection):
         self.ffe.floor.switch_main_light.add_callback(self.ffe.floor.switch_main_light.KEY_LONGPUSH_0, True, self.ffe.all_off)
 
         # FFE ALL OFF - Long push input device
-        self.ffe.sleep.input_device.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_RIGHT_LONG, self.ffe.all_off)
+        self.ffe.sleep.input_device.add_callback(self.ffe.sleep.input_device.KEY_ACTION,
+                                                 self.ffe.sleep.input_device.ACTION_RIGHT_LONG, self.ffe.all_off)
 
         # FFW ALL OFF - Long push ffw_floor
         self.ffw.floor.switch_main_light.add_callback(self.ffw.floor.switch_main_light.KEY_LONGPUSH_0,
@@ -93,9 +94,6 @@ class all_functions(room_collection):
         self.ffw.floor.switch_main_light.add_callback(self.ffw.floor.switch_main_light.KEY_LONGPUSH_0, True, self.ffw.all_off)
 
     def init_sumer_winter_mode(self):
-        # ALL summer/winter mode
-        self.videv_summer_mode = videv_pure_switch(self.mqtt_client, config.TOPIC_ALL_SUMMER_WINTER_MODE)
-
         self.videv_summer_mode.add_callback(self.videv_summer_mode.KEY_STATE, None, self.gfw.summer_mode)
         self.videv_summer_mode.add_callback(self.videv_summer_mode.KEY_STATE, None, self.ffw.summer_mode)
         self.videv_summer_mode.add_callback(self.videv_summer_mode.KEY_STATE, None, self.ffe.summer_mode)

function/helpers.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-from base import common_base
+from mqtt.smarthome import common_base
 import config
 import geo
 import task

function/modules.py

@@ -11,8 +11,7 @@ Targets:
     - Method .add_calback(key, data, callback, on_change_only=False) to register videv actualisation on changes
 """
 
-from base import common_base
-import config
+from mqtt.smarthome import common_base
 import devices
 from function.helpers import day_state
 import logging

function/rooms.py

@@ -13,6 +13,8 @@ logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
 
 
 class room(object):
+    ADD_TO_VIDEV_ALL_OFF = None
+
     def __init__(self, mqtt_client):
         self.mqtt_client = mqtt_client
 
@@ -20,7 +22,7 @@ class room(object):
         logger.info("Switching all off \"%s\"", type(self).__name__)
         for name, obj in inspect.getmembers(self):
             try:
-                if obj.__module__.startswith('devices'):
+                if obj.__module__.startswith('smart_devices'):
                     obj.all_off()
             except AttributeError:
                 pass    # not a module or has no method all_off
@@ -33,7 +35,7 @@ class room(object):
 
 
 class room_collection(object):
-    ALLOWED_CLASSES = ("room", "room_collection")
+    ADD_TO_VIDEV_ALL_OFF = None
 
     def __init__(self, mqtt_client):
         self.mqtt_client = mqtt_client
@@ -49,6 +51,8 @@ class room_collection(object):
                     sub.all_off()
                 except AttributeError:
                     pass    # don't mind, if sub has no method all_off
+                except:
+                    logger.error("Failed to switch off %s (%s)", repr(sub_name), type(sub).__name__)
 
     def summer_mode(self, device=None, key=None, data=None):
         logger.info("Changing to %s \"%s\"", "summer mode" if data else "winter_mode", type(self).__name__)
@@ -56,7 +60,7 @@ class room_collection(object):
             # attribute name is not private
             if not sub_name.startswith("__"):
                 sub = getattr(self, sub_name)
-                if sub.__class__.__bases__[0].__name__ in self.ALLOWED_CLASSES:
+                if isinstance(sub, (room, room_collection)):
                     sub.summer_mode(data)
 
     def all_devices(self, object_to_analyse=None, depth=0):

function/videv.py

@@ -1,193 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-"""
-Virtual Device(s)
-
-Targets:
-  * MQTT-Interface to control joined devices as one virtual device
-  * Primary signal routing
-  * No functionality should be implemented here
-"""
-
-from base import videv_base
-from function.rooms import room, room_collection
-
-
-class videv_pure_switch(videv_base):
-    KEY_STATE = 'state'
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-        self[self.KEY_STATE] = False
-        #
-        self.mqtt_client.add_callback(self.topic + '/state/set', self.__state__)
-
-    def __state__(self, mqtt_client, userdata, message):
-        self.set(self.KEY_STATE, message.payload == b'true')
-        self.__tx__(self.KEY_STATE, message.payload == b'true')
-
-
-class videv_switching(videv_base):
-    KEY_STATE = 'state'
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-
-    def connect_sw_device(self, sw_device, sw_key):
-        self.add_routing(self.KEY_STATE, sw_device, sw_key)
-
-
-class videv_switching_timer(videv_switching):
-    KEY_TIMER = 'timer'
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-
-    def connect_tm_device(self, tm_device, tm_key):
-        self.add_display(self.KEY_TIMER, tm_device, tm_key)
-
-
-class videv_switching_motion(videv_switching):
-    KEY_STATE = 'state'
-    #
-    KEY_TIMER = 'timer'
-    KEY_MOTION_SENSOR = 'motion_%d'
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-
-    def connect_mo_function(self, mo_function):
-        self.add_display(self.KEY_TIMER, mo_function, mo_function.KEY_TIMER)
-        # motion sensor state
-        for index, motion_sensor in enumerate(mo_function.motion_sensors):
-            self.add_display(self.KEY_MOTION_SENSOR % index, motion_sensor, motion_sensor.KEY_OCCUPANCY)
-
-
-class videv_switch_brightness(videv_switching):
-    KEY_BRIGHTNESS = 'brightness'
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-
-    def connect_br_device(self, br_device, br_key):
-        self.add_routing(self.KEY_BRIGHTNESS, br_device, br_key)
-
-
-class videv_switch_brightness_color_temp(videv_switch_brightness):
-    KEY_COLOR_TEMP = 'color_temp'
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-
-    def connect_ct_device(self, ct_device, ct_key):
-        self.add_routing(self.KEY_COLOR_TEMP, ct_device, ct_key)
-
-
-class videv_heating(videv_base):
-    KEY_USER_TEMPERATURE_SETPOINT = 'user_temperature_setpoint'
-    KEY_VALVE_TEMPERATURE_SETPOINT = 'valve_temperature_setpoint'
-    KEY_AWAY_MODE = 'away_mode'
-    KEY_SUMMER_MODE = 'summer_mode'
-    KEY_START_BOOST = 'start_boost'
-    KEY_SET_DEFAULT_TEMPERATURE = 'set_default_temperature'
-    KEY_BOOST_TIMER = 'boost_timer'
-    #
-    KEY_TEMPERATURE = 'temperature'
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-
-    def connect_heating_function(self, heating_function):
-        #
-        self.add_routing(self.KEY_USER_TEMPERATURE_SETPOINT, heating_function, heating_function.KEY_USER_TEMPERATURE_SETPOINT)
-        self.add_routing(self.KEY_AWAY_MODE, heating_function, heating_function.KEY_AWAY_MODE)
-        self.add_routing(self.KEY_SUMMER_MODE, heating_function, heating_function.KEY_SUMMER_MODE)
-        #
-        self.add_control(self.KEY_START_BOOST, heating_function, heating_function.KEY_START_BOOST, False)
-        self.add_control(self.KEY_SET_DEFAULT_TEMPERATURE, heating_function, heating_function.KEY_SET_DEFAULT_TEMPERATURE, False)
-        #
-        self.add_display(self.KEY_VALVE_TEMPERATURE_SETPOINT, heating_function, heating_function.KEY_TEMPERATURE_SETPOINT)
-        self.add_display(self.KEY_BOOST_TIMER, heating_function, heating_function.KEY_BOOST_TIMER)
-        self.add_display(self.KEY_TEMPERATURE, heating_function, heating_function.KEY_TEMPERATURE_CURRENT, False)
-
-
-class videv_multistate(videv_base):
-    KEY_STATE = 'state_%d'
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-
-    def connect_br_function(self, device, key_for_device, num_states):
-        self.num_states = num_states
-        # send default values
-        for i in range(0, num_states):
-            self.__tx__(self.KEY_STATE % i, False)
-        #
-        device.add_callback(key_for_device, None, self.__index_rx__, True)
-
-    def __index_rx__(self, device, key, data):
-        for i in range(0, self.num_states):
-            self.__tx__(self.KEY_STATE % i, i == data)
-
-
-class videv_audio_player(videv_base):
-    KEY_ACTIVE_PLAYER = 'player_%d'
-    KEY_TITLE = 'title'
-    NO_TITLE = '---'
-
-    def __init__(self, mqtt_client, topic):
-        super().__init__(mqtt_client, topic)
-        self.__device_cnt__ = 0
-
-    def connect_audio_device(self, device):
-        self.add_display(self.KEY_ACTIVE_PLAYER % self.__device_cnt__, device, device.KEY_STATE)
-        device.add_callback(device.KEY_TITLE, None, self.__title_rx__, True)
-        self.__device_cnt__ += 1
-
-    def __title_rx__(self, device, key, data):
-        self.__tx__(self.KEY_TITLE, data or self.NO_TITLE)
-
-
-class all_off(videv_base):
-    ALLOWED_CLASSES = (room, room_collection, )
-
-    def __init__(self, mqtt_client, topic, room_collection):
-        super().__init__(mqtt_client, topic)
-        self.__room_collection__ = room_collection
-        # init __inst_dict__
-        self.__inst_dict__ = {}
-        self.__add_instances__("all", self.__room_collection__)
-        # register mqtt callbacks for all my keys
-        for key in self.__inst_dict__:
-            mqtt_client.add_callback(topic + "/" + key, self.all_off)
-
-    def __check_inst_capabilities__(self, name, inst):
-        # fits to specified classes
-        if isinstance(inst, self.ALLOWED_CLASSES):
-            try:
-                # all_off method is callable
-                return callable(inst.all_off)
-            except AttributeError:
-                # all_off method does not exist
-                return False
-        return False
-
-    def __add_instances__(self, name, inst, level=0):
-        if self.__check_inst_capabilities__(name, inst):
-            # add given instance to my __inst_dict__
-            self.__inst_dict__[name] = inst
-            # iterate over all attribute names of instance
-            for sub_name in dir(inst):
-                # attribute name is not private
-                if not sub_name.startswith("__"):
-                    sub = getattr(inst, sub_name)
-                    # recurse with this object
-                    if level == 0:
-                        self.__add_instances__(sub_name, sub, level=level+1)
-                    else:
-                        self.__add_instances__(name + "/" + sub_name, sub, level=level+1)
-
-    def all_off(self, client, userdata, message):
-        key = message.topic[len(self.topic) + 1:]
-        self.__inst_dict__[key].all_off()

mqtt

@@ -1 +1 @@
-Subproject commit 95dda53a55b40591bbd5200ae5ea8c354610b913
+Subproject commit c2b32852127bc1a3aca078a2dad3993f46cb81c2

smart_brain.py

@@ -11,7 +11,7 @@ logger = report.default_logging_config()
 
 
 VERS_MAJOR = 1
-VERS_MINOR = 3
+VERS_MINOR = 4
 VERS_PATCH = 2
 
 INFO_TOPIC = "__info__"

smart_devices

@@ -0,0 +1 @@
+Subproject commit c75c0cfacd48e9d51817f128539f96487cef2f98

topics.py

@@ -1,5 +0,0 @@
-#
-# TOPICS
-#
-TOPIC_ALL_OFF_VIDEV = "videv/off"
-TOPIC_ALL_SUMMER_WINTER_MODE = "videv/summer_mode"