hmr 0.0.3__tar.gz → 0.0.3.2__tar.gz

{hmr-0.0.3 → hmr-0.0.3.2}/PKG-INFO

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

{hmr-0.0.3 → hmr-0.0.3.2}/pyproject.toml

@@ -6,7 +6,7 @@ description = "Hot Module Reload for Python"
 dependencies = [
     "watchfiles>=0.21,<2",
 ]
-version = "0.0.3"
+version = "0.0.3.2"
 
 [project.scripts]
 hmr = "reactivity.hmr:cli"

hmr-0.0.3.2/reactivity/__init__.py

@@ -0,0 +1,5 @@
+from .functional import batch, create_effect, create_memo, create_signal, memoized_method, memoized_property
+from .helpers import Reactive
+from .primitives import State
+
+__all__ = ["Reactive", "State", "batch", "create_effect", "create_memo", "create_signal", "memoized_method", "memoized_property"]

{hmr-0.0.3 → hmr-0.0.3.2}/reactivity/functional.py

@@ -3,7 +3,7 @@ from functools import wraps
 from typing import Protocol, overload
 
 from .helpers import Memoized, MemoizedMethod, MemoizedProperty
-from .primitives import Batch, Derived, Signal
+from .primitives import Batch, Effect, Signal
 
 
 class Getter[T](Protocol):
@@ -19,19 +19,19 @@ def create_signal[T](initial_value: T = None, check_equality=True) -> tuple[Gett
     return signal.get, signal.set
 
 
-def create_effect[T](fn: Callable[[], T], auto_run=True):
-    return Derived(fn, auto_run)
+def create_effect[T](fn: Callable[[], T], call_immediately=True):
+    return Effect(fn, call_immediately)
 
 
 def create_memo[T](fn: Callable[[], T]):
     return Memoized(fn)
 
 
-def memoized_property[T, Self](method: Callable[[Self], T]):
+def memoized_property[T, I](method: Callable[[I], T]):
     return MemoizedProperty(method)
 
 
-def memoized_method[T, Self](method: Callable[[Self], T]):
+def memoized_method[T, I](method: Callable[[I], T]):
     return MemoizedMethod(method)
 
 

{hmr-0.0.3 → hmr-0.0.3.2}/reactivity/helpers.py

@@ -1,5 +1,7 @@
+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
@@ -14,53 +16,69 @@ class Memoized[T](Subscribable, BaseComputation[T]):
         self._recompute = False
 
     def trigger(self):
+        self.track()
         if self._recompute:
+            self._recompute = False
             self._before()
-            self.cached_value = self.fn()
-            self._after()
-            self.is_stale = False
-        elif not self.is_stale:
-            del self.cached_value
-            self.is_stale = True
-        self.track()
+            try:
+                self.cached_value = self.fn()
+                self.is_stale = False
+            finally:
+                self._after()
+        else:
+            self.invalidate()
 
     def __call__(self):
         if self.is_stale:
             self._recompute = True
             self.trigger()
-            self._recompute = False
+            assert not self._recompute
         return self.cached_value
 
     def invalidate(self):
-        del self.cached_value
-        self.is_stale = True
+        if not self.is_stale:
+            del self.cached_value
+            self.is_stale = True
 
 
-class MemoizedProperty[T, Self]:
-    def __init__(self, method: Callable[[Self], T]):
+class MemoizedProperty[T, I]:
+    def __init__(self, method: Callable[[I], T]):
         super().__init__()
         self.method = method
-        self.map = WeakKeyDictionary[Self, Memoized]()
+        self.map = WeakKeyDictionary[I, Memoized[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, owner):
+    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 = Memoized(partial(self.method, instance))
         return func()
 
 
-class MemoizedMethod[T, Self]:
-    def __init__(self, method: Callable[[Self], T]):
+class MemoizedMethod[T, I]:
+    def __init__(self, method: Callable[[I], T]):
         super().__init__()
         self.method = method
-        self.map = WeakKeyDictionary[Self, Memoized]()
+        self.map = WeakKeyDictionary[I, Memoized[T]]()
 
-    def __get__(self, instance, owner):
-        try:
-            return self.map[instance]
-        except KeyError:
-            self.map[instance] = memo = Memoized(partial(self.method, instance))
+    @overload
+    def __get__(self, instance: None, owner: type[I]) -> Self: ...
+    @overload
+    def __get__(self, instance: I, owner: type[I]) -> Memoized[T]: ...
+
+    def __get__(self, instance: I | None, owner):
+        if instance is None:
+            return self
+        if memo := self.map.get(instance):
             return memo
+        self.map[instance] = memo = Memoized(partial(self.method, instance))
+        return memo
 
 
 class Reactive[K, V](Subscribable, MutableMapping[K, V]):
@@ -69,24 +87,23 @@ class Reactive[K, V](Subscribable, MutableMapping[K, V]):
     def __hash__(self):
         return id(self)
 
-    def __init__(self, initial: Mapping | None = None, check_equality=True):
+    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: dict[K, Signal[V]] = {} if initial is None else {k: Signal(v, check_equality) for k, v in initial.items()}
+        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()})
         self._check_equality = check_equality
 
     def __getitem__(self, key: K):
