velbus-aio 2024.5.1__tar.gz → 2024.7.1__tar.gz

{velbus_aio-2024.5.1/velbus_aio.egg-info → velbus_aio-2024.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: velbus-aio
-Version: 2024.5.1
+Version: 2024.7.1
 Summary: Open-source home automation platform running on Python 3.
 Author-email: Maikel Punie <maikel.punie@gmail.com>
 License: MIT

{velbus_aio-2024.5.1 → velbus_aio-2024.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools", "wheel"]
 [project]
 name = "velbus-aio"
 license = {text = "MIT"}
-version = "2024.5.1"
+version = "2024.7.1"
 description = "Open-source home automation platform running on Python 3."
 readme = "README.md"
 authors = [
@@ -51,7 +51,7 @@ exclude_dirs = ["tests"]
 skips = ["B301", "B403", "B323", "B104", "B110"]
 
 [tool.bumpver]
-current_version = "2024.5.1"
+current_version = "2024.7.1"
 version_pattern = "YYYY.MM.INC0"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

{velbus_aio-2024.5.1 → velbus_aio-2024.7.1}/requirements.txt

@@ -1,3 +1,5 @@
+aiofile
 backoff>=1.10.0
 pyserial>=3.5.0
 pyserial-asyncio-fast>=0.11
+setuptools

{velbus_aio-2024.5.1 → velbus_aio-2024.7.1/velbus_aio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: velbus-aio
-Version: 2024.5.1
+Version: 2024.7.1
 Summary: Open-source home automation platform running on Python 3.
 Author-email: Maikel Punie <maikel.punie@gmail.com>
 License: MIT

{velbus_aio-2024.5.1 → velbus_aio-2024.7.1}/velbusaio/channels.py

@@ -508,6 +508,7 @@ class Temperature(Channel):
     _min = None
     _target = 0
     _cmode = None
+    _coolmode = None
     _cstatus = None
     _thermostat = False
     _sleep_timer = 0

{velbus_aio-2024.5.1 → velbus_aio-2024.7.1}/velbusaio/const.py

@@ -38,7 +38,13 @@ RTR: Final = 0x40
 NO_RTR: Final = 0x00
 
 CACHEDIR: Final = ".velbuscache"
-LOAD_TIMEOUT: Final = 600
+
+# Module scan timeout values (in mSec)
+SCAN_MODULETYPE_TIMEOUT: Final = 2000  # time to wait for ModuleTypeRequest
+SCAN_MODULEINFO_TIMEOUT_INITIAL: Final = 1000  # time to wait for first info (status)
+SCAN_MODULEINFO_TIMEOUT_INTERVAL: Final = (
+    150  # time to wait for info interval (between next message)
+)
 
 DEVICE_CLASS_ILLUMINANCE: Final = "illuminance"
 DEVICE_CLASS_TEMPERATURE: Final = "temperature"

{velbus_aio-2024.5.1 → velbus_aio-2024.7.1}/velbusaio/controller.py

@@ -14,7 +14,6 @@ import serial
 import serial_asyncio_fast
 
 from velbusaio.channels import Channel
-from velbusaio.const import LOAD_TIMEOUT
 from velbusaio.exceptions import VelbusConnectionFailed
 from velbusaio.handler import PacketHandler
 from velbusaio.helpers import get_cache_dir
@@ -42,20 +41,22 @@ class Velbus:
         self._protocol = VelbusProtocol(
             message_received_callback=self._on_message_received,
             connection_lost_callback=self._on_connection_lost,
-            end_of_scan_callback=self._on_end_of_scan,
         )
         self._closing = False
         self._auto_reconnect = True
 
         self._dsn = dsn
-        self._handler = PacketHandler(self.send, self)
+        self._handler = PacketHandler(self)
         self._modules: dict[int, Module] = {}
         self._submodules: list[int] = []
-        self._send_queue = asyncio.Queue()
-        self._cache_dir = cache_dir
+        self._send_queue: asyncio.Queue = asyncio.Queue()
+        self._cache_dir: str = cache_dir
         # make sure the cachedir exists
         pathlib.Path(self._cache_dir).mkdir(parents=True, exist_ok=True)
 
+    def get_cache_dir(self) -> str:
+        return self._cache_dir
+
     async def _on_message_received(self, msg: RawMessage) -> None:
         """On message received function."""
         await self._handler.handle(msg)
@@ -66,11 +67,7 @@ class Velbus:
             self._log.debug("Reconnecting to transport")
             asyncio.ensure_future(self.connect())
 
-    def _on_end_of_scan(self) -> None:
-        """Notify the scan failure."""
-        self._handler.scan_finished()
-
-    async def add_module(
+    def add_module(
         self,
         addr: int,
         typ: int,
@@ -81,8 +78,7 @@ class Velbus:
         build_week: int | None = None,
     ) -> None:
         """Add a found module to the module cache."""
-        self._log.info(f"Found module: type:{typ} address:{addr}")
-        self._modules[addr] = Module.factory(
+        module = Module.factory(
             addr,
             typ,
             data,
@@ -92,30 +88,31 @@ class Velbus:
             memorymap=memorymap,
             cache_dir=self._cache_dir,
         )
-        self._modules[addr].initialize(self.send)
-        await self._modules[addr].load()
+        module.initialize(self.send)
+        self._modules[addr] = module
+        self._log.info(f"Found module {addr}: {module}")
 
-    async def add_submodules(self, addr: int, subList: dict[int, int]) -> None:
+    def add_submodules(self, module: Module, subList: dict[int, int]) -> None:
         """Add submodules address to module."""
         for sub_num, sub_addr in subList.items():
             if sub_addr == 0xFF:
                 continue
             self._submodules.append(sub_addr)
-            self._modules[addr]._sub_address[sub_num] = sub_addr
-            self._modules[sub_addr] = self._modules[addr]
-        self._modules[addr].cleanupSubChannels()
+            module._sub_address[sub_num] = sub_addr
+            self._modules[sub_addr] = module
+        module.cleanupSubChannels()
 
     def get_modules(self) -> dict:
         """Return the module cache."""
         return self._modules
 
-    def get_module(self, addr: str) -> None | Module:
+    def get_module(self, addr: int) -> None | Module:
         """Get a module on an address."""
         if addr in self._modules:
             return self._modules[addr]
         return None
 
-    def get_channels(self, addr: str) -> None | dict:
+    def get_channels(self, addr: int) -> None | dict:
         """Get the channels for an address."""
         if addr in self._modules:
             return (self._modules[addr]).get_channels()
@@ -129,6 +126,7 @@ class Velbus:
 
     async def connect(self, test_connect: bool = False) -> None:
         """Connect to the bus and load all the data."""
+        await self._handler.read_protocol_data()
         auth = None
         # connect to the bus
         if ":" in self._dsn:
@@ -181,44 +179,15 @@ class Velbus:
             await self._protocol.write_auth_key(auth)
 
         # scan the bus
-        await self.scan()
+        await self._handler.scan()
 
     async def scan(self) -> None:
-        """Scan the bus."""
-        self._handler.scan_started()
-        for addr in range(1, 256):
-            msg = ModuleTypeRequestMessage(addr)
-            await self.send(msg)
-        await self._handler._scan_complete_event.wait()
-        # calculate how long to wait
-        calc_timeout = len(self._modules) * 30
-        if calc_timeout < LOAD_TIMEOUT:
-            timeout = calc_timeout
-        else:
-            timeout = LOAD_TIMEOUT
-        # create a task to wait until we have all modules loaded
-        tsk = asyncio.Task(self._check_if_modules_are_loaded())
-        try:
-            await asyncio.wait_for(tsk, timeout=timeout)
-        except asyncio.TimeoutError:
-            self._log.error(
-                f"Not all modules are loaded within a timeout of {LOAD_TIMEOUT} seconds, continuing with the loaded modules"
-            )
+        """Service endpoint to restart the scan"""
+        await self._handler.scan(True)
 
-    async def _check_if_modules_are_loaded(self) -> None:
-        """Task to wait until modules are loaded."""
-        while True:
-            mods_loaded = 0
-            for mod in (self.get_modules()).values():
-                if mod.is_loaded():
-                    mods_loaded += 1
-                else:
-                    self._log.warning(f"Waiting for module {mod._address}")
-            if mods_loaded == len(self.get_modules()):
-                self._log.info("All modules loaded")
-                return
-            self._log.info("Not all modules loaded yet, waiting 15 seconds")
-            await asyncio.sleep(15)
+    async def sendTypeRequestMessage(self, address: int) -> None:
+        msg = ModuleTypeRequestMessage(address)
+        await self.send(msg)
 
     async def send(self, msg: Message) -> None:
         """Send a packet."""

velbus_aio-2024.7.1/velbusaio/handler.py

@@ -0,0 +1,277 @@
+"""
+Velbus packet handler
+:Author maikel punie <maikel.punie@gmail.com>
+"""
+
+from __future__ import annotations
+
+from velbusaio.const import SCAN_MODULETYPE_TIMEOUT
+from velbusaio.const import SCAN_MODULEINFO_TIMEOUT_INITIAL
+from velbusaio.const import SCAN_MODULEINFO_TIMEOUT_INTERVAL
+
+import asyncio
+import json
+import logging
+import threading
+import os
+import pathlib
+
+from aiofile import async_open
+
+from typing import TYPE_CHECKING, Awaitable, Callable
+import pkg_resources
+
+from velbusaio.command_registry import commandRegistry
+from velbusaio.helpers import h2, keys_exists
+from velbusaio.message import Message
+from velbusaio.messages.module_subtype import ModuleSubTypeMessage
+from velbusaio.messages.module_type import ModuleTypeMessage, ModuleType2Message
+from velbusaio.raw_message import RawMessage
+
+
+if TYPE_CHECKING:
+    from velbusaio.controller import Velbus
+
+
+class PacketHandler:
+    """
+    The packetHandler class
+    """
+
+    def __init__(
+        self,
+        velbus: Velbus,
+    ) -> None:
+        self._log = logging.getLogger("velbus-handler")
+        self._log.setLevel(logging.DEBUG)
+        self._velbus = velbus
+        self._typeResponseReceived = asyncio.Event()
+        self._scanLock = threading.Lock()
+        self._modulescan_address = 0
+        self._scan_complete = False
+        self._scan_delay_msec = 0
+
+    async def read_protocol_data(self):
+        async with async_open(
+            pkg_resources.resource_filename(__name__, "protocol.json")
+        ) as protocol_file:
+            self.pdata = json.loads(await protocol_file.read())
+
+    def empty_cache(self) -> bool:
+        if (
+            len(
+                [
+                    name
+                    for name in os.listdir(f"{self._velbus.get_cache_dir()}")
+                    if os.path.isfile(f"{self._velbus.get_cache_dir()}/{name}")
+                ]
+            )
+            == 0
+        ):
+            return True
+        return False
+
+    async def scan(self, reload_cache: bool = False) -> None:
+        if reload_cache:
+            self._modulescan_address = 0
+            self._scan_complete = False
+        # non-blocking check to see if the cache_dir is empty
+        loop = asyncio.get_running_loop()
+        print(self._velbus.get_cache_dir())
+        print(await loop.run_in_executor(None, self.empty_cache))
+        if not reload_cache and await loop.run_in_executor(None, self.empty_cache):
+            self._log.info("No cache yet, so forcing a bus scan")
+            reload_cache = True
+        self._log.info("Start module scan")
+        while self._modulescan_address < 254:
+            address = 0
+            module = None
+            with self._scanLock:
+                self._modulescan_address = self._modulescan_address + 1
+                address = self._modulescan_address
+                module = self._velbus.get_module(address)
+
+            self._log.info(f"Starting handling scan {address}")
+
+            cfile = pathlib.Path(f"{self._velbus.get_cache_dir()}/{address}.json")
+            # cleanup the old module cache if needed
+            scanModule = reload_cache
+            if scanModule and os.path.isfile(cfile):
+                os.remove(cfile)
+            elif os.path.isfile(cfile):
+                scanModule = os.path.isfile(cfile)
+            if scanModule:
+                try:
+                    self._log.info(f"Starting scan {address}")
+                    self._typeResponseReceived.clear()
+                    await self._velbus.sendTypeRequestMessage(address)
+                    await asyncio.wait_for(
+                        self._typeResponseReceived.wait(),
+                        SCAN_MODULETYPE_TIMEOUT / 1000.0,
+                    )
+                    with self._scanLock:
+                        module = self._velbus.get_module(address)
+                except asyncio.TimeoutError:
+                    self._log.info(
+                        f"Scan module {address} failed: not present or unavailable"
+                    )
+                if module is not None:
+                    try:
+                        self._log.debug(f"Module {address} detected: start loading")
+                        await asyncio.wait_for(
+                            module.load(from_cache=True),
+                            SCAN_MODULEINFO_TIMEOUT_INITIAL / 1000.0,
+                        )
+                        self._scan_delay_msec = SCAN_MODULEINFO_TIMEOUT_INITIAL
+                        while self._scan_delay_msec > 50 and not module.is_loaded():
+                            # self._log.debug(
+                            #    f"\t... waiting {self._scan_delay_msec} is_loaded={module.is_loaded()}"
+                            # )
+                            self._scan_delay_msec = self._scan_delay_msec - 50
+                            await asyncio.sleep(0.05)
+                        self._log.info(
+                            f"Scan module {address} completed, module loaded={module.is_loaded()}"
+                        )
+                    except asyncio.TimeoutError:
+                        self._log.error(
+                            f"Module {address} did not respond to info requests after successful type request"
+                        )
+        self._scan_complete = True
+        self._log.info("Module scan completed")
+
+    async def handle(self, rawmsg: RawMessage) -> None:
+        """
+        Handle a received packet
+        """
+        if rawmsg.address < 1 or rawmsg.address > 254:
+            return
+        if rawmsg.command is None:
+            return
+
+        priority = rawmsg.priority
+        address = rawmsg.address
+        rtr = rawmsg.rtr
+        command_value = rawmsg.command
+        data = rawmsg.data_only
+
+        # handle module type response message
+        if command_value == 0xFF:
+            if not self._scan_complete:
+                tmsg: ModuleTypeMessage = ModuleTypeMessage()
+                tmsg.populate(priority, address, rtr, data)
+                with self._scanLock:
+                    self._handle_module_type(tmsg)
+                    if address == self._modulescan_address:
+                        self._typeResponseReceived.set()
+                    else:
+                        self._log.debug(
+                            f"Unexpected module type message module address {address}, Velbuslink scan?"
+                        )
+                        self._modulescan_address = address - 1
+
+                self._typeResponseReceived.set()
+
+        # handle module subtype response message
+        elif command_value in (0xB0, 0xA7, 0xA6):
+            if not self._scan_complete:
+                msg: ModuleSubTypeMessage = ModuleSubTypeMessage()
+                msg.populate(priority, address, rtr, data)
+                if command_value == 0xB0:
+                    msg.sub_address_offset = 0
+                elif command_value == 0xA7:
+                    msg.sub_address_offset = 4
+                elif command_value == 0xA6:
+                    msg.sub_address_offset = 8
+                with self._scanLock:
+                    self._scan_delay_msec = SCAN_MODULEINFO_TIMEOUT_INITIAL
+                    self._handle_module_subtype(msg)
+
+        # ignore broadcast
+        elif command_value in self.pdata["MessagesBroadCast"]:
+            self._log.debug(
+                "Received broadcast message {} from {}, ignoring".format(
+                    self.pdata["MessageBroadCast"][str(command_value).upper()], address
+                )
+            )
+
+        # handle other messages for modules that are already scanned
+        else:
+            module = None
+            with self._scanLock:
+                module = self._velbus.get_module(address)
+            if module is not None:
+                module_type = module.get_type()
+                if commandRegistry.has_command(int(command_value), module_type):
+                    command = commandRegistry.get_command(command_value, module_type)
+                    if not command:
+                        return
+                    msg = command()
+                    msg.populate(priority, address, rtr, data)
+                    # restart the info completion time when info message received
+                    if command_value in (
+                        0xF0,
+                        0xF1,
+                        0xF2,
+                        0xFB,
+                        0xFE,
+                        0xCC,
+                    ):  # names, memory data, memory block
+                        self._scan_delay_msec = SCAN_MODULEINFO_TIMEOUT_INTERVAL
+                        # self._log.debug(f"Restart timeout {msg}")
+                    # send the message to the modules
+                    await module.on_message(msg)
+                else:
+                    self._log.warning(f"NOT FOUND IN command_registry: {rawmsg}")
+
+    def _handle_module_type(self, msg: ModuleTypeMessage | ModuleType2Message) -> None:
+        """
+        load the module data
+        """
+        if msg is not None:
+            module = self._velbus.get_module(msg.address)
+            if module is None:
+                data = keys_exists(self.pdata, "ModuleTypes", h2(msg.module_type))
+                if not data:
+                    self._log.warning(f"Module not recognized: {msg.module_type}")
+                    return
+                self._velbus.add_module(
+                    msg.address,
+                    msg.module_type,
+                    data,
+                    memorymap=msg.memory_map_version,
+                    build_year=msg.build_year,
+                    build_week=msg.build_week,
+                    serial=msg.serial,
+                )
+            else:
+                self._log.debug(
+                    f"***Module already exists scanAddr={self._modulescan_address} addr={msg.address} {msg}"
+                )
+
+        # else:
+        #    self._log.debug("*** handle_module_type called without response message")
+
+    def _handle_module_subtype(self, msg: ModuleSubTypeMessage) -> None:
+        module = self._velbus.get_module(msg.address)
+        if module is not None:
+            addrList = {
+                (msg.sub_address_offset + 1): msg.sub_address_1,
+                (msg.sub_address_offset + 2): msg.sub_address_2,
+                (msg.sub_address_offset + 3): msg.sub_address_3,
+                (msg.sub_address_offset + 4): msg.sub_address_4,
+            }
+            self._velbus.add_submodules(module, addrList)
+
+
+#    def _channel_convert(self, module: str, channel: str, ctype: str) -> None | int:
+#        data = keys_exists(
+#            self.pdata, "ModuleTypes", h2(module), "ChannelNumbers", ctype
+#        )
+#        if data and "Map" in data and h2(channel) in data["Map"]:
+#            return data["Map"][h2(channel)]
+#        if data and "Convert" in data:
+#            return int(channel)
+#        for offset in range(0, 8):
+#            if channel & (1 << offset):
+#                return offset + 1
+#        return None

{velbus_aio-2024.5.1 → velbus_aio-2024.7.1}/velbusaio/message.py

@@ -20,19 +20,19 @@ class Message:
     Base Velbus message
     """
 
-    def __init__(self, address: int = None) -> None:
+    def __init__(self, address: int = 0) -> None:
         self.priority = PRIORITY_LOW
-        self.address = None
-        self.rtr = False
+        self.address: int = 0
+        self.rtr: bool = False
         self.data = bytearray()
         self.set_defaults(address)
 
-    def set_attributes(self, priority: int, address: int, rtr: int) -> None:
+    def set_attributes(self, priority: int, address: int, rtr: bool) -> None:
         self.priority = priority
         self.address = address
         self.rtr = rtr
 
-    def populate(self, priority: int, address: int, rtr: int, data: int) -> None:
+    def populate(self, priority: int, address: int, rtr: bool, data: int) -> None:
         raise NotImplementedError
 
     def set_defaults(self, address: int | None) -> None:
@@ -66,7 +66,7 @@ class Message:
             if callable(getattr(self, key)) or key.startswith("__"):
                 del me[key]
             if isinstance(me[key], (bytes, bytearray)):
-                me[key] = str(me[key], "utf-8")
+                me[key] = str(me[key])
         return me
 
     def to_json(self) -> str:

{velbus_aio-2024.5.1 → velbus_aio-2024.7.1}/velbusaio/messages/module_subtype.py

@@ -25,7 +25,7 @@ class ModuleSubTypeMessage(Message):
 
     # pylint: disable-msg=R0902
 
-    def __init__(self, address=None, sub_address_offset: int = 0):
+    def __init__(self, address=None, sub_address_offset: int = 0) -> None:
         Message.__init__(self)
         self.module_type = 0x00
         self.sub_address_1 = 0xFF
@@ -36,13 +36,13 @@ class ModuleSubTypeMessage(Message):
         self.serial = 0
         self.sub_address_offset = sub_address_offset
 
-    def module_name(self):
+    def module_name(self) -> str:
         """
         :return: str
         """
         return "Unknown"
 
-    def populate(self, priority, address, rtr, data):
+    def populate(self, priority, address, rtr, data) -> None:
         """
         :return: None
         """

{velbus_aio-2024.5.1 → velbus_aio-2024.7.1}/velbusaio/messages/module_type.py

@@ -98,7 +98,7 @@ class ModuleTypeMessage(Message):
 
     # pylint: disable-msg=R0902
 
-    def __init__(self, address=None):
+    def __init__(self, address=None) -> None:
         Message.__init__(self)
         self.module_type = 0x00
         self.led_on = []
@@ -110,13 +110,13 @@ class ModuleTypeMessage(Message):
         self.build_week = 0
         self.set_defaults(address)
 
-    def module_name(self):
+    def module_name(self) -> str:
         """
         :return: str
         """
         return "Unknown"
 
-    def populate(self, priority, address, rtr, data):
+    def populate(self, priority, address, rtr, data) -> None:
         """
         :return: None
         """
@@ -151,7 +151,7 @@ class ModuleTypeMessage(Message):
     ],
 )
 class ModuleType2Message(Message):
-    def __init__(self, address=None):
+    def __init__(self, address=None) -> None:
         Message.__init__(self)
         self.module_type = 0x00
         self.led_on = []
@@ -164,7 +164,7 @@ class ModuleType2Message(Message):
         self.term = 0
         self.set_defaults(address)
 
-    def module_name(self):
+    def module_name(self) -> str:
         """
         :return: str
         """