rustuya-local 0.1.0.dev1__tar.gz → 0.1.0.dev2__tar.gz

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/CHANGELOG.md

@@ -8,6 +8,20 @@ stable release.
 
 ## [Unreleased]
 
+## [0.1.0.dev2] — 2026-10-11
+
+### Fixed
+- Serialize device setting saves and override reloads so simultaneous commands preserve every device's settings,
+  including when a save is cancelled during file work.
+- Release a Hub's native rule pack on service shutdown, failed construction, and failed rule replacement; retain
+  shared packs until their last owner releases them.
+- Remove Runner reconnect callbacks and subscriptions on shutdown or failed startup, and await background cleanup.
+- Retry transient override-loading failures and read watched device files off the event loop.
+
+### Changed
+- Share atomic file replacement across settings, converter files and the override pack, using unique temporary files.
+- Refresh the roadmap and document the cover motion-source selector and position-source settings.
+
 ## [0.1.0.dev1] — 2026-10-11
 
 ### Changed

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rustuya-local
-Version: 0.1.0.dev1
+Version: 0.1.0.dev2
 Summary: Local Tuya control: rustuya-bridge -> tuya2ildevice -> IL (ildevice). HA-independent core.
 Project-URL: Homepage, https://github.com/3735943886/rustuya-local
 Project-URL: Repository, https://github.com/3735943886/rustuya-local
@@ -110,21 +110,26 @@ put there, and leaves a file alone once you edit it.
 
 ### Cover settings
 
-A curtain or blind whose position runs the other way, or that never shows *opening* / *closing*, is fixed from its
-own configuration switches, not a file. Each appears only where it changes something:
+A curtain or blind whose position runs the other way, or whose *opening* / *closing* state is wrong, can be fixed
+from its own configuration switches and motion-source selector. Each appears only where it changes something:
 
-| switch | shown when the cover has | turn it on when |
+| setting | shown when the cover has | use it when |
 |---|---|---|
 | *Invert current position* | a position it reports | fully opened, it shows 0% |
 | *Invert target position* | a target position, separate from the reported one | *Open* closes it |
 | *Invert control* | an open / close command and no target position | *Open* closes it |
-| *Infer motion* (on by default) | a reported position and a target or a command | off: when *opening* / *closing* is wrong |
+| *Use target as current position* | distinct reported and target position sources | the target DP should supply the displayed position |
+| *Motion state source* | a position or control DP, with no custom converter owning the motion state | choose `inferred` for motion inference, `control` for control reports, or `none` to disable motion generation; `control` requires a control DP |
+| *Invert reported motion* | the `control` motion source | the reported *opening* and *closing* meanings are reversed |
 
-With one position data point for both, *Invert current position* turns both. A switch changes nothing on the device:
+With one position data point for both, *Invert current position* turns both. Motion defaults to `inferred` when
+device settings are enabled, unless an override selects another source. A setting changes nothing on the device:
 the setting is saved as the device's block in `zz_settings.json` in the converters directory and applied at once, so it
 survives a restart and can be edited there too. Without a converters directory (a daemon with no
 `custom_converters`) the switches are not offered; `"options": {"device_settings": false}` turns them off.
-A block with the same `cover` keys in your own file or the pack sets a model's starting point; the switches win.
+A block with the same `cover` keys in your own file or the pack sets a model's starting point; the saved settings win.
+Older `cover.infer_motion` and `converters.cover_motion` blocks are upgraded on loading to `cover.state_source`
+(`inferred`, or `none` for `infer_motion: false`) and `cover.settle`; see [migration notes](docs/MIGRATING.md).
 
 In Home Assistant the files can be edited from a sidebar panel: the integration's *Configure* → *Add the Rustuya
 panel to the sidebar* adds it and links to it. The panel is for administrators. It fetches the device list from Tuya Cloud, shows the

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/README.md

@@ -84,21 +84,26 @@ put there, and leaves a file alone once you edit it.
 
 ### Cover settings
 
-A curtain or blind whose position runs the other way, or that never shows *opening* / *closing*, is fixed from its
-own configuration switches, not a file. Each appears only where it changes something:
+A curtain or blind whose position runs the other way, or whose *opening* / *closing* state is wrong, can be fixed
+from its own configuration switches and motion-source selector. Each appears only where it changes something:
 
