relationalai 0.13.5__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

relationalai/experimental/paths/rpq/rpq.py

@@ -1,378 +0,0 @@
-from abc import ABC, abstractmethod
-import typing
-from .glushkov import Glushkov
-from .filter import (
-    NodeFilter, NodeLabel, AnonymousNodeFilter, EdgeLabel, AnonymousEdgeFilter,
-    parse_label
-)
-from relationalai.semantics import Concept
-
-# =========================================================================================
-# Regular Path Queries (RPQs) with local filters
-# =========================================================================================
-#
-# Regular Path Queries with local filters are represented as ASTs defined with this grammar.
-#
-# expr ::= Node([NodeLabel], [AnonymousNodeFilter])
-#        | Edge(EdgeLabel, [AnonymousEdgeFilter])
-#        | Concat(expr₁, expr₂)
-#        | Union(expr₁, expr₂)
-#        | Star(expr)
-#        | Plus(expr)
-#        | Optional(expr)
-#        | Void
-#
-# Every Edge leaf of an RPQ is automatically assigned a unique position `pos` value i.e.,
-# the `Edge` constructor uses a class variable `_id_counter` to generate a fresh value for
-# each new instance of `Edge`. The positions are used to provide the user with clear
-# feedback (error and warnings) that refers to specific places in the input RPQ.
-#
-# An important requirement is that an RPQ does not use two Edge leaves with the same
-# position.  With a natural use of the RPQ constructors, this requirement is not violated
-# unless a subexpression is reused. Consequently, the `clone` method is provided to create a
-# copy of an RPQ subexpression with fresh edge positions. For further safety, we ensure that
-# no two Edges with the same position are present, by constructing the set of positions of
-# an expression. If during the construction of a complex RPQ (`Concat` or `Union`) we find
-# repeating positions, we clone one of the expressions to ensure that the positions are
-# unique in the whole RPQ.
-# =========================================================================================
-
-#------------------------------------------------------------------------------------------
-# Auxiliary function for repeating `expr{n:m}` used to implement slicing operator of RPQ
-#------------------------------------------------------------------------------------------
-
-
-#-----------------------------------------------------------------------------
-# Parsing RPQ elements specified with strings (node and edge labels).
-#-----------------------------------------------------------------------------
-
-
-class RPQ(ABC):
-    _id_counter = 0
-
-    @classmethod
-    def next_id(cls) -> int:
-        cls._id_counter += 1
-        return cls._id_counter
-
-    def __init__(self, positions: typing.FrozenSet[int] = frozenset()):
-        self._positions = positions
-
-    @property
-    def positions(self) -> typing.FrozenSet[int]:
-        return self._positions
-
-    @abstractmethod
-    def clone(self) -> 'RPQ':
-        pass
-
-    @abstractmethod
-    def glushkov(self) -> Glushkov:
-        pass
-
-    @abstractmethod
-    def pprint(self, ind) -> str:
-        pass
-
-    def __str__(self):
-        return self.pprint("")
-
-    @abstractmethod
-    def to_dict(self) -> dict:
-        pass
-
-    def __len__(self) -> int:
-        return len(self.positions)
-
-    # expr[n:m]
-    def __getitem__(self, key):
-        if isinstance(key, int):
-            return _repeat(self, key, key)
-        elif isinstance(key, slice):
-            return _repeat(self, key.start, key.stop)
-        else:
-            return NotImplemented
-
-    # expr₁ | expr₂
-    def __or__(self, other):
-        if isinstance(self, Void):
-            return other
-        elif isinstance(other, Void):
-            return self
-        else:
-            return Union(self, other)
-
-    # expr₁ ⋅ expr₂
-    def __mul__(self, other):
-        return Concat(self, other)
-
-# ∅
-class Void(RPQ):
-    def __init__(self):
-        super().__init__()
-
-    def clone(self):
-        return Void()
-
-    def glushkov(self):
-        return Glushkov.void()
-
-    def pprint(self, ind):
-        return ind + "⋅ ∅"
-
-    def to_dict(self):
-        return {"type": "Void"}
-
-# ε(label {filter})
-class Node(RPQ):
-    def __init__(self,
-                 label: typing.Optional[NodeLabel]=None,
-                 filter: typing.Optional[AnonymousNodeFilter]=None):
-        super().__init__()
-        self.label = label
-        self.filter = filter
-
-    def clone(self):
-        return Node(self.label, self.filter)
-
-    def glushkov(self):
-        filters: typing.List[NodeFilter] = []
-        if self.label is not None:
-            filters.append(self.label)
-        if self.filter is not None:
-            filters.append(self.filter)
-        return Glushkov.node_transition(*filters)
-
-    def pprint(self, ind):
-        res = ind + "⋅ Node("
-        if self.label is not None:
-            res += f"{self.label}"
-        if self.filter is not None:
-            res += " {" if self.label is not None else "{"
-            res += f"{self.filter}"
-            res += "}"
-        res += ")"
-        return res
-
-    def to_dict(self) -> dict:
-        d = {"type": "Node"}
-        if self.label is not None:
-            d["label"] = self.label.to_dict() # type: ignore
-        if self.filter is not None:
-            d["filter"] = self.filter.to_dict() # type: ignore
-        return d
-
-# -[label {filter}]->
-class Edge(RPQ):
-    def __init__(self,
-                 label: EdgeLabel,
-                 filter: typing.Optional[AnonymousEdgeFilter] = None):
-        self.pos = self.next_id()
-        super().__init__(frozenset([self.pos]))
-        self.label = label
-        self.filter = filter
-
-    def clone(self):
-        return Edge(self.label, self.filter)
-
-    def glushkov(self):
-        return Glushkov.edge_transition(self.pos, self.label, self.filter)
-
-    # we avoid using `[...]` which can be mistaken for control sequence by rich-text loggers
-    def pprint(self, ind):
-        res = ind + "⋅ "
-        filter_str = ""
-        if self.filter is not None:
-            filter_str += f" {{ {self.filter} }}"
-        if self.label.direction == "forward":
-            res += f"-⟨{self.label.label}{filter_str}⟩→"
-        else:
-            res += f"←⟨{self.label.label}{filter_str}⟩-"
-        res += f" pos={self.pos} "
-        return res
-
-    def to_dict(self) -> dict:
-        return {
-            "type": "Edge",
-            "pos": self.pos,
-            "label": self.label.to_dict() # type: ignore
-        }
-
-# expr₁ ⋅ expr₂
-class Concat(RPQ):
-    def __init__(self, expr1:RPQ, expr2:RPQ):
-        if not expr1.positions.isdisjoint(expr2.positions):
-            expr2 = expr2.clone()
-        super().__init__(expr1.positions | expr2.positions)
-        self.expr1 = expr1
-        self.expr2 = expr2
-
-    def clone(self):
-        return Concat(self.expr1.clone(), self.expr2.clone())
-
-    def glushkov(self):
-        g = self.expr1.glushkov()
-        g *= self.expr2.glushkov()
-        return g
-
-    def pprint(self, ind):
-        res = ind + "⋅ Concat\n"
-        res += self.expr1.pprint(ind + "   ") + "\n"
-        res += self.expr2.pprint(ind + "   ")
-        return res
-
-    def to_dict(self) -> dict:
-        return {
-            "type": "Concat",
-            "expr1": self.expr1.to_dict(), # type: ignore
-            "expr2": self.expr2.to_dict()  # type: ignore
-        }
-
-# expr ₁ | expr₂
-class Union(RPQ):
-    def __init__(self, expr1:RPQ, expr2:RPQ):
-        if not expr1.positions.isdisjoint(expr2.positions):
-            expr2 = expr2.clone()
-        super().__init__(expr1.positions | expr2.positions)
-        self.expr1 = expr1
-        self.expr2 = expr2
-
-    def clone(self):
-        return Union(self.expr1.clone(), self.expr2.clone())
-
-    def glushkov(self):
-        g = self.expr1.glushkov()
-        g |= self.expr2.glushkov()
-        return g
-
-    def pprint(self, ind):
-        res = ind + "⋅ Union\n"
-        res += self.expr1.pprint(ind + "   ") + "\n"
-        res += self.expr2.pprint(ind + "   ")
-        return res
-
-    def to_dict(self) -> dict:
-        return {
-            "type": "Union",
-            "expr1": self.expr1.to_dict(), # type: ignore
-            "expr2": self.expr2.to_dict()  # type: ignore
-        }
-
-# expr*
-class Star(RPQ):
-    def __init__(self, expr:RPQ):
-        super().__init__(expr.positions)
-        self.expr = expr
-
-    def clone(self):
-        return Star(self.expr.clone())
-
-    def glushkov(self):
-        return self.expr.glushkov().star()
-
-    def pprint(self, ind):
-        return ind + "⋅ Star\n" + self.expr.pprint(ind + '   ')
-
-    def to_dict(self) -> dict:
-        return {
-            "type": "Star",
-            "expr": self.expr.to_dict() # type: ignore
-        }
-
-# expr+
-class Plus(RPQ):
-    def __init__(self, expr:RPQ):
-        super().__init__(expr.positions)
-        self.expr = expr
-
-    def clone(self):
-        return Plus(self.expr.clone())
-
-    def glushkov(self):
-        return self.expr.glushkov().plus()
-
-    def pprint(self, ind):
-        return ind + "⋅ Plus\n" + self.expr.pprint(ind + '   ')
-
-    def to_dict(self) -> dict:
-        return {
-            "type": "Plus",
-            "expr": self.expr.to_dict() # type: ignore
-        }
-
-# expr?
-class Optional(RPQ):
-    def __init__(self, expr:RPQ):
-        super().__init__(expr.positions)
-        self.expr = expr
-
-    def clone(self):
-        return Optional(self.expr.clone())
-
-    def glushkov(self):
-        return self.expr.glushkov().optional()
-
-    def pprint(self, ind):
-        return ind + "⋅ Optional\n" + self.expr.pprint(ind + '   ')
-
-    def to_dict(self) -> dict:
-        return {
-            "type": "Optional",
-            "expr": self.expr.to_dict() # type: ignore
-        }
-
-
-
-# allowed types for segments in RPQ constructors:
-Segment = typing.Union[str, Concept, RPQ]
-
-
-def _process_segment(s: Segment) -> RPQ:
-
-    if isinstance(s, str):
-        label = parse_label(s)
-        if isinstance(label, NodeLabel):
-            return Node(label)
-        else:
-            return Edge(label)
-    elif isinstance(s, Concept):
-        return Node(NodeLabel(s._name))
-    elif isinstance(s, RPQ):
-        return s
-    else:
-        raise Exception(f"Incorrect type `{type(s)}` of segment `{s}`")
-
-
-def _repeat(pattern: 'RPQ', n:typing.Union[int,None], m:typing.Union[int,None]) -> 'RPQ':
-    n = n if n is not None else 0
-    assert n >= 0, f"Negative start range [{n}:{m}]"
-    assert (m is None or m >= n), f"Invalid repeat range [{n}:{m}]"
-    if m is None:
-        if n == 0:
-            return Star(pattern)
-        elif n == 1:
-            return Plus(pattern)
-        else:
-            result = pattern.clone()
-            for _ in range(n-2):
-                result = Concat(result, pattern.clone())
-            return Concat(result, Plus(pattern))
-    else:
-        if n == 0:
-            if m == 0:
-                return Node()
-            else:
-                result = Optional(pattern)
-                for _ in range(m-1):
-                    result = Concat(result, Optional(pattern.clone()))
-                return result
-        else:
-            result = pattern
-            for _ in range(n-1):
-                result = Concat(result, pattern.clone())
-            for _ in range(m-n):
-                result = Concat(result, Optional(pattern.clone()))
-            return result
-
-# Explicitly export RPQ and other relevant classes
-__all__ = ["RPQ", "Node", "Edge", "Concat", "Union", "Star"]

