tksheet 7.4.11__py3-none-any.whl → 7.4.13__py3-none-any.whl

tksheet/other_classes.py

@@ -40,7 +40,7 @@ DraggedRowColumn = namedtuple("DraggedRowColumn", "dragged to_move")
 
 
 class SelectionBox:
-    __slots__ = ("fill_iid", "bd_iid", "index", "header", "coords", "type_")
+    __slots__ = ("fill_iid", "bd_iid", "index", "header", "coords", "type_", "state")
 
     def __init__(
         self,
@@ -50,6 +50,7 @@ class SelectionBox:
         header: int | None = None,
         coords: tuple[int, int, int, int] = None,
         type_: Literal["cells", "rows", "columns"] = "cells",
+        state: Literal["normal", "hidden"] = "normal",
     ) -> None:
         self.fill_iid = fill_iid
         self.bd_iid = bd_iid
@@ -57,6 +58,7 @@ class SelectionBox:
         self.header = header
         self.coords = coords
         self.type_ = type_
+        self.state = state
 
 
 Selected = namedtuple(
@@ -446,7 +448,7 @@ class Node:
         self,
         text: str,
         iid: str,
-        parent: str | None = None,
+        parent: str = "",
         children: list[str] | None = None,
     ) -> None:
         self.text = text

tksheet/row_index.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import tkinter as tk
 from collections import defaultdict
 from collections.abc import Callable, Generator, Hashable, Iterator, Sequence
+from contextlib import suppress
 from functools import partial
-from itertools import chain, cycle, islice, repeat
-from math import ceil, floor
+from itertools import cycle, islice, repeat
+from math import ceil
 from operator import itemgetter
 from typing import Any, Literal
 
@@ -758,7 +759,7 @@ class RowIndex(tk.Canvas):
         if size < self.MT.min_row_height:
             new_row_pos = ceil(self.MT.row_positions[self.rsz_h - 1] + self.MT.min_row_height)
         elif size > self.ops.max_row_height:
-            new_row_pos = floor(self.MT.row_positions[self.rsz_h - 1] + self.ops.max_row_height)
+            new_row_pos = int(self.MT.row_positions[self.rsz_h - 1] + self.ops.max_row_height)
         increment = new_row_pos - self.MT.row_positions[self.rsz_h]
         self.MT.row_positions[self.rsz_h + 1 :] = [
             e + increment for e in islice(self.MT.row_positions, self.rsz_h + 1, None)
@@ -1054,51 +1055,6 @@ class RowIndex(tk.Canvas):
             self.MT.run_selection_binding("rows")
         return fill_iid
 
-    def display_box(
-        self,
-        x1: int,
-        y1: int,
-        x2: int,
-        y2: int,
-        fill: str,
-        outline: str,
-        state: str,
-        tags: str | tuple[str],
-        iid: None | int = None,
-    ) -> int:
-        coords = rounded_box_coords(
-            x1,
-            y1,
-            x2,
-            y2,
-            radius=5 if self.ops.rounded_boxes else 0,
-        )
-        if isinstance(iid, int):
-            self.coords(iid, coords)
-            self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags)
-        else:
-            if self.hidd_boxes:
-                iid = self.hidd_boxes.pop()
-                self.coords(iid, coords)
-                self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags)
-            else:
-                iid = self.create_polygon(
-                    coords,
-                    fill=fill,
-                    outline=outline,
-                    state=state,
-                    tags=tags,
-                    smooth=True,
-                )
-            self.disp_boxes.add(iid)
-        return iid
-
-    def hide_box(self, item: int | None) -> None:
-        if isinstance(item, int):
-            self.disp_boxes.discard(item)
-            self.hidd_boxes.add(item)
-            self.itemconfig(item, state="hidden")
-
     def get_cell_dimensions(self, datarn: int) -> tuple[int, int]:
         txt = self.cell_str(datarn, fix=False)
         if txt:
@@ -1116,7 +1072,7 @@ class RowIndex(tk.Canvas):
                 align = self.cell_options[datarn]["align"]
             else:
                 align = self.align
-            if align.endswith("w"):
+            if align[-1] == "w":
                 w += self.MT.index_txt_height
             w += self.get_iid_indent(self.MT._row_index[datarn].iid) + 10
         return w, h
@@ -1290,7 +1246,7 @@ class RowIndex(tk.Canvas):
             new_w = self.get_index_text_width(only_rows=only_rows)
         else:
             new_w = None