-| switch | shown when the cover has | turn it on when |
+| setting | shown when the cover has | use it when |
 |---|---|---|
 | *Invert current position* | a position it reports | fully opened, it shows 0% |
 | *Invert target position* | a target position, separate from the reported one | *Open* closes it |
 | *Invert control* | an open / close command and no target position | *Open* closes it |
-| *Infer motion* (on by default) | a reported position and a target or a command | off: when *opening* / *closing* is wrong |
+| *Use target as current position* | distinct reported and target position sources | the target DP should supply the displayed position |
+| *Motion state source* | a position or control DP, with no custom converter owning the motion state | choose `inferred` for motion inference, `control` for control reports, or `none` to disable motion generation; `control` requires a control DP |
+| *Invert reported motion* | the `control` motion source | the reported *opening* and *closing* meanings are reversed |
 
-With one position data point for both, *Invert current position* turns both. A switch changes nothing on the device:
+With one position data point for both, *Invert current position* turns both. Motion defaults to `inferred` when
+device settings are enabled, unless an override selects another source. A setting changes nothing on the device:
 the setting is saved as the device's block in `zz_settings.json` in the converters directory and applied at once, so it
 survives a restart and can be edited there too. Without a converters directory (a daemon with no
 `custom_converters`) the switches are not offered; `"options": {"device_settings": false}` turns them off.
-A block with the same `cover` keys in your own file or the pack sets a model's starting point; the switches win.
+A block with the same `cover` keys in your own file or the pack sets a model's starting point; the saved settings win.
+Older `cover.infer_motion` and `converters.cover_motion` blocks are upgraded on loading to `cover.state_source`
+(`inferred`, or `none` for `infer_motion: false`) and `cover.settle`; see [migration notes](docs/MIGRATING.md).
 
 In Home Assistant the files can be edited from a sidebar panel: the integration's *Configure* → *Add the Rustuya
 panel to the sidebar* adds it and links to it. The panel is for administrators. It fetches the device list from Tuya Cloud, shows the

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/custom_components/rustuya/manifest.json

@@ -13,8 +13,8 @@
     "paho-mqtt>=2.0",
     "rustuya-manager>=0.2.2",
     "pyrustuyabridge>=0.4",
-    "rustuya-local>=0.1.0.dev1"
+    "rustuya-local>=0.1.0.dev2"
   ],
   "single_config_entry": true,
-  "version": "0.1.0.dev1"
+  "version": "0.1.0.dev2"
 }

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/custom_components/rustuya/www/rustuya-panel.js

@@ -3,7 +3,7 @@
 // <config>/rustuya_converters and the override pack (the rustuya-manager plugin tab's file API).
 //
 // Home Assistant sets `hass`, `narrow` and `panel` on the element; every call goes through hass.callApi, which carries
-// the user's token. The views are for administrators only (converters run code in Home Assistant's process).
+// the user's token. The views are for administrators only (rule files change how devices are driven).
 
 const ORIGIN = { pack: "origin_pack", pack_edited: "origin_pack_edited" };      // I18N keys
 const PACK_CHANGES = ["added", "updated", "removed", "kept"];                    // a pack sync's lists, in this order

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/docs/ROADMAP.md

@@ -1,6 +1,16 @@
-# 남은 일 (2026-09-28 기준)
+# 남은 일 (2026-10-11 갱신)
 