relationalai/experimental/paths/tests/tests_limit_sp_max_length.py

@@ -1,90 +0,0 @@
-from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.experimental.paths.graph import Graph
-from relationalai.experimental.paths.path_algorithms.find_paths import find_shortest_paths
-
-
-# First test with grid graph
-model = Model("test_all", dry_run=False)
-
-grid = Graph.construct_grid(model, 3)
-
-path_num, k = Integer.ref(), Integer.ref()
-v = grid.Node.ref()
-
-n1_1 = grid.Node.new(row = 1, col = 1)
-n1_2 = grid.Node.new(row = 1, col = 2)
-n1_3 = grid.Node.new(row = 1, col = 3)
-n2_1 = grid.Node.new(row = 2, col = 1)
-n2_2 = grid.Node.new(row = 2, col = 2)
-n2_3 = grid.Node.new(row = 2, col = 3)
-n3_1 = grid.Node.new(row = 3, col = 1)
-n3_2 = grid.Node.new(row = 3, col = 2)
-n3_3 = grid.Node.new(row = 3, col = 3)
-
-Source_1 = model.Concept("Source_1", extends=[grid.Node])
-Target_1 = model.Concept("Target_1", extends=[grid.Node])
-
-define(Source_1(n1_1))
-define(Source_1(n1_2))
-define(Target_1(n3_2))
-define(Target_1(n3_3))
-
-paths_1 = find_shortest_paths(grid, Source_1, Target_1, num_paths=1, max_length=3)
-iter_path_1 = select(k, v.row, v.col).where(paths_1(path_num, k, v)).to_df()
-tuple_path_1 = tuple(sorted([row for row in iter_path_1.itertuples(index = False, name = None)]))
-
-expected_path_1 = (
-    (0, 1, 2), (1, 2, 2), (2, 3, 2)
-)
-
-assert tuple_path_1 == expected_path_1
-
-
-# Second test with grid graph
-paths_2 = find_shortest_paths(grid, Source_1, Target_1, num_paths=10, max_length=1)
-
-assert select(k, v.row, v.col).where(paths_2(path_num, k, v)).to_df().empty
-
-
-# Third test with grid graph
-Source_3 = model.Concept("Source_3", extends=[grid.Node])
-Target_3 = model.Concept("Target_3", extends=[grid.Node])
-
-define(Source_3(n1_1))
-define(Target_3(n3_3))
-
-paths_3 = find_shortest_paths(grid, Source_3, Target_3, num_paths=10, max_length=4)
-
-assert select(count(path_num)).where(paths_3(path_num, k, v)).to_df().iloc[0,0] == 6
-
-
-# Fourth test with grid graph
-paths_4 = find_shortest_paths(grid, Source_3, Target_3, num_paths=10, max_length=3)
-
-assert select(k, v.row, v.col).where(paths_4(path_num, k, v)).to_df().empty
-
-
-# Fifth test with grid graph
-Source_5 = model.Concept("Source_5", extends=[grid.Node])
-Target_5 = model.Concept("Target_5", extends=[grid.Node])
-
-define(Source_5(n1_1))
-define(Target_5(n1_1))
-
-paths_5 = find_shortest_paths(grid, Source_5, Target_5, num_paths=10, max_length=0)
-
-assert select(count(path_num)).where(paths_5(path_num, k, v)).to_df().iloc[0,0] == 1
-
-
-# Sixth test with grid graph
-Source_6 = model.Concept("Source_6", extends=[grid.Node])
-Target_6 = model.Concept("Target_6", extends=[grid.Node])
-
-define(Source_6(n1_1))
-define(Source_6(n3_3))
-define(Target_6(n1_1))
-define(Target_6(n3_3))
-
-paths_6 = find_shortest_paths(grid, Source_6, Target_6, num_paths=10, max_length=0)
-
-assert select(count(path_num)).where(paths_6(path_num, k, v)).to_df().iloc[0,0] == 2

