python-library-reactive-model 0.1.0__tar.gz

python_library_reactive_model-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.venv/
+.env
+.pytest_cache/
+config.yaml
+logs/

python_library_reactive_model-0.1.0/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: python-library-reactive-model
+Version: 0.1.0
+Requires-Python: >=3.10

python_library_reactive_model-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "python-library-reactive-model"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.hatch.build.targets.wheel]
+packages = ["reactive_model"]

python_library_reactive_model-0.1.0/reactive_model/__init__.py

@@ -0,0 +1,11 @@
+from .computed import ComputedModel
+from .ref import RefModel
+from .dict_ref import DictRefModel
+from .list_ref import ListRefModel
+
+__all__ = [
+    "RefModel",
+    "ComputedModel",
+    "DictRefModel",
+    "ListRefModel",
+]

python_library_reactive_model-0.1.0/reactive_model/computed.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Callable, TypeVar, cast
+
+from .reactive import ReactiveModel
+from .track import Collector, Trackable, compute_context, track
+
+T = TypeVar("T")
+_MISSING = object()
+
+
+class ComputedModel(ReactiveModel[T]):
+    def __init__(self, expr: Callable[[], T]) -> None:
+        super().__init__()
+        self._expr = expr
+        self._cache: T | object = _MISSING
+        self._deps: dict[int, tuple[Trackable, int]] = {}
+
+    @property
+    def value(self) -> T:
+        if self._needs_recompute():
+            self._recompute()
+        track(self)
+        return cast(T, self._cache)
+
+    @property
+    def version(self) -> int:
+        if self._needs_recompute():
+            self._recompute()
+        return super().version
+
+    def _needs_recompute(self) -> bool:
+        if self._cache is _MISSING:
+            return True
+
+        for dep, captured_version in self._deps.values():
+            if dep.version != captured_version:
+                return True
+
+        return False
+
+    def _recompute(self) -> None:
+        collector = Collector()
+
+        with compute_context(self, collector):
+            new_value = self._expr()
+
+        new_deps: dict[int, tuple[Trackable, int]] = {}
+        for dep_id, dep in collector.deps.items():
+            new_deps[dep_id] = (dep, dep.version)
+
+        self._deps = new_deps
+        self._cache = new_value
+
+        self.touch()

python_library_reactive_model-0.1.0/reactive_model/dict_ref.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator, MutableMapping
+from typing import Generic, TypeVar
+
+from .ref import RefModel
+from .track import track
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class DictProxy(MutableMapping[K, V], Generic[K, V]):
+    def __init__(self, owner: "DictRefModel[K, V]") -> None:
+        self._owner = owner
+
+    def __getitem__(self, key: K) -> V:
+        return self._owner._value[key]
+
+    def __setitem__(self, key: K, value: V) -> None:
+        self._owner._value[key] = value
+        self._owner.touch()
+
+    def __delitem__(self, key: K) -> None:
+        del self._owner._value[key]
+        self._owner.touch()
+
+    def __iter__(self) -> Iterator[K]:
+        return iter(self._owner._value)
+
+    def __len__(self) -> int:
+        return len(self._owner._value)
+
+    def clear(self) -> None:
+        if self._owner._value:
+            self._owner._value.clear()
+            self._owner.touch()
+
+    def update(self, other=(), /, **kwargs: V) -> None:
+        changed = False
+
+        if other:
+            if hasattr(other, "items"):
+                for k, v in other.items():
+                    self._owner._value[k] = v
+                    changed = True
+            else:
+                for k, v in other:
+                    self._owner._value[k] = v
+                    changed = True
+
+        for k, v in kwargs.items():
+            self._owner._value[k] = v
+            changed = True
+
+        if changed:
+            self._owner.touch()
+
+    def pop(self, key: K, default=...):
+        if default is ...:
+            value = self._owner._value.pop(key)
+            self._owner.touch()
+            return value
+
+        if key in self._owner._value:
+            value = self._owner._value.pop(key)
+            self._owner.touch()
+            return value
+        return default
+
+    def popitem(self) -> tuple[K, V]:
+        item = self._owner._value.popitem()
+        self._owner.touch()
+        return item
+
+    def setdefault(self, key: K, default: V = None):  # type: ignore[assignment]
+        if key in self._owner._value:
+            return self._owner._value[key]
+        self._owner._value[key] = default
+        self._owner.touch()
+        return default
+
+    def __repr__(self) -> str:
+        return repr(self._owner._value)
+
+
+class DictRefModel(RefModel[dict[K, V]]):
+    def __init__(self, value: dict[K, V] | None = None) -> None:
+        if value is None:
+            value = {}
+        super().__init__(value)
+        self._proxy = DictProxy(self)
+
+    @property
+    def value(self) -> DictProxy[K, V]:
+        track(self)
+        return self._proxy
+
+    @value.setter
+    def value(self, value: dict[K, V]) -> None:
+        self._value = value
+        self.touch()

