relationalai 0.13.0__py3-none-any.whl → 0.13.0.dev0__py3-none-any.whl

v0/relationalai/experimental/paths/tests/tests_limit_walks_multiple.py

@@ -0,0 +1,113 @@
+from v0.relationalai.semantics import Model, Integer, define, select, count
+from v0.relationalai.experimental.paths.graph import Graph
+from v0.relationalai.experimental.paths.path_algorithms.find_paths import find_walks
+
+
+# First test with grid graph
+model = Model("tests_find_walks_single", dry_run=False)
+
+grid = Graph.construct_grid(model, 2, "undirected")
+
+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)
+n2_1 = grid.Node.new(row = 2, col = 1)
+n2_2 = grid.Node.new(row = 2, col = 2)
+
+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(n2_2))
+define(Target_1(n1_1))
+define(Target_1(n2_2))
+
+paths_1 = find_walks(grid, Source_1, Target_1, 0, 20)
+iter_path_1 = select(path_num, k, v.row, v.col).where(paths_1(path_num, k, v)).to_df()
+list_path_1 = sorted([row for row in iter_path_1.itertuples(index = False, name = None)])
+set_path_1 = set()
+for i in range(1, max([t[0] for t in list_path_1]) + 1):
+    set_path_1.add(tuple((t[1:] for t in list_path_1 if t[0] == i)))
+
+expected_path_1_1 = (
+    (0, 1, 1),
+)
+
+expected_path_1_2 = (
+    (0, 2, 2),
+)
+
+assert (
+    set_path_1 == {
+        expected_path_1_1, expected_path_1_2
+    }
+)
+
+
+# Second test with grid graph
+paths_2 = find_walks(grid, Source_1, Target_1, 2, 20)
+iter_path_2 = select(path_num, k, v.row, v.col).where(paths_2(path_num, k, v)).to_df()
+list_path_2 = sorted([row for row in iter_path_2.itertuples(index = False, name = None)])
+set_path_2 = set()
+for i in range(1, max([t[0] for t in list_path_2]) + 1):
+    set_path_2.add(tuple((t[1:] for t in list_path_2 if t[0] == i)))
+
+expected_path_2_1 = (
+    (0, 1, 1), (1, 1, 2), (2, 1, 1)
+)
+
+expected_path_2_2 = (
+    (0, 1, 1), (1, 1, 2), (2, 2, 2)
+)
+
+expected_path_2_3 = (
+    (0, 1, 1), (1, 2, 1), (2, 1, 1)
+)
+
+expected_path_2_4 = (
+    (0, 1, 1), (1, 2, 1), (2, 2, 2)
+)
+
+expected_path_2_5 = (
+    (0, 2, 2), (1, 1, 2), (2, 1, 1)
+)
+
+expected_path_2_6 = (
+    (0, 2, 2), (1, 1, 2), (2, 2, 2)
+)
+
+expected_path_2_7 = (
+    (0, 2, 2), (1, 2, 1), (2, 1, 1)
+)
+
+expected_path_2_8 = (
+    (0, 2, 2), (1, 2, 1), (2, 2, 2)
+)
+
+assert (
+    set_path_2 == {
+        expected_path_1_1, expected_path_1_2,
+        expected_path_2_1, expected_path_2_2, expected_path_2_3, expected_path_2_4,
+        expected_path_2_5, expected_path_2_6, expected_path_2_7, expected_path_2_8
+    }
+)
+
+
+# Third test with grid graph
+paths_3 = find_walks(grid, Source_1, Target_1, 4, 20)
+
+assert select(count(path_num)).where(paths_3(path_num, k, v)).to_df().iloc[0,0] == 20
+
+
+# Fourth test with grid graph
+paths_4 = find_walks(grid, Source_1, Target_1, 4, 100)
+
+assert select(count(path_num)).where(paths_4(path_num, k, v)).to_df().iloc[0,0] == 42
+
+
+# Fifth test with grid graph
+paths_5 = find_walks(grid, Source_1, Target_1, 4)
+
+assert select(count(path_num)).where(paths_5(path_num, k, v)).to_df().iloc[0,0] == 42

v0/relationalai/experimental/paths/tests/tests_limit_walks_single.py

