relationalai 0.13.0.dev0__py3-none-any.whl → 0.13.2__py3-none-any.whl

relationalai/early_access/dsl/core/relations.py

@@ -0,0 +1,276 @@
+from abc import abstractmethod
+
+from relationalai.early_access.dsl.core.exprs import contextStack
+from relationalai.early_access.dsl.core.namespaces import Namespace
+from relationalai.early_access.dsl.core.rules import Rule
+from relationalai.early_access.dsl.core.utils import camel_to_snake
+
+
+def addrule(rul): return contextStack.root_context().addrule(rul)
+
+
+# A @rule decorator that can be used to register a rule, optionally with one or more
+# annotations.
+#
+# Examples:
+#   @rule(Annotation.INNER_LOOP_NON_STRATIFIED, ...)
+#   def my_rule():
+#       ...
+#
+#   @rule()
+#   def my_other_rule():
+#       ...
+def rule(*annotations):
+    def decorator(func):
+        rule_instance = addrule(func)
+        for annotation in annotations:
+            rule_instance.annotate(annotation)
+        return func
+
+    return decorator
+
+
+class AbstractRelation:
+    class NullContainer:
+        def name(self): return ""
+
+        def entity(self): return False
+
+    # A Relation can serve as a context for declaring rules that
+    # populate that relation and also for declaring constraints
+    # that pertain only to this single relation -- e.g., functional
+    # and mandatory constraints.
+    #
+    def __enter__(self):
+        contextStack.push(self)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        contextStack.pop()
+        pass
+
+    # A Relation can be "invoked" in the body of a rule definition to
+    # declare what will be an Atom in the Schema generated by the rule
+    # def.
+    #
+    # Note that because Schemas expect these Atoms to be defined on
+    # RelationComponents, we have to make sure that such a component
+    # exists in the Schema in context.
+    #
+    def __call__(self, *args):
+        context = contextStack.root_context()
+        if context is not None:
+            return context.build_atom(self, args)
+        return None
+
+    def __init__(self, namespace, name, sig):
+        self._relname = name
+        self._container = namespace
+        self._signature = sig
+        self._rules = []
+
+    # The "rule" to add is a function object with a number of parameters that should
+    # equal the number of roles in this Relation.
+    #
+    def addrule(self, rule):
+        if not isinstance(rule, Rule):
+            # Assume that rule is a Python function that, when invoked can build a rule
+            rule = Rule(self).elaborate(rule)
+
+        self._rules.append(rule)
+        return rule
+
+    def rules(self):
+        return self._rules
+
+    def arity(self):
+        return self._signature.arity()
+
+    def binary(self) -> bool:
+        return self.arity() == 2
+
+    def display(self):
+        return self.qualified_name()
+
+    def entityid(self):
+        return hash(self.qualified_name())
+
+    # Generates a new Rule that populates this relation, returning a tuple whose
+    # first component is the Rule object and whose next n-1 components are the
+    # free variables of this rule in order. Allows one to construct new rules that
+    # populate a relation and get a handle on all free variables individually using
+    # one method call, e.g.:
+    #
+    #   (rule, x, y, z) = relation.genrule()
+    #
+    def genrule(self):
+        rule = Rule(self)
+        self._rules.append(rule)
+        tup = [rule]
+        for v in rule.freevars():
+            tup.append(v)
+        return tuple(tup)
+
+    def pprint(self):
+        return self.display() + self._signature.display()
+
+    # Returns the fully-qualified name that will be used in queries to
+    # refer to this Relation.
+    #
+    def qualified_name(self):
+        if not isinstance(self._container, Namespace):
+            raise Exception(f"Cannot find containing namespace for Relation named {self._relname}")
+
+        if self._container == Namespace.top:
+            return self._relname
+        else:
+            # TODO: [VAMI] We changed `::` to `__` to spead up E2E testing. We should change it back to `::` before release.
+            return f"{self._container.qualified_name()}__{self._relname}"
+
+    def signature(self):
+        return self._signature
+
+    def rel_name(self):
+        return self._relname
+
+    def first(self):
+        return self._signature.first()
+
+class Relation(AbstractRelation):
+
+    def __init__(self, namespace, reading, relationship, functional=False):
+        super().__init__(namespace, reading.to_rel_name(),
+                         RelationSignature(*reading.types(), functional=functional))
+        self._reading = reading
+        self._relationship = relationship
+
+    def __getattr__(self, item):
+        if item in self.__dict__:
+            return self.__dict__[item]
+        return self._relationship.role_by_name(item)
+
+    def reading(self):
+        return self._reading
+
+    def relationship(self):
+        return self._relationship
+
+class AssertedRelation(AbstractRelation):
+    """
+    A relation that's assumed to be defined in the target system, but cannot be verified.
+
+    This is used as a common parent class for such relations, and the compiler makes sure to
+    not generate any unnecessary constructs for them.
+    """
+    def __init__(self, namespace, name, sig):
+        super().__init__(namespace, name, sig)
+
+class ExternalRelation(AssertedRelation):
+
+    def __init__(self, namespace, name, sig):
+        super().__init__(namespace, name, sig)
+
+class ExportRelation(AssertedRelation):
+
+    def __init__(self, namespace, name, sig):
+        super().__init__(namespace, name, sig)
+
+class EntityPopulationRelation(AbstractRelation):
+
+    def __init__(self, namespace, name, sig):
+        super().__init__(namespace, name, sig)
+
+class EntityInstanceRelation(AbstractRelation):
+
+    def __init__(self, namespace, name, sig):
+        type = sig.first()
+        # Instance relations are in type's namespace
+        type_namespace = Namespace(camel_to_snake(type.display()), namespace)
+        super().__init__(type_namespace, name, sig)
+
+class AbstractRelationSignature:
+
+    def __init__(self, *types):
+        self._types = types
+
+    def __call__(self, *args, **kwargs):
+        seq = [self]
+        for i in range(len(args)):
+            seq.append(args[i])
+        context = contextStack.root_context()
+        if context is not None:
+            return context.build_relation_variable(seq, kwargs)
+        return None
+
+    def arity(self):
+        return len(self._types)
+
+    def entityid(self):
+        relhash = hash([r.entityid() for r in self._types])
+        if self.functional():
+            return hash((relhash, True))
+        else:
+            return hash((relhash, False))
+
+    def relational(self) -> bool:
+        return True
+
+    # An n-ary AbstractRelationSignature is functional if its n-th column
+    # is functionally dependent on the first n-1 columns.
+    #
+    @abstractmethod
+    def functional(self) -> bool:
+        """Return True when relation is functional otherwise False."""
+
+    def domainsig(self):
+        if self.functional():
+            a = self.arity()
+            return self._types[0:a - 1]
+        else:
+            return self._types
+
+    def rangesig(self):
+        if self.functional():
+            return self._types[self.arity() - 1]
+        else:
+            return None
+
+    def types(self):
+        return self._types
+
+    def display(self):
+        dsp = [r.display() for r in self.domainsig() if r is not None]
+        dom = "(" + ", ".join(dsp) + ")"
+        range_sig = self.rangesig()
+        if range_sig is not None:
+            return f"{dom} -> {range_sig.display()}"
+        else:
+            return dom
+
+    # An AbstractRelationSignature is a subtype of another if the two have the
+    # same number of types and in each corresponding type pair (t1, t2),
+    # the type that plays t1 is a subtype of the type that plays t2.
+    #
+    def subtype_of(self, sig2):
+        if self.arity() != sig2.arity():
+            return False
+
+        for i in range(self.arity()):
+            if not self._types[i].subtype_of(sig2._types[i]):
+                return False
+
+        return True
+
+    def first(self):
+        return self._types[0]
+
+class RelationSignature(AbstractRelationSignature):
+
+    def __init__(self, *types, functional=False):
+        super().__init__(*types)
+        self._is_functional = functional
+
+    def set_functional(self, functional: bool) -> None:
+        self._is_functional = functional
+
+    def functional(self): return self._is_functional

