velbus-aio 2025.4.2__tar.gz → 2025.5.0__tar.gz

{velbus_aio-2025.4.2/velbus_aio.egg-info → velbus_aio-2025.5.0}/PKG-INFO

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

{velbus_aio-2025.4.2 → velbus_aio-2025.5.0}/pyproject.toml

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

{velbus_aio-2025.4.2 → velbus_aio-2025.5.0/velbus_aio.egg-info}/PKG-INFO

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

{velbus_aio-2025.4.2 → velbus_aio-2025.5.0}/velbusaio/handler.py

@@ -139,7 +139,7 @@ class PacketHandler:
                 if module is not None:
                     try:
                         self._log.debug(
-                            f"Module {module._address} detected: start loading"
+                            f"Module {module.get_address()} detected: start loading"
                         )
                         await asyncio.wait_for(
                             module.load(from_cache=True),

{velbus_aio-2025.4.2 → velbus_aio-2025.5.0}/velbusaio/messages/dali_dim_value_status.py

@@ -10,7 +10,7 @@ from velbusaio.message import Message
 COMMAND_CODE = 0xA5
 
 
-@register(COMMAND_CODE, ["VMBDALI", "VMBDALI-20"])
+@register(COMMAND_CODE, ["VMBDALI", "VMBDALI-20", "VMB8DC-20", "VMB4LEDPWM-20"])
 class DimValueStatus(Message):
     """
     send by: VMBDALI

{velbus_aio-2025.4.2 → velbus_aio-2025.5.0}/velbusaio/messages/dimmer_status.py

@@ -25,7 +25,18 @@ LED_FAST_BLINKING = 1 << 5
 LED_VERY_FAST_BLINKING = 1 << 4
 
 
-@register(COMMAND_CODE, ["VMB1DM", "VMBDME", "VMB1LED"])
+@register(
+    COMMAND_CODE,
+    [
+        "VMB1DM",
+        "VMBDME",
+        "VMB1LED",
+        "VMBDALI",
+        "VMBDALI-20",
+        "VMB8DC-20",
+        "VMB4LEDPWM-20",
+    ],
+)
 class DimmerStatusMessage(Message):
     """
     sent by: VMBDME

{velbus_aio-2025.4.2 → velbus_aio-2025.5.0}/velbusaio/messages/module_type.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import struct
 
-from velbusaio.command_registry import register
+from velbusaio.command_registry import MODULE_DIRECTORY, register
 from velbusaio.message import Message
 
 COMMAND_CODE = 0xFF
@@ -110,11 +110,15 @@ class ModuleTypeMessage(Message):
         self.build_week = 0
         self.set_defaults(address)
 
-    def module_name(self) -> str:
+    def module_type_name(self) -> str:
         """
         :return: str
         """
-        return "Unknown"
+        return (
+            MODULE_DIRECTORY[self.module_type]
+            if self.module_type in MODULE_DIRECTORY
+            else "Unknown"
+        )
 
     def populate(self, priority, address, rtr, data) -> None:
         """

{velbus_aio-2025.4.2 → velbus_aio-2025.5.0}/velbusaio/module.py

@@ -243,6 +243,9 @@ class Module:
             d["channels"][num] = chan.to_cache()
         return d
 
+    def get_address(self) -> int:
+        return self._address
+
     def get_addresses(self) -> list:
         """
         Get all addresses for this module
@@ -550,6 +553,10 @@ class Module:
             await self._update_channel(
                 message.channel, {"power": message.power, "energy": message.energy}
             )
+        elif isinstance(message, DimValueStatus):
+            for offset, dim_value in enumerate(message.dim_values):
+                channel = message.channel + offset
+                await self._update_channel(channel, {"state": dim_value})
 
     async def _update_channel(self, channel: int, updates: dict):
         try:

{velbus_aio-2025.4.2 → velbus_aio-2025.5.0}/velbusaio/module_spec/17.json

@@ -113,7 +113,17 @@
       "03FE": { "ModuleName": "62" },
       "03FF": { "ModuleName": "64:Save" }
     },
-    "ModuleName": "03C0-03FF"
+    "ModuleName": "03C0-03FF",
+    "Channels": {
+      "01": "0000-000F",
+      "02": "0010-001F",
+      "03": "0020-002F",
+      "04": "0030-003F",
+      "05": "0040-004F",
+      "06": "0050-005F",
+      "07": "0060-006F",
+      "08": "0070-007F"
+    }
   },
   "Type": "VMB6PBN"
 }

velbus_aio-2025.5.0/velbusaio/vlp_reader.py

