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

v0/relationalai/early_access/dsl/core/types/concepts.py

@@ -0,0 +1,128 @@
+from typing import Optional
+
+from v0.relationalai.early_access.dsl.core.types import Type
+from v0.relationalai.early_access.dsl.core.types.constrained import ConstrainedValueType
+
+class Concept(ConstrainedValueType):
+
+    def __init__(self, name: str, extends: Optional[Type]=None):
+        super().__init__(name)
+        self._name = name
+        self._types = []
+        if extends is not None:
+            self._types.append(extends)
+
+        for t in self._types:
+            self.build_scalar_variable([t], {})
+        self.name_type_variables()
+
+    def build_scalar_variable(self, args, kwargs):
+        if len(args) == 0:
+            raise Exception(f"Unexpected error in Concept {self.display()}")
+
+        if len(kwargs) != 0:
+            raise Exception(
+                f"Cannot use keyword arguments when instantiating a type parameter for Concept {self.display()}")
+
+        p_type = args[0]
+        if len(args) == 1:
+
+            # Then we are instantiating T to create a new TypeVariable that will parameterize
+            # this Concept (self)
+            #
+            self._parent = p_type
+            tv = p_type.ranges_over()
+            self.addparam(tv)
+            return tv
+        else:
+            self._type_constraints.add_atomic_constraint(self.build_atom(p_type, args[1:]))
+
+    def build_relation_variable(self, args, kwargs):
+        if len(args) == 0:
+            raise Exception(f"Unexpected error in Concept {self.display()}")
+
+        if len(args) > 1:
+            raise Exception(f"Cannot declare type variable of Concept {self.display()} by supplying more than a type")
+
+        if len(kwargs) != 0:
+            raise Exception(
+                f"Cannot use keyword arguments when instantiating a type parameter for Concept {self.display()}")
+
+        self._parent = args[0]
+
+        tvar = self._parent.ranges_over()
+        self._params.append(tvar)
+
+        return tvar.typevar_tuple()
+
+    # Add TypeVariable *tv* as a parameter to this type
+    #
+    def addparam(self, tv):
+        self._params.append(tv)
+        return tv
+
+    def arity(self) -> int:
+        if self._parent is None:
+            return len(self._params)
+        else:
+            return self._parent.arity()
+
+    # Returns True if this type is an EntityType or one of its subtypes
+    # and False otherwise
+    #
+    def entity(self) -> bool:
+        return False
+
+    # 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):
+        if self._parent is None:
+            return val[0]
+        else:
+            return self._parent.instantiate(val[0])
+
+    def ranges_over(self):
+        # If this type is not nominal, then it should have exactly one
+        # TypeVariable parameter, which we can dupe and then extend
+        # with any additional scalar constraints declared by this type.
+        #
+        lone_type_var = self._params[0]
+
+        (tvar, vmap) = lone_type_var.dupe()
+        vmap[id(lone_type_var)] = tvar
+        # tvar._vmap = vmap
+        tvar.decl = self
+        for c in self._type_constraints._sconstraints.values():
+            cnew = c.revar(vmap)
+            tvar._cset._sconstraints[id(cnew)] = cnew
+        return tvar
+
+    def head_display(self):
+        headvars = []
+        for v in self._params:
+            vt = v.typeof()
+            if vt == self._parent:
+                headvars.append(f"{v.display()}")
+            else:
+                headvars.append(f"{v.display()} in {vt.display()}")
+        head = ", ".join(headvars)
+        if self._parent is None:
+            return f"value type {self.display()}({head})"
+        else:
+            return f"value type {self.display()} <: {self._parent.display()}({head})"
+
+    def root_nominal_type(self): # type: ignore
+        if self._parent is None:
+            return self
+        else:
+            return self._parent.root_nominal_type()
+
+    # A non-composite Concept can have a root unconstrained type.
+    #
+    def root_unconstrained_type(self):
+        if self.arity() == 1:
+            return self._params[0].typeof().root_unconstrained_type()
+        else:
+            raise Exception(f"Composite nominal type {self.display()} has no root unconstrained type")

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

