Use create device: siemens sentron, sma sunny boy, kits, enphase&sunny island

packages/modules/devices/openwb/openwb_bat_kit/config.py

@@ -7,7 +7,7 @@ def __init__(self):
         pass
 
 
-class BatKit:
+class BatKitSetup:
     def __init__(self,
                  name: str = "openWB Speicher-Kit",
                  type: str = "openwb_bat_kit",

packages/modules/devices/openwb/openwb_bat_kit/device.py

@@ -1,85 +1,37 @@
 import logging
-from typing import Dict, Optional, List, Union
+from typing import Iterable
 
-from dataclass_utils import dataclass_from_dict
-from helpermodules.cli import run_using_positional_cli_args
 from modules.common import modbus
 from modules.common.component_context import SingleComponentUpdateContext
-from modules.common.abstract_device import AbstractDevice, DeviceDescriptor
-from modules.devices.openwb.openwb_bat_kit import bat
-from modules.devices.openwb.openwb_bat_kit.config import BatKit, BatKitBatSetup
+from modules.common.abstract_device import DeviceDescriptor
+from modules.common.configurable_device import ComponentFactoryByType, ConfigurableDevice, MultiComponentUpdater
+from modules.devices.openwb.openwb_bat_kit.config import BatKitSetup, BatKitBatSetup
+from modules.devices.openwb.openwb_bat_kit.bat import BatKit
 
 log = logging.getLogger(__name__)
 
 
-class Device(AbstractDevice):
-    def __init__(self, device_config: Union[Dict, BatKit]) -> None:
-        self.device_config = dataclass_from_dict(BatKit, device_config)
-        self.components = {}  # type: Dict[str, bat.BatKit]
-        self.client = modbus.ModbusTcpClient_("192.168.193.19", 8899)
+def create_device(device_config: BatKitSetup):
+    def create_bat_component(component_config: BatKitBatSetup):
+        return BatKit(device_config.id, component_config, client)
 
-    def add_component(self, component_config: Union[Dict, BatKitBatSetup]) -> None:
-        if isinstance(component_config, Dict):
-            component_type = component_config["type"]
-        else:
-            component_type = component_config.type
-        component_config = dataclass_from_dict(COMPONENT_TYPE_TO_MODULE[
-            component_type].component_descriptor.configuration_factory, component_config)
-        if component_type == "bat":
-            self.components["component"+str(component_config.id)] = bat.BatKit(
-                self.device_config.id, component_config, self.client)
-        else:
-            raise Exception(
-                "illegal component type " + component_type)
+    def update_components(components: Iterable[BatKit]):
+        with client:
+            for component in components:
+                with SingleComponentUpdateContext(component.fault_state):
+                    component.update()
 
-    def update(self) -> None:
-        log.debug("Start device reading " + str(self.components))
-        if self.components:
-            for component in self.components:
-                # Auch wenn bei einer Komponente ein Fehler auftritt, sollen alle anderen noch ausgelesen werden.
-                with SingleComponentUpdateContext(self.components[component].fault_state):
-                    self.components[component].update()
-        else:
-            log.warning(
-                self.device_config.name +
-                ": Es konnten keine Werte gelesen werden, da noch keine Komponenten konfiguriert wurden."
-            )
+    try:
+        client = modbus.ModbusTcpClient_("192.168.193.19", 8899)
+    except Exception:
+        log.exception("Fehler in create_device")
+    return ConfigurableDevice(
+        device_config=device_config,
+        component_factory=ComponentFactoryByType(
+            bat=create_bat_component,
+        ),
+        component_updater=MultiComponentUpdater(update_components)
+    )
 
 
-COMPONENT_TYPE_TO_MODULE = {
-    "bat": bat
-}
-
-
-def read_legacy(component_type: str, version: int, num: Optional[int] = None, evu_version: Optional[int] = None):
-    """ Ausführung des Moduls als Python-Skript
-    """
-    dev = Device(BatKit())
-
-    component_config = get_component_config(component_type, version, num)
-    dev.add_component(component_config)
-    log.debug('openWB Version: ' + str(version))
-
-    if component_type == "evu_inverter" and evu_version:
-        component_config = get_component_config("counter", evu_version, None)
-        dev.add_component(component_config)
-        log.debug('openWB EVU-Version: ' + str(evu_version))
-
-    dev.update()
-
-
-def get_component_config(component_type: str, version: int, num: Optional[int] = None) -> Dict:
-    if component_type == "bat":
-        component_config = bat.component_descriptor.configuration_factory()
-    else:
-        raise Exception("illegal component type " + component_type)
-    component_config.id = None
-    component_config.configuration.version = version
-    return component_config
-
-
-def main(argv: List[str]):
-    run_using_positional_cli_args(read_legacy, argv)
-
-
-device_descriptor = DeviceDescriptor(configuration_factory=BatKit)
+device_descriptor = DeviceDescriptor(configuration_factory=BatKitSetup)

packages/modules/devices/openwb/openwb_evu_kit/config.py

@@ -7,7 +7,7 @@ def __init__(self):
         pass
 
 
-class EvuKit:
+class EvuKitSetup:
     def __init__(self,
                  name: str = "openWB EVU-Kit",
                  type: str = "openwb_evu_kit",

packages/modules/devices/openwb/openwb_evu_kit/device.py

@@ -1,114 +1,50 @@
 import logging
 import time
-from typing import Dict, Union, Optional, List
+from typing import Iterable, Union
 
-from dataclass_utils import dataclass_from_dict
-from helpermodules.cli import run_using_positional_cli_args
 from modules.common import modbus
-from modules.common.abstract_device import AbstractDevice, DeviceDescriptor
+from modules.common.abstract_device import DeviceDescriptor
 from modules.common.component_context import SingleComponentUpdateContext
+from modules.common.configurable_device import ComponentFactoryByType, ConfigurableDevice, MultiComponentUpdater
 from modules.devices.openwb.openwb_bat_kit.bat import BatKit
-from modules.devices.openwb.openwb_evu_kit import bat
-from modules.devices.openwb.openwb_evu_kit import counter
-from modules.devices.openwb.openwb_evu_kit import inverter
-from modules.devices.openwb.openwb_evu_kit.config import EvuKit, EvuKitBatSetup, EvuKitCounterSetup, EvuKitInverterSetup
+from modules.devices.openwb.openwb_evu_kit.counter import EvuKit
+from modules.devices.openwb.openwb_evu_kit.config import (EvuKitSetup, EvuKitBatSetup, EvuKitCounterSetup,
+                                                          EvuKitInverterSetup)
 from modules.devices.openwb.openwb_pv_kit.inverter import PvKit
 
 log = logging.getLogger(__name__)
 
 
-class Device(AbstractDevice):
-    COMPONENT_TYPE_TO_CLASS = {
-        "bat": BatKit,
-        "counter": counter.EvuKit,
-        "inverter": PvKit
-    }
+def create_device(device_config: EvuKitSetup):
+    def create_bat_component(component_config: EvuKitBatSetup):
+        return BatKit(device_config.id, component_config, client)
 
-    def __init__(self, device_config: Union[Dict, EvuKit]) -> None:
-        self.device_config = dataclass_from_dict(EvuKit, device_config)
-        self.components = {}  # type: Dict[str, Union[BatKit, counter.EvuKit, PvKit]]
-        self.client = modbus.ModbusTcpClient_("192.168.193.15", 8899)
+    def create_counter_component(component_config: EvuKitCounterSetup):
+        return EvuKit(device_config.id, component_config, client)
 
-    def add_component(self,
-                      component_config: Union[Dict, EvuKitBatSetup, EvuKitCounterSetup, EvuKitInverterSetup]) -> None:
-        if isinstance(component_config, Dict):
-            component_type = component_config["type"]
-        else:
-            component_type = component_config.type
-        component_config = dataclass_from_dict(COMPONENT_TYPE_TO_MODULE[
-            component_type].component_descriptor.configuration_factory, component_config)
-        if component_type in self.COMPONENT_TYPE_TO_CLASS:
-            self.components["component"+str(component_config.id)] = (self.COMPONENT_TYPE_TO_CLASS[component_type](
-                self.device_config.id, component_config, self.client))
-        else:
-            raise Exception(
-                "illegal component type " + component_type + ". Allowed values: " +
-                ','.join(self.COMPONENT_TYPE_TO_CLASS.keys())
-            )
+    def create_inverter_component(component_config: EvuKitInverterSetup):
+        return PvKit(device_config.id, component_config, client)
 
-    def update(self) -> None:
-        log.debug("Start device reading " + str(self.components))
-        if self.components:
-            for component in self.components:
-                # Auch wenn bei einer Komponente ein Fehler auftritt, sollen alle anderen noch ausgelesen werden.
-                with SingleComponentUpdateContext(self.components[component].fault_state):
-                    self.components[component].update()
+    def update_components(components: Iterable[Union[BatKit, EvuKit, PvKit]]):
+        with client:
+            for component in components:
+                with SingleComponentUpdateContext(component.fault_state):
+                    component.update()
                     time.sleep(0.2)
-        else:
-            log.warning(
-                self.device_config.name +
-                ": Es konnten keine Werte gelesen werden, da noch keine Komponenten konfiguriert wurden."
-            )
 
-
-COMPONENT_TYPE_TO_MODULE = {
-    "bat": bat,
-    "counter": counter,
-    "inverter": inverter
-}
-
-
-def read_legacy(component_type: str,
-                evu_version: int,
-                bat_module: Optional[str] = "",
-                bat_version: Optional[int] = 0,
-                num: Optional[int] = None,
-                inverter_module: Optional[str] = "",
-                inverter_version: Optional[int] = 0):
-    """ Ausführung des Moduls als Python-Skript
-    """
-    dev = Device(EvuKit())
-
-    component_config = get_component_config(component_type, evu_version, None)
-    dev.add_component(component_config)
-    log.debug('openWB Version: ' + str(evu_version))
-
-    if inverter_module == "wr_ethmpm3pmaevu" or inverter_module == "wr2_ethlovatoaevu":
-        component_config = get_component_config("inverter", inverter_version, num)
-        dev.add_component(component_config)
-        log.debug('openWB Inverter-Version: ' + str(inverter_version))
-    if bat_module == "speicher_sdmaevu":
-        component_config = get_component_config("bat", bat_version, None)
-        dev.add_component(component_config)
-        log.debug('openWB Bat-Version: ' + str(bat_version))
-
-    dev.update()
-
-
-def get_component_config(component_type: str, version: Optional[int], num: Optional[int] = None) -> Dict:
-    if component_type in COMPONENT_TYPE_TO_MODULE:
-        component_config = COMPONENT_TYPE_TO_MODULE[component_type].component_descriptor.configuration_factory()
-    else:
-        raise Exception("illegal component type " + component_type +
-                        ". Allowed values: " +
-                        ','.join(COMPONENT_TYPE_TO_MODULE.keys()))
-    component_config.id = num
-    component_config.configuration.version = version
-    return component_config
-
-
-def main(argv: List[str]):
-    run_using_positional_cli_args(read_legacy, argv)
-
-
-device_descriptor = DeviceDescriptor(configuration_factory=EvuKit)
+    try:
+        client = modbus.ModbusTcpClient_("192.168.193.15", 8899)
+    except Exception:
+        log.exception("Fehler in create_device")
+    return ConfigurableDevice(
+        device_config=device_config,
+        component_factory=ComponentFactoryByType(
+            bat=create_bat_component,
+            counter=create_counter_component,
+            inverter=create_inverter_component,
+        ),
+        component_updater=MultiComponentUpdater(update_components)
+    )
+
+
+device_descriptor = DeviceDescriptor(configuration_factory=EvuKitSetup)

packages/modules/devices/openwb/openwb_pv_kit/config.py

@@ -7,7 +7,7 @@ def __init__(self):
         pass
 
 
-class PvKit:
+class PvKitSetup:
     def __init__(self,
                  name: str = "openWB PV-Kit",
                  type: str = "openwb_pv_kit",

packages/modules/devices/openwb/openwb_pv_kit/device.py

@@ -1,84 +1,37 @@
 import logging
-from typing import Dict, Optional, List, Union
+from typing import Iterable
 
-from dataclass_utils import dataclass_from_dict
-from helpermodules.cli import run_using_positional_cli_args
 from modules.common import modbus
-from modules.common.abstract_device import AbstractDevice, DeviceDescriptor
+from modules.common.abstract_device import DeviceDescriptor
 from modules.common.component_context import SingleComponentUpdateContext
+from modules.common.configurable_device import ComponentFactoryByType, ConfigurableDevice, MultiComponentUpdater
 from modules.devices.openwb.openwb_pv_kit import inverter
-from modules.devices.openwb.openwb_pv_kit.config import PvKit, PvKitInverterSetup
+from modules.devices.openwb.openwb_pv_kit.config import PvKitSetup, PvKitInverterSetup
 
 log = logging.getLogger(__name__)
 
 
-class Device(AbstractDevice):
-    def __init__(self, device_config: Union[Dict, PvKit]) -> None:
-        self.device_config = dataclass_from_dict(PvKit, device_config)
-        self.components = {}  # type: Dict[str, inverter.PvKit]
-        self.client = modbus.ModbusTcpClient_("192.168.193.13", 8899)
+def create_device(device_config: PvKitSetup):
+    def create_inverter_component(component_config: PvKitInverterSetup):
+        return inverter.PvKit(device_config.id, component_config, client)
 
-    def add_component(self, component_config: Union[Dict, PvKitInverterSetup]) -> None:
-        if isinstance(component_config, Dict):
-            component_type = component_config["type"]
-        else:
-            component_type = component_config.type
-        component_config = dataclass_from_dict(COMPONENT_TYPE_TO_MODULE[
-            component_type].component_descriptor.configuration_factory, component_config)
-        if component_type == "inverter":
-            self.components["component"+str(component_config.id)] = inverter.PvKit(
-                self.device_config.id, component_config, self.client)
-        else:
-            raise Exception("illegal component type " + component_type)
+    def update_components(components: Iterable[inverter.PvKit]):
+        with client:
+            for component in components:
+                with SingleComponentUpdateContext(component.fault_state):
+                    component.update()
 
-    def update(self) -> None:
-        log.debug("Start device reading " + str(self.components))
-        if self.components:
-            for component in self.components:
-                # Auch wenn bei einer Komponente ein Fehler auftritt, sollen alle anderen noch ausgelesen werden.
-                with SingleComponentUpdateContext(self.components[component].fault_state):
-                    self.components[component].update()
-        else:
-            log.warning(
-                self.device_config.name +
-                ": Es konnten keine Werte gelesen werden, da noch keine Komponenten konfiguriert wurden."
-            )
+    try:
+        client = modbus.ModbusTcpClient_("192.168.193.13", 8899)
+    except Exception:
+        log.exception("Fehler in create_device")
+    return ConfigurableDevice(
+        device_config=device_config,
+        component_factory=ComponentFactoryByType(
+            inverter=create_inverter_component,
+        ),
+        component_updater=MultiComponentUpdater(update_components)
+    )
 
 
-COMPONENT_TYPE_TO_MODULE = {
-    "inverter": inverter
-}
-
-
-def read_legacy(component_type: str, version: int, num: Optional[int] = None, evu_version: Optional[int] = None):
-    """ Ausführung des Moduls als Python-Skript
-    """
-    dev = Device(PvKit())
-
-    component_config = get_component_config(component_type, version, num)
-    dev.add_component(component_config)
-    log.debug('openWB Version: ' + str(version))
-
-    if component_type == "evu_inverter" and evu_version:
-        component_config = get_component_config("counter", evu_version, None)
-        dev.add_component(component_config)
-        log.debug('openWB EVU-Version: ' + str(evu_version))
-
-    dev.update()
-
-
-def get_component_config(component_type: str, version: int, num: Optional[int] = None) -> Dict:
-    if component_type == "inverter":
-        component_config = inverter.component_descriptor.configuration_factory()
-    else:
-        raise Exception("illegal component type " + component_type)
-    component_config.id = num
-    component_config.configuration.version = version
-    return component_config
-
-
-def main(argv: List[str]):
-    run_using_positional_cli_args(read_legacy, argv)
-
-
-device_descriptor = DeviceDescriptor(configuration_factory=PvKit)
+device_descriptor = DeviceDescriptor(configuration_factory=PvKitSetup)