-        value = self._signals.setdefault(key, Signal(self.UNSET, self._check_equality)).get()
+        value = self._signals[key].get()
         if value is self.UNSET:
             raise KeyError(key)
         return value
 
     def __setitem__(self, key: K, value: V):
         with Batch():
-            try:
-                self._signals[key].set(value)
-            except KeyError:
-                self._signals[key] = Signal(value, self._check_equality)
-                self._signals[key].set(value)
+            self._signals[key].set(value)
             self.notify()
 
     def __delitem__(self, key: K):
@@ -95,7 +112,6 @@ class Reactive[K, V](Subscribable, MutableMapping[K, V]):
             raise KeyError(key)
         with Batch():
             state.set(self.UNSET)
-            state.notify()
             self.notify()
 
     def __iter__(self):

{hmr-0.0.3 → hmr-0.0.3.2}/reactivity/hmr.py

@@ -58,11 +58,14 @@ class ReactiveModule(ModuleType):
             return self.__file
         raise AttributeError("file")
 
+    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)
+
     @property
     def load(self):
         if is_called_in_this_file():
-            code = compile(self.__file.read_text("utf-8"), str(self.__file), "exec", dont_inherit=True)
-            return lambda: exec(code, self.__namespace, self.__namespace_proxy)
+            return self.__load
         raise AttributeError("load")
 
     def __dir__(self):
@@ -95,7 +98,7 @@ class ReactiveModuleLoader(Loader):
         namespace = {"__file__": str(self._file), "__spec__": spec, "__loader__": self}
         if self._is_package:
             assert self._file.name == "__init__.py"
-            namespace["__path__"] = [str(self._file.parent.parent)]
+            namespace["__path__"] = [str(self._file.parent)]
         return ReactiveModule(self._file, namespace, spec.name)
 
     def exec_module(self, module: ModuleType):
@@ -246,4 +249,4 @@ def cli():
     SyncReloader(entry, excludes={".venv"}).keep_watching_until_interrupt()
 
 
-__version__ = "0.0.3"
+__version__ = "0.0.3.2"

{hmr-0.0.3 → hmr-0.0.3.2}/reactivity/primitives.py

@@ -1,5 +1,5 @@
 from collections.abc import Callable
-from typing import Any
+from typing import Any, Self, overload
 from weakref import WeakKeyDictionary, WeakSet
 
 
@@ -79,7 +79,14 @@ class State[T](Signal[T]):
         self._check_equality = check_equality
         self.map = WeakKeyDictionary[Any, Signal[T]]()
 
+    @overload
+    def __get__(self, instance: None, owner: type) -> Self: ...
+    @overload
+    def __get__(self, instance: Any, owner: type) -> T: ...
+
     def __get__(self, instance, owner):
+        if instance is None:
+            return self
         try:
             return self.map[instance].get()
         except KeyError:
@@ -94,13 +101,13 @@ class State[T](Signal[T]):
         state.set(value)
 
 
-class Derived[T](BaseComputation[T]):
-    def __init__(self, fn: Callable[[], T], auto_run=True):
+class Effect[T](BaseComputation[T]):
+    def __init__(self, fn: Callable[[], T], call_immediately=True):
         super().__init__()
 
         self._fn = fn
 
-        if auto_run:
+        if call_immediately:
             self()
 
     def trigger(self):

hmr-0.0.3/reactivity/__init__.py

@@ -1,5 +0,0 @@
-from .functional import batch, create_effect, create_memo, create_signal, memoized_method, memoized_property
-from .helpers import Reactive
-from .primitives import Derived, State
-
-__all__ = ["Derived", "Reactive", "State", "batch", "create_effect", "create_memo", "create_signal", "memoized_method", "memoized_property"]