-재설계(REDESIGN.md 9장)는 끝났다. 현재 배포: tuya2ildevice 0.3.16, rustuya-local 0.0.45(PyPI, HACS, 매니저 카탈로그 drop-in), rustuya-manager 0.2.1, pyrustuyabridge 0.4.0(PyPI).
+현재 작업 트리는 `rustuya-local 0.1.0.dev2`이며 `tuya2ildevice>=0.4.0.dev3`, `pyrustuyabridge>=0.4`를 요구한다.
+HA 통합과 매니저 플러그인 테스트는 `rustuya-manager>=0.2.2`를 사용한다. 변환은 Sans-I/O Rust 드라이버가 맡고,
+기기 레지스트리·IL MQTT 어댑터·전송·타이머·규칙 파일 로딩은 `rustuya_local.host`로 옮겼다.
+버전별 변경은 [CHANGELOG.md](../CHANGELOG.md)에 기록한다. 이 문서는 실제 배포 서버의 최신 상태를 확인하는 자료가 아니다.
+
+2026-10-11 코드 검토 후 동시 설정 저장을 직렬화하고, Hub 규칙 팩과 Runner 재연결 콜백의 종료 처리를 보강했다.
+파일 원자적 교체와 비동기 작업 종료 처리를 공통화했고, 기기 목록 감시의 파일 읽기를 이벤트 루프 밖으로 옮겼다.
+실기기 검증은 아래 M2에 기록된 범위이며, 이번 코드·자동 테스트 검증으로 완료 처리하지 않는다.
+
+아래 마일스톤의 완료 항목은 2026-09-28까지의 이력이다. 당시 배포 기준은 tuya2ildevice 0.3.16,
+rustuya-local 0.0.45, rustuya-manager 0.2.1, pyrustuyabridge 0.4.0이었다.
 rustuya-homeassistant 는 폐기 안내만 푸시했다(아카이브 안 함). 2026-09-27 에 저장소 이름을 rustuya-homeassistant 로 바꿨다가 같은 날
 되돌렸다(HA 전용이 아니고 이름이 여러 개면 헷갈림): 저장소·PyPI·import·CLI·플러그인 id 모두 `rustuya-local`.
 아래는 그 뒤에 남은 것을 마일스톤 순서로 정리한 것이다. 저장소 표기: **T** tuya2ildevice, **L** rustuya-local, **H** il-ha,

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rustuya-local"
-version = "0.1.0.dev1"
+version = "0.1.0.dev2"
 description = "Local Tuya control: rustuya-bridge -> tuya2ildevice -> IL (ildevice). HA-independent core."
 readme = "README.md"
 requires-python = ">=3.13"

rustuya_local-0.1.0.dev2/release-notes.md

@@ -0,0 +1,11 @@
+### Fixed
+- Serialize device setting saves and override reloads so simultaneous commands preserve every device's settings,
+  including when a save is cancelled during file work.
+- Release a Hub's native rule pack on service shutdown, failed construction, and failed rule replacement; retain
+  shared packs until their last owner releases them.
+- Remove Runner reconnect callbacks and subscriptions on shutdown or failed startup, and await background cleanup.
+- Retry transient override-loading failures and read watched device files off the event loop.
+
+### Changed
+- Share atomic file replacement across settings, converter files and the override pack, using unique temporary files.
+- Refresh the roadmap and document the cover motion-source selector and position-source settings.

rustuya_local-0.1.0.dev2/src/rustuya_local/async_tools.py