@@ -0,0 +1,113 @@
+import importlib.resources
+import json
+import logging
+import sys
+
+from aiofile import async_open
+from bs4 import BeautifulSoup
+
+from velbusaio.command_registry import MODULE_DIRECTORY
+from velbusaio.helpers import h2
+
+
+class vlpFile:
+
+    def __init__(self, file_path) -> None:
+        self._file_path = file_path
+        self._modules = {}
+        self._log = logging.getLogger("velbus-vlpFile")
+
+    def get(self) -> dict:
+        return self._modules
+
+    async def read(self) -> None:
+        with open(self._file_path) as file:
+            xml_content = file.read()
+        _soup = BeautifulSoup(xml_content, "xml")
+        for module in _soup.find_all("Module"):
+            self._modules[module["address"]] = vlpModule(
+                module.find("Caption").get_text(),
+                module["address"],
+                module["build"],
+                module["serial"],
+                module["type"],
+                module.find("Memory").get_text(),
+            )
+            await self._modules[module["address"]].load_module_spec()
+            print(self._modules[module["address"]].get_channel_name(1))
+            print(self._modules[module["address"]].get_channel_name(2))
+            print(self._modules[module["address"]].get_channel_name(3))
+            print(self._modules[module["address"]].get_channel_name(4))
+            print(self._modules[module["address"]].get_channel_name(5))
+            print(self._modules[module["address"]].get_channel_name(10))
+
+
+class vlpModule:
+
+    def __init__(self, name, addresses, build, serial, type, memory) -> None:
+        self._name = name
+        self._addresses = addresses
+        self._build = build
+        self._serial = serial
+        self._type = type
+        self._memory = memory
+        self._spec = {}
+        self._type_id = next(
+            (key for key, value in MODULE_DIRECTORY.items() if value == self._type),
+            None,
+        )
+        self._log = logging.getLogger("velbus-vlpFile")
+
+    def get(self) -> dict:
+        return {
+            "name": self._name,
+            "addresses": self._addresses,
+            "build": self._build,
+            "serial": self._serial,
+            "type": self._type,
+            "memory": self._memory,
+        }
+
+    def get_name(self) -> str:
+        return self._name
+
+    def get_channel_name(self, chan: int) -> str | None:
+        self._log.debug(f"get_channel_name: {chan}")
+        if "Memory" not in self._spec:
+            self._log.debug(" => no Memory locations found")
+            return None
+        if "Channels" not in self._spec["Memory"]:
+            self._log.debug(" => no Channels Memory locations found")
+            return None
+        if h2(chan) not in self._spec["Memory"]["Channels"]:
+            self._log.debug(f" => no chan {chan} Memory locations found")
+            return None
+        byte_data = bytes.fromhex(
+            self._read_from_memory(self._spec["Memory"]["Channels"][h2(chan)]).replace(
+                "FF", ""
+            )
+        )
+        return byte_data.decode("ascii")
+
+    async def load_module_spec(self) -> None:
+        if sys.version_info >= (3, 13):
+            with importlib.resources.path(
+                __name__, f"module_spec/{h2(self._type_id)}.json"
+            ) as fspath:
+                async with async_open(fspath) as protocol_file:
+                    self._spec = json.loads(await protocol_file.read())
+        else:
+            async with async_open(
+                str(
+                    importlib.resources.files(__name__.split(".")[0]).joinpath(
+                        f"module_spec/{h2(self._type)}.json"
+                    )
+                )
+            ) as protocol_file:
+                self._spec = json.loads(await protocol_file.read())
+
+    def _read_from_memory(self, address_range) -> str | None:
+        start_str, end_str = address_range.split("-")
+        start = int(start_str, 16) * 2
+        end = (int(end_str, 16) + 1) * 2
+        return self._memory[start:end]

velbus_aio-2025.4.2/velbusaio/vlp_reader.py

@@ -1,33 +0,0 @@
-from bs4 import BeautifulSoup
-
-
-class vlpFile:
-
-    def __init__(self, file_path) -> None:
-        self._file_path = file_path
-        self._soup = None
-        self._modules = {}
-        self._read()
-        self._parse()
-        print(self._modules)
-
-    def _read(self) -> None:
-        with open(self._file_path) as file:
-            xml_content = file.read()
-        self._soup = BeautifulSoup(xml_content, "xml")
-
-    def _parse(self) -> None:
-        for module in self._soup.find_all("Module"):
-            self._parse_module(module)
-
-    def _parse_module(self, module) -> None:
-        mod_info = {}
-        mod_info["name"] = module.find("Caption").get_text()
-        mod_info["addresses"] = module["address"]
-        mod_info["build"] = module["build"]
-        mod_info["serial"] = module["serial"]
-        mod_info["build"] = module["build"]
-        mod_info["type"] = module["type"]
-        memory = module.find("Memory")
-        mod_info["memory"] = memory.get_text()
-        self._modules[mod_info["addresses"]] = mod_info