relationalai/early_access/dsl/core/rules.py

@@ -0,0 +1,112 @@
+from enum import Enum
+
+from relationalai.early_access.dsl.core import tempvar
+from relationalai.early_access.dsl.core.builders.logic import LogicBuilder
+from relationalai.early_access.dsl.core.exprs import contextStack
+from relationalai.early_access.dsl.core.exprs.scalar import ScalarExprBuilder
+from relationalai.early_access.dsl.core.logic import LogicFragment, RelVariable
+from relationalai.early_access.dsl.core.logic.exists import ExistentialConstraint
+from relationalai.early_access.dsl.core.types import Type
+
+
+class Annotation(Enum):
+    FUNCTION = 1
+    INLINE = 2
+    ITER = 3
+    INNER_LOOP = 4
+    INNER_LOOP_NON_STRATIFIED = 5
+    FORCE_DNF = 6
+
+    def display(self):
+        return f"@{self}"
+
+    def __str__(self):
+        return self.name.lower()
+
+
+class Rule(LogicFragment, ScalarExprBuilder):
+
+    def __enter__(self):
+        contextStack.push(self)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        contextStack.pop()
+
+    # Partially construct this Rule by creating a head atom and an array of free variables
+    # from a Relation (rel)
+    #
+    def __init__(self, rel):
+        LogicFragment.__init__(self)
+        fvars = []
+        for i in range(rel._signature.arity()):
+            type = rel._signature._types[i]
+            var = self.build_scalar_variable([type, tempvar(i)], {})
+            fvars.append(var)
+
+        self.head = LogicBuilder.build_atom(self, rel, fvars)
+        self._populates = rel
+        self._freevars = fvars
+        self._annotations = []
+
+    def annotate(self, a):
+        self._annotations.append(a)
+        return self
+
+    # Elaborates the body of this rule by invoking a Python function that, when
+    # supplied with the array of free variables declared by this rule will populate
+    # the conjuncts that make up the body of the rule.
+    #
+    def elaborate(self, func):
+        with self.genexists(): # type: ignore
+            func(*(self.freevars()))
+        return self
+
+    def genexists(self):
+        x = ExistentialConstraint.build_existential()
+        self._existentials[id(x)] = x
+        return x
+
+    def freevars(self):
+        return tuple(self._freevars)
+
+    def populates(self): return self._populates
+
+    def pprint(self):
+        annotations = "\n".join([a.display() for a in self._annotations])
+        head = self.head.pprint()
+        body = self.rel_formula()
+        rule = f"def {head}:\n{body}"
+        if annotations != "":
+            return annotations + "\n" + rule
+        else:
+            return rule
+
+    # Returns a new Rule that duplicates self after mapping every
+    # Relation referred to by an atom through relmap
+    #
+    def map(self, relmap):
+        newrel = relmap[self.populates().entityid()]
+        r = Rule(newrel)
+        r._sconstraints = self._sconstraints
+        r._atoms = {}
+        for a in self._atoms:
+            newatom = a.map(relmap)
+            r._atoms[newatom.entityid()] = newatom
+        r._existentials = {}
+        for e in self._existentials.values():
+            ext = e.map(relmap)
+            r._existentials[ext.entityid()] = ext
+        return r
+
+def Vars(*args: Type):
+    vars = []
+    size = contextStack.size()
+    for i, t in enumerate(args):
+        if isinstance(t, RelVariable):
+            vars.append(t)
+        else:
+            vars.append(t(f'_x{i}_{size}'))
+    if len(vars) == 1:
+        return vars[0]
+    return tuple(vars)