@@ -0,0 +1,24 @@
+"""Small lifecycle helpers for background tasks and file work."""
+
+import asyncio
+import contextlib
+from collections.abc import Callable
+
+
+async def cancel_task(task: asyncio.Task | None) -> None:
+    """Cancel an owned task and wait until its cleanup has finished."""
+    if task is not None:
+        task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await task
+
+
+async def run_in_thread[**P, T](function: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    """Finish file work before propagating cancellation; cancelling cannot stop its thread."""
+    task = asyncio.create_task(asyncio.to_thread(function, *args, **kwargs))
+    try:
+        return await asyncio.shield(task)
+    except asyncio.CancelledError:
+        # Do not release a caller's lock or close its resources while the worker still uses them.
+        await asyncio.gather(task, return_exceptions=True)
+        raise

rustuya_local-0.1.0.dev2/src/rustuya_local/files.py

@@ -0,0 +1,18 @@
+"""Atomic replacement shared by settings, converter files and the override pack."""
+
+import os
+import tempfile
+from pathlib import Path
+
+
+def atomic_write(path: Path, data: str | bytes) -> None:
+    """Replace a file using a unique sibling temporary file; preserve it if writing fails."""
+    payload = data.encode("utf-8") if isinstance(data, str) else data
+    fd, name = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.")
+    temporary = Path(name)
+    try:
+        with os.fdopen(fd, "wb") as stream:
+            stream.write(payload)
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/src/rustuya_local/host/devices.py

@@ -7,13 +7,25 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+from dataclasses import dataclass
 from pathlib import Path
+from typing import Protocol
 
-from .runner import Runner
+from ..async_tools import cancel_task, run_in_thread
 
 _LOGGER = logging.getLogger(__name__)
 
 
+class DeviceRegistry(Protocol):
+    def sync_devices(self, records: list[dict]) -> object: ...
+
+
+@dataclass(frozen=True)
+class _DeviceUpdate:
+    stamp: tuple[int, int] | None
+    records: list[dict] | None
+
+
 def parse_devices(raw: str | bytes) -> tuple[list[dict], list[str]]:
     """(usable records, ids skipped). The file is a list of records or a dict of them; a record without an `id` or a
     `category` cannot be turned into an IL device (there is nothing to classify it by)."""
@@ -43,7 +55,7 @@ class DeviceWatcher:
     """Follow the device file: a new record is added to the runner, a changed one replaced, a removed one removed.
     A file that cannot be read or parsed right now (half written by something else) leaves things as they are."""
 
-    def __init__(self, path: str | Path, runner: Runner, interval: float = 5.0) -> None:
+    def __init__(self, path: str | Path, runner: DeviceRegistry, interval: float = 5.0) -> None:
         self.path = Path(path)
         self.runner = runner
         self.interval = interval
@@ -51,13 +63,13 @@ class DeviceWatcher:
         self._task: asyncio.Task | None = None
 
     def start(self) -> None:
-        self._stamp = self._stat()
-        self._task = asyncio.ensure_future(self._loop())
+        if self._task is None:
+            self._stamp = self._stat()
+            self._task = asyncio.create_task(self._loop())
 
     async def stop(self) -> None:
-        if self._task:
-            self._task.cancel()
-            self._task = None
+        task, self._task = self._task, None
+        await cancel_task(task)
 
     def _stat(self) -> tuple[int, int] | None:
         try:
@@ -68,20 +80,31 @@ class DeviceWatcher:
 
     def check(self) -> bool:
         """Sync once if the file changed since the last look; True if it did."""
+        return self._apply(self._read_changes())
+
+    def _read_changes(self) -> _DeviceUpdate | None:
         stamp = self._stat()
         if stamp is None or stamp == self._stamp:
-            return False
-        self._stamp = stamp
+            return None
         try:
             records = load_devices(self.path)
         except (OSError, ValueError):
             _LOGGER.warning("could not read %s; keeping the devices as they are", self.path)
-            self._stamp = None                      # look again next time
-            return True
-        self.runner.sync_devices(records)
+            return _DeviceUpdate(None, None)        # look again next time
+        return _DeviceUpdate(stamp, records)
+
+    def _apply(self, update: _DeviceUpdate | None) -> bool:
+        if update is None:
+            return False
+        if update.records is not None:
+            self.runner.sync_devices(update.records)
+        self._stamp = update.stamp
         return True
 
     async def _loop(self) -> None:
         while True:
             await asyncio.sleep(self.interval)
-            self.check()
+            try:
+                self._apply(await run_in_thread(self._read_changes))
+            except Exception:
+                _LOGGER.exception("could not sync devices from %s; will retry", self.path)

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/src/rustuya_local/host/hub.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import time
+import weakref
 from collections import Counter
 from collections.abc import Sequence
 from typing import Any
@@ -27,6 +28,12 @@ from .rules import upgrade_overrides
 _pack_users: Counter[str] = Counter()
 
 
+def _acquire(rules: dict) -> str:
+    rules_id = register_rules(rules)
+    _pack_users[rules_id] += 1
+    return rules_id
+
+
 def _release(rules_id: str) -> None:
     _pack_users[rules_id] -= 1
     if _pack_users[rules_id] <= 0:
@@ -42,16 +49,27 @@ class Hub:
         self.il = il or IlTopics()
         self._kw = {**driver_kwargs, 'rules': rules if rules is not None else default_rules()}
         self._kw['overrides'] = upgrade_overrides(self._kw.get('overrides'))
-        self._rules_id = register_rules(self._kw['rules'])
-        _pack_users[self._rules_id] += 1
         for device in devices:
             self._check_id(device['id'])
         self._devices = {d['id']: d for d in devices}
-        self.drivers = {i: self._create(d, self._kw) for i, d in self._devices.items()}
+        self.drivers: dict[str, TuyaDriver] = {}
+        self._rules_id = _acquire(self._kw['rules'])
+        self._release_rules = weakref.finalize(self, _release, self._rules_id)
+        try:
+            self.drivers = {i: TuyaDriver(d, **self._kw) for i, d in self._devices.items()}
+        except BaseException:
+            self.close()
+            raise
 
-    @staticmethod
-    def _create(device, options):
-        return TuyaDriver(device, **options)
+    def close(self) -> None:
+        """Release this Hub's drivers and rule pack once; stop() only publishes presence."""
+        self.drivers.clear()
+        self._devices.clear()
+        self._release_rules()
+
+    def _check_open(self) -> None:
+        if not self._release_rules.alive:
+            raise RuntimeError('Hub is closed')
 
     @property
     def records(self) -> dict[str, dict]:
@@ -87,8 +105,9 @@ class Hub:
 
     def set_device(self, device: dict, seed: Sequence[Connected | Disconnected | Message] = (),
                    now: float | None = None) -> list:
+        self._check_open()
         self._check_id(device['id'])
-        new = self._create(device, self._kw)
+        new = TuyaDriver(device, **self._kw)
         old = self.drivers.get(device['id'])
         if not seed and old is not None and old.linked:
             seed = [Connected()]
@@ -110,19 +129,27 @@ class Hub:
                 *self.il.clear(device_id, old.descriptor['props'], descriptor=True)]
 
     def reload(self, overrides: dict | None, *, rules: dict | None = None, now: float | None = None) -> list:
