relationalai 0.12.4__py3-none-any.whl → 0.12.7__py3-none-any.whl

relationalai/__init__.py

@@ -1,3 +1,7 @@
+"""
+The RelationalAI Python SDK.
+"""
+
 from __future__ import annotations
 import importlib.metadata
 

relationalai/clients/snowflake.py

@@ -834,19 +834,25 @@ Otherwise, remove it from your '{profile}' configuration profile.
         program_span_id: str | None = None,
         headers: Dict | None = None,
     ):
-        """Only call _poll_use_index if there are sources to process."""
+        """Only call poll() if there are sources to process and cache is not valid."""
         sources_list = list(sources)
         self.database = model
         if sources_list:
-            return self._poll_use_index(
-                app_name=app_name,
-                sources=sources_list,
-                model=model,
-                engine_name=engine_name,
-                engine_size=engine_size,
-                program_span_id=program_span_id,
-                headers=headers,
+            poller = UseIndexPoller(
+                self,
+                app_name,
+                sources_list,
+                model,
+                engine_name,
+                engine_size,
+                self.language,
+                program_span_id,
+                headers,
+                self.generation
             )
+            # If cache is valid (data freshness has not expired), skip polling
+            if not poller.cache.is_valid():
+                return poller.poll()
 
     #--------------------------------------------------
     # Models
@@ -2836,6 +2842,15 @@ class SnowflakeTable(dsl.Type):
                 else:
                     self(snowflake_id=id).set(**{prop_ident: val})
 
+        # Because we're bypassing a bunch of the normal Type.add machinery here,
+        # we need to manually account for the case where people are using value types.
+        def wrapped(x):
+            if not model._config.get("compiler.use_value_types", False):
+                return x
+            other_id = dsl.create_var()
+            model._action(dsl.build.construct(self._type, [x, other_id]))
+            return other_id
+
         # new UInt128 schema mapping rules
         with model.rule(dynamic=True, globalize=True, source=self._source):
             id = dsl.create_var()
@@ -2845,7 +2860,7 @@ class SnowflakeTable(dsl.Type):
             # for avoiding a non-blocking warning
             edb(dsl.Symbol("METADATA$KEY"), id)
             std.rel.UInt128(id)
-            self.add(id, snowflake_id=id)
+            self.add(wrapped(id), snowflake_id=id)
 
         for prop, prop_type in self._schema["columns"].items():
             _prop = prop
@@ -2867,7 +2882,7 @@ class SnowflakeTable(dsl.Type):
                     model._check_property(_prop._prop)
                     raw_relation = getattr(std.rel, prop_ident)
                     dsl.tag(raw_relation, dsl.Builtins.FunctionAnnotation)
-                    raw_relation.add(id, val)
+                    raw_relation.add(wrapped(id), val)
 
     def namespace(self):
         return f"{self._parent._parent._name}.{self._parent._name}"
@@ -3450,19 +3465,25 @@ class DirectAccessResources(Resources):
         program_span_id: str | None = None,
         headers: Dict | None = None,
     ):
-        """Only call _poll_use_index if there are sources to process."""
+        """Only call poll() if there are sources to process and cache is not valid."""
         sources_list = list(sources)
         self.database = model
         if sources_list:
-            return self._poll_use_index(
+            poller = DirectUseIndexPoller(
+                self,
                 app_name=app_name,
                 sources=sources_list,
                 model=model,
                 engine_name=engine_name,
                 engine_size=engine_size,
+                language=self.language,
                 program_span_id=program_span_id,
                 headers=headers,
+                generation=self.generation,
             )
+            # If cache is valid (data freshness has not expired), skip polling
+            if not poller.cache.is_valid():
+                return poller.poll()
 
     def _check_exec_async_status(self, txn_id: str, headers: Dict[str, str] | None = None) -> bool:
         """Check whether the given transaction has completed."""

relationalai/early_access/lqp/constructors/__init__.py

@@ -2,12 +2,12 @@ import warnings
 
 from relationalai.semantics.lqp.constructors import (
     mk_abstraction, mk_and, mk_exists, mk_or, mk_pragma, mk_primitive,
-    mk_specialized_value, mk_type, mk_value, mk_var
+    mk_specialized_value, mk_type, mk_value
 )
 
 __all__ = [
     "mk_abstraction", "mk_and", "mk_exists", "mk_or", "mk_pragma", "mk_primitive", "mk_specialized_value", "mk_type",
-    "mk_value", "mk_var"
+    "mk_value"
 ]
 
 warnings.warn(

relationalai/early_access/metamodel/rewrite/__init__.py

@@ -1,7 +1,7 @@
 from relationalai.semantics.metamodel.rewrite import Flatten, \
     DNFUnionSplitter, ExtractNestedLogicals, flatten
 from relationalai.semantics.lqp.rewrite import Splinter,  \
-    ExtractKeys, FDConstraints
+    ExtractKeys, FunctionAnnotations
 
 __all__ = ["Splinter", "Flatten", "DNFUnionSplitter", "ExtractKeys",
-           "ExtractNestedLogicals", "FDConstraints", "flatten"]
+           "ExtractNestedLogicals", "FunctionAnnotations", "flatten"]

relationalai/{semantics/reasoners/graph → experimental}/paths/README.md

@@ -12,8 +12,8 @@ The following is a minimal working example:
 from relationalai.semantics import Model, Integer, select, String, where, define
 from relationalai.semantics.std import strings
 
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.api import node, edge, path, star, match
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.api import node, edge, path, star, match
 
 model = Model("my_paths")
 

relationalai/experimental/paths/__init__.py

@@ -1,309 +1,14 @@
-import os
-from typing import List, Set, Tuple, Union
-import zipfile
-from enum import Enum
-
-from relationalai import dsl
-from relationalai.dsl import Graph, Instance, Type, Property, create_vars, get_graph, next_id
-from relationalai.metamodel import ActionType, Builtins
-from relationalai.std import rel
-
-class VarLength:
-    def __init__(self, type: Type):
-        self.type = type
-        self.min = 1
-        self.max = 1
-
-    def __getitem__(self, key):
-        if isinstance(key, slice):
-            self.min = key.start
-            self.max = key.stop
-        else:
-            raise ValueError("VarLength only supports slicing")
-        return self
-
-class PathSelection(Enum):
-    ALL = "all" # return all paths between source and target
-    SINGLE = "single" # return a single path between source and target
-    LIMIT = "limit" # return a specified number paths between source and target, as given by parameter k.
-    RANDOM = "random" # return a single randomly-chosen path between source and target, seeded with parameter seed.
-    UNIFORM_RANDOM = "uniform_random" # return a single uniform randomly-chosen path between source and target, seeded with parameter seed.
-
-class PathGroup(Enum):
-    ANY = "any"
-    FOREACH = "for_each"
-
-class Strategy(Enum):
-    FROM_SOURCE = "from_source"
-    TWO_SIDED = "two_sided"
-
-class PathQuery:
-
-    def __init__(
-        self,
-        model: Graph,
-        segments: List[Union[Instance,VarLength]],
-        backwards_edge: str,
-        group: PathGroup = PathGroup.FOREACH,
-        selection: PathSelection = PathSelection.ALL,
-        strategy: Strategy = Strategy.FROM_SOURCE,
-    ):
-        # create types and instance
-        self._path_id = next_id()
-        self._conn_relation_name = f"conn_{self._path_id}"
-        self._model = model
-
-        # create types
-        self._Path = dsl.Type(model, f"Path{self._path_id}", omit_intrinsic_type_in_hash=True)
-        self._PathNode = dsl.Type(model, f"PathNode{self._path_id}", omit_intrinsic_type_in_hash=True)
-        self._PathEdge = dsl.Type(model, f"PathEdge{self._path_id}", omit_intrinsic_type_in_hash=True)
-
-        # declare multivalued attributes
-        self._Path.nodes.has_many()
-        self._Path.edges.has_many()
-
-        # mark these types and their attributes as @no_inline
-        self._add_noinline(self._Path, [])
-        self._add_noinline(self._PathNode, ["path", "index", "node_id"])
-        self._add_noinline(self._PathEdge, ["path", "index", "label"])
-
-        # create instance
-        self._instance = self._Path()
-        self._match_called = False
-
-        # store path query attributes
-        self._segments = segments
-        self._backwards_edge = backwards_edge
-        self._group = group
-        self._selection = selection
-        self._strategy = strategy
-
-    def _add_noinline(self, typ, props):
-        typ._type.parents.append(Builtins.NoInlineAnnotation)
-        for prop in props:
-            getattr(typ, prop)._prop.parents.append(Builtins.NoInlineAnnotation)
-
-    def _match(self):
-        # avoid emitting the Rel multiple times, which throws off Pathfinder
-        if not self._match_called:
-            self._match_called = True
-
-            begin_var, end_var = self._match_inner()
-
-            self._begin_var = begin_var
-            self._end_var = end_var
-
-        return self._conn_relation_name
-
-    def _match_inner(self):
-        begin_var = None
-        cur_end = None
-
-        for idx, segment in enumerate(self._segments):
-            if isinstance(segment, VarLength):
-                var_length_rel_name = self._var_length(idx, segment)
-                seg_begin, seg_end = create_vars(2)
-                getattr(rel, var_length_rel_name)(seg_begin, seg_end)
-
-                if begin_var is None:
-                    begin_var = seg_begin
-                    cur_end = seg_end
-                else:
-                    getattr(seg_begin, self._backwards_edge) == cur_end
-                    cur_end = seg_end
-            else:
-                next_var = segment
-                if begin_var is None:
-                    begin_var = next_var
-                    cur_end = begin_var
-                else:
-                    getattr(next_var, self._backwards_edge) == cur_end
-                    cur_end = next_var
-
-        conn_relation = getattr(rel, self._conn_relation_name)
-        conn_relation._rel.parents.append(Builtins.NoInlineAnnotation)
-        conn_relation.add(begin_var, cur_end)
-
-        return begin_var, cur_end
-
-    def _var_length(self, segment_idx: int, segment: VarLength):
-        # relations for each length
-        prefix = f"conn_{self._path_id}_segment_{segment_idx}"
-
-        lines = []
-
-        for length in range(1, segment.max+1):
-            length_rel_name = f"{prefix}_length_{length}"
-
-            if length == 1:
-                lines.extend([
-                    f"def {length_rel_name}(a, a1):",
-                    f"    {segment.type._type.name}(a) and",
-                    "    a = a1"
-                ])
-                # would just project `(a, a)`, but that gives a
-                # bunch of Rel warnings`
-
-            else:
-                prev_length_relation_name = f"{prefix}_length_{length-1}"
-                lines.extend([
-                    f"def {length_rel_name}(a, c):",
-                    "    exists((b) |",
-                    f"       {prev_length_relation_name}(a, b) and",
-                    f"       {segment.type._type.name}(c) and",
-                    f"       {self._backwards_edge}(c, b)",
-                    "     )"
-                ])
-
-        # union them all together in overall segment relation
-        lines.extend([
-            f"def {prefix}(start, finish):",
-            "    " + " or\n    ".join([
-                f"{prefix}_length_{length}(start, finish)"
-                for length in range(1, segment.max+1)
-            ]),
-        ])
-
-        self._model.install_raw(
-            '\n'.join(lines),
-            name=f"path_{self._path_id}_segment_{segment_idx}",
-        )
-
-        return prefix
-
-
-class PathInstance(Instance):
-
-    def __init__(
-        self,
-        path_query: PathQuery,
-    ):
-        self._path_query = path_query
-
-        self._already_called = False
-        super().__init__(
-            self._path_query._model,
-            ActionType.Get, [self._path_query._instance],
-            named={},
-        )
-
-    # implements producer API
-    def _to_var(self):
-        self._invoke_pathfinder()
-        return super()._to_var()
-
-    def _invoke_pathfinder(self):
-        if self._already_called:
-            return
-        self._already_called = True
-
-        # ensure that the pathfinder Rel library is installed
-        _install_pathfinder(self._path_query._model)
-
-        source_rel = f"source_{self._path_query._path_id}"
-        target_rel = f"target_{self._path_query._path_id}"
-        getattr(rel, source_rel).add(self._path_query._begin_var)
-        getattr(rel, target_rel).add(self._path_query._end_var)
-
-        shortest_paths_rel = f"shortest_paths_{self._path_query._path_id}"
-        path_edge_rel = f"path_edge_{self._path_query._path_id}"
-        path_node_rel = f"path_node_{self._path_query._path_id}"
-
-        invocation = f"""
-        @no_inline
-        def {shortest_paths_rel} {{
-            ::pathfinder::shortest_paths[
-                :{self._path_query._group.value},
-                :{self._path_query._selection.value},
-                :{self._path_query._strategy.value},
-                {self._path_query._conn_relation_name},
-                {source_rel},
-                {target_rel}
-            ]
-        }}
-
-        @no_inline
-        def {path_node_rel}(path, index, id):
-            {shortest_paths_rel}(path, :node, index, id)
-
-        @no_inline
-        def {path_edge_rel}(path, index, label):
-            {shortest_paths_rel}(path, :edge_label, index, label)
-        """
-
-        self._path_query._model.install_raw(invocation)
-
-        # select out nodes
-        with self._path_query._model.rule():
-            path_id, index, node_label = create_vars(3)
-            getattr(rel, path_node_rel)(path_id, index, node_label)
-            path = self._path_query._Path.add(id=path_id)
-            # TODO: avoid perf hit of going in both directions (path<->node)
-            node = self._path_query._PathNode.add(path=path, index=index, value=node_label)
-            path.nodes.add(node)
-
-        # select out edges
-        with self._path_query._model.rule():
-            path_id, index, label = create_vars(3)
-            getattr(rel, path_edge_rel)(path_id, index, label)
-            path = self._path_query._Path.add(id=path_id)
-            # TODO: avoid perf hit of going in both directions (path<->edge)
-            edge = self._path_query._PathEdge.add(path=path, index=index, label=label)
-            path.edges.add(edge)
-
-# TODO: automatically infer this from the path query itself
-def enable_on(edge: Property, filter_attrs: List[Tuple[Type, Set[str]]]):  # noqa: F821
-    edge._prop.parents.append(Builtins.PQEdgeAnnotation)
-    edge._prop.parents.append(Builtins.NoInlineAnnotation)
-    for type, attrs in filter_attrs:
-        type._type.parents.append(Builtins.PQFilterAnnotation)
-        type._type.parents.append(Builtins.NoInlineAnnotation)
-        for attr_name in attrs:
-            prop = getattr(type, attr_name)
-            prop._prop.parents.append(Builtins.PQFilterAnnotation)
-            prop._prop.parents.append(Builtins.NoInlineAnnotation)
-
-# main entry point
-def path(
-    segments: List[Union[Instance,VarLength]],
-    backwards_edge: str,
-    group: PathGroup = PathGroup.FOREACH,
-    selection: PathSelection = PathSelection.ALL,
-    strategy: Strategy = Strategy.FROM_SOURCE,
-):
-    """
-    Find a path consisting of the provided segments, linked by
-    the provided `backwards_edge` property.
-    """
-
-    model = get_graph()
-
-    query = PathQuery(model, segments, backwards_edge, group, selection, strategy)
-
-    # declare filter relations
-    conn_relation_name = query._match()
-
-    # invoke filter
-    a, b = create_vars(2)
-    getattr(rel, conn_relation_name)(a, b)
-
-    # return a special Producer representing the path itself, which
-    # lazily invokes Pathfinder
-    return PathInstance(query)
-
-def _get_pathfinder_source():
-    # check if the current dir is in a zip file
-    current_dir = os.path.dirname(__file__)
-    pathfinder_path = os.path.join(current_dir, "pathfinder.rel")
-    if os.path.exists(pathfinder_path):
-        return open(pathfinder_path).read()
-    # if we're in a zip file, read it within that
-    zip_split = current_dir.split(".zip")
-    zip_path = zip_split[0] + ".zip"
-    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-        with zip_ref.open('relationalai/experimental/paths/pathfinder.rel') as file:
-            return file.read().decode("utf-8")
-
-def _install_pathfinder(model: Graph):
-    source = _get_pathfinder_source()
-    model.install_raw(source, name="pathfinder", overwrite=True)
+## pathfinder module
+
+from .api import node, edge, path, optional, plus, star, union, match
+
+__all__ = [
+    'node',
+    'edge',
+    'path',
+    'optional',
+    'plus',
+    'star',
+    'union',
+    'match',
+]

relationalai/{semantics/reasoners/graph → experimental}/paths/examples/basic_example.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, select, String, define
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.api import path, star, match
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.api import path, star, match
 
 # Create an automaton that matches paths with pattern: A(A*)B:
 pattern = path("A", star("A"), "B")

relationalai/{semantics/reasoners/graph → experimental}/paths/examples/paths_benchmark.py

@@ -4,8 +4,8 @@ Example usage of automaton-based pathfinding.
 
 import time
 from relationalai.semantics import Model, Integer, select, String, define
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.api import node, path, match
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.api import node, path, match
 
 import argparse
 

relationalai/{semantics/reasoners/graph → experimental}/paths/examples/paths_example.py

@@ -4,8 +4,8 @@ Example usage of automaton-based pathfinding.
 
 import time
 from relationalai.semantics import Model, Integer, select, String, define
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.api import node, path, match
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.api import node, path, match
 
 import argparse
 

relationalai/{semantics/reasoners/graph → experimental}/paths/examples/pattern_to_automaton.py

@@ -1,4 +1,4 @@
-from relationalai.semantics.reasoners.graph.paths.api import path, union
+from relationalai.experimental.paths.api import path, union
 from relationalai.semantics import Concept
 
 Node = Concept('Node')

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/one_sided_ball_repetition.py

@@ -1,6 +1,6 @@
 # For builder components.
 from relationalai.semantics import Integer, define
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
+from relationalai.experimental.paths.graph import Graph
 
 
 def ball_with_repetition(g:Graph, Source, max_length):

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/single.py

@@ -1,8 +1,8 @@
 # For builder components.
 from relationalai.semantics import Integer, where, define, select, min
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
 
 # find a (deterministic) path from src to dst inside the given ball
 # where dst is at distance radius from src

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/two_sided_balls_repetition.py

@@ -1,6 +1,6 @@
 # For builder components.
 from relationalai.semantics import Integer, define
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
+from relationalai.experimental.paths.graph import Graph
 
 
 def two_balls_repetition(g:Graph, Source, Target, max_length):

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/two_sided_balls_upto.py

@@ -1,7 +1,7 @@
 # For builder components.
 from relationalai.semantics import Integer, define, not_, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.utilities.iterators import setup_iteration
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.utilities.iterators import setup_iteration
 
 
 def two_balls_upto(g:Graph, Source, Target, max_length=None):

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/usp-old.py

@@ -1,8 +1,8 @@
 # For builder components.
 from relationalai.semantics import Integer, define, max, sum, not_
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_upto import ball_upto
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
 
 
 def compute_usp(g: Graph, Source, Target, max_length = None):

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/usp-tuple.py

@@ -1,8 +1,8 @@
 # For builder components.
 from relationalai.semantics import Model, Integer, define, max, sum, select, not_
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_upto import ball_upto
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
 
 
 def compute_usp(g: Graph, Source, Target, max_length = None):

relationalai/{semantics/reasoners/graph → experimental}/paths/path_algorithms/usp.py

@@ -1,8 +1,8 @@
 # For builder components.
 from relationalai.semantics import Integer, define, sum, not_
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_upto import ball_upto
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
 
 
 def compute_usp(g: Graph, Source, Target, max_length=None):

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_limit_sp_max_length.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.find_paths import find_shortest_paths
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.find_paths import find_shortest_paths
 
 
 # First test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_limit_sp_multiple.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.find_paths import find_shortest_paths
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.find_paths import find_shortest_paths
 
 
 # First test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_limit_sp_single.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.find_paths import find_shortest_paths
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.find_paths import find_shortest_paths
 
 
 # First test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_limit_walks_multiple.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.find_paths import find_walks
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.find_paths import find_walks
 
 
 # First test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_limit_walks_single.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select, count
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.find_paths import find_walks
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.find_paths import find_walks
 
 
 # First test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_one_sided_ball_repetition_multiple.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
 
 
 # Test with grid graph

relationalai/{semantics/reasoners/graph → experimental}/paths/tests/tests_one_sided_ball_repetition_single.py

@@ -1,6 +1,6 @@
 from relationalai.semantics import Model, Integer, define, select
-from relationalai.semantics.reasoners.graph.paths.graph import Graph
-from relationalai.semantics.reasoners.graph.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
 
 
 # Test with grid graph