python-rako-2025 0.5.0__tar.gz → 0.5.1__tar.gz

{python_rako_2025-0.5.0 → python_rako_2025-0.5.1}/.github/dependabot.yml

@@ -4,12 +4,10 @@ updates:
   - package-ecosystem: pip
     directory: "/"
     schedule:
-      interval: daily
-      time: "06:00"
-    open-pull-requests-limit: 10
+      interval: weekly
+    open-pull-requests-limit: 5
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: daily
-      time: "06:00"
-    open-pull-requests-limit: 10
+      interval: weekly
+    open-pull-requests-limit: 5

{python_rako_2025-0.5.0 → python_rako_2025-0.5.1}/CHANGELOG.md

@@ -9,6 +9,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet.
 
+## [0.5.1] - 2026-11-04
+
+### Fixed
+
+- `BridgeStateSnapshot.reconcile()` no longer wipes rooms that are missing
+  from the scene cache. `from_caches()` lists every room in the level table,
+  so a missing room arrived with `scene=None`, which `reconcile()` read as a
+  missed scene change, and reset the room and its channels to unknown. This is
+  the opposite of the documented rule that absence is not evidence. A bridge
+  that has just restarted refills its cache one scene selection at a time
+  (occupancy-sensor rooms within minutes), so the first non-empty read after a
+  restart reset every other room to unknown. Rooms missing from the cache now
+  only fill in rooms and channels nothing has reported yet. They keep a faded
+  room's `faded_from` guard, which the wipe used to discard, letting a later
+  stale cache entry bring back the pre-fade scene. The test for this rule
+  passed only because it used an empty level table; it now uses a real one.
+
 ## [0.5.0] - 2026-08-30
 
 ### Added
@@ -110,7 +127,8 @@ e.g.:
 - ...
 -->
 
-[Unreleased]: https://github.com/SimonLeigh/python-rako/compare/v0.5.0...master
+[Unreleased]: https://github.com/SimonLeigh/python-rako/compare/v0.5.1...master
+[0.5.1]: https://github.com/SimonLeigh/python-rako/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/SimonLeigh/python-rako/releases/tag/v0.5.0
 
 <!--

{python_rako_2025-0.5.0 → python_rako_2025-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-rako-2025
-Version: 0.5.0
+Version: 0.5.1
 Summary: Asynchronous Python client for Rako Controls Lighting
 Project-URL: Homepage, https://github.com/SimonLeigh/python-rako
 Project-URL: Repository, https://github.com/SimonLeigh/python-rako

python_rako_2025-0.5.1/python_rako/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.5.1"

{python_rako_2025-0.5.0 → python_rako_2025-0.5.1}/python_rako/state.py

@@ -328,9 +328,16 @@ class BridgeStateSnapshot:
         Had the cache said scene 3, the scene change would have been one we
         missed, and the room would be rebuilt from the cache instead.
 
-        Rooms absent from ``fresh`` are left exactly as they are: the bridge
-        deletes fade-controlled rooms from its scene cache, so absence is not
-        evidence of anything.
+        Rooms absent from the scene cache are left exactly as they are, whether
+        they are missing from ``fresh`` altogether or -- as
+        :meth:`from_caches` lists every room in the level table -- present with
+        ``scene=None``.  Absence is not evidence of anything: the bridge
+        deletes fade-controlled rooms from its scene cache by design, and after
+        a restart its cache starts empty and refills one scene selection at a
+        time, so a read taken then lists only the rooms used since.  Treating
+        ``None`` as a scene change would wipe every other room to unknown.
+        Such a room only fills in rooms and channels we have never heard of,
+        as unknown; it never overwrites anything already tracked.
 
         **Fades get one extra guard.**  A fade sets the room's scene to
         ``None``, which would otherwise always "differ" from a cached scene and
@@ -351,6 +358,15 @@ class BridgeStateSnapshot:
                 rc: state for rc, state in fresh.channels.items() if rc.room_id == room
             }
 
