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

relationalai/early_access/dsl/core/constraints/scalar.py

@@ -1,310 +0,0 @@
-from relationalai.early_access.dsl.core.constraints import Constraint, TrueConstraint, FalseConstraint
-
-class ScalarConstraint(Constraint):
-
-    def __init__(self, x, y, z):
-        self.op = y
-        if y == "=" and x.grounded():
-            self.left = z
-            self.right = x
-        else:
-            self.left = x
-            self.right = z
-
-    # A binding is a definition in which the right-hand side of the equality
-    # comparison is grounded and so will evaluate to a constant (e.g., "x == 20")
-    #
-    def binding(self):
-        return self.definition() and self.right.grounded()
-
-    def commutative_definition(self):
-        return self.definition() and self.right.variable()
-
-    def commute(self):
-        if not self.commutative_definition():
-            raise Exception(f"Cannot commute non-commutative definition {self.pprint()}")
-        return ScalarConstraint( self.right, '=', self.left )
-
-    # A definition is a left var ScalarConstraint of the form that involves an
-    # equality operator (e.g., "x == 20", or "x == y + 5" )
-    #
-    def definition(self):
-        return self.left.variable() and self.equality()
-
-    def equality(self):
-        return self.op == "="
-
-    def negate(self):
-        left = self.left
-        right = self.right
-        if self.op == "=":
-            return ScalarConstraint(left, "!=", right)
-        if self.op == "!=":
-            return ScalarConstraint(left, "=", right)
-        if self.op == "<=":
-            return ScalarConstraint(left, ">", right)
-        if self.op == "<":
-            return ScalarConstraint(left, ">=", right)
-        if self.op == ">=":
-            return ScalarConstraint(left, "<", right)
-        if self.op == ">":
-            return ScalarConstraint(left, "<=", right)
-
-        raise Exception(f"Cannot negate constraint {self.pprint()}")
-
-    # Emit this schema to a textual output using the Z display style
-    #
-    def pprint(self):
-
-        left = self.left
-        right = self.right
-        result = []
-
-        if hasattr(left, "display"):
-            result.append(left.display())
-        else:
-            result.append(left)
-
-        if self.op == "=":
-            result.append("==")
-        else:
-            result.append(self.op)
-
-        if hasattr(right, "display"):
-            result.append(right.display())
-        else:
-            result.append(right)
-
-        return " ".join(result)
-
-    def rel_formula(self):
-        return f"{self.left.display()} {self.op} {self.right.display()}"
-
-    def grounded(self):
-        return self.left.grounded() and self.right.grounded()
-
-    def grounds(self, v, groundings):
-        if self.equality():
-            lv = self.left
-            if lv.variable():
-                if lv.entityid() == v.entityid():
-                    return self.right.grounded_using(groundings)
-                else:
-                    rv = self.right
-                    if rv.variable() and rv.entityid() == v.entityid():
-                        return self.left.grounded_using(groundings)
-        return False
-
-    def scalar_refs(self):
-        dic = self.left.scalar_refs()
-        rdict = self.right.scalar_refs()
-        for v in rdict:
-            if v not in dic:
-                dic[v] = rdict[v]
-        return dic
-
-    def refersto(self, varname: str) -> bool:
-        return self.left.refersto(varname) or self.right.refersto(varname)
-
-    def relational(self) -> bool:
-        return self.left.relational() or self.right.relational()
-
-    def rename(self, renaming):
-        return ScalarConstraint(self.left.rename(renaming),
-                                self.op,
-                                self.right.rename(renaming))
-
-    def revar(self, vmap):
-        return ScalarConstraint(self.left.revar(vmap),
-                                self.op,
-                                self.right.revar(vmap))
-
-    # Report out the propositional variables that are used in this constraint as
-    # an extension to the bindings dictionary that is provided.
-    #
-    def report_propositional_variable_usage(self, bindings):
-        uses = self.scalar_refs()
-
-        if len(bindings) == 0:
-            return uses
-        else:
-            bdgs = bindings.copy()
-            for v in uses:
-                if v not in bindings:
-                    bdgs[v] = uses[v]
-
-            return bdgs
-
-    def simplify(self):
-        if self.grounded():
-            exec(f"self.x = {self.pprint()}")
-            if self.x: # type: ignore
-                return TrueConstraint()
-            else:
-                return FalseConstraint()
-        else:
-            left = self.left.simplify()
-            right = self.right.simplify()
-            if left.grounded() and self.equality():
-                return ScalarConstraint(right, self.op, left)
-            else:
-                return ScalarConstraint(left, self.op, right)
-
-    def substitute(self, bindings):
-        x = self.left.substitute(bindings)
-        y = self.right.substitute(bindings)
-        return ScalarConstraint(x, self.op, y)
-
-    def map_builder(self, builder):
-        x = self.left.map_builder(builder)
-        y = self.right.map_builder(builder)
-        return ScalarConstraint(x, self.op, y)
-
-    def entityid(self):
-        return hash((self.op,
-                     self.left.entityid(),
-                     self.right.entityid()))
-
-
-# Given a dictionary 'props' of ScalarConstraints, return the dictionary
-# containing that subset of props that are binding definitions
-#
-def binding_definitions_of(props):
-    return {c.entityid(): c for c in props.values() if c.binding()}
-
-
-# Given a set props of ScalarConstraints, partition props into
-# (bcons, other) where bcons are binding definitions, and return
-# (bdgs, bcons, other) where bdgs is a binding dictionary used to
-# apply constraints from bcons.
-#
-def bindings_from(props):
-    bdgs = {}
-    bcons = {}
-    other = []
-
-    bprops = binding_definitions_of(props)
-
-    # Partition props into a dictionary of substitution bindings (bdgs)
-    # that derive from the binding definitions in props and any other
-    # (non-binding) constraints in props.
-    #
-    for chash in props:
-        c = props[chash]
-        if chash in bprops:
-            v = c.left.display()
-            if v in bdgs:
-                # Then we have (at least 2) constraints of the form:
-                #    v == expr1
-                #    v == expr2
-                # for expressions expr1 and expr2. In this case, we
-                # need to add the equality constraint `expr1 == expr2`
-                # to other.
-                #
-                expr1 = bdgs[v]
-                expr2 = c.right
-                if expr2.variable():
-                    # Prefer to put the variable on the LHS when possible
-                    #
-                    other.append(ScalarConstraint(expr2, "=", expr1))
-                else:
-                    other.append(ScalarConstraint(expr1, "=", expr2))
-            else:
-                bdgs[v] = c.right
-                bcons[chash] = c
-        else:
-            other.append(c)
-
-    return bdgs, bcons, other
-
-def commutative_definitions_from(props):
-    defns = {}
-    cdcons = {}
-    other = []
-
-    cdefs = commutative_definitions_of(props)
-
-    # Partition props into a dictionary of commutative definitions (defns)
-    # that derive from the binding definitions in props and any other
-    # (non-binding) constraints in props.
-    #
-    for chash in props:
-        c = props[chash]
-        if chash in cdefs and c.commute().entityid() not in defns:
-            # Add {chash: c} to defns if its commuted equivalent not already there!
-            defns[c.left.display()] = c.right
-            cdcons[chash] = c
-        else:
-            other.append(c)
-
-    return defns, cdcons, other
-
-def definitions_of(props):
-    return {c.entityid(): c for c in props.values() if c.definition()}
-
-def commutative_definitions_of(props):
-    return {c.entityid(): c for c in props.values() if c.commutative_definition()}
-
-# Given a set (comps, atoms) of ScalarConstraints and AtomicConstraints respectively,
-# find any binding constraints in comps and use them to do constant folding within
-# (comps, atoms), returning that set of constraints that is equivalent following
-# one or more rounds of constant folding.
-#
-def fold_constants(comps, atoms):
-    (bdgs, newcomps, other) = bindings_from(comps)
-    blen = 0
-
-    if len(bdgs) == 0:
-        return comps, atoms
-
-    # Otherwise, there is at least one binding to try to apply.
-
-    while blen < len(bdgs):
-        # Note that len(bdgs) is non-decreasing with each iteration
-        #
-        blen = len(bdgs)
-
-        # We have not yet applied all bindings. So try to fold
-        # any bound value into other constraints, simplifying
-        # where possible.
-        #
-        for c in other:
-            cprime = c.substitute(bdgs).simplify()
-            if isinstance(cprime, FalseConstraint):
-                # Signal that the whole set of constraints is unsatisfiable
-                return {1: cprime}, {}
-            if not isinstance(cprime, TrueConstraint):
-                newcomps[cprime.entityid()] = cprime
-
-        comps = newcomps
-        (bdgs, newcomps, other) = bindings_from(comps)
-
-    newatoms = {}
-    for c in atoms:
-        cprime = atoms[c].substitute(bdgs).simplify()
-        newatoms[cprime.entityid()] = cprime
-
-    return comps, newatoms
-
-
-# Given a set (comps, atoms) of ScalarConstraints and AtomicConstraints respectively,
-# find any commutative-definition constraints in comps and propagatge them within
-# (comps, atoms), returning that set of constraints that is equivalent following
-# one or more rounds of propagation.
-#
-def propagate_definitions(comps, atoms):
-
-    (cdefs, newcomps, other) = commutative_definitions_from(comps)
-
-    if len(cdefs) == 0:
-        return comps, atoms
-    for c in other:
-        cprime = c.substitute(cdefs)
-        newcomps[cprime.entityid()] = cprime
-
-    newatoms = {}
-    for c in atoms:
-        cprime = atoms[c].substitute(cdefs)
-        newatoms[cprime.entityid()] = cprime
-
-    return newcomps, newatoms