@@ -0,0 +1,267 @@
+from abc import abstractmethod
+
+from v0.relationalai.early_access.dsl.core.builders.logic import ScalarConstraintBuilder, LogicBuilder
+from v0.relationalai.early_access.dsl.core.cset import ConstraintSet
+from v0.relationalai.early_access.dsl.core.exprs.scalar import ScalarExprBuilder, box_number
+from v0.relationalai.early_access.dsl.core.relations import RelationSignature, ExternalRelation
+from v0.relationalai.early_access.dsl.core.types import AbstractValueType
+from v0.relationalai.early_access.dsl.core.types.variables import UnstableConstraintSet, NominalTypeVariable, \
+    BasicTypeVariable, TypeVariable
+
+
+# A ConstrainedValueType:
+#
+#  * is identified by a *name*,
+#  * is parameterized by a sequence *params* of TypeVariables
+#  * has a set *constraints* of ScalarConstraints
+#
+# We implement constraint sets using an int-keyed dictionary to simplify
+# duplicate constraint removal.
+#
+class ConstrainedValueType(AbstractValueType, ScalarExprBuilder, LogicBuilder):
+
+    def __enter__(self): # type: ignore
+        super().__enter__()
+        return self.typevar_tuple()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        super().__exit__(exc_type, exc_value, traceback)
+        self.name_type_variables()
+
+    def __init__(self, nm):
+        AbstractValueType.__init__(self, nm)
+        self._params = []
+        self._type_constraints = UnstableConstraintSet()
+        self._constructor = None
+
+    def __xor__(self, args):
+        return self.constructor()(*args)
+
+    def build_comparison(self, left, op, right):
+        c = ScalarConstraintBuilder.build_comparison(self, left, op, right)
+        tc = self._type_constraints
+        tc.add_scalar_constraint(c)
+        return c
+
+    # Generates a string that displays the TypeVariable constraints (one per line)
+    # declared by this ConstrainedValueType
+    #
+    def constraint_display(self):
+        exists = []
+        for v in self._params:
+            if isinstance(v, NominalTypeVariable):
+                exists.append(v.all_constraint_display())
+        exists_atoms = "\n".join(exists)
+        exists_ppr = exists_atoms + "\n" if exists_atoms != "" else ""
+
+        constraints = [f"   {c.pprint()}" for c in self.denotes().values()]
+        if exists_ppr != "":
+            return exists_ppr + "\n" + "\n".join(constraints)
+        else:
+            return "\n".join(constraints)
+
+    def constructor(self):
+        if self._constructor is None:
+            # Create a constructor function (relation) for this ValueType
+            ctortype = [item.typeof() for item in self.ctordomain()]
+            ctortype.append(self)
+            self._constructor = ExternalRelation(self.namespace(),
+                                                 self.ctor_name(),
+                                                 RelationSignature(*tuple(ctortype)))
+        return self._constructor
+
+    # Returns True if the Python constant `val` is an instance of this ValueType
+    def contains(self, val):
+
+        if self.signature_arity() != 1:
+            raise Exception(
+                f"NOT IMPLEMENTED: Check containment of values in ({self.display()}) which is not unary")
+
+        # Get the lone type variable over which `self` imposes additional constraints
+        tvar = self._params[0]
+        if tvar.decl.contains(val) and isinstance(self._type_constraints, ConstraintSet):
+            return self._type_constraints.evaluate({tvar.varname(): box_number(val)}) is not None
+
+        return False
+
+    def ctordomain(self):
+        return self._params
+
+    def ctor_name(self):
+        return f"^{self.display()}"
+
+    # Returns what ORM would consider to be the "DataType" of this AbstractValueType, if it makes sense.
+    #
+    def datatype(self):
+        if not self.unary():
+            raise Exception(
+                f"Cannot infer an ORM datatype from AbstractValueType {self.display()}, which is not a "
+                f"ConstrainedUnaryValueType")
+
+        return self._params[0].typeof()
+
+    # Assemble the set of constraints that are either declared or inherited by
+    # this ConstrainedValueType. This method does not attempt to minimize constraints,
+    # in contrast with verifies.
+    #
+    def denotes(self):
+        C = self._type_constraints._sconstraints.copy()
+        for ac in self._type_constraints._atoms.values():
+            scs = self.interpret_type_atom(ac)
+            for s in scs:
+                if s not in C:
+                    C[s] = scs[s]
+
+        for p in self._params:
+            C = p.denotes(C)
+
+        return C
+
+    # Generates the headline declaration of this ConstrainedValueType, separately
+    # form the constraints, as the structure of this headline varies based on
+    # whether this is a ValueType or a ValueSubtype
+    #
+    @abstractmethod
+    def head_display(self) -> str: pass
+
+    # Interpret Atom ac as an AtomicConstraint of the form:
+    #
+    #    T(x)
+    #
+    # where T is a ConstrainedValueType and x is a TypeVariable.
+    #
+    # Checks that the type of x conforms to that of the lone TypeVariable
+    # that parameterizes T and returns all ScalarConstraints that T imposes
+    # on those variables.
+    #
+    def interpret_type_atom(self, ac):
+
+        T = ac.relation()
+        args = ac.args
+
+        if len(args) > 1:
+            raise Exception(f"Cannot apply ValueSubtype constraint ({T.display()}) to more than one TypeVariable")
+
+        vmap = {}
+        tv = args[0]
+        if isinstance(tv, BasicTypeVariable):
+            if T.nominal():
+                raise Exception(
+                        f"Argument mismatch when using type {T.display()} as an AtomicConstraint in context of ValueType {self.display()}")
+
+            if T.root_unconstrained_type() != tv.decl.root_unconstrained_type():
+                raise Exception(
+                    f"Applying type constraint {T.display()} to variable of incompatible unconstrained "
+                    f"type {tv.decl.physical_typeof().pprint()}")
+
+            vmap[id(T._params[0])] = tv
+        else:
+            # tv is a NominalTypeVariable
+
+            ttup = flatten_typevar_tuple([], T.typevar_tuple())
+            tvtup = flatten_typevar_tuple([], tv.typevar_tuple())
+
+            if len(ttup) != len(tvtup):
+                raise Exception(
+                    f"Argument mismatch when using type {T.display()} as an AtomicConstraint in context of ValueType {self.display()}")
+
+            for i in range(len(ttup)):
+                if not isinstance(tvtup[i], TypeVariable):
+                    raise Exception(
+                        f"When using type {T.display()} as an AtomicConstraint in context of ValueType {self.display()}, {i}-th "
+                        f"argument is not a TypeVariable")
+
+                tup_basic_type = ttup[i].physical_typeof()
+                tvtup_basic_type = tvtup[i].physical_typeof()
+
+                # Validate that tup_basic_type and arg_basic_type are compatible
+
+                if tup_basic_type != tvtup_basic_type:
+                    raise Exception(
+                        f"Applying basic type constraint {T.display()} to variable of incompatible unconstrained "
+                        f"type {tvtup_basic_type.pprint()}")
+
+                vmap[id(ttup[i])] = tvtup[i]
+
+        rv = {}
+        constraints = T.denotes()
+        for cindex in constraints:
+            c = constraints[cindex]
+            dupc = c.revar(vmap)
+            rv[dupc.entityid()] = dupc
+        return rv
+
+    # Assign a unique number to each type variable (including the parts of nominal type variables,
+    # recursively) so that each type variable in the signature of this ConstrainedValueType will
+    # have a unique name to use in interpreting type constraints.
+    #
+    def name_type_variables(self, initial_pos=0):
+        pos = initial_pos
+        for v in self._params:
+            pos = v.setpos(pos)
+        self._type_constraints = self._type_constraints.stabilize()
+
+    def pprint(self):
+        body = self.constraint_display()
+        if body != "":
+            return self.head_display() + ":\n" + body
+        else:
+            return self.head_display()
+
+    def signature_arity(self):
+        sum = 0
+        for v in self._params:
+            sum = sum + v.typeof().signature_arity()
+        return sum
+
+    # Returns the (possibly nested) tuple of BasicTypeVariables over which this ConstrainedValueType
+    # ranges. This is useful when instantiating this type, as the calling context will often need to
+    # directly reference these BasicTypeVariables. So, for instance, using this facility, we can
+    # write code like:
+    #
+    #    ((x, y), (w, z)) = DoubleInterval.typevar_tuple()
+    #
+    # The flatten_typevar_tuple function can be used to flatten these tuples into an array, in this
+    # case:
+    #
+    #    [ x, y, w, z ]
+    #
+    def typevar_tuple(self):
+        tvars = []
+        for tvar in self._params:
+            tp = tvar.typeof()
+            if tp.nominal():
+                tvars.append(tvar.typevar_tuple())
+            else:
+                tvars.append(tvar)
+        if len(tvars) == 1:
+            return tvars[0]
+        else:
+            return tuple(tvars)
+
+    # Helper method that returns the UnconstrainedSignature of this ConstrainedValueType
+    # in the special case where that tuple is a single BasicTypeVariable, raising
+    # an exception otherwise.
+    #
+    def value(self):
+        if self.signature_arity() != 1:
+            raise Exception(
+                f"Cannot refer to singleton value type variable for non-unary AbstractValueType {self.display()}")
+        else:
+            return self.typevar_tuple()
+
+    def constraint(self) -> bool:
+        return True
+
+
+def flatten_typevar_tuple(seq, tup):
+    if type(tup) is tuple:
+        for v in tup:
+            if tuple(v):
+                seq = flatten_typevar_tuple(seq, v)
+            else:
+                seq.append(v)
+    else:
+        seq.append(tup)
+
+    return seq