+            if fresh_room.scene is None:
+                # Not in the scene cache: no news. Keep everything we know --
+                # including a faded room's faded_from guard -- and only fill in
+                # rooms and channels we have never heard of, as unknown.
+                rooms.setdefault(room, replace(fresh_room, updated_at=now))
+                for room_channel, state in fresh_channels.items():
+                    channels.setdefault(room_channel, replace(state, updated_at=now))
+                continue
+
             if tracked is not None and tracked.is_faded:
                 if fresh_room.scene == tracked.faded_from:
                     _LOGGER.debug(

{python_rako_2025-0.5.0 → python_rako_2025-0.5.1}/tests/test_state.py

@@ -304,7 +304,11 @@ def test_reconcile_does_not_overwrite_a_command_echo():
 def test_reconcile_leaves_rooms_absent_from_the_cache_alone():
     """Absence from the scene cache means fade-controlled, not off."""
     tracked = empty_snapshot().apply(ChannelStatusMessage(9, 1, 200))
-    fresh = BridgeStateSnapshot.from_caches(SceneCache({6: 1}), LevelCache())
+    # The real level table, as get_state_snapshot() passes it: room 9 is then
+    # listed in ``fresh`` with scene=None rather than missing from it.
+    fresh = BridgeStateSnapshot.from_caches(SceneCache({6: 1}), LEVEL_TABLE)
+    assert fresh.room_scene(9) is None
+    assert 9 in fresh.rooms
 
     reconciled = tracked.reconcile(fresh)
 
@@ -312,6 +316,74 @@ def test_reconcile_leaves_rooms_absent_from_the_cache_alone():
     assert reconciled.channel_state(9, 1).source is StateSource.LEVEL_BROADCAST
 
 
+def test_reconcile_survives_a_bridge_restart_refilling_its_cache():
+    """A restarted bridge's cache lists only the rooms used since the restart.
+
+    Observed 2026-11-03: the bridge's cache came back empty, then partly
+    refilled by occupancy-sensor rooms within minutes. That read is not empty,
+    so it passes an emptiness check, yet every other room appears with
+    scene=None. None of them changed; none of them may be wiped to unknown.
+    """
+    tracked = (
+        empty_snapshot()
+        .apply(SceneStatusMessage(6, 0, 2))
+        .apply(ChannelStatusMessage(6, 1, 129))
+        .apply(SceneStatusMessage(7, 0, 0))
+    )
+    refilling = BridgeStateSnapshot.from_caches(SceneCache({9: 1}), LEVEL_TABLE)
+
+    reconciled = tracked.reconcile(refilling)
+
+    assert reconciled.room_scene(6) == 2
+    assert reconciled.channel_level(6, 1) == 129
+    assert reconciled.channel_state(6, 1).source is StateSource.LEVEL_BROADCAST
+    assert reconciled.channel_level(6, 2) == 192
+    assert reconciled.room_scene(7) == 0
+    assert reconciled.channel_level(7, 2) == 0
+    # The room that is in the cache is still reconciled normally.
+    assert reconciled.room_scene(9) == 1
+    assert reconciled.channel_level(9, 1) == 255
+
+
+def test_reconcile_keeps_the_fade_guard_while_the_room_is_absent():
+    """The bridge drops a faded room from its cache; that must not reset the guard.
+
+    Otherwise the next read that still carries the pre-fade scene would be
+    adopted as a "missed scene change" and resurrect levels the fade invalidated.
+    """
+    tracked = (
+        empty_snapshot()
+        .apply(SceneStatusMessage(6, 0, 1))
+        .apply(FadeMessage(6, 0, direction=FadeDirection.UP, command=CommandType.FADE))
+    )
+    absent = BridgeStateSnapshot.from_caches(SceneCache({7: 1}), LEVEL_TABLE)
+
+    after_absent = tracked.reconcile(absent)
+
+    assert after_absent.rooms[6].is_faded
+    assert after_absent.rooms[6].faded_from == 1
+
+    stale = BridgeStateSnapshot.from_caches(SceneCache({6: 1}), LEVEL_TABLE)
+    reconciled = after_absent.reconcile(stale)
+
+    assert reconciled.room_scene(6) is None
+    assert reconciled.channel_level(6, 1) is None
+    assert reconciled.channel_state(6, 1).source is StateSource.UNKNOWN_AFTER_FADE
+
+
+def test_reconcile_adopts_absent_rooms_it_has_never_seen_as_unknown():
+    """A room nothing has told us about is added -- as unknown, never off."""
+    tracked = empty_snapshot().apply(SceneStatusMessage(6, 0, 1))
+    fresh = BridgeStateSnapshot.from_caches(SceneCache({6: 1}), LEVEL_TABLE)
+
+    reconciled = tracked.reconcile(fresh)
+
+    assert 9 in reconciled.rooms
+    assert reconciled.room_scene(9) is None
+    assert reconciled.channel_level(9, 1) is None
+    assert reconciled.channel_state(9, 1).source is StateSource.UNKNOWN_AFTER_FADE
+
+
 def test_reconcile_adopts_rooms_we_have_never_seen():
     tracked = empty_snapshot()
     fresh = BridgeStateSnapshot.from_caches(SceneCache({6: 3}), LEVEL_TABLE)

python_rako_2025-0.5.0/python_rako/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.5.0"