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

v0/relationalai/experimental/paths/examples/paths_example.py

@@ -1,116 +0,0 @@
-"""
-Example usage of automaton-based pathfinding.
-"""
-
-import time
-from v0.relationalai.semantics import Model, Integer, select, String, define
-from v0.relationalai.experimental.paths.graph import Graph
-from v0.relationalai.experimental.paths.api import node, path, match
-
-import argparse
-
-
-# def print_paths(path_node, path_label):
-#     # Print nodes and labels in a readable format
-#     l2 = String.ref()
-#     k = Integer.ref()
-#     m = Integer.ref()
-#     print("\nNodes and labels in the path on the original graph:")
-#     select(k, m, l2).where(
-#         path_node(k, m),
-#         path_label(k, label := String.ref()),
-#         l2 == strings.concat("-[", label, "]->")
-#     ).inspect()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Pathfinder example script.")
-    parser.add_argument("--num_paths", type=int, default=None, help="Number of paths to find.")
-    args = parser.parse_args()
-
-    print("Number of paths to find:", args.num_paths)
-
-    # Create an automaton that matches paths with pattern: A(A*)B:
-    # pattern = path("-[A]->", star("-[A]->"), "-[B]->")
-    # edge_list = [(1, 2, "A"), (2, 3, "A"), (3, 4, "A"), (4, 5, "B"), (1, 5, "A")]
-
-    # 2 paths matching AB:
-    # pattern = path("-[A]->", "-[B]->")
-    # edge_list = [(1, 2, "A"), (2, 3, "B"), (1, 4, "A"), (4, 3, "B")]
-
-    
-
-    # pattern = path("-[A]->")
-    # edge_list = [(1, 3, "A"), (2, 3, "A")]
-
-    pattern = path("A")
-    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
-    edge_list = [(1, 2, "A")]
-
-
-    sources = []
-    targets = []
-
-    sources = [1]
-    targets = [2]
-
-    # pattern = path("-[A]->")
-    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
-
-    # sources = [1, 2]
-    # targets = [3, 4]
-    # 2 paths from 2 different source nodes:
-    # pattern = path("-[A]->")
-    # edge_list = [(1, 3, "A"), (2, 3, "A")]
-
-    # pattern = path("-[A]->")
-    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
-
-    timestamp = str(time.gmtime(0))
-
-    print("\nEdge list:\n", edge_list)
-
-    # Initialize the RelationalAI model
-    model = Model(f"paths_{timestamp}", use_lqp=True) # , use_lqp=True)  # strict=True  # dry_run=False  # use_direct_access=True
-    # use_lqp=True  # strict=True  # dry_run=False  # use_direct_access=True
-
-    # model.define(
-    #     RawSource("rel", "@span_no_threshold")
-    # )
-
-    graph = Graph.from_edge_list(model, edge_list)
-    Node = graph.Node
-
-    # Call the function to find the path
-
-    Source = model.Relationship(f"source6 {{{Node}}}")
-    Target = model.Relationship(f"target6 {{{Node}}}")
-
-    for src in sources:
-        define(Source(Node.new(id=src)))
-
-    for tgt in targets:
-        define(Target(Node.new(id=tgt)))
-
-    src, tgt = Node.ref(), Node.ref()
-
-    # select(graph.Node).inspect()
-
-    graph.Edge.inspect()
-    select(src).where(Source(src)).inspect()
-    select(tgt).where(Target(tgt)).inspect()
-
-    # print(f"\nFinding paths matching the automaton pattern from {src} to {dst}..."
-    # projected_paths = match(graph, pattern, Source, Target, num_paths=args.num_paths)
-
-    start = time.time()
-    projected_paths = match(graph, pattern, Source, Target)
-
-    i, k = Integer.ref(), Integer.ref()
-    node = graph.Node.ref()
-    label = String.ref()
-
-    result = select(i, k, label, node.id).where(projected_paths(i, k, label, node)).inspect()
-    end = time.time()
-
-    print(f"Time taken to find paths: {end - start} seconds")