@@ -0,0 +1,149 @@
+from v0.relationalai.semantics import Model, Integer, define, select, count
+from v0.relationalai.experimental.paths.graph import Graph
+from v0.relationalai.experimental.paths.path_algorithms.find_paths import find_walks
+
+
+# First test with grid graph
+model = Model("tests_find_walks_single", dry_run=False)
+
+grid = Graph.construct_grid(model, 2, "undirected")
+
+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)
+n2_1 = grid.Node.new(row = 2, col = 1)
+n2_2 = grid.Node.new(row = 2, col = 2)
+
+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(n2_2))
+
+paths_1 = find_walks(grid, Source_1, Target_1, 2, 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, 2, 2)
+)
+
+expected_path_2 = (
+    (0, 1, 1), (1, 2, 1), (2, 2, 2)
+)
+
+assert (
+    tuple_path_1 == expected_path_1 or
+    tuple_path_1 == expected_path_2
+)
+
+
+
+# Second test with grid graph
+paths_2 = find_walks(grid, Source_1, Target_1, 2, 20)
+
+assert select(count(path_num)).where(paths_2(path_num, k, v)).to_df().iloc[0,0] == 2
+
+
+# Third test with grid graph
+paths_3 = find_walks(grid, Source_1, Target_1, 4, 20)
+
+assert select(count(path_num)).where(paths_3(path_num, k, v)).to_df().iloc[0,0] == 10
+
+
+
+# Fourth test with grid graph
+paths_4 = find_walks(grid, Source_1, Target_1, 4, 20)
+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(1, max([t[0] for t in list_path_4]) + 1):
+    set_path_4.add(tuple((t[1:] for t in list_path_4 if t[0] == i)))
+
+expected_path_3 = (
+    (0, 1, 1), (1, 1, 2), (2, 1, 1), (3, 1, 2), (4, 2, 2)
+)
+
+expected_path_4 = (
+    (0, 1, 1), (1, 1, 2), (2, 1, 1), (3, 2, 1), (4, 2, 2)
+)
+
+expected_path_5 = (
+    (0, 1, 1), (1, 1, 2), (2, 2, 2), (3, 1, 2), (4, 2, 2)
+)
+
+expected_path_6 = (
+    (0, 1, 1), (1, 1, 2), (2, 2, 2), (3, 2, 1), (4, 2, 2)
+)
+
+expected_path_7 = (
+    (0, 1, 1), (1, 2, 1), (2, 1, 1), (3, 1, 2), (4, 2, 2)
+)
+
+expected_path_8 = (
+    (0, 1, 1), (1, 2, 1), (2, 1, 1), (3, 2, 1), (4, 2, 2)
+)
+
+expected_path_9 = (
+    (0, 1, 1), (1, 2, 1), (2, 2, 2), (3, 1, 2), (4, 2, 2)
+)
+
+expected_path_10 = (
+    (0, 1, 1), (1, 2, 1), (2, 2, 2), (3, 2, 1), (4, 2, 2)
+)
+
+assert (
+    set_path_4 == {
+        expected_path_1, expected_path_2, expected_path_3, expected_path_4, expected_path_5,
+        expected_path_6, expected_path_7, expected_path_8, expected_path_9, expected_path_10
+    }
+)
+
+
+# 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_walks(grid, Source_5, Target_5, 0, 10)
+iter_path_5 = select(k, v.row, v.col).where(paths_5(path_num, k, v)).to_df()
+list_path_5 = [row for row in iter_path_5.itertuples(index = False, name = None)]
+
+
+expected_path_5_1 = [
+    (0, 1, 1)
+]
+
+assert list_path_5 == expected_path_5_1
+
+
+# Sixth test with grid graph
+paths_6 = find_walks(grid, Source_5, Target_5, 2, 20)
+iter_path_6 = select(path_num, k, v.row, v.col).where(paths_6(path_num, k, v)).to_df()
+list_path_6 = sorted([row for row in iter_path_6.itertuples(index = False, name = None)])
+set_path_6 = set()
+for i in range(1, max([t[0] for t in list_path_6]) + 1):
+    set_path_6.add(tuple((t[1:] for t in list_path_6 if t[0] == i)))
+
+expected_path_6_1 = (
+    (0, 1, 1),
+)
+
+expected_path_6_2 = (
+    (0, 1, 1), (1, 2, 1), (2, 1, 1)
+)
+
+expected_path_6_3 = (
+    (0, 1, 1), (1, 1, 2), (2, 1, 1)
+)
+
+assert (
+    set_path_6 == {
+        expected_path_6_1, expected_path_6_2, expected_path_6_3
+    }
+)

v0/relationalai/experimental/paths/tests/tests_one_sided_ball_repetition_multiple.py

