dtree-encoding 1.7.0__tar.gz → 1.8.0__tar.gz

{dtree_encoding-1.7.0 → dtree_encoding-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dtree-encoding
-Version: 1.7.0
+Version: 1.8.0
 Summary: DTree: incremental encoding of the topology of directed trees by two projections (Q1, Q2): O(1) reachability, and/or queries on the topology of the tree, dynamic (incremental) updates
 Author-email: Enis Olgac <enis@digraphs.info>
 License: MIT
@@ -59,7 +59,9 @@ t = DTree.from_file("Test.csx")   # e.g. examples/Test.csx from the repository
 | C# (docs) | Python |
 |---|---|
 | `DTree(id)` | `DTree(tree_id="P1")` |
-| `Insert(parent, child)` | `insert(parent, child)` |
+| `Insert(parent, child)` | `insert(parent, child)` (last child) |
+| `InsertAfter`, `InsertBefore` | `insert_after(sibling, child)`, `insert_before(sibling, child)` |
+| `AddLine` | `add_line(line)` (`p: c`, `s > c`, `s < c`; also in `from_file`) |
 | `Contains(node)` | `contains(node)` / `node in t` |
 | `GetParent(node)` | `get_parent(node)` (`None` for the root) |
 | `CutNPaste(u, p)` | `cut_n_paste(subtree_root, new_parent)` |

{dtree_encoding-1.7.0 → dtree_encoding-1.8.0}/README.md

@@ -36,7 +36,9 @@ t = DTree.from_file("Test.csx")   # e.g. examples/Test.csx from the repository
 | C# (docs) | Python |
 |---|---|
 | `DTree(id)` | `DTree(tree_id="P1")` |
-| `Insert(parent, child)` | `insert(parent, child)` |
+| `Insert(parent, child)` | `insert(parent, child)` (last child) |
+| `InsertAfter`, `InsertBefore` | `insert_after(sibling, child)`, `insert_before(sibling, child)` |
+| `AddLine` | `add_line(line)` (`p: c`, `s > c`, `s < c`; also in `from_file`) |
 | `Contains(node)` | `contains(node)` / `node in t` |
 | `GetParent(node)` | `get_parent(node)` (`None` for the root) |
 | `CutNPaste(u, p)` | `cut_n_paste(subtree_root, new_parent)` |

{dtree_encoding-1.7.0 → dtree_encoding-1.8.0}/dtree/__init__.py

@@ -3,4 +3,4 @@
 from .dtree import SINK, SOURCE, DList, DNode, DTree, UMax, UMin, VMax, VMin
 
 __all__ = ["DTree", "DNode", "DList", "VMin", "VMax", "UMin", "UMax", "SOURCE", "SINK"]
-__version__ = "1.7.0"
+__version__ = "1.8.0"

{dtree_encoding-1.7.0 → dtree_encoding-1.8.0}/dtree/dtree.py

@@ -351,7 +351,12 @@ class DTree:
     # -- construction ------------------------------------------------------
     @classmethod
     def from_file(cls, path: str, tree_id: Optional[str] = None) -> "DTree":
-        """Read the ``parent: child1; child2`` format used by the .csx examples."""
+        """Read the format used by the .csx examples.
+
+        ``parent: child1; child2`` adds children as last children of ``parent``;
+        ``sibling > child1; child2`` inserts them as siblings directly after ``sibling``
+        (in that order), ``sibling < child1; child2`` directly before it.
+        """
         import os
 
         tree = cls(tree_id or os.path.splitext(os.path.basename(path))[0])
@@ -362,12 +367,27 @@ class DTree:
                     continue
                 if line.startswith("@@"):
                     break
-                parent, _, rest = line.partition(":")
-                for child in (c.strip() for c in rest.split(";")):
-                    if child:
-                        tree.insert(parent.strip(), child)
+                tree.add_line(line)
         return tree
 
+    def add_line(self, line: str) -> List[DNode]:
+        """Apply one line of the description format (see from_file); returns the new handles."""
+        at = min((i for i in (line.find(":"), line.find(">"), line.find("<")) if i >= 0), default=-1)
+        if at < 0:
+            raise ValueError(f"no ':', '>' or '<' in {line!r}")
+        op, anchor = line[at], line[:at].strip()
+        children = [c.strip() for c in line[at + 1:].split(";") if c.strip()]
+        added = []
+        for child in children:
+            if op == ":":
+                added.append(self.insert(anchor, child))
+            elif op == ">":
+                added.append(self.insert_after(anchor, child))
+                anchor = child                       # the next one goes after this one
+            else:
+                added.append(self.insert_before(anchor, child))
+        return added
+
     def insert(self, parent, child: str) -> DNode:
         """Add the edge parent -> child and return the handle of ``child``.
 
@@ -387,6 +407,56 @@ class DTree:
         self.edge_log.append(f"({p.name}, {child})")
         return n
 
+    def insert_after(self, sibling, child: str) -> DNode:
+        """Insert ``child`` as a sibling directly after ``sibling`` (same parent) and return its
+        handle. In Q1 it goes after the end of the sibling's subtree, in Q2 directly before the
+        sibling; no other node moves. The root has no siblings."""
+        s = self._sibling(sibling, child)
+        p = s.up
+        i = p.kids.index(s)
+        w = self._subtree_last_node(s)
+        n = self._link_node(child, p, i + 1, w.c1, s.c2.prev)
+        if i + 1 == len(p.kids) - 1:
+            p.last = n                                  # n is now the last node of p's subtree
+        self.edge_log.append(f"({s.name} > {child})")
+        return n
+
+    def insert_before(self, sibling, child: str) -> DNode:
+        """Insert ``child`` as a sibling directly before ``sibling`` (same parent) and return its
+        handle. In Q1 it goes directly before the sibling, in Q2 after the end of the sibling's
+        subtree there (directly before the previous sibling; for a first child, after the end
+        of the parent's subtree in Q2, found by following first children); no other node moves."""
+        s = self._sibling(sibling, child)
+        p = s.up
+        i = p.kids.index(s)
+        q2_after = p.kids[i - 1].c2.prev if i > 0 else self._subtree_first_last_q2(s).c2
+        n = self._link_node(child, p, i, s.c1.prev, q2_after)
+        self.edge_log.append(f"({s.name} < {child})")
+        return n
+
+    def _sibling(self, sibling, child: str) -> DNode:
+        if child in (SOURCE, SINK):
+            raise ValueError("SOURCE/SINK markers cannot be tree nodes")
+        s = self._node(sibling)
+        if s.up is None:
+            raise ValueError("the root has no siblings")
+        if child in self._nodes:
+            raise ValueError(f"child {child!r} is already in the tree")
+        return s
+
+    def _link_node(self, name: str, p: DNode, index: int, q1_after, q2_after) -> DNode:
+        """Create a child of p at position ``index`` among p's children, linked after the given cells."""
+        n = DNode(name, self)
+        c1, c2 = self._q1._new(name), self._q2._new(name)
+        self._q2._link_after(c2, q2_after)
+        self._q1._link_after(c1, q1_after)
+        n.up = p
+        p.kids.insert(index, n)
+        c1.node = c2.node = n
+        n.c1, n.c2 = c1, c2
+        self._nodes[name] = n
+        return n
+
     def _new_node(self, name: str, p: Optional[DNode]) -> DNode:
         n = DNode(name, self)
         q1, q2 = self._q1, self._q2

{dtree_encoding-1.7.0 → dtree_encoding-1.8.0}/dtree_encoding.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dtree-encoding
-Version: 1.7.0
+Version: 1.8.0
 Summary: DTree: incremental encoding of the topology of directed trees by two projections (Q1, Q2): O(1) reachability, and/or queries on the topology of the tree, dynamic (incremental) updates
 Author-email: Enis Olgac <enis@digraphs.info>
 License: MIT
@@ -59,7 +59,9 @@ t = DTree.from_file("Test.csx")   # e.g. examples/Test.csx from the repository
 | C# (docs) | Python |
 |---|---|
 | `DTree(id)` | `DTree(tree_id="P1")` |
-| `Insert(parent, child)` | `insert(parent, child)` |
+| `Insert(parent, child)` | `insert(parent, child)` (last child) |
+| `InsertAfter`, `InsertBefore` | `insert_after(sibling, child)`, `insert_before(sibling, child)` |
+| `AddLine` | `add_line(line)` (`p: c`, `s > c`, `s < c`; also in `from_file`) |
 | `Contains(node)` | `contains(node)` / `node in t` |
 | `GetParent(node)` | `get_parent(node)` (`None` for the root) |
 | `CutNPaste(u, p)` | `cut_n_paste(subtree_root, new_parent)` |

{dtree_encoding-1.7.0 → dtree_encoding-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dtree-encoding"
-version = "1.7.0"
+version = "1.8.0"
 description = "DTree: incremental encoding of the topology of directed trees by two projections (Q1, Q2): O(1) reachability, and/or queries on the topology of the tree, dynamic (incremental) updates"
 readme = "README.md"
 requires-python = ">=3.8"

{dtree_encoding-1.7.0 → dtree_encoding-1.8.0}/tests/test_dtree.py

@@ -68,6 +68,18 @@ class Reference:
         for n in gone:
             del self.parent[n]
 
+    def insert_after(self, s, v):
+        p = self.parent[s]
+        sib = self.children[p]
+        sib.insert(sib.index(s) + 1, v)
+        self.parent[v] = p
+
+    def insert_before(self, s, v):
+        p = self.parent[s]
+        sib = self.children[p]
+        sib.insert(sib.index(s), v)
+        self.parent[v] = p
+
     def move(self, u, p):
         old = self.parent[u]
         self.children[old].remove(u)
@@ -559,6 +571,136 @@ class TestAgainstReference(unittest.TestCase):
                 check(self, t, ref)
 
 
+class TestSiblingInsert(unittest.TestCase):
+    def test_example(self):
+        t = DTree()
+        t.insert("A", "B")
+        t.insert("A", "D")
+        t.insert("B", "C")
+        t.insert_after("B", "X")       # A: B, X, D
+        t.insert_before("B", "W")      # A: W, B, X, D
+        t.insert_before("C", "C0")     # B: C0, C
+        self.assertEqual(t.children("A"), ["W", "B", "X", "D"])
+        self.assertEqual(t.children("B"), ["C0", "C"])
+        self.assertEqual(t.q1, ["A", "W", "B", "C0", "C", "X", "D"])
+        self.assertEqual(t.q2, ["A", "D", "X", "B", "C", "C0", "W"])
+        self.assertTrue(t.can_reach("A", "X") and not t.can_reach("B", "X"))
+        self.assertEqual(t.subtree_last("A"), "D")
+
+    def test_rules(self):
+        t = DTree()
+        t.insert("A", "B")
+        with self.assertRaises(ValueError):
+            t.insert_after("A", "Z")           # the root has no siblings
+        with self.assertRaises(ValueError):
+            t.insert_before("A", "Z")
+        with self.assertRaises(ValueError):
+            t.insert_after("B", "A")           # already in the tree
+        with self.assertRaises(KeyError):
+            t.insert_after("nobody", "Z")
+        n = t.insert_after(t.get_node("B"), "C")   # handles work too
+        self.assertIsInstance(n, DNode)
+        self.assertEqual(t.children("A"), ["B", "C"])
+
+    def test_example_file(self):
+        t = DTree.from_file(os.path.join(EXAMPLES, "siblings.csx"))
+        self.assertEqual(t.children("01"), ["02", "04", "06", "05"])
+        self.assertEqual(t.q1, ["01", "02", "03a", "03", "04", "06", "05"])
+        self.assertEqual(t.q2, ["01", "05", "06", "04", "02", "03", "03a"])
+
+    def test_description_lines(self):
+        t = DTree()
+        t.add_line("A: B; D")
+        t.add_line("B > X; Y")         # X after B, Y after X
+        t.add_line("D < W1; W2")       # W1 before D, W2 before D
+        t.add_line("B: C")
+        self.assertEqual(t.children("A"), ["B", "X", "Y", "W1", "W2", "D"])
+        self.assertEqual(t.children("B"), ["C"])
+
+    def test_random_mix(self):
+        # all three kinds of insertion, mixed with deletes and moves, against the reference
+        import dtree.dtree as impl
+        for budget in (impl._BUDGET, 0):
+            saved, impl._BUDGET = impl._BUDGET, budget
+            try:
+                for seed in range(12):
+                    t, ref, rnd = random_tree(20, seed)
+                    k = 0
+                    for _ in range(100):
+                        nodes = ref.nodes()
+                        inner = [n for n in nodes if n != ref.root]
+                        r = rnd.random()
+                        name = f"x{k}"
+                        if r < 0.25:
+                            p = rnd.choice(nodes)
+                            t.insert(p, name)
+                            ref.insert(p, name)
+                            k += 1
+                        elif r < 0.5 and inner:
+                            s = rnd.choice(inner)
+                            t.insert_after(s, name)
+                            ref.insert_after(s, name)
+                            k += 1
+                        elif r < 0.75 and inner:
+                            s = rnd.choice(inner)
+                            t.insert_before(s, name)
+                            ref.insert_before(s, name)
+                            k += 1
+                        elif r < 0.85 and len(inner) > 10:
+                            v = rnd.choice(inner)
+                            t.delete(v)
+                            ref.delete(v)
+                        elif len(inner) > 10:
+                            u = rnd.choice(inner)
+                            banned = set(t.subtree(u))
+                            p = rnd.choice([n for n in nodes if n not in banned])
+                            t.cut_n_paste(u, p)
+                            ref.move(u, p)
+                        check(self, t, ref)
+                        for v in rnd.sample(ref.nodes(), 3):
+                            sub_v = [w for w in ref.nodes() if w == v or v == ref.root or v in ref_ancestors(ref.parent, w)]
+                            self.assertEqual(t.subtree_last(v), [w for w in t.q1 if w in sub_v][-1])
+            finally:
+                impl._BUDGET = saved
+
+    def test_same_gap_many_times(self):
+        # repeated insertion into the same gap from both sides: positions stay strictly increasing
+        t, ref = DTree(), Reference()
+        t.insert("r", "a")
+        ref.insert("r", "a")
+        t.insert("r", "b")
+        ref.insert("r", "b")
+        left, right = "a", "b"
+        for i in range(400):
+            if i % 2:
+                t.insert_after(left, f"l{i}")
+                ref.insert_after(left, f"l{i}")
+                left = f"l{i}"
+            else:
+                t.insert_before(right, f"r{i}")
+                ref.insert_before(right, f"r{i}")
+                right = f"r{i}"
+        check(self, t, ref)
+
+    def test_constructed_nodes_stay_valid(self):
+        t, ref, rnd = random_tree(60, 3)
+        S = rnd.sample(ref.nodes(), 6)
+        um, vm = t.umin(S), t.vmax(S)
+        for i in range(60):
+            s = rnd.choice([n for n in ref.nodes() if n != ref.root])
+            if i % 2:
+                t.insert_after(s, f"y{i}")
+                ref.insert_after(s, f"y{i}")
+            else:
+                t.insert_before(s, f"y{i}")
+                ref.insert_before(s, f"y{i}")
+        for v in ref.nodes():
+            anc = set(ref_ancestors(ref.parent, v)[1:]) | ({ref.root} if v != ref.root else set())
+            self.assertEqual(um.reached_by_some(v), any(m in anc for m in S), v)
+            below = {w for w in ref.nodes() if w != v and (v == ref.root or v in ref_ancestors(ref.parent, w))}
+            self.assertEqual(vm.reaches_some(v), any(m in below for m in S), v)
+
+
 class TestNoSizeLimit(unittest.TestCase):
     def test_deep_chain(self):
         t = DTree()