+        self._check_open()
         options = {**self._kw, 'overrides': upgrade_overrides(overrides)}
-        rules_id = self._rules_id
         if rules is not None:
             options['rules'] = rules
-            rules_id = register_rules(rules)
+        rules_id = _acquire(options['rules'])
         try:
-            fresh = {i: self._create(d, options) for i, d in self._devices.items()}
-        except Exception:
-            if not _pack_users[rules_id]:           # refused: a pack nobody took is not kept
-                unregister_rules(rules_id)
+            fresh = {i: TuyaDriver(d, **options) for i, d in self._devices.items()}
+            actions, replacements = self._replacements(fresh, options['rules'], time.time() if now is None else now)
+        except BaseException:
+            _release(rules_id)
             raise
+        self.drivers.update(replacements)
+        self._kw = options
+        self._release_rules()
+        self._rules_id = rules_id
+        self._release_rules = weakref.finalize(self, _release, rules_id)
+        return actions
+
+    def _replacements(self, fresh: dict[str, TuyaDriver], rules: dict,
+                      now: float) -> tuple[list, dict[str, TuyaDriver]]:
         actions = []
-        now = time.time() if now is None else now
         replacements = {}
         for device_id, new in fresh.items():
             old = self.drivers[device_id]
@@ -131,17 +158,11 @@ class Hub:
             seed = [Connected()] if old.linked else []
             if old.synced:
                 seed.append(Message('state', old.dps))
-            actions.extend(self._adopt(old, new, seed, now, rules=options['rules']))
+            actions.extend(self._adopt(old, new, seed, now, rules=rules))
             if old.linked and not old.synced:
                 actions.append(BridgeCommand(device_id, 'get'))
             replacements[device_id] = new
-        self.drivers.update(replacements)
-        self._kw = options
-        if rules_id != self._rules_id:              # every driver was replaced: none uses the old pack now
-            _pack_users[rules_id] += 1
-            _release(self._rules_id)
-            self._rules_id = rules_id
-        return actions
+        return actions, replacements
 
     def subscriptions(self) -> list[Subscribe]:
         return [Subscribe(IL, self.il.set_subscription())]
@@ -150,6 +171,7 @@ class Hub:
         return Publish(IL, self.il.presence, 'online' if online else 'offline', True)
 
     def start(self, now: float | None = None) -> list:
+        self._check_open()
         now = time.time() if now is None else now
         actions = [self.presence(True)]
         for device_id, driver in self.drivers.items():

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/src/rustuya_local/host/overrides.py

@@ -20,8 +20,10 @@ from typing import Any
 
 from tuya2ildevice import OverrideError, merge_all
 
-from rustuya_local.host.rules import load_rules_tolerant, upgrade_overrides
+from rustuya_local.host.rules import load_rules_tolerant, rule_files, upgrade_overrides
 
+from ..async_tools import cancel_task, run_in_thread
+from ..files import atomic_write
 from .runner import Runner
 
 _LOGGER = logging.getLogger(__name__)
@@ -35,15 +37,6 @@ class OverrideSet:
     warnings: list[str] = field(default_factory=list)
 
 
-def _files(path: Path) -> list[Path]:
-    if path.is_file():
-        return [path]
-    if not path.is_dir():
-        return []
-    return sorted(p for p in path.iterdir()
-                  if p.is_file() and p.suffix == ".json" and p.name[0] not in "._")
-
-
 def load_overrides(path: str | Path) -> OverrideSet:
     """Read a directory (or one `.json` file) of rule files over `TUYA_ENGINE_RULES`. Never raises for a bad file."""
     locations = [p for p in os.environ.get("TUYA_ENGINE_RULES", "").split(os.pathsep) if p]
