hmr 0.1.1.1__tar.gz → 0.2.0__tar.gz

{hmr-0.1.1.1 → hmr-0.2.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: hmr
-Version: 0.1.1.1
+Version: 0.2.0
 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.1.1 → hmr-0.2.0}/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.1.1"
+version = "0.2.0"
 
 [project.scripts]
 hmr = "reactivity.hmr:cli"

{hmr-0.1.1.1 → hmr-0.2.0}/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.1.1 → hmr-0.2.0}/reactivity/hmr.py

@@ -8,7 +8,7 @@ from importlib.util import spec_from_loader
 from inspect import currentframe
 from pathlib import Path
 from runpy import run_path
-from types import ModuleType
+from types import ModuleType, TracebackType
 from typing import Any
 
 from . import Reactive, batch, memoized_method
@@ -60,8 +60,12 @@ class ReactiveModule(ModuleType):
 
     @memoized_method
     def __load(self):
-        code = compile(self.__file.read_text("utf-8"), str(self.__file), "exec", dont_inherit=True)
-        exec(code, self.__namespace, self.__namespace_proxy)
+        try:
+            code = compile(self.__file.read_text("utf-8"), str(self.__file), "exec", dont_inherit=True)
+        except SyntaxError as e:
+            sys.excepthook(type(e), e, e.__traceback__)
+        else:
+            exec(code, self.__namespace, self.__namespace_proxy)
 
     @property
     def load(self):
@@ -153,6 +157,30 @@ def get_path_module_map():
     return {module.file.resolve(): module for module in sys.modules.values() if isinstance(module, ReactiveModule)}
 
 
+class ErrorFilter:
+    def __init__(self, *exclude_filenames: str):
+        self.exclude_filenames = set(exclude_filenames)
+
+    def __call__(self, tb: TracebackType):
+        current = tb
+        while current is not None:
+            if current.tb_frame.f_code.co_filename not in self.exclude_filenames:
+                return current
+            current = current.tb_next
+        return tb
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type: type[BaseException], exc_value: BaseException, traceback: TracebackType):
+        if exc_value is None:
+            return
+        tb = self(traceback)
+        exc_value = exc_value.with_traceback(tb)
+        sys.excepthook(exc_type, exc_value, tb)
+        return True
+
+
 class BaseReloader:
     def __init__(self, entry_file: str, includes: Iterable[str] = (".",), excludes: Iterable[str] = ()):
         self.entry = entry_file
@@ -160,13 +188,12 @@ class BaseReloader:
         self.excludes = excludes
         patch_meta_path(includes, excludes)
         self.last_globals = {}
+        self.error_filter = ErrorFilter(__file__, "<frozen runpy>")
 
     @memoized_method
     def run_entry_file(self):
-        try:
+        with self.error_filter:
             self.last_globals = run_path(self.entry, self.last_globals, "__main__")
-        except Exception as e:
-            sys.excepthook(e.__class__, e, e.__traceback__)
 
     @property
     def watch_filter(self):
@@ -189,16 +216,12 @@ class BaseReloader:
                     if path.samefile(self.entry):
                         self.run_entry_file.invalidate()
                     elif module := path2module.get(path):
-                        try:
+                        with self.error_filter:
                             module.load.invalidate()
-                        except Exception as e:
-                            sys.excepthook(e.__class__, e, e.__traceback__)
 
             for module in path2module.values():
-                try:
+                with self.error_filter:
                     module.load()
-                except Exception as e:
-                    sys.excepthook(e.__class__, e, e.__traceback__)
             self.run_entry_file()
 
 
@@ -255,9 +278,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()
 
 
-__version__ = "0.1.1.1"
+__version__ = "0.2.0"

{hmr-0.1.1.1 → hmr-0.2.0}/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)