ramses-rf 0.53.3__tar.gz → 0.53.4__tar.gz

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/.github/workflows/check-cov.yml

@@ -89,7 +89,7 @@ jobs:
           hide_complexity: true
           indicators: true
           output: both
-          thresholds: '80 90'
+          thresholds: '80 95'
 
       - name: Add Coverage PR Comment
         # from: https://github.com/marketplace/actions/comment-pull-request

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/.pre-commit-config.yaml

@@ -14,7 +14,7 @@ repos:
       # Run `python-typing-update` hook manually from time to time
       # to update python typing syntax.
       # Will require manual work, before submitting changes!
-      # pre-commit run --hook-stage manual python-typing-update --all-files
+      # prek run --hook-stage manual python-typing-update --all-files
       - id: python-typing-update
         stages: [manual]
         args:
@@ -39,6 +39,10 @@ repos:
     hooks:
       - id: check-executables-have-shebangs
       # id: check-json  # don't enable this one
+      # - id: no-commit-to-branch
+      #   args:
+      #     - --branch=master
+      #     - --branch=stable
       - id: check-toml
       - id: check-yaml
       - id: debug-statements

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ramses_rf
-Version: 0.53.3
+Version: 0.53.4
 Summary: A stateful RAMSES-II protocol decoder & analyser.
 Project-URL: Homepage, https://github.com/ramses-rf/ramses_rf
 Project-URL: Bug Tracker, https://github.com/ramses-rf/ramses_rf/issues

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/pyproject.toml

@@ -116,7 +116,7 @@
     "raise NotImplementedError",
   ]
   format = "text"
-  fail_under = 75
+  fail_under = 80  # total cov now 83%
   ignore_errors = true
 
 [tool.coverage.html]

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/ramses_cli/client.py

@@ -471,13 +471,8 @@ def print_results(gwy: Gateway, **kwargs: Any) -> None:
         system_id, _ = kwargs[GET_SCHED]
 
 
-def _save_state(gwy: Gateway) -> None:
-    """Save the gateway state to files.
-
-    :param gwy: The gateway instance.
-    """
-    schema, msgs = gwy.get_state()
-
+def _write_state(schema: dict[str, Any], msgs: dict[str, str]) -> None:
+    """Write the state to the file system (blocking)."""
     with open("state_msgs.log", "w") as f:
         [f.write(f"{dtm} {pkt}\r\n") for dtm, pkt in msgs.items()]  # if not m._expired
 
@@ -485,13 +480,22 @@ def _save_state(gwy: Gateway) -> None:
         f.write(json.dumps(schema, indent=4))
 
 
-def _print_engine_state(gwy: Gateway, **kwargs: Any) -> None:
+async def _save_state(gwy: Gateway) -> None:
+    """Save the gateway state to files.
+
+    :param gwy: The gateway instance.
+    """
+    schema, msgs = await gwy.get_state()
+    await asyncio.to_thread(_write_state, schema, msgs)
+
+
+async def _print_engine_state(gwy: Gateway, **kwargs: Any) -> None:
     """Print the current engine state (schema and packets).
 
     :param gwy: The gateway instance.
     :param kwargs: Command arguments to determine verbosity.
     """
-    (schema, packets) = gwy.get_state(include_expired=True)
+    (schema, packets) = await gwy.get_state(include_expired=True)
 
     if kwargs["print_state"] > 0:
         print(f"schema: {json.dumps(schema, indent=4)}\r\n")
@@ -671,10 +675,10 @@ async def async_main(command: str, lib_kwargs: dict[str, Any], **kwargs: Any) ->
     print(f"\r\nclient.py: Engine stopped: {msg}")
 
     # if kwargs["save_state"]:
-    #    _save_state(gwy)
+    #    await _save_state(gwy)
 
     if kwargs["print_state"]:
-        _print_engine_state(gwy, **kwargs)
+        await _print_engine_state(gwy, **kwargs)
 
     elif command == EXECUTE:
         print_results(gwy, **kwargs)

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/ramses_rf/gateway.py

@@ -267,12 +267,14 @@ class Gateway(Engine):
         :returns: None
         :rtype: None
         """
+        # Stop the Engine first to ensure no tasks/callbacks try to write
+        # to the DB while we are closing it.
+        await super().stop()
 
         if self.msg_db:
             self.msg_db.stop()
-        await super().stop()
 
-    def _pause(self, *args: Any) -> None:
+    async def _pause(self, *args: Any) -> None:
         """Pause the (unpaused) gateway (disables sending/discovery).
 
         There is the option to save other objects, as `args`.
@@ -288,12 +290,12 @@ class Gateway(Engine):
         self.config.disable_discovery, disc_flag = True, self.config.disable_discovery
 
         try:
-            super()._pause(disc_flag, *args)
+            await super()._pause(disc_flag, *args)
         except RuntimeError:
             self.config.disable_discovery = disc_flag
             raise
 
-    def _resume(self) -> tuple[Any]:
+    async def _resume(self) -> tuple[Any]:
         """Resume the (paused) gateway (enables sending/discovery, if applicable).
 
         Will restore other objects, as `args`.
@@ -305,11 +307,13 @@ class Gateway(Engine):
 
         _LOGGER.debug("Gateway: Resuming engine...")
 
-        self.config.disable_discovery, *args = super()._resume()  # type: ignore[assignment]
+        # args_tuple = await super()._resume()
+        # self.config.disable_discovery, *args = args_tuple  # type: ignore[assignment]
+        self.config.disable_discovery, *args = await super()._resume()  # type: ignore[assignment]
 
         return args
 
-    def get_state(
+    async def get_state(
         self, include_expired: bool = False
     ) -> tuple[dict[str, Any], dict[str, str]]:
         """Return the current schema & state (may include expired packets).
@@ -320,7 +324,7 @@ class Gateway(Engine):
         :rtype: tuple[dict[str, Any], dict[str, str]]
         """
 
-        self._pause()
+        await self._pause()
 
         def wanted_msg(msg: Message, include_expired: bool = False) -> bool:
             if msg.code == Code._313F:
@@ -357,7 +361,7 @@ class Gateway(Engine):
             }
             # _LOGGER.warning("Missing MessageIndex")
 
-        self._resume()
+        await self._resume()
 
         return self.schema, dict(sorted(pkts.items()))
 
@@ -392,7 +396,7 @@ class Gateway(Engine):
         tmp_transport: RamsesTransportT  # mypy hint
 
         _LOGGER.debug("Gateway: Restoring a cached packet log...")
-        self._pause()
+        await self._pause()
 
         if _clear_state:  # only intended for test suite use
             clear_state()
@@ -428,7 +432,7 @@ class Gateway(Engine):
         await tmp_transport.get_extra_info(SZ_READER_TASK)
 
         _LOGGER.debug("Gateway: Restored, resuming")
-        self._resume()
+        await self._resume()
 
     def _add_device(self, dev: Device) -> None:  # TODO: also: _add_system()
         """Add a device to the gateway (called by devices during instantiation).

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/ramses_rf/version.py

@@ -1,4 +1,4 @@
 """RAMSES RF - a RAMSES-II protocol decoder & analyser (application layer)."""
 
-__version__ = "0.53.3"
+__version__ = "0.53.4"
 VERSION = __version__

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/ramses_tx/gateway.py

@@ -12,7 +12,6 @@ import asyncio
 import logging
 from collections.abc import Callable
 from datetime import datetime as dt
-from threading import Lock
 from typing import TYPE_CHECKING, Any, Never
 
 from .address import ALL_DEV_ADDR, HGI_DEV_ADDR, NON_DEV_ADDR
@@ -120,7 +119,7 @@ class Engine:
         self._log_all_mqtt = kwargs.pop(SZ_LOG_ALL_MQTT, False)
         self._kwargs: dict[str, Any] = kwargs  # HACK
 
-        self._engine_lock = Lock()  # FIXME: threading lock, or asyncio lock?
+        self._engine_lock = asyncio.Lock()
         self._engine_state: (
             tuple[_MsgHandlerT | None, bool | None, *tuple[Any, ...]] | None
         ) = None
@@ -217,15 +216,13 @@ class Engine:
     async def stop(self) -> None:
         """Close the transport (will stop the protocol)."""
 
-        async def cancel_all_tasks() -> None:  # TODO: needs a lock?
-            _ = [t.cancel() for t in self._tasks if not t.done()]
-            try:  # FIXME: this is broken
-                if tasks := (t for t in self._tasks if not t.done()):
-                    await asyncio.gather(*tasks)
-            except asyncio.CancelledError:
-                pass
+        # Shutdown Safety - wait for tasks to clean up
+        tasks = [t for t in self._tasks if not t.done()]
+        for t in tasks:
+            t.cancel()
 
-        await cancel_all_tasks()
+        if tasks:
+            await asyncio.wait(tasks)
 
         if self._transport:
             self._transport.close()
@@ -233,12 +230,14 @@ class Engine:
 
         return None
 
-    def _pause(self, *args: Any) -> None:
+    async def _pause(self, *args: Any) -> None:
         """Pause the (active) engine or raise a RuntimeError."""
-
-        if not self._engine_lock.acquire(blocking=False):
+        # Async lock handling
+        if self._engine_lock.locked():
             raise RuntimeError("Unable to pause engine, failed to acquire lock")
 
+        await self._engine_lock.acquire()
+
         if self._engine_state is not None:
             self._engine_lock.release()
             raise RuntimeError("Unable to pause engine, it is already paused")
