python-library-tree-model 0.1.0__tar.gz

python_library_tree_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_tree_model-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: python-library-tree-model
+Version: 0.1.0
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-library-reactive-model

python_library_tree_model-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "python-library-tree-model"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = [
+    "python-library-reactive-model",
+    "pydantic>=2.0.0",
+]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["tree_model"]

python_library_tree_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
+python -m pip install -e .
+python -m unittest discover -s tests -p "test_*.py"

python_library_tree_model-0.1.0/tests/test_tree_node.py

@@ -0,0 +1,165 @@
+import unittest
+
+from tree_model import TreeModel
+
+
+class TreeModelTests(unittest.TestCase):
+    def test_full_name_and_add_child(self) -> None:
+        root = TreeModel(name="root")
+        a = TreeModel(name="a")
+        b = TreeModel(name="b")
+
+        root.add_child(a)
+        a.add_child(b)
+
+        self.assertIs(a.parent, root)
+        self.assertIs(b.parent, a)
+
+        self.assertEqual(root.full_name, "root")
+        self.assertEqual(a.full_name, "root.a")
+        self.assertEqual(b.full_name, "root.a.b")
+
+    def test_len_and_iter_direct_children(self) -> None:
+        root = TreeModel(name="root")
+        a = TreeModel(name="a")
+        b = TreeModel(name="b")
+        root.add_child(a)
+        root.add_child(b)
+
+        self.assertEqual(len(root), 2)
+        self.assertEqual(list(root), [a, b])
+
+    def test_exists_non_recursive_and_recursive(self) -> None:
+        root = TreeModel(name="root")
+        a = TreeModel(name="a")
+        b = TreeModel(name="b")
+
+        root.add_child(a)
+        a.add_child(b)
+
+        self.assertTrue(root.exists_child(lambda n: n.name == "a"))
+        self.assertFalse(root.exists_child(lambda n: n.name == "b"))
+        self.assertTrue(root.exists_child(lambda n: n.name == "b", recursive=True))
+        self.assertFalse(root.exists_child(lambda n: n.name == "missing", recursive=True))
+
+    def test_find_by_name(self) -> None:
+        root = TreeModel(name="root")
+        a = TreeModel(name="a")
+        b = TreeModel(name="b")
+        root.add_child(a)
+        a.add_child(b)
+
+        self.assertIs(root.find_child_by_name("a"), a)
+        self.assertIsNone(root.find_child_by_name("b"))
+        self.assertIs(root.find_child_by_name("b", recursive=True), b)
+
+    def test_get_raises_when_missing(self) -> None:
+        root = TreeModel(name="root")
+
+        with self.assertRaises(ValueError) as ctx:
+            root.get_child(lambda n: n.name == "missing")
+        self.assertIn("未找到", str(ctx.exception))
+
+    def test_get_recursive(self) -> None:
+        root = TreeModel(name="root")
+        a = TreeModel(name="a")
+        b = TreeModel(name="b")
+        root.add_child(a)
+        a.add_child(b)
+
+        self.assertIs(root.get_child(lambda n: n.name == "a"), a)
+        self.assertIs(root.get_child(lambda n: n.name == "b", recursive=True), b)
+
+    def test_find_returns_none_when_missing(self) -> None:
+        root = TreeModel(name="root")
+        a = TreeModel(name="a")
+        root.add_child(a)
+
+        self.assertIsNone(root.find_child_by_name("missing"))
+        self.assertIsNone(root.find_child_by_name("missing", recursive=True))
+
+    def test_filter_shallow_and_recursive(self) -> None:
+        root = TreeModel(name="root")
+        a = TreeModel(name="a")
+        b = TreeModel(name="b")
+        c = TreeModel(name="b")
+        root.add_child(a)
+        a.add_child(b)
+        root.add_child(c)
+
+        self.assertEqual(root.filter_child(lambda n: n.name == "b"), [c])
+        self.assertEqual(root.filter_child(lambda n: n.name == "b", recursive=True), [b, c])
+
+    def test_delete_child_removes_from_parent(self) -> None:
+        root = TreeModel(name="root")
+        child = TreeModel(name="child")
+
+        root.add_child(child)
+        self.assertTrue(root.exists_child(lambda n: n.name == "child"))
+
+        child.delete()
+
+        self.assertFalse(root.exists_child(lambda n: n.name == "child"))
+        self.assertIsNone(child.parent)
+        self.assertEqual(len(root), 0)
+
+    def test_delete_parent_deletes_descendants(self) -> None:
+        root = TreeModel(name="root")
+        a = TreeModel(name="a")
+        b = TreeModel(name="b")
+
+        root.add_child(a)
+        a.add_child(b)
+
+        root.delete()
+
+        self.assertIsNone(root.parent)
+        self.assertIsNone(a.parent)
+        self.assertIsNone(b.parent)
+        self.assertEqual(len(list(root)), 0)
+
+    def test_add_child_rejects_separator_in_name(self) -> None:
+        root = TreeModel(name="root")
+        bad = TreeModel(name="a.b")
+
+        with self.assertRaises(ValueError):
+            root.add_child(bad)
+
+    def test_add_child_rejects_existing_parent(self) -> None:
+        root1 = TreeModel(name="root1")
+        root2 = TreeModel(name="root2")
+        child = TreeModel(name="child")
+
+        root1.add_child(child)
+
+        with self.assertRaises(ValueError):
+            root2.add_child(child)
+
+    def test_add_child_rejects_same_child_twice(self) -> None:
+        root = TreeModel(name="root")
+        child = TreeModel(name="child")
+        root.add_child(child)
+
+        with self.assertRaises(ValueError) as ctx:
+            root.add_child(child)
+        self.assertIn("parent", str(ctx.exception))
+
+    def test_on_delete_callback_runs_when_node_deleted(self) -> None:
+        root = TreeModel(name="root")
+        child = TreeModel(name="child")
+        root.add_child(child)
+
+        called: list[str] = []
+
+        def mark() -> None:
+            called.append("x")
+
+        child.on_delete(mark)
+        child.delete()
+
+        self.assertEqual(called, ["x"])
+        self.assertEqual(len(root), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

python_library_tree_model-0.1.0/tree_model/__init__.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator
+from typing import Optional
+
+from pydantic import BaseModel, Field, PrivateAttr
+from reactive_model import ListRefModel
+
+
+class TreeModel(BaseModel):
+    name: str = Field(..., description="节点名称")
+    parent: Optional["TreeModel"] = Field(None, description="父节点")
+
+    _children: ListRefModel["TreeModel"] = PrivateAttr(default_factory=ListRefModel)
+    _on_delete: list[Callable[[], None]] = PrivateAttr(default_factory=list)
+    _name_separator: str = PrivateAttr(".")
+
+    @property
+    def full_name(self) -> str:
+        if self.parent is None:
+            return self.name
+        return f"{self.parent.full_name}{self._name_separator}{self.name}"
+
+    def add_child(self, child: "TreeModel") -> None:
+        if child.parent is not None:
+            raise ValueError(f"child {child.name!r} 已经有 parent")
+        if self._name_separator in child.name:
+            raise ValueError(f"child {child.name!r} 不允许包含名称分隔符")
+        if any(item is child for item in self._children.value):
+            raise ValueError("child 已经是子节点")
+
+        child.parent = self
+        self._children.value.append(child)
+        child.on_delete(lambda: self._remove_child(child))
+
+    def _remove_child(self, child: "TreeModel") -> None:
+        children = self._children.value
+        for index, item in enumerate(children):
+            if item is child:
+                del children[index]
+                break
+
+    def delete(self) -> None:
+        for child in list(self._children.value):
+            child.delete()
+
+        self._children.value.clear()
+        self.parent = None
+
+        for fn in self._on_delete:
+            fn()
+        self._on_delete.clear()
+
+    def on_delete(self, callback: Callable[[], None]) -> Callable[[], None]:
+        self._on_delete.append(callback)
+        return callback
+
+    def find_child(
+        self,
+        predicate: Callable[["TreeModel"], bool],
+        recursive: bool = False,
+    ) -> "TreeModel | None":
+        for child in self._children.value:
+            if predicate(child):
+                return child
+            if recursive:
+                found = child.find_child(predicate, recursive=True)
+                if found is not None:
+                    return found
+        return None
+
+    def filter_child(
+        self,
+        predicate: Callable[["TreeModel"], bool],
+        recursive: bool = False,
+    ) -> list["TreeModel"]:
+        result: list[TreeModel] = []
+        for child in self._children.value:
+            if predicate(child):
+                result.append(child)
+            if recursive:
+                result.extend(child.filter_child(predicate, recursive=True))
+        return result
+
+    def exists_child(
+        self,
+        predicate: Callable[["TreeModel"], bool],
+        recursive: bool = False,
+    ) -> bool:
+        return self.find_child(predicate, recursive=recursive) is not None
+
+    def get_child(
+        self,
+        predicate: Callable[["TreeModel"], bool],
+        recursive: bool = False,
+    ) -> "TreeModel":
+        child = self.find_child(predicate, recursive=recursive)
+        if child is None:
+            raise ValueError("未找到符合条件的子节点")
+        return child
+
+    def find_child_by_name(self, name: str, recursive: bool = False) -> "TreeModel | None":
+        return self.find_child(lambda node: node.name == name, recursive=recursive)
+
+    def __iter__(self) -> Iterator["TreeModel"]:
+        return iter(self._children.value)
+
+    def __len__(self) -> int:
+        return len(self._children.value)