refactor: Building of device_info

custom_components/solarman/api.py

@@ -12,7 +12,6 @@
 from pysolarmanv5 import PySolarmanV5Async, V5FrameError
 from umodbus.client.tcp import read_coils, read_discrete_inputs, read_holding_registers, read_input_registers, write_single_coil, write_multiple_coils, write_single_register, write_multiple_registers, parse_response_adu
 
-from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo, format_mac
 from homeassistant.helpers.update_coordinator import UpdateFailed
 
 from .const import *
@@ -107,53 +106,26 @@ async def write_multiple_holding_registers(self, register_addr, values):
         return await self._tcp_parse_response_adu(write_multiple_registers(self.mb_slave_id, register_addr, values))
 
 class Inverter(PySolarmanV5AsyncWrapper):
-    def __init__(self, address, serial, port, mb_slave_id):
-        super().__init__(address, serial, port, mb_slave_id)
-        self._is_busy = 0
-        self.state_updated = datetime.now()
-        self.state_interval = 0
-        self.state = -1
-        self.auto_reconnect = AUTO_RECONNECT
-        self.manufacturer = "Solarman"
-        self.model = None
-        self.parameter_definition = None
-        self.device_info = {}
+    _is_busy = 0
+
+    auto_reconnect = AUTO_RECONNECT
+    state = -1
+    state_interval = 0
+    state_updated = datetime.now()
+    device_info = {}
+    profile = None
 
     async def load(self, name, mac, path, file):
         self.name = name
-        self.mac = mac
-        self.lookup_path = path
-        self.lookup_file = process_profile(file if file else "deye_hybrid.yaml")
-        self.model = self.lookup_file.replace(".yaml", "")
-        self.parameter_definition = await yaml_open(self.lookup_path + self.lookup_file)
-        self.profile = ParameterParser(self.parameter_definition)
-
-        if "info" in self.parameter_definition and "model" in self.parameter_definition["info"]:
-            info = self.parameter_definition["info"]
-            if "manufacturer" in info:
-                self.manufacturer = info["manufacturer"]
-            if "model" in info:
-                self.model = info["model"]
-        elif '_' in self.model:
-            dev_man = self.model.split('_')
-            self.manufacturer = dev_man[0].capitalize()
-            self.model = dev_man[1].upper()
-        else:
-            self.manufacturer = "Solarman"
-            self.model = "Stick Logger"
-
-        self.device_info = ({ "connections": {(CONNECTION_NETWORK_MAC, format_mac(self.mac))} } if self.mac else {}) | {
-            "identifiers": {(DOMAIN, self.serial)},
-            "name": self.name,
-            "manufacturer": self.manufacturer,
-            "model": self.model,
-            "serial_number": self.serial
-        }
+
+        if (n := process_profile(file if file else "deye_hybrid.yaml")) and (p := await yaml_open(path + n)):
+            self.device_info = build_device_info(self.serial, mac, name, p["info"] if "info" in p else None, n)
+            self.profile = ParameterParser(p)
 
         _LOGGER.debug(self.device_info)
 
     def get_sensors(self):
-        return self.profile.get_sensors() if self.parameter_definition else []
+        return self.profile.get_sensors() if self.profile else []
 
     def available(self):
         return self.state > -1

custom_components/solarman/common.py

@@ -6,6 +6,8 @@
 
 from datetime import datetime, time
 
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo, format_mac
+
 from .const import *
 
 def get_current_file_name(value):
@@ -38,6 +40,26 @@ async def yaml_open(file):
 def process_profile(filename):
     return filename if not filename in PROFILE_REDIRECT_TABLE else PROFILE_REDIRECT_TABLE[filename]
 
+def build_device_info(serial, mac, name, info, filename):
+    manufacturer = "Solarman"
+    model = "Stick Logger"
+
+    if info and "model" in info:
+        if "manufacturer" in info:
+            manufacturer = info["manufacturer"]
+        model = info["model"]
+    elif '_' in filename and (dev_man := filename.replace(".yaml", "").split('_')):
+        manufacturer = dev_man[0].capitalize()
+        model = dev_man[1].upper()
+
+    return ({ "connections": {(CONNECTION_NETWORK_MAC, format_mac(mac))} } if mac else {}) | {
+        "identifiers": {(DOMAIN, serial)},
+        "serial_number": serial,
+        "manufacturer": manufacturer,
+        "model": model,
+        "name": name
+    }
+
 def is_platform(description, value):
     return (description["platform"] if "platform" in description else "sensor") == value
 

custom_components/solarman/const.py

@@ -59,7 +59,7 @@
 # On the contrary changing this value can break:
 # - Request scheduling according "update_interval" properties set in profiles
 # - Inverter configuring flows
-# - Behavior of integration services
+# - Behavior of services
 #
 TIMINGS_INTERVAL = 5
 TIMINGS_INTERVAL_SCALE = 1

custom_components/solarman/coordinator.py

@@ -12,10 +12,13 @@
 _LOGGER = logging.getLogger(__name__)
 
 class InverterCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+    _counter = 0
+
+    #self.setup_method = setup_method | setup_method: Callable[[], Awaitable[None]] | None = None
+
     def __init__(self, hass: HomeAssistant, inverter):
         super().__init__(hass, _LOGGER, name = inverter.name, update_interval = TIMINGS_UPDATE_INTERVAL, always_update = False)
         self.inverter = inverter
-        self._counter = 0
 
     def _accounting(self) -> int:
         try:

custom_components/solarman/parser.py

@@ -12,14 +12,15 @@
 _LOGGER = logging.getLogger(__name__)
 
 class ParameterParser:
+    _update_interval = DEFAULT_REGISTERS_UPDATE_INTERVAL
+    _code = DEFAULT_REGISTERS_CODE
+    _min_span = DEFAULT_REGISTERS_MIN_SPAN
+    _digits = DEFAULT_DIGITS
+    _registers_table = {}
+    _result = {}
+
     def __init__(self, profile):
         self._profile = profile
-        self._update_interval = DEFAULT_REGISTERS_UPDATE_INTERVAL
-        self._code = DEFAULT_REGISTERS_CODE
-        self._min_span = DEFAULT_REGISTERS_MIN_SPAN
-        self._digits = DEFAULT_DIGITS
-        self._registers_table = {}
-        self._result = {}
 
         if "default" in self._profile:
             default = self._profile["default"]
@@ -41,7 +42,7 @@ def __init__(self, profile):
                 for r in range(pr[REQUEST_START], pr[REQUEST_END] + 1):
                     requests_table[r] = get_request_code(pr)
 
-        for p in self.parameters():
+        for p in self._profile["parameters"]:
             for i in p["items"]:
                 if "registers" in i:
                     for r in i["registers"]:
@@ -57,14 +58,11 @@ def __init__(self, profile):
         self._lambda = lambda x, y: y - x > self._min_span
         self._lambda_code_aware = lambda x, y: self._registers_table[x] != self._registers_table[y] or y - x > self._min_span
 
-        self._items = [inherit(item, group) for group in self.parameters() for item in group["items"]]
+        self._items = [inherit(item, group) for group in self._profile["parameters"] for item in group["items"]]
 
     def flush_states(self):
         self._result = {}
 
-    def parameters(self):
-        return self._profile["parameters"]
-
     def is_valid(self, parameters):
         return "name" in parameters and "rule" in parameters  # and "registers" in parameters