relationalai/early_access/dsl/core/std/__init__.py

@@ -0,0 +1,45 @@
+from relationalai.early_access.dsl.core.namespaces import Namespace
+from relationalai.early_access.dsl.core.relations import RelationSignature, ExternalRelation
+from relationalai.early_access.dsl.core.types import Type
+from relationalai.early_access.dsl.core.types.standard import DateTime, Date, PositiveInteger, Decimal, String, Symbol, \
+    Any, Integer
+
+#=
+# StdLib.
+#=
+
+standard_relations = {}
+
+parse_date_name = "parse_date"
+parse_date = ExternalRelation(Namespace.top, parse_date_name, RelationSignature(String, String, Date))
+standard_relations[parse_date_name] = parse_date
+
+parse_datetime_name = "parse_datetime"
+parse_datetime = ExternalRelation(Namespace.top, parse_datetime_name, RelationSignature(String, String, DateTime))
+standard_relations[parse_datetime_name] = parse_datetime
+
+parse_decimal_name = "parse_decimal"
+parse_decimal = ExternalRelation(Namespace.top, parse_decimal_name, RelationSignature(PositiveInteger, PositiveInteger, String, Decimal))
+standard_relations[parse_decimal_name] = parse_decimal
+
+power_name = "power"
+power = ExternalRelation(Namespace.top, power_name, RelationSignature(Integer, Integer, Integer))
+standard_relations[power_name] = power
+
+unpack_name = "unpack"
+def unpack(*sig: Type):
+    return ExternalRelation(Namespace.top, unpack_name, RelationSignature(*sig))
+standard_relations[unpack_name] = unpack
+
+decimal_ctor_name = "decimal"
+new_decimal = ExternalRelation(Namespace.top, decimal_ctor_name, RelationSignature(Integer, Integer, Integer, Decimal))
+standard_relations[decimal_ctor_name] = new_decimal
+
+#=
+# Rel Mirror.
+#=
+
+mirror_lower_name = "mirror_lower"
+mirror_lower_rel_name = "::std::mirror::lower"
+mirror_lower = ExternalRelation(Namespace.top, mirror_lower_rel_name, RelationSignature(Symbol, Any))
+standard_relations[mirror_lower_rel_name] = mirror_lower