@@ -59,13 +52,15 @@ class OverrideWatcher:
     engine refuses is left out and reported (`load_overrides`); overrides the Hub refuses as a whole (`OverrideError`,
     a bad `base`) are reported and the ones in effect stay."""
 
-    def __init__(self, path: str | Path, runner: Runner, interval: float = 5.0, base: dict | None = None) -> None:
+    def __init__(self, path: str | Path, runner: Runner | None, interval: float = 5.0,
+                 base: dict | None = None) -> None:
         self.path = Path(path)
         self.runner = runner
         self.interval = interval
         self.base = base or {}
         self._stamp: Any = None
         self._task: asyncio.Task | None = None
+        self._lock = asyncio.Lock()
 
     def load(self) -> OverrideSet:
         loaded = load_overrides(self.path)
@@ -82,24 +77,25 @@ class OverrideWatcher:
     async def load_initial(self) -> OverrideSet:
         """Load what is there now, off the event loop, and remember it as applied: pass the result to the Hub you
         create, then `watch()`."""
-        def work() -> OverrideSet:
-            self._stamp = self._stat()
-            return self.load()
-        return await asyncio.to_thread(work)
+        async with self._lock:
+            self._stamp, loaded = await run_in_thread(self._snapshot)
+            return loaded
+
+    def _snapshot(self) -> tuple[Any, OverrideSet]:
+        return self._stat(), self.load()
 
     def watch(self) -> None:
         """Start following the directory from the state last loaded."""
         if self._task is None:
-            self._task = asyncio.ensure_future(self._loop())
+            self._task = asyncio.create_task(self._loop())
 
     async def stop(self) -> None:
-        if self._task:
-            self._task.cancel()
-            self._task = None
+        task, self._task = self._task, None
+        await cancel_task(task)
 
     def _stat(self) -> Any:
         stamp = []
-        for p in _files(self.path):
+        for p in rule_files([self.path]):
             try:
                 st = p.stat()
             except OSError:
@@ -112,8 +108,8 @@ class OverrideWatcher:
         stamp = self._stat()
         if stamp == self._stamp:
             return False
-        self._stamp = stamp
         self._apply(self.load())
+        self._stamp = stamp
         return True
 
     def _apply(self, loaded: OverrideSet) -> None:
@@ -131,18 +127,18 @@ class OverrideWatcher:
         if self.path.is_file() or (self.path.suffix == ".json" and not self.path.is_dir()):
             _LOGGER.warning("overrides are the one file %s: the settings of %s are not saved", self.path, device_id)
             return
-        try:
-            await asyncio.to_thread(self._write_settings, device_id, block)
-        except Exception:
-            _LOGGER.exception("could not save the settings of %s in %s", device_id, self.path / SETTINGS_FILE)
-            return
-        try:
-            def work() -> tuple[Any, OverrideSet]:
-                return self._stat(), self.load()
-            self._stamp, loaded = await asyncio.to_thread(work)
-            self._apply(loaded)
-        except Exception:
-            _LOGGER.exception("could not apply the settings of %s", device_id)
+        async with self._lock:
+            try:
+                await run_in_thread(self._write_settings, device_id, block)
+            except Exception:
+                _LOGGER.exception("could not save the settings of %s in %s", device_id, self.path / SETTINGS_FILE)
+                return
+            try:
+                stamp, loaded = await run_in_thread(self._snapshot)
+                self._apply(loaded)
+                self._stamp = stamp
+            except Exception:
+                _LOGGER.exception("could not apply the settings of %s", device_id)
 
     def _write_settings(self, device_id: str, block: dict) -> None:
         path = self.path / SETTINGS_FILE
@@ -160,17 +156,20 @@ class OverrideWatcher:
             entries[device_id] = block
         else:
             entries.pop(device_id, None)
-        tmp = path.with_name(f".{path.name}.tmp")             # a dot file: never loaded
-        tmp.write_text(json.dumps(data, indent=2, sort_keys=True, ensure_ascii=False) + "\n", "utf-8")
-        os.replace(tmp, path)
+        atomic_write(path, json.dumps(data, indent=2, sort_keys=True, ensure_ascii=False) + "\n")
 
     async def _loop(self) -> None:
         # the file work (stat, read) runs in a worker thread: a host such as Home Assistant
         # must not block its event loop on it; only the reload itself runs on the loop
         while True:
             await asyncio.sleep(self.interval)
-            stamp = await asyncio.to_thread(self._stat)
-            if stamp == self._stamp:
-                continue
-            self._stamp = stamp
-            self._apply(await asyncio.to_thread(self.load))
+            async with self._lock:
+                try:
+                    stamp = await run_in_thread(self._stat)
+                    if stamp == self._stamp:
+                        continue
+                    stamp, loaded = await run_in_thread(self._snapshot)
+                    self._apply(loaded)
+                    self._stamp = stamp
+                except Exception:
+                    _LOGGER.exception("could not reload overrides in %s; will retry", self.path)

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev2}/src/rustuya_local/host/pack.py

@@ -26,13 +26,13 @@ from __future__ import annotations
 import hashlib
 import json
 import logging
-import os
 import re
 import urllib.request
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
+from ..files import atomic_write
 from .overrides import SETTINGS_FILE
 
 _LOGGER = logging.getLogger(__name__)
@@ -87,12 +87,6 @@ def _sha(data: bytes) -> str:
     return hashlib.sha256(data).hexdigest()
 
 
-def _write(path: Path, data: bytes) -> None:
-    tmp = path.with_name(f".{path.name}.tmp")
-    tmp.write_bytes(data)
-    os.replace(tmp, path)
-
-
 def fetch_manifest(base_url: str = BASE_URL) -> dict[str, Any]:
     raw = _download(base_url + MANIFEST)
     try:
@@ -167,7 +161,7 @@ def sync(directory: str | Path, *, base_url: str = BASE_URL, manifest: dict[str,
             if _sha(data) != sha:
                 raise PackError(f"{name}: does not match the manifest's hash")
             _check(name, data)
-            _write(path, data)
+            atomic_write(path, data)
         except (PackError, OSError) as e:
             out.failed.append(str(e) if str(e).startswith(name) else f"{name}: {e}")
             if name in before and current is not None:
@@ -194,7 +188,7 @@ def sync(directory: str | Path, *, base_url: str = BASE_URL, manifest: dict[str,
 
     ledger = json.dumps({"version": 1, "files": dict(sorted(owned.items()))}, indent=2) + "\n"
     if owned or before:
-        _write(directory / LEDGER, ledger.encode())
+        atomic_write(directory / LEDGER, ledger)
     for kind, names in (("added", out.added), ("updated", out.updated), ("removed", out.removed)):
         if names:
             _LOGGER.info("pack: %s %s", kind, ", ".join(names))