v0/relationalai/early_access/dsl/core/types/constrained/nominal.py

@@ -0,0 +1,143 @@
+from v0.relationalai.early_access.dsl.core.instances import Instance, ValueTypeInstance
+from v0.relationalai.early_access.dsl.core.types import Type
+from v0.relationalai.early_access.dsl.core.types.constrained import ConstrainedValueType
+from v0.relationalai.early_access.dsl.core.types.variables import NominalTypeVariable
+
+
+class ValueType(ConstrainedValueType):
+
+    def __init__(self, nm, *args):
+        super().__init__(nm)
+        self._types = args
+        for arg in args:
+            self.build_scalar_variable([arg], {})
+        self.name_type_variables()
+
+    # Add TypeVariable *tv* as a parameter to this type
+    #
+    def addparam(self, tv):
+        self._params.append(tv)
+        return tv
+
+    def arity(self) -> int:
+        return len(self._params)
+
+    def build_scalar_variable(self, args, kwargs):
+        if len(args) == 0:
+            raise Exception(f"Unexpected error in ValueType {self.display()}")
+
+        if len(kwargs) != 0:
+            raise Exception(
+                f"Cannot use keyword arguments when instantiating a type parameter for ValueSubtype {self.display()}")
+
+        T = args[0]
+        if len(args) == 1:
+
+            # Then we are instantiating T to create a new TypeVariable that will parameterize
+            # this ValueType (self)
+            #
+            tv = T.ranges_over()
+            self.addparam(tv)
+            return tv
+        else:
+            self._type_constraints.add_atomic_constraint(self.build_atom(T, args[1:]))
+
+    def build_relation_variable(self, args, kwargs):
+        if len(args) == 0:
+            raise Exception(f"Unexpected error in ValueType {self.display()}")
+
+        if len(kwargs) != 0:
+            raise Exception(
+                f"Cannot use keyword arguments when instantiating a type parameter for ValueSubtype {self.display()}")
+
+        T = args[0]
+        if not isinstance(T, Type):
+            raise Exception("When an AtomicConstraint is asserted in context of a ValueType, the predicate must name a Type")
+
+        if len(args) == 1:
+            # Then we are instantiating T to create a new TypeVariable that will parameterize
+            # this ValueType (self)
+            #
+
+            tvar = T.ranges_over() # type: ignore
+            self.addparam(tvar)
+
+            return tvar.typevar_tuple()
+
+        else:
+            # Otherwise, we expect T to behave as a type predicate that is applied to a tuple
+            # (args[1:]) of BasicTypeVariables for the purpose of imposing T's constraints
+            # on those variables. We implement this by creating a renaming using tuple args[1:]
+            # and then applying that renaming to each constraint that T verifies, adding the
+            # result to the constraints declared by self.
+            #
+            self._type_constraints.add_atomic_constraint(self.build_atom(T, args[1:]))
+
+    # Generates the string used to display the opening declaration for this ValueType
+    #
+    def head_display(self):
+        headvars = []
+        for v in self._params:
+            vt = v.typeof()
+            headvars.append(f"{v.display()} in {vt.display()}")
+        head = ", ".join(headvars)
+        return f"value type {self.display()}({head})"
+
+    def instantiate(self, *tup):
+
+        cvars = self._params
+        if len(tup) != len(cvars):
+            raise Exception(
+                f"ValueType {self.display()} constructor expects {len(cvars)} arguments but was instantiated with {len(tup)}")
+
+        params = []
+        for i in range(len(cvars)):
+            arg = tup[i]
+            tp = cvars[i].decl
+            if isinstance(arg, Instance) or not tp.nominal():
+                params.append(arg)
+            else:
+                params.append(tp.instantiate(arg))
+        return ValueTypeInstance(self, params)
+
+    def nominal(self) -> bool:
+        return True
+
+    # Return a fresh type variable that ranges over this nominal ValueType
+    #
+    def ranges_over(self):
+        tvar = NominalTypeVariable(self)
+
+        # For each TypeVariable that parameterizes self, duplicate
+        # it to form a part of tvar
+        #
+        vmap = {}
+        for p in self._params:
+            (pprime, vmap) = p.dupe(vmap)
+            tvar._parts.append(pprime)
+        tvar._vmap = vmap
+
+        # Instantiate all scalar constraints from self using vmap
+
+        for c in self._type_constraints._sconstraints.values():
+            cnew = c.revar(vmap)
+            tvar._cset._sconstraints[id(cnew)] = cnew
+
+        for c in self._type_constraints._atoms:
+            cnew = c.revar(vmap)
+            tvar._cset._atoms[id(cnew)] = cnew
+
+        return tvar
+
+    def root_nominal_type(self): return self # type: ignore
+
+    # A non-composite ValueType can have a root unconstrained type.
+    #
+    def root_unconstrained_type(self):
+        if self.arity() == 1:
+            return self._params[0].typeof().root_unconstrained_type()
+        else:
+            raise Exception(f"Composite nominal type {self.display()} has no root unconstrained type")
+
+    def __str__(self):
+        return f"ValueType({self.display()})"