relationalai/early_access/dsl/core/temporal/recall.py

@@ -0,0 +1,6 @@
+from relationalai.early_access.dsl.core.relations import Relation
+
+
+def prev(r: 'Relation') -> Relation:
+    p = Relation(r._container, f"{r._relname}__prev", r._signature)
+    return p

relationalai/early_access/dsl/core/types/__init__.py

@@ -0,0 +1,270 @@
+from abc import abstractmethod
+
+from relationalai.early_access.dsl.core.exprs import contextStack
+from relationalai.early_access.dsl.core.namespaces import Namespace
+from relationalai.early_access.dsl.core.types.variables import TypeVariable
+from relationalai.early_access.dsl.core.utils import generate_stable_uuid
+
+
+# This abstract class generalizes over all types
+#
+class Type:
+
+    # A Type T can be "instantiated" for one of several purposes, depending
+    # on context:
+    #
+    #   1) in the context of a ConstrainedValueType, to add a parameter TypeVariable
+    #      to that type; and
+    #   2) in the context of a ConjunctiveSchema:
+    #      a) if the argument is a string name, then adds a new ScalarComponent of
+    #         that name to the schema; or
+    #      b) if the argument is a ScalarVariable, then adds an atom that references
+    #         the unary population relation for the EntityType in a Rel body formula
+    #
+    # In case (1), there should be no arguments (args); in case (2a), we expect there
+    # to be exactly one string argument that names the component being added to the
+    # SchemaFragment; while in context (2b) we expect there to be exactly one argument
+    # of type ScalarVariable.
+    #
+    # Because we use RelationVariables to range over the parameters of a nominal value
+    # type, to properly handle case (1) we have to call one of:
+    #
+    #  - build_relation_variable
+    #  - build_scalar_variable
+    #
+    # depending on whether T is a nominal type. But that distinction is really only
+    # relevant to case (1) -- which means the concrete builder objects that implement
+    # the ScalarConstraintBuilder interface for cases (2a) and (2b) must implement
+    # both methods the same way.
+    #
+    def __call__(self, *args, **kwargs):
+        seq = [self]
+        for i in range(len(args)):
+            seq.append(args[i])
+
+        if self.nominal() or self.entity():
+            return contextStack.root_context().build_relation_variable(seq, kwargs)
+        else:
+            return contextStack.root_context().build_scalar_variable(seq, kwargs)
+
+    def __enter__(self):
+        contextStack.push(self)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        contextStack.pop()
+
+    def __init__(self, nm):
+        self._name = nm
+        #
+        if not contextStack.empty():
+            tp = contextStack.root_context()
+            if isinstance(tp, Namespace):
+                self._namespace = tp
+            else:
+                self._namespace = Namespace.top
+        else:
+            self._namespace = Namespace.top
+
+    # Returns the number of TypeVariables that parameterize this Type
+    #
+    def arity(self) -> int:
+        return 1
+
+    def display(self):
+        return self._name
+
+    # Returns True if this type is an EntityType or one of its subtypes
+    # and False otherwise
+    #
+    def entity(self) -> bool:
+        return False
+
+    # Returns an integer (hash) that identifies this Type, allowing us
+    # to treat Types sort of like entity types for which we had declared
+    # a preferred identifier to allow different physical objects to unify
+    # to the same entity. Contrast this with the "id" method which would
+    # not allow us to do this unification.
+    #
+    def entityid(self):
+        return hash(self._name)
+
+    def guid(self):
+        return generate_stable_uuid(self._name)
+
+    # Returns the Rel required to instantiate an instance of this Type
+    # from a given value val. By default, just return val; subclasses
+    # will override as appropriate
+    #
+    def instantiate(self, *val):
+        return val[0]
+
+    def namespace(self):
+        return self._namespace
+
+    # This predicate returns True if this type is a ValueType or
+    # some subtype of a ValueType.
+    #
+    def nominal(self) -> bool:
+        return False
+
+
+class AbstractValueType(Type):
+
+    def __init__(self, nm):
+        Type.__init__(self, nm)
+
+    # Returns true if self is both unconstrained and also numeric, meaning its constraints
+    # (if any) can be statically verified.
+    #
+    def basic_numeric(self) -> bool: return False
+
+    # Returns True if the Python constant `val` is an instance of this ValueType
+    def contains(self, val) -> bool: return False
+
+    # Gathers the set of BasicTypeVariable constraints that this AbstractValueType denotes
+    # either by declaring or inheriting.
+    #
+    def denotes(self): return {}
+
+    # Returns true if this is a nominal value type or a subtype that is rooted by a nominal
+    # value type
+    #
+    def nominal(self) -> bool: return False
+
+    # Returns true if this is a constraint value type or a subtype that is rooted by a constrained
+    # value type
+    #
+    def constraint(self) -> bool: return False
+
+    # Returns true if this is a constraint value type or a subtype that is rooted by a constrained
+    # value type and signature_arity is 1
+    #
+    def constraint_unary(self) -> bool:
+        return self.constraint() and self.unary()
+
+    # Creates a new TypeVariable that ranges over this AbstractValueType, including all
+    # constraints (if any) suitably instantiated to the new TypeVariable
+    #
+    @abstractmethod
+    def ranges_over(self) -> TypeVariable: pass
+
+    # Where possible, returns the lone UnconstrainedValueType that will be used as the physical
+    # representation of instances of this AbstractValueType at runtime.
+    #
+    def root_nominal_type(self):
+        raise Exception(f"Cannot determine root nominal type of AbstractValueType {self.display()}")
+
+    # The signature arity of a AbstractValueType refers to the number of BasicTypeVariables
+    # that occur in its physical implementation. For UnconstrainedValueTypes, the arity is 1.
+    # For ConstrainedValueTypes, the arity is the size of the flattened basic-type variable
+    # tuple that it constrains.
+    #
+    def signature_arity(self) -> int: return 1
+
+    # Returns true if this is a value type has signature_arity == 1
+    #
+    def unary(self):
+        return self.signature_arity() == 1
+
+    def subtype_of(self, T2):
+        if self.nominal():
+            if not T2.nominal():
+                return False
+
+            # Both are nominal value types, so make sure names are the same
+            #
+            nt1 = self.root_nominal_type()
+            nt2 = T2.root_nominal_type()
+            if nt1.display() != nt2.display():
+                return False
+        else:
+            if T2.nominal():
+                return False
+
+            # Neither type is nominal, so check if one or both are unconstrained
+
+            if self.unconstrained():
+                return self.display() == T2.display()
+
+            if T2.unconstrained():
+                u2 = self.root_unconstrained_type() # type: ignore
+                return T2.display() == u2.display()
+
+        # All nominal type checking has passed and neither type is Unconstrained
+
+        if self.signature_arity() != T2.signature_arity():
+            return False
+
+        # Types have same signature arities, so check constraints on type variables.
+
+        mapping = map_type_var_tuple_to(self.typevar_tuple(), T2.typevar_tuple())
+
+        if len(mapping) != self.signature_arity():
+            return False
+
+        # Same typevar tuples, so now just check that the every models of self is also
+        # a model of T2.
+        #
+        cset1 = {}
+        for c in self.denotes().values():
+            cprime = c.rename(mapping)
+            cset1[cprime.entityid()] = cprime
+
+        return True
+
+    # Returns true if this type is Unconstrained
+    #
+    def unconstrained(self) -> bool:
+        return False
+
+    @abstractmethod
+    def typevar_tuple(self) -> tuple[TypeVariable, ...]:
+        pass
+
+
+def basic_type_instance(val):
+    if isinstance(val, str):
+        return True
+    if isinstance(val, int):
+        return True
+    if isinstance(val, float):
+        return True
+    return False
+
+def map_type_var_tuple_to(tup1, tup2):
+    return map_type_var_tuple_to_rec(tup1, tup2, {})
+
+def map_type_var_tuple_to_rec(tup1, tup2, m):
+    if type(tup1) is tuple:
+        if type(tup2) is not tuple:
+            return {}
+
+        v1 = tup1[0]
+        v2 = tup2[0]
+        m[v1.display()] = v2
+        return map_type_var_tuple_to_rec(tup1[1:], tup2[1:], m)
+    else:
+        if type(tup2) is tuple:
+            return {}
+        m[tup1.display()] = tup2
+
+    return m
+
+def typevar_tuple_string_rec(tup) -> str:
+    if type(tup) is not tuple:
+        return tup.display()
+
+    results = [typevar_tuple_string_rec(v) for v in tup]
+
+    if len(results) == 1:
+        return results[0]
+    else:
+        return "(" + ", ".join(results) + ")"
+
+
+def typevar_tuple_string(tup) -> str:
+    if type(tup) is not tuple:
+        return f"({tup.display()})"
+    else:
+        return typevar_tuple_string_rec(tup)