syncwave 0.1.0__tar.gz

syncwave-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Lucas Iannitello
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

syncwave-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.3
+Name: syncwave
+Version: 0.1.0
+Summary: Make your code reactive; Turn plain JSONs into a live data store, two-way synced with Python objects.
+Keywords: 
+Author: Lucas Iannitello
+Author-email: Lucas Iannitello <lucas.iannitello@protonmail.com>
+License: MIT License
+         
+         Copyright (c) 2025 Lucas Iannitello
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: watchdog>=6.0.0
+Requires-Python: >=3.9
+Project-URL: Documentation, https://github.com/iannitello/syncwave
+Project-URL: Homepage, https://github.com/iannitello/syncwave
+Project-URL: Issues, https://github.com/iannitello/syncwave/issues
+Project-URL: Repository, https://github.com/iannitello/syncwave
+Description-Content-Type: text/markdown
+
+# Syncwave
+
+Make your code reactive; Turn plain JSONs into a live data store, two-way synced with Python objects.
+
+> [!WARNING]
+> Syncwave is under active development. Until version **1.0**, any minor release (`0.x`) may introduce breaking API changes. Pin the exact version to use in production.
+>
+> Version **1.0** will be released when the library is stable, feature-complete, and tested.
+
+## Getting Started
+
+Install from [PyPI](https://pypi.org):
+
+```shell
+# pip
+pip install syncwave
+
+# uv
+uv add syncwave
+```
+
+Bind a Pydantic model to a JSON file with `@syncwave.register`. Syncwave automatically synchronizes the file with your in-memory objects.
+
+```python
+from pydantic import BaseModel
+
+from syncwave import Syncwave
+
+# 1. Initialise Syncwave with a directory to hold the JSON files.
+syncwave = Syncwave(data_dir="data")
+
+
+# 2. Define and register a model
+# This also creates a JSON file at `data/customers.json` if it doesn't exist.
+# Otherwise, the data is loaded into the `syncwave` instance.
+@syncwave.register(name="customers", key="id")
+class Customer(BaseModel):
+    id: int
+    name: str
+    age: int
+
+
+# syncwave acts as a read-only dict with:
+#     keys   -> collection name (e.g. "customers")
+#     values -> corresponding SyncStore
+# A SyncStore also acts as a read-only dict:
+#     keys   -> model's key field (e.g. `id`)
+#     values -> live Pydantic model instances
+
+
+# 3. Create and mutate instances like you would with normal Pydantic objects.
+john = Customer(id=1, name="John Doe", age=30)  # Automatically inserted in JSON
+john.age = 31  # Automatically updated in JSON
+
+
+# 4. Delete instances with `SyncStore.delete(key)`.
+syncwave["customers"].delete(1)  # Removed from syncwave and JSON
+
+# 5. External edits propagate automatically.
+# First, let's add a new customer to populate the JSON file.
+Customer(id=2, name="Jane Doe", age=25)
+
+input("Now edit 'data/customers.json' and press Enter…")
+print(syncwave)
+```
+
+## License
+
+Syncwave is licensed under the MIT License.

syncwave-0.1.0/README.md

@@ -0,0 +1,69 @@
+# Syncwave
+
+Make your code reactive; Turn plain JSONs into a live data store, two-way synced with Python objects.
+
+> [!WARNING]
+> Syncwave is under active development. Until version **1.0**, any minor release (`0.x`) may introduce breaking API changes. Pin the exact version to use in production.
+>
+> Version **1.0** will be released when the library is stable, feature-complete, and tested.
+
+## Getting Started
+
+Install from [PyPI](https://pypi.org):
+
+```shell
+# pip
+pip install syncwave
+
+# uv
+uv add syncwave
+```
+
+Bind a Pydantic model to a JSON file with `@syncwave.register`. Syncwave automatically synchronizes the file with your in-memory objects.
+
+```python
+from pydantic import BaseModel
+
+from syncwave import Syncwave
+
+# 1. Initialise Syncwave with a directory to hold the JSON files.
+syncwave = Syncwave(data_dir="data")
+
+
+# 2. Define and register a model
+# This also creates a JSON file at `data/customers.json` if it doesn't exist.
+# Otherwise, the data is loaded into the `syncwave` instance.
+@syncwave.register(name="customers", key="id")
+class Customer(BaseModel):
+    id: int
+    name: str
+    age: int
+
+
+# syncwave acts as a read-only dict with:
+#     keys   -> collection name (e.g. "customers")
+#     values -> corresponding SyncStore
+# A SyncStore also acts as a read-only dict:
+#     keys   -> model's key field (e.g. `id`)
+#     values -> live Pydantic model instances
+
+
+# 3. Create and mutate instances like you would with normal Pydantic objects.
+john = Customer(id=1, name="John Doe", age=30)  # Automatically inserted in JSON
+john.age = 31  # Automatically updated in JSON
+
+
+# 4. Delete instances with `SyncStore.delete(key)`.
+syncwave["customers"].delete(1)  # Removed from syncwave and JSON
+
+# 5. External edits propagate automatically.
+# First, let's add a new customer to populate the JSON file.
+Customer(id=2, name="Jane Doe", age=25)
+
+input("Now edit 'data/customers.json' and press Enter…")
+print(syncwave)
+```
+
+## License
+
+Syncwave is licensed under the MIT License.

syncwave-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "syncwave"
+version = "0.1.0"
+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" }]
+requires-python = ">=3.9"
+dependencies = [
+    "pydantic>=2.11.7",
+    "watchdog>=6.0.0",
+]
+license = { file = "LICENSE" }
+keywords = []
+classifiers = []
+
+[project.urls]
+Homepage = "https://github.com/iannitello/syncwave"
+Documentation = "https://github.com/iannitello/syncwave"
+Repository = "https://github.com/iannitello/syncwave"
+Issues = "https://github.com/iannitello/syncwave/issues"
+
+[build-system]
+requires = ["uv_build>=0.8.4,<0.9.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.12.7",
+]
+
+[tool.ruff.lint]
+extend-select = ["E501"]

syncwave-0.1.0/src/syncwave/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "0.1.0"
+
+
+from .syncwave import SyncStore, Syncwave
+
+__all__ = ["SyncStore", "Syncwave"]

syncwave-0.1.0/src/syncwave/io.py

@@ -0,0 +1,98 @@
+import json
+import os
+from pathlib import Path
+from tempfile import mkstemp
+from threading import Lock, Timer
+from typing import Any, Callable
+
+from .watcher import watcher
+
+JSONData = Any
+DataProvider = Callable[[], JSONData]
+
+
+class _IO:
+    ENCODING = "utf-8"
+    DEFAULT_JSON_CONTENT = {}
+    DUMPS_CONFIG = {"indent": 2, "ensure_ascii": False}
+    DEBOUNCE_WINDOW = 0.05
+
+    def __init__(self) -> None:
+        self._lock = Lock()
+        self._debounce_timers: dict[Path, Timer] = {}
+        self._pending_data_providers: dict[Path, DataProvider] = {}
+
+    def json_dumps(self, data: JSONData) -> str:
+        return json.dumps(data, **self.DUMPS_CONFIG)
+
+    def init_json_file(self, path: Path) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        if path.is_dir():
+            raise IsADirectoryError(f"Path '{path}' is a directory, not a file.")
+        if not path.exists() or path.stat().st_size == 0:
+            self._atomic_write(path, self.DEFAULT_JSON_CONTENT)
+            return
+        try:
+            with path.open(encoding=self.ENCODING) as f:
+                json.load(f)
+        except json.JSONDecodeError as e:
+            raise IOError(f"File '{path}' exists but is not a valid JSON file.") from e
+
+    def read_json(self, path: Path) -> JSONData:
+        with self._lock:
+            if path in self._pending_data_providers:
+                return self._pending_data_providers[path]()
+        with path.open(encoding=self.ENCODING) as f:
+            return json.load(f)
+
+    def write_json(self, path: Path, data_provider: DataProvider) -> None:
+        with self._lock:
+            if path in self._debounce_timers:
+                self._debounce_timers[path].cancel()
+
+            self._pending_data_providers[path] = data_provider
+
+            timer = Timer(
+                self.DEBOUNCE_WINDOW,
+                self._scheduled_write,
+                args=(path, data_provider),
+            )
+            self._debounce_timers[path] = timer
+            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)
+
+    def _atomic_write(self, path: Path, data: JSONData) -> None:
+        fd, tmp_path = mkstemp(prefix=".tmp_", suffix=".json", dir=path.parent)
+        try:
+            with os.fdopen(fd, "w", encoding=self.ENCODING) as tmp_file:
+                json.dump(data, tmp_file, **self.DUMPS_CONFIG)
+                tmp_file.write("\n")
+                tmp_file.flush()
+                os.fsync(tmp_file.fileno())
+
+            # Atomically replace the target file
+            watcher.mark_self_write(path)
+            os.replace(tmp_path, path)
+
+        except Exception as e:
+            # Attempt to remove temporary file on error
+            try:
+                os.remove(tmp_path)
+            except OSError:
+                pass
+            # Raise a clear error message including context
+            raise IOError(
+                f"Failed to write JSON to '{path}'. "
+                f"Temporary file '{tmp_path}' removed. Original error: {e}"
+            ) from e
+
+
+io = _IO()

syncwave-0.1.0/src/syncwave/syncwave.py

@@ -0,0 +1,223 @@
+import json
+import threading
+from collections.abc import Mapping
+from inspect import isclass
+from pathlib import Path
+from typing import Any, Callable, Iterator, Optional, Type, Union, get_args
+
+from pydantic import BaseModel, ValidationError
+
+from .io import io
+from .watcher import watcher
+
+# Only acceptable types for the key field to be used as a JSON key
+JSONKey = Union[str, int, float, bool, None]
+
+
+def _validate_key_type(cls: Type[BaseModel], key: str) -> None:
+    # This will work if the key field is a basic type (str, int, float, bool, or None),
+    # but will fail for more complex types (Union[str, int], Optional[str], etc.).
+    # In that case skip the validation.
+    key_type = cls.model_fields[key].annotation
+    if key_type in get_args(JSONKey):
+        return
+    raise TypeError(
+        f"The key field '{key}' in class '{cls.__module__}.{cls.__qualname__}' will be "
+        "used as a JSON key. It must be a basic type (str, int, float, bool, or None), "
+        f"not {key_type.__name__ if hasattr(key_type, '__name__') else str(key_type)}."
+    )
+
+
+class SyncStore(Mapping[JSONKey, BaseModel]):
+    def __init__(
+        self,
+        syncwave: "Syncwave",
+        cls: Type[BaseModel],
+        *,
+        name: Optional[str] = None,
+        key: str,
+        skip_key_validation: bool = False,
+        file_name: Optional[str] = None,
+        sub_dir: Optional[Union[Path, str]] = None,
+        file_path: Optional[Union[Path, str]] = None,
+        # in_memory: bool = True,  # TODO: implement in_memory
+    ) -> None:
+        if not isinstance(syncwave, Syncwave):
+            raise ValueError("The syncwave argument must be an instance of Syncwave.")
+        if not (isclass(cls) and issubclass(cls, BaseModel)):
+            raise ValueError("Only subclasses of BaseModel can be used.")
+        if (name_ := name or cls.__name__.lower()) in syncwave:
+            raise ValueError(f"The name '{name_}' is already registered.")
+        if cls in [store.cls for store in syncwave.values()]:
+            raise ValueError(f"The class '{cls.__name__}' is already registered.")
+        if key not in cls.model_fields:
+            raise ValueError(f"'{cls.__name__}' does not have a field '{key}'.")
+        if not skip_key_validation:
+            _validate_key_type(cls, key)
+
+        self.syncwave = syncwave
+        self.cls = cls
+        self.name = name_
+        self.key = key
+        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._patch_cls()
+        io.init_json_file(self.path)
+        self.load()
+        watcher.watch(self.path, self.load)
+        self.syncwave._swd[self.name] = self
+
+    def __getitem__(self, key: JSONKey) -> BaseModel:
+        with self._lock:
+            return self._ssd[key]
+
+    def __iter__(self) -> Iterator[JSONKey]:
+        with self._lock:
+            # first, convert to a list so the iterator is over a frozen object
+            return iter(list(self._ssd))
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._ssd)
+
+    def __repr__(self) -> str:
+        with self._lock:
+            return repr(self._ssd)
+
+    def __str__(self) -> str:
+        return io.json_dumps(self.to_dict())
+
+    def to_dict(self) -> dict[JSONKey, dict[str, Any]]:
+        with self._lock:
+            return {
+                key: model_instance.model_dump()
+                for key, model_instance in self._ssd.items()
+            }
+
+    def delete(self, key: JSONKey) -> None:
+        with self._lock:
+            del self._ssd[key]
+        io.write_json(self.path, self.to_dict)
+
+    def load(self) -> None:
+        try:
+            tmp_ssd: dict[JSONKey, BaseModel] = {}
+            for value in io.read_json(self.path).values():
+                model = self.cls.model_validate(value)
+                tmp_ssd[getattr(model, self.key)] = model
+            with self._lock:
+                # no JSONDecodeError or ValidationError at this point, safe to clear
+                self._ssd.clear()
+                self._ssd.update(tmp_ssd)
+        except (json.JSONDecodeError, ValidationError):
+            return
+        else:
+            io.write_json(self.path, self.to_dict)
+
+    def _get_path(
+        self,
+        file_name: str,
+        sub_dir: Union[Path, str, None],
+        file_path: Union[Path, str, None],
+    ) -> Path:
+        if file_path:
+            return Path(file_path).resolve()
+        file_name = file_name if file_name.endswith(".json") else f"{file_name}.json"
+        if sub_dir:
+            return (self.syncwave.data_dir / sub_dir / file_name).resolve()
+        return (self.syncwave.data_dir / file_name).resolve()
+
+    def _patch_cls(self) -> None:
+        # preserve original methods
+        original_init = self.cls.__init__
+        original_setattr = self.cls.__setattr__
+        original_delattr = self.cls.__delattr__
+
+        def __init__(model_instance: BaseModel, *args: Any, **kwargs: Any) -> None:
+            original_init(model_instance, *args, **kwargs)
+            key_value = getattr(model_instance, self.key)
+            with self._lock:
+                self._ssd[key_value] = model_instance
+            io.write_json(self.path, self.to_dict)
+
+        def __setattr__(model_instance: BaseModel, attr: str, value: Any) -> None:
+            # TODO check for edge cases
+            old_value = getattr(model_instance, attr)
+            original_setattr(model_instance, attr, value)
+            with self._lock:
+                if attr == self.key:
+                    del self._ssd[old_value]
+                    self._ssd[value] = model_instance
+            io.write_json(self.path, self.to_dict)
+
+        def __delattr__(model_instance: BaseModel, attr: str) -> None:
+            old_value = getattr(model_instance, attr)
+            original_delattr(model_instance, attr)
+            with self._lock:
+                if attr == self.key:
+                    del self._ssd[old_value]
+            io.write_json(self.path, self.to_dict)
+
+        # override original methods
+        self.cls.__init__ = __init__
+        self.cls.__setattr__ = __setattr__
+        self.cls.__delattr__ = __delattr__
+
+
+class Syncwave(Mapping[str, SyncStore]):
+    def __init__(self, data_dir: Union[str, Path]) -> None:
+        self.data_dir = Path(data_dir).resolve()
+        self._swd: dict[str, SyncStore] = {}  # actual mapping, swd = SyncWaveDict
+
+    def __getitem__(self, key: str) -> SyncStore:
+        return self._swd[key]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._swd)
+
+    def __len__(self) -> int:
+        return len(self._swd)
+
+    def __repr__(self) -> str:
+        return repr(self._swd)
+
+    def __str__(self) -> str:
+        return io.json_dumps(self.to_dict())
+
+    def to_dict(self) -> dict[str, dict[JSONKey, dict[str, Any]]]:
+        return {name: syncstore.to_dict() for name, syncstore in self._swd.items()}
+
+    def load(self) -> None:
+        for syncstore in self._swd.values():
+            syncstore.load()
+
+    def stop(self) -> None:
+        watcher.stop()
+
+    def register(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: str,
+        skip_key_validation: bool = False,
+        file_name: Optional[str] = None,
+        sub_dir: Optional[Union[Path, str]] = None,
+        file_path: Optional[Union[Path, str]] = None,
+        # in_memory: bool = True,  # TODO: implement in_memory
+    ) -> Callable[[Type[BaseModel]], Type[BaseModel]]:
+        def decorator(cls: Type[BaseModel]) -> Type[BaseModel]:
+            SyncStore(
+                self,
+                cls,
+                name=name,
+                key=key,
+                skip_key_validation=skip_key_validation,
+                file_name=file_name,
+                sub_dir=sub_dir,
+                file_path=file_path,
+            )
+            return cls
+
+        return decorator

syncwave-0.1.0/src/syncwave/watcher.py

@@ -0,0 +1,139 @@
+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()