relationalai/early_access/dsl/core/context.py

@@ -1,13 +0,0 @@
-from relationalai.early_access.dsl.core.stack import Stack
-
-
-class ContextStack(Stack):
-
-    def __init__(self):
-        super().__init__()
-
-    def root_context(self):
-        ctx = self.top()
-        if ctx is None:
-            raise Exception('Context stack is empty')
-        return ctx

relationalai/early_access/dsl/core/cset.py

@@ -1,132 +0,0 @@
-from relationalai.early_access.dsl.core.constraints import FalseConstraint, TrueConstraint
-from relationalai.early_access.dsl.core.constraints.predicate.atomic import AtomicConstraint
-from relationalai.early_access.dsl.core.constraints.scalar import ScalarConstraint, fold_constants
-
-
-# A ConstraintSet is a stable collection of constraints that can be composed
-# into a conjunctive datalog query. These are useful for structuring declarative
-# specifications of types, formulae, and more abstract schemas, as well as
-# forming the basis for Rel rules.
-#
-# One interesting problem concerns the construction of stable constraints, as
-# we may need to create UnstableConstraintSets before all of the constraints
-# stabilize and then generate the ConstraintSet once they do
-#
-
-class AbstractConstraintSet:
-
-    def __init__(self):
-        self._atoms = {}
-        self._sconstraints = {}
-
-    def add_atomic_constraint(self, c): pass
-
-    def add_scalar_constraint(self, c): pass
-
-    # Returns a ConstraintSet that stabilizes the constraints declared in this set by
-    # replacing object ids in the dictionaries with (now stable) constraint entityids.
-    #
-    def stabilize(self):
-        cset = ConstraintSet()
-        cset._sconstraints = {c.entityid(): c for c in self._sconstraints.values()}
-        cset._atoms = {c.entityid(): c for c in self._atoms.values()}
-        return cset
-
-
-class ConstraintSet(AbstractConstraintSet):
-
-    def __init__(self):
-        super().__init__()
-
-    def add_scalar_constraint(self, c):
-        cv = c.entityid()
-        if not isinstance(c, ScalarConstraint):
-            raise Exception(f"Attempt to add {c.pprint()} as a scalar constraint")
-
-        if cv not in self._sconstraints:
-            self._sconstraints[cv] = c
-
-    def add_atomic_constraint(self, c):
-        cv = c.entityid()
-        if not isinstance(c, AtomicConstraint):
-            raise Exception(f"Attempt to add {c.pprint()} as an atomic constraint")
-
-        if cv not in self._atoms:
-            self._atoms[cv] = c
-
-    # Partially evaluate this ConstraintSet by substituting values
-    # for its scalar variables, simplifying where possible.
-    #
-    # Returns None if the result of evaluation is infeasible
-    #
-    def evaluate(self, bdgs):
-
-        # First we evaluate each constraint with bdgs
-        #
-        comps = {}
-        for c in self._sconstraints.values():
-            cprime = c.substitute(bdgs).simplify()
-            if isinstance(cprime, FalseConstraint):
-                return None
-            else:
-                if not isinstance(cprime, TrueConstraint):
-                    comps[cprime.entityid()] = cprime
-
-        atoms = {}
-        for c in self._atoms.values():
-            cprime = c.substitute(bdgs).simplify()
-            atoms[cprime.entityid()] = cprime
-
-        (comps, atoms) = fold_constants(comps, atoms)
-
-        if 1 in comps and isinstance(comps[1], FalseConstraint):
-            return None
-        else:
-            s = ConstraintSet()
-            s._sconstraints = comps
-            s._atoms = atoms
-            return s
-
-    def propositional_constraints(self):
-        return self._sconstraints | self._atoms
-
-    # Textual representation of a Rel formula that represents the body of a rule by
-    # conjoining the propsitional constraints of this Schema
-    #
-    def rel_formula(self):
-        props = [f"    {c.rel_formula()}" for c in self._sconstraints.values()]
-        for c in self._atoms.values():
-            props.append(f"    {c.rel_formula()}")
-        return " and\n".join(props)
-
-
-# In uses like value-type construction, constraints must be added before the
-# constraints stabilize -- meaning the constraints exist and refer to variables,
-# but the name or other identifying information about the variables has yet to
-# be assigned. Because ConstraintSets assume stable constraints, we have to
-# implement such use cases using UnstableConstraintSets that can be stabilized
-# to produce ConstraintSets.
-#
-# These unstable sets cannot rely on stable constraint entityids to manage the
-# sets and instead use simple object ids.
-#
-class UnstableConstraintSet(AbstractConstraintSet):
-
-    def __init__(self):
-        super().__init__()
-
-    def add_scalar_constraint(self, c):
-        cv = id(c)
-        if not isinstance(c, ScalarConstraint):
-            raise Exception(f"Attempt to add {c.pprint()} as a scalar constraint")
-
-        if cv not in self._sconstraints:
-            self._sconstraints[cv] = c
-
-    def add_atomic_constraint(self, c):
-        cv = id(c)
-        if not isinstance(c, AtomicConstraint):
-            raise Exception(f"Attempt to add {c.pprint()} as an atomic constraint")
-
-        if cv not in self._atoms:
-            self._atoms[cv] = c

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

