hmr 0.0.2.2__tar.gz → 0.0.3.1__tar.gz

{hmr-0.0.2.2 → hmr-0.0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hmr
-Version: 0.0.2.2
+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.2.2 → hmr-0.0.3.1}/pyproject.toml

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

hmr-0.0.3.1/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.2.2 → hmr-0.0.3.1}/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.2.2 → hmr-0.0.3.1}/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):

{hmr-0.0.2.2 → hmr-0.0.3.1}/reactivity/hmr.py

@@ -9,6 +9,7 @@ from inspect import currentframe
 from pathlib import Path
 from runpy import run_path
 from types import ModuleType
+from typing import Any
 
 from . import Reactive, batch, create_effect, memoized_method
 
@@ -26,7 +27,7 @@ def is_called_in_this_file() -> bool:
     return frame.f_globals.get("__file__") == __file__
 
 
-class NamespaceProxy(Reactive):
+class NamespaceProxy(Reactive[str, Any]):
     def __init__(self, initial: MutableMapping, check_equality=True):
         super().__init__(initial, check_equality)
         self._original = initial
@@ -43,6 +44,10 @@ class NamespaceProxy(Reactive):
 class ReactiveModule(ModuleType):
     def __init__(self, file: Path, namespace: dict, name: str, doc: str | None = None):
         super().__init__(name, doc)
+        self.__is_initialized = False
+        self.__dict__.update(namespace)
+        self.__is_initialized = True
+
         self.__namespace = namespace
         self.__namespace_proxy = NamespaceProxy(namespace)
         self.__file = file
@@ -53,12 +58,24 @@ 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():
-            return lambda: exec(self.__file.read_text("utf-8"), self.__namespace, self.__namespace_proxy)
+            return self.__load
         raise AttributeError("load")
 
+    def __dir__(self):
+        return iter(self.__namespace_proxy)
+
+    def __getattribute__(self, name: str):
+        if name == "__dict__" and self.__is_initialized:
+            return self.__namespace
+        return super().__getattribute__(name)
+
     def __getattr__(self, name: str):
         try:
             return self.__namespace_proxy[name]
@@ -78,7 +95,7 @@ class ReactiveModuleLoader(Loader):
         self._is_package = is_package
 
     def create_module(self, spec: ModuleSpec):
-        namespace = {}
+        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)]
@@ -232,4 +249,4 @@ def cli():
     SyncReloader(entry, excludes={".venv"}).keep_watching_until_interrupt()
 
 
-__version__ = "0.0.2.2"
+__version__ = "0.0.3.1"

{hmr-0.0.2.2 → hmr-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.2.2/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"]