-        if new_w is not None and (sheet_w_x := floor(self.PAR.winfo_width() * 0.7)) < new_w:
+        if new_w is not None and (sheet_w_x := int(self.PAR.winfo_width() * 0.7)) < new_w:
             new_w = sheet_w_x
         if new_w and (self.current_width - new_w > 20 or new_w - self.current_width > 3):
             if self.MT.find_window.open:
@@ -1308,6 +1264,7 @@ class RowIndex(tk.Canvas):
         sel_rows_bg: str,
         selections: dict,
         datarn: int,
+        has_dd: bool,
     ) -> tuple[str, str, bool]:
         redrawn = False
         kwargs = self.get_cell_kwargs(datarn, key="highlight")
@@ -1348,11 +1305,7 @@ class RowIndex(tk.Canvas):
                     self.current_width - 1,
                     sr,
                     fill=fill,
-                    outline=(
-                        self.ops.index_fg
-                        if self.get_cell_kwargs(datarn, key="dropdown") and self.ops.show_dropdown_borders
-                        else ""
-                    ),
+                    outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
                     tag="s",
                 )
             tree_arrow_fg = txtfg
@@ -1360,9 +1313,27 @@ class RowIndex(tk.Canvas):
             if "rows" in selections and r in selections["rows"]:
                 txtfg = self.ops.index_selected_rows_fg
                 tree_arrow_fg = self.ops.selected_rows_tree_arrow_fg
+                redrawn = self.redraw_highlight(
+                    0,
+                    fr + 1,
+                    self.current_width - 1,
+                    sr,
+                    fill=self.ops.index_selected_rows_bg,
+                    outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tag="s",
+                )
             elif "cells" in selections and r in selections["cells"]:
                 txtfg = self.ops.index_selected_cells_fg
                 tree_arrow_fg = self.ops.selected_cells_tree_arrow_fg
+                redrawn = self.redraw_highlight(
+                    0,
+                    fr + 1,
+                    self.current_width - 1,
+                    sr,
+                    fill=self.ops.index_selected_cells_bg,
+                    outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tag="s",
+                )
             else:
                 txtfg = self.ops.index_fg
                 tree_arrow_fg = self.ops.tree_arrow_fg
@@ -1424,7 +1395,7 @@ class RowIndex(tk.Canvas):
     ) -> None:
         mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
         small_mod = int(mod / 5)
-        mid_y = floor(self.MT.min_row_height / 2)
+        mid_y = int(self.MT.min_row_height / 2)
         if has_children:
             # up arrow
             if open_:
@@ -1520,7 +1491,7 @@ class RowIndex(tk.Canvas):
         if draw_arrow:
             mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
             small_mod = int(mod / 5)
