hmr 0.1.2__tar.gz → 0.2.1__tar.gz

{hmr-0.1.2 → hmr-0.2.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: hmr
-Version: 0.1.2
+Version: 0.2.1
 Summary: Hot Module Reload for Python
 Project-URL: repository, https://github.com/promplate/pyth-on-line/tree/reactivity
 Requires-Python: >=3.12
-Requires-Dist: watchfiles<2,>=0.21
+Requires-Dist: watchfiles<2,>=0.21; sys_platform != "emscripten"
 

{hmr-0.1.2 → hmr-0.2.1}/pyproject.toml

@@ -4,9 +4,9 @@ dynamic = []
 requires-python = ">=3.12"
 description = "Hot Module Reload for Python"
 dependencies = [
-    "watchfiles>=0.21,<2",
+    "watchfiles>=0.21,<2 ; sys_platform != 'emscripten'",
 ]
-version = "0.1.2"
+version = "0.2.1"
 
 [project.scripts]
 hmr = "reactivity.hmr:cli"

{hmr-0.1.2 → hmr-0.2.1}/reactivity/helpers.py

@@ -13,32 +13,29 @@ class Memoized[T](Subscribable, BaseComputation[T]):
         self.fn = fn
         self.is_stale = True
         self.cached_value: T
-        self._recompute = False
+
+    def recompute(self):
+        self._before()
+        try:
+            self.cached_value = self.fn()
+            self.is_stale = False
+        finally:
+            self._after()
 
     def trigger(self):
-        self.track()
-        if self._recompute:
-            self._recompute = False
-            self._before()
-            try:
-                self.cached_value = self.fn()
-                self.is_stale = False
-            finally:
-                self._after()
-        else:
-            self.invalidate()
+        self.invalidate()
 
     def __call__(self):
+        self.track()
         if self.is_stale:
-            self._recompute = True
-            self.trigger()
-            assert not self._recompute
+            self.recompute()
         return self.cached_value
 
     def invalidate(self):
         if not self.is_stale:
             del self.cached_value
             self.is_stale = True
+            self.notify()
 
 
 class MemoizedProperty[T, I]:

{hmr-0.1.2 → hmr-0.2.1}/reactivity/hmr.py

@@ -8,6 +8,7 @@ from importlib.util import spec_from_loader
 from inspect import currentframe
 from pathlib import Path
 from runpy import run_path
+from site import getsitepackages
 from types import ModuleType, TracebackType
 from typing import Any
 
@@ -115,7 +116,7 @@ class ReactiveModuleFinder(MetaPathFinder):
     def __init__(self, includes: Iterable[str] = ".", excludes: Iterable[str] = ()):
         super().__init__()
         self.includes = [Path(i).resolve() for i in includes]
-        self.excludes = [Path(e).resolve() for e in excludes]
+        self.excludes = [Path(e).resolve() for e in (*excludes, *getsitepackages())]
 
     def _accept(self, path: Path):
         return path.is_file() and not is_relative_to_any(path, self.excludes) and is_relative_to_any(path, self.includes)
@@ -149,7 +150,7 @@ def patch_module(name_or_module: str | ModuleType):
     return m
 
 
-def patch_meta_path(includes: Iterable[str] = (".",), excludes: Iterable[str] = (".venv",)):
+def patch_meta_path(includes: Iterable[str] = (".",), excludes: Iterable[str] = ()):
     sys.meta_path.insert(0, ReactiveModuleFinder(includes, excludes))
 
 
@@ -278,9 +279,10 @@ def cli():
         print("\n Usage: hmr <entry file>, just like python <entry file>\n")
         exit(1)
     entry = sys.argv[-1]
-    assert Path(entry).is_file(), f"{entry} is not a file"
+    if not (path := Path(entry)).is_file():
+        raise FileNotFoundError(path.resolve())
     sys.path.insert(0, ".")
-    SyncReloader(entry, excludes={".venv"}).keep_watching_until_interrupt()
+    SyncReloader(entry).keep_watching_until_interrupt()
 
 
-__version__ = "0.1.2"
+__version__ = "0.2.1"

{hmr-0.1.2 → hmr-0.2.1}/reactivity/primitives.py

@@ -1,4 +1,4 @@
-from collections.abc import Callable
+from collections.abc import Callable, Iterable
 from typing import Any, Self, overload
 from weakref import WeakKeyDictionary, WeakSet
 
@@ -9,17 +9,19 @@ class Subscribable:
         self.subscribers = set[BaseComputation]()
 
     def track(self):
-        for computation in _current_computations:
-            if computation is not self:
-                self.subscribers.add(computation)
-                computation.dependencies.add(self)
+        if not _current_computations:
+            return
+        last = _current_computations[-1]
+        if last is not self:
+            self.subscribers.add(last)
+            last.dependencies.add(self)
 
     def notify(self):
         if _batches:
-            _batches[-1].callbacks.extend(self.subscribers)
+            schedule_callbacks(self.subscribers)
         else:
-            for subscriber in {*self.subscribers}:
-                subscriber.trigger()
+            with Batch(force_flush=False):
+                schedule_callbacks(self.subscribers)
 
 
 class BaseComputation[T]:
@@ -46,9 +48,9 @@ class BaseComputation[T]:
     def __exit__(self, *_):
         self.dispose()
 
-    def trigger(self) -> T: ...
+    def trigger(self) -> Any: ...
 
-    def __call__(self):
+    def __call__(self) -> T:
         return self.trigger()
 
 
@@ -119,22 +121,38 @@ class Effect[T](BaseComputation[T]):
 
 
 class Batch:
-    def __init__(self):
-        self.callbacks: list[BaseComputation] = []
+    def __init__(self, force_flush=True):
+        self.callbacks = set[BaseComputation]()
+        self.force_flush = force_flush
 
     def flush(self):
-        callbacks = set(self.callbacks)
-        self.callbacks.clear()
-        for computation in callbacks:
-            computation.trigger()
+        triggered = set()
+        while self.callbacks:
+            callbacks = self.callbacks - triggered
+            self.callbacks.clear()
+            for computation in callbacks:
+                if computation in self.callbacks:
+                    continue  # skip if re-added during callback
+                computation.trigger()
+                triggered.add(computation)
 
     def __enter__(self):
         _batches.append(self)
 
     def __exit__(self, *_):
-        last = _batches.pop()
+        if self.force_flush or len(_batches) == 1:
+            try:
+                self.flush()
+            finally:
+                last = _batches.pop()
+        else:
+            last = _batches.pop()
+            schedule_callbacks(self.callbacks)
         assert last is self
-        self.flush()
 
 
 _batches: list[Batch] = []
+
+
+def schedule_callbacks(callbacks: Iterable[BaseComputation]):
+    _batches[-1].callbacks.update(callbacks)