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

relationalai/semantics/lqp/primitives.py

@@ -1,8 +1,8 @@
 from relationalai.semantics.metamodel.types import digits_to_bits
 from relationalai.semantics.lqp import ir as lqp
 from relationalai.semantics.lqp.types import is_numeric
-from relationalai.semantics.lqp.utils import UniqueNames, lqp_hash
-from relationalai.semantics.lqp.constructors import mk_primitive, mk_specialized_value, mk_type, mk_value, mk_var
+from relationalai.semantics.lqp.utils import TranslationCtx, gen_unique_var, lqp_hash
+from relationalai.semantics.lqp.constructors import mk_primitive, mk_specialized_value, mk_type, mk_value
 
 rel_to_lqp = {
     "=": "rel_primitive_eq",
@@ -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 = {
@@ -202,15 +205,15 @@ def is_monotype(name: str) -> bool:
 
 # We take the name and type of the variable that we're summing over, so that we can generate
 # recognizable names for the variables in the reduce operation and preserve the type.
-def lqp_avg_op(names: UniqueNames, op_name: str, sum_name: str, sum_type: lqp.Type) -> lqp.Abstraction:
+def lqp_avg_op(ctx: TranslationCtx, op_name: str, sum_name: str, sum_type: lqp.Type) -> lqp.Abstraction:
     count_type = mk_type(lqp.TypeName.INT)
     vars = [
-        (mk_var(names.get_name(sum_name)), sum_type),
-        (mk_var(names.get_name("counter")), count_type),
-        (mk_var(names.get_name(sum_name)), sum_type),
-        (mk_var(names.get_name("one")), count_type),
-        (mk_var(names.get_name("sum")), sum_type),
-        (mk_var(names.get_name("count")), count_type),
+        (gen_unique_var(ctx, sum_name), sum_type),
+        (gen_unique_var(ctx, "counter"), count_type),
+        (gen_unique_var(ctx, sum_name), sum_type),
+        (gen_unique_var(ctx, "one"), count_type),
+        (gen_unique_var(ctx, "sum"), sum_type),
+        (gen_unique_var(ctx, "count"), count_type),
     ]
 
     x1 = vars[0][0]
@@ -230,10 +233,10 @@ def lqp_avg_op(names: UniqueNames, op_name: str, sum_name: str, sum_type: lqp.Ty
     return lqp.Abstraction(vars=vars, value=body, meta=None)
 
 # Default handler for aggregation operations in LQP.
-def lqp_agg_op(names: UniqueNames, op_name: str, aggr_arg_name: str, aggr_arg_type: lqp.Type) -> lqp.Abstraction:
-    x = mk_var(names.get_name(f"x_{aggr_arg_name}"))
-    y = mk_var(names.get_name(f"y_{aggr_arg_name}"))
-    z = mk_var(names.get_name(f"z_{aggr_arg_name}"))
+def lqp_agg_op(ctx: TranslationCtx, op_name: str, aggr_arg_name: str, aggr_arg_type: lqp.Type) -> lqp.Abstraction:
+    x = gen_unique_var(ctx, f"x_{aggr_arg_name}")
+    y = gen_unique_var(ctx, f"y_{aggr_arg_name}")
+    z = gen_unique_var(ctx, f"z_{aggr_arg_name}")
     ts = [(x, aggr_arg_type), (y, aggr_arg_type), (z, aggr_arg_type)]
 
     name = agg_to_lqp.get(op_name, op_name)
@@ -241,9 +244,9 @@ def lqp_agg_op(names: UniqueNames, op_name: str, aggr_arg_name: str, aggr_arg_ty
 
     return lqp.Abstraction(vars=ts, value=body, meta=None)
 
-def lqp_operator(names: UniqueNames, op_name: str, aggr_arg_name: str, aggr_arg_type: lqp.Type) -> lqp.Abstraction:
+def lqp_operator(ctx: TranslationCtx, op_name: str, aggr_arg_name: str, aggr_arg_type: lqp.Type) -> lqp.Abstraction:
     # TODO: Can we just pass through unknown operations?
     if op_name not in agg_to_lqp:
         raise NotImplementedError(f"Unsupported aggregation: {op_name}")
 
-    return lqp_agg_op(names, op_name, aggr_arg_name, aggr_arg_type)
+    return lqp_agg_op(ctx, op_name, aggr_arg_name, aggr_arg_type)

relationalai/semantics/lqp/rewrite/__init__.py

@@ -1,7 +1,7 @@
 from .cdc import CDC
 from .extract_common import ExtractCommon
 from .extract_keys import ExtractKeys
-from .fd_constraints import FDConstraints
+from .function_annotations import FunctionAnnotations
 from .quantify_vars import QuantifyVars
 from .splinter import Splinter
 
@@ -9,7 +9,7 @@ __all__ = [
     "CDC",
     "ExtractCommon",
     "ExtractKeys",
-    "FDConstraints",
+    "FunctionAnnotations",
     "QuantifyVars",
     "Splinter",
 ]

relationalai/semantics/lqp/rewrite/{fd_constraints.py → function_annotations.py}

@@ -5,7 +5,7 @@ from relationalai.semantics.metamodel import ir, compiler as c, visitor as v, bu
 from relationalai.semantics.metamodel.util import OrderedSet, ordered_set
 
 
-class FDConstraints(c.Pass):
+class FunctionAnnotations(c.Pass):
     """
     Pass marks all appropriate relations with `function` annotation.
     Criteria:
@@ -17,7 +17,7 @@ class FDConstraints(c.Pass):
         collect_fd = CollectFunctionalRelationsVisitor()
         new_model = collect_fd.walk(model)
         # mark relations collected by previous visitor with `@function` annotation
-        return FDConstraintsVisitor(collect_fd.functional_relations).walk(new_model)
+        return FunctionalAnnotationsVisitor(collect_fd.functional_relations).walk(new_model)
 
 
 @dataclass
@@ -57,9 +57,9 @@ class CollectFunctionalRelationsVisitor(v.Rewriter):
 
 
 @dataclass
-class FDConstraintsVisitor(v.Rewriter):
+class FunctionalAnnotationsVisitor(v.Rewriter):
     """
-    This visitor marks functional_relations with `functional` annotation.
+    This visitor marks functional_relations with `function` annotation.
     """
 
     def __init__(self, functional_relations: OrderedSet):

relationalai/semantics/lqp/utils.py

@@ -1,5 +1,6 @@
 from relationalai.semantics.lqp import ir as lqp
 from relationalai.semantics.metamodel import ir
+from relationalai.semantics.metamodel.helpers import sanitize
 from relationalai.semantics.metamodel.util import FrozenOrderedSet
 
 from hashlib import sha256
@@ -13,21 +14,24 @@ class UniqueNames:
         self.id_to_name = dict[int,str]()
 
     def get_name(self, name: str) -> str:
-        if name in self.seen:
-            self.seen[name] += 1
-            id = self.seen[name]
-            # If the original name has a suffix we can get collisions with generated names,
-            # so test the new name.
-            while f"{name}_{id}" in self.seen:
-                id += 1
-                self.seen[name] = id
-            new_name = f"{name}_{id}"
-            self.seen[new_name] = 1
-            return new_name
-        else:
+        # Names will eventually be sanitized, which could cause collisions, so we
+        # do the sanitization here.
+        name = '_' if name == '_' else sanitize(name)
+        if name not in self.seen:
             self.seen[name] = 1
             return f"{name}"
 
+        self.seen[name] += 1
+        id = self.seen[name]
+        # If the original name has a suffix we can get collisions with generated names,
+        # so test the new name.
+        while f"{name}_{id}" in self.seen:
+            id += 1
+            self.seen[name] = id
+        new_name = f"{name}_{id}"
+        self.seen[new_name] = 1
+        return new_name
+
     # Get a unique name for the given id. If the id is already in the map, return the
     # existing name. Otherwise, generate a new name using the suggested_name and
     # store it in the map.
@@ -55,7 +59,7 @@ def gen_rel_id(ctx: TranslationCtx, orig_name: str, suffix: str = "") -> lqp.Rel
     ctx.rel_id_to_orig_name[relation_id] = orig_name
     return relation_id
 
-def gen_unique_var(ctx: TranslationCtx, name_hint: str):
+def gen_unique_var(ctx: TranslationCtx, name_hint: str) -> lqp.Var:
     """
     Generate a new variable with a unique name based on the provided hint.
     """

relationalai/semantics/metamodel/builtins.py

@@ -507,6 +507,13 @@ track = f.relation("track", [
 ])
 track_annotation = f.annotation(track, [])
 
+# Enables config used by raicode/src/Recursion. Supported for Relationships and queries.
+recursion_config = f.relation("recursion_config", [
+    f.input_field("config_key", types.Symbol),
+    f.input_field("config_value", types.Int64)
+])
+recursion_config_annotation = f.annotation(recursion_config, [])
+
 # All ir nodes marked by this annotation will be removed from the final metamodel before compilation.
 # Specifically it happens in `Flatten` pass when rewrites for `require` happen
 discharged = f.relation("discharged", [])
@@ -648,6 +655,48 @@ rel_primitive_solverlib_ho_appl = aggregation("rel_primitive_solverlib_ho_appl",
 implies = f.relation("implies", [f.input_field("a", types.Bool), f.input_field("b", types.Bool)])
 all_different = aggregation("all_different", [f.input_field("over", types.Any)])
 
+# graph primitive algorithm helpers
+infomap = aggregation("infomap", [
+    f.input_field("weights", types.AnyList),
+    f.input_field("node_count", types.Any),
+    f.input_field("edge_count", types.Any),
+    f.input_field("teleportation_rate", types.Float),
+    f.input_field("visit_rate_tolerance", types.Float),
+    f.input_field("level_tolerance", types.Float),
+    f.input_field("sweep_tolerance", types.Float),
+    f.input_field("max_levels", types.Int64),
+    f.input_field("max_sweeps", types.Int64),
+    f.input_field("randomization_seed", types.Int64),
+    f.field("termination_info", types.String),
+    f.field("node_index", types.Int64),
+    f.field("community", types.Int64)
+])
+
+louvain = aggregation("louvain", [
+    f.input_field("weights", types.AnyList),
+    f.input_field("node_count", types.Any),
+    f.input_field("edge_count", types.Any),
+    f.input_field("level_tolerance", types.Float),
+    f.input_field("sweep_tolerance", types.Float),
+    f.input_field("max_levels", types.Int64),
+    f.input_field("max_sweeps", types.Int64),
+    f.input_field("randomization_seed", types.Int64),
+    f.field("termination_info", types.String),
+    f.field("node_index", types.Int64),
+    f.field("community", types.Int64)
+])
+
+label_propagation = aggregation("label_propagation", [
+    f.input_field("weights", types.AnyList),
+    f.input_field("node_count", types.Any),
+    f.input_field("edge_count", types.Any),
+    f.input_field("max_sweeps", types.Int64),
+    f.input_field("randomization_seed", types.Int64),
+    f.field("termination_info", types.String),
+    f.field("node_index", types.Int64),
+    f.field("community", types.Int64)
+])
+
 #
 # Public access to built-in relations
 #
@@ -683,7 +732,7 @@ def _compute_builtin_overloads() -> list[ir.Relation]:
     return overloads
 
 # manually maintain the list of relations that are actually annotations
-builtin_annotations = [external, export, concept_population, from_cdc, from_cast, track]
+builtin_annotations = [external, export, concept_population, from_cdc, from_cast, track, recursion_config]
 builtin_annotations_by_name = dict((r.name, r) for r in builtin_annotations)
 
 builtin_relations = _compute_builtin_relations()

relationalai/semantics/metamodel/typer/typer.py

@@ -137,6 +137,9 @@ def to_type(value: ir.Value|ir.Field) -> ir.Type:
     if isinstance(value, tuple):
         return types.AnyList
 
+    if isinstance(value, ir.Relation):
+        return types.AnyList
+
     raise TypeError(f"Cannot determine IR type for value: {value} of type {type(value).__name__}")
 
 def type_matches(actual:ir.Type, expected:ir.Type, allow_expected_parents=False) -> bool:

relationalai/semantics/reasoners/__init__.py

@@ -1,3 +1,7 @@
+"""
+The RelationalAI Semantics Reasoners Module.
+"""
+
 # Mark this package's docstrings for inclusion
 # in automatically generated web documentation,
 # by default as early access.

relationalai/semantics/reasoners/experimental/__init__.py

@@ -0,0 +1,7 @@
+"""
+Experimental reasoners and algorithms.
+
+This namespace contains experimental features that may change in future versions.
+"""
+
+__all__ = []