-            mid_y = floor(self.MT.min_row_height / 2)
+            mid_y = int(self.MT.min_row_height / 2)
             if open_:
                 # up arrow
                 points = (
@@ -1686,6 +1657,7 @@ class RowIndex(tk.Canvas):
                 continue
             checkbox_kwargs = {}
             datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
+            dropdown_kwargs = self.get_cell_kwargs(datarn, key="dropdown")
             fill, tree_arrow_fg, dd_drawn = self.redraw_highlight_get_text_fg(
                 fr=rtopgridln,
                 sr=rbotgridln,
@@ -1694,19 +1666,21 @@ class RowIndex(tk.Canvas):
                 sel_rows_bg=sel_rows_bg,
                 selections=selections,
                 datarn=datarn,
+                has_dd=bool(dropdown_kwargs),
             )
+
             if datarn in self.cell_options and "align" in self.cell_options[datarn]:
                 align = self.cell_options[datarn]["align"]
             else:
                 align = self.align
-            if dropdown_kwargs := self.get_cell_kwargs(datarn, key="dropdown"):
-                max_width = self.current_width - self.MT.index_txt_height - 2
-                if align.endswith("w"):
+            if dropdown_kwargs:
+                max_width = self.current_width - self.MT.index_txt_height - 5
+                if align[-1] == "w":
                     draw_x = 3
-                elif align.endswith("e"):
+                elif align[-1] == "e":
                     draw_x = self.current_width - 5 - self.MT.index_txt_height
-                elif align.endswith("n"):
-                    draw_x = ceil((self.current_width - self.MT.index_txt_height) / 2)
+                elif align[-1] == "n":
+                    draw_x = (self.current_width - self.MT.index_txt_height) / 2
                 self.redraw_dropdown(
                     0,
                     rtopgridln,
@@ -1721,22 +1695,22 @@ class RowIndex(tk.Canvas):
                 )
             else:
                 max_width = self.current_width - 2
-                if align.endswith("w"):
+                if align[-1] == "w":
                     draw_x = 3
-                elif align.endswith("e"):
+                elif align[-1] == "e":
                     draw_x = self.current_width - 3
-                elif align.endswith("n"):
-                    draw_x = floor(self.current_width / 2)
+                elif align[-1] == "n":
+                    draw_x = self.current_width / 2
                 if (
                     (checkbox_kwargs := self.get_cell_kwargs(datarn, key="checkbox"))
                     and not dropdown_kwargs
                     and max_width > self.MT.index_txt_height + 1
                 ):
                     box_w = self.MT.index_txt_height + 1
-                    if align.endswith("w"):
+                    if align[-1] == "w":
                         draw_x += box_w + 3
-                    elif align.endswith("n"):
-                        draw_x += ceil(box_w / 2) + 1
+                    elif align[-1] == "n":
+                        draw_x += box_w / 2 + 1
                     max_width -= box_w + 4
                     try:
                         draw_check = (
@@ -1759,7 +1733,7 @@ class RowIndex(tk.Canvas):
             if treeview and isinstance(self.MT._row_index, list) and len(self.MT._row_index) > datarn:
                 iid = self.MT._row_index[datarn].iid
                 max_width -= self.MT.index_txt_height
-                if align.endswith("w"):
+                if align[-1] == "w":
                     draw_x += self.MT.index_txt_height + 3
                 level, indent = self.get_iid_level_indent(iid)
                 draw_x += indent + 5
@@ -1811,7 +1785,6 @@ class RowIndex(tk.Canvas):
                             anchor=align,
                             state="normal",
                         )
-                    self.tag_raise(iid)
                 else:
                     iid = self.create_text(
                         draw_x,
@@ -1845,7 +1818,6 @@ class RowIndex(tk.Canvas):
                                 anchor=align,
                                 state="normal",
                             )
-                        self.tag_raise(iid)
                     else:
                         iid = self.create_text(
                             draw_x,
@@ -1898,6 +1870,7 @@ class RowIndex(tk.Canvas):
                 if showing:
                     self.itemconfig(iid, state="hidden")
                     dct[iid] = False
+        self.tag_raise("t")
         if self.disp_resize_lines:
             self.tag_raise("rh")
         return True
@@ -2505,8 +2478,8 @@ class RowIndex(tk.Canvas):
         kwargs = self.get_cell_kwargs(datarn, key=None, cell=r_ops)
         if "checkbox" in kwargs:
             return False
-        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
-            return kwargs["values"][0]
+        elif "dropdown" in kwargs and kwargs["dropdown"]["validate_input"] and kwargs["dropdown"]["values"]:
+            return kwargs["dropdown"]["values"][0]
         else:
             return ""
 
@@ -2757,16 +2730,17 @@ class RowIndex(tk.Canvas):
                 )
                 # deal with displayed mapping
                 event_data["moved"]["rows"]["displayed"] = {}
-                if new_loc_is_displayed:
-                    if disp_insert_row is None:
-                        if new_parent or insert_row > move_to_row:
-                            disp_insert_row = self.MT.disprn(self.rns[move_to_iid]) + 1
+                with suppress(Exception):
+                    if new_loc_is_displayed:
+                        if disp_insert_row is None:
+                            if new_parent or insert_row > move_to_row:
+                                disp_insert_row = self.MT.disprn(self.rns[move_to_iid]) + 1
+                            else:
+                                disp_insert_row = self.MT.disprn(self.rns[move_to_iid])
+                        if (disp_from_row := self.MT.try_disprn(self.rns[item])) is not None:
+                            event_data["moved"]["rows"]["displayed"] = {disp_from_row: disp_insert_row}
                         else:
-                            disp_insert_row = self.MT.disprn(self.rns[move_to_iid])
-                    if (disp_from_row := self.MT.try_disprn(self.rns[item])) is not None:
-                        event_data["moved"]["rows"]["displayed"] = {disp_from_row: disp_insert_row}
-                    else:
-                        event_data["moved"]["rows"]["displayed"] = {(): disp_insert_row}
+                            event_data["moved"]["rows"]["displayed"] = {(): disp_insert_row}
 
                 if any(self.move_pid_causes_recursive_loop(self.MT._row_index[r].iid, new_parent) for r in moved_rows):
                     event_data["moved"]["rows"] = {}
@@ -2787,7 +2761,7 @@ class RowIndex(tk.Canvas):
                         event_data["moved"]["rows"]["data"],
                     )
                     data_new_idxs = event_data["moved"]["rows"]["data"]