v0/relationalai/experimental/paths/examples/pattern_to_automaton.py

@@ -1,28 +0,0 @@
-from v0.relationalai.experimental.paths.api import path, union
-from v0.relationalai.semantics import Concept
-
-Node = Concept('Node')
-OddNode = Concept('OddNode')
-EvenNode = Concept('EvenNode')
-
-# pattern = path(node(Node, lambda n: n.id > 3), star('-[A]->', '-[B]->'), Node)
-
-# pattern = path(node(Node, lambda n: n.id > 3), Node)
-
-# pattern = path(Node, '-[A]->', Node, '-[B]->', Node)
-
-# pattern = path('-[B]->', node(Node, lambda n: n.id > 3), '-[A]->')
-
-# pattern = path(OddNode, star('-[A]->', '-[B]->'), EvenNode)
-
-# pattern = path(OddNode, star('-[A]->', node(OddNode, lambda n: n.id > 3)), EvenNode)
-
-pattern = path(union("-[A]->", "-[B]->"), union("-[A]->", "-[B]->"))
-
-g = pattern.glushkov()
-a = g.automaton()
-a.reduce()
-
-print(a)
-
-

v0/relationalai/experimental/paths/find_paths_via_automaton.py

@@ -1,85 +0,0 @@
-"""
-Main functionality for finding paths through automaton.
-"""
-
-from v0.relationalai.semantics import define, where, Integer
-
-from .product_graph import create_product_graph #, find_path_in_product_graph
-# from .product_graph import project_product_graph_path_to_original_graph
-
-from .path_algorithms.find_paths import find_shortest_paths, find_walks
-
-def find_paths_via_automaton(graph, automaton, Source, Target,
-                             num_paths = None, max_length = 1000,
-                             type = "shortest"):
-    """
-    Find a path in the graph allowed by the automaton from Source nodes to Target nodes.
-
-    Args:
-        graph: The user's input graph
-        automaton: Automaton object representing the pattern to match
-        Source: Source node entities
-        Target: Target node entities
-        num_paths: Optional
-          - if specified, limit the number of paths returned
-          - if None, all paths are returned.
-
-    Returns:
-        product_graph: The product graph
-        paths: Relationship of arity 4 encoding paths in the original graph
-    """
-    model = graph.model
-    Node = graph.Node
-
-    # Create product graph:
-    product_graph = create_product_graph(graph, automaton)
-    ProductGraphNode = product_graph.Node
-
-    # automaton states:
-    init_state = 0  # assumes single initial state labeled 0 of the automaton
-
-    FinalState = model.Relationship("final_state1 {Integer}")
-    for state in automaton.get_final_states():
-        define(FinalState(state))
-
-    # FinalState.inspect()
-
-    # Product graph source and target sets:
-    ProductGraphSource = model.Relationship(f"pg_source {{{ProductGraphNode}}}")
-    ProductGraphTarget = model.Relationship(f"pg_target {{{ProductGraphNode}}}")
-
-    st = Integer.ref() # state in the automaton
-    src, tgt = Node.ref(), Node.ref()
-
-    where(Source(src)).define(
-        product_graph_src := ProductGraphNode.new(
-            state=init_state, orig_node=src
-        ),
-        ProductGraphSource(product_graph_src)
-    )
-
-    where(Target(tgt), FinalState(st)).define(
-        product_graph_dst := ProductGraphNode.new(
-            state=st, orig_node=tgt
-        ),
-        ProductGraphTarget(product_graph_dst)
-    )
-
-    # ProductGraphSource.inspect()
-    # ProductGraphTarget.inspect()
-
-    if type == "shortest":
-        # Find shortest paths in the product graph:
-        find_paths_function = find_shortest_paths
-
-    elif type == "walks":
-        find_paths_function = find_walks
-    else:
-        raise ValueError(f"Unknown type of path search: {type}")
-
-    paths = find_paths_function(
-        product_graph, ProductGraphSource, ProductGraphTarget,
-        num_paths=num_paths, max_length=max_length
-    )
-
-    return product_graph, paths

