hmr 0.0.3__py3-none-any.whl → 0.0.3.1__py3-none-any.whl

{hmr-0.0.3.dist-info → hmr-0.0.3.1.dist-info}/METADATA

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

@@ -0,0 +1,9 @@
+hmr-0.0.3.1.dist-info/METADATA,sha256=lb041EpepaHAh0yvImQPiVofZkBEEnNJ4gQYy2Sv-d0,230
+hmr-0.0.3.1.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+hmr-0.0.3.1.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=OogpUAsVnXX60Ib3ckcVWrJX9jwYfYAKFwUEJw3UcsM,3800
+reactivity/hmr.py,sha256=kBwaVLFCHRz0CX_f5AgTc0Yq8Avknjjnv0LkzGLu4UM,8576
+reactivity/primitives.py,sha256=lw4G3GpANRGK5dKw11eYc2-nlOJ1uCO3f3MiLa41jG8,3588
+hmr-0.0.3.1.dist-info/RECORD,,

reactivity/__init__.py

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

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)
 
 

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
@@ -36,31 +38,44 @@ class Memoized[T](Subscribable, BaseComputation[T]):
         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]]()
 
-    def __get__(self, instance, owner):
+    @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 = 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]]()
+
+    @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, owner):
-        try:
-            return self.map[instance]
-        except KeyError:
-            self.map[instance] = memo = Memoized(partial(self.method, instance))
+    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 +84,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 +109,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):

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):
@@ -246,4 +249,4 @@ def cli():
     SyncReloader(entry, excludes={".venv"}).keep_watching_until_interrupt()
 
 
-__version__ = "0.0.3"
+__version__ = "0.0.3.1"

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.dist-info/RECORD

@@ -1,9 +0,0 @@
-hmr-0.0.3.dist-info/METADATA,sha256=p98mCIdhqoduIMYRW_Lme7IlbZsfmzQ-czinyxdTzmo,228
-hmr-0.0.3.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-hmr-0.0.3.dist-info/entry_points.txt,sha256=g_T0uJ43WgsdG14kkkdaBQuIL0HO-m1qvtjXMP6d060,59
-reactivity/__init__.py,sha256=Stl2BBvqzutjcmF-O-olFTbSzJxzAl1xNMbu8mAVjlo,320
-reactivity/functional.py,sha256=KAsqgPQsxIGuqO4BAtH6VF78MigLSBQ2k3aL4o_Vffg,1290
-reactivity/helpers.py,sha256=auLTDFjfFc-cU9kVfm356GALW9lJIQ_UV7LGRZ2fWIw,3434
-reactivity/hmr.py,sha256=VmFpw9OZV4yiO0LuNu2wRfN4q-QoDvhPSDdjjixR1e8,8543
-reactivity/primitives.py,sha256=EIa_-5XOhffKw_lJ13EoAmFD3l0u_LFG1pJbODZSpMw,3351
-hmr-0.0.3.dist-info/RECORD,,