relationalai 0.12.9__py3-none-any.whl → 0.12.10__py3-none-any.whl

relationalai/semantics/lqp/rewrite/annotate_constraints.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from relationalai.semantics.metamodel import builtins
+from relationalai.semantics.metamodel.ir import Node, Model, Require
+from relationalai.semantics.metamodel.compiler import Pass
+from relationalai.semantics.metamodel.rewrite.discharge_constraints import (
+    DischargeConstraintsVisitor
+)
+from relationalai.semantics.lqp.rewrite.functional_dependencies import (
+    is_valid_unique_constraint, normalized_fd
+)
+
+
+
+class AnnotateConstraints(Pass):
+    """
+    Extends `DischargeConstraints` pass by discharging only those Require nodes that cannot
+    be declared as constraints in LQP.
+
+    More precisely, the pass annotates Require nodes depending on how they should be
+    treated when generating code:
+     * `@declare_constraint` if the Require represents a constraint that can be declared in LQP.
+     * `@discharge` if the Require represents a constraint that should be dismissed during
+       code generation. Namely, when it cannot be declared in LQP and uses one of the
+       `unique`, `exclusive`, `anyof` builtins. These nodes are removed from the IR model
+       in the Flatten pass.
+    """
+
+    def rewrite(self, model: Model, options: dict = {}) -> Model:
+        return AnnotateConstraintsRewriter().walk(model)
+
+
+class AnnotateConstraintsRewriter(DischargeConstraintsVisitor):
+    """
+    Visitor marks all nodes which should be removed from IR model with `discharge` annotation.
+    """
+
+    def _should_be_declarable_constraint(self, node: Require) -> bool:
+        if not is_valid_unique_constraint(node):
+            return False
+        # Currently, we only declare non-structural functional dependencies.
+        fd = normalized_fd(node)
+        assert fd is not None  # already checked by _is_valid_unique_constraint
+        return not fd.is_structural
+
+    def handle_require(self, node: Require, parent: Node):
+        if self._should_be_declarable_constraint(node):
+            return node.reconstruct(
+                node.engine,
+                node.domain,
+                node.checks,
+                node.annotations | [builtins.declare_constraint_annotation]
+            )
+
+        return super().handle_require(node, parent)

relationalai/semantics/lqp/rewrite/extract_keys.py

@@ -249,6 +249,24 @@ class ExtractKeysRewriter(Rewriter):
 
         return f.logical(tuple(outer_body), [])
 
+    def noop_logical(self, node: ir.Logical) -> bool:
+        # logicals that don't hoist variables are essentially filters like lookups
+        if not node.hoisted:
+            return True
+        if len(node.body) != 1:
+            return False
+        inner = node.body[0]
+        if not isinstance(inner, (ir.Match, ir.Union)):
+            return False
+        outer_vars = helpers.hoisted_vars(node.hoisted)
+        inner_vars = helpers.hoisted_vars(inner.hoisted)
+        for v in outer_vars:
+            if v not in inner_vars:
+                return False
+        # all vars hoisted by the outer logical, are also
+        # hoisted by the inner Match/Union
+        return True
+
     # compute inital information that's needed for later steps. E.g., what's nullable or
     # not, do some output columns have a default value, etc.
     def preprocess_logical(self, node: ir.Logical, output_keys: Iterable[ir.Var]):
@@ -264,10 +282,11 @@ class ExtractKeysRewriter(Rewriter):
                 non_nullable_vars.update(vars)
                 top_level_tasks.add(task)
             elif isinstance(task, ir.Logical):
-                # logicals that don't hoist variables are essentially filters like lookups
-                if not task.hoisted:
+                if self.noop_logical(task):
                     top_level_tasks.add(task)
-                    # TODO: should we do something about the inner variables?
+                    non_nullable_vars.update(helpers.hoisted_vars(task.hoisted))
+                    continue
+
                 for h in task.hoisted:
                     # Hoisted vars without a default are not nullable
                     if isinstance(h, ir.Var):