@@ -255,13 +254,18 @@ class Engine:
 
         self._engine_state = (handler, read_only, *args)
 
-    def _resume(self) -> tuple[Any]:  # FIXME: not atomic
+    async def _resume(self) -> tuple[Any]:  # FIXME: not atomic
         """Resume the (paused) engine or raise a RuntimeError."""
 
         args: tuple[Any]  # mypy
 
-        if not self._engine_lock.acquire(timeout=0.1):
-            raise RuntimeError("Unable to resume engine, failed to acquire lock")
+        # Async lock with timeout
+        try:
+            await asyncio.wait_for(self._engine_lock.acquire(), timeout=0.1)
+        except TimeoutError as err:
+            raise RuntimeError(
+                "Unable to resume engine, failed to acquire lock"
+            ) from err
 
         if self._engine_state is None:
             self._engine_lock.release()

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/ramses_tx/transport.py

@@ -49,7 +49,6 @@ import logging
 import os
 import re
 import sys
-import time
 from collections import deque
 from collections.abc import Awaitable, Callable, Iterable
 from datetime import datetime as dt, timedelta as td
@@ -979,18 +978,21 @@ class FileTransport(_ReadTransport, _FileTransportAbstractor):
         if bool(disable_sending) is False:
             raise exc.TransportSourceInvalid("This Transport cannot send packets")
 
+        self._evt_reading = asyncio.Event()
+
         self._extra[SZ_READER_TASK] = self._reader_task = self._loop.create_task(
             self._start_reader(), name="FileTransport._start_reader()"
         )
 
         self._make_connection(None)
 
-    async def _start_reader(self) -> None:  # TODO
+    async def _start_reader(self) -> None:
         """Start the reader task."""
         self._reading = True
+        self._evt_reading.set()  # Start in reading state
+
         try:
-            # await self._reader()
-            await self.loop.run_in_executor(None, self._blocking_reader)
+            await self._producer_loop()
         except Exception as err:
             self.loop.call_soon_threadsafe(
                 functools.partial(self._protocol.connection_lost, err)  # type: ignore[arg-type]
@@ -1000,47 +1002,59 @@ class FileTransport(_ReadTransport, _FileTransportAbstractor):
                 functools.partial(self._protocol.connection_lost, None)
             )
 
-    def _blocking_reader(self) -> None:
+    def pause_reading(self) -> None:
+        """Pause the receiving end (no data to protocol.pkt_received())."""
+        self._reading = False
+        self._evt_reading.clear()  # Puts the loop to sleep efficiently
+
+    def resume_reading(self) -> None:
+        """Resume the receiving end."""
+        self._reading = True
+        self._evt_reading.set()  # Wakes the loop immediately
+
+    async def _producer_loop(self) -> None:
         """Loop through the packet source for Frames and process them."""
+        # NOTE: fileinput interaction remains synchronous-blocking for simplicity,
+        # but the PAUSE mechanism is now async-non-blocking.
 
         if isinstance(self._pkt_source, dict):
             for dtm_str, pkt_line in self._pkt_source.items():  # assume dtm_str is OK
-                self._process_line(dtm_str, pkt_line)
+                await self._process_line(dtm_str, pkt_line)
 
         elif isinstance(self._pkt_source, str):  # file_name, used in client parse
             # open file file_name before reading
             try:
                 with fileinput.input(files=self._pkt_source, encoding="utf-8") as file:
                     for dtm_pkt_line in file:  # self._pkt_source:
-                        self._process_line_from_raw(dtm_pkt_line)
+                        await self._process_line_from_raw(dtm_pkt_line)
             except FileNotFoundError as err:
                 _LOGGER.warning(f"Correct the packet file name; {err}")
 
         elif isinstance(self._pkt_source, TextIOWrapper):  # used by client monitor
             for dtm_pkt_line in self._pkt_source:  # should check dtm_str is OK
-                self._process_line_from_raw(dtm_pkt_line)
+                await self._process_line_from_raw(dtm_pkt_line)
 
         else:
             raise exc.TransportSourceInvalid(
                 f"Packet source is not dict, TextIOWrapper or str: {self._pkt_source:!r}"
             )
 
-    def _process_line_from_raw(self, line: str) -> None:
+    async def _process_line_from_raw(self, line: str) -> None:
         """Helper to process raw lines."""
         # there may be blank lines in annotated log files
         if (line := line.strip()) and line[:1] != "#":
-            self._process_line(line[:26], line[27:])
+            await self._process_line(line[:26], line[27:])
             # this is where the parsing magic happens!
 
-    def _process_line(self, dtm_str: str, frame: str) -> None:
+    async def _process_line(self, dtm_str: str, frame: str) -> None:
         """Push frame to protocol in a thread-safe way."""