v0/relationalai/early_access/dsl/core/types/constrained/subtype.py

@@ -0,0 +1,124 @@
+from v0.relationalai.early_access.dsl.core.types.constrained import ConstrainedValueType
+from v0.relationalai.early_access.dsl.core.types.variables import NominalTypeVariable
+
+
+class ValueSubtype(ConstrainedValueType):
+
+    def __init__(self, nm, *args):
+        super().__init__(nm)
+        for arg in args:
+            self.build_scalar_variable([arg], {})
+        self.name_type_variables()
+
+    def arity(self):
+        return self._parent.arity()
+
+    def build_scalar_variable(self, args, kwargs):
+        if len(args) == 0:
+            raise Exception(f"Unexpected error in ValueSubtype {self.display()}")
+
+        if len(kwargs) != 0:
+            raise Exception(
+                f"Cannot use keyword arguments when instantiating a type parameter for ValueSubtype {self.display()}")
+
+        ptype = args[0]
+        if len(args) == 1:
+            self._parent = ptype
+            tvar = ptype.ranges_over()
+            self._params = [tvar]
+            return self.typevar_tuple()
+        else:
+            self._type_constraints.add_atomic_constraint(self.build_atom(ptype, args[1:]))
+
+    def build_relation_variable(self, args, kwargs):
+        if len(args) == 0:
+            raise Exception(f"Unexpected error in ValueSubtype {self.display()}")
+
+        if len(args) > 1:
+            raise Exception(f"Cannot declare type variable of ValueSubtype {self.display()} by supplying more than a type")
+
+        if len(kwargs) != 0:
+            raise Exception(
+                f"Cannot use keyword arguments when instantiating a type parameter for ValueSubtype {self.display()}")
+
+        vtype = args[0]
+        self._parent = vtype
+
+        tvar = vtype.ranges_over()
+        self._params.append(tvar)
+
+        return tvar.typevar_tuple()
+
+    def instantiate(self, *val):
+        return self._parent.instantiate(val[0])
+
+    def nominal(self):
+        return self._parent.nominal()
+
+    # Return a fresh type variable that ranges over this ValueSubtype
+    #
+    def ranges_over(self):
+
+        # Self is a ValueSubtype, which is either nominal or not
+
+        if self.nominal():
+            # If nominal, then the variable that ranges over self must be a NominalTypeVariable
+            tvar = NominalTypeVariable(self)
+            tvar._parts = []
+            vmap = {}
+            selfparts = self._params[0]._parts
+            for p in selfparts:
+                (pprime, vmap) = p.dupe(vmap)
+                tvar._parts.append(pprime)
+            tvar._vmap = vmap
+
+            # Because tvar might have multiple part variables, any subtype constraints that constrain
+            # self will need to apply not to tvar.
+
+            # Instantiate all scalar constraints from vt using vmap
+            for c in self._type_constraints._sconstraints.values():
+                cnew = c.revar(vmap)
+                tvar._cset._sconstraints[id(cnew)] = cnew
+
+            for c in self._type_constraints._atoms:
+                cnew = c.revar(vmap)
+                tvar._cset._atoms[id(cnew)] = cnew
+
+            return tvar
+
+        else:
+            # If this type is not nominal, then it should have exactly one
+            # TypeVariable parameter, which we can dupe and then extend
+            # with any additional scalar constraints declared by this type.
+            #
+            lone_type_var = self._params[0]
+
+            (tvar, vmap) = lone_type_var.dupe()
+            vmap[id(lone_type_var)] = tvar
+            # tvar._vmap = vmap
+            tvar.decl = self
+            for c in self._type_constraints._sconstraints.values():
+                cnew = c.revar(vmap)
+                tvar._cset._sconstraints[id(cnew)] = cnew
+            return tvar
+
+    def head_display(self):
+        parent = self.parent()
+        headvars = []
+        for v in self._params:
+            vt = v.typeof()
+            if vt == parent:
+                headvars.append(f"{v.display()}")
+            else:
+                headvars.append(f"{v.display()} in {vt.display()}")
+        head = ", ".join(headvars)
+        return f"value type {self.display()} <: {parent.display()}({head})"
+
+    def parent(self):
+        return self._parent
+
+    def root_nominal_type(self):
+        return self._parent.root_nominal_type()
+
+    def root_unconstrained_type(self):
+        return self._parent.root_unconstrained_type()