-                    data_old_idxs = dict(zip(data_new_idxs.values(), data_new_idxs))
+                    data_old_idxs = {v: k for k, v in data_new_idxs.items()}
 
                     if () in event_data["moved"]["rows"]["displayed"]:
                         del event_data["moved"]["rows"]["displayed"][()]
@@ -3016,15 +2990,6 @@ class RowIndex(tk.Canvas):
             if not parent_node.children:
                 self.tree_open_ids.discard(parent_node.iid)
 
-    def build_pid_causes_recursive_loop(self, iid: str, pid: str) -> bool:
-        return any(
-            i == pid
-            for i in chain(
-                self.get_iid_descendants(iid),
-                islice(self.get_iid_ancestors(iid), 1, None),
-            )
-        )
-
     def move_pid_causes_recursive_loop(self, to_move_iid: str, move_to_parent: str) -> bool:
         # if the parent the item is being moved under is one of the item's descendants
         # then it is a recursive loop
@@ -3045,8 +3010,8 @@ class RowIndex(tk.Canvas):
         include_parent_column: bool = True,
         include_text_column: bool = True,
     ) -> None:
-        index = self.MT._row_index
         data_rns = {}
+        tree = {}
         if text_column is None:
             text_column = iid_column
         if not isinstance(ncols, int):
@@ -3058,33 +3023,27 @@ class RowIndex(tk.Canvas):
             else:
                 iid = row[iid_column]
                 pid = row[parent_column]
-            if iid in self.rns:
-                index[self.rns[iid]].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
+            if iid in tree:
+                tree[iid].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
             else:
-                index.append(
-                    Node(
-                        text=row[text_column] if isinstance(text_column, int) else text_column[rn],
-                        iid=iid,
-                        parent="",
-                    )
+                tree[iid] = Node(
+                    text=row[text_column] if isinstance(text_column, int) else text_column[rn],
+                    iid=iid,
+                    parent="",
                 )
-                self.rns[iid] = len(index) - 1
             data_rns[iid] = rn
             if pid:
-                if pid in self.rns:
-                    index[self.rns[pid]].children.append(iid)
+                if pid in tree:
+                    tree[pid].children.append(iid)
                 else:
-                    index.append(
-                        Node(
-                            text=pid,
-                            iid=pid,
-                            children=[iid],
-                        )
+                    tree[pid] = Node(
+                        text=pid,
+                        iid=pid,
+                        children=[iid],
                     )
-                    self.rns[pid] = len(index) - 1
-                index[self.rns[iid]].parent = pid
+                tree[iid].parent = pid
             else:
-                index[self.rns[iid]].parent = ""
+                tree[iid].parent = ""
         exclude = set()
         if not include_iid_column:
             exclude.add(iid_column)
@@ -3093,18 +3052,35 @@ class RowIndex(tk.Canvas):
         if isinstance(text_column, int) and not include_text_column:
             exclude.add(text_column)
         rows = []
+        ctr = 0
         if exclude:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
-                rows.append(row)
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(e for i, e in enumerate(data[data_rns[diid]]) if i not in exclude)
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         else:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                row.extend(data[data_rns[iid]])
-                rows.append(row)
-        self.MT._row_index = []
-        self.rns = {}
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    row.extend(data[data_rns[iid]])
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(data[data_rns[diid]])
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         self.PAR.insert_rows(
             rows=rows,
             idx=0,
@@ -3119,7 +3095,6 @@ class RowIndex(tk.Canvas):
         )
         self.MT.all_rows_displayed = False
         self.MT.displayed_rows = list(range(len(self.MT._row_index)))
-        self.rns = {n.iid: i for i, n in enumerate(self.MT._row_index)}
         if open_ids:
             self.PAR.tree_set_open(open_ids=open_ids)
         else:
@@ -3146,8 +3121,8 @@ class RowIndex(tk.Canvas):
         include_parent_column: bool = True,
         include_text_column: bool = True,
     ) -> None:
-        index = self.MT._row_index
         data_rns = {}
+        tree = {}
         iids_missing_rows = set()
         if text_column is None:
             text_column = iid_column
@@ -3174,43 +3149,36 @@ class RowIndex(tk.Canvas):
                     x += 1
                 tally_of_ids[iid] += 1
                 row[iid_column] = new
-            if iid in self.rns:
-                index[self.rns[iid]].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
+            if iid in tree:
+                tree[iid].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
             else:
-                index.append(
-                    Node(
-                        text=row[text_column] if isinstance(text_column, int) else text_column[rn],
-                        iid=iid,
-                        parent="",
-                    )
+                tree[iid] = Node(
+                    text=row[text_column] if isinstance(text_column, int) else text_column[rn],
+                    iid=iid,
+                    parent="",
                 )
-                self.rns[iid] = len(index) - 1
             if iid in iids_missing_rows:
                 iids_missing_rows.discard(iid)
             data_rns[iid] = rn
-            if iid == pid or self.build_pid_causes_recursive_loop(iid, pid):
+            if iid == pid or self.build_pid_causes_recursive_loop(iid, pid, tree):
                 row[parent_column] = ""
                 pid = ""
             if pid:
-                if pid in self.rns:
-                    index[self.rns[pid]].children.append(iid)
+                if pid in tree:
+                    tree[pid].children.append(iid)
                 else:
-                    index.append(
-                        Node(
-                            text=pid,
-                            iid=pid,
-                            children=[iid],
-                        )
+                    tree[pid] = Node(
+                        text=pid,
+                        iid=pid,
+                        children=[iid],
                     )
                     iids_missing_rows.add(pid)
-                    self.rns[pid] = len(index) - 1
-                index[self.rns[iid]].parent = pid
+                tree[iid].parent = pid
             else:
-                index[self.rns[iid]].parent = ""
+                tree[iid].parent = ""
         empty_rows = {}
         for iid in iids_missing_rows:
-            node = index[self.rns[iid]]
-            node.parent = ""
+            node = tree[iid]
             newrow = self.MT.get_empty_row_seq(len(data), ncols)
             newrow[iid_column] = node.iid
             empty_rows[node.iid] = newrow
@@ -3222,24 +3190,41 @@ class RowIndex(tk.Canvas):
         if isinstance(text_column, int) and not include_text_column:
             exclude.add(text_column)
         rows = []
+        ctr = 0
         if exclude:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                if iid in empty_rows:
-                    row.extend(e for i, e in enumerate(empty_rows[iid]) if i not in exclude)
-                else:
-                    row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
-                rows.append(row)
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    if iid in empty_rows:
+                        row.extend(e for i, e in enumerate(empty_rows[iid]) if i not in exclude)
+                    else:
+                        row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(e for i, e in enumerate(data[data_rns[diid]]) if i not in exclude)
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         else:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                if iid in empty_rows:
-                    row.extend(empty_rows[iid])
-                else:
-                    row.extend(data[data_rns[iid]])
-                rows.append(row)
-        self.MT._row_index = []
-        self.rns = {}
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    if iid in empty_rows:
+                        row.extend(empty_rows[iid])
+                    else:
+                        row.extend(data[data_rns[iid]])
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(data[data_rns[diid]])
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         self.PAR.insert_rows(
             rows=rows,
             idx=0,
@@ -3254,7 +3239,6 @@ class RowIndex(tk.Canvas):
         )
         self.MT.all_rows_displayed = False
         self.MT.displayed_rows = list(range(len(self.MT._row_index)))
-        self.rns = {n.iid: i for i, n in enumerate(self.MT._row_index)}
         if open_ids:
             self.PAR.tree_set_open(open_ids=open_ids)
         else:
@@ -3265,3 +3249,29 @@ class RowIndex(tk.Canvas):
                 data_indexes=True,
                 row_heights=row_heights is not False,
             )
+
+    def _build_get_descendants(self, iid: str, tree: dict[str, Node]) -> Generator[str]:
+        stack = [iter(tree[iid].children)]
+        while stack:
+            top_iterator = stack[-1]
+            try:
+                ciid = next(top_iterator)
+                yield ciid
+                if tree[ciid].children:
+                    stack.append(iter(tree[ciid].children))
+            except StopIteration:
+                stack.pop()
+
+    def build_pid_causes_recursive_loop(self, iid: str, pid: str, tree: dict[str, Node]) -> bool:
+        # check descendants
+        for diid in self._build_get_descendants(iid, tree):
+            if diid == pid:
+                return True
+        # check ancestors
+        current_iid = iid
+        while tree[current_iid].parent:
+            parent_iid = tree[current_iid].parent
+            if parent_iid == pid:
+                return True
+            current_iid = parent_iid
+        return False