@@ -0,0 +1,70 @@
+from v0.relationalai.semantics import Model, Integer, define, select
+from v0.relationalai.experimental.paths.graph import Graph
+from v0.relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+
+
+# Test with grid graph
+model_grid = Model("tests_one_sided_ball_repetition grid", dry_run=False)
+
+grid = Graph.construct_grid(model_grid, 3)
+
+n = Integer.ref()
+u = grid.Node.ref()
+
+source_1_1 = grid.Node.new(row = 1, col = 1)
+source_1_2 = grid.Node.new(row = 1, col = 2)
+
+Source_1 = model_grid.Concept("Source_1", extends=[grid.Node])
+
+define(Source_1(source_1_1))
+define(Source_1(source_1_2))
+
+source_ball_1 = ball_with_repetition(grid, Source_1, 3)
+iter_set_1 = select(n, u.row, u.col).where(source_ball_1(n, u)).to_df()
+set_ball_1 = set(row for row in iter_set_1.itertuples(index = False, name = None))
+
+expected_ball_1 = {
+    (0, 1, 1), (1, 2, 1), (1, 1, 2), (2, 3, 1), (2, 2, 2), (2, 1, 3), (3, 3, 2), (3, 2, 3),
+    (0, 1, 2), (1, 2, 2), (1, 1, 3), (2, 3, 2), (2, 2, 3), (3, 3, 3)
+}
+
+assert set_ball_1 == expected_ball_1
+
+
+# First test with diamond graph
+model_diamond = Model("tests_one_sided_ball_repetition diamond", dry_run=False)
+
+diamond = Graph.construct_diamond(model_diamond, 3)
+
+v = diamond.Node.ref()
+
+source_2_1 = diamond.Node.new(id = 2)
+source_2_2 = diamond.Node.new(id = 4)
+
+Source_2 = model_diamond.Concept("Source_2", extends=[diamond.Node])
+
+define(Source_2(source_2_1))
+define(Source_2(source_2_2))
+
+source_ball_2 = ball_with_repetition(diamond, Source_2, 4)
+iter_set_2 = select(n, v.id).where(source_ball_2(n, v)).to_df()
+set_ball_2 = set(row for row in iter_set_2.itertuples(index = False, name = None))
+
+expected_ball_2 = {
+    (0, 4), (1, 5), (1, 6), (2, 7), (3, 8), (3, 9), (4, 10),
+    (0, 2), (1, 4), (2, 5), (2, 6), (3, 7), (4, 8), (4, 9)
+}
+
+assert set_ball_2 == expected_ball_2
+
+
+# Second test with diamond graph
+source_ball_3 = ball_with_repetition(diamond, Source_2, 0)
+iter_set_3 = select(n, v.id).where(source_ball_3(n, v)).to_df()
+set_ball_3 = set(row for row in iter_set_3.itertuples(index = False, name = None))
+
+expected_ball_3 = {
+    (0, 2), (0, 4)
+}
+
+assert set_ball_3 == expected_ball_3

v0/relationalai/experimental/paths/tests/tests_one_sided_ball_repetition_single.py

@@ -0,0 +1,64 @@
+from v0.relationalai.semantics import Model, Integer, define, select
+from v0.relationalai.experimental.paths.graph import Graph
+from v0.relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+
+
+# Test with grid graph
+model_grid = Model("tests_one_sided_ball_repetition grid", dry_run=False)
+
+grid = Graph.construct_grid(model_grid, 3)
+
+n = Integer.ref()
+u = grid.Node.ref()
+
+source_1 = grid.Node.new(row = 1, col = 2)
+
+Source_1 = model_grid.Concept("Source_1", extends=[grid.Node])
+
+define(Source_1(source_1))
+
+source_ball_1 = ball_with_repetition(grid, Source_1, 3)
+iter_set_1 = select(n, u.row, u.col).where(source_ball_1(n, u)).to_df()
+set_ball_1 = set(row for row in iter_set_1.itertuples(index = False, name = None))
+
+expected_ball_1 = {
+    (0, 1, 2), (1, 2, 2), (1, 1, 3), (2, 3, 2), (2, 2, 3), (3, 3, 3)
+}
+
+assert set_ball_1 == expected_ball_1
+
+
+# First test with diamond graph
+model_diamond = Model("tests_one_sided_ball_repetition diamond", dry_run=False)
+
+diamond = Graph.construct_diamond(model_diamond, 3)
+
+v = diamond.Node.ref()
+
+source_2 = diamond.Node.new(id = 2)
+
+Source_2 = model_diamond.Concept("Source_2", extends=[diamond.Node])
+
+define(Source_2(source_2))
+
+source_ball_2 = ball_with_repetition(diamond, Source_2, 4)
+iter_set_2 = select(n, v.id).where(source_ball_2(n, v)).to_df()
+set_ball_2 = set(row for row in iter_set_2.itertuples(index = False, name = None))
+
+expected_ball_2 = {
+    (0, 2), (1, 4), (2, 5), (2, 6), (3, 7), (4, 8), (4, 9)
+}
+
+assert set_ball_2 == expected_ball_2
+
+
+# Second test with diamond graph
+source_ball_3 = ball_with_repetition(diamond, Source_2, 0)
+iter_set_3 = select(n, v.id).where(source_ball_3(n, v)).to_df()
+set_ball_3 = set(row for row in iter_set_3.itertuples(index = False, name = None))
+
+expected_ball_3 = {
+    (0, 2)
+}
+
+assert set_ball_3 == expected_ball_3

