relationalai 0.12.4__tar.gz → 0.12.6__tar.gz

{relationalai-0.12.4 → relationalai-0.12.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relationalai
-Version: 0.12.4
+Version: 0.12.6
 Summary: RelationalAI Library and CLI
 Author-email: RelationalAI <support@relational.ai>
 License-File: LICENSE

{relationalai-0.12.4 → relationalai-0.12.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = 'relationalai'
-version = '0.12.4'
+version = '0.12.6'
 description = 'RelationalAI Library and CLI'
 readme="docs/pypi/README.md"
 authors = [
@@ -94,7 +94,6 @@ allow-direct-references = true
 only-include = ["src"]
 [tool.hatch.build.targets.sdist.force-include]
 "frontend/debugger/dist" = "frontend/debugger/dist"
-"src/relationalai/experimental/paths/pathfinder.rel" = "src/relationalai/experimental/paths/pathfinder.rel"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/relationalai", "src/relationalai_test_util"]

{relationalai-0.12.4 → relationalai-0.12.6}/src/relationalai/__init__.py

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

{relationalai-0.12.4 → relationalai-0.12.6}/src/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
@@ -3450,19 +3456,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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/__init__.py

@@ -12,5 +12,3 @@ __all__ = [
     'union',
     'match',
 ]
-
-

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/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

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_one_sided_ball_upto_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_upto import ball_upto
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
 
 
 # First test with grid graph and multiple source and target nodes

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_one_sided_ball_upto_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_upto import ball_upto
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
 
 
 # First test with grid graph

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_single_paths.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.single import single_shortest_path
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.single import single_shortest_path
 
 
 model = Model("test_single_paths", dry_run=False)

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_single_walks.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.single import single_walk
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.single import single_walk
 
 
 model = Model("test_single_paths", dry_run=False)

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_single_walks_undirected.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.single import single_walk
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.single import single_walk
 
 
 model = Model("test_single_paths", dry_run=False)

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_two_sided_balls_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.two_sided_balls_repetition import two_balls_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.two_sided_balls_repetition import two_balls_repetition
 
 
 # Test with diamond graph

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_two_sided_balls_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.two_sided_balls_repetition import two_balls_repetition
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.two_sided_balls_repetition import two_balls_repetition
 
 
 # Test with diamond graph

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_two_sided_balls_upto_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.two_sided_balls_upto import two_balls_upto
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.two_sided_balls_upto import two_balls_upto
 
 
 # Test with grid graph

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_two_sided_balls_upto_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.two_sided_balls_upto import two_balls_upto
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.two_sided_balls_upto import two_balls_upto
 
 
 # Test with grid graph

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_usp_nsp_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.usp import compute_usp, compute_nsp
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.usp import compute_usp, compute_nsp
 
 
 # First test for usp with grid graph

{relationalai-0.12.4/src/relationalai/semantics/reasoners/graph → relationalai-0.12.6/src/relationalai/experimental}/paths/tests/tests_usp_nsp_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.usp import compute_usp, compute_nsp
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.usp import compute_usp, compute_nsp
 
 
 # First test for usp with grid graph

{relationalai-0.12.4 → relationalai-0.12.6}/src/relationalai/semantics/__init__.py

@@ -1,3 +1,7 @@
+"""
+The RelationalAI Semantics Module.
+"""
+
 # Mark this package's docstrings for inclusion
 # in automatically generated web documentation.
 __include_in_docs__ = True

{relationalai-0.12.4 → relationalai-0.12.6}/src/relationalai/semantics/internal/annotations.py

@@ -6,3 +6,4 @@ concept_population = Relationship.builtins["concept_population"]
 function = Relationship.builtins["function"]
 from_cdc = Relationship.builtins["from_cdc"]
 track = Relationship.builtins["track"]
+recursion_config = Relationship.builtins["recursion_config"]

{relationalai-0.12.4 → relationalai-0.12.6}/src/relationalai/semantics/internal/internal.py

@@ -3419,6 +3419,8 @@ class Compiler():
             return out
 
         elif isinstance(item, TypeRef):
+            if isinstance(item._thing, Relationship):
+                return self.to_relation(item._thing)
             concept = to_type(item)
             if not concept:
                 raise ValueError(f"Cannot find concept for {item}, {type(item)}")

{relationalai-0.12.4 → relationalai-0.12.6}/src/relationalai/semantics/lqp/builtins.py

@@ -12,4 +12,5 @@ annotations_to_emit = FrozenOrderedSet([
     adhoc.name,
     builtins.function.name,
     builtins.track.name,
+    builtins.recursion_config.name,
 ])

{relationalai-0.12.4 → relationalai-0.12.6}/src/relationalai/semantics/lqp/model2lqp.py

@@ -253,7 +253,7 @@ def _translate_rank(ctx: TranslationCtx, rank: ir.Rank, body: lqp.Formula) -> lq
     # to convert it to Int128.
     result_var, _ = _translate_term(ctx, rank.result)
     # The primitive will return an Int64 result, so we need a var to hold the intermediary.
-    result_64_var = gen_unique_var(ctx, "result_64")
+    result_64_var = gen_unique_var(ctx, "rank_result_64")
     result_64_type = mk_type(lqp.TypeName.INT)
 
     cast = lqp.Cast(input=result_64_var, result=result_var, meta=None)
@@ -273,7 +273,7 @@ def _translate_descending_rank(ctx: TranslationCtx, limit: int, result: lqp.Var,
     result_type = mk_type(lqp.TypeName.INT)
 
     # Rename abstracted args in the body to new variable names
-    var_map = {var.name: gen_unique_var(ctx, var.name) for (var, _) in abstr_args}
+    var_map = {var.name: gen_unique_var(ctx, 't_' + var.name) for (var, _) in abstr_args}
     body = utils.rename_vars_formula(body, var_map)
     new_abstr_args = [(var_map[var.name], typ) for (var, typ) in abstr_args]
 
@@ -340,7 +340,7 @@ def _translate_ascending_rank(ctx: TranslationCtx, limit: int, result_var: lqp.V
     terms = [result_var] + [v[0] for v in abstr_args]
 
     # Rename abstracted args in the body to new variable names
-    var_map = {var.name: gen_unique_var(ctx, var.name) for (var, _) in abstr_args}
+    var_map = {var.name: gen_unique_var(ctx, 't_' + var.name) for (var, _) in abstr_args}
     body = utils.rename_vars_formula(body, var_map)
     new_abstr_args = [(var_map[var.name], typ) for (var, typ) in abstr_args]
     sort_abstr = mk_abstraction(new_abstr_args, body)
@@ -461,6 +461,7 @@ def _translate_aggregate(ctx: TranslationCtx, aggr: ir.Aggregate, body: lqp.Form
     # `input_args`` hold the types of the input arguments, but they may have been modified
     # if we're dealing with a count, so we use `abstr_args` to find the type.
     (aggr_arg, aggr_arg_type) = abstr_args[-1]
+
     # Group-bys do not need to be handled at all, since they are introduced outside already
     reduce = lqp.Reduce(
         op=lqp_operator(ctx.var_names, aggr.aggregation.name, aggr_arg.name, aggr_arg_type),
@@ -542,6 +543,12 @@ def _translate_to_atom(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
 
     if task.relation == builtins.join:
         return _translate_join(ctx, task)
+    elif task.relation == builtins.infomap:
+        return _translate_infomap(ctx, task)
+    elif task.relation == builtins.louvain:
+        return _translate_louvain(ctx, task)
+    elif task.relation == builtins.label_propagation:
+        return _translate_label_propagation(ctx, task)
 
     terms = []
     term_types = []
@@ -667,6 +674,92 @@ def _extract_pyrel_error_ids(ctx: TranslationCtx, model: ir.Model) -> list[Tuple
 
     return pyrel_error_attrs
 
+# Translate a relation reference into an abstraction over its fields.
+def _translate_relation_ref(ctx: TranslationCtx, relation: ir.Relation) -> lqp.Abstraction:
+    projection = []
+    for field in relation.fields:
+        var = gen_unique_var(ctx, field.name)
+        typ = meta_type_to_lqp(field.type)
+        projection.append((var, typ))
+
+    rid = get_relation_id(ctx, relation, projection)
+    atom = lqp.Atom(name=rid, terms=[var for (var, _) in projection], meta=None)
+    return mk_abstraction(projection, atom)
+
+# Common translation logic for graph algorithms.
+# task.args[0] : normalized weight list (int64, int64, float)
+# task.args[1] : normalized node count (relation or constant int64)
+# task.args[2] : normalized edge count (relation or constant int64)
+# task.args[3:-3] : algorithm parameters (var or constant)
+# task.args[-3] : diagnostic info
+# task.args[-2] : node index
+# task.args[-1] : community ident
+def _translate_graph_common(name: str, ctx: TranslationCtx, task: ir.Lookup):
+    abstractions = []
+
+    assert isinstance(task.args[0], ir.Relation), \
+        f"Expected relation as first arg to {name}, got {task.args[0]}:{type(task.args[0])}"
+    abstractions.append(_translate_relation_ref(ctx, task.args[0]))
+
+    # Allow constant args for node and edge count
+    for arg in task.args[1:3]:
+        if isinstance(arg, ir.Relation):
+            abst = _translate_relation_ref(ctx, arg)
+            typ = abst.vars[0][1]
+            assert typ.type_name == lqp.TypeName.INT, \
+                f"Expected Int64 types for node and edge counts, got type {typ.type_name}"
+            abstractions.append(abst)
+        else:
+            var, typ, eq = binding_to_lqp_var(ctx, arg)
+            assert eq is not None, \
+                f"Expected equality formula for {name} arg {arg}:{type(arg)}"
+            abstractions.append(mk_abstraction([(var, typ)], mk_and([eq])))
+
+    for arg in task.args[3:-3]:
+        var, typ, eq = binding_to_lqp_var(ctx, arg)
+        if eq:
+            abstractions.append(mk_abstraction([(var, typ)], mk_and([eq])))
+        else:
+            print(f"Primitive graph algorithm arg without eq:\n var:{var}, typ:{typ}\n arg:{arg}:{type(arg)}")
+            abstractions.append(mk_abstraction([(var, typ)], mk_and([])))
+
+    terms = []
+    for arg in task.args[-3:]:
+        term, _ = _translate_relterm(ctx, arg)
+        terms.append(term)
+
+    return (abstractions, terms)
+
+def _translate_infomap(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
+    abstractions, terms = _translate_graph_common("infomap", ctx, task)
+
+    return lqp.FFI(
+        meta=None,
+        name="rel_primitive_infomap",
+        args=abstractions,
+        terms=terms,
+    )
+
+def _translate_louvain(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
+    abstractions, terms = _translate_graph_common("louvain", ctx, task)
+
+    return lqp.FFI(
+        meta=None,
+        name="rel_primitive_louvain",
+        args=abstractions,
+        terms=terms,
+    )
+
+def _translate_label_propagation(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
+    abstractions, terms = _translate_graph_common("label_propagation", ctx, task)
+
+    return lqp.FFI(
+        meta=None,
+        name="rel_primitive_async_label_propagation",
+        args=abstractions,
+        terms=terms,
+    )
+
 # Hard-coded implementation of Rel's string_join
 def _translate_join(ctx: TranslationCtx, task: ir.Lookup) -> lqp.Formula:
     assert len(task.args) == 3

{relationalai-0.12.4 → relationalai-0.12.6}/src/relationalai/semantics/lqp/primitives.py

@@ -96,6 +96,9 @@ rel_to_lqp = {
     "split": "rel_primitive_string_split",
     "split_part": "rel_primitive_string_split",
     "regex_match": "rel_primitive_regex_match",
+    "infomap": "rel_primitive_infomap",
+    "louvain": "rel_primitive_louvain",
+    "label_propagation": "rel_primitive_async_label_propagation",
 }
 
 primitive_type_reorderings = {