yhttp 9.4.2__tar.gz → 9.5.0__tar.gz

{yhttp-9.4.2/yhttp.egg-info → yhttp-9.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yhttp
-Version: 9.4.2
+Version: 9.5.0
 Summary: A very micro http framework.
 Home-page: http://github.com/yhttp/yhttp
 Author: Vahid Mardani
@@ -29,7 +29,7 @@ License-File: LICENSE
 Requires-Dist: snam>=1.0.2
 Requires-Dist: easycli<2,>=1.10.1
 Requires-Dist: ujson
-Requires-Dist: inotify-simple
+Requires-Dist: watchdog
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{yhttp-9.4.2 → yhttp-9.5.0}/setup.py

@@ -18,7 +18,7 @@ dependencies = [
     'snam >= 1.0.2',
     'easycli >= 1.10.1, < 2',
     'ujson',
-    'inotify-simple',
+    'watchdog',
 ]
 
 

{yhttp-9.4.2 → yhttp-9.5.0}/tests/test_fswatcher.py

@@ -1,3 +1,5 @@
+from types import SimpleNamespace
+
 from yhttp.core.fswatcher import FSWatcher
 
 
@@ -50,3 +52,32 @@ def test_watcher(mktmptree, chdir):
         assert not w.wait()
 
         w.close()
+
+
+def test_moved_event_reports_watched_destination(tmp_path):
+    watched_file = tmp_path / 'watched.txt'
+    w = FSWatcher(files=[str(watched_file)])
+    w._watchfiles.add(str(watched_file))
+    event = SimpleNamespace(
+        event_type='moved', src_path=str(tmp_path / 'old.txt'),
+        dest_path=str(watched_file),
+    )
+
+    assert w._event_paths(event) == {str(watched_file)}
+
+
+def test_wait_collects_event_until_timeout(monkeypatch, tmp_path):
+    watched_file = tmp_path / 'watched.txt'
+    w = FSWatcher(files=[str(watched_file)])
+    w._watchfiles.add(str(watched_file))
+    w._events.put(SimpleNamespace(
+        event_type='modified', src_path=str(watched_file),
+    ))
+    # Start before the deadline, then report that the event arrived after it.
+    ticks = iter((0, 0.001, 0.006))
+    monkeypatch.setattr(
+        'yhttp.core.fswatcher.time.monotonic',
+        lambda: next(ticks)
+    )
+
+    assert w.wait(timeout=5) == {str(watched_file)}

yhttp-9.5.0/yhttp/core/fswatcher.py

@@ -0,0 +1,145 @@
+import fnmatch
+from glob import glob
+from os import path
+from queue import Empty, Queue
+import time
+
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+from .logging import logger
+
+
+DEFAULT_EXCLUDEDIRECTORIES = [
+    '**/__pycache__',
+    '**/.*',
+    '**/~*',
+]
+DEFAULT_EXCLUDEFILES = [
+    '**/.*',
+    '**/*~',
+    '**/4913',
+]
+
+
+class _EventHandler(FileSystemEventHandler):
+    def __init__(self, watcher):
+        self.watcher = watcher
+
+    def on_any_event(self, event):
+        if event.event_type not in ('created', 'deleted', 'modified', 'moved'):
+            return
+        # Watchdog reports a directory modification when an entry inside it
+        # changes. Inotify only reported the entry itself for the masks we
+        # used, so directory metadata events must not become change results.
+        if event.is_directory and event.event_type == 'modified':
+            return
+        self.watcher._events.put(event)
+
+
+class FSWatcher:
+    def __init__(self, directories=None, files=None, excludedirectories=None,
+                 excludefiles=None):
+        assert directories or files
+        self.directories = directories or []
+        self.files = files or []
+        self._observer = Observer()
+        self._events = Queue()
+        self._handler = _EventHandler(self)
+        self._watched_directories = set()
+        self._watchfiles = set()
+
+        self.excludedirectories = list(DEFAULT_EXCLUDEDIRECTORIES)
+        if excludedirectories:
+            self.excludedirectories.extend(excludedirectories)
+
+        self.excludefiles = list(DEFAULT_EXCLUDEFILES)
+        if excludefiles:
+            self.excludefiles.extend(excludefiles)
+
+    def _excludedirectory(self, node):
+        return any(fnmatch.fnmatchcase(node, pattern)
+                   for pattern in self.excludedirectories)
+
+    def _excludefile(self, node):
+        return any(fnmatch.fnmatchcase(node, pattern)
+                   for pattern in self.excludefiles)
+
+    def _refine_watches(self):
+        self._watched_directories = set()
+        self._watchfiles = set()
+
+        for pattern in self.directories:
+            for node in glob(pattern, recursive=True):
+                if path.isdir(node) and not self._excludedirectory(node):
+                    self._watched_directories.add(path.abspath(node))
+
+        for pattern in self.files:
+            for node in glob(pattern, recursive=True):
+                if path.isfile(node) and not self._excludefile(node):
+                    self._watchfiles.add(path.abspath(node))
+
+    def start(self):
+        self._refine_watches()
+        directories = set(self._watched_directories)
+        directories.update(path.dirname(node) for node in self._watchfiles)
+        for directory in directories:
+            logger.info(f'Adding watch for: {directory}')
+            self._observer.schedule(self._handler, directory, recursive=False)
+        self._observer.start()
+
+    def stop(self):
+        if self._observer.is_alive():
+            self._observer.stop()
+            self._observer.join()
+        self._clear_events()
+
+    def close(self):
+        self.stop()
+
+    def _clear_events(self):
+        while True:
+            try:
+                self._events.get_nowait()
+            except Empty:
+                break
+
+    def _event_paths(self, event):
+        paths = [event.src_path]
+        if event.event_type == 'moved':
+            paths.append(event.dest_path)
+
+        matching = set()
+        for node in paths:
+            node = path.abspath(node)
+            if self._excludefile(node):
+                continue
+            if node in self._watchfiles:
+                matching.add(node)
+            if (node in self._watched_directories or path.dirname(node) in
+                    self._watched_directories):
+                matching.add(node)
+        return matching
+
+    def wait(self, timeout=0):
+        changes = set()
+        deadline = time.monotonic() + max(timeout, 0) / 1000
+        # Watchdog delivers notifications asynchronously. A short initial wait
+        # lets zero-debounce callers observe events caused just before wait().
+        initial_wait = 0.25 if timeout <= 0 else max(timeout, 0) / 1000
+        while True:
+            if timeout <= 0:
+                remaining = initial_wait
+            else:
+                remaining = max(0, deadline - time.monotonic())
+            try:
+                event = self._events.get(timeout=remaining)
+            except Empty:
+                break
+            changes.update(self._event_paths(event))
+            if changes and timeout > 0 and time.monotonic() >= deadline:
+                break
+            if changes and timeout <= 0:
+                # Drain notifications already queued in this delivery batch.
+                continue
+        return changes

yhttp-9.5.0/yhttp/core/version.py

@@ -0,0 +1 @@
+__version__ = '9.5.0'

{yhttp-9.4.2 → yhttp-9.5.0/yhttp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yhttp
-Version: 9.4.2
+Version: 9.5.0
 Summary: A very micro http framework.
 Home-page: http://github.com/yhttp/yhttp
 Author: Vahid Mardani
@@ -29,7 +29,7 @@ License-File: LICENSE
 Requires-Dist: snam>=1.0.2
 Requires-Dist: easycli<2,>=1.10.1
 Requires-Dist: ujson
-Requires-Dist: inotify-simple
+Requires-Dist: watchdog
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{yhttp-9.4.2 → yhttp-9.5.0}/yhttp.egg-info/requires.txt

@@ -1,4 +1,4 @@
 snam>=1.0.2
 easycli<2,>=1.10.1
 ujson
-inotify-simple
+watchdog

yhttp-9.4.2/yhttp/core/fswatcher.py

@@ -1,137 +0,0 @@
-import time
-from os import path
-from glob import glob
-import fnmatch
-
-from inotify_simple import INotify, flags
-from .logging import logger
-
-
-DEFAULT_EXCLUDEDIRECTORIES = [
-    '**/__pycache__',
-    '**/.*',
-    '**/~*',
-]
-DEFAULT_EXCLUDEFILES = [
-    '**/.*',
-    '**/*~',
-    '**/4913',
-]
-
-
-class FSWatcher(INotify):
-    def __init__(self, directories=None, files=None, excludedirectories=None,
-                 excludefiles=None):
-        assert directories or files
-        super().__init__(closefd=False)
-        self._directorymask = flags.CREATE \
-            | flags.DELETE \
-            | flags.DELETE_SELF \
-            | flags.MOVE_SELF \
-            | flags.MOVED_FROM \
-            | flags.MOVED_TO \
-            | flags.MODIFY
-
-        self._filemask = flags.MODIFY | flags.DELETE_SELF | flags.MOVE_SELF
-        self.directories = directories or []
-        self.files = files or []
-        self._wds = {}
-
-        self.excludedirectories = []
-        self.excludedirectories.extend(DEFAULT_EXCLUDEDIRECTORIES)
-        if excludedirectories:
-            self.excludedirectories.extend(excludedirectories)
-
-        self.excludefiles = []
-        self.excludefiles.extend(DEFAULT_EXCLUDEFILES)
-        if excludefiles:
-            self.excludefiles.extend(excludefiles)
-
-    def _excludedirectory(self, node):
-        for pattern in self.excludedirectories:
-            if fnmatch.fnmatchcase(node, pattern):
-                return True
-
-        return False
-
-    def _excludefile(self, node):
-        for pattern in self.excludefiles:
-            if fnmatch.fnmatchcase(node, pattern):
-                return True
-
-        return False
-
-    def _refine_watches(self):
-        self._watchdirectories = set()
-        self._watchfiles = set()
-
-        for pattern in self.directories:
-            matches = glob(pattern, recursive=True)
-            for node in matches:
-                if path.isdir(node) and not self._excludedirectory(node):
-                    self._watchdirectories.add(node)
-
-        for pattern in self.files:
-            matches = glob(pattern, recursive=True)
-            for node in matches:
-                if path.isfile(node) and not self._excludefile(node):
-                    self._watchfiles.add(node)
-
-    def watch(self, node, mask):
-        logger.info(f'Adding watch for: {node}')
-        wd = self.add_watch(node, mask)
-        self._wds[wd] = node
-
-    def start(self):
-        self._refine_watches()
-        for node in self._watchdirectories:
-            self.watch(node, self._directorymask)
-
-        for node in self._watchfiles:
-            self.watch(node, self._filemask)
-
-    def stop(self):
-        self._readall()
-        for wd in self._wds:
-            self.rm_watch(wd)
-
-        self._wds = {}
-
-    def close(self):
-        self._poller.unregister(self.fileno())
-        super().close()
-
-    def wait(self, timeout=0):
-        changes = set()
-        starttime = None
-        while True:
-            for e in self.read(timeout):
-                # cannot simulate this situation, but I think it's enough to
-                # raise error
-                if e.wd == -1:  # pragma: no cover
-                    raise OSError('INotify event queue overflow')
-
-                # uncomment to debug masks(flags)
-                # fl = [f.name for f in flags.from_mask(e.mask)]
-                if e.mask & flags.IGNORED:
-                    continue
-
-                if not (e.mask & flags.ISDIR) and e.name:
-                    fn = path.join(self._wds[e.wd], e.name)
-                    if e.name and self._excludefile(fn):
-                        continue
-                else:
-                    fn = self._wds[e.wd]
-
-                changes.add(fn)
-
-            if changes:
-                if starttime is None:
-                    starttime = time.perf_counter()
-                    continue
-                timeout -= (time.perf_counter() - starttime) * 1000
-
-            if timeout <= 0:
-                break
-
-        return changes

yhttp-9.4.2/yhttp/core/version.py

@@ -1 +0,0 @@
-__version__ = '9.4.2'