hmr 0.3.3.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

{hmr-0.3.3.3.dist-info → hmr-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hmr
-Version: 0.3.3.3
+Version: 0.4.0
 Summary: Hot Module Reload for Python
 Project-URL: repository, https://github.com/promplate/pyth-on-line/tree/reactivity
 Requires-Python: >=3.12

hmr-0.4.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+hmr-0.4.0.dist-info/METADATA,sha256=SrlGz7FGOOGLKRHK7XNuluX_-FkXYvF0DeL12Qaa7DM,258
+hmr-0.4.0.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+hmr-0.4.0.dist-info/entry_points.txt,sha256=g_T0uJ43WgsdG14kkkdaBQuIL0HO-m1qvtjXMP6d060,59
+reactivity/__init__.py,sha256=pX-RUzkezCC1x4eOWGxNhXbwrbvBLP_3pQuZr9eZz1Y,300
+reactivity/functional.py,sha256=U06vshcVhZ0sb218gcmHtEhfgTNAGtQ7zyvPz2w5qKM,1292
+reactivity/helpers.py,sha256=1KCpre2HTFZrngEKkI2HwSFMkCmsUCq2aPEbp0y3kKg,5140
+reactivity/hmr/__init__.py,sha256=S5ZIHqCRpevdzWuhS0aCua_S8F0LkK0YNg6IgeTScFQ,177
+reactivity/hmr/__main__.py,sha256=uIcyjR5gMFIXH_3hS0B3SD00RirVf7GIct-uItx675o,64
+reactivity/hmr/api.py,sha256=USwQUtMIdhGRJFGYTp-S23ZelbB39FkV9bB0UEqlAvc,1579
+reactivity/hmr/core.py,sha256=4bGNcugfk1pKMngw_NMyW8HFogVmorlHyV3utyBHYF0,11488
+reactivity/hmr/hooks.py,sha256=-yLr5ktiyqPb1nDbHsgv6-c_ZkziBjNqCU-0PCfXGYU,592
+reactivity/hmr/utils.py,sha256=-PO-LMP4sc3IP-Bn_baq2w9IFWBZ3zGesgRn5wR6bS0,1555
+reactivity/primitives.py,sha256=mB6cbHKDqtilOfgaEhshtRWJq9s0nPEKqRK0hfCoyFE,5671
+hmr-0.4.0.dist-info/RECORD,,

{hmr-0.3.3.3.dist-info → hmr-0.4.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.3)
+Generator: pdm-backend (2.4.4)
 Root-Is-Purelib: true
 Tag: py3-none-any

reactivity/helpers.py

@@ -1,10 +1,9 @@
 from collections import defaultdict
 from collections.abc import Callable, Mapping, MutableMapping
-from functools import partial
 from typing import Self, overload
 from weakref import WeakKeyDictionary
 
-from .primitives import BaseComputation, Batch, Signal, Subscribable
+from .primitives import BaseComputation, Batch, Derived, Signal, Subscribable
 
 
 class Memoized[T](Subscribable, BaseComputation[T]):
@@ -54,7 +53,7 @@ class MemoizedProperty[T, I]:
             return self
         if func := self.map.get(instance):
             return func()
-        self.map[instance] = func = Memoized(partial(self.method, instance))
+        self.map[instance] = func = Memoized(self.method.__get__(instance, owner))
         return func()
 
 
@@ -74,7 +73,7 @@ class MemoizedMethod[T, I]:
             return self
         if memo := self.map.get(instance):
             return memo
-        self.map[instance] = memo = Memoized(partial(self.method, instance))
+        self.map[instance] = memo = Memoized(self.method.__get__(instance, owner))
         return memo
 
 
@@ -99,7 +98,7 @@ class Reactive[K, V](Subscribable, MutableMapping[K, V]):
         return value
 
     def __setitem__(self, key: K, value: V):
-        with Batch():
+        with Batch(force_flush=False):
             self._signals[key].set(value)
             self.notify()
 
@@ -107,7 +106,7 @@ class Reactive[K, V](Subscribable, MutableMapping[K, V]):
         state = self._signals[key]
         if state.get(track=False) is self.UNSET:
             raise KeyError(key)
-        with Batch():
+        with Batch(force_flush=False):
             state.set(self.UNSET)
             self.notify()
 
@@ -121,8 +120,51 @@ class Reactive[K, V](Subscribable, MutableMapping[K, V]):
 
     def __repr__(self):
         self.track()
-        return repr({k: v.get() for k, v in self._signals.items()})
+        unset = self.UNSET
+        return repr({k: value for k, v in self._signals.items() if (value := v.get()) is not unset})
 
     def items(self):
         self.track()
         return ({k: v.get() for k, v in self._signals.items()}).items()
+
+
+class DerivedProperty[T, I]:
+    def __init__(self, method: Callable[[I], T]):
+        super().__init__()
+        self.method = method
+        self.map = WeakKeyDictionary[I, Derived[T]]()
+
+    @overload
+    def __get__(self, instance: None, owner: type[I]) -> Self: ...
+    @overload
+    def __get__(self, instance: I, owner: type[I]) -> T: ...
+
+    def __get__(self, instance: I | None, owner):
+        if instance is None:
+            return self
+        if func := self.map.get(instance):
+            return func()
+        self.map[instance] = func = Derived(self.method.__get__(instance, owner))
+        return func()
+
+
+class DerivedMethod[T, I]:
+    def __init__(self, method: Callable[[I], T], check_equality=True):
+        super().__init__()
+        self.method = method
+        self.check_equality = check_equality
+        self.map = WeakKeyDictionary[I, Derived[T]]()
+
+    @overload
+    def __get__(self, instance: None, owner: type[I]) -> Self: ...
+    @overload
+    def __get__(self, instance: I, owner: type[I]) -> Derived[T]: ...
+
+    def __get__(self, instance: I | None, owner):
+        if instance is None:
+            return self
+        if func := self.map.get(instance):
+            return func
+
+        self.map[instance] = func = Derived(self.method.__get__(instance, owner), self.check_equality)
+        return func

reactivity/hmr/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == "__main__":
+    from .core import cli
+
+    cli()

reactivity/hmr/api.py

@@ -2,8 +2,6 @@ from .core import AsyncReloader, BaseReloader, SyncReloader
 
 
 def _clean_up(r: BaseReloader):
-    r.run_entry_file.dispose()
-    r.run_entry_file.invalidate()
     r.entry_module.load.dispose()
     r.entry_module.load.invalidate()
 

reactivity/hmr/core.py

@@ -5,14 +5,17 @@ from functools import cached_property
 from importlib.abc import Loader, MetaPathFinder
 from importlib.machinery import ModuleSpec
 from importlib.util import spec_from_loader
-from inspect import currentframe
+from inspect import currentframe, ismethod
 from pathlib import Path
 from site import getsitepackages
 from types import ModuleType, TracebackType
 from typing import Any, Self
 from weakref import WeakValueDictionary
 
-from .. import Reactive, batch, memoized_method
+from .. import Reactive, batch
+from ..functional import create_effect
+from ..helpers import DerivedMethod
+from ..primitives import BaseDerived, Derived, Signal
 from .hooks import call_post_reload_hooks, call_pre_reload_hooks
 
 
@@ -29,10 +32,31 @@ def is_called_in_this_file() -> bool:
     return frame.f_globals.get("__file__") == __file__
 
 
+class Name(Signal, BaseDerived):
+    def __init__(self, initial_value):
+        super().__init__(initial_value)
+
+
 class NamespaceProxy(Reactive[str, Any]):
-    def __init__(self, initial: MutableMapping, check_equality=True):
+    def __init__(self, initial: MutableMapping, module: "ReactiveModule", check_equality=True):
         super().__init__(initial, check_equality)
         self._original = initial
+        self.module = module
+
+    def _null(self):
+        self.module.load.subscribers.add(signal := Name(self.UNSET))
+        signal.dependencies.add(self.module.load)
+        return signal
+
+    def __getitem__(self, key: str):
+        try:
+            return super().__getitem__(key)
+        finally:
+            signal = self._signals[key]
+            if self.module.load in signal.subscribers:
+                # a module's loader shouldn't subscribe its variables
+                signal.subscribers.remove(self.module.load)
+                self.module.load.dependencies.remove(signal)
 
     def __setitem__(self, key, value):
         self._original[key] = value
@@ -53,7 +77,7 @@ class ReactiveModule(ModuleType):
         self.__is_initialized = True
 
         self.__namespace = namespace
-        self.__namespace_proxy = NamespaceProxy(namespace)
+        self.__namespace_proxy = NamespaceProxy(namespace, self)
         self.__file = file
 
         self.instances[file.resolve()] = self
@@ -64,7 +88,7 @@ class ReactiveModule(ModuleType):
             return self.__file
         raise AttributeError("file")
 
-    @memoized_method
+    @DerivedMethod
     def __load(self):
         try:
             code = compile(self.__file.read_text("utf-8"), str(self.__file), "exec", dont_inherit=True)
@@ -72,6 +96,13 @@ class ReactiveModule(ModuleType):
             sys.excepthook(type(e), e, e.__traceback__)
         else:
             exec(code, self.__namespace, self.__namespace_proxy)
+        finally:
+            for dep in list((load := self.__load).dependencies):
+                assert ismethod(load.fn)  # for type narrowing
+                if isinstance(dep, Derived) and ismethod(dep.fn) and isinstance(dep.fn.__self__, ReactiveModule) and dep.fn.__func__ is load.fn.__func__:
+                    # unsubscribe it because we want invalidation to be fine-grained
+                    dep.subscribers.remove(load)
+                    load.dependencies.remove(dep)
 
     @property
     def load(self):
@@ -91,6 +122,8 @@ class ReactiveModule(ModuleType):
         try:
             return self.__namespace_proxy[name]
         except KeyError as e:
+            if getattr := self.__namespace_proxy.get("__getattr__"):
+                return getattr(name)
             raise AttributeError(*e.args) from e
 
     def __setattr__(self, name: str, value):
@@ -200,14 +233,9 @@ class BaseReloader:
         namespace = {"__file__": self.entry, "__name__": "__main__"}
         return ReactiveModule(Path(self.entry), namespace, "__main__")
 
-    @memoized_method
     def run_entry_file(self):
-        call_pre_reload_hooks()
-
-        self.entry_module.load.invalidate()
-        self.entry_module.load()
-
-        call_post_reload_hooks()
+        with self.error_filter:
+            self.entry_module.load()
 
     @property
     def watch_filter(self):
@@ -222,22 +250,23 @@ class BaseReloader:
             return
 
         path2module = get_path_module_map()
+        staled_modules: set[ReactiveModule] = set()
+
+        call_pre_reload_hooks()
 
         with batch():
             for type, file in events:
                 if type is not Change.deleted:
                     path = Path(file).resolve()
-                    if path.samefile(self.entry):
-                        self.run_entry_file.invalidate()
-                    elif module := path2module.get(path):
-                        module.load.invalidate()
+                    if module := path2module.get(path):
+                        staled_modules.add(module)
 
-            with self.error_filter:
-                for module in path2module.values():
-                    if module.file.samefile(self.entry):
-                        continue
-                    module.load()
-                self.run_entry_file()
+            for module in staled_modules:
+                with self.error_filter:
+                    module.load.invalidate()
+                    module.load()  # because `module.load` is not pulled by anyone
+
+        call_post_reload_hooks()
 
 
 class _SimpleEvent:
@@ -268,11 +297,10 @@ class SyncReloader(BaseReloader):
         del self._stop_event
 
     def keep_watching_until_interrupt(self):
-        with suppress(KeyboardInterrupt):
-            with self.error_filter:
-                self.run_entry_file()
+        call_pre_reload_hooks()
+        with suppress(KeyboardInterrupt), create_effect(self.run_entry_file):
+            call_post_reload_hooks()
             self.start_watching()
-        self.run_entry_file.dispose()
 
 
 class AsyncReloader(BaseReloader):
@@ -294,11 +322,8 @@ class AsyncReloader(BaseReloader):
         del self._stop_event
 
     async def keep_watching_until_interrupt(self):
-        with suppress(KeyboardInterrupt):
-            with self.error_filter:
-                self.run_entry_file()
+        with suppress(KeyboardInterrupt), create_effect(self.run_entry_file):
             await self.start_watching()
-        self.run_entry_file.dispose()
 
 
 def cli():
@@ -312,4 +337,4 @@ def cli():
     SyncReloader(entry).keep_watching_until_interrupt()
 
 
-__version__ = "0.3.3.3"
+__version__ = "0.4.0"

reactivity/hmr/utils.py

@@ -50,7 +50,7 @@ def cache_across_reloads[T](func: Callable[[], T]) -> Callable[[], T]:
 
     @wraps(func)
     @create_memo
-    def wrapper():
+    def wrapper() -> T:
         return functions[source]()
 
     memos[source] = wrapper

reactivity/primitives.py

@@ -156,3 +156,60 @@ _batches: list[Batch] = []
 
 def schedule_callbacks(callbacks: Iterable[BaseComputation]):
     _batches[-1].callbacks.update(callbacks)
+
+
+class BaseDerived[T](Subscribable, BaseComputation[T]):
+    def __init__(self):
+        super().__init__()
+        self.dirty = True
+
+    def _sync_dirty_deps(self):
+        for dep in self.dependencies:
+            if isinstance(dep, BaseDerived) and dep.dirty:
+                dep()
+
+
+class Derived[T](BaseDerived[T]):
+    UNSET: T = object()  # type: ignore
+
+    def __init__(self, fn: Callable[[], T], check_equality=True):
+        super().__init__()
+        self.fn = fn
+        self._check_equality = check_equality
+        self._value = self.UNSET
+
+    def recompute(self):
+        self._before()
+        try:
+            value = self.fn()
+            self.dirty = False
+            if self._check_equality:
+                if value == self._value:
+                    return
+                elif self._value is self.UNSET:  # do not notify on first set
+                    self._value = value
+                    return
+            self._value = value
+            self.notify()
+        finally:
+            self._after()
+
+    def __call__(self):
+        self.track()
+        self._sync_dirty_deps()
+        if self.dirty:
+            self.recompute()
+
+        return self._value
+
+    def trigger(self):
+        self.dirty = True
+        if _pulled(self):
+            self()
+
+    def invalidate(self):
+        self.trigger()
+
+
+def _pulled(sub: Subscribable):
+    return any(not isinstance(s, BaseDerived) or _pulled(s) for s in sub.subscribers)

hmr-0.3.3.3.dist-info/RECORD

@@ -1,13 +0,0 @@
-hmr-0.3.3.3.dist-info/METADATA,sha256=TWN_VystOGF0zdKckjiayJus6XK7GJ-L03xlibtXs2E,260
-hmr-0.3.3.3.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-hmr-0.3.3.3.dist-info/entry_points.txt,sha256=g_T0uJ43WgsdG14kkkdaBQuIL0HO-m1qvtjXMP6d060,59
-reactivity/__init__.py,sha256=pX-RUzkezCC1x4eOWGxNhXbwrbvBLP_3pQuZr9eZz1Y,300
-reactivity/functional.py,sha256=U06vshcVhZ0sb218gcmHtEhfgTNAGtQ7zyvPz2w5qKM,1292
-reactivity/helpers.py,sha256=7gwsIKKrjEahSz9G9oR4s1LdYXQTCIMO0k4UGXGla9Y,3714
-reactivity/hmr/__init__.py,sha256=S5ZIHqCRpevdzWuhS0aCua_S8F0LkK0YNg6IgeTScFQ,177
-reactivity/hmr/api.py,sha256=-0-6Tn0AVkaDs7_qrCCd9TXxRTPDMDB08-UYfepTdec,1644
-reactivity/hmr/core.py,sha256=TSbL1AMiel2eKzk23z1Sb8ruCTx9s5m6blbj0L9RGD4,10252
-reactivity/hmr/hooks.py,sha256=-yLr5ktiyqPb1nDbHsgv6-c_ZkziBjNqCU-0PCfXGYU,592
-reactivity/hmr/utils.py,sha256=zM7X5I8ywOguOt20uE55INWOGen3FuJZDAvgouu7lI8,1550
-reactivity/primitives.py,sha256=DR2waJbzhVKOioHXMliE4FIsxQUq7DZA0umPrlvchA4,4217
-hmr-0.3.3.3.dist-info/RECORD,,