relationalai 1.0.0a3__py3-none-any.whl → 1.0.0a5__py3-none-any.whl

relationalai/semantics/__init__.py

@@ -91,14 +91,10 @@ def distinct(*args:Value):
     model = _check_model()
     return model.distinct(*args)
 
-def not_(*args:Value):
+def not_(*args:Statement):
     model = _check_model()
     return model.not_(*args)
 
-def literal(value, type: Concept|None = None) -> Literal:
-    model = _check_model()
-    return Literal(value, model, type)
-
 #------------------------------------------------------
 # Convenience types
 #------------------------------------------------------
@@ -120,13 +116,14 @@ Date = core.Date
 DateTime = core.DateTime
 # RawSource = core.RawSource
 # Hash = core.Hash
+Error = core.Error
 
 #------------------------------------------------------
 # Convenience aggregates
 # NOTE: these should be deprecated
 #------------------------------------------------------
-
-from .std import aggregates as aggs
+# Import after convenience functions are defined to avoid circular imports
+from .std import aggregates as aggs  # noqa: E402
 
 rank = aggs.rank
 limit = aggs.limit
@@ -147,7 +144,12 @@ per = aggs.per
 __all__ = [
     "Alias", "CoreLibrary", "Concept", "Data", "Distinct", "Expression", "Field", "FieldRef", "Fragment",
     "Library", "Literal", "Match", "Model", "New", "Not", "Chain", "Property", "Reading", "Relationship",
-    "Table", "Union", "Value", "Variable", "core",
+    "Table", "Union", "Value", "Variable", "core", "Error",
+    "Any", "AnyEntity", "TypeVar", "EntityTypeVar",
+    "Number", "String", "Integer", "Int", "Int64", "Int128", "Float", "Decimal", "Bool", "Boolean", "Date", "DateTime",
+
+    "rank", "limit", "asc", "desc",
+    "count", "sum", "min", "max", "avg", "string_join", "per",
 
     "select", "define", "where", "require", "union", "data", "not_",
 ]

relationalai/semantics/backends/sql/sql_compiler.py

@@ -1,15 +1,12 @@
 from __future__ import annotations
 from collections import deque
 from dataclasses import dataclass, field
-from sqlglot import exp, select
 
 from ....util.structures import OrderedSet
 from ...metamodel.metamodel import Aggregate, Logical, Lookup, Model, Node, Relation, Task, Update, Var, Value
-from ...metamodel.pprint import pprint as mmpp
 from ...metamodel.rewriter import Rewriter, Walker
 from ...metamodel.metamodel_analyzer import Analyzer as MMAnalyzer
 
-from rich import print as rp
 
 #------------------------------------------------------
 # Simple flatten
@@ -286,8 +283,8 @@ class SQLCompiler:
                 analysis.analyze(rule)
 
         analysis.construct_sccs()
-        sccs = analysis.sccs
 
+        # sccs = analysis.sccs
         # print("\nStrongly Connected Components:")
         # for i, scc in enumerate(sccs, start=1):
         #     tag = f" (recursive {scc.strategy(analysis)})" if scc.recursive else ""

relationalai/semantics/experimental/builder.py