relationalai/experimental/paths/tests/tests_limit_sp_multiple.py

@@ -1,119 +0,0 @@
-from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.experimental.paths.graph import Graph
-from relationalai.experimental.paths.path_algorithms.find_paths import find_shortest_paths
-
-
-# First test with grid graph
-model = Model("test_all", dry_run=False)
-
-grid = Graph.construct_grid(model, 3)
-
-path_num, k = Integer.ref(), Integer.ref()
-v = grid.Node.ref()
-
-n1_1 = grid.Node.new(row = 1, col = 1)
-n1_2 = grid.Node.new(row = 1, col = 2)
-n1_3 = grid.Node.new(row = 1, col = 3)
-n2_1 = grid.Node.new(row = 2, col = 1)
-n2_2 = grid.Node.new(row = 2, col = 2)
-n2_3 = grid.Node.new(row = 2, col = 3)
-n3_1 = grid.Node.new(row = 3, col = 1)
-n3_2 = grid.Node.new(row = 3, col = 2)
-n3_3 = grid.Node.new(row = 3, col = 3)
-
-Source_1 = model.Concept("Source_1", extends=[grid.Node])
-Target_1 = model.Concept("Target_1", extends=[grid.Node])
-
-define(Source_1(n1_1))
-define(Source_1(n1_2))
-define(Target_1(n3_2))
-define(Target_1(n3_3))
-
-paths_1 = find_shortest_paths(grid, Source_1, Target_1, num_paths=1)
-iter_path_1 = select(k, v.row, v.col).where(paths_1(path_num, k, v)).to_df()
-tuple_path_1 = tuple(sorted([row for row in iter_path_1.itertuples(index = False, name = None)]))
-
-expected_path_1 = (
-    (0, 1, 2), (1, 2, 2), (2, 3, 2)
-)
-
-assert tuple_path_1 == expected_path_1
-
-
-# Second test with grid graph
-paths_2 = find_shortest_paths(grid, Source_1, Target_1, num_paths=10)
-iter_path_2 = select(k, v.row, v.col).where(paths_2(path_num, k, v)).to_df()
-tuple_path_2 = tuple(sorted([row for row in iter_path_2.itertuples(index = False, name = None)]))
-
-assert tuple_path_2 == expected_path_1
-
-
-# Third test with grid graph
-Source_3 = model.Concept("Source_3", extends=[grid.Node])
-Target_3 = model.Concept("Target_3", extends=[grid.Node])
-
-define(Source_3(n1_1))
-define(Source_3(n2_2))
-define(Source_3(n3_3))
-define(Target_3(n1_1))
-define(Target_3(n3_3))
-
-paths_3 = find_shortest_paths(grid, Source_3, Target_3, num_paths=1)
-iter_path_3 = select(k, v.row, v.col).where(paths_3(path_num, k, v)).to_df()
-tuple_path_3 = tuple(sorted([row for row in iter_path_3.itertuples(index = False, name = None)]))
-
-expected_path_3_1 = ((0, 1, 1),)
-expected_path_3_2 = ((0, 3, 3),)
-
-assert (
-    tuple_path_3 == expected_path_3_1 or
-    tuple_path_3 == expected_path_3_2
-)
-
-
-# Fourth test with grid graph
-paths_4 = find_shortest_paths(grid, Source_3, Target_3, num_paths=2)
-iter_path_4 = select(path_num, k, v.row, v.col).where(paths_4(path_num, k, v)).to_df()
-list_path_4 = sorted([row for row in iter_path_4.itertuples(index = False, name = None)])
-set_path_4 = set()
-for i in range(2):
-    set_path_4.add(tuple((tup[1], tup[2], tup[3]) for tup in list_path_4[i:i+1]))
-
-assert len(list_path_4) == 2 and set_path_4 == { expected_path_3_1, expected_path_3_2 }
-
-
-# Fifth test with grid graph
-Source_5 = model.Concept("Source_5", extends=[grid.Node])
-Target_5 = model.Concept("Target_5", extends=[grid.Node])
-
-define(Source_5(n1_2))
-define(Source_5(n2_1))
-define(Target_5(n2_3))
-define(Target_5(n3_2))
-
-paths_5 = find_shortest_paths(grid, Source_5, Target_5, num_paths=3)
-
-assert select(count(path_num)).where(paths_5(path_num, k, v)).to_df().iloc[0,0] == 3
-
-
-# Sixth test with grid graph
-paths_6 = find_shortest_paths(grid, Source_5, Target_5, num_paths=10)
-
-assert select(count(path_num)).where(paths_6(path_num, k, v)).to_df().iloc[0,0] == 6
-
-
-# Seventh test with grid graph
-paths_7 = find_shortest_paths(grid, Source_5, Target_5)
-
-assert select(count(path_num)).where(paths_7(path_num, k, v)).to_df().iloc[0,0] == 6
-
-
-# Eighth test with grid graph
-paths_8 = find_shortest_paths(grid, Source_3, Target_3)
-iter_path_8 = select(path_num, k, v.row, v.col).where(paths_8(path_num, k, v)).to_df()
-list_path_8 = sorted([row for row in iter_path_8.itertuples(index = False, name = None)])
-set_path_8 = set()
-for i in range(2):
-    set_path_8.add(tuple((tup[1], tup[2], tup[3]) for tup in list_path_8[i:i+1]))
-
-assert len(list_path_8) == 2 and set_path_8 == { expected_path_3_1, expected_path_3_2 }

