syncwave 0.1.1__tar.gz → 0.1.2__tar.gz

{syncwave-0.1.1 → syncwave-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: syncwave
-Version: 0.1.1
+Version: 0.1.2
 Summary: Make your code reactive; Turn plain JSONs into a live data store, two-way synced with Python objects.
 Keywords: 
 Author: Lucas Iannitello

{syncwave-0.1.1 → syncwave-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "syncwave"
-version = "0.1.1"
+version = "0.1.2"
 description = "Make your code reactive; Turn plain JSONs into a live data store, two-way synced with Python objects."
 readme = "README.md"
 authors = [{ name = "Lucas Iannitello", email = "lucas.iannitello@protonmail.com" }]
@@ -24,8 +24,12 @@ build-backend = "uv_build"
 
 [dependency-groups]
 dev = [
-    "ruff>=0.12.7",
+    "ruff>=0.12.9",
 ]
 
 [tool.ruff.lint]
-extend-select = ["E501"]
+select = ["E", "F"]
+
+unfixable = [
+    "F401"  # disable fix for unused imports
+]

{syncwave-0.1.1 → syncwave-0.1.2}/src/syncwave/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 
 
 from .syncwave import SyncStore, Syncwave

{syncwave-0.1.1 → syncwave-0.1.2}/src/syncwave/io.py

@@ -62,15 +62,13 @@ class _IO:
             timer.start()
 
     def _scheduled_write(self, path: Path, data_provider: DataProvider) -> None:
-        try:
-            self._atomic_write(path, data_provider())
-        finally:
-            with self._lock:
-                self._debounce_timers.pop(path, None)
-                self._pending_data_providers.pop(path, None)
+        with self._lock:
+            self._debounce_timers.pop(path, None)
+            self._pending_data_providers.pop(path, None)
+        self._atomic_write(path, data_provider())
 
     def _atomic_write(self, path: Path, data: JSONData) -> None:
-        fd, tmp_path = mkstemp(prefix=".tmp_", suffix=".json", dir=path.parent)
+        fd, tmp_path = mkstemp(prefix=watcher.TMP_FILE_PREFIX, dir=path.parent)
         try:
             with os.fdopen(fd, "w", encoding=self.ENCODING) as tmp_file:
                 json.dump(data, tmp_file, **self.DUMPS_CONFIG)

{syncwave-0.1.1 → syncwave-0.1.2}/src/syncwave/syncwave.py

@@ -1,8 +1,8 @@
-import json
-import threading
 from collections.abc import Mapping
 from inspect import isclass
+from json import JSONDecodeError
 from pathlib import Path
+from threading import RLock
 from typing import Any, Callable, Iterator, Optional, Type, Union, get_args
 
 from pydantic import BaseModel, ValidationError
@@ -62,7 +62,7 @@ class SyncStore(Mapping[JSONKey, BaseModel]):
         self.path = self._get_path(file_name or name_, sub_dir, file_path)
 
         self._ssd: dict[JSONKey, BaseModel] = {}  # actual mapping, ssd = SyncStoreDict
-        self._lock = threading.RLock()
+        self._lock = RLock()
         self._patch_cls()
         io.init_json_file(self.path)
         self.load()
@@ -111,9 +111,9 @@ class SyncStore(Mapping[JSONKey, BaseModel]):
                 # no JSONDecodeError or ValidationError at this point, safe to clear
                 self._ssd.clear()
                 self._ssd.update(tmp_ssd)
-        except (json.JSONDecodeError, ValidationError):
-            return
-        else:
+        except (FileNotFoundError, JSONDecodeError, ValidationError):
+            pass
+        finally:
             io.write_json(self.path, self.to_dict)
 
     def _get_path(

syncwave-0.1.2/src/syncwave/watcher.py

@@ -0,0 +1,177 @@
+from pathlib import Path
+from threading import Lock, Timer
+from time import monotonic, sleep
+from typing import Callable
+
+from watchdog.events import (
+    DirDeletedEvent,
+    DirMovedEvent,
+    FileSystemEvent,
+    FileSystemEventHandler,
+)
+from watchdog.observers import Observer
+from watchdog.observers.api import ObservedWatch
+
+DirPath = Path
+FilePath = Path
+Callback = Callable[[], None]
+
+
+class _Watcher:
+    TMP_FILE_PREFIX = ".tmp_"
+
+    def __init__(self) -> None:
+        self._lock = Lock()
+        # dir_path -> (watch object, set of file_paths)
+        self._watched_dirs: dict[DirPath, tuple[ObservedWatch, set[FilePath]]] = {}
+
+        self._observer = Observer()
+        self._event_handler = _EventHandler(self)
+        self._observer.start()
+
+    def watch(self, file_path: FilePath, callback: Callback) -> None:
+        if not file_path.is_file():
+            raise ValueError(f"Path '{file_path}' is not a file.")
+
+        dir_path = file_path.parent
+        with self._lock:
+            # if the directory is already being watched, just add the file to the set
+            if dir_path in self._watched_dirs:
+                _, watched_files = self._watched_dirs[dir_path]
+                watched_files.add(file_path)
+            # otherwise, schedule the directory and create the set of watched files
+            else:
+                self._watched_dirs[dir_path] = (
+                    self._observer.schedule(self._event_handler, str(dir_path)),
+                    {file_path},
+                )
+        # set or reset the callback in all cases
+        self._event_handler.set_callback(file_path, callback)
+
+    def unwatch(self, file_path: FilePath) -> None:
+        # remove the callback
+        self._event_handler.unset_callback(file_path)
+
+        dir_path = file_path.parent
+        with self._lock:
+            # if the directory is not being watched, do nothing
+            if dir_path not in self._watched_dirs:
+                return
+
+            # if the file is in the set, remove it
+            watch, watched_files = self._watched_dirs[dir_path]
+            if file_path in watched_files:
+                watched_files.remove(file_path)
+
+            # if the set is empty, unschedule the directory
+            if not watched_files:
+                self._observer.unschedule(watch)
+                del self._watched_dirs[dir_path]
+
+    def mark_self_write(self, file_path: FilePath) -> None:
+        self._event_handler.mark_self_write(file_path)
+
+    def get_watched_dirs(self) -> dict[DirPath, set[FilePath]]:
+        with self._lock:
+            return {
+                dir_path: watched_files.copy()
+                for dir_path, (_, watched_files) in self._watched_dirs.items()
+            }
+
+    def restore_watched_dir(self, dir_path: DirPath) -> None:
+        with self._lock:
+            if dir_path not in self._watched_dirs:
+                return
+            dir_path.mkdir(parents=True, exist_ok=True)
+            watch, watched_files = self._watched_dirs[dir_path]
+            self._observer.unschedule(watch)
+            self._watched_dirs[dir_path] = (
+                self._observer.schedule(self._event_handler, str(dir_path)),
+                watched_files,
+            )
+
+    def stop(self) -> None:
+        self._observer.stop()
+        self._observer.join()
+
+
+class _EventHandler(FileSystemEventHandler):
+    DEBOUNCE_WINDOW = 0.05
+    SELF_WRITE_WINDOW = 0.5
+
+    def __init__(self, watcher: _Watcher) -> None:
+        self._watcher = watcher
+        self._lock = Lock()
+        self._callbacks: dict[FilePath, Callback] = {}
+        self._debounce_timers: dict[FilePath, Timer] = {}
+        self._self_writes_ts: dict[FilePath, float] = {}
+
+    def set_callback(self, file_path: FilePath, callback: Callback) -> None:
+        with self._lock:
+            self._callbacks[file_path] = callback
+
+    def unset_callback(self, file_path: FilePath) -> None:
+        with self._lock:
+            self._callbacks.pop(file_path, None)
+
+    def mark_self_write(self, file_path: FilePath) -> None:
+        with self._lock:
+            self._self_writes_ts[file_path] = monotonic()
+
+    def _is_self_write(self, file_path: FilePath) -> bool:
+        # not protected by the lock because it's only called internally
+        ts = self._self_writes_ts.get(file_path)
+        if ts is not None and monotonic() - ts < self.SELF_WRITE_WINDOW:
+            return True
+        return False
+
+    def dispatch(self, event: FileSystemEvent) -> None:
+        if event.is_directory:
+            if not isinstance(event, (DirDeletedEvent, DirMovedEvent)):
+                return
+            watched_dirs = self._watcher.get_watched_dirs()
+            for dir_path in self._paths_from_event(event):
+                if dir_path in watched_dirs:
+                    self._on_dir_deleted(dir_path, watched_dirs[dir_path])
+        else:
+            for file_path in self._paths_from_event(event):
+                self._on_file_modified(file_path)
+
+    def _on_dir_deleted(self, dir_path: DirPath, watched_files: set[FilePath]) -> None:
+        sleep(self.DEBOUNCE_WINDOW)  # low-tech debounce
+        self._watcher.restore_watched_dir(dir_path)
+        for file_path in watched_files:
+            self._on_file_modified(file_path)
+
+    def _on_file_modified(self, file_path: FilePath) -> None:
+        with self._lock:
+            if file_path not in self._callbacks or self._is_self_write(file_path):
+                return
+
+            if file_path in self._debounce_timers:
+                self._debounce_timers[file_path].cancel()
+
+            timer = Timer(
+                self.DEBOUNCE_WINDOW,
+                self._scheduled_callback,
+                args=(file_path, self._callbacks[file_path]),
+            )
+            self._debounce_timers[file_path] = timer
+            timer.start()
+
+    def _scheduled_callback(self, file_path: FilePath, callback: Callback) -> None:
+        with self._lock:
+            self._debounce_timers.pop(file_path, None)
+        callback()
+
+    def _paths_from_event(self, event: FileSystemEvent) -> list[Path]:
+        paths = []
+        if self._watcher.TMP_FILE_PREFIX not in event.src_path:
+            paths.append(Path(event.src_path).resolve())
+        dest_path = getattr(event, "dest_path", "")
+        if dest_path and self._watcher.TMP_FILE_PREFIX not in dest_path:
+            paths.append(Path(dest_path).resolve())
+        return paths
+
+
+watcher = _Watcher()

syncwave-0.1.1/src/syncwave/watcher.py

@@ -1,139 +0,0 @@
-from pathlib import Path
-from threading import Lock, Timer
-from time import monotonic
-from typing import Callable, Union
-
-from watchdog.events import (
-    DirModifiedEvent,
-    FileModifiedEvent,
-    FileSystemEvent,
-    FileSystemEventHandler,
-)
-from watchdog.observers import Observer
-from watchdog.observers.api import ObservedWatch
-
-DirPath = Path
-FilePath = Path
-Callback = Callable[[], None]
-
-
-class _Watcher:
-    SELF_WRITE_WINDOW = 0.5
-
-    def __init__(self) -> None:
-        self._lock = Lock()
-        # mapping dir_path -> (watch object, set of file_paths)
-        self._watched_dirs: dict[DirPath, tuple[ObservedWatch, set[FilePath]]] = {}
-        self._self_writes_ts: dict[FilePath, float] = {}
-        self._callbacks: dict[FilePath, Callback] = {}
-
-        self._observer = Observer()
-        self._event_handler = _EventHandler(self)
-        self._observer.start()
-
-    def stop(self) -> None:
-        self._observer.stop()
-        self._observer.join()
-
-    def watch(self, file_path: FilePath, callback: Callback) -> None:
-        dir_path = file_path.parent
-
-        if not file_path.is_file():
-            raise ValueError(f"Path {file_path} is not a file.")
-
-        with self._lock:
-            # if the directory is already being watched...
-            if dir_path in self._watched_dirs:
-                _, watched_files = self._watched_dirs[dir_path]
-
-                # ...but the file is not in the set, add it
-                if file_path not in watched_files:
-                    watched_files.add(file_path)
-
-                # and in any case, update the callback before returning
-                self._callbacks[file_path] = callback
-                return
-
-            # otherwise, schedule the directory and register the callback
-            self._watched_dirs[dir_path] = (
-                self._observer.schedule(self._event_handler, str(dir_path)),
-                {file_path},
-            )
-            self._callbacks[file_path] = callback
-
-    def unwatch(self, file_path: FilePath) -> None:
-        dir_path = file_path.parent
-
-        with self._lock:
-            # remove the callback
-            self._callbacks.pop(file_path, None)
-
-            # if the directory is not being watched, do nothing
-            if dir_path not in self._watched_dirs:
-                return
-
-            watch, watched_files = self._watched_dirs[dir_path]
-
-            # if the file is in the set, remove it
-            if file_path in watched_files:
-                watched_files.remove(file_path)
-
-            # if the set is empty, unschedule the directory
-            if not watched_files:
-                self._observer.unschedule(watch)
-                del self._watched_dirs[dir_path]
-
-    def mark_self_write(self, file_path: FilePath) -> None:
-        with self._lock:
-            self._self_writes_ts[file_path] = monotonic()
-
-    def _is_self_write(self, file_path: FilePath) -> bool:
-        with self._lock:
-            ts = self._self_writes_ts.get(file_path)
-            if ts is not None and monotonic() - ts < self.SELF_WRITE_WINDOW:
-                return True
-        return False
-
-
-class _EventHandler(FileSystemEventHandler):
-    DEBOUNCE_WINDOW = 0.05
-
-    def __init__(self, watcher: _Watcher) -> None:
-        self.lock = Lock()
-        self.watcher = watcher
-        self.debounce_timers: dict[FileSystemEvent, Timer] = {}
-
-    def on_modified(self, event: Union[FileModifiedEvent, DirModifiedEvent]) -> None:
-        if event.is_directory or isinstance(event, DirModifiedEvent):
-            return
-
-        file_path = Path(event.src_path).resolve()
-
-        if self.watcher._is_self_write(file_path):
-            return
-
-        callback = self.watcher._callbacks.get(file_path)
-        if callback is None:
-            return
-
-        with self.lock:
-            if event in self.debounce_timers:
-                self.debounce_timers[event].cancel()
-
-            timer = Timer(
-                self.DEBOUNCE_WINDOW,
-                self.schedule_callback,
-                args=(event, callback),
-            )
-            self.debounce_timers[event] = timer
-            timer.start()
-
-    def schedule_callback(self, event: FileSystemEvent, callback: Callback) -> None:
-        try:
-            callback()
-        finally:
-            with self.lock:
-                self.debounce_timers.pop(event, None)
-
-
-watcher = _Watcher()