v0/relationalai/experimental/paths/tests/tests_one_sided_ball_upto_multiple.py

@@ -0,0 +1,115 @@
+from v0.relationalai.semantics import Model, Integer, define, select
+from v0.relationalai.experimental.paths.graph import Graph
+from v0.relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+
+
+# First test with grid graph and multiple source and target nodes
+model_grid = Model("test_one_sided_ball_upto grid", dry_run=False)
+
+grid = Graph.construct_grid(model_grid, 3)
+
+n = Integer.ref()
+u = grid.Node.ref()
+
+source_1_1 = grid.Node.new(row = 1, col = 2)
+source_1_2 = grid.Node.new(row = 2, col = 1)
+target_1_1 = grid.Node.new(row = 3, col = 2)
+target_1_2 = grid.Node.new(row = 2, col = 3)
+
+Source_1 = model_grid.Concept("Source_1", extends=[grid.Node])
+Target_1 = model_grid.Concept("Target_1", extends=[grid.Node])
+
+define(Source_1(source_1_1))
+define(Source_1(source_1_2))
+define(Target_1(target_1_1))
+define(Target_1(target_1_2))
+
+source_ball_1 = ball_upto(grid, Source_1, Target_1)
+iter_set_1 = select(n, u.row, u.col).where(source_ball_1(n, u)).to_df()
+set_ball_1 = set(row for row in iter_set_1.itertuples(index = False, name = None))
+
+expected_ball_1 = {
+    (0, 1, 2), (0, 2, 1), (1, 3, 1), (1, 2, 2), (1, 1, 3), (2, 3, 2), (2, 2, 3)
+}
+
+assert set_ball_1 == expected_ball_1
+
+
+# Second test with grid graph and multiple source and target nodes
+target_2_1 = grid.Node.new(row = 3, col = 3)
+
+Target_2 = model_grid.Concept("Target_2", extends=[grid.Node])
+
+define(Target_2(target_1_1))
+define(Target_2(target_1_2))
+define(Target_2(target_2_1))
+
+source_ball_2 = ball_upto(grid, Source_1, Target_2)
+iter_set_2 = select(n, u.row, u.col).where(source_ball_2(n, u)).to_df()
+set_ball_2 = set(row for row in iter_set_2.itertuples(index = False, name = None))
+
+assert set_ball_2 == expected_ball_1
+
+
+# First test with diamond graph and multiple source and target nodes
+model_diamond = Model("test_one_sided_ball_upto diamond", dry_run=False)
+
+diamond = Graph.construct_diamond(model_diamond, 3)
+
+v = diamond.Node.ref()
+
+source_3_1 = diamond.Node.new(id = 2)
+source_3_2 = diamond.Node.new(id = 3)
+target_3_1 = diamond.Node.new(id = 7)
+target_3_2 = diamond.Node.new(id = 8)
+target_3_3 = diamond.Node.new(id = 9)
+
+Source_3 = model_diamond.Concept("Source_3", extends=[diamond.Node])
+Target_3 = model_diamond.Concept("Target_3", extends=[diamond.Node])
+
+define(Source_3(source_3_1))
+define(Source_3(source_3_2))
+define(Target_3(target_3_1))
+define(Target_3(target_3_2))
+define(Target_3(target_3_3))
+
+source_ball_3 = ball_upto(diamond, Source_3, Target_3)
+iter_set_3 = select(n, v.id).where(source_ball_3(n, v)).to_df()
+set_ball_3 = set(row for row in iter_set_3.itertuples(index = False, name = None))
+
+expected_ball_3 = {
+    (0, 2), (0, 3), (1, 4), (2, 5), (2, 6), (3, 7)
+}
+
+assert set_ball_3 == expected_ball_3
+
+
+# Second test with diamond graph and multiple source and target nodes
+source_4_1 = diamond.Node.new(id = 1)
+source_4_2 = diamond.Node.new(id = 2)
+source_4_3 = diamond.Node.new(id = 4)
+target_4_1 = diamond.Node.new(id = 2)
+target_4_2 = diamond.Node.new(id = 4)
+target_4_3 = diamond.Node.new(id = 5)
+
+Source_4 = model_diamond.Concept("Source_4", extends=[diamond.Node])
+Target_4 = model_diamond.Concept("Target_4", extends=[diamond.Node])
+
+define(Source_4(source_4_1))
+define(Source_4(source_4_2))
+define(Source_4(source_4_3))
+define(Target_4(target_4_1))
+define(Target_4(target_4_2))
+define(Target_4(target_4_3))
+
+n = Integer.ref()
+
+source_ball_4 = ball_upto(diamond, Source_4, Target_4)
+iter_set_4 = select(n, v.id).where(source_ball_4(n, v)).to_df()
+set_ball_4 = set(row for row in iter_set_4.itertuples(index = False, name = None))
+
+expected_ball_4 = {
+    (0, 1), (0, 2), (0, 4)
+}
+
+assert set_ball_4 == expected_ball_4