@@ -0,0 +1,295 @@
+from typing import Any, Union, TypeAlias
+from contextlib import contextmanager
+from contextvars import ContextVar
+from relationalai.semantics.frontend.base import Statement, Relationship, Model, Concept
+
+__all__ = [
+    "procedure", "loop",
+    "ProcedureBuilder", "LoopBuilder", "Instruction",
+    "OrMonoid", "Monoid"
+]
+
+#------------------------------------------------------
+# Monoid Types (only Boolean monoid supported at the moment)
+#------------------------------------------------------
+
+class Monoid():
+    pass
+
+class OrMonoid(Monoid):
+    pass
+
+#------------------------------------------------------
+# Instruction Types (tagged tuples or LoopBuilder)
+#------------------------------------------------------
+
+# Instructions are tagged tuples:
+#   ("assign", expr)                - define a relation
+#   ("empty", relationship)         - initialize relation to empty
+#   ("upsert", arity, expr)         - upsert with arity (number of keys)
+#   ("monoid", arity, monoid, expr) - monoid add with arity (number of keys)
+#   ("monus", arity, monoid, expr)  - monus delete with arity (number of keys)
+#   ("break", conditions)           - break condition (tuple of conditions, treated as conjunction)
+#   ("loop", LoopBuilder)           - a loop. could be over a relation (for-loop) or empty (while-loop)
+
+Instruction: TypeAlias = tuple[str, Any] | tuple[str, int, Any] | tuple[str, int, Monoid, Any]
+
+#------------------------------------------------------
+# Context Variables for tracking current builder
+#------------------------------------------------------
+
+# The current instruction container (ProcedureBuilder or LoopBuilder)
+_current_container: ContextVar[Union["ProcedureBuilder", "LoopBuilder", None]] = ContextVar(
+    'current_container', default=None
+)
+
+def _register_instruction(instr: Instruction) -> None:
+    """Register an instruction with the current container if in context."""
+    container = _current_container.get()
+    if container is None: 
+        raise RuntimeError("Instructions can only be used inside an procedure")
+    elif isinstance(container, ProcedureBuilder) or isinstance(container, LoopBuilder):
+        container._instructions.append(instr)
+
+#------------------------------------------------------
+# InstructionContext helper class
+#------------------------------------------------------
+
+class InstructionContext:
+    """Represents the context behind instructions that behave like insert/deletes."""
+
+    def __init__(self, arity: int | None = None, monoid=None):
+        self.arity = arity
+        self._monoid = monoid 
+
+    def with_arity(self, arity: int):
+        assert self.arity is None, "Cannot redefine arity of an instruction"
+        return InstructionContext(arity=arity, monoid=self._monoid)
+
+    def with_monoid(self, monoid: Monoid):
+        assert self._monoid is None, "Cannot redefine monoid of an instruction"
+        return InstructionContext(arity=self.arity, monoid=monoid)
+
+    def upsert(self, expr: Statement) -> Instruction:
+        assert self.arity is not None, "Upsert must have an integer arity. Use `with_arity(x).upsert(...)`"
+        instr: Instruction = ("upsert", self.arity, expr)
+        _register_instruction(instr)
+        return instr
+
+    def monoid(self, expr: Statement) -> Instruction:
+        assert self.arity is not None, "Monoid must have an integer arity. Use `with_arity(x).monoid(...)`"
+        assert self._monoid is not None, "Monoid must have a monoid. Use `with_monoid(x).monoid(...)`"
+        instr: Instruction = ("monoid", self.arity, self._monoid, expr)
+        _register_instruction(instr)
+        return instr
+
+    def monus(self, expr: Statement) -> Instruction:
+        assert self.arity is not None, "Monus must have an integer arity. Use `with_arity(x).monus(...)`"
+        assert self._monoid is not None, "Monus must have a monoid. Use `with_monoid(x).monus(...)`"
+        instr: Instruction = ("monus", self.arity, self._monoid, expr)
+        _register_instruction(instr)
+        return instr
+
+#------------------------------------------------------
+# LoopBuilder
+#------------------------------------------------------
+
+class LoopBuilder:
+    """Represents a loop in the engine."""
+
+    def __init__(self, over: list[Union[Concept, Relationship]] = []):
+        # TODO: Currently looping over things is not supported.
+        self._over = over
+        self._instructions: list[Instruction] = []
+
+    def __str__(self):
+        return self._format(indent=0)
+
+    def _format(self, indent: int = 0) -> str:
+        prefix = "  " * indent
+        lines = [f"{prefix}Loop:"]
+        for instr in self._instructions:
+            lines.append(self._format_instruction(instr, indent + 1))
+        return "\n".join(lines)
+
+    def _format_instruction(self, instr: Instruction, indent: int) -> str:
+        prefix = "  " * indent
+        if isinstance(instr, LoopBuilder):
+            return instr._format(indent)
+        tag = instr[0]
+        if tag == "assign":
+            return f"{prefix}@assign {instr[1]}"
+        elif tag == "empty":
+            return f"{prefix}@empty {instr[1]}"
+        elif tag == "upsert":
+            return f"{prefix}@upsert:{instr[1]} {instr[2]}"  # type: ignore[index]
+        elif tag == "monoid":
+            return f"{prefix}@monoid:{instr[1]}:{instr[2]} {instr[3]}"  # type: ignore[index]
+        elif tag == "monus":
+            return f"{prefix}@monus:{instr[1]}:{instr[2]} {instr[3]}"  # type: ignore[index]
+        elif tag == "break":
+            return f"{prefix}@break {instr[1]}"
+        else:
+            return f"{prefix}{instr}"
+
+#------------------------------------------------------
+# ProcedureBuilder
+#------------------------------------------------------
+
+class ProcedureBuilder:
+    """Builds an imperative procedure with global relationships and instructions.
+
+    An ProcedureBuilder represents a complete procedure containing:
+    - Global relationships (loop heads)
+    - A sequence of instructions (assign, empty, upsert, break, or loops)
+    """
+
+    def __init__(self, model: Model, *globals: Relationship):
+        self._model = model
+        self._globals: tuple[Relationship, ...] = globals
+        self._instructions: list[Instruction] = []
+
+    def assign(self, expr: Statement) -> Instruction:
+        instr: Instruction = ("assign", expr)
+        _register_instruction(instr)
+        return instr
+
+    def empty(self, relationship: Relationship) -> Instruction:
+        instr: Instruction = ("empty", relationship)
+        _register_instruction(instr)
+        return instr
+
+    def break_if(self, *conditions: Statement) -> Instruction:
+        instr: Instruction = ("break", conditions)
+        _register_instruction(instr)
+        return instr
+
+    def with_arity(self, arity: int) -> InstructionContext:
+        return InstructionContext(arity=arity)
+
+    def with_monoid(self, monoid: Monoid) -> InstructionContext:
+        return InstructionContext(monoid=monoid)
+
+    def loop(self, over: list[Union[Concept, Relationship]] = []):
+        return loop(over)
+
+    def __str__(self):
+        lines = ["Procedure:"]
+
+        # Print globals
+        if self._globals:
+            lines.append("  Globals:")
+            for rel in self._globals:
+                lines.append(f"    {rel}")
+
+        # Print instructions
+        if self._instructions:
+            lines.append("  Instructions:")
+            for instr in self._instructions:
+                lines.append(self._format_instruction(instr, indent=2))
+
+        return "\n".join(lines)
+
+    def _format_instruction(self, instr: Instruction, indent: int) -> str:
+        prefix = "  " * indent
+        if isinstance(instr, LoopBuilder):
+            return instr._format(indent)
+        tag = instr[0]
+        if tag == "assign":
+            return f"{prefix}@assign {instr[1]}"
+        elif tag == "empty":
+            return f"{prefix}@empty {instr[1]}"
+        elif tag == "upsert":
+            return f"{prefix}@upsert:{instr[1]} {instr[2]}"  # type: ignore[index]
+        elif tag == "monoid":
+            return f"{prefix}@monoid:{instr[1]}:{instr[2]} {instr[3]}"  # type: ignore[index]
+        elif tag == "monus":
+            return f"{prefix}@monus:{instr[1]}:{instr[2]} {instr[3]}"  # type: ignore[index]
+        elif tag == "break":
+            return f"{prefix}@break {instr[1]}"
+        elif tag == "loop":
+            return f"{prefix}@loop {instr[1]}"
+        else:
+            return f"{prefix}{instr}"
+
+#------------------------------------------------------
+# Context Managers
+#------------------------------------------------------
+
+@contextmanager
+def procedure(*globals: Relationship, model: Model | None = None):
+    """Context manager for defining an procedure with global relationships.
+
+    Usage:
+        with procedure(Reachable, Frontier):
+            assign(...)
+            empty(...)
+            with loop():
+                upsert(...)
+                break_if(...)
+
+    Parameters
+    ----------
+    *globals : Relationship
+        Relationships that are modified by the procedure. Important to specify for compilation.
+
+    Yields
+    ------
+    ProcedureBuilder
+        The procedure builder (can be used to access the built structure).
+    """
+    from .. import _check_model
+    model = _check_model() if model is None else model
+    builder = ProcedureBuilder(model, *globals)
+
+    model._procedure_fragment(builder)
+
+    token = _current_container.set(builder)
+    try:
+        yield builder
+    finally:
+        _current_container.reset(token)
+
+
+@contextmanager
+def loop(over: list[Union[Concept, Relationship]] = []):
+    """Context manager for defining a loop within an procedure.
+
+    Usage:
+        with procedure(...):
+            with loop():
+                # instructions inside the loop (while-loop)
+                assign(...)
+                break_if(...)
+
+        with procedure(...):
+            with loop(over=SomeRelation):
+                # instructions inside the loop (for-loop over relation)
+                ...
+
+    Can be nested for inner loops:
+        with procedure(...):
+            with loop():
+                with loop():
+                    # nested loop
+                    ...
+
+    Parameters
+    ----------
+    over : optional
+        Relationship to iterate over (for-loop). If None, creates a while-loop.
+    """
+    parent = _current_container.get()
+    if parent is None:
+        raise RuntimeError("loop() must be used inside procedure() or another loop()")
+
+    loop_builder = LoopBuilder(over=over)
+    instr: Instruction = ("loop", loop_builder)
+    # Register this loop as an instruction in the parent container
+    parent._instructions.append(instr)
+
+    token = _current_container.set(loop_builder)
+    try:
+        yield loop_builder
+    finally:
+        _current_container.reset(token)

relationalai/semantics/experimental/builtins.py

@@ -0,0 +1,154 @@
+from relationalai.semantics.metamodel import Relation, Annotation, Update, Node, Literal, Sequence, Loop
+from relationalai.semantics.metamodel.builtins import builtins as bt
+from relationalai.semantics.experimental.builder import Monoid, OrMonoid
+from relationalai.semantics.metamodel.rewriter import Rewriter
+
+__all__ = [
+    "LoopyInstructionAdder", "LoopyGlobalAdder",
+    "init_relation", "init_annotation", "mk_init",
+    "global_relation", "global_annotation", "mk_global",
+    "assign_relation", "assign_annotation", "mk_assign",
+    "upsert_relation", "upsert_annotation", "mk_upsert",
+    "monoid_relation", "monoid_annotation", "mk_monoid",
+    "monus_relation", "monus_annotation", "mk_monus",
+    "algorithm_relation", "algorithm_annotation", "mk_algorithm",
+    "script_relation", "script_annotation", "mk_script",
+    "while_relation", "while_annotation", "mk_while",
+]
+
+# Loopy annotations
+
+# LoopyIR annotation rewriters
+class LoopyInstructionAdder(Rewriter):
+    def __init__(self, anno: Annotation):
+        self.anno = anno
+        super().__init__()
+
+    def apply_update(self, node: Node):
+        return self(node)
+
+    def update(self, node: Update):
+        new_annos = tuple(node.annotations) + (self.anno,)
+        return node.mut(annotations=new_annos)
+
+class LoopyGlobalAdder(Rewriter):
+    def __init__(self, globals: list[Relation]):
+        self.globals = globals
+        super().__init__()
+
+    def apply_update(self, node: Node):
+        return self(node)
+
+    def update(self, node: Update):
+        if node.relation in self.globals:
+            new_annos = tuple(node.annotations) + (global_annotation(),)
+            return node.mut(annotations=new_annos)
+        else:
+            return node
+
+# Init
+
+init_relation = Relation("init")
+def init_annotation():
+    return Annotation(relation=init_relation)
+
+def mk_init(i: Node):
+    return LoopyInstructionAdder(init_annotation()).apply_update(i)
+
+# Empty
+
+empty_relation = Relation("empty")
+def empty_annotation():
+    return Annotation(relation=empty_relation)
+
+def mk_empty(i: Node):
+    return LoopyInstructionAdder(empty_annotation()).apply_update(i)
+
+# Global
+
+global_relation = Relation("global")
+def global_annotation():
+    return Annotation(relation=global_relation)
+
+def mk_global(globals: list[Relation], i: Node):
+    return LoopyGlobalAdder(globals).apply_update(i)
+
+# Assign
+
+assign_relation = Relation("assign")
+def assign_annotation():
+    return Annotation(assign_relation)
+
+def mk_assign(i: Node):
+    return LoopyInstructionAdder(assign_annotation()).apply_update(i)
+
+# Upsert
+
+upsert_relation = Relation("upsert")
+def upsert_annotation(arity: int):
+    arity_val = Literal(bt.core.Integer, arity)
+    return Annotation(relation=upsert_relation, args=(arity_val,))
+
+def mk_upsert(i: Node, arity: int):
+    return LoopyInstructionAdder(upsert_annotation(arity)).apply_update(i)
+
+# Monoid conversion (in prep for monoid and monus instructions)
+
+def convert_monoid(monoid: Monoid):
+    if isinstance(monoid, OrMonoid):
+        return (bt.core.Boolean, Literal(bt.core.String, "or"))
+    else:
+        raise RuntimeError("Only OrMonoid supported for now")
+
+# Monoid
+
+monoid_relation = Relation("monoid")
+def monoid_annotation(arity: int, monoid: Monoid):
+    arity_val = Literal(bt.core.Integer, arity)
+    monoid_type, monoid_op = convert_monoid(monoid)
+    return Annotation(relation=monoid_relation, args=(arity_val, monoid_type, monoid_op))
+
+def mk_monoid(i: Node, arity: int, monoid: Monoid):
+    return LoopyInstructionAdder(monoid_annotation(arity, monoid)).apply_update(i)
+
+# Monus
+
+monus_relation = Relation("monus")
+def monus_annotation(arity: int, monoid: Monoid):
+    arity_val = Literal(bt.core.Integer, arity)
+    monoid_type, monoid_op = convert_monoid(monoid)
+    return Annotation(relation=monus_relation, args=(arity_val, monoid_type, monoid_op))
+
+def mk_monus(i: Node, arity: int, monoid: Monoid):
+    return LoopyInstructionAdder(monus_annotation(arity, monoid)).apply_update(i)
+
+# Algorithm
+
+algorithm_relation = Relation("algorithm", ())
+def algorithm_annotation():
+    return Annotation(relation=algorithm_relation)
+
+def mk_algorithm(s: Sequence):
+    new_annos = tuple(s.annotations) + (algorithm_annotation(),)
+    return s.mut(annotations=new_annos)
+
+# Script
+
+script_relation = Relation("script", ())
+def script_annotation():
+    return Annotation(relation=script_relation)
+
+def mk_script(s: Sequence):
+    new_annos = tuple(s.annotations) + (script_annotation(),)
+    return s.mut(annotations=new_annos)
+
+# While
+
+while_relation = Relation("while", ())
+def while_annotation():
+    return Annotation(relation=while_relation)
+
+def mk_while(s: Sequence | Loop):
+    new_annos = tuple(s.annotations) + (while_annotation(),)
+    return s.mut(annotations=new_annos)
+