hmr 0.0.1__tar.gz

hmr-0.0.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: hmr
+Version: 0.0.1
+Summary: Hot Module Reload for Python
+Project-URL: repository, https://github.com/promplate/pyth-on-line/tree/reactivity
+Requires-Python: >=3.12
+Requires-Dist: watchfiles<2,>=0.21
+

hmr-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "hmr"
+version = "0.0.1"
+requires-python = ">=3.12"
+description = "Hot Module Reload for Python"
+dependencies = [
+    "watchfiles>=0.21,<2",
+]
+
+[project.scripts]
+hmr = "reactivity.hmr:cli"
+
+[project.urls]
+repository = "https://github.com/promplate/pyth-on-line/tree/reactivity"
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool]

hmr-0.0.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 Derived, State
+
+__all__ = ["Derived", "Reactive", "State", "batch", "create_effect", "create_memo", "create_signal", "memoized_method", "memoized_property"]

hmr-0.0.1/reactivity/functional.py

@@ -0,0 +1,54 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import Protocol, overload
+
+from .helpers import Memoized, MemoizedMethod, MemoizedProperty
+from .primitives import Batch, Derived, Signal
+
+
+class Getter[T](Protocol):
+    def __call__(self, track=True) -> T: ...
+
+
+class Setter[T](Protocol):
+    def __call__(self, value: T): ...
+
+
+def create_signal[T](initial_value: T = None, check_equality=True) -> tuple[Getter[T], Setter[T]]:
+    signal = Signal(initial_value, check_equality)
+    return signal.get, signal.set
+
+
+def create_effect[T](fn: Callable[[], T], auto_run=True):
+    return Derived(fn, auto_run)
+
+
+def create_memo[T](fn: Callable[[], T]):
+    return Memoized(fn)
+
+
+def memoized_property[T, Self](method: Callable[[Self], T]):
+    return MemoizedProperty(method)
+
+
+def memoized_method[T, Self](method: Callable[[Self], T]):
+    return MemoizedMethod(method)
+
+
+@overload
+def batch() -> Batch: ...
+@overload
+def batch[**P, T](func: Callable[P, T]) -> Callable[P, T]: ...
+
+
+def batch[**P, T](func: Callable[P, T] | None = None) -> Callable[P, T] | Batch:
+    if func is not None:
+
+        @wraps(func)
+        def wrapped(*args, **kwargs):
+            with Batch():
+                return func(*args, **kwargs)
+
+        return wrapped
+
+    return Batch()

hmr-0.0.1/reactivity/helpers.py

