hmr 0.6.2.1__tar.gz → 0.6.3__tar.gz

{hmr-0.6.2.1 → hmr-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hmr
-Version: 0.6.2.1
+Version: 0.6.3
 Summary: Hot Module Reload for Python
 Keywords: reactive-programming,reload,signals,hmr
 Classifier: Development Status :: 5 - Production/Stable

{hmr-0.6.2.1 → hmr-0.6.3}/pyproject.toml

@@ -20,7 +20,7 @@ description = "Hot Module Reload for Python"
 dependencies = [
     "watchfiles>=0.21,<2 ; sys_platform != 'emscripten'",
 ]
-version = "0.6.2.1"
+version = "0.6.3"
 
 [project.scripts]
 hmr = "reactivity.hmr:cli"

hmr-0.6.3/reactivity/hmr/_experimental.py

@@ -0,0 +1,23 @@
+from collections.abc import Callable
+
+from reactivity.context import Context
+
+from ..primitives import BaseDerived, _equal
+
+
+class Dirty[T](BaseDerived[T]):
+    UNSET = object()
+
+    def __init__(self, fn: Callable[[], T], *, context: Context | None = None):
+        super().__init__(context=context)
+        self.fn = fn
+        self.value = __class__.UNSET
+
+    def trigger(self):
+        self.track()
+        with self._enter():
+            value = self.fn()
+            if not _equal(value, self.value):
+                self.value = value
+                self.notify()  # BUG: b -> a <- (b, c) will cause Dirty a to re-evaluate by c
+            return value

{hmr-0.6.2.1 → hmr-0.6.3}/reactivity/hmr/core.py

@@ -13,8 +13,9 @@ from typing import Self
 from weakref import WeakValueDictionary
 
 from ..context import Context, new_context
-from ..helpers import DerivedMethod
+from ..helpers import DerivedMethod, DerivedProperty
 from ..primitives import BaseDerived, Derived, Signal
+from ._experimental import Dirty
 from .hooks import call_post_reload_hooks, call_pre_reload_hooks
 from .proxy import Proxy
 
@@ -114,7 +115,7 @@ class ReactiveModule(ModuleType):
 
     def __getattr__(self, name: str):
         try:
-            return self.__namespace_proxy[name]
+            return self.__namespace_proxy[name] if name != "__path__" else self.__namespace[name]
         except KeyError as e:
             if name != "__path__" and (getattr := self.__namespace_proxy.get("__getattr__")):
                 return getattr(name)
@@ -143,6 +144,11 @@ class ReactiveModuleLoader(Loader):
         module.load()
 
 
+@Dirty
+def sys_path():  # TODO: Path(".") may change too
+    return sys.path
+
+
 class ReactiveModuleFinder(MetaPathFinder):
     def __init__(self, includes: Iterable[str] = ".", excludes: Iterable[str] = ()):
         super().__init__()
@@ -152,12 +158,18 @@ class ReactiveModuleFinder(MetaPathFinder):
     def _accept(self, path: Path):
         return path.is_file() and not is_relative_to_any(path, self.excludes) and is_relative_to_any(path, self.includes)
 
+    @DerivedProperty
+    def search_paths(self):
+        # FIXME: Handle case where `includes` contains file paths, not just directories
+        # Currently we assume `includes` never specify individual files
+        # And we assume `includes` and `excludes` never change
+        return [path for path in (Path(p).resolve() for p in sys_path()) if not is_relative_to_any(path, self.excludes) and is_relative_to_any(path, self.includes)]
+
     def find_spec(self, fullname: str, paths: Sequence[str] | None, _=None):
         if fullname in sys.modules:
             return None
 
-        for p in sys.path:
-            directory = Path(p).resolve()
+        for directory in self.search_paths:
             if directory.is_file():
                 continue
 
@@ -219,7 +231,7 @@ class BaseReloader:
         self.includes = includes
         self.excludes = excludes
         patch_meta_path(includes, excludes)
-        self.error_filter = ErrorFilter(*(str(i) for i in Path(__file__, "../..").resolve().glob("**/*.py")))
+        self.error_filter = ErrorFilter(*map(str, Path(__file__, "../..").resolve().glob("**/*.py")))
 
     @cached_property
     def entry_module(self):
@@ -335,4 +347,4 @@ def cli():
     reloader.keep_watching_until_interrupt()
 
 
-__version__ = "0.6.2.1"
+__version__ = "0.6.3"

hmr-0.6.3/reactivity/hmr/exec_hack/__init__.py

@@ -0,0 +1,7 @@
+import ast
+
+from .transform import ClassTransformer
+
+
+def fix_class_name_resolution(mod: ast.Module) -> ast.Module:
+    return ast.fix_missing_locations(ClassTransformer().visit(mod))

hmr-0.6.3/reactivity/hmr/exec_hack/transform.py

@@ -0,0 +1,61 @@
+import ast
+from typing import override
+
+
+class ClassTransformer(ast.NodeTransformer):
+    @override
+    def visit_ClassDef(self, node: ast.ClassDef):
+        node.body = [
+            name_lookup_function,
+            *map(ClassBodyTransformer().visit, node.body),
+            ast.Delete(targets=[ast.Name(id="__name_lookup", ctx=ast.Del())]),
+        ]
+        return node
+
+
+class ClassBodyTransformer(ast.NodeTransformer):
+    @override
+    def visit_Name(self, node: ast.Name):
+        if isinstance(node.ctx, ast.Load) and node.id != "__name_lookup":
+            return build_name_lookup(node.id)
+        return node
+
+    @override
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        node.decorator_list = [self.visit(d) for d in node.decorator_list]
+        self.visit(node.args)
+        if node.returns:
+            node.returns = self.visit(node.returns)
+        return node
+
+    visit_AsyncFunctionDef = visit_FunctionDef  # type: ignore  # noqa: N815
+
+    @override
+    def visit_Lambda(self, node: ast.Lambda):
+        self.visit(node.args)
+        return node
+
+
+def build_name_lookup(name: str) -> ast.Call:
+    return ast.Call(func=ast.Name(id="__name_lookup", ctx=ast.Load()), args=[ast.Constant(value=name)], keywords=[])
+
+
+name_lookup_source = """
+
+def __name_lookup(name):
+    from collections import ChainMap
+    from inspect import currentframe
+    f = currentframe().f_back
+    c = ChainMap(f.f_locals, f.f_globals, f.f_builtins)
+    f = f.f_back
+    while f is not None and f.f_code.co_name != "<module>":
+        c.maps.insert(1, f.f_locals)
+        f = f.f_back
+    m = object()
+    if (v := c.get(name, m)) is not m:
+        return v
+    raise NameError(name)
+
+"""
+
+name_lookup_function = ast.parse(name_lookup_source).body[0]

{hmr-0.6.2.1 → hmr-0.6.3}/reactivity/hmr/utils.py

@@ -1,3 +1,4 @@
+from ast import parse
 from collections import UserDict
 from collections.abc import Callable
 from functools import wraps
@@ -7,6 +8,7 @@ from types import FunctionType
 
 from ..helpers import Memoized
 from .core import HMR_CONTEXT, NamespaceProxy, ReactiveModule
+from .exec_hack import fix_class_name_resolution
 from .hooks import post_reload, pre_reload
 
 memos: dict[str, Callable] = {}
@@ -27,6 +29,9 @@ def clear_memos():
             del memos[func]
 
 
+_cache_decorator_phase = False
+
+
 def cache_across_reloads[T](func: Callable[[], T]) -> Callable[[], T]:
     file = getsourcefile(func)
     assert file is not None
@@ -41,6 +46,12 @@ def cache_across_reloads[T](func: Callable[[], T]) -> Callable[[], T]:
 
     proxy: NamespaceProxy = module._ReactiveModule__namespace_proxy  # type: ignore  # noqa: SLF001
 
+    global _cache_decorator_phase
+    _cache_decorator_phase = not _cache_decorator_phase
+    if _cache_decorator_phase:  # this function will be called twice: once transforming ast and once re-executing the patched source
+        exec(compile(fix_class_name_resolution(parse(source)), file, "exec"), DictProxy(proxy))
+        return proxy[func.__name__]
+
     func = FunctionType(func.__code__, DictProxy(proxy), func.__name__, func.__defaults__, func.__closure__)
 
     functions[source] = func

{hmr-0.6.2.1 → hmr-0.6.3}/reactivity/primitives.py

@@ -15,8 +15,8 @@ def _equal(a, b):
                 comparison_result = a == b
             if comparison_result:
                 return True
-        except ValueError as e:
-            if ".all()" in str(e) and hasattr(comparison_result, "all"):  # array-like instances
+        except (ValueError, RuntimeError) as e:
+            if "is ambiguous" in str(e) and hasattr(comparison_result, "all"):  # array-like instances
                 comparison_result = comparison_result.all()
             else:
                 return False