@@ -1,116 +0,0 @@
-# Copyright 2024 RelationalAI, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# This module defines generic expressions (Exprs). These are
-# extended for use in Schema and Type constraints in other
-# modules.
-#
-from abc import abstractmethod
-
-from relationalai.early_access.dsl.core.context import ContextStack
-
-contextStack = ContextStack()
-
-
-class Expr:
-
-    # We can assert equality (==) between any pair of Exprs, though the
-    # meaning varies depending on whether self is an ScalarExpr or
-    # a RelationExpr
-    #
-    def __eq__(self, other): # type: ignore
-        contextStack.root_context().build_comparison(self, "=", other)
-
-    # Returns a printable form of this Expr.
-    #
-    @abstractmethod
-    def display(self) -> str: pass
-
-    # Returns a copy of this Expr with renaming applied to replace
-    # any variable that occurs in the renaming dictionary, which is
-    # keyed by the names of the variables to rename. For instance,
-    # if expr had the form (x + 2), then:
-    #
-    #    expr.rename({"x": y})
-    #
-    # would have the form (y + 2)
-    #
-    @abstractmethod
-    def rename(self, renaming) -> 'Expr': pass
-
-    # Returns a copy of this Expr with vmap applied to replace
-    # any variable that occurs in the vmap dictionary, which is
-    # keyed by the identifier of the variables to revar. For
-    # instance, if expr had the form (x + 2) and the entityid
-    # of x was 100, then:
-    #
-    #    expr.revar({100: y})
-    #
-    # would have the form (y + 2)
-    #
-    @abstractmethod
-    def revar(self, vmap) -> 'Expr': pass
-
-    # Returns a dictionary of ScalarVariables referenced by this Expr,
-    # with variable names (strings) as keys
-    #
-    def scalar_refs(self): return {}
-
-    # Returns an integer (hash) that identifies this Expr, allowing us
-    # to treat Exprs sort of like entity types for which we had declared
-    # a preferred identifier so as 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.
-    #
-    @abstractmethod
-    def entityid(self) -> int: pass
-
-    # This predicate returns True if this Expr refers to a variable
-    # with this varname and False otherwise.
-    #
-    @abstractmethod
-    def refersto(self, varname: str) -> bool: pass
-
-    # This predicate returns True if this Expr references any kind of
-    # Relation and False otherwise.
-    #
-    def relational(self) -> bool: return False
-
-    # This predicate returns True if this Expr is a (scalar or relation)
-    # variable and False otherwise.
-    #
-    def variable(self) -> bool: return False
-
-
-class Wildcard(Expr):
-    def __init__(self): pass
-
-    def display(self): return "_"
-
-    def grounded_using(self, groundings): return True
-
-    def refersto(self, varname: str): return False
-
-    def rename(self, renaming): return self
-
-    def revar(self, vmap): return self
-
-    def substitute(self, bindings): return self
-
-    def entityid(self): return hash(Wildcard)
-
-
-# Declare this variable for use in Datalog-style rules
-#
-_ = Wildcard()

relationalai/early_access/dsl/core/exprs/relational.py

@@ -1,18 +0,0 @@
-from relationalai.early_access.dsl.core.exprs import Expr, contextStack
-from relationalai.early_access.dsl.core.exprs.scalar import box_number
-
-
-# Relational non-scalar Exprs
-
-class RelationVariable(Expr):
-
-    # RelationVariables may be "invoked" to declare Atoms
-    #
-    def __call__(self, *args):
-        return contextStack.root_context().build_atom(self, [box_number(a) for a in args])
-
-    def arity(self): pass
-
-    def typeof(self): pass
-
-    def variable(self): return True