velbus-aio 2023.12.0__py3-none-any.whl → 2025.11.0__py3-none-any.whl

velbusaio/protocol.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import binascii
 import logging
+import time
 import typing as t
 from asyncio import transports
 
@@ -15,9 +16,7 @@ from velbusaio.raw_message import create as create_message_info
 
 def _on_write_backoff(details):
     logging.debug(
-        "Transport is not open, waiting {wait} seconds after {tries}",
-        wait=details.wait,
-        tries=details.tries,
+        f"Transport is not open, waiting {details.wait} seconds after {details.tries}"
     )
 
 
@@ -31,13 +30,11 @@ class VelbusProtocol(asyncio.BufferedProtocol):
         self,
         message_received_callback: t.Callable[[RawMessage], t.Awaitable[None]],
         connection_lost_callback=None,
-        end_of_scan_callback=None,
     ) -> None:
         super().__init__()
         self._log = logging.getLogger("velbus-protocol")
         self._message_received_callback = message_received_callback
         self._connection_lost_callback = connection_lost_callback
-        self._end_of_scan_callback = end_of_scan_callback
 
         # everything for reading from Velbus
         self._buffer = bytearray(MAXIMUM_MESSAGE_SIZE)
@@ -63,14 +60,14 @@ class VelbusProtocol(asyncio.BufferedProtocol):
         self._restart_writer = True
         self.restart_writing()
 
-    async def pause_writing(self):
+    async def pause_writing(self) -> None:
         """Pause writing."""
         self._restart_writer = False
         if self._writer_task:
             self._send_queue.put_nowait(None)
         await asyncio.sleep(0.1)
 
-    def restart_writing(self):
+    def restart_writing(self) -> None:
         """Resume writing."""
         if self._restart_writer and not self._write_transport_lock.locked():
             self._writer_task = asyncio.ensure_future(
@@ -78,7 +75,7 @@ class VelbusProtocol(asyncio.BufferedProtocol):
             )
             self._writer_task.add_done_callback(lambda _future: self.restart_writing())
 
-    def close(self):
+    def close(self) -> None:
         self._closing = True
         self._restart_writer = False
         if self.transport:
@@ -165,7 +162,7 @@ class VelbusProtocol(asyncio.BufferedProtocol):
         self._buffer_view = memoryview(self._buffer)
 
     async def _process_message(self, msg: RawMessage) -> None:
-        self._log.debug(f"RX: {msg}")
+        # self._log.debug(f"RX: {msg}")
         await self._message_received_callback(msg)
 
     # Everything write-related
@@ -184,22 +181,22 @@ class VelbusProtocol(asyncio.BufferedProtocol):
         await self._write_transport_lock.acquire()
         while self._restart_writer:
             # wait for an item from the queue
-            msg_info = await self._send_queue.get()
+            msg_info: RawMessage | None = await self._send_queue.get()
             if msg_info is None:
                 self._restart_writer = False
                 return
             message_sent = False
             try:
+                start_time = time.perf_counter()
                 while not message_sent:
                     message_sent = await self._write_message(msg_info)
-                if msg_info.command == 0xEF:
-                    # 'channel name request' command provokes in worst case 99 answer packets from VMBGPOD
-                    queue_sleep_time = SLEEP_TIME * 33
-                else:
-                    queue_sleep_time = SLEEP_TIME
-                if msg_info.rtr and msg_info.address == 0xFF:
-                    self._end_of_scan_callback()
+                send_time = time.perf_counter() - start_time
+
+                self._send_queue.task_done()  # indicate that the item of the queue has been processed
+
+                queue_sleep_time = self._calculate_queue_sleep_time(msg_info, send_time)
                 await asyncio.sleep(queue_sleep_time)
+
             except (asyncio.CancelledError, GeneratorExit) as exc:
                 if not self._closing:
                     self._log.error(f"Stopping Velbus writer due to {exc!r}")
@@ -211,6 +208,22 @@ class VelbusProtocol(asyncio.BufferedProtocol):
             self._write_transport_lock.release()
         self._log.debug("Ending Velbus write message from send queue")
 