@@ -0,0 +1,110 @@
+from collections.abc import Callable, Mapping, MutableMapping
+from functools import partial
+from weakref import WeakKeyDictionary
+
+from .primitives import BaseComputation, Batch, Signal, Subscribable
+
+
+class Memoized[T](Subscribable, BaseComputation):
+    def __init__(self, fn: Callable[[], T]):
+        super().__init__()
+        self.fn = fn
+        self.is_stale = True
+        self.cached_value: T
+        self._recompute = False
+
+    def trigger(self):
+        if self._recompute:
+            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()
+
+    def __call__(self):
+        if self.is_stale:
+            self._recompute = True
+            self.trigger()
+            self._recompute = False
+        return self.cached_value
+
+    def invalidate(self):
+        del self.cached_value
+        self.is_stale = True
+
+
+class MemoizedProperty[T, Self]:
+    def __init__(self, method: Callable[[Self], T]):
+        super().__init__()
+        self.method = method
+        self.map = WeakKeyDictionary[Self, Memoized]()
+
+    def __get__(self, instance, owner):
+        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]):
+        super().__init__()
+        self.method = method
+
+    def __get__(self, instance, owner):
+        return Memoized(partial(self.method, instance))
+
+
+class Reactive[K, V](Subscribable, MutableMapping[K, V]):
+    UNSET: V = object()  # type: ignore
+
+    def __hash__(self):
+        return id(self)
+
+    def __init__(self, initial: Mapping | 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._check_equality = check_equality
+
+    def __getitem__(self, key: K):
+        value = self._signals.setdefault(key, Signal(self.UNSET, self._check_equality)).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.notify()
+
+    def __delitem__(self, key: K):
+        state = self._signals[key]
+        if state.get(track=False) is self.UNSET:
+            raise KeyError(key)
+        with Batch():
+            state.set(self.UNSET)
+            state.notify()
+            self.notify()
+
+    def __iter__(self):
+        self.track()
+        return iter(self._signals)
+
+    def __len__(self):
+        self.track()
+        return len(self._signals)
+
+    def __repr__(self):
+        self.track()
+        return repr({k: v.get() for k, v in self._signals.items()})
+
+    def items(self):
+        self.track()
+        return ({k: v.get() for k, v in self._signals.items()}).items()

hmr-0.0.1/reactivity/hmr.py

@@ -0,0 +1,215 @@
+import sys
+from collections.abc import Iterable, Sequence
+from contextlib import suppress
+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 pathlib import Path
+from runpy import run_path
+from types import ModuleType
+
+from . import Reactive, batch, create_effect, memoized_method
+
+
+def is_called_in_this_file() -> bool:
+    frame = currentframe()  # this function
+    assert frame is not None
+
+    frame = frame.f_back  # the function calling this function
+    assert frame is not None
+
+    frame = frame.f_back  # the function calling the function calling this function
+    assert frame is not None
+
+    return frame.f_globals.get("__file__") == __file__
+
+
+class ReactiveModule(ModuleType):
+    def __init__(self, file: Path, namespace: dict, name: str, doc: str | None = None):
+        super().__init__(name, doc)
+        self.__namespace = namespace
+        self.__namespace_proxy = Reactive(namespace)
+        self.__file = file
+
+    @property
+    def file(self):
+        if is_called_in_this_file():
+            return self.__file
+        raise AttributeError("file")
+
+    @property
+    def load(self):
+        if is_called_in_this_file():
+            return lambda: exec(self.__file.read_text("utf-8"), self.__namespace, self.__namespace_proxy)
+        raise AttributeError("load")
+
+    def __getattr__(self, name: str):
+        try:
+            return self.__namespace_proxy[name]
+        except KeyError as e:
+            raise AttributeError(*e.args) from e
+
+    def __setattr__(self, name: str, value):
+        if is_called_in_this_file():
+            return super().__setattr__(name, value)
+        self.__namespace_proxy[name] = value
+
+
+class ReactiveModuleLoader(Loader):
+    def __init__(self, file: Path, is_package=False):
+        super().__init__()
+        self._file = file
+        self._is_package = is_package
+
+    def create_module(self, spec: ModuleSpec):
+        namespace = {}
+        if self._is_package:
+            assert self._file.name == "__init__.py"
+            namespace["__path__"] = [str(self._file.parent.parent)]
+            namespace["__package__"] = spec.name
+        return ReactiveModule(self._file, namespace, spec.name)
+
+    def exec_module(self, module: ModuleType):
+        assert isinstance(module, ReactiveModule)
+        create_effect(lambda: module.load())
+
+
+class ReactiveModuleFinder(MetaPathFinder):
+    def __init__(self, includes: Iterable[str] = ".", excludes: Iterable[str] = ()):
+        super().__init__()
+        self.includes = [Path(i).resolve() for i in includes]
+        self.excludes = [Path(e).resolve() for e in excludes]
+
+    def find_spec(self, fullname: str, paths: Sequence[str] | None, _=None):
+        if fullname in sys.modules:
+            return None
+
+        for p in paths or sys.path:
+            directory = Path(p)
+            if directory.is_file():
+                continue
+            if any(directory.is_relative_to(exclude) for exclude in self.excludes):
+                continue
+            if all(not directory.is_relative_to(include) for include in self.includes):
+                continue
+
+            file = directory / f"{fullname.replace('.', '/')}.py"
+            if file.is_file() and all(not file.is_relative_to(exclude) for exclude in self.excludes):
+                return spec_from_loader(fullname, ReactiveModuleLoader(file), origin=str(file))
+            file = directory / f"{fullname.replace('.', '/')}/__init__.py"
+            if file.is_file() and all(not file.is_relative_to(exclude) for exclude in self.excludes):
+                return spec_from_loader(fullname, ReactiveModuleLoader(file, is_package=True), origin=str(file))
+
+
+def patch_module(name_or_module: str | ModuleType):
+    name = name_or_module if isinstance(name_or_module, str) else name_or_module.__name__
+    module = sys.modules[name_or_module] if isinstance(name_or_module, str) else name_or_module
+    assert isinstance(module.__file__, str), f"{name} is not a file-backed module"
+    m = sys.modules[name] = ReactiveModule(Path(module.__file__), module.__dict__, module.__name__, module.__doc__)
+    return m
+
+
+def patch_meta_path(includes: Iterable[str] = (".",), excludes: Iterable[str] = (".venv",)):
+    sys.meta_path.insert(0, ReactiveModuleFinder(includes, excludes))
+
+
+def get_path_module_map():
+    return {module.file.resolve(): module for module in sys.modules.values() if isinstance(module, ReactiveModule)}
+
+
+class BaseReloader:
+    def __init__(self, entry_file: str, includes: Iterable[str] = (".",), excludes: Iterable[str] = ()):
+        self.entry = entry_file
+        self.includes = includes
+        self.excludes = excludes
+        patch_meta_path(includes, excludes)
+
+    @memoized_method
+    def run_entry_file(self):
+        try:
+            run_path(self.entry, run_name="__main__")
+        except Exception as e:
+            sys.excepthook(e.__class__, e, e.__traceback__)
+
+    @property
+    def watch_filter(self):
+        from watchfiles import PythonFilter
+
+        return PythonFilter(ignore_paths=tuple(self.excludes))
+
+    def on_events(self, events: Iterable[tuple[int, str]]):
+        from watchfiles import Change
+
+        if not events:
+            return
+
+        path2module = get_path_module_map()
+
+        with batch():
+            for type, file in events:
+                if type is Change.modified:
+                    path = Path(file).resolve()
+                    if path.samefile(self.entry):
+                        self.run_entry_file()
+                    elif module := path2module.get(path):
+                        try:
+                            module.load()
+                        except Exception as e:
+                            sys.excepthook(e.__class__, e, e.__traceback__)
+
+
+class SyncReloader(BaseReloader):
+    @cached_property
+    def _stop_event(self):
+        from threading import Event
+
+        return Event()
+
+    def stop_watching(self):
+        self._stop_event.set()
+        del self._stop_event
+
+    def start_watching(self):
+        from watchfiles import watch
+
+        for events in watch(self.entry, *self.includes, watch_filter=self.watch_filter, stop_event=self._stop_event):
+            self.on_events(events)
+
+    def keep_watching_until_interrupt(self):
+        with suppress(KeyboardInterrupt):
+            self.run_entry_file()
+            self.start_watching()
+        self.run_entry_file.dispose()
+
+
+class AsyncReloader(BaseReloader):
+    @cached_property
+    def _stop_event(self):
+        from asyncio import Event
+
+        return Event()
+
+    def stop_watching(self):
+        self._stop_event.set()
+        del self._stop_event
+
+    async def start_watching(self):
+        from watchfiles import awatch
+
+        async for events in awatch(self.entry, *self.includes, watch_filter=self.watch_filter, stop_event=self._stop_event):
+            self.on_events(events)
+
+    async def keep_watching_until_interrupt(self):
+        with suppress(KeyboardInterrupt):
+            self.run_entry_file()
+            await self.start_watching()
+        self.run_entry_file.dispose()
+
+
+def cli():
+    entry = sys.argv[-1]
+    assert Path(entry).is_file(), f"{entry} is not a file"
+    sys.path.insert(0, ".")
+    SyncReloader(entry, excludes={".venv"}).keep_watching_until_interrupt()

hmr-0.0.1/reactivity/primitives.py

@@ -0,0 +1,133 @@
+from collections.abc import Callable
+from typing import Any
+from weakref import WeakKeyDictionary, WeakSet
+
+
+class Subscribable:
+    def __init__(self):
+        super().__init__()
+        self.subscribers = set[BaseComputation]()
+
+    def track(self):
+        for computation in _current_computations:
+            if computation is not self:
+                self.subscribers.add(computation)
+                computation.dependencies.add(self)
+
+    def notify(self):
+        if _batches:
+            _batches[-1].callbacks.extend(self.subscribers)
+        else:
+            for subscriber in {*self.subscribers}:
+                subscriber.trigger()
+
+
+class BaseComputation:
+    def __init__(self):
+        super().__init__()
+        self.dependencies = WeakSet[Subscribable]()
+
+    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
+
+    def __exit__(self, *_):
+        self.dispose()
+
+    def trigger(self) -> Any: ...
+
+    def __call__(self):
+        return self.trigger()
+
+
+_current_computations: list[BaseComputation] = []
+
+
+class Signal[T](Subscribable):
+    def __init__(self, initial_value: T = None, check_equality=True):
+        super().__init__()
+        self._value: T = initial_value
+        self._check_equality = check_equality
+
+    def get(self, track=True):
+        if track:
+            self.track()
+        return self._value
+
+    def set(self, value: T):
+        if not self._check_equality or self._value != value:
+            self._value = value
+            self.notify()
+
+
+class State[T](Signal[T]):
+    def __init__(self, initial_value: T = None, check_equality=True):
+        super().__init__(initial_value, check_equality)
+        self._value = initial_value
+        self._check_equality = check_equality
+        self.map = WeakKeyDictionary[Any, Signal[T]]()
+
+    def __get__(self, instance, owner):
+        try:
+            return self.map[instance].get()
+        except KeyError:
+            self.map[instance] = state = Signal(self._value, self._check_equality)
+            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)
+        state.set(value)
+
+
+class Derived[T](BaseComputation):
+    def __init__(self, fn: Callable[[], T], auto_run=True):
+        super().__init__()
+
+        self._fn = fn
+
+        if auto_run:
+            self()
+
+    def trigger(self):
+        self._before()
+        try:
+            return self._fn()
+        finally:
+            self._after()
+
+
+class Batch:
+    def __init__(self):
+        self.callbacks: list[BaseComputation] = []
+
+    def flush(self):
+        callbacks = set(self.callbacks)
+        self.callbacks.clear()
+        for computation in callbacks:
+            computation.trigger()
+
+    def __enter__(self):
+        _batches.append(self)
+
+    def __exit__(self, *_):
+        last = _batches.pop()
+        assert last is self
+        self.flush()
+
+
+_batches: list[Batch] = []