python_library_reactive_model-0.1.0/reactive_model/list_ref.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, MutableSequence
+from typing import Generic, TypeVar, overload
+
+from .ref import RefModel
+from .track import track
+
+T = TypeVar("T")
+
+
+class ListProxy(MutableSequence[T], Generic[T]):
+    def __init__(self, owner: "ListRefModel[T]") -> None:
+        self._owner = owner
+
+    def __len__(self) -> int:
+        return len(self._owner._value)
+
+    @overload
+    def __getitem__(self, index: int) -> T: ...
+    @overload
+    def __getitem__(self, index: slice) -> list[T]: ...
+
+    def __getitem__(self, index: int | slice) -> T | list[T]:
+        return self._owner._value[index]
+
+    @overload
+    def __setitem__(self, index: int, value: T) -> None: ...
+    @overload
+    def __setitem__(self, index: slice, value: Iterable[T]) -> None: ...
+
+    def __setitem__(self, index: int | slice, value: T | Iterable[T]) -> None:
+        self._owner._value[index] = value  # type: ignore[index,assignment]
+        self._owner.touch()
+
+    def __delitem__(self, index: int | slice) -> None:
+        del self._owner._value[index]
+        self._owner.touch()
+
+    def insert(self, index: int, value: T) -> None:
+        self._owner._value.insert(index, value)
+        self._owner.touch()
+
+    def clear(self) -> None:
+        if self._owner._value:
+            self._owner._value.clear()
+            self._owner.touch()
+
+    def extend(self, values: Iterable[T]) -> None:
+        data = list(values)
+        if data:
+            self._owner._value.extend(data)
+            self._owner.touch()
+
+    def sort(self, *, key=None, reverse: bool = False) -> None:
+        self._owner._value.sort(key=key, reverse=reverse)
+        self._owner.touch()
+
+    def reverse(self) -> None:
+        self._owner._value.reverse()
+        self._owner.touch()
+
+    def __repr__(self) -> str:
+        return repr(self._owner._value)
+
+
+class ListRefModel(RefModel[list[T]]):
+    def __init__(self, value: list[T] | None = None) -> None:
+        if value is None:
+            value = []
+        super().__init__(value)
+        self._proxy = ListProxy(self)
+
+    @property
+    def value(self) -> ListProxy[T]:
+        track(self)
+        return self._proxy
+
+    @value.setter
+    def value(self, value: list[T]) -> None:
+        self._value = value
+        self.touch()

python_library_reactive_model-0.1.0/reactive_model/reactive.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class ReactiveModel(Generic[T]):
+    def __init__(self) -> None:
+        """
+        Attributes:
+            _version: 版本号
+        """
+        self._version = 0
+
+    @property
+    def version(self) -> int:
+        """版本号"""
+        return self._version
+
+    def touch(self) -> None:
+        """标记为改动"""
+        self._version += 1
+
+    @property
+    def value(self) -> T:
+        """值"""
+        raise NotImplementedError

python_library_reactive_model-0.1.0/reactive_model/ref.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+from typing import TypeVar
+
+from .reactive import ReactiveModel
+from .track import track
+
+T = TypeVar("T")
+
+
+class RefModel(ReactiveModel[T]):
+    def __init__(self, value: T) -> None:
+        """
+        Args:
+            value: 值
+        Attributes:
+            _value: 值
+        """
+        super().__init__()
+        self._value = value
+
+    @property
+    def value(self) -> T:
+        track(self)
+        return self._value
+
+    @value.setter
+    def value(self, value: T) -> None:
+        self._value = value
+        self.touch()

python_library_reactive_model-0.1.0/reactive_model/track.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from contextvars import ContextVar
+import inspect
+from typing import Protocol
+
+
+class Trackable(Protocol):
+    @property
+    def version(self) -> int: ...
+
+
+class Collector:
+    def __init__(self) -> None:
+        self.deps: dict[int, Trackable] = {}
+
+    def add(self, dep: Trackable) -> None:
+        self.deps[id(dep)] = dep
+
+
+class CircularDependencyError(RuntimeError):
+    pass
+
+
+_ACTIVE_COLLECTOR: ContextVar[Collector | None] = ContextVar(
+    "_ACTIVE_COLLECTOR",
+    default=None,
+)
+
+_COMPUTE_STACK: ContextVar[tuple[object, ...]] = ContextVar(
+    "_COMPUTE_STACK",
+    default=(),
+)
+
+
+def track(dep: Trackable) -> None:
+    collector = _ACTIVE_COLLECTOR.get()
+    if collector is not None:
+        collector.add(dep)
+
+
+def _format_expr(expr: object) -> str:
+    file: str | None = None
+    line: int | None = None
+    code: str | None = None
+
+    try:
+        file = inspect.getsourcefile(expr) or inspect.getfile(expr)
+    except Exception:
+        pass
+
+    try:
+        lines, line = inspect.getsourcelines(expr)
+        code = "".join(lines).strip()
+    except Exception:
+        pass
+
+    location = "<unknown>" if file is None else f"{file}:{line}" if line is not None else file
+    return f"{location} -> {code}" if code else location
+
+
+def _build_cycle_message(cycle: tuple[object, ...]) -> str:
+    lines = ["检测到循环依赖:"]
+    for idx, item in enumerate(cycle, start=1):
+        expr = getattr(item, "_expr", None)
+        lines.append(f"{idx}. {_format_expr(expr)}")
+    return "\n".join(lines)
+
+
+@contextmanager
+def compute_context(owner: object, collector: Collector):
+    stack = _COMPUTE_STACK.get()
+    if owner in stack:
+        start = stack.index(owner)
+        cycle = stack[start:] + (owner,)
+        raise CircularDependencyError(_build_cycle_message(cycle))
+
+    collector_token = _ACTIVE_COLLECTOR.set(collector)
+    stack_token = _COMPUTE_STACK.set(stack + (owner,))
+    try:
+        yield
+    finally:
+        _COMPUTE_STACK.reset(stack_token)
+        _ACTIVE_COLLECTOR.reset(collector_token)

