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

relationalai/early_access/dsl/core/relations.py

@@ -1,276 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,270 +0,0 @@
-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)