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

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

@@ -1,412 +0,0 @@
-from abc import abstractmethod
-
-from relationalai.early_access.dsl.core.builders import ExprBuilder
-from relationalai.early_access.dsl.core.exprs import Expr, contextStack
-
-# Arithmetic expressions are those Numbers, ScalarVariables, and larger
-# expressions that combine these with arithmetic operators
-#
-class ScalarExpr(Expr):
-
-    # ScalarExpr building operators and methods
-
-    def __add__(self, other):
-        return contextStack.root_context().build_plus(self, other)
-
-    def __radd__(self, other):
-        return contextStack.root_context().build_plus(self, other)
-
-    def __mod__(self, other):
-        return contextStack.root_context().build_modulus(self, other)
-
-    def __rmod__(self, other):
-        return contextStack.root_context().build_modulus(self, other)
-
-    def __mul__(self, other):
-        return contextStack.root_context().build_times(self, other)
-
-    def __rmul__(self, other):
-        return contextStack.root_context().build_times(self, other)
-
-    def __neg__(self):
-        return contextStack.root_context().build_negate(self)
-
-    def __sub__(self, other):
-        return contextStack.root_context().build_minus(self, other)
-
-    def __rsub__(self, other):
-        return contextStack.root_context().build_minus(self, other)
-
-    def __truediv__(self, other):
-        return contextStack.root_context().build_divide(self, other)
-
-    def __rtruediv__(self, other):
-        return contextStack.root_context().build_divide(self, other)
-
-    # Constraint-building operators and methods
-
-    def __ge__(self, other):
-        contextStack.root_context().build_comparison(self, ">=", other)
-
-    def __gt__(self, other):
-        contextStack.root_context().build_comparison(self, ">", other)
-
-    def __le__(self, other):
-        contextStack.root_context().build_comparison(self, "<=", other)
-
-    def __lt__(self, other):
-        contextStack.root_context().build_comparison(self, "<", other)
-
-    def __ne__(self, other): # type: ignore
-        contextStack.root_context().build_comparison(self, "!=", other)
-
-    def is_in(self, other):
-        return contextStack.root_context().build_element_of(self, other)
-
-    def not_in(self, other):
-        return contextStack.root_context().build_not_element_of(self, other)
-
-    @abstractmethod
-    def map_builder(self, builder):
-        raise NotImplementedError(f"Not implemented for \"{type(self)}\".")
-
-
-class ScalarVariable(ScalarExpr):
-
-    def physical_typeof(self):
-        raise Exception(f"Cannot retrieve phsyical type of variable {self.display()}")
-
-    def grounded(self):
-        return False
-
-    def grounded_using(self, groundings):
-        return self.display() in groundings
-
-    def refersto(self, varname: str) -> bool:
-        return self.display() == varname
-
-    def scalar_refs(self):
-        return {self.display(): self}
-
-    def rename(self, renaming):
-        vname = self.display()
-        if vname in renaming:
-            return renaming[vname]
-        else:
-            return self
-
-    def substitute(self, bindings):
-        return self.rename(bindings)
-
-    def typeof(self):
-        pass
-
-    def variable(self):
-        return True
-
-class Literal(ScalarExpr):
-    def __init__(self, v): self.val = v
-
-    def display(self): return str(self.val)
-
-    def entityid(self): return hash(self.val)
-
-    def grounded(self): return True
-
-    def grounded_using(self, groundings): return True
-
-    def rename(self, renaming): return self
-
-    def revar(self, vmap): return self
-
-    def refersto(self, varname): return False
-
-    def simplify(self): return self
-
-    def substitute(self, bindings): return self
-
-    def __hash__(self):
-        return hash(self.val)
-
-    def map_builder(self, builder):
-        return self
-
-class Number(Literal):
-    pass
-
-class String(Literal):
-
-    def display(self): return f"\"{self.val}\""
-
-
-class Negate(ScalarExpr):
-    def __init__(self, x):
-        self._part = x
-
-    def display(self):
-        p = self._part
-        return f"- {p.display()}"
-
-    def entityid(self):
-        return hash((Negate, self._part.entityid()))
-
-    # Attempts to evaluate this expression statically, returning a single Number if
-    # possible, otherwise returns self.
-    #
-    def evaluate(self):
-        if self.grounded():
-            exec(f"self.x = {self.display()}")
-            return Number(self.x) # type: ignore
-        else:
-            return self
-
-    def grounded(self):
-        return self._part.grounded()
-
-    def grounded_using(self, groundings):
-        return self._part.grounded_using(groundings)
-
-    def scalar_refs(self):
-        return self._part.scalar_refs()
-
-    def refersto(self, varname):
-        return self._part.refersto(varname)
-
-    def rename(self, renaming):
-        return Negate(self._part.rename(renaming))
-
-    def revar(self, vmap):
-        return Negate(self._part.revar(vmap))
-
-    def simplify(self):
-        ev = self.evaluate()
-        if ev.entityid() != self.entityid():
-            return ev
-        else:
-            return Negate(self._part.simplify())
-
-    def substitute(self, bindings):
-        return Negate(self._part.substitute(bindings))
-
-
-class BinaryScalarExpr(ScalarExpr):
-
-    def __init__(self, op):
-        self._op = op
-
-    def display(self):
-        return f"{self._left.display()} {self._op} {self._right.display()}"
-
-    # Attempts to evaluate this expression statically, returning a single Number if
-    # possible, otherwise returns self.
-    #
-    def evaluate(self):
-        if self.grounded():
-            exec(f"self.x = {self.display()}")
-            return Number(self.x) # type: ignore
-        else:
-            return self
-
-    def grounded(self):
-        return self._left.grounded() and self._right.grounded()
-
-    def grounded_using(self, groundings):
-        return self._left.grounded_using(groundings) and self._right.grounded_using(groundings)
-
-    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):
-        return self._left.refersto(varname) or self._right.refersto(varname)
-
-    def set_args(self, x, z):
-        self._left = box_number(x)
-        self._right = box_number(z)
-
-    def op(self):
-        return self._op
-
-
-class Plus(BinaryScalarExpr):
-
-    def __init__(self, x, z):
-        super().__init__("+")
-        self.set_args(x, z)
-
-    def rename(self, renaming):
-        return Plus(self._left.rename(renaming),
-                    self._right.rename(renaming))
-
-    def revar(self, vmap):
-        return Plus(self._left.revar(vmap),
-                    self._right.revar(vmap))
-
-    def simplify(self):
-        ev = self.evaluate()
-        if ev.entityid() != self.entityid():
-            return ev
-        else:
-            return Plus(self._left.simplify(), self._right.simplify())
-
-    def substitute(self, bindings):
-        return Plus(self._left.substitute(bindings), self._right.substitute(bindings))
-
-    def entityid(self):
-        return hash((Plus,
-                     self._left.entityid(),
-                     self._right.entityid()))
-
-    def map_builder(self, builder):
-        return Plus(self._left.map_builder(builder), self._right.map_builder(builder))
-
-
-class Minus(BinaryScalarExpr):
-
-    def __init__(self, x, z):
-        super().__init__("-")
-        self.set_args(x, z)
-
-    def rename(self, renaming):
-        return Minus(self._left.rename(renaming),
-                     self._right.rename(renaming))
-
-    def revar(self, vmap):
-        return Minus(self._left.revar(vmap),
-                     self._right.revar(vmap))
-
-    def simplify(self):
-        ev = self.evaluate()
-        if ev.entityid() != self.entityid():
-            return ev
-        else:
-            return Minus(self._left.simplify(), self._right.simplify())
-
-    def substitute(self, bindings):
-        return Minus(self._left.substitute(bindings), self._right.substitute(bindings))
-
-    def entityid(self):
-        return hash((Minus,
-                     self._left.entityid(),
-                     self._right.entityid()))
-
-    def map_builder(self, builder):
-        return Minus(self._left.map_builder(builder), self._right.map_builder(builder))
-
-
-class Modulus(BinaryScalarExpr):
-    def __init__(self, x, z):
-        super().__init__("%")
-        self.set_args(x, z)
-
-    def rename(self, renaming):
-        return Modulus(self._left.rename(renaming),
-                       self._right.rename(renaming))
-
-    def revar(self, vmap):
-        return Modulus(self._left.revar(vmap),
-                       self._right.revar(vmap))
-
-    def simplify(self):
-        ev = self.evaluate()
-        if ev.entityid() != self.entityid():
-            return ev
-        else:
-            return Modulus(self._left.simplify(), self._right.simplify())
-
-    def substitute(self, bindings):
-        return Modulus(self._left.substitute(bindings), self._right.substitute(bindings))
-
-    def entityid(self):
-        return hash((Modulus,
-                     self._left.entityid(),
-                     self._right.entityid()))
-
-
-class Times(BinaryScalarExpr):
-
-    def __init__(self, x, z):
-        super().__init__("*")
-        self.set_args(x, z)
-
-    def rename(self, renaming):
-        return Times(self._left.rename(renaming),
-                     self._right.rename(renaming))
-
-    def revar(self, vmap):
-        return Times(self._left.revar(vmap),
-                     self._right.revar(vmap))
-
-    def simplify(self):
-        ev = self.evaluate()
-        if ev.entityid() != self.entityid():
-            return ev
-        else:
-            return Times(self._left.simplify(), self._right.simplify())
-
-    def substitute(self, bindings):
-        return Times(self._left.substitute(bindings), self._right.substitute(bindings))
-
-    def entityid(self):
-        return hash((Times,
-                     self._left.entityid(),
-                     self._right.entityid()))
-
-
-class Divide(BinaryScalarExpr):
-
-    def __init__(self, x, z):
-        super().__init__("/")
-        self.set_args(x, z)
-
-    def entityid(self):
-        return hash((Divide,
-                     self._left.entityid(),
-                     self._right.entityid()))
-
-    def rename(self, renaming):
-        return Divide(self._left.rename(renaming),
-                      self._right.rename(renaming))
-
-    def revar(self, vmap):
-        return Divide(self._left.revar(vmap),
-                      self._right.revar(vmap))
-
-    def simplify(self):
-        ev = self.evaluate()
-        if ev.entityid() != self.entityid():
-            return ev
-        else:
-            return Divide(self._left.simplify(), self._right.simplify())
-
-    def substitute(self, bindings):
-        return Divide(self._left.substitute(bindings), self._right.substitute(bindings))
-
-
-class ScalarExprBuilder(ExprBuilder):
-
-    def build_divide(self, left, right): return Divide(left, box_number(right))
-
-    def build_plus(self, left, right): return Plus(left, box_number(right))
-
-    def build_minus(self, left, right): return Minus(left, box_number(right))
-
-    def build_modulus(self, left, right): return Modulus(left, box_number(right))
-
-    def build_negate(self, expr): return Negate(expr)
-
-    def build_times(self, left, right): return Times(left, box_number(right))
-
-
-def box_number(x):
-    if isinstance(x, (int, float)):
-        return Number(x)
-    else:
-        if isinstance(x, str):
-            return String(x)
-        else:
-            return x