+    @staticmethod
+    def _calculate_queue_sleep_time(msg_info, send_time):
+        sleep_time = SLEEP_TIME
+
+        if msg_info.rtr:
+            sleep_time = SLEEP_TIME  # this is a scan command. We could be quicker?
+
+        if msg_info.command == 0xEF:
+            # 'channel name request' command provokes in worst case 99 answer packets from VMBGPOD
+            sleep_time = SLEEP_TIME * 33  # TODO make this adaptable on module_type
+
+        if send_time > sleep_time:
+            return 0  # no need to wait, we are already late
+        else:
+            return sleep_time - send_time
+
     @backoff.on_predicate(
         backoff.expo,
         lambda is_sent: not is_sent,
@@ -224,3 +237,7 @@ class VelbusProtocol(asyncio.BufferedProtocol):
             return True
         else:
             return False
+
+    async def wait_on_all_messages_sent_async(self) -> None:
+        self._log.debug("Waiting on all messages sent")
+        await self._send_queue.join()

velbusaio/raw_message.py

@@ -130,12 +130,12 @@ def _trim_buffer_garbage(rawmessage: bytearray) -> bytearray:
     if rawmessage and rawmessage[0] != START_BYTE:
         start_index = rawmessage.find(START_BYTE)
         if start_index > -1:
-            logging.debug(
-                "Trimming leading garbage from buffer content: {buffer} becomes {new_buffer}".format(
-                    buffer=binascii.hexlify(rawmessage),
-                    new_buffer=binascii.hexlify(rawmessage[start_index:]),
-                )
-            )
+            #           logging.debug(
+            #                "Trimming leading garbage from buffer content: {buffer} becomes {new_buffer}".format(
+            #                    buffer=binascii.hexlify(rawmessage),
+            #                    new_buffer=binascii.hexlify(rawmessage[start_index:]),
+            #                )
+            #            )
             return rawmessage[start_index:]
         else:
             logging.debug(

velbusaio/util.py

@@ -1,3 +1,7 @@
+"""
+Some common utils.
+"""
+
 from typing import Union
 
 from velbusaio.const import MAXIMUM_MESSAGE_SIZE, MINIMUM_MESSAGE_SIZE

velbusaio/vlp_reader.py

@@ -0,0 +1,249 @@
+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:
+        async with async_open(self._file_path) as file:
+            xml_content = await file.read()
+        _soup = BeautifulSoup(xml_content, "xml")
+        for module in _soup.find_all("Module"):
+            mod = vlpModule(
+                module.find("Caption").get_text(),
+                module["address"],
+                module["build"],
+                module["serial"],
+                module["type"],
+                module.find("Memory").get_text(),
+            )
+            self._modules.append(mod)
+            await mod.parse()
+        self._modules.sort(key=lambda mod: mod.get_decimal_addr())
+
+    def dump(self) -> None:
+        for m in self._modules:
+            print(f"Module {m.get_decimal_addr()}: {m._name}, type {m._type_id}")
+            for key, value in m._channels.items():
+                name = value["Name"]
+                print(f"  {key} => {name}")
+
+
+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._channels = {}
+        self._type_id = next(
+            (key for key, value in MODULE_DIRECTORY.items() if value == self._type),
+            None,
+        )
+        self._log = logging.getLogger("velbus-vlpFile")
+        self._log.info(
+            f"=> Created vlpModule address: {self._addresses} type: {self._type} ({self._type_id})"
+        )
+
+    def get(self) -> None:
+        print(self._channels)
+        print(self)
+
+    def get_addr(self) -> str:
+        return self._addresses
+
+    def get_name(self) -> str:
+        return self._name
+
+    def get_type(self) -> int | None:
+        return self._type_id
+
+    def get_serial(self) -> str:
+        return self._serial
+
+    def get_memory(self) -> str:
+        return self._memory
+
+    def get_build(self) -> str:
+        return self._build
+
+    def get_channels(self) -> dict:
+        return self._channels
+
+    def __str__(self):
+        return f"vlpModule(name={self._name}, addresses={self._addresses}, build={self._build}, serial={self._serial}, type={self._type})"
+
+    def get_decimal_addr(
+        self,
+    ) -> int:  # lgor: get the numeric value of primary module address
+        addr = self._addresses.split(",")[0]
+        return int(addr, 16)
+
+    async def parse(self) -> None:
+        await self._load_module_spec()
+
+        if "Memory" not in self._spec:
+            self._log.debug("  => no Memory locations found")
+            return None
+
+        # channel names
+        self._channels = self._spec.get("Channels", {})
+        for addr, chan in self._channels.items():
+            self._log.debug(f" => Processing channel {addr}:")
+            if ("Editable" in chan) and (chan["Editable"] == "yes"):
+                self._log.debug(f"  => channel {addr} is editable, getting name")
+                name = self._get_channel_name(int(addr))
+                if name:
+                    self._log.debug(f"  => got name '{name}' for channel {addr}")
+                    self._channels[addr]["Name"] = name
+                    self._channels[addr]["_is_loaded"] = True
+
+        # extra
+        self._load_extra_data()
+
+    def _load_extra_data(self) -> None:
+        self._log.debug(" => Getting extra data")
+        if "Extras" not in self._spec["Memory"]:
+            self._log.debug("  => no Extra Memory locations found")
+            return None
+        for addr, extra in self._spec["Memory"]["Extras"].items():
+            byte_data = bytes.fromhex(self._read_from_memory(addr))
+            self._log.debug(
+                f"  => got extra data {byte_data.hex().upper()} from address {addr}"
+            )
+            if "Translate" in extra:
+                translation_found = False
+                for translate_key, translate_value in extra["Translate"].items():
+                    if translate_key.startswith("%"):
+                        # Binary pattern matching
+                        if self._match_binary_pattern(translate_key, byte_data):
+                            self._log.debug(
+                                f"   => Binary pattern {translate_key} matched, value: {translate_value}"
+                            )
+                            self._channels[translate_value["Channel"]][
+                                translate_value["SubName"]
+                            ] = translate_value["Value"]
+                            translation_found = True
+                    else:
+                        # Direct value matching (existing behavior for integer keys)
+                        try:
+                            int_key = int(translate_key)
+                            if len(byte_data) > 0 and byte_data[0] == int_key:
+                                self._log.debug(
+                                    f"   => Direct match for value {int_key}: {translate_value}"
+                                )
+                                translation_found = True
+                        except ValueError:
+                            # Not an integer key, skip
+                            continue
+                if not translation_found:
+                    self._log.error(
+                        f" => No translation found for data {byte_data.hex().upper()}"
+                    )
+
+    def _match_binary_pattern(self, pattern: str, byte_data: bytes) -> bool:
+        """
+        Match a binary pattern like %......00 against byte data.
+        % indicates binary pattern
+        . means don't care bit
+        0/1 are specific bits that must match
+        """
+        if not pattern.startswith("%"):
+            return False
+
+        # Remove the % prefix
+        binary_pattern = pattern[1:]
+
+        # Convert byte_data to binary string (without '0b' prefix)
+        if len(byte_data) == 0:
+            return False
+
+        # Take the first byte for pattern matching
+        byte_value = byte_data[0]
+        binary_data = format(byte_value, "08b")
+
+        # Check if pattern length matches
+        if len(binary_pattern) != len(binary_data):
+            return False
+
+        # Check each bit position
+        for i, (pattern_bit, data_bit) in enumerate(zip(binary_pattern, binary_data)):
+            if pattern_bit == ".":
+                # Don't care bit, skip
+                continue
+            elif pattern_bit != data_bit:
+                # Specific bit must match
+                return False
+
+        return True
+
+    def _get_channel_name(self, chan: int) -> str | None:
+        if "Channels" not in self._spec["Memory"]:
+            self._log.debug("  => no Channels Memory locations found")
+            return None
+        dchan = format(chan, "02d")
+        if dchan 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"][dchan]).replace(
+                "FF", ""
+            )
+        )
+        try:
+            name = byte_data.decode("ascii")
+        except UnicodeDecodeError as e:
+            self._log.error(f"  => UnicodeDecodeError: {e}")
+            name = byte_data
+        finally:
+            return name
+
+    async def _load_module_spec(self) -> None:
+        self._log.debug(f" => Load module spec for {self._type_id}")
+        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_id)}.json"
+                    )
+                )
+            ) as protocol_file:
+                self._spec = json.loads(await protocol_file.read())
+
+    def _read_from_memory(self, address_range) -> str | None:
+        # its a single address
+        if "-" not in address_range:
+            start = int(address_range, 16) * 2
+            end = (int(address_range, 16) + 1) * 2
+            return self._memory[start:end]
+        # its a range
+        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-2023.12.0.dist-info/RECORD

