python-library-reactive-model 0.1.2__tar.gz → 0.1.3__tar.gz

{python_library_reactive_model-0.1.2 → python_library_reactive_model-0.1.3}/.gitignore

@@ -8,4 +8,6 @@ build/
 .env
 .pytest_cache/
 config.yaml
-logs/
+logs/
+.cursor/
+uv.lock

{python_library_reactive_model-0.1.2 → python_library_reactive_model-0.1.3}/PKG-INFO

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

{python_library_reactive_model-0.1.2 → python_library_reactive_model-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-library-reactive-model"
-version = "0.1.2"
+version = "0.1.3"
 requires-python = ">=3.10"
 dependencies = []
 

python_library_reactive_model-0.1.3/reactive_model/__init__.py

@@ -0,0 +1,13 @@
+from .computed_model import ComputedModel
+from .ref_model import RefModel
+from .dict_ref_model import DictRefModel
+from .list_ref_model import ListRefModel
+from .computed_property import computed_property
+
+__all__ = [
+    "RefModel",
+    "ComputedModel",
+    "DictRefModel",
+    "ListRefModel",
+    "computed_property",
+]

python_library_reactive_model-0.1.2/reactive_model/computed.py → python_library_reactive_model-0.1.3/reactive_model/computed_model.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Callable, TypeVar, cast
 
-from .reactive import ReactiveModel
+from .reactive_model import ReactiveModel
 from .track import Collector, Trackable, compute_context, track
 
 T = TypeVar("T")

python_library_reactive_model-0.1.3/reactive_model/computed_property.py

@@ -0,0 +1,24 @@
+from typing import Callable, Generic, TypeVar
+
+from reactive_model.computed_model import ComputedModel
+
+T = TypeVar("T")
+
+class computed_property(Generic[T]):
+    def __init__(self, func: Callable[..., T]) -> None:
+        self.func = func
+        self.storage_name = ""
+
+    def __set_name__(self, owner, name):
+        self.storage_name = f"__computed_{name}"
+
+    def __get__(self, obj, owner=None) -> T:
+        if obj is None:
+            return self
+
+        model = obj.__dict__.get(self.storage_name)
+        if model is None:
+            model = ComputedModel(lambda: self.func(obj))
+            obj.__dict__[self.storage_name] = model
+
+        return model.value

python_library_reactive_model-0.1.2/reactive_model/dict_ref.py → python_library_reactive_model-0.1.3/reactive_model/dict_ref_model.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections.abc import Iterable, Iterator, MutableMapping
 from typing import Generic, TypeVar
 
-from .ref import RefModel
+from .ref_model import RefModel
 from .track import track
 
 K = TypeVar("K")

python_library_reactive_model-0.1.2/reactive_model/list_ref.py → python_library_reactive_model-0.1.3/reactive_model/list_ref_model.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections.abc import Iterable, MutableSequence
 from typing import Generic, TypeVar, overload
 
-from .ref import RefModel
+from .ref_model import RefModel
 from .track import track
 
 T = TypeVar("T")
@@ -18,6 +18,7 @@ class ListProxy(MutableSequence[T], Generic[T]):
 
     @overload
     def __getitem__(self, index: int) -> T: ...
+
     @overload
     def __getitem__(self, index: slice) -> list[T]: ...
 
@@ -26,6 +27,7 @@ class ListProxy(MutableSequence[T], Generic[T]):
 
     @overload
     def __setitem__(self, index: int, value: T) -> None: ...
+
     @overload
     def __setitem__(self, index: slice, value: Iterable[T]) -> None: ...
 
@@ -41,25 +43,41 @@ class ListProxy(MutableSequence[T], Generic[T]):
         self._owner._value.insert(index, value)
         self._owner.touch()
 
+    def append(self, value: T) -> None:
+        self._owner._value.append(value)
+        self._owner.touch()
+
+    def extend(self, values: Iterable[T]) -> None:
+        self._owner._value.extend(values)
+        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 pop(self, index: int = -1) -> T:
+        item = self._owner._value.pop(index)
+        self._owner.touch()
+        return item
 
-    def sort(self, *, key=None, reverse: bool = False) -> None:
-        self._owner._value.sort(key=key, reverse=reverse)
+    def remove(self, value: T) -> None:
+        self._owner._value.remove(value)
         self._owner.touch()
 
     def reverse(self) -> None:
         self._owner._value.reverse()
         self._owner.touch()
 
+    def sort(self, *args: object, **kwargs: object) -> None:
+        self._owner._value.sort(*args, **kwargs)  # type: ignore[arg-type]
+        self._owner.touch()
+
+    def __iadd__(self, other: Iterable[T]) -> ListProxy[T]:
+        self._owner._value += list(other)
+        self._owner.touch()
+        return self
+
     def __repr__(self) -> str:
         return repr(self._owner._value)
 
@@ -79,4 +97,4 @@ class ListRefModel(RefModel[list[T]]):
     @value.setter
     def value(self, value: list[T]) -> None:
         self._value = value
-        self.touch()
+        self.touch()

python_library_reactive_model-0.1.2/reactive_model/ref.py → python_library_reactive_model-0.1.3/reactive_model/ref_model.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from typing import TypeVar
 
-from .reactive import ReactiveModel
+from .reactive_model import ReactiveModel
 from .track import track
 
 T = TypeVar("T")

python_library_reactive_model-0.1.3/tests/test_computed_property.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import unittest
+
+from reactive_model import RefModel, computed_property
+
+
+class TestComputedProperty(unittest.TestCase):
+    def test_access_on_class_returns_descriptor(self) -> None:
+        class Host:
+            def __init__(self) -> None:
+                self.x = RefModel(1)
+
+            @computed_property
+            def doubled(self) -> int:
+                return self.x.value * 2
+
+        desc = Host.doubled
+        self.assertIsInstance(desc, computed_property)
+        self.assertEqual(desc.storage_name, "__computed_doubled")
+
+    def test_lazy_compute_and_cache(self) -> None:
+        calls: list[int] = []
+
+        class Host:
+            def __init__(self) -> None:
+                self.x = RefModel(1)
+
+            @computed_property
+            def doubled(self) -> int:
+                calls.append(1)
+                return self.x.value * 2
+
+        h = Host()
+        self.assertEqual(calls, [])
+        self.assertEqual(h.doubled, 2)
+        self.assertEqual(calls, [1])
+        self.assertEqual(h.doubled, 2)
+        self.assertEqual(calls, [1])
+
+    def test_invalidates_when_dependency_changes(self) -> None:
+        class Host:
+            def __init__(self) -> None:
+                self.x = RefModel(1)
+
+            @computed_property
+            def doubled(self) -> int:
+                return self.x.value * 2
+
+        h = Host()
+        self.assertEqual(h.doubled, 2)
+        h.x.value = 3
+        self.assertEqual(h.doubled, 6)
+
+    def test_model_stored_on_instance_dict(self) -> None:
+        class Host:
+            def __init__(self) -> None:
+                self.x = RefModel(10)
+
+            @computed_property
+            def label(self) -> str:
+                return f"x={self.x.value}"
+
+        h = Host()
+        self.assertNotIn("__computed_label", h.__dict__)
+        _ = h.label
+        self.assertIn("__computed_label", h.__dict__)
+        model = h.__dict__["__computed_label"]
+        self.assertEqual(model.value, "x=10")
+
+    def test_per_instance_independence(self) -> None:
+        class Host:
+            def __init__(self, n: int) -> None:
+                self.x = RefModel(n)
+
+            @computed_property
+            def doubled(self) -> int:
+                return self.x.value * 2
+
+        a = Host(2)
+        b = Host(5)
+        self.assertEqual(a.doubled, 4)
+        self.assertEqual(b.doubled, 10)
+        a.x.value = 3
+        self.assertEqual(a.doubled, 6)
+        self.assertEqual(b.doubled, 10)
+
+    def test_two_computed_properties_same_instance(self) -> None:
+        class Host:
+            def __init__(self) -> None:
+                self.x = RefModel(2)
+
+            @computed_property
+            def doubled(self) -> int:
+                return self.x.value * 2
+
+            @computed_property
+            def tripled(self) -> int:
+                return self.x.value * 3
+
+        h = Host()
+        self.assertEqual(h.doubled, 4)
+        self.assertEqual(h.tripled, 6)
+        h.x.value = 4
+        self.assertEqual(h.doubled, 8)
+        self.assertEqual(h.tripled, 12)
+
+
+if __name__ == "__main__":
+    unittest.main()

python_library_reactive_model-0.1.2/reactive_model/__init__.py

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