v0/relationalai/experimental/paths/graph.py

@@ -1,185 +0,0 @@
-from v0.relationalai.semantics import Integer, define, Concept, Relationship, std
-
-
-class Graph:
-    def __init__(self, model, Node:Concept, Edge:Relationship):
-        """
-        Initialize a Graph instance with Node and Edge concepts.
-        """
-        self.Node = Node
-        self.Edge = Edge
-        self.model = model
-
-
-    @classmethod
-    def from_edge_list(cls, model, edge_list):
-        """
-        Create a Graph instance from a Model.
-        The Model should have Node and Edge concepts defined.
-        """
-
-        Node = model.Concept("Node")
-
-        if len(edge_list[0]) == 2:
-            Edge = model.Relationship(f"edge4 {{{Node}}} {{{Node}}}")
-
-            for src, dst, in edge_list:
-                u = Node.new(id=src)
-                v = Node.new(id=dst)
-
-                define(u)
-                define(v)
-                define(Edge(u, v))
-        else:
-            Edge = model.Relationship(f"edge5 {{{Node}}} {{{Node}}} {{String}}")
-
-            for src, dst, label in edge_list:
-                u = Node.new(id=src)
-                v = Node.new(id=dst)
-
-                define(u)
-                define(v)
-                define(Edge(u, v, label))
-
-        return cls(model, Node, Edge)
-
-
-    @classmethod
-    def construct_grid(cls, model, side, tp = 'directed'):
-        """
-        Create a grid Graph instance from a Model. The length of the side of the grid
-        is given by the parameter `side`.
-        The Model should have Node and Edge concepts defined.
-        """
-        Node = model.Concept("Node")
-        Edge = model.Relationship(f"edge6 {{{Node}}} {{{Node}}}")
-
-        n, m = Integer.ref(), Integer.ref()
-        u, v = Node.ref(), Node.ref()
-
-        define(Node.new(row = n, col = m)).where(
-            n == std.range(1, side + 1, 1),
-            m == std.range(1, side + 1, 1)
-        )
-
-        define(Edge(u, v)).where(
-            Node(u),
-            Node(v),
-            u.row == v.row,
-            v.col == u.col + 1
-        )
-
-        define(Edge(u, v)).where(
-            Node(u),
-            Node(v),
-            u.col == v.col,
-            v.row == u.row + 1
-        )
-
-        if tp == 'undirected':
-            define(Edge(u, v)).where(Edge(v, u))
-
-        return cls(model, Node, Edge)
-
-
-    @classmethod
-    def construct_diamond(cls, model, diamonds, tp = 'directed'):
-        """
-        Create a diamond Graph instance from a Model. The number of diamonds in the graph
-        is given by the parameter `diamonds`.
-        The Model should have Node and Edge concepts defined.
-        """
-        Node = model.Concept("Node")
-        Edge = model.Relationship(f"edge7 {{{Node}}} {{{Node}}}")
-
-        n = Integer.ref()
-        u, v = Node.ref(), Node.ref()
-
-        define(Node.new(id = n)).where(
-            n == std.range(1, 3*diamonds + 2, 1)
-        )
-
-        define(Edge(u, v)).where(
-            n == std.range(1, diamonds + 1, 1),
-            Node(u),
-            Node(v),
-            u.id == 3*(n-1) + 1,
-            v.id == 3*(n-1) + 2
-        )
-
-        define(Edge(u, v)).where(
-            n == std.range(1, diamonds + 1, 1),
-            Node(u),
-            Node(v),
-            u.id == 3*(n-1) + 1,
-            v.id == 3*(n-1) + 3
-        )
-
-        define(Edge(u, v)).where(
-            n == std.range(1, diamonds + 1, 1),
-            Node(u),
-            Node(v),
-            u.id == 3*(n-1) + 2,
-            v.id == 3*n + 1
-        )
-
-        define(Edge(u, v)).where(
-            n == std.range(1, diamonds + 1, 1),
-            Node(u),
-            Node(v),
-            u.id == 3*(n-1) + 3,
-            v.id == 3*n + 1
-        )
-
-        if tp == 'undirected':
-            define(Edge(u, v)).where(Edge(v, u))
-
-        return cls(model, Node, Edge)
-
-
-    @classmethod
-    def construct_rake(cls, model, length, fan_out, tp = 'directed'):
-        """
-        Create a grid Graph instance from a Model. The length of the side of the grid
-        is given by the parameter `side`.
-        The Model should have Node and Edge concepts defined.
-        """
-        Node = model.Concept("Node")
-        Edge = model.Relationship(f"edge8 {{{Node}}} {{{Node}}}")
-
-        start, i = Integer.ref(), Integer.ref()
-        u, v = Node.ref(), Node.ref()
-
-        define(Node.new(id = i)).where(
-            i == std.range(0,  (length + 1) * (fan_out + 1), 1)
-        )
-
-        define(Edge(u, v)).where(
-            i == std.range(0, length, 1),
-            Node(u),
-            Node(v),
-            u.id == i,
-            v.id == i + 1
-        )
-
-        define(Edge(u, v)).where(
-            i == std.range(length + 1, (length + 1) * fan_out + 1, length + 1),
-            Node(u),
-            Node(v),
-            u.id == length,
-            v.id == i
-        )
-
-        define(Edge(u, v)).where(
-            start == std.range(length + 1, (length + 1) * fan_out + 2, length + 1),
-            i == std.range(start, start + length, 1),
-            Node(u),
-            Node(v),
-            u.id == i,
-            v.id == i + 1
-        )
-
-        if tp == 'undirected':
-            define(Edge(u, v)).where(Edge(v, u))
-
-        return cls(model, Node, Edge)