relationalai/experimental/paths/tests/tests_limit_sp_single.py

@@ -1,104 +0,0 @@
-from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.experimental.paths.graph import Graph
-from relationalai.experimental.paths.path_algorithms.find_paths import find_shortest_paths
-
-
-# First test with grid graph
-model = Model("test_all", dry_run=False)
-
-grid = Graph.construct_grid(model, 3)
-
-path_num, k = Integer.ref(), Integer.ref()
-v = grid.Node.ref()
-
-n1_1 = grid.Node.new(row = 1, col = 1)
-n1_2 = grid.Node.new(row = 1, col = 2)
-n1_3 = grid.Node.new(row = 1, col = 3)
-n2_1 = grid.Node.new(row = 2, col = 1)
-n2_2 = grid.Node.new(row = 2, col = 2)
-n2_3 = grid.Node.new(row = 2, col = 3)
-n3_1 = grid.Node.new(row = 3, col = 1)
-n3_2 = grid.Node.new(row = 3, col = 2)
-n3_3 = grid.Node.new(row = 3, col = 3)
-
-Source_1 = model.Concept("Source_1", extends=[grid.Node])
-Target_1 = model.Concept("Target_1", extends=[grid.Node])
-
-define(Source_1(n1_1))
-define(Target_1(n3_3))
-
-paths_1 = find_shortest_paths(grid, Source_1, Target_1, num_paths=1)
-iter_path_1 = select(k, v.row, v.col).where(paths_1(path_num, k, v)).to_df()
-tuple_path_1 = tuple(sorted([row for row in iter_path_1.itertuples(index = False, name = None)]))
-
-expected_path_1 = (
-    (0, 1, 1), (1, 1, 2), (2, 1, 3), (3, 2, 3), (4, 3, 3)
-)
-
-expected_path_2 = (
-    (0, 1, 1), (1, 1, 2), (2, 2, 2), (3, 2, 3), (4, 3, 3)
-)
-
-expected_path_3 = (
-    (0, 1, 1), (1, 1, 2), (2, 2, 2), (3, 3, 2), (4, 3, 3)
-)
-
-expected_path_4 = (
-    (0, 1, 1), (1, 2, 1), (2, 2, 2), (3, 2, 3), (4, 3, 3)
-)
-
-expected_path_5 = (
-    (0, 1, 1), (1, 2, 1), (2, 2, 2), (3, 3, 2), (4, 3, 3)
-)
-
-expected_path_6 = (
-    (0, 1, 1), (1, 2, 1), (2, 3, 1), (3, 3, 2), (4, 3, 3)
-)
-
-assert (
-    tuple_path_1 == expected_path_1 or
-    tuple_path_1 == expected_path_2 or
-    tuple_path_1 == expected_path_3 or
-    tuple_path_1 == expected_path_4 or
-    tuple_path_1 == expected_path_5 or
-    tuple_path_1 == expected_path_6
-)
-
-
-
-# Second test with grid graph
-paths_2 = find_shortest_paths(grid, Source_1, Target_1, num_paths=3)
-
-assert select(count(path_num)).where(paths_2(path_num, k, v)).to_df().iloc[0,0] == 3
-
-
-
-# Third test with grid graph
-paths_3 = find_shortest_paths(grid, Source_1, Target_1, num_paths=6)
-iter_path_3 = select(path_num, k, v.row, v.col).where(paths_3(path_num, k, v)).to_df()
-list_path_3 = sorted([row for row in iter_path_3.itertuples(index = False, name = None)])
-set_path_3 = set()
-for i in range(6):
-    set_path_3.add(tuple((tup[1], tup[2], tup[3]) for tup in list_path_3[5*i:5*(i+1)]))
-
-assert (
-    set_path_3 == {
-        expected_path_1, expected_path_2, expected_path_3, expected_path_4, expected_path_5, expected_path_6
-    }
-)
-
-
-# Fourth test with grid graph
-paths_4 = find_shortest_paths(grid, Source_1, Target_1)
-iter_path_4 = select(path_num, k, v.row, v.col).where(paths_4(path_num, k, v)).to_df()
-list_path_4 = sorted([row for row in iter_path_4.itertuples(index = False, name = None)])
-set_path_4 = set()
-for i in range(6):
-    set_path_4.add(tuple((tup[1], tup[2], tup[3]) for tup in list_path_4[5*i:5*(i+1)]))
-
-assert (
-    len(list_path_4) == 30 and
-    set_path_4 == {
-        expected_path_1, expected_path_2, expected_path_3, expected_path_4, expected_path_5, expected_path_6
-    }
-)