relationalai/early_access/dsl/core/instances.py

@@ -1,44 +0,0 @@
-from relationalai.early_access.dsl.core.exprs import Expr
-
-
-class Instance(Expr):
-
-    def __init__(self, c, arglist):
-        self.concept = c
-        self.arglist = arglist
-
-    def entityid(self):
-        arghashes = []
-        for c in self.arglist:
-            if isinstance(c, Instance):
-                arghashes.append(c.entityid())
-            else:
-                arghashes.append(c)
-        return hash((self.concept.entityid(), *arghashes))
-
-    def display(self):
-        params = []
-        for i in range(len(self.arglist)):
-            arg = self.arglist[i]
-            if isinstance(arg, Instance):
-                params.append(arg.pprint())
-            else:
-                # Otherwise, arg must be a constraint of some UnconstrainedValueType
-                if isinstance(arg, str):
-                    params.append(f"\"{arg}\"")
-                else:
-                    params.append(arg)
-        return self.concept.ctor_name() + '[' + ",".join(params) + ']'
-
-    def pprint(self):
-        return self.display()
-
-
-class ValueTypeInstance(Instance):
-
-    def __init__(self, vtype, arglist):
-        if len(arglist) != len(vtype._params):
-            raise Exception(
-                f"Value type {vtype.name()} constructor maps tuples of length {len(vtype.constructor())} but was "
-                f"instantiated with {len(arglist)} arguments")
-        Instance.__init__(self, vtype, arglist)

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