relationalai/semantics/lqp/rewrite/functional_dependencies.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from typing import Optional, Sequence
 from relationalai.semantics.internal import internal
 from relationalai.semantics.metamodel.ir import (
-    Require, Logical, Var, Relation, Lookup, ScalarType
+    Node, Require, Logical, Var, Relation, Lookup, ScalarType
 )
 from relationalai.semantics.metamodel import builtins
 
@@ -130,14 +130,16 @@ def _split_unique_require_node(node: Require) -> Optional[tuple[list[Var], list[
         return None
 
     # collect variables
-    all_vars: set[Var] = set()
+    all_vars: list[Var] = []
     for lookup in guard:
         for arg in lookup.args:
             if not isinstance(arg, Var):
                 return None
-            all_vars.add(arg)
+            if arg in all_vars:
+                continue
+            all_vars.append(arg)
 
-    unique_vars: set[Var] = set()
+    unique_vars: list[Var] = []
     if len(unique_atom.args) != 1:
         return None
     if not isinstance(unique_atom.args[0], (internal.TupleArg, tuple)):
@@ -147,10 +149,12 @@ def _split_unique_require_node(node: Require) -> Optional[tuple[list[Var], list[
     for arg in unique_atom.args[0]:
         if not isinstance(arg, Var):
             return None
-        unique_vars.add(arg)
+        if arg in unique_vars:
+            return None
+        unique_vars.append(arg)
 
     # check that unique vars are a subset of other vars
-    if not unique_vars.issubset(all_vars):
+    if not set(unique_vars).issubset(set(all_vars)):
         return None
 
     return list(all_vars), list(unique_vars), guard
@@ -218,10 +222,10 @@ class FunctionalDependency:
      - `X` and `Y` are disjoint and covering sets of variables used in `φ`
     """
     def __init__(self, guard: Sequence[Lookup], keys: Sequence[Var], values: Sequence[Var]):
-        self.guard = frozenset(guard)
-        self.keys = frozenset(keys)
-        self.values = frozenset(values)
-        assert self.keys.isdisjoint(self.values), "Keys and values must be disjoint"
+        self.guard = tuple(guard)
+        self.keys = tuple(keys)
+        self.values = tuple(values)
+        assert set(self.keys).isdisjoint(set(self.values)), "Keys and values must be disjoint"
 
         # for structural fd check
         self._is_structural:bool = False
@@ -280,3 +284,31 @@ class FunctionalDependency:
             raise ValueError("Functional dependency is not structural")
         assert self._structural_rank is not None
         return self._structural_rank
+
+    def __str__(self) -> str:
+        guard_str = " ∧ ".join([str(atom) for atom in self.guard]).strip()
+        keys_str = ", ".join([str(var) for var in self.keys]).strip()
+        values_str = ", ".join([str(var) for var in self.values]).strip()
+        return f"{guard_str}: {{{keys_str}}} -> {{{values_str}}}"
+
+def contains_only_declarable_constraints(node: Node) -> bool:
+    """
+    Checks whether the input `Logical` node contains only `Require` nodes annotated with
+    `declare_constraint`.
+    """
+    if not isinstance(node, Logical):
+        return False
+    if len(node.body) == 0:
+        return False
+    for task in node.body:
+        if not isinstance(task, Require):
+            return False
+        if not is_declarable_constraint(task):
+            return False
+    return True
+
+def is_declarable_constraint(node: Require) -> bool:
+    """
+    Checks whether the input `Require` node is annotated with `declare_constraint`.
+    """
+    return builtins.declare_constraint_annotation in node.annotations

relationalai/semantics/lqp/rewrite/quantify_vars.py

@@ -5,6 +5,7 @@ from relationalai.semantics.metamodel.compiler import Pass
 from relationalai.semantics.metamodel.visitor import Visitor, Rewriter
 from relationalai.semantics.metamodel.util import OrderedSet, ordered_set
 from typing import Optional, Any, Tuple, Iterable
+from .functional_dependencies import contains_only_declarable_constraints
 
 class QuantifyVars(Pass):
     """
@@ -67,6 +68,7 @@ class VarScopeInfo(Visitor):
     IGNORED_NODES = (ir.Type,
                     ir.Var, ir.Literal, ir.Relation, ir.Field,
                     ir.Default, ir.Output, ir.Update, ir.Aggregate,
+                    ir.Check, ir.Require,
                     ir.Annotation, ir.Rank)
 
     def __init__(self):
@@ -74,6 +76,9 @@ class VarScopeInfo(Visitor):
         self._vars_in_scope = {}
 
     def leave(self, node: ir.Node, parent: Optional[ir.Node]=None):
+        if contains_only_declarable_constraints(node):
+            return node
+
         if isinstance(node, ir.Lookup):
             self._record(node, helpers.vars(node.args))
 
@@ -189,6 +194,9 @@ class FindQuantificationNodes(Visitor):
         self.node_quantifies_vars = {}
 
     def enter(self, node: ir.Node, parent: Optional[ir.Node]=None) -> "Visitor":
+        if contains_only_declarable_constraints(node):
+            return self
+
         if isinstance(node, (ir.Logical, ir.Not)):
             ignored_vars = _ignored_vars(node)
             self._handled_vars.update(ignored_vars)
@@ -202,6 +210,9 @@ class FindQuantificationNodes(Visitor):
         return self
 
     def leave(self, node: ir.Node, parent: Optional[ir.Node]=None) -> ir.Node:
+        if contains_only_declarable_constraints(node):
+            return node
+
         if isinstance(node, (ir.Logical, ir.Not)):
             ignored_vars = _ignored_vars(node)
             self._handled_vars.difference_update(ignored_vars)
@@ -221,6 +232,9 @@ class QuantifyVarsRewriter(Rewriter):
         self.node_quantifies_vars = quant.node_quantifies_vars
 
     def handle_logical(self, node: ir.Logical, parent: ir.Node, ctx:Optional[Any]=None) -> ir.Logical:
+        if contains_only_declarable_constraints(node):
+            return node
+
         new_body = self.walk_list(node.body, node)
 
         if node.id in self.node_quantifies_vars:

relationalai/semantics/lqp/validators.py

@@ -21,6 +21,9 @@ CompilableType = Union[
     # Effects
     ir.Output,
     ir.Update,
+
+    # Constraints
+    ir.Require,
 ]
 
 # Preconditions

relationalai/semantics/metamodel/builtins.py

@@ -524,6 +524,11 @@ recursion_config_annotation = f.annotation(recursion_config, [])
 discharged = f.relation("discharged", [])
 discharged_annotation = f.annotation(discharged, [])
 
+# Require nodes with this annotation will be kept in the final metamodel to be emitted as
+# constraint declarations (LQP)
+declare_constraint = f.relation("declare_constraint", [])
+declare_constraint_annotation = f.annotation(declare_constraint, [])
+
 #
 # Aggregations
 #

relationalai/semantics/metamodel/rewrite/flatten.py

@@ -5,7 +5,7 @@ from typing import Tuple
 
 from relationalai.semantics.metamodel import builtins, ir, factory as f, helpers
 from relationalai.semantics.metamodel.compiler import Pass, group_tasks
-from relationalai.semantics.metamodel.util import OrderedSet, ordered_set, NameCache
+from relationalai.semantics.metamodel.util import NameCache, OrderedSet, ordered_set
 from relationalai.semantics.metamodel import dependency
 from relationalai.semantics.metamodel.typer.typer import to_type
 
@@ -419,9 +419,15 @@ class Flatten(Pass):
     def handle_require(self, req: ir.Require, ctx: Context):
         # only extract the domain if it is a somewhat complex Logical and there's more than
         # one check, otherwise insert it straight into all checks
-        domain = req.domain
-        # only generate logic for not discharged requires
-        if builtins.discharged_annotation not in req.annotations:
+        if builtins.discharged_annotation in req.annotations:
+            # remove discharged Requires
+            return Flatten.HandleResult(None)
+        elif builtins.declare_constraint_annotation in req.annotations:
+            # leave Requires that are declared constraints
+            return Flatten.HandleResult(req)
+        else:
+            # generate logic for remaining requires
+            domain = req.domain
             if len(req.checks) > 1 and isinstance(domain, ir.Logical) and len(domain.body) > 1:
                 body = OrderedSet.from_iterable(domain.body)
                 vars = helpers.hoisted_vars(domain.hoisted)

relationalai/semantics/metamodel/typer/typer.py

@@ -156,6 +156,10 @@ def type_matches(actual:ir.Type, expected:ir.Type, allow_expected_parents=False)
     if actual == types.Any or expected == types.Any:
         return True
 
+    # any entity matches any entity (surprise surprise!)
+    if extends_any_entity(expected) and not is_primitive(actual):
+        return True
+
     # all decimals match across each other
     if types.is_decimal(actual) and types.is_decimal(expected):
         return True
@@ -288,6 +292,15 @@ def is_base_primitive(type:ir.Type) -> bool:
 def is_primitive(type:ir.Type) -> bool:
     return to_base_primitive(type) is not None
 
+def extends_any_entity(type:ir.Type) -> bool:
+    if type == types.AnyEntity:
+        return True
+    if isinstance(type, ir.ScalarType):
+        for parent in type.super_types:
+            if extends_any_entity(parent):
+                return True
+    return False
+
 def invalid_type(type:ir.Type) -> bool:
     if isinstance(type, ir.UnionType):
         # if there are multiple primitives, or a primtive and a non-primitive

relationalai/semantics/metamodel/types.py

@@ -80,6 +80,7 @@ GenericDecimal = ir.ScalarType("GenericDecimal", util.frozen())
 #
 Null = ir.ScalarType("Null", util.frozen())
 Any = ir.ScalarType("Any", util.frozen())
+AnyEntity = ir.ScalarType("AnyEntity", util.frozen())
 Hash = ir.ScalarType("Hash", util.frozen())
 String = ir.ScalarType("String", util.frozen())
 Int64 = ir.ScalarType("Int64")
@@ -144,7 +145,7 @@ def is_null(t: ir.Type) -> bool:
 
 def is_abstract_type(t: ir.Type) -> bool:
     if isinstance(t, ir.ScalarType):
-        return t in [Any, Number, GenericDecimal]
+        return t in [Any, AnyEntity, Number, GenericDecimal]
     elif isinstance(t, ir.ListType):
         return is_abstract_type(t.element_type)
     elif isinstance(t, ir.TupleType):

relationalai/semantics/reasoners/graph/core.py

@@ -20,7 +20,7 @@ from relationalai.semantics import (
     count, sum, avg,
 )
 from relationalai.docutils import include_in_docs
-from relationalai.semantics.internal import annotations
+from relationalai.semantics.internal import annotations, AnyEntity
 from relationalai.semantics.internal import internal as builder_internal # For primitive graph algorithms.
 from relationalai.semantics.std.math import abs, isnan, isinf, maximum, natural_log, sqrt
 from relationalai.semantics.std.integers import int64
@@ -158,7 +158,7 @@ class Graph():
             f"but is a `{type(weighted).__name__}`."
         )
         assert isinstance(model, Model), (
-            "The `model` argument must be a `builder.Model`, "
+            "The `model` argument must be a `relationalai.semantics.Model`, "
             f"but is a `{type(model).__name__}`."
         )
         self.directed = directed
@@ -355,7 +355,7 @@ class Graph():
     @cached_property
     def Node(self) -> Concept:
         """Lazily define and cache the self.Node concept."""
-        _Node = self._user_node_concept or self._model.Concept(self._NodeConceptStr)
+        _Node = self._user_node_concept or self._model.Concept(self._NodeConceptStr, extends=[AnyEntity])
         _Node.annotate(annotations.track("graphs", "Node"))
         return _Node
 
@@ -2304,14 +2304,14 @@ class Graph():
                 # neighbor_a_rel = self._neighbor_of(node_subset_from)
                 #
                 # domain_w = Relationship(f"{{node:{self._NodeConceptStr}}} is the domain of `w` in `common_neighbor(u, v, w)`")
-                # node_x, node_y = graph.Node.ref(), graph.Node.ref()
-                # where(neighbor_a_rel(node_x, node_y)).define(domain_w(node_y))
+                # where(neighbor_a_rel(node_a, node_b)).define(domain_w(node_b))
                 # neighbor_b_rel = self._neighbor_of(domain_w)
                 #
                 # node_constraint = []
                 #
-                # # need to reverse the args of `neighbor_b_rel()`, due to its domain constraint
-                # # relies on the symmetry of `neighbor`
+                # # For this case only, we reverse the args of `neighbor_b_rel()`, which
+                # # is allowed by the symmetry of `neighbor`, in order to take advantage
+                # # of domain constraint on `neighbor_b_rel()`.
                 # where(
                 #     *node_constraint,
                 #     neighbor_a_rel(node_a, neighbor_node),
@@ -2748,15 +2748,15 @@ class Graph():
         if node_subset is None:
             # No constraint - use cached count_inneighbor relationship and all nodes
             count_inneighbor_rel = self._count_inneighbor
-            node_set = self.Node
+            node_constraint = []
         else:
             # Constrained to nodes in the subset - use constrained count_inneighbor relationship
             count_inneighbor_rel = self._count_inneighbor_of(node_subset)
-            node_set = node_subset
+            node_constraint = [node_subset(self.Node)]
 
         # Apply the same indegree logic for both cases
         where(
-            node_set(self.Node),
+            *node_constraint,
             _indegree := where(count_inneighbor_rel(self.Node, Integer)).select(Integer) | 0,
         ).define(_indegree_rel(self.Node, _indegree))
 
@@ -2933,15 +2933,15 @@ class Graph():
         if node_subset is None:
             # No constraint - use cached count_outneighbor relationship and all nodes
             count_outneighbor_rel = self._count_outneighbor
-            node_set = self.Node
+            node_constraint = []
         else:
             # Constrained to nodes in the subset - use constrained count_outneighbor relationship
             count_outneighbor_rel = self._count_outneighbor_of(node_subset)
-            node_set = node_subset
+            node_constraint = [node_subset(self.Node)]
 
         # Apply the same outdegree logic for both cases
         where(
-            node_set(self.Node),
+            *node_constraint,
             _outdegree := where(count_outneighbor_rel(self.Node, Integer)).select(Integer) | 0,
         ).define(_outdegree_rel(self.Node, _outdegree))
 
@@ -3099,12 +3099,12 @@ class Graph():
             node, neighbor, weight = self.Node.ref(), self.Node.ref(), Float.ref()
 
             if node_subset is None:
-                node_constraint = node  # No constraint on nodes.
+                node_constraint = []  # No constraint on nodes.
             else:
-                node_constraint = node_subset(node)  # Nodes constrained to given subset.
+                node_constraint = [node_subset(node)]  # Nodes constrained to given subset.
 
             where(
-                node_constraint,
+                *node_constraint,
                 weighted_degree_no_loops := sum(neighbor, weight).per(node).where(
                     self._weight(node, neighbor, weight),
                     node != neighbor,
@@ -3172,7 +3172,7 @@ class Graph():
         >>> define(n1, n2, n3)
         >>> define(
         ...     Edge.new(src=n1, dst=n2, weight=1.0),
-        ...     Edge.new(src=n2, dst=n1, weight=-1.0),
+        ...     Edge.new(src=n2, dst=n1, weight=0.0),
         ...     Edge.new(src=n2, dst=n3, weight=1.0),
         ... )
         >>>
@@ -3186,7 +3186,7 @@ class Graph():
         ... ).inspect()
         ▰▰▰▰ Setup complete
             id  node_weighted_indegree
-        0   1                    -1.0
+        0   1                     0.0
         1   2                     1.0
         2   3                     1.0
         >>>
@@ -3218,9 +3218,6 @@ class Graph():
         weighted_outdegree
 
         """
-        # TODO: It looks like the weights in the example in the docstring above
-        #   are holdovers from a version of the library that did not disallow
-        #   negative weights. Need to update the example to use only non-negative weights.
         if of is None:
             return self._weighted_indegree
         else:
@@ -3251,20 +3248,15 @@ class Graph():
         # Choose the appropriate node set
         if node_subset is None:
             # No constraint - use all nodes
-            node_set = self.Node
+            node_constraint = []
         else:
             # Constrained to nodes in the subset
-            node_set = node_subset
-        # TODO: In a future cleanup pass, replace `node_set` with a `node_constraint`
-        #   that replaces the `node_set(self.Node)` in the where clause below,
-        #   and generates only `self.Node` (rather than `self.Node(self.Node)`)
-        #   in the `subset is None` case. This applies to a couple other
-        #   degree-of type relations as well.
+            node_constraint = [node_subset(self.Node)]
 
         # Apply the weighted indegree logic for both cases
         src, inweight = self.Node.ref(), Float.ref()
         where(
-            node_set(self.Node),
+            *node_constraint,
             _weighted_indegree := sum(src, inweight).per(self.Node).where(self._weight(src, self.Node, inweight)) | 0.0,
         ).define(_weighted_indegree_rel(self.Node, _weighted_indegree))
 
@@ -3324,7 +3316,7 @@ class Graph():
         >>> define(n1, n2, n3)
         >>> define(
         ...     Edge.new(src=n1, dst=n2, weight=1.0),
-        ...     Edge.new(src=n2, dst=n1, weight=-1.0),
+        ...     Edge.new(src=n2, dst=n1, weight=0.0),
         ...     Edge.new(src=n2, dst=n3, weight=1.0),
         ... )
         >>>
@@ -3339,7 +3331,7 @@ class Graph():
         ▰▰▰▰ Setup complete
             id  node_weighted_outdegree
         0   1                      1.0
-        1   2                      0.0
+        1   2                      1.0
         2   3                      0.0
         >>>
         >>> # 4. Use 'of' parameter to constrain the set of nodes to compute weighted outdegree of
@@ -3355,7 +3347,7 @@ class Graph():
         ▰▰▰▰ Setup complete
             id  node_weighted_outdegree
         0   1                      1.0
-        1   2                      0.0
+        1   2                      1.0
 
         Notes
         -----
@@ -3404,15 +3396,15 @@ class Graph():
         # Choose the appropriate node set
         if node_subset is None:
             # No constraint - use all nodes
-            node_set = self.Node
+            node_constraint = []
         else:
             # Constrained to nodes in the subset
-            node_set = node_subset
+            node_constraint = [node_subset(self.Node)]
 
         # Apply the weighted outdegree logic for both cases
         dst, outweight = self.Node.ref(), Float.ref()
         where(
-            node_set(self.Node),
+            *node_constraint,
             _weighted_outdegree := sum(dst, outweight).per(self.Node).where(self._weight(self.Node, dst, outweight)) | 0.0,
         ).define(_weighted_outdegree_rel(self.Node, _weighted_outdegree))
 
@@ -4537,12 +4529,12 @@ class Graph():
         _triangle_count_rel = self._model.Relationship(f"{{node:{self._NodeConceptStr}}} belongs to {{count:Integer}} triangles")
 
         if node_subset is None:
-            node_constraint = self.Node # No constraint on nodes.
+            node_constraint = [] # No constraint on nodes.
         else:
-            node_constraint = node_subset(self.Node)  # Nodes constrained to given subset.
+            node_constraint = [node_subset(self.Node)]  # Nodes constrained to given subset.
 
         where(
-            node_constraint,
+            *node_constraint,
             _count := self._nonzero_triangle_count_fragment(self.Node) | 0
         ).define(_triangle_count_rel(self.Node, _count))
 
@@ -4819,16 +4811,16 @@ class Graph():
         if node_subset is None:
             degree_no_self_rel = self._degree_no_self
             triangle_count_rel = self._triangle_count
-            node_constraint = node  # No constraint on nodes.
+            node_constraint = []  # No constraint on nodes.
         else:
             degree_no_self_rel = self._degree_no_self_of(node_subset)
             triangle_count_rel = self._triangle_count_of(node_subset)
-            node_constraint = node_subset(node)  # Nodes constrained to given subset.
+            node_constraint = [node_subset(node)]  # Nodes constrained to given subset.
 
         degree_no_self = Integer.ref()
         triangle_count = Integer.ref()
         where(
-            node_constraint,
+            *node_constraint,
             _lcc := where(
                 degree_no_self_rel(node, degree_no_self),
                 triangle_count_rel(node, triangle_count),
@@ -4866,12 +4858,12 @@ class Graph():
         node, neighbor = self.Node.ref(), self.Node.ref()
 
         if node_subset is None:
-            node_constraint = node  # No constraint on nodes.
+            node_constraint = []  # No constraint on nodes.
         else:
-            node_constraint = node_subset(node)  # Nodes constrained to given subset.
+            node_constraint = [node_subset(node)]  # Nodes constrained to given subset.
 
         where(
-            node_constraint,
+            *node_constraint,
             _dns := count(neighbor).per(node).where(self._no_loop_edge(node, neighbor)) | 0,
         ).define(_degree_no_self_rel(node, _dns))
 
@@ -7296,7 +7288,7 @@ class Graph():
 
         # TODO: Optimization opportunity. In some of the cases below
         #   (unweighted in particular), the node_constraint is redundant with
-        #   the constraints baked into the _count_outneigherbor_of and
+        #   the constraints baked into the _count_outneighbor_of and
         #   _outneighbor_of relationships. The join with node_constraint
         #   could be eliminated in those cases. Possibly also relevant to
         #   other domain-constrained relations.
@@ -7366,19 +7358,18 @@ class Graph():
         # Define cosine similarity logic for both weighted and unweighted cases.
         if not self.weighted:
             # Unweighted case: use count of common outneighbors.
-            count_outneighor_u, count_outneighor_v = Integer.ref(), Integer.ref()
+            count_outneighbor_u, count_outneighbor_v = Integer.ref(), Integer.ref()
             common_outneighbor_node = self.Node.ref()
-            score = Float.ref()
 
             where(
                 *node_constraints,
-                count_outneighbor_u_rel(node_u, count_outneighor_u),
-                count_outneighbor_v_rel(node_v, count_outneighor_v),
+                count_outneighbor_u_rel(node_u, count_outneighbor_u),
+                count_outneighbor_v_rel(node_v, count_outneighbor_v),
                 c_common := count(common_outneighbor_node).per(node_u, node_v).where(
                     outneighbor_u_rel(node_u, common_outneighbor_node),
                     outneighbor_v_rel(node_v, common_outneighbor_node),
                 ),
-                score := c_common / sqrt(count_outneighor_u * count_outneighor_v),
+                score := c_common / sqrt(count_outneighbor_u * count_outneighbor_v),
             ).define(
                 _cosine_similarity_rel(node_u, node_v, score)
             )
@@ -8186,13 +8177,13 @@ class Graph():
         neighbor_node = self.Node.ref()
         if node_subset is not None:
             neighbor_rel = self._neighbor_of(node_subset)
-            node_constraint = node_subset(self.Node)
+            node_constraint = [node_subset(self.Node)]
         else:
             neighbor_rel = self._neighbor
-            node_constraint = self.Node
+            node_constraint = []
 
         where(
-            node_constraint,
+            *node_constraint,
             not_(neighbor_rel(self.Node, neighbor_node))
         ).define(_isolated_node_rel(self.Node))
 

relationalai/tools/debugger.py

@@ -3,6 +3,8 @@ import re
 from nicegui import ui
 import json
 
+from relationalai.debugging import DEBUG_LOG_FILE
+
 
 last_mod_time = None
 current_json_objects = []
@@ -141,12 +143,12 @@ def poll():
     global current_json_objects
     # Check the last modification time of the file
     try:
-        mod_time = os.path.getmtime('debug.jsonl')
+        mod_time = os.path.getmtime(DEBUG_LOG_FILE)
         if last_mod_time is None or mod_time > last_mod_time:
             last_mod_time = mod_time
             # File has changed, read and parse the new content
             new_objects = []
-            with open('debug.jsonl', 'r') as file:
+            with open(DEBUG_LOG_FILE, 'r') as file:
                 for line in file:
                     try:
                         # Parse each JSON object and add it to the list