hmr 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

{hmr-0.5.3.dist-info → hmr-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hmr
-Version: 0.5.3
+Version: 0.6.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.6.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+hmr-0.6.0.dist-info/METADATA,sha256=AQEgb94qk_NRTRAap3w-eie4GVIebx3ZPzUPWrrN_98,1999
+hmr-0.6.0.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+hmr-0.6.0.dist-info/entry_points.txt,sha256=g_T0uJ43WgsdG14kkkdaBQuIL0HO-m1qvtjXMP6d060,59
+reactivity/__init__.py,sha256=pX-RUzkezCC1x4eOWGxNhXbwrbvBLP_3pQuZr9eZz1Y,300
+reactivity/context.py,sha256=Iuq1uXYJjQeizOucocu56ObGy5O_sb7Q-mXeKJzAwMA,1239
+reactivity/functional.py,sha256=jJLEq88w5ag2cXuD1T118uEjnEg37_mqvWmFkb47KVY,1300
+reactivity/helpers.py,sha256=MoIU6UmvPDC31HW5mQn2kFKJZNjrzioLXXEyYQMHUuw,5820
+reactivity/hmr/__init__.py,sha256=S5ZIHqCRpevdzWuhS0aCua_S8F0LkK0YNg6IgeTScFQ,177
+reactivity/hmr/__main__.py,sha256=uIcyjR5gMFIXH_3hS0B3SD00RirVf7GIct-uItx675o,64
+reactivity/hmr/api.py,sha256=ypS_LyzMH1JbN5cSwamAJ0HEcHMOY7BOIINuJmWJwo8,2283
+reactivity/hmr/core.py,sha256=OMgjdnvv6QWUmDmJxInuT93RwWuwNSicHTdgF0k4vL4,11835
+reactivity/hmr/hooks.py,sha256=jIFpe4CNxfaS9RcR4OIodx_sOZlnJ_IA1T1RtHPXhwU,945
+reactivity/hmr/utils.py,sha256=h9m7iRXlvsLTrHoXV9gEVbhz3XsPK4KgnStYoCAWE5I,1616
+reactivity/primitives.py,sha256=z69PqQxizN2sbursmpKW5SlWshlZZzdLgFH9u8E5eZc,6857
+hmr-0.6.0.dist-info/RECORD,,

reactivity/context.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from contextlib import contextmanager
+from functools import partial
+from typing import TYPE_CHECKING, NamedTuple
+
+if TYPE_CHECKING:
+    from .primitives import BaseComputation, Batch
+
+
+class Context(NamedTuple):
+    current_computations: list[BaseComputation]
+    batches: list[Batch]
+
+    def schedule_callbacks(self, callbacks: Iterable[BaseComputation]):
+        self.batches[-1].callbacks.update(callbacks)
+
+    @contextmanager
+    def enter(self, computation: BaseComputation):
+        computation.dispose()
+        self.current_computations.append(computation)
+        try:
+            yield
+        finally:
+            last = self.current_computations.pop()
+            assert last is computation  # sanity check
+
+    @property
+    def batch(self):
+        from .primitives import Batch
+
+        return partial(Batch, context=self)
+
+    @property
+    def signal(self):
+        from .primitives import Signal
+
+        return partial(Signal, context=self)
+
+    @property
+    def effect(self):
+        from .primitives import Effect
+
+        return partial(Effect, context=self)
+
+
+def new_context():
+    return Context([], [])
+
+
+default_context = new_context()

reactivity/helpers.py

@@ -3,23 +3,21 @@ from collections.abc import Callable, Mapping, MutableMapping
 from typing import Self, overload
 from weakref import WeakKeyDictionary
 
+from .context import Context
 from .primitives import BaseComputation, Batch, Derived, Signal, Subscribable
 
 
 class Memoized[T](Subscribable, BaseComputation[T]):
-    def __init__(self, fn: Callable[[], T]):
-        super().__init__()
+    def __init__(self, fn: Callable[[], T], *, context: Context | None = None):
+        super().__init__(context=context)
         self.fn = fn
         self.is_stale = True
         self.cached_value: T
 
     def recompute(self):
-        self._before()
-        try:
+        with self._enter():
             self.cached_value = self.fn()
             self.is_stale = False
-        finally:
-            self._after()
 
     def trigger(self):
         self.invalidate()
@@ -38,10 +36,11 @@ class Memoized[T](Subscribable, BaseComputation[T]):
 
 
 class MemoizedProperty[T, I]:
-    def __init__(self, method: Callable[[I], T]):
+    def __init__(self, method: Callable[[I], T], *, context: Context | None = None):
         super().__init__()
         self.method = method
         self.map = WeakKeyDictionary[I, Memoized[T]]()
+        self.context = context
 
     @overload
     def __get__(self, instance: None, owner: type[I]) -> Self: ...
@@ -53,15 +52,16 @@ class MemoizedProperty[T, I]:
             return self
         if func := self.map.get(instance):
             return func()
-        self.map[instance] = func = Memoized(self.method.__get__(instance, owner))
+        self.map[instance] = func = Memoized(self.method.__get__(instance, owner), context=self.context)
         return func()
 
 
 class MemoizedMethod[T, I]:
-    def __init__(self, method: Callable[[I], T]):
+    def __init__(self, method: Callable[[I], T], *, context: Context | None = None):
         super().__init__()
         self.method = method
         self.map = WeakKeyDictionary[I, Memoized[T]]()
+        self.context = context
 
     @overload
     def __get__(self, instance: None, owner: type[I]) -> Self: ...
@@ -73,7 +73,7 @@ class MemoizedMethod[T, I]:
             return self
         if memo := self.map.get(instance):
             return memo
-        self.map[instance] = memo = Memoized(self.method.__get__(instance, owner))
+        self.map[instance] = memo = Memoized(self.method.__get__(instance, owner), context=self.context)
         return memo
 
 
@@ -86,9 +86,9 @@ class Reactive[K, V](Subscribable, MutableMapping[K, V]):
     def _null(self):
         return Signal(self.UNSET, self._check_equality)
 
-    def __init__(self, initial: Mapping[K, V] | None = None, check_equality=True):
-        super().__init__()
-        self._signals = defaultdict[K, Signal[V]](self._null) if initial is None else defaultdict(self._null, {k: Signal(v, check_equality) for k, v in initial.items()})
+    def __init__(self, initial: Mapping[K, V] | None = None, check_equality=True, *, context: Context | None = None):
+        super().__init__(context=context)
+        self._signals = defaultdict[K, Signal[V]](self._null) if initial is None else defaultdict(self._null, {k: Signal(v, check_equality, context=context) for k, v in initial.items()})
         self._check_equality = check_equality
 
     def __getitem__(self, key: K):
@@ -98,7 +98,7 @@ class Reactive[K, V](Subscribable, MutableMapping[K, V]):
         return value
 
     def __setitem__(self, key: K, value: V):
-        with Batch(force_flush=False):
+        with Batch(force_flush=False, context=self.context):
             if self._signals[key].set(value):
                 self.notify()
 
@@ -106,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(force_flush=False):
+        with Batch(force_flush=False, context=self.context):
             state.set(self.UNSET)
             self.notify()
 
@@ -131,10 +131,11 @@ class Reactive[K, V](Subscribable, MutableMapping[K, V]):
 
 
 class DerivedProperty[T, I]:
-    def __init__(self, method: Callable[[I], T]):
+    def __init__(self, method: Callable[[I], T], *, context: Context | None = None):
         super().__init__()
         self.method = method
         self.map = WeakKeyDictionary[I, Derived[T]]()
+        self.context = context
 
     @overload
     def __get__(self, instance: None, owner: type[I]) -> Self: ...
@@ -146,16 +147,17 @@ class DerivedProperty[T, I]:
             return self
         if func := self.map.get(instance):
             return func()
-        self.map[instance] = func = Derived(self.method.__get__(instance, owner))
+        self.map[instance] = func = Derived(self.method.__get__(instance, owner), context=self.context)
         return func()
 
 
 class DerivedMethod[T, I]:
-    def __init__(self, method: Callable[[I], T], check_equality=True):
+    def __init__(self, method: Callable[[I], T], check_equality=True, *, context: Context | None = None):
         super().__init__()
         self.method = method
         self.check_equality = check_equality
         self.map = WeakKeyDictionary[I, Derived[T]]()
+        self.context = context
 
     @overload
     def __get__(self, instance: None, owner: type[I]) -> Self: ...
@@ -168,5 +170,5 @@ class DerivedMethod[T, I]:
         if func := self.map.get(instance):
             return func
 
-        self.map[instance] = func = Derived(self.method.__get__(instance, owner), self.check_equality)
+        self.map[instance] = func = Derived(self.method.__get__(instance, owner), self.check_equality, context=self.context)
         return func

reactivity/hmr/api.py

@@ -1,6 +1,6 @@
 import sys
 
-from .core import AsyncReloader, BaseReloader, SyncReloader, create_effect
+from .core import HMR_CONTEXT, AsyncReloader, BaseReloader, SyncReloader
 from .hooks import call_post_reload_hooks, call_pre_reload_hooks
 
 
@@ -9,7 +9,7 @@ class LifecycleMixin(BaseReloader):
         self._original_main_module = sys.modules["__main__"]
         sys.modules["__main__"] = self.entry_module
         call_pre_reload_hooks()
-        self.effect = create_effect(self.run_entry_file)
+        self.effect = HMR_CONTEXT.effect(self.run_entry_file)
         call_post_reload_hooks()
 
     def clean_up(self):

reactivity/hmr/core.py

@@ -1,7 +1,7 @@
 import sys
 from collections.abc import Iterable, MutableMapping, Sequence
 from contextlib import suppress
-from functools import cached_property
+from functools import cached_property, partial
 from importlib.abc import Loader, MetaPathFinder
 from importlib.machinery import ModuleSpec
 from importlib.util import spec_from_loader
@@ -12,8 +12,8 @@ from types import ModuleType, TracebackType
 from typing import Any, Self
 from weakref import WeakValueDictionary
 
-from .. import Reactive, batch
-from ..functional import create_effect
+from .. import Reactive
+from ..context import new_context
 from ..helpers import DerivedMethod
 from ..primitives import BaseDerived, Derived, Signal
 from .hooks import call_post_reload_hooks, call_pre_reload_hooks
@@ -36,14 +36,17 @@ class Name(Signal, BaseDerived):
     pass
 
 
+HMR_CONTEXT = new_context()
+
+
 class NamespaceProxy(Reactive[str, Any]):
     def __init__(self, initial: MutableMapping, module: "ReactiveModule", check_equality=True):
-        super().__init__(initial, check_equality)
+        super().__init__(initial, check_equality, context=HMR_CONTEXT)
         self._original = initial
         self.module = module
 
     def _null(self):
-        self.module.load.subscribers.add(signal := Name(self.UNSET, self._check_equality))
+        self.module.load.subscribers.add(signal := Name(self.UNSET, self._check_equality, context=HMR_CONTEXT))
         signal.dependencies.add(self.module.load)
         return signal
 
@@ -87,7 +90,7 @@ class ReactiveModule(ModuleType):
             return self.__file
         raise AttributeError("file")
 
-    @DerivedMethod
+    @partial(DerivedMethod, context=HMR_CONTEXT)
     def __load(self):
         try:
             code = compile(self.__file.read_text("utf-8"), str(self.__file), "exec", dont_inherit=True)
@@ -253,7 +256,7 @@ class BaseReloader:
 
         call_pre_reload_hooks()
 
-        with batch():
+        with HMR_CONTEXT.batch():
             for type, file in events:
                 if type is not Change.deleted:
                     path = Path(file).resolve()
@@ -297,7 +300,7 @@ class SyncReloader(BaseReloader):
 
     def keep_watching_until_interrupt(self):
         call_pre_reload_hooks()
-        with suppress(KeyboardInterrupt), create_effect(self.run_entry_file):
+        with suppress(KeyboardInterrupt), HMR_CONTEXT.effect(self.run_entry_file):
             call_post_reload_hooks()
             self.start_watching()
 
@@ -322,7 +325,7 @@ class AsyncReloader(BaseReloader):
 
     async def keep_watching_until_interrupt(self):
         call_pre_reload_hooks()
-        with suppress(KeyboardInterrupt), create_effect(self.run_entry_file):
+        with suppress(KeyboardInterrupt), HMR_CONTEXT.effect(self.run_entry_file):
             call_post_reload_hooks()
             await self.start_watching()
 
@@ -341,4 +344,4 @@ def cli():
     reloader.keep_watching_until_interrupt()
 
 
-__version__ = "0.5.3"
+__version__ = "0.6.0"

reactivity/primitives.py

@@ -1,7 +1,9 @@
-from collections.abc import Callable, Iterable
+from collections.abc import Callable
 from typing import Any, Self, overload
 from weakref import WeakKeyDictionary, WeakSet
 
+from .context import Context, default_context
+
 
 def _equal(a, b):
     if a is b:
@@ -22,43 +24,40 @@ def _equal(a, b):
 
 
 class Subscribable:
-    def __init__(self):
+    def __init__(self, *, context: Context | None = None):
         super().__init__()
         self.subscribers = set[BaseComputation]()
+        self.context = context or default_context
 
     def track(self):
-        if not _current_computations:
+        if not self.context.current_computations:
             return
-        last = _current_computations[-1]
+        last = self.context.current_computations[-1]
         if last is not self:
             self.subscribers.add(last)
             last.dependencies.add(self)
 
     def notify(self):
-        if _batches:
-            schedule_callbacks(self.subscribers)
+        if self.context.batches:
+            self.context.schedule_callbacks(self.subscribers)
         else:
-            with Batch(force_flush=False):
-                schedule_callbacks(self.subscribers)
+            with Batch(force_flush=False, context=self.context):
+                self.context.schedule_callbacks(self.subscribers)
 
 
 class BaseComputation[T]:
-    def __init__(self):
+    def __init__(self, *, context: Context | None = None):
         super().__init__()
         self.dependencies = WeakSet[Subscribable]()
+        self.context = context or default_context
 
     def dispose(self):
         for dep in self.dependencies:
             dep.subscribers.remove(self)
         self.dependencies.clear()
 
-    def _before(self):
-        self.dispose()
-        _current_computations.append(self)
-
-    def _after(self):
-        last = _current_computations.pop()
-        assert last is self  # sanity check
+    def _enter(self):
+        return self.context.enter(self)
 
     def __enter__(self):
         return self
@@ -72,12 +71,9 @@ class BaseComputation[T]:
         return self.trigger()
 
 
-_current_computations: list[BaseComputation] = []
-
-
 class Signal[T](Subscribable):
-    def __init__(self, initial_value: T = None, check_equality=True):
-        super().__init__()
+    def __init__(self, initial_value: T = None, check_equality=True, *, context: Context | None = None):
+        super().__init__(context=context)
         self._value: T = initial_value
         self._check_equality = check_equality
 
@@ -95,8 +91,8 @@ class Signal[T](Subscribable):
 
 
 class State[T](Signal[T]):
-    def __init__(self, initial_value: T = None, check_equality=True):
-        super().__init__(initial_value, check_equality)
+    def __init__(self, initial_value: T = None, check_equality=True, *, context: Context | None = None):
+        super().__init__(initial_value, check_equality, context=context)
         self._value = initial_value
         self._check_equality = check_equality
         self.map = WeakKeyDictionary[Any, Signal[T]]()
@@ -112,20 +108,20 @@ class State[T](Signal[T]):
         try:
             return self.map[instance].get()
         except KeyError:
-            self.map[instance] = state = Signal(self._value, self._check_equality)
+            self.map[instance] = state = Signal(self._value, self._check_equality, context=self.context)
             return state.get()
 
     def __set__(self, instance, value: T):
         try:
             state = self.map[instance]
         except KeyError:
-            self.map[instance] = state = Signal(self._value, self._check_equality)
+            self.map[instance] = state = Signal(self._value, self._check_equality, context=self.context)
         state.set(value)
 
 
 class Effect[T](BaseComputation[T]):
-    def __init__(self, fn: Callable[[], T], call_immediately=True):
-        super().__init__()
+    def __init__(self, fn: Callable[[], T], call_immediately=True, *, context: Context | None = None):
+        super().__init__(context=context)
 
         self._fn = fn
 
@@ -133,17 +129,15 @@ class Effect[T](BaseComputation[T]):
             self()
 
     def trigger(self):
-        self._before()
-        try:
+        with self._enter():
             return self._fn()
-        finally:
-            self._after()
 
 
 class Batch:
-    def __init__(self, force_flush=True):
+    def __init__(self, force_flush=True, *, context: Context | None = None):
         self.callbacks = set[BaseComputation]()
         self.force_flush = force_flush
+        self.context = context or default_context
 
     def flush(self):
         triggered = set()
@@ -157,30 +151,23 @@ class Batch:
                 triggered.add(computation)
 
     def __enter__(self):
-        _batches.append(self)
+        self.context.batches.append(self)
 
     def __exit__(self, *_):
-        if self.force_flush or len(_batches) == 1:
+        if self.force_flush or len(self.context.batches) == 1:
             try:
                 self.flush()
             finally:
-                last = _batches.pop()
+                last = self.context.batches.pop()
         else:
-            last = _batches.pop()
-            schedule_callbacks(self.callbacks)
+            last = self.context.batches.pop()
+            self.context.schedule_callbacks(self.callbacks)
         assert last is self
 
 
-_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__()
+    def __init__(self, *, context: Context | None = None):
+        super().__init__(context=context)
         self.dirty = True
 
     def _sync_dirty_deps(self):
@@ -192,15 +179,14 @@ class BaseDerived[T](Subscribable, BaseComputation[T]):
 class Derived[T](BaseDerived[T]):
     UNSET: T = object()  # type: ignore
 
-    def __init__(self, fn: Callable[[], T], check_equality=True):
-        super().__init__()
+    def __init__(self, fn: Callable[[], T], check_equality=True, *, context: Context | None = None):
+        super().__init__(context=context)
         self.fn = fn
         self._check_equality = check_equality
         self._value = self.UNSET
 
     def recompute(self):
-        self._before()
-        try:
+        with self._enter():
             value = self.fn()
             self.dirty = False
             if self._check_equality:
@@ -211,8 +197,6 @@ class Derived[T](BaseDerived[T]):
                     return
             self._value = value
             self.notify()
-        finally:
-            self._after()
 
     def __call__(self):
         self.track()

hmr-0.5.3.dist-info/RECORD

@@ -1,14 +0,0 @@
-hmr-0.5.3.dist-info/METADATA,sha256=Y3kB1iJBhlnFuwz18jp1wn98jNXwBo_UtXOuj4OpR6Q,1999
-hmr-0.5.3.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-hmr-0.5.3.dist-info/entry_points.txt,sha256=g_T0uJ43WgsdG14kkkdaBQuIL0HO-m1qvtjXMP6d060,59
-reactivity/__init__.py,sha256=pX-RUzkezCC1x4eOWGxNhXbwrbvBLP_3pQuZr9eZz1Y,300
-reactivity/functional.py,sha256=jJLEq88w5ag2cXuD1T118uEjnEg37_mqvWmFkb47KVY,1300
-reactivity/helpers.py,sha256=rcrCXy1mmlei-if_BN4nSgS2IG9kBj-jq1YRwEfcITo,5329
-reactivity/hmr/__init__.py,sha256=S5ZIHqCRpevdzWuhS0aCua_S8F0LkK0YNg6IgeTScFQ,177
-reactivity/hmr/__main__.py,sha256=uIcyjR5gMFIXH_3hS0B3SD00RirVf7GIct-uItx675o,64
-reactivity/hmr/api.py,sha256=sKDQV7uKRVoDifTZKrLQGZP-fzgYbdVjfEOC6ki4NKY,2280
-reactivity/hmr/core.py,sha256=_H4PvJdNe328AlA84WkGxYJHehJBDvS5yqwyIRywCWo,11714
-reactivity/hmr/hooks.py,sha256=jIFpe4CNxfaS9RcR4OIodx_sOZlnJ_IA1T1RtHPXhwU,945
-reactivity/hmr/utils.py,sha256=h9m7iRXlvsLTrHoXV9gEVbhz3XsPK4KgnStYoCAWE5I,1616
-reactivity/primitives.py,sha256=alFH1W7y2UHgXI3Vlk8GFdIlcFTcQ3Q9cpz2Y1vDZuQ,6553
-hmr-0.5.3.dist-info/RECORD,,