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

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

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

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

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

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