-        while not self._reading:
-            time.sleep(0.001)
+        # Efficient wait - 0% CPU usage while paused
+        await self._evt_reading.wait()
 
         self._frame_read(dtm_str, frame)
 
-        # NOTE: instable without, big performance penalty if delay >0
-        time.sleep(0)
+        # Yield control to the event loop to prevent starvation during large file reads
+        await asyncio.sleep(0)
 
     def _close(self, exc: exc.RamsesException | None = None) -> None:
         """Close the transport (cancel any outstanding tasks).

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/ramses_tx/version.py

@@ -1,4 +1,4 @@
 """RAMSES RF - a RAMSES-II protocol decoder & analyser (transport layer)."""
 
-__version__ = "0.53.3"
+__version__ = "0.53.4"
 VERSION = __version__

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/requirements/requirements_dev.txt

@@ -1,5 +1,5 @@
 # Requirements to dev/test the source code
-# - last checked/updated: 2026-01-11 (c.f. HA 2026.1.0)
+# - last checked/updated: 2026-01-22 (c.f. 0.53.4 / HA 2026.1.2)
 # - HA core reqs: https://github.com/home-assistant/core/blob/dev/requirements.txt
 
 # for using the ramses_rf library with CLI
@@ -10,7 +10,8 @@
 # - pip list | grep -E 'pre-commit|ruff|mypy|types-|voluptuous|pytest|hatch'
 
 # used for development (linting)
-  pre-commit >= 4.2.0                            # HA (core) uses 4.2.0
+  prek == 0.2.28                                 # same as ramses_cc and HA core 2026.1.2
+  # pre-commit >= 4.3.0                          # replaced by prek since 2026.1
   ruff >= 0.13.0                                 # HA uses 0.13.0 ! also in: pre-commit-config.yaml
 
 # used for development (typing)
@@ -25,6 +26,7 @@
   pytest-cov >= 7.0.0                            # HA uses 6.2.1, includes coverage.py as dep
   pytest-sugar >= 1.0.0                          # HA uses 1.0.0
   pytest-xdist >= 3.8.0                          # HA uses 3.8.0
+  PyYAML                                         # required for tests/tests/test_vol_schema import
 # syrupy >= 4.8.1                                # HA uses 4.9.1
 
 # used for build/deploy

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/tests/tests/test_eavesdrop_schema.py

@@ -25,7 +25,7 @@ def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
 async def assert_schemas_equal(gwy: Gateway, expected_schema: dict) -> None:
     """Check the gwy schema, then shuffle and test again."""
 
-    schema, packets = gwy.get_state(include_expired=True)
+    schema, packets = await gwy.get_state(include_expired=True)
     assert_expected(schema, expected_schema)
 
     packets = shuffle_dict(packets)

{ramses_rf-0.53.3 → ramses_rf-0.53.4}/tests/tests/test_schemas.py

@@ -8,7 +8,6 @@ import pytest
 
 from ramses_rf import Gateway
 from ramses_rf.helpers import shrink
-from ramses_rf.schemas import load_schema
 
 from .helpers import (
     TEST_DIR,
@@ -33,7 +32,7 @@ async def test_schema_discover_from_log(f_name: Path) -> None:
         assert shrink(gwy.schema) == shrink(schema)
 
         gwy.ser_name = "/dev/null"  # HACK: needed to pause engine
-        schema, packets = gwy.get_state(include_expired=True)
+        schema, packets = await gwy.get_state(include_expired=True)
         packets = shuffle_dict(packets)
         await gwy._restore_cached_packets(packets)
 
@@ -42,16 +41,11 @@ async def test_schema_discover_from_log(f_name: Path) -> None:
     await gwy.stop()
 
 
-@pytest.mark.parametrize(
-    "f_name", [f.stem for f in Path(f"{WORK_DIR}/jsn_files").glob("*.json")]
-)
-async def test_schema_load_from_json(gwy: Gateway, f_name: Path) -> None:  # noqa: F811
-    with open(f"{WORK_DIR}/jsn_files/{f_name}.json") as f:
-        schema = json.load(f)
-
-    load_schema(gwy, **schema)
+# def test_schema_load_from_json(f_name: Path) -> None:
+#     path = f"{WORK_DIR}/jsn_files/{f_name}.json"
+#     gwy = Gateway(None, input_file=path, config={})  # noqa: F811
 
-    # print(json.dumps(schema, indent=4))
-    # print(json.dumps(self.gwy.schema, indent=4))
+#     with open(f"{WORK_DIR}/jsn_files/{f_name}.json") as f:
+#         schema = json.load(f)
 
-    assert shrink(gwy.schema) == shrink(schema)
+#     load_schema(gwy, schema)