ramses-rf 0.53.5__tar.gz → 0.53.6__tar.gz

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/.github/workflows/check-lint.yml

@@ -1,5 +1,7 @@
 name: Linting
 
+permissions:  ## security hint
+  contents: read
 
 on:
   push:

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/.github/workflows/check-test.yml

@@ -1,5 +1,7 @@
 name: Testing
 
+permissions:
+  contents: read
 
 on:
   push:

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/.github/workflows/check-type.yml

@@ -1,5 +1,7 @@
 name: Typing
 
+permissions:
+  contents: read
 
 on:
   push:

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ramses_rf
-Version: 0.53.5
+Version: 0.53.6
 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
@@ -62,11 +62,11 @@ To install the `ramses_rf` command line client:
 ```
 git clone https://github.com/ramses-rf/ramses_rf
 cd ramses_rf
-pip install -r requirements.txt
+pip install -r requirements/requirements.txt
 pip install -e .
 ```
 
-The CLI is called ``client.py`` and is included in the code root.
+The CLI is called `client.py` and is included in the code root.
 It has options to monitor and parse Ramses-II traffic to screen or a log file, and to parse a file containing Ramses-II messages to the screen.
 See the [client.py CLI wiki page](https://github.com/ramses-rf/ramses_rf/wiki/2.-The-client.py-command-line) for instructions.
 

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/README.md

@@ -41,11 +41,11 @@ To install the `ramses_rf` command line client:
 ```
 git clone https://github.com/ramses-rf/ramses_rf
 cd ramses_rf
-pip install -r requirements.txt
+pip install -r requirements/requirements.txt
 pip install -e .
 ```
 
-The CLI is called ``client.py`` and is included in the code root.
+The CLI is called `client.py` and is included in the code root.
 It has options to monitor and parse Ramses-II traffic to screen or a log file, and to parse a file containing Ramses-II messages to the screen.
 See the [client.py CLI wiki page](https://github.com/ramses-rf/ramses_rf/wiki/2.-The-client.py-command-line) for instructions.
 

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/ramses_rf/dispatcher.py

@@ -270,7 +270,11 @@ def process_msg(gwy: Gateway, msg: Message) -> None:
         )
 
     except (AttributeError, LookupError, TypeError, ValueError) as err:
-        _LOGGER.exception("%s < %s(%s)", msg._pkt, err.__class__.__name__, err)
+        if getattr(gwy.config, "enforce_strict_handling", False):
+            raise
+        _LOGGER.warning(
+            "%s < %s(%s)", msg._pkt, err.__class__.__name__, err, exc_info=True
+        )
 
     else:
         logger_xxxx(msg)

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/ramses_rf/schemas.py

@@ -245,6 +245,7 @@ SCH_GLOBAL_SCHEMAS = vol.Schema(SCH_GLOBAL_SCHEMAS_DICT, extra=vol.PREVENT_EXTRA
 # 4/7: Gateway (parser/state) configuration
 SZ_DISABLE_DISCOVERY: Final = "disable_discovery"
 SZ_ENABLE_EAVESDROP: Final = "enable_eavesdrop"
+SZ_ENFORCE_STRICT_HANDLING: Final = "enforce_strict_handling"
 SZ_MAX_ZONES: Final = "max_zones"  # TODO: move to TCS-attr from GWY-layer
 SZ_REDUCE_PROCESSING: Final = "reduce_processing"
 SZ_USE_ALIASES: Final = "use_aliases"  # use friendly device names from known_list
@@ -253,6 +254,7 @@ SZ_USE_NATIVE_OT: Final = "use_native_ot"  # favour OT (3220s) over RAMSES
 SCH_GATEWAY_DICT = {
     vol.Optional(SZ_DISABLE_DISCOVERY, default=False): bool,
     vol.Optional(SZ_ENABLE_EAVESDROP, default=False): bool,
+    vol.Optional(SZ_ENFORCE_STRICT_HANDLING, default=False): bool,
     vol.Optional(SZ_MAX_ZONES, default=DEFAULT_MAX_ZONES): vol.All(
         int, vol.Range(min=1, max=16)
     ),  # NOTE: no default

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/ramses_rf/version.py

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

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/ramses_tx/protocol_fsm.py

@@ -145,13 +145,20 @@ class ProtocolContext:
             # nope, was not successful, so multiplier should be incremented...
             self._multiplier = min(3, old_val + 1)
 
+            if self._cmd_tx_count < 3:
+                level = logging.DEBUG
+            elif self._cmd_tx_count == 3:
+                level = logging.INFO
+            else:
+                level = logging.WARNING
+
             if isinstance(self._state, WantEcho):
-                _LOGGER.warning(
-                    f"Timeout expired waiting for echo: {self} (delay={delay})"
+                _LOGGER.log(
+                    level, f"Timeout expired waiting for echo: {self} (delay={delay})"
                 )
             else:  # isinstance(self._state, WantRply):
-                _LOGGER.warning(
-                    f"Timeout expired waiting for reply: {self} (delay={delay})"
+                _LOGGER.log(
+                    level, f"Timeout expired waiting for reply: {self} (delay={delay})"
                 )
 
             assert isinstance(self.is_sending, bool), (

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/ramses_tx/schemas.py

@@ -407,6 +407,7 @@ def select_device_filter_mode(
 # 5/5: Gateway (engine) configuration
 
 SZ_DISABLE_SENDING: Final = "disable_sending"
+SZ_AUTOSTART: Final = "autostart"
 SZ_DISABLE_QOS: Final = "disable_qos"
 SZ_ENFORCE_KNOWN_LIST: Final[str] = f"enforce_{SZ_KNOWN_LIST}"
 SZ_EVOFW_FLAG: Final = "evofw_flag"
@@ -418,6 +419,7 @@ SZ_USE_REGEX: Final = "use_regex"
 
 SCH_ENGINE_DICT = {
     vol.Optional(SZ_DISABLE_SENDING, default=False): bool,
+    vol.Optional(SZ_AUTOSTART, default=False): bool,
     vol.Optional(SZ_DISABLE_QOS, default=None): vol.Any(
         None,  # None is selective QoS (e.g. QoS only for bindings, schedule, etc.)
         bool,

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/ramses_tx/transport.py

@@ -1278,8 +1278,9 @@ class PortTransport(_RegHackMixin, _FullTransport, _PortTransportAbstractor):  #
 
         super()._close(exc)
 
-        if self._init_task:
-            self._init_task.cancel()
+        # Use getattr because _init_task may not be set if initialization failed
+        if init_task := getattr(self, "_init_task", None):
+            init_task.cancel()
 
         if self._leaker_task:
             self._leaker_task.cancel()
@@ -1810,6 +1811,7 @@ class CallbackTransport(_FullTransport, _CallbackTransportAbstractor):
         protocol: RamsesProtocolT,
         io_writer: Callable[[str], Awaitable[None]],
         disable_sending: bool = False,
+        autostart: bool = False,
         **kwargs: Any,
     ) -> None:
         """Initialize the callback transport.
@@ -1820,6 +1822,8 @@ class CallbackTransport(_FullTransport, _CallbackTransportAbstractor):
         :type io_writer: Callable[[str], Awaitable[None]]
         :param disable_sending: Whether to disable sending, defaults to False.
         :type disable_sending: bool, optional
+        :param autostart: Whether to start reading immediately, defaults to False.
+        :type autostart: bool, optional
         """
         # Pass kwargs up the chain. _ReadTransport will extract 'loop' if present.
         # _BaseTransport will pass 'loop' to _CallbackTransportAbstractor, which consumes it.
@@ -1834,9 +1838,11 @@ class CallbackTransport(_FullTransport, _CallbackTransportAbstractor):
         # Section 6.1: Object Lifecycle Logging
         _LOGGER.info(f"CallbackTransport created with io_writer={io_writer}")
 
-        # NOTE: connection_made is NOT called here. It must be triggered
-        # externally (e.g. by the Bridge) via the protocol methods once
-        # the external connection is ready.
+        # Handshake: Notify protocol immediately (Safe: idempotent)
+        self._protocol.connection_made(self, ramses=True)
+
+        if autostart:
+            self.resume_reading()
 
     async def write_frame(self, frame: str, disable_tx_limits: bool = False) -> None:
         """Process a frame for transmission by passing it to the external writer.
@@ -1879,19 +1885,19 @@ class CallbackTransport(_FullTransport, _CallbackTransportAbstractor):
         :type dtm: str | None, optional
         """
         _LOGGER.debug(
-            f"Received frame from external source: frame='{frame}', timestamp={dtm}"
+            f"Received frame from external source: frame={repr(frame)}, timestamp={dtm}"
         )
 
-        # Section 4.2: Circuit Breaker implementation (Packet gating)
+        # Circuit Breaker implementation (Packet gating)
         if not self._reading:
             _LOGGER.debug(f"Dropping received frame (transport paused): {repr(frame)}")
             return
 
         dtm = dtm or dt_now().isoformat()
 
-        # Section 6.1: Boundary Logging (Incoming)
+        # Boundary Logging (Incoming)
         _LOGGER.debug(
-            f"Ingesting frame into transport: frame='{frame}', timestamp={dtm}"
+            f"Ingesting frame into transport: frame={repr(frame)}, timestamp={dtm}"
         )
 
         # Pass to the standard processing pipeline
@@ -1949,7 +1955,7 @@ async def transport_factory(
     extra: dict[str, Any] | None = None,
     loop: asyncio.AbstractEventLoop | None = None,
     log_all: bool = False,
-    **kwargs: Any,  # HACK: odd/misc params
+    **kwargs: Any,  # HACK: odd/misc params, inc. autostart
 ) -> RamsesTransportT:
     """Create and return a Ramses-specific async packet Transport.
 
@@ -1980,11 +1986,18 @@ async def transport_factory(
     :raises exc.TransportSourceInvalid: If the packet source is invalid or multiple sources are specified.
     """
 
+    # Extract autostart (default to False if missing), used in transport_constructor only
+    autostart = kwargs.pop("autostart", False)
+
     # If a constructor is provided, delegate entirely to it.
     if transport_constructor:
         _LOGGER.debug("transport_factory: Delegating to external transport_constructor")
         return await transport_constructor(
-            protocol, disable_sending=disable_sending, extra=extra, **kwargs
+            protocol,
+            disable_sending=disable_sending,
+            extra=extra,
+            autostart=autostart,  # <--- Pass it explicitly
+            **kwargs,
         )
 
     # kwargs are specific to a transport. The above transports have:

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/ramses_tx/version.py

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

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/requirements/requirements_dev.txt

@@ -10,7 +10,7 @@
 # - pip list | grep -E 'pre-commit|ruff|mypy|types-|voluptuous|pytest|hatch'
 
 # used for development (linting)
-  prek == 0.3.0                                 # same as ramses_cc and HA core 2026.1.2
+  prek == 0.3.1                                 # 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
 

{ramses_rf-0.53.5 → ramses_rf-0.53.6}/tests/tests_rf/test_dispatcher.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
 """RAMSES RF - Unittests for dispatcher."""
 
+import logging
 from collections.abc import Generator
 from datetime import datetime as dt, timedelta as td
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
@@ -25,6 +26,7 @@ def mock_gateway() -> Generator[MagicMock, None, None]:
     gateway.config = MagicMock()
     gateway.config.disable_discovery = False
     gateway.config.enable_eavesdrop = False
+    gateway.config.reduce_processing = 0  # Ensure processing continues by default
     gateway._loop = MagicMock()
     gateway._loop.call_soon = MagicMock()
     gateway._loop.call_later = MagicMock()
@@ -99,3 +101,61 @@ class Test_dispatcher_gateway:
         assert msg1._has_array
         assert dispatcher.detect_array_fragment(msg2, msg1)
         assert not dispatcher.detect_array_fragment(msg3, msg1)
+
+
+class TestDispatcherErrorHandling:
+    """Test Dispatcher exception handling logic."""
+
+    def test_process_msg_strict_mode(self, mock_gateway: MagicMock) -> None:
+        """Test process_msg raises exception in strict mode."""
+        # Enable strict mode
+        mock_gateway.config.enforce_strict_handling = True
+
+        # Create a message with a valid payload for code 0001
+        msg = Message._from_pkt(
+            Packet(
+                dt.now(),
+                "...  I --- 01:000001 --:------ 01:000001 0001 005 00FFFF0200",
+            )
+        )
+
+        # Force a ValueError within process_msg by mocking _check_msg_addrs
+        with (
+            patch(
+                "ramses_rf.dispatcher._check_msg_addrs",
+                side_effect=ValueError("Test Error"),
+            ),
+            pytest.raises(ValueError, match="Test Error"),
+        ):
+            dispatcher.process_msg(mock_gateway, msg)
+
+    def test_process_msg_safe_mode(
+        self, mock_gateway: MagicMock, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Test process_msg logs warning with trace in safe mode."""
+        # Disable strict mode (safe mode)
+        mock_gateway.config.enforce_strict_handling = False
+
+        msg = Message._from_pkt(
+            Packet(
+                dt.now(),
+                "...  I --- 01:000001 --:------ 01:000001 0001 005 00FFFF0200",
+            )
+        )
+
+        # Force a ValueError within process_msg
+        with (
+            patch(
+                "ramses_rf.dispatcher._check_msg_addrs",
+                side_effect=ValueError("Test Error"),
+            ),
+            caplog.at_level(logging.WARNING),
+        ):
+            dispatcher.process_msg(mock_gateway, msg)
+
+        # Assert exception was caught and logged
+        assert "Test Error" in caplog.text
+        # Check that it was logged as a WARNING
+        assert any(r.levelname == "WARNING" for r in caplog.records)
+        # Check that traceback information is present (exc_info=True)
+        assert any(r.exc_info is not None for r in caplog.records)

ramses_rf-0.53.6/tests/tests_tx/test_transport.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Tests for CallbackTransport initialization logic."""
+
+import asyncio
+from typing import Any
+from unittest.mock import AsyncMock, Mock, patch
+
+from ramses_tx.transport import CallbackTransport, transport_factory
+
+
+async def _async_callback_factory(*args: Any, **kwargs: Any) -> CallbackTransport:
+    """Async wrapper for CallbackTransport to satisfy transport_factory signature."""
+    return CallbackTransport(*args, **kwargs)
+
+
+async def test_callback_transport_handshake() -> None:
+    """Test that connection_made is called automatically upon initialization."""
+    mock_protocol = Mock()
+    mock_writer = AsyncMock()
+
+    transport = CallbackTransport(mock_protocol, mock_writer)
+
+    # Assert handshake called immediately
+    mock_protocol.connection_made.assert_called_once_with(transport, ramses=True)
+
+
+async def test_callback_transport_handshake_idempotency() -> None:
+    """Test that manual connection_made calls are safe (idempotent at protocol level)."""
+    mock_protocol = Mock()
+    mock_writer = AsyncMock()
+
+    transport = CallbackTransport(mock_protocol, mock_writer)
+
+    # Verify initial call
+    mock_protocol.connection_made.assert_called_once()
+
+    # Manually call again (simulating legacy consumer behavior)
+    mock_protocol.connection_made(transport, ramses=True)
+
+    # Assert called twice without error (protocol impl handles idempotency logic)
+    assert mock_protocol.connection_made.call_count == 2
+
+
+async def test_callback_transport_autostart_false() -> None:
+    """Test that reading is paused by default (autostart=False)."""
+    mock_protocol = Mock()
+    mock_writer = AsyncMock()
+
+    transport = CallbackTransport(mock_protocol, mock_writer, autostart=False)
+
+    assert transport.is_reading() is False
+
+
+async def test_callback_transport_autostart_default() -> None:
+    """Test that reading is paused by default (backward compatibility)."""
+    mock_protocol = Mock()
+    mock_writer = AsyncMock()
+
+    transport = CallbackTransport(mock_protocol, mock_writer)
+
+    assert transport.is_reading() is False
+
+
+async def test_callback_transport_autostart_true() -> None:
+    """Test that reading is resumed automatically if autostart=True."""
+    mock_protocol = Mock()
+    mock_writer = AsyncMock()
+
+    transport = CallbackTransport(mock_protocol, mock_writer, autostart=True)
+
+    assert transport.is_reading() is True
+
+
+async def test_factory_routes_autostart_to_custom_constructor() -> None:
+    """Check that autostart is passed to a custom transport_constructor."""
+    mock_protocol = Mock()
+    mock_writer = AsyncMock()
+
+    # 1. Test with autostart=True
+    # NOTE: transport_factory awaits the constructor, so we must pass an async callable
+    transport = await transport_factory(
+        mock_protocol,
+        transport_constructor=_async_callback_factory,
+        io_writer=mock_writer,
+        autostart=True,
+    )
+    assert isinstance(transport, CallbackTransport)
+    assert transport.is_reading() is True
+
+    # 2. Test with autostart=False (default)
+    transport_paused = await transport_factory(
+        mock_protocol,
+        transport_constructor=_async_callback_factory,
+        io_writer=mock_writer,
+        autostart=False,
+    )
+    assert isinstance(transport_paused, CallbackTransport)
+    assert transport_paused.is_reading() is False
+
+
+async def test_factory_strips_autostart_for_standard_transport() -> None:
+    """Check that autostart is REMOVED before calling standard transports.
+
+    If it isn't removed, the standard transports (PortTransport/MqttTransport)
+    would raise TypeError because they don't accept 'autostart' in __init__.
+    """
+    mock_protocol = Mock()
+    mock_protocol.wait_for_connection_made = AsyncMock()
+
+    # We must patch serial_for_url because transport_factory calls it via
+    # get_serial_instance BEFORE creating PortTransport.
+    with (
+        patch("ramses_tx.transport.PortTransport") as MockPortTransport,
+        patch("ramses_tx.transport.serial_for_url") as mock_serial_for_url,
+    ):
+        # Setup the mock serial object to pass validity checks
+        mock_serial = Mock()
+        mock_serial.portstr = "/dev/ttyUSB0"
+        mock_serial_for_url.return_value = mock_serial
+
+        # valid-looking config so factory enters the Serial branch
+        port_config: Any = {}
+
+        await transport_factory(
+            mock_protocol,
+            port_name="/dev/ttyUSB0",
+            port_config=port_config,
+            autostart=True,  # This argument must be filtered out!
+        )
+
+        # Assert PortTransport was called
+        assert MockPortTransport.call_count == 1
+
+        # Verify 'autostart' was NOT in the call args
+        call_args = MockPortTransport.call_args
+        assert "autostart" not in call_args.kwargs
+        assert "autostart" not in call_args.args  # just in case
+
+
+async def test_factory_strips_autostart_for_mqtt_transport() -> None:
+    """Check that autostart is REMOVED before calling MqttTransport."""
+    mock_protocol = Mock()
+    mock_protocol.wait_for_connection_made = AsyncMock()
+
+    with patch("ramses_tx.transport.MqttTransport") as MockMqttTransport:
+        # valid-looking config so factory enters the MQTT branch
+        # We must provide port_config because transport_factory validates it
+        # is not None even for MQTT
+        port_config: Any = {}
+
+        await transport_factory(
+            mock_protocol,
+            port_name="mqtt://broker:1883",
+            port_config=port_config,
+            autostart=True,  # This must be filtered out
+        )
+
+        assert MockMqttTransport.call_count == 1
+        call_args = MockMqttTransport.call_args
+        assert "autostart" not in call_args.kwargs
+
+
+async def test_port_transport_close_robustness() -> None:
+    """Check that PortTransport.close() does not raise AttributeError if init failed.
+
+    This ensures that _close() checks for the existence of _init_task before
+    attempting to cancel it.
+    """
+    from ramses_tx.transport import PortTransport
+
+    mock_protocol = Mock()
+    mock_serial = Mock()
+
+    # Define a side_effect for SerialTransport.__init__ that sets required attributes
+    # PortTransport expects _loop to be set by the parent class
+    def mock_init(self: Any, loop: Any, protocol: Any, serial_instance: Any) -> None:
+        self._loop = loop or asyncio.get_event_loop()
+        self._protocol = protocol
+        self._serial = serial_instance  # Set backing attribute directly
+
+    # Patch SerialTransport.__init__ using 'new' to replace it with the function directly.
+    # This ensures 'self' is passed correctly, which doesn't happen with a standard Mock side_effect.
+    with patch(
+        "ramses_tx.transport.serial_asyncio.SerialTransport.__init__",
+        new=mock_init,
+    ):
+        transport = PortTransport(mock_serial, mock_protocol)
+
+        # Pre-condition: _init_task is created asynchronously, so it shouldn't exist yet
+        # because we haven't yielded to the event loop
+        assert not hasattr(transport, "_init_task")
+
+        # Execute close - should not raise AttributeError
+        transport.close()