python_library_reactive_model-0.1.0/test.bat

@@ -0,0 +1,10 @@
+@echo off
+cd /d %~dp0
+
+if not exist .venv (
+    python -m venv .venv
+)
+
+call .venv\Scripts\activate.bat
+pip install -e .
+python -m unittest discover -s tests -p "test*.py" -v

python_library_reactive_model-0.1.0/tests/test_reactive_model.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import unittest
+
+from reactive_model import ComputedModel, DictRefModel, ListRefModel, RefModel
+from reactive_model.track import CircularDependencyError
+
+
+class TestRefModel(unittest.TestCase):
+    def test_get_set(self) -> None:
+        r = RefModel(10)
+        self.assertEqual(r.value, 10)
+        r.value = 20
+        self.assertEqual(r.value, 20)
+
+    def test_touch_bumps_version(self) -> None:
+        r = RefModel(0)
+        v0 = r.version
+        r.value = 1
+        self.assertGreater(r.version, v0)
+
+
+class TestComputedModel(unittest.TestCase):
+    def test_lazy_and_cache(self) -> None:
+        calls: list[int] = []
+
+        def expr() -> int:
+            calls.append(1)
+            return 42
+
+        c = ComputedModel(expr)
+        self.assertEqual(calls, [])
+        self.assertEqual(c.value, 42)
+        self.assertEqual(calls, [1])
+        self.assertEqual(c.value, 42)
+        self.assertEqual(calls, [1])
+
+    def test_invalidates_when_dep_changes(self) -> None:
+        count = RefModel(1)
+        double = ComputedModel(lambda: count.value * 2)
+        self.assertEqual(double.value, 2)
+        v_after_first = double.version
+        count.value = 2
+        self.assertGreater(count.version, 0)
+        self.assertEqual(double.value, 4)
+        self.assertGreaterEqual(double.version, v_after_first)
+
+    def test_chained_computed(self) -> None:
+        count = RefModel(1)
+        double = ComputedModel(lambda: count.value * 2)
+        label = ComputedModel(lambda: f"double={double.value}")
+        self.assertEqual(label.value, "double=2")
+        count.value = 2
+        self.assertEqual(double.value, 4)
+        self.assertEqual(label.value, "double=4")
+
+
+class TestCircularDependency(unittest.TestCase):
+    def test_mutual_computed_raises(self) -> None:
+        a_holder: list[ComputedModel[int] | None] = [None]
+        b_holder: list[ComputedModel[int] | None] = [None]
+
+        def a_expr() -> int:
+            assert b_holder[0] is not None
+            return b_holder[0].value
+
+        def b_expr() -> int:
+            assert a_holder[0] is not None
+            return a_holder[0].value
+
+        a_holder[0] = ComputedModel(a_expr)
+        b_holder[0] = ComputedModel(b_expr)
+
+        with self.assertRaises(CircularDependencyError):
+            _ = a_holder[0].value
+
+
+class TestDictRefModel(unittest.TestCase):
+    def test_proxy_mutation_invalidates_computed(self) -> None:
+        d = DictRefModel({"x": 1})
+        total = ComputedModel(lambda: sum(d.value.values()))
+        self.assertEqual(total.value, 1)
+        d.value["x"] = 10
+        self.assertEqual(total.value, 10)
+
+    def test_replace_whole_dict(self) -> None:
+        d = DictRefModel({"a": 1})
+        keys = ComputedModel(lambda: sorted(d.value.keys()))
+        self.assertEqual(keys.value, ["a"])
+        d.value = {"b": 2}
+        self.assertEqual(keys.value, ["b"])
+
+
+class TestListRefModel(unittest.TestCase):
+    def test_proxy_mutation_invalidates_computed(self) -> None:
+        lst = ListRefModel([1, 2, 3])
+        s = ComputedModel(lambda: sum(lst.value))
+        self.assertEqual(s.value, 6)
+        lst.value.append(4)
+        self.assertEqual(s.value, 10)
+
+    def test_replace_whole_list(self) -> None:
+        lst = ListRefModel([1])
+        length = ComputedModel(lambda: len(lst.value))
+        self.assertEqual(length.value, 1)
+        lst.value = [1, 2, 3]
+        self.assertEqual(length.value, 3)
+
+
+if __name__ == "__main__":
+    unittest.main()