v0/relationalai/experimental/paths/tests/tests_one_sided_ball_upto_single.py

@@ -0,0 +1,75 @@
+from v0.relationalai.semantics import Model, Integer, define, select
+from v0.relationalai.experimental.paths.graph import Graph
+from v0.relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+
+
+# First test with grid graph
+model_grid = Model("test_one_sided_ball_upto grid", dry_run=False)
+grid = Graph.construct_grid(model_grid, 3)
+
+n = Integer.ref()
+u = grid.Node.ref()
+
+source_1 = grid.Node.new(row = 1, col = 1)
+target_1 = grid.Node.new(row = 2, col = 2)
+
+Source_1 = model_grid.Concept("Source_1", extends=[grid.Node])
+Target_1 = model_grid.Concept("Target_1", extends=[grid.Node])
+
+define(Source_1(source_1))
+define(Target_1(target_1))
+
+source_ball_1 = ball_upto(grid, Source_1, Target_1)
+iter_set_1 = select(n, u.row, u.col).where(source_ball_1(n, u)).to_df()
+set_ball_1 = set(row for row in iter_set_1.itertuples(index = False, name = None))
+
+expected_ball_1 = {
+    (0, 1, 1), (1, 2, 1), (1, 1, 2), (2, 3, 1), (2, 2, 2), (2, 1, 3)
+}
+
+assert set_ball_1 == expected_ball_1
+
+
+# Second test with grid graph
+target_2 = grid.Node.new(row = 3, col = 3)
+
+Target_2 = model_grid.Concept("Target_2", extends=[grid.Node])
+
+define(Target_2(target_2))
+
+source_ball_2 = ball_upto(grid, Source_1, Target_2)
+iter_set_2 = select(n, u.row, u.col).where(source_ball_2(n, u)).to_df()
+set_ball_2 = set(row for row in iter_set_2.itertuples(index = False, name = None))
+
+expected_ball_2 = {
+    (0, 1, 1), (1, 2, 1), (1, 1, 2), (2, 3, 1), (2, 2, 2), (2, 1, 3), (3, 3, 2), (3, 2, 3), (4, 3, 3)
+}
+
+assert set_ball_2 == expected_ball_2
+
+
+# Test with diamond graph
+model_diamond = Model("test_one_sided_ball_upto diamond", dry_run=False)
+
+diamond = Graph.construct_diamond(model_diamond, 3)
+
+v = diamond.Node.ref()
+
+source_3 = diamond.Node.new(id = 2)
+target_3 = diamond.Node.new(id = 8)
+
+Source_3 = model_diamond.Concept("Source_3", extends=[diamond.Node])
+Target_3 = model_diamond.Concept("Target_3", extends=[diamond.Node])
+
+define(Source_3(source_3))
+define(Target_3(target_3))
+
+source_ball_3 = ball_upto(diamond, Source_3, Target_3)
+iter_set_3 = select(n, v.id).where(source_ball_3(n, v)).to_df()
+set_ball_3 = set(row for row in iter_set_3.itertuples(index = False, name = None))
+
+expected_ball_3 = {
+    (0, 2), (1, 4), (2, 5), (2, 6), (3, 7), (4, 8), (4, 9)
+}
+
+assert set_ball_3 == expected_ball_3