@@ -1,193 +0,0 @@
-from relationalai.early_access.dsl.core import warn
-from relationalai.early_access.dsl.core.builders.logic import LogicBuilder
-from relationalai.early_access.dsl.core.cset import ConstraintSet
-from relationalai.early_access.dsl.core.exprs.scalar import ScalarVariable, ScalarExprBuilder
-
-class RelVariable(ScalarVariable):
-
-    def __init__(self, nm, tp):
-        self._name = nm
-        self._type = tp
-
-    def display(self): return self._name
-
-    def entityid(self):
-        return hash((self._name, self._type.entityid()))
-
-    def physical_typeof(self):
-        return self.typeof().physical_typeof()
-
-    def typeof(self): return self._type
-
-    def __hash__(self):
-        return hash((self._name, self._type))
-
-    def map_builder(self, builder):
-        return RelVariable(self._name, self._type)
-
-class LogicFragment(ConstraintSet, LogicBuilder, ScalarExprBuilder):
-
-    def __init__(self):
-        ConstraintSet.__init__(self)
-        self._scalars = {}
-        self._existentials = {}
-
-    def add_component(self, d):
-        vname = d.display()
-
-        if vname not in self._scalars:
-            self._scalars[vname] = d
-            return True
-        else:
-            d1 = d.typeof()
-            d2 = self._scalars[vname].typeof()
-            if not d2.subtype_of(d1):
-                if d1.subtype_of(d2):
-                    self._scalars[vname] = d
-                else:
-                    raise Exception(
-                        f"++ Error: Cannot declare two scalar variables named {vname} in the same schema context")
-
-        return False
-
-    def add_existential_constraint(self, c):
-        self._existentials[id(c)] = c
-        return c
-
-    def build_atom(self, rel, args):
-        atom = LogicBuilder.build_atom(self, rel, args)
-        self.add_atomic_constraint(atom)
-        return atom
-
-    def build_comparison(self, left, op, right):
-        c = LogicBuilder.build_comparison(self, left, op, right)
-        self.add_scalar_constraint(c)
-        return c
-
-    def build_scalar_variable(self, args, kwargs):
-        tp = args[0]
-        if len(args) < 2 or not isinstance(args[1], str):
-            raise Exception("This should not happen")
-
-        decl = RelVariable(args[1], tp)
-        self.add_component(decl)
-        return decl
-
-    def build_relation_variable(self, args, kwargs):
-        tp = args[0]
-
-        # [REKS] Very subtle. This is needed because when tp is a ConstrainedValueType,
-        #        this method will be called. Correct during type analysis, but incorrect
-        #        during declarations of Rel variables of said type
-        #
-        if tp.nominal():
-            return self.build_scalar_variable(args, kwargs)
-
-        # [REKS] Another subtlety. In Rel, we can name a Relation the same as an EntityType,
-        #        and we often do this for relations that maintain the finite population of
-        #        entites of that type. But then we can refer to these relations as Atoms in
-        #        rules, and they will be interpreted as requests to instantiate the EntityType
-        #        with a variable name -- which is not a name but a RelVariable meant to range
-        #        over the population of the relation.
-        #
-        varorname = args[1]
-        if isinstance(varorname, RelVariable):
-            # [VAMI] TODO: uncomment later
-            # warn(f"Corner case to follow up on when building_relation_varornameiable {varorname.display()}")
-            return self.build_atom(tp.population(), [varorname])
-        else:
-            decl = RelVariable(varorname, tp)
-
-            self.add_component(decl)
-            return decl
-
-
-    # Partially evaluate this Schema by substituting values for
-    # its schema variables, simplifying where possible.
-    #
-    def evaluate(self, bdgs):
-
-        # Project away from decls any variables that are declared in pdecls
-        #
-        def project_decls(decls, pdecls):
-            return {v: decls[v] for v in decls if v not in pdecls}
-
-        decls = project_decls(self._scalars, bdgs)
-
-        super = ConstraintSet.evaluate(self, bdgs)
-
-        if super is None:
-            return super
-        else:
-            s = LogicFragment()
-            s._scalars = decls
-            s._sconstraints = super._sconstraints
-            s._atoms = super._atoms
-            return s
-
-    def propositional_constraints(self):
-        par = ConstraintSet.propositional_constraints(self)
-        if len(self._existentials) == 0:
-            return par
-        else:
-            d = self._existentials
-            for x in d:
-                par[x] = d[x]
-        return par
-
-    def rel_formula(self):
-        subf = ConstraintSet.rel_formula(self)
-        if len(self._existentials) == 0:
-            if len(subf) == 0:
-                return '    true'
-            else:
-                return subf
-        else:
-            xcs = [c.rel_formula() for c in self._existentials.values()]
-            xf = "\n".join(xcs)
-            if subf == "":
-                return xf
-            return subf + "\n" + xf
-
-    # Given an optional set of constraints that defaults to all propositional
-    # constraints in this LogicFragment, returns a dictionary that represents
-    # that subset of this Fragment's scalar variables that is not grounded by
-    # those constraints.
-    #
-    # Grounding is decided the same way it is in datalog, namely if the
-    # variable is referenced positively in a finite relation or in an
-    # atom of an infinite relation in which every other variable in that
-    # atom is grounded.
-    #
-    def ungrounded_components(self, constraints=None):
-
-        if constraints is None:
-            constraints = self.propositional_constraints()
-        vars = [d for d in self._scalars.values()]
-
-        groundings = {}
-        glen = -1
-
-        while glen < len(groundings):
-            glen = len(groundings)
-
-            for c in constraints.values():
-                for v in vars:
-                    if c.grounds(v, groundings):
-                        groundings[v.display()] = v
-
-        return [v for v in vars if v.display() not in groundings]
-
-    def view(self, view_name):
-        c = self.ungrounded_components()
-
-        args = ", ".join([v.display() for v in self._scalars.values()])
-        body = self.rel_formula()
-        rule = f"def {view_name}({args}): " + "\n" + body
-
-        if len(c) > 0:
-            vstr = ", ".join([v.display() for v in c])
-            warn(f"Ungrounded variables ({vstr}) in schema prevent materialization (declaring view @inline)")
-            return "@inline\n" + rule
-        else:
-            return rule