yhttp 9.4.2__tar.gz → 9.6.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yhttp
-Version: 9.4.2
+Version: 9.6.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.6.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.6.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.4.2 → yhttp-9.6.0}/tests/test_static.py

@@ -1,6 +1,11 @@
 from os import path
+from types import SimpleNamespace
 
 from bddrest import status, response, when
+import pytest
+
+from yhttp.core.headerset import HeaderSet
+from yhttp.core.static import file as staticfile
 
 
 def test_staticfile(app, httpreq, tmpdir):
@@ -17,6 +22,117 @@ def test_staticfile(app, httpreq, tmpdir):
         assert response == 'foo'
 
 
+def test_staticfile_byte_ranges(app, httpreq, tmpdir):
+    filename = path.join(tmpdir, 'range.txt')
+    with open(filename, 'wb') as f:
+        f.write(b'0123456789')
+
+    app.staticfile(r'/range\.txt', filename)
+
+    with httpreq('/range.txt', headers={'Range': 'bytes=2-5'}):
+        assert status == 206
+        assert response.headers['accept-ranges'] == 'bytes'
+        assert response.headers['content-range'] == 'bytes 2-5/10'
+        assert response.headers['content-length'] == '4'
+        assert response == '2345'
+
+    with httpreq('/range.txt', headers={'Range': 'bytes=-3'}):
+        assert status == 206
+        assert response.headers['content-range'] == 'bytes 7-9/10'
+        assert response == '789'
+
+    with httpreq('/range.txt', headers={'Range': 'bytes=20-'}):
+        assert status == 416
+        assert response.headers['content-range'] == 'bytes */10'
+
+    with httpreq('/range.txt', headers={'Range': 'bytes=-0'}):
+        assert status == 416
+        assert response.headers['content-range'] == 'bytes */10'
+
+    with httpreq('/range.txt', headers={'Range': 'invalid'}):
+        assert status == 200
+        assert response.headers['content-length'] == '10'
+        assert response == '0123456789'
+
+    with httpreq(
+        '/range.txt', headers={'Range': 'bytes=0-1,4-5'}
+    ):
+        assert status == 200
+        assert response == '0123456789'
+
+
+@pytest.mark.parametrize('range_header', [
+    'bytes=10',
+    'bytes=-',
+    'bytes=3-1',
+    'bytes=abc-def',
+    'bytes=--1',
+])
+def test_malformed_or_unsupported_ranges_send_full_file(
+    app, httpreq, tmpdir, range_header,
+):
+    filename = path.join(tmpdir, 'range.txt')
+    with open(filename, 'wb') as f:
+        f.write(b'0123456789')
+    app.staticfile(r'/range\.txt', filename)
+
+    with httpreq('/range.txt', headers={'Range': range_header}):
+        assert status == 200
+        assert response == '0123456789'
+
+
+def test_empty_static_file(app, httpreq, tmpdir):
+    filename = path.join(tmpdir, 'empty.txt')
+    open(filename, 'wb').close()
+    app.staticfile(r'/empty\.txt', filename)
+
+    with httpreq('/empty.txt'):
+        assert status == 200
+        assert response.headers['content-length'] == '0'
+        assert response == ''
+
+
+def test_staticfile_short_read_after_size_lookup(tmpdir):
+    filename = path.join(tmpdir, 'short.txt')
+    with open(filename, 'wb') as f:
+        f.write(b'content')
+
+    handler = staticfile(filename)
+    request = SimpleNamespace(
+        verb='get', environ={},
+        response=SimpleNamespace(headers=HeaderSet()),
+    )
+    open(filename, 'wb').close()
+
+    assert list(handler(request)) == []
+
+
+def test_staticdirectory_byte_ranges(app, httpreq, tmpdir):
+    filename = path.join(tmpdir, 'range.txt')
+    with open(filename, 'wb') as f:
+        f.write(b'0123456789')
+    app.staticdirectory('/static', tmpdir)
+
+    with httpreq('/static/range.txt', headers={'Range': 'bytes=3-'}):
+        assert status == 206
+        assert response.headers['content-range'] == 'bytes 3-9/10'
+        assert response == '3456789'
+
+
+def test_range_request_with_if_range_sends_full_file(app, httpreq, tmpdir):
+    filename = path.join(tmpdir, 'range.txt')
+    with open(filename, 'wb') as f:
+        f.write(b'0123456789')
+    app.staticfile(r'/range\.txt', filename)
+
+    with httpreq('/range.txt', headers={
+        'Range': 'bytes=2-5',
+        'If-Range': '"unknown-validator"',
+    }):
+        assert status == 200
+        assert response == '0123456789'
+
+
 def test_staticdirectory(app, httpreq, mktmptree):
     temproot = mktmptree({
         'bar': {

yhttp-9.6.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.4.2 → yhttp-9.6.0}/yhttp/core/static.py

@@ -8,21 +8,94 @@ from . import statuses
 CHUNKSIZE = 1024 * 10
 
 
+def _byte_range(request, length):
+    """Return the selected byte interval, or None when Range is ignored."""
+    if request.verb != 'get' or 'HTTP_IF_RANGE' in request.environ:
+        return None
+
+    value = request.environ.get('HTTP_RANGE')
+    if not value or '=' not in value:
+        return None
+
+    unit, spec = value.split('=', 1)
+    if unit.strip().lower() != 'bytes' or ',' in spec:
+        # Multiple ranges are optional; ignore them and send the full entity.
+        return None
+
+    spec = spec.strip()
+    if '-' not in spec:
+        return None
+    first, last = (part.strip() for part in spec.split('-', 1))
+    if not first and not last:
+        return None
+
+    try:
+        if not first:
+            suffix_length = int(last)
+            if suffix_length < 0:
+                return None
+            if suffix_length == 0 or length == 0:
+                return False
+            return max(0, length - suffix_length), length - 1
+
+        start = int(first)
+        if last:
+            end = int(last)
+            if end < start:
+                return None
+        else:
+            end = length - 1
+    except ValueError:
+        return None
+
+    if start >= length:
+        return False
+    return start, min(end, length - 1)
+
+
+def _stream_file(request, filename, length, contenttype):
+    response = request.response
+    response.contenttype = contenttype
+    response.headers['accept-ranges'] = 'bytes'
+
+    byte_range = _byte_range(request, length)
+    if byte_range is False:
+        response.status = '416 Range Not Satisfiable'
+        response.headers['content-range'] = f'bytes */{length}'
+        response.length = 0
+        yield b''
+        return
+
+    if byte_range is None:
+        response.length = length
+        start, end = 0, length - 1
+    else:
+        start, end = byte_range
+        response.status = '206 Partial Content'
+        response.headers['content-range'] = f'bytes {start}-{end}/{length}'
+        response.length = end - start + 1
+
+    if not response.length:
+        yield b''
+        return
+
+    with open(filename, 'rb') as f:
+        f.seek(start)
+        remaining = response.length
+        while remaining:
+            chunk = f.read(min(CHUNKSIZE, remaining))
+            if not chunk:
+                break
+            remaining -= len(chunk)
+            yield chunk
+
+
 def file(filename):
     length = path.getsize(filename)
     type_ = guess_type(path.split(filename)[1])[0]
 
     def get(request):
-        response = request.response
-        response.length = length
-        response.contenttype = type_
-        with open(filename, 'rb') as f:
-            while True:
-                chunk = f.read(CHUNKSIZE)
-                if not chunk:
-                    break
-
-                yield chunk
+        yield from _stream_file(request, filename, length, type_)
 
     return get
 
@@ -145,14 +218,11 @@ def directory(rootpath, default=False, autoindex=True, fallback=False):
             if not path.exists(target):
                 raise statuses.notfound()
 
-        response.length = path.getsize(target)
-        response.contenttype = guess_type(path.split(target)[1])[0]
-        with open(target, 'rb') as f:
-            while True:
-                chunk = f.read(CHUNKSIZE)
-                if not chunk:
-                    break
-
-                yield chunk
+        yield from _stream_file(
+            request,
+            target,
+            path.getsize(target),
+            guess_type(path.split(target)[1])[0],
+        )
 
     return get

yhttp-9.6.0/yhttp/core/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yhttp
-Version: 9.4.2
+Version: 9.6.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.6.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'