@@ -1,103 +0,0 @@
-velbusaio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-velbusaio/channels.py,sha256=ezviD9AepEneuBezcWpk0tWoPZxbTit8wuMcBO44MsM,22848
-velbusaio/command_registry.py,sha256=UJOknKYGDPb0pPuvsH42GetEVC-Sa3bMkiSExE6DfPc,4787
-velbusaio/const.py,sha256=9JY8oMrE4galRPAv247RXP_xDOdYkyPc7lBlptJius4,1550
-velbusaio/controller.py,sha256=h8LProppbTYJNdyyS5rQ3ZweiTjcKsdbKBzNoOS_IAk,9253
-velbusaio/discovery.py,sha256=Px6qoZl4QhF17aMz6JxstCORBpLzZGWEK9h4Vyvg57o,1649
-velbusaio/exceptions.py,sha256=FHkXaM3dK5Gkk-QGAf9dLE3FPlCU2FRZWUyY-4KRNnA,515
-velbusaio/handler.py,sha256=gI0Zma9SbcVEvAzYno4IJbqwtEYQk5Cp6zxVNtmox54,8342
-velbusaio/helpers.py,sha256=8PWyD13UA244ESk5YwPcRzvjK3OBAqmhwAwC6E9W4B4,2542
-velbusaio/message.py,sha256=ZFy0iup_DK_so_wZsr2F-3A4AJgQGxf5C3TXjK4BMW0,5047
-velbusaio/module.py,sha256=GmuUthbqlluI8n8HHgTjMsPbzSWWDUa5Y2XPSbJArms,35355
-velbusaio/protocol.py,sha256=sut7jf3IJiJRx59w1EJs0AX4Aa15vrPNgIWJrtQkMjc,8220
-velbusaio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-velbusaio/raw_message.py,sha256=5604X_0Itav6Ts89tXWvXs6sdx_KWRvPvSHjtFjXlMA,4613
-velbusaio/util.py,sha256=eCsGQJ9nuzk_B2skBlv3MsNaMaHDXo1a1qSPjObzXH4,1540
-velbusaio/messages/__init__.py,sha256=7L1ziMh5u5HE62MjzcDRhKVof294puZzKFCbBrqxeqw,5892
-velbusaio/messages/blind_status.py,sha256=3K5JRRn34_N1oQRKNBCkNwWIwhaURYL1ZNZhQZWFnSU,3417
-velbusaio/messages/bus_active.py,sha256=7aSGEASI4WxWZV9HI6P1b_p6wU1UvbJYmT90Hz_I8ls,748
-velbusaio/messages/bus_error_counter_status.py,sha256=GYMAxyIHUZLzse-pzyUgegLMY75ptFLKNP5qADbuNFg,1177
-velbusaio/messages/bus_error_counter_status_request.py,sha256=9Y-yW4Z8FPPbn-ky5JTxGkt6NQg7ISDQVHPaVnm7P4U,702
-velbusaio/messages/bus_off.py,sha256=SUi9lOp8BNwl6aWacjp1TC0xcleTKSQt1sM8yWUoeGg,678
-velbusaio/messages/channel_name_part1.py,sha256=TiziwJb7idwi7YeAxDVGMVrG1VPRrBnCswMZZXA0V4w,2577
-velbusaio/messages/channel_name_part2.py,sha256=YUQFBvSRkft79FSRNGd3-gV2hpiDx11TgyNH65IcG1w,2577
-velbusaio/messages/channel_name_part3.py,sha256=46LiGIwm0HKTwd7CMfKFUv5xjebAK85uQwopAlBEYjY,2578
-velbusaio/messages/channel_name_request.py,sha256=11HK4IDjJOg_K57ssEZ5ZAV-P0y5ysjJVUX_3di3uTk,2363
-velbusaio/messages/clear_led.py,sha256=O5InexnnPpzJcmKBfVVILTtIZ7ojljJ2xn-hRXRP8cM,911
-velbusaio/messages/counter_status.py,sha256=FW1Vaf3U-Mp5Zg--HcBs24Oh739sZ00EocFaeF5Maf4,1239
-velbusaio/messages/counter_status_request.py,sha256=0SeJemPRheX5k1DjZlnvaY0dWhHBVqh4d60kMe8RVxc,918
-velbusaio/messages/cover_down.py,sha256=r1PzvwyhmMF5BiKlxQELBwsdqVqSW_9lPYO0B_4O0WU,2551
-velbusaio/messages/cover_off.py,sha256=a8a1iRQwcEycQQvyjMjRHTeWoSHejjBAJiiQtkzf5SQ,2257
-velbusaio/messages/cover_position.py,sha256=UsBaENP1x61iTQTx8oPTH6GS1iwI8g0xah-b5hnxbwg,1282
-velbusaio/messages/cover_up.py,sha256=-P6Ze1OUDSs-YTqFPV0Tl3_EpCL97OJ2CeFB1ZDsLgk,2546
-velbusaio/messages/dali_device_settings.py,sha256=JeiUGw5oPPQde7buNz0T7euZ-QJVxmtTZF2DYVJxFsM,4855
-velbusaio/messages/dali_device_settings_request.py,sha256=3IqaXOxqidJCJ1FxFMDofaXiX75SCgFcPyOQk0p6L_Q,1461
-velbusaio/messages/dali_dim_value_status.py,sha256=V2Fs8CZNihIi9ZxQs7Bxkt9qCInFXxMZnF6vKhIUCnQ,1044
-velbusaio/messages/dimmer_channel_status.py,sha256=nJ_83uVe0FIiwWmGt7XNXcRYu3ikNUwxOOg5nHzaOPw,2470
-velbusaio/messages/dimmer_status.py,sha256=QwWbVoCLndhymsOcj-jw0scqUuQRU3m6J6q1FwgNgn4,2937
-velbusaio/messages/edge_set_color.py,sha256=enwPshhNrleAQQwc3RobPt5foZ1ynE_74SlBEuzd86w,3305
-velbusaio/messages/edge_set_custom_color.py,sha256=fw4hQTrTxNBb63XLTY9iLFtPYrNh0mAAE28DCxG9h1A,1337
-velbusaio/messages/fast_blinking_led.py,sha256=Q5scu34RQJZ43EDZCR1kJy63gULSWHN5bpKpqo_XOOc,908
-velbusaio/messages/forced_off.py,sha256=QQiwMbVUW6wegyTLrf1daJiS8KggPXZvepGsBU9_FUo,590
-velbusaio/messages/forced_on.py,sha256=tS7dUayO_0Grco5TfiOMWBUOc0CY44w_7FcpU-ZViJU,589
-velbusaio/messages/interface_status_request.py,sha256=2vAbB2Qha3pp1ZLepM8TWJyPkX_6I_lmGBIKxJxfajU,694
-velbusaio/messages/ir_receiver_status.py,sha256=_STATc_X7R4o-uyG5iQyyasyB_Np6ubkNi__5w_IeT0,374
-velbusaio/messages/kwh_status.py,sha256=K4twkBx-XhdmqAhnAZ6xuHX4kiNQuhDQl5JHDnxdlnQ,1413
-velbusaio/messages/light_value_request.py,sha256=sF7YYlbTESEBp05bygcLVpjFpejM9m-N8sbL_hDUPO0,598
-velbusaio/messages/memo_text.py,sha256=yg7Qc4mHWoclMN9Rk6L_lCmh_NjPTdwSvkAYalUY0Vw,1030
-velbusaio/messages/memory_data.py,sha256=ZTf8R8r8LpaBg2KOK8CnQJ8RU6gH2DEWfr7phqY5pjE,1030
-velbusaio/messages/memory_data_block.py,sha256=VdZ3s1f3xRgaMRqbceLgByEjoRPSaDU82BLdGQXUvc8,1044
-velbusaio/messages/memory_dump_request.py,sha256=g8jWuy3IwqG6UvTz2_eVng1e0TAPy8XF3Mt6u0l5GVU,698
-velbusaio/messages/module_status.py,sha256=PLsmTheV-fTGHc5FhrzNXMxvGKP8EeYFjadY07ENOn0,6399
-velbusaio/messages/module_status_request.py,sha256=Iv9Y2UXzPFyz3FiL0yH-o231S5_dOfv9z72AYgEjLjM,960
-velbusaio/messages/module_subtype.py,sha256=aDoXFR6fnVFitPLnB9RNLnR4S_t4MZP1uoMMzg4JfB0,1463
-velbusaio/messages/module_type.py,sha256=2VhKxtPF_8VKPsyWGUvBcwTlxVIxgNnRi5HVYdAAwgU,4115
-velbusaio/messages/module_type_request.py,sha256=v8LBuPG_nxvh2lid9XG254M522PN-zSVezEMCOLrGis,753
-velbusaio/messages/push_button_status.py,sha256=AkhZJ5xhMjWDKidOffLZewIi8qWDTu7q8qt4joNenIw,1553
-velbusaio/messages/raw.py,sha256=m7xaGhDqmvHxy0UzWC4gijAbkqXkNEdfrsKRDKWX1JM,1963
-velbusaio/messages/read_data_block_from_memory.py,sha256=Z3hacc_wHtgkkeA3ZsfJv-1xTIt73M5AKbvggZdZtew,974
-velbusaio/messages/read_data_from_memory.py,sha256=I__kKm8xcoQz6e5DKr8G3w3NnpXfuv0a3Fn_EIg0Tw4,977
-velbusaio/messages/realtime_clock_status_request.py,sha256=KEvcmWlgN4XbpHSA90fg3RFVU2bsNGq6sfugw9IbdTg,607
-velbusaio/messages/receive_buffer_full.py,sha256=dgyzmZ8VxhQk8r4vUs2uWuojut2Akj4IMazkqfDa1e4,857
-velbusaio/messages/receive_ready.py,sha256=f1LdUVcUTG7rj71wCVHgF03zbkIx4CpJKG7zgXIERf4,686
-velbusaio/messages/relay_status.py,sha256=BBJHM54gzbOTAoQ_N8ls3IiJoOIklKFCvBU4odntXvM,2836
-velbusaio/messages/restore_dimmer.py,sha256=Xk3GqthYwqCMc6rPXCCc5EXWoXZWpWrk1r8nevfdfso,1783
-velbusaio/messages/select_program.py,sha256=RHvOvWXC7w8wxMhco0NUDPIMK6r6Q2LCd87Kdnl7hxI,834
-velbusaio/messages/sensor_settings_request.py,sha256=njSYjNTxhNyRKJLP7wexaWHnYiSWbrSlOm_F7myuBdw,818
-velbusaio/messages/sensor_temp_request.py,sha256=R-VNtqqiDbgZjPNfj5nE0_bTuGLD74Zy-FUsrCcyXFI,598
-velbusaio/messages/sensor_temperature.py,sha256=Erh7pIrbxpmurg3x9_di6A6Os_2Sgpid7T6LgHuWQyA,1557
-velbusaio/messages/set_date.py,sha256=aV8qO3kJsIMsLZPwVZB5PKivBVa7YHpottj6sTgUSiM,1459
-velbusaio/messages/set_daylight_saving.py,sha256=bpP4BN-uyFIRt4Y6finaaYBIzI08A5AVsUFJfnpxzkg,1117
-velbusaio/messages/set_dimmer.py,sha256=gS3Bm6BvKj9ZnHDOGwTzrEGukXnoPVkAQCRwLOG-E9Q,1936
-velbusaio/messages/set_led.py,sha256=hNmbmS2hXqTBVfXMWYhyf10-BOvd5ZwimMd74Cyj5PQ,899
-velbusaio/messages/set_realtime_clock.py,sha256=2EVdIKLB0M1syBZyIpD-vxiEJMriqElxnw3cO773Nw4,1308
-velbusaio/messages/set_temperature.py,sha256=PMs_uXWMhggIX0s2ikediwTJ4WSpvrXzahCJ0Ak_hks,958
-velbusaio/messages/slider_status.py,sha256=poNQY8hvdTVqD0qfLxvmp-w3js2MVozTLR657cZOI8o,1393
-velbusaio/messages/slow_blinking_led.py,sha256=a5Kpbx_IAYzOoahkgaqcc61j3ecFjy6fT9Dox6BlUiM,908
-velbusaio/messages/start_relay_blinking_timer.py,sha256=KdTqYxXquPn07_Con_vSfbi7KthdsUv4SwkxJj2MEGk,1297
-velbusaio/messages/start_relay_timer.py,sha256=fhaIJrVOP2MrIpzzlswyENC4XwhS8YOgr4p6rShSYyA,1289
-velbusaio/messages/switch_relay_off.py,sha256=nTE-l9_lpvxneq1txoTrX_C-gJ2aDQ-0czqd8JLwNts,1098
-velbusaio/messages/switch_relay_on.py,sha256=Vj4tjTCrK7CBRJBFnF81fAp0qFWGqX_JAeeioV3x9aE,1097
-velbusaio/messages/switch_to_comfort.py,sha256=9NuqVHwrWLsFUmx2ayra_0oubc5ovKTAawoG44w61h8,790
-velbusaio/messages/switch_to_day.py,sha256=ZqUdZkZDtZsUsZNLj08G3PlJ8jd6H0uos8vdnivPwwg,786
-velbusaio/messages/switch_to_night.py,sha256=FhoKB-a7TWQLm3MsLJ-5ttUNVgT9CIvS-HogrF1MZTg,788
-velbusaio/messages/switch_to_safe.py,sha256=DD8z7QwFU0Z_f2OT9ANjPfu7jLNKktqaID6nUce3K-U,787
-velbusaio/messages/temp_sensor_settings_part1.py,sha256=QDAQDmdpJNWNWRqigtkDzAYmy4lxo7ZtX4CuThwUOb0,604
-velbusaio/messages/temp_sensor_settings_part2.py,sha256=kQBlvVBroETdZjxz-oB6nAJlImbwGBNPhJVArDf26-M,583
-velbusaio/messages/temp_sensor_settings_part3.py,sha256=_HugqJ5wVj84TCBC_4Y3NcdUNVE4SevIW9uskiAKKWs,583
-velbusaio/messages/temp_sensor_settings_part4.py,sha256=GxxW8VttzeYlSgLAdkCFkMvIm5Q_Mzgy10WLgSXKhxA,583
-velbusaio/messages/temp_sensor_settings_request.py,sha256=YSKKGjqAbeBbtmstPg5tCaEbXIRI5i_2NustkXIm7wY,606
-velbusaio/messages/temp_sensor_status.py,sha256=rMHQ3-I9jMWn1fE2xjmaoSRoXfBA4JxccR5XQ92J71w,3827
-velbusaio/messages/temp_set_cooling.py,sha256=9HyGzdcr5R-EoXvem8Ajgx8_12WB7yUYUcvVxZXqT-8,723
-velbusaio/messages/temp_set_heating.py,sha256=F0B1RsQNdq7F25z3Sure6Hobph-HJVglOhK7K-lHQFE,723
-velbusaio/messages/update_led_status.py,sha256=1b4gWqmmtAYUAeaoJdkda_zlW02lLwsIPoXMRGD8OCg,1300
-velbusaio/messages/very_fast_blinking_led.py,sha256=3gB3TYXFFUdna_VaGrfSWGpOpX2iOu_8i5L9qQ2YG1s,912
-velbusaio/messages/write_data_to_memory.py,sha256=2bC-vuv_RK3hGxvKeba1zR405ffj-CkYh3hJ9LVEaME,1038
-velbusaio/messages/write_memory_block.py,sha256=5pP4hCRV7tc5xYxHO_51t-uCYgNtVHiaPic_ZGG2Y9s,1031
-velbusaio/messages/write_module_address_and_serial_number.py,sha256=gU-yAHxICP6LPQX7BRj-WUfiVpTk0sV1CMlXeElAwl4,1596
-velbusaio/moduleprotocol/protocol.json,sha256=zChwegR8Ic_Msw5iVMV_W3kVmSyK5DwYof46wD7l9H8,883766
-velbus_aio-2023.12.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-velbus_aio-2023.12.0.dist-info/METADATA,sha256=nl4xVLuNrlqrwm2OcgO0V1tkXSFJZ31P2QmYgeIvb0Q,3079
-velbus_aio-2023.12.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-velbus_aio-2023.12.0.dist-info/top_level.txt,sha256=W0-lSOwD23mm8FqaIe9vY20fKicBMIdUVjF-zmfxRnY,15
-velbus_aio-2023.12.0.dist-info/RECORD,,