v0/relationalai/experimental/paths/path_algorithms/find_paths.py

@@ -1,280 +0,0 @@
-# Find shortest paths and walks in a graph
-
-from v0.relationalai.semantics import std, Integer, where, define, rank, sum, not_
-from v0.relationalai.semantics.std.integers import int64
-
-
-
-from ..graph import Graph
-from ..utilities.prefix_sum import linear_prefix_sum_with_groupby
-from .usp import compute_usp, compute_nsp_from_usp, compute_uw, compute_nw_from_uw
-
-
-
-def range_int64(start, stop, step=1):
-    """Helper for std.range with int64 arguments."""
-    return std.range(int64(start), int64(stop), int64(step))
-
-
-def find_shortest_paths(g: Graph, Source, Target, max_length=None, num_paths=None):
-    Node = g.Node
-
-    u, v, src = Node.ref(), Node.ref(), Node.ref()
-    i, val, lo, hi = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
-    level, n, m, path_num = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
-    d, r, s, tot = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
-
-    ord_source = g.model.Relationship(f"ord_source {{Integer}}th source node {{{Node}}}")
-    total_paths = g.model.Relationship("total_paths {Integer}")
-    int_source = g.model.Relationship(f"int_source paths from {{{Node}}} numbered {{Integer}} to {{Integer}}")
-    paths_listing = g.model.Relationship(f"paths_listing {{{Node}}} {{Integer}} {{Integer}} {{Integer}}")
-    paths = g.model.Relationship(f"paths {{{Integer}}} has {{{Integer}}}th node {{{Node}}}")
-    neighbor = g.model.Relationship(f"neighbor {{{Node}}} neighbor {{Integer}} is {{{Node}}}")
-    edge_nsp = g.model.Relationship(f"edge_nsp num shortest from {{{Node}}} through {{Integer}} neighbor {{Integer}}")
-    acc_nsp = g.model.Relationship(f"acc_nsp num shortest from {{{Node}}} neighbor from 1 to {{Integer}} is {{Integer}}")
-    nsp_interval = g.model.Relationship(f"nsp_interval {{{Node}}} {{Integer}} {{Integer}} {{Integer}}")
-    path_routing = g.model.Relationship(f"path_routing {{{Node}}} {{Integer}} {{{Node}}} {{Integer}}")
-
-    usp, Boundary = compute_usp(g, Source, Target, max_length)
-
-    where(usp(u, v), r == rank(v).per(u)).define(neighbor(u, r, v))
-
-    nsp = compute_nsp_from_usp(g, usp, Source, Target, Boundary)
-
-    define(edge_nsp(u, i, val)).where(
-        neighbor(u, i, v),
-        nsp(v, val)
-    )
-
-    acc_nsp = linear_prefix_sum_with_groupby(edge_nsp)
-
-    define(nsp_interval(u, i, lo, hi)).where(
-        i == 1,
-        lo == 1,
-        acc_nsp(u, i, hi)
-    )
-    define(nsp_interval(u, i, lo, hi)).where(
-        acc_nsp(u, i - 1, lo - 1),
-        acc_nsp(u, i, hi)
-    )
-
-    define(ord_source(r, u)).where(
-        Source(u),
-        usp(u, v),
-        r == rank(u)
-    )
-
-    define(ord_source(r, u)).where(
-        Source(u),
-        Target(u),
-        r == rank(u)
-    )
-
-    if num_paths is not None:
-        define(total_paths(num_paths))
-    else:
-        define(total_paths(sum(src, n))).where(nsp(src, n))
-
-    define(int_source(src, n, m)).where(
-        total_paths(tot),
-        ord_source(1, src),
-        n == 1,
-        nsp(src, level),
-        n <= tot,
-        tot <= level,
-        m == tot
-    )
-
-    define(int_source(src, n, m)).where(
-        total_paths(tot),
-        ord_source(1, src),
-        n == 1,
-        nsp(src, level),
-        level < tot,
-        m == level
-    )
-
-    define(int_source(src, n, m)).where(
-        total_paths(tot),
-        ord_source(d, src),
-        ord_source(d-1, u),
-        int_source(u, r, s),
-        n == s + 1,
-        nsp(src, level),
-        n <= tot,
-        tot <= s + level,
-        m == tot
-    )
-
-    define(int_source(src, n, m)).where(
-        total_paths(tot),
-        ord_source(d, src),
-        ord_source(d-1, u),
-        int_source(u, r, s),
-        n == s + 1,
-        nsp(src, level),
-        s + level < tot,
-        m == s + level
-    )
-
-    where(
-        int_source(src, n, m),
-        path_num == range_int64(n, m + 1, 1),
-        r == path_num - n + 1,
-    ).define(paths_listing(src, r, 0, path_num))
-
-    where(
-        paths_listing(u, m, level - 1, path_num),
-        path_routing(u, m, v, n)
-    ).define(paths_listing(v, n, level, path_num))
-
-    where(
-        nsp_interval(u, i, lo, hi),
-        m == range_int64(lo, hi + 1, 1),
-        neighbor(u, i, v),
-        n == m - lo + 1
-    ).define(path_routing(u, m, v, n))
-
-    define(paths(path_num, level, v)).where(
-        paths_listing(v, n, level, path_num)
-    )
-
-    return paths
-
-
-def find_walks(g: Graph, Source, Target, max_length, num_paths=None):
-    Node = g.Node
-
-    u, v, src = Node.ref(), Node.ref(), Node.ref()
-    i, val, lo, hi = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
-    level, n, m, path_num = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
-    d, r, s, tot = Integer.ref(), Integer.ref(), Integer.ref(), Integer.ref()
-
-    ord_source = g.model.Relationship(f"ord_source {{Integer}}th source node {{{Node}}}")
-    total_paths = g.model.Relationship("total_paths {Integer}")
-    int_source = g.model.Relationship(f"int_source paths from {{{Node}}} numbered {{Integer}} to {{Integer}}")
-    paths_listing = g.model.Relationship(f"paths_listing {{{Node}}} {{Integer}} {{Integer}} {{Integer}}")
-    paths = g.model.Relationship(f"paths {{{Integer}}} has {{{Integer}}}th node {{{Node}}}")
-    neighbor = g.model.Relationship(f"neighbor pair {{{Node}}} {{Integer}} neighbor {{Integer}} is {{{Node}}}")
-    edge_nsp = g.model.Relationship(f"edge_nsp num shortest from pair {{{Node}}} {{Integer}} through {{Integer}} neighbor {{Integer}}")
-    acc_nsp = g.model.Relationship(f"acc_nsp num shortest from {{{Node}}} neighbor from 1 to {{Integer}} is {{Integer}}")
-    nsp_interval = g.model.Relationship(f"nsp_interval {{{Node}}} {{Integer}} {{Integer}} {{Integer}} {{Integer}}")
-    path_routing = g.model.Relationship(f"path_routing {{{Node}}} {{Integer}} {{Integer}} {{{Node}}} {{Integer}}")
-
-    uw, Boundary = compute_uw(g, Source, Target, max_length)
-
-
-    where(uw(u, n, v), r == rank(v).per(u, n)).define(neighbor(u, n, r, v))
-
-    nw = compute_nw_from_uw(g, uw, Target, Boundary)
-
-    define(edge_nsp(u, n, i, val)).where(
-        neighbor(u, n, i, v),
-        nw(v, n + 1, val)
-    )
-
-    acc_nsp = linear_prefix_sum_with_groupby(edge_nsp)
-
-    define(nsp_interval(u, n, i, lo, hi)).where(
-        i == 1,
-        lo == 1,
-        acc_nsp(u, n, i, hi)
-    )
-    define(nsp_interval(u, n, i, lo, hi)).where(
-        acc_nsp(u, n, i - 1, lo - 1),
-        acc_nsp(u, n, i, hi)
-    )
-
-    define(ord_source(r, u)).where(
-        Source(u),
-        uw(u, 0, v),
-        r == rank(u)
-    )
-
-    define(ord_source(r, u)).where(
-        Source(u),
-        Target(u),
-        r == rank(u)
-    )
-
-    if num_paths is not None:
-        define(total_paths(num_paths))
-    else:
-        define(total_paths(sum(src, 0, n))).where(nw(src, 0, n))
-
-    define(int_source(src, n, m)).where(
-        total_paths(tot),
-        ord_source(1, src),
-        n == 1,
-        nw(src, 0, level),
-        n <= tot,
-        tot <= level,
-        m == tot
-    )
-
-    define(int_source(src, n, m)).where(
-        total_paths(tot),
-        ord_source(1, src),
-        n == 1,
-        nw(src, 0, level),
-        level < tot,
-        m == level
-    )
-
-    define(int_source(src, n, m)).where(
-        total_paths(tot),
-        ord_source(d, src),
-        ord_source(d-1, u),
-        int_source(u, r, s),
-        n == s + 1,
-        nw(src, 0, level),
-        n <= tot,
-        tot <= s + level,
-        m == tot
-    )
-
-    define(int_source(src, n, m)).where(
-        total_paths(tot),
-        ord_source(d, src),
-        ord_source(d-1, u),
-        int_source(u, r, s),
-        n == s + 1,
-        nw(src, 0, level),
-        s + level < tot,
-        m == s + level
-    )
-
-    where(
-        int_source(src, n, m),
-        path_num == range_int64(n, m + 1, 1),
-        r == path_num - n + 1,
-    ).define(paths_listing(src, r, 0, path_num))
-
-    where(
-        paths_listing(u, m, level - 1, path_num),
-        path_routing(u, level - 1, m, v, n),
-        not_(Target(u))
-    ).define(paths_listing(v, n, level, path_num))
-
-    where(
-        paths_listing(u, m, level - 1, path_num),
-        path_routing(u, level - 1, m - 1, v, n),
-        Target(u),
-        m >= 2
-    ).define(paths_listing(v, n, level, path_num))
-
-    where(
-        nsp_interval(u, level, i, lo, hi),
-        m == range_int64(lo, hi + 1, 1),
-        neighbor(u, level, i, v),
-        n == m - lo + 1
-    ).define(path_routing(u, level, m, v, n))
-
-    define(paths(path_num, level, v)).where(
-        paths_listing(v, n, level, path_num)
-    )
-
-    return paths
-
-# Explicitly export relevant classes and functions
-__all__ = []