relationalai 0.13.5__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

relationalai/semantics/lqp/builtins.py

@@ -1,213 +0,0 @@
-from typing import TypeGuard
-from relationalai.semantics.metamodel import factory as f, ir, types
-from relationalai.semantics.metamodel.util import FrozenOrderedSet
-from relationalai.semantics.metamodel import builtins
-
-# Indicates a relation is short-lived, thus, backends should not optimize for incremental
-# maintenance.
-adhoc = f.relation("adhoc", [])
-adhoc_annotation = f.annotation(adhoc, [])
-
-# We only want to emit attributes for a known set of annotations.
-supported_lqp_annotations = FrozenOrderedSet([
-    adhoc.name,
-    builtins.function.name,
-    builtins.track.name,
-    builtins.recursion_config.name,
-])
-
-# [LoopyIR] Annotations used to mark metamodel IR elements as Loopy constructs.
-# 1. Programming structures:
-#   * @script marks Sequence blocks `begin ... end`
-#   * @algorithm additionally marks the top-level script
-#   * @while marks Loop as a `while(true) {...}`; its sole Task is a @script @while Sequence
-# 2. Base instructions (Update's with derive Effects)
-#   * @global marks instructions that write to a global relation (only used in top-level script)
-#   * @empty marks instructions that initialize relations to an empty relation
-#   * @assign marks instructions that are standard assignments
-#   * @upsert marks instructions that perform in-place upserts
-#   * @monoid marks instructions that perform in-place monoid updates
-#   * @monus marks instructions that perform in-place monus updates
-
-# These tasks require dedicated handling and currently are only supported in LQP.
-
-# Here we only provide basic inspection functions. Functions for creating these annotations
-# and more complex analysis are in the module relationalai.semantics.lqp.algorithms
-
-# Algorithm: for top-level script of an algorithm
-_algorithm_anno_name = "algorithm"
-algorithm = f.relation(_algorithm_anno_name, [])
-
-def algorithm_annotation():
-    return f.annotation(algorithm, [])
-
-def has_algorithm_annotation(node: ir.Node) -> bool:
-    if not hasattr(node, "annotations"):
-        return False
-    annotations = getattr(node, "annotations", [])
-    for anno in annotations:
-        if anno.relation.name == _algorithm_anno_name:
-            return True
-    return False
-
-# Script: for Sequence blocks (algorithm or while loop)
-_script_anno_name = "script"
-script = f.relation(_script_anno_name, [])
-
-def script_annotation():
-    return f.annotation(script, [])
-
-def has_script_annotation(node: ir.Node) -> bool:
-    if not hasattr(node, "annotations"):
-        return False
-    annotations = getattr(node, "annotations", [])
-    for anno in annotations:
-        if anno.relation.name == _script_anno_name:
-            return True
-    return False
-
-# While: for a while Loop or its script body (Sequence)
-_while_anno_name = "while"
-while_ = f.relation(_while_anno_name, [])
-
-def while_annotation():
-    return f.annotation(while_, [])
-
-def has_while_annotation(node: ir.Node) -> bool:
-    if not hasattr(node, "annotations"):
-        return False
-    annotations = getattr(node, "annotations", [])
-    for anno in annotations:
-        if anno.relation.name == _while_anno_name:
-            return True
-    return False
-
-# Global: marks instructions that write to relation that is the result of an algorithm
-_global_anno_name = "global"
-global_ = f.relation(_global_anno_name, [])
-
-def global_annotation():
-    return f.annotation(global_, [])
-
-def has_global_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
-    if not hasattr(node, "annotations"):
-        return False
-    annotations = getattr(node, "annotations", [])
-    for anno in annotations:
-        if anno.relation.name == _global_anno_name:
-            return True
-    return False
-
-# Empty: Initializes a relation to an empty relation
-_empty_anno_name = "empty"
-empty = f.relation(_empty_anno_name, [])
-
-def empty_annotation():
-    return f.annotation(empty, [])
-
-def has_empty_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
-    if not hasattr(node, "annotations"):
-        return False
-    annotations = getattr(node, "annotations", [])
-    for anno in annotations:
-        if anno.relation.name == _empty_anno_name:
-            return True
-    return False
-
-# Assign: overwrites the target relation
-_assign_anno_name = "assign"
-assign = f.relation(_assign_anno_name, [])
-
-def assign_annotation():
-    return f.annotation(assign, [])
-
-def has_assign_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
-    if not hasattr(node, "annotations"):
-        return False
-    annotations = getattr(node, "annotations", [])
-    for anno in annotations:
-        if anno.relation.name == _assign_anno_name:
-            return True
-    return False
-
-# Upsert: In-place update of relation
-_upsert_anno_name = "upsert"
-upsert = f.relation(_upsert_anno_name, [])
-
-def upsert_annotation(arity: int):
-    return f.annotation(upsert, [f.literal(arity, type=types.Int64)])
-
-def has_upsert_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
-    if not hasattr(node, "annotations"):
-        return False
-    annotations = getattr(node, "annotations", [])
-    for anno in annotations:
-        if anno.relation.name == _upsert_anno_name:
-            return True
-    return False
-
-def get_upsert_annotation(i: ir.Update):
-    for anno in i.annotations:
-        if anno.relation.name == _upsert_anno_name:
-            return anno
-    return None
-
-# Monoid: In-place update of relation by another by a monoid operation (e.g. Integer addition)
-_monoid_anno_name = "monoid"
-monoid = f.relation(_monoid_anno_name, [])
-
-def monoid_annotation(monoid_type: ir.ScalarType, monoid_op: str, arity: int):
-    return f.annotation(monoid, [f.literal(arity, type=types.Int64), monoid_type, f.literal(monoid_op, type=types.String)])
-
-def has_monoid_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
-    if not hasattr(node, "annotations"):
-        return False
-    annotations = getattr(node, "annotations", [])
-    for anno in annotations:
-        if anno.relation.name == _monoid_anno_name:
-            return True
-    return False
-
-def get_monoid_annotation(i: ir.Update):
-    for anno in i.annotations:
-        if anno.relation.name == _monoid_anno_name:
-            return anno
-    return None
-
-# Monus: In-place update of relation by another by "subtraction" operation, if it exists (e.g. Integer subtraction)
-_monus_anno_name = "monus"
-monus = f.relation(_monus_anno_name, [])
-
-def monus_annotation(monoid_type: ir.ScalarType, monoid_op: str, arity: int):
-    return f.annotation(monus, [f.literal(arity, type=types.Int64), monoid_type, f.literal(monoid_op, type=types.String)])
-
-def has_monus_annotation(node: ir.Node) -> TypeGuard[ir.Update]:
-    if not hasattr(node, "annotations"):
-        return False
-    annotations = getattr(node, "annotations", [])
-    for anno in annotations:
-        if anno.relation.name == _monus_anno_name:
-            return True
-    return False
-
-def get_monus_annotation(i: ir.Update):
-    for anno in i.annotations:
-        if anno.relation.name == _monus_anno_name:
-            return anno
-    return None
-
-# Get arity from annotation (for @upsert, @monoid, and @monus)
-def get_arity(i: ir.Annotation):
-    for arg in i.args:
-        if isinstance(arg, ir.Literal) and (arg.type == types.Int64 or arg.type == types.Int128 or arg.type == types.Number):
-            return arg.value
-    assert False, "Failed to get arity"
-
-# All Loopy instructions
-loopy_instructions = [
-    empty,
-    assign,
-    upsert,
-    monoid,
-    monus
-]

relationalai/semantics/lqp/compiler.py

@@ -1,22 +0,0 @@
-#--------------------------------------------------
-# Compiler
-#--------------------------------------------------
-
-from relationalai.semantics.lqp import ir as lqp, model2lqp
-from relationalai.semantics.lqp.utils import TranslationCtx, UniqueNames
-from relationalai.semantics.lqp.passes import lqp_passes
-from relationalai.semantics.metamodel import ir, compiler as c
-
-from typing import Optional
-
-class Compiler(c.Compiler):
-    def __init__(self):
-        super().__init__(lqp_passes())
-        self.def_names = UniqueNames()
-
-    def do_compile(self, model: ir.Model, options:dict={}) -> tuple[Optional[tuple], lqp.Epoch]:
-        fragment_id: bytes = options.get("fragment_id", bytes(404))
-        # Reset the var context for each compilation
-        # TODO: Change to unique var names per lookup
-        # TODO: Have our needs realigned with NameCache?
-        return model2lqp.to_lqp(model, fragment_id, TranslationCtx(self.def_names))

relationalai/semantics/lqp/constructors.py

@@ -1,68 +0,0 @@
-from typing import Tuple
-from relationalai.semantics.lqp import ir as lqp
-
-def mk_and(args: list[lqp.Formula]) -> lqp.Formula:
-    # Flatten nested conjunctions
-    if any(isinstance(arg, lqp.Conjunction) for arg in args):
-        final_args = []
-        for arg in args:
-            if isinstance(arg, lqp.Conjunction):
-                final_args.extend(arg.args)
-            else:
-                final_args.append(arg)
-        args = final_args
-
-    if len(args) == 1:
-        return args[0]
-
-    return lqp.Conjunction(args=args, meta=None)
-
-def mk_or(args: list[lqp.Formula]) -> lqp.Formula:
-    # Flatten nested disjunctions
-    if any(isinstance(arg, lqp.Disjunction) for arg in args):
-        final_args = []
-        for arg in args:
-            if isinstance(arg, lqp.Disjunction):
-                final_args.extend(arg.args)
-            else:
-                final_args.append(arg)
-        args = final_args
-
-    if len(args) == 1:
-        return args[0]
-
-    return lqp.Disjunction(args=args, meta=None)
-
-def mk_abstraction(vars: list[Tuple[lqp.Var, lqp.Type]], value: lqp.Formula) -> lqp.Abstraction:
-    return lqp.Abstraction(vars=vars, value=value, meta=None)
-
-def mk_exists(vars: list[Tuple[lqp.Var, lqp.Type]], value: lqp.Formula) -> lqp.Formula:
-    if len(vars) == 0:
-        return value
-    abstr = mk_abstraction(vars, value)
-    return lqp.Exists(body=abstr, meta=None)
-
-def mk_specialized_value(value) -> lqp.SpecializedValue:
-    return lqp.SpecializedValue(value=value, meta=None)
-
-def mk_value(value) -> lqp.Value:
-    return lqp.Value(value=value, meta=None)
-
-def mk_type(typename: lqp.TypeName, parameters: list[lqp.Value]=[]) -> lqp.Type:
-    return lqp.Type(type_name=typename, parameters=parameters, meta=None)
-
-def mk_primitive(name: str, terms: list[lqp.RelTerm]) -> lqp.Primitive:
-    return lqp.Primitive(name=name, terms=terms, meta=None)
-
-def mk_pragma(name: str, terms: list[lqp.Var]) -> lqp.Pragma:
-    return lqp.Pragma(name=name, terms=terms, meta=None)
-
-def mk_attribute(name: str, args: list[lqp.Value]) -> lqp.Attribute:
-    return lqp.Attribute(name=name, args=args, meta=None)
-
-def mk_transaction(
-    epochs: list[lqp.Epoch],
-    configure: lqp.Configure = lqp.construct_configure({}, None),
-    sync = None
-) -> lqp.Transaction:
-    return lqp.Transaction(epochs=epochs, configure=configure, sync=sync, meta=None)