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

v0/relationalai/early_access/dsl/schemas/components.py

@@ -0,0 +1,203 @@
+from abc import abstractmethod
+from typing import Union
+
+from v0.relationalai.early_access.dsl.core.exprs.relational import RelationVariable
+from v0.relationalai.early_access.dsl.core.exprs.scalar import ScalarVariable
+from v0.relationalai.early_access.dsl.core.relations import Relation
+from v0.relationalai.early_access.dsl.core.types import Type
+from v0.relationalai.early_access.dsl.schemas.exprs import Domain, Range
+from v0.relationalai.early_access.dsl.core.constraints.predicate.universal import RelationalEqualityConstraint
+from v0.relationalai.early_access.dsl.relations import EmptyRelation
+
+
+#
+# The abstract class SchemaComponent models a component that is introduced in the
+# "declaration part" of a Schema
+#
+# Each declaration has the form:
+#    v : t
+# where v is a Var and t is a Type or Relation signature (arity and column types).
+# The interpretation is that v is an element of Type t or has signature t.
+#
+class SchemaComponent:
+
+    def __init__(self, name, dashes=0):
+        self._name = name
+        self._dashes:int = dashes
+        self.before = None
+
+    def basevar(self):
+        if self.undecorated():
+            return self
+
+        if hasattr(self, 'before') and self.before is not None:
+            return self.before.basevar()
+
+        raise Exception("Need to extend SchemaComponent.basevar to create undecorated vars.")
+
+    @abstractmethod
+    def duplicate(self, name, t) -> 'SchemaComponent':
+        pass
+
+    @abstractmethod
+    def relational(self) -> bool:
+        pass
+
+    @abstractmethod
+    def typeof(self) -> Union[Type, Relation]:
+        pass
+
+    # Emit this schema to a textual output using the Z display style
+    #
+    def pprint(self):
+        return f"{self.name()} : {self.typeof().display()}"
+
+    @abstractmethod
+    def prefix(self, pref) -> 'SchemaComponent':
+        pass
+
+    def display_name(self):
+        return self.name()
+
+    def entityid(self):
+        return hash(self.name())
+
+    def decorated(self) -> bool:
+        return self._dashes > 0
+
+    def name(self):
+        nm = self._name if isinstance(self._name, str) else self._name.display()
+        return nm + self._dashes * "'"
+
+    def sync_with(self, peer):
+        return {self.name(): peer}
+
+    def undash(self):
+        if self._dashes > 0:
+            return self.before
+        return self
+
+    def undecorated(self) -> bool:
+        return self._dashes == 0
+
+
+class RelationEmptyConstraint(RelationalEqualityConstraint):
+
+    def __init__(self, left, sig):
+        super().__init__(left, EmptyRelation(sig))
+
+
+class RelationalComponent(RelationVariable, SchemaComponent):
+
+    def __init__(self, name, t, dashes=0):
+        super().__init__(name, dashes)
+        self.relation = t
+        if dashes < 2:
+            self.after = RelationalComponent(name, t, dashes + 1)
+            self.after.before = self
+
+    def arity(self):
+        return self.relation.arity()
+
+    def display(self):
+        return self.name()
+
+    def domain(self):
+        return Domain(self)
+
+    def duplicate(self, name, t) -> 'RelationalComponent':
+        return RelationalComponent(name, t, self._dashes)
+
+    def empty(self):
+        return RelationEmptyConstraint(self, self.relation)
+
+    def entityid(self):
+        return SchemaComponent.entityid(self)
+
+    def prefix(self, pref):
+        comp = RelationalComponent(prefix_concat(pref, self._name), self.relation)
+        for i in range(self._dashes):
+            comp = comp.after
+        return comp
+
+    def range(self):
+        return Range(self)
+
+    def rename(self, renaming):
+        vname = self.display()
+        if vname in renaming:
+            var = renaming[vname]
+            if isinstance(var, str):
+                return RelationalComponent(var, self.relation, self._dashes)
+            return var
+        else:
+            return self
+
+    def refersto(self, varname: str):
+        return self.display() == varname
+
+    def relational(self) -> bool:
+        return True
+
+    def typeof(self):
+        return self.relation
+
+    def substitute(self, bindings):
+        vname = self.display()
+        if vname in bindings:
+            return bindings[vname]
+        else:
+            return self
+
+
+class ScalarComponent(ScalarVariable, SchemaComponent):
+
+    def __init__(self, name, t, dashes=0):
+        super().__init__(name, dashes)
+        self._scalartype = t
+        if dashes < 2:
+            newcomp = ScalarComponent(name, t, dashes + 1)
+            newcomp.before = self
+            self.after = newcomp
+
+    def entityid(self):
+        return SchemaComponent.entityid(self)
+
+    def prefix(self, pref):
+        comp = ScalarComponent(prefix_concat(pref, self._name), self._scalartype)
+        for i in range(self._dashes):
+            comp = comp.after
+        return comp
+
+    def physical_typeof(self):
+        return self._scalartype.root_unconstrained_type()
+
+    def typeof(self):
+        return self._scalartype
+
+    def display(self):
+        return self.name()
+
+    def duplicate(self, name, t) -> 'ScalarComponent':
+        return ScalarComponent(name, t, self._dashes)
+
+    def rename(self, renaming):
+        vname = self.display()
+        if vname in renaming:
+            var = renaming[vname]
+            if isinstance(var, str):
+                return ScalarComponent(var, self._scalartype, self._dashes)
+            return var
+        else:
+            return self
+
+    def simplify(self):
+        return self
+
+
+def prefix_concat(s1, s2):
+    if not s1:
+        return s2
+    if not s2:
+        return s1
+    return s1 + s2[0].capitalize() + s2[1:]

v0/relationalai/early_access/dsl/schemas/contexts.py

@@ -0,0 +1,156 @@
+from v0.relationalai.early_access.dsl.core.builders.logic import LogicBuilder
+from v0.relationalai.early_access.dsl.core.constraints.predicate.universal import RelationalEqualityConstraint
+from v0.relationalai.early_access.dsl.core.exprs import contextStack
+from v0.relationalai.early_access.dsl.core.exprs.scalar import ScalarExprBuilder
+from v0.relationalai.early_access.dsl.core.types.constrained import ConstrainedValueType
+from v0.relationalai.early_access.dsl.constants import PRIME, DASHES
+from v0.relationalai.early_access.dsl.schemas.components import RelationalComponent, ScalarComponent
+from v0.relationalai.early_access.dsl.types.entities import AbstractEntityType
+
+
+def remove_prefix(nm, prefix):
+    lpref = len(prefix)
+    if lpref == 0 or not nm.startswith(prefix):
+        return nm
+    else:
+        truncated = nm[lpref:]
+        if len(truncated) == 1:
+            return truncated.lower()
+        else:
+            newstr = truncated[0].lower() + truncated[1:]
+            return newstr
+
+
+def extract_name(nm, dashes, prefix):
+    dash_suffix = dashes * PRIME
+    index = nm.rfind(dash_suffix)
+    if index == -1:
+        return remove_prefix(nm, prefix)
+    else:
+        return remove_prefix(nm[0:index], prefix)
+
+
+def properly_decorated_name(nm, dashes, prefix):
+    if dashes != 0:
+        dash_suffix = dashes * PRIME
+        if nm.rfind(dash_suffix) == -1:
+            return False
+    return nm.startswith(prefix)
+
+
+class SchemaContext(LogicBuilder, ScalarExprBuilder):
+
+    @staticmethod
+    def close():
+        contextStack.pop()
+
+    @staticmethod
+    def open(schema):
+        ctx = SchemaContext(schema)
+        contextStack.push(ctx)
+        return ctx
+
+    def __init__(self, schema):
+        self.schema = schema
+
+    def build_atom(self, rel, args):
+        s = self.schema
+        atom = s.build_atom(rel, args)
+        s.add_atomic_constraint(atom)
+        return atom
+
+    def build_comparison(self, left, op, right):
+        s = self.schema
+        if left.relational():
+            if not right.relational() or op != "=":
+                bad_expr = f"{left.display()} {op} {right.display()}"
+                raise Exception(
+                    f"Currently cannot declare anything other than equality constraints on relations. Saw {bad_expr}")
+            c = RelationalEqualityConstraint(left, right)
+            s.add_predicate_constraint(c)
+            return c
+        else:
+            c = s.build_comparison(left, op, right)
+            s.add_scalar_constraint(c)
+            return c
+
+    def build_element_of(self, e, set):
+        s = self.schema
+        s.add_atomic_constraint(s.build_element_of(e, set))
+
+    def build_scalar_variable(self, args, kwargs):
+
+        dashes = kwargs[DASHES] if DASHES in kwargs else 0
+
+        tp = args[0]
+        nameorvar = args[1]
+        if isinstance(nameorvar, str):
+            name = nameorvar
+
+            if self.schema.disjunctive():
+                raise Exception("Cannot add a component directly to a disjunctive schema")
+
+            decl = ScalarComponent(name, tp, dashes)
+            self.schema.add_component(decl)
+            return decl
+        else:
+            if isinstance(tp, AbstractEntityType):
+                rel = tp.population()
+                relname = rel.qualified_name()
+                ctx = self.schema
+                if ctx.has_relation_component(relname):
+                    comp = ctx.retrieve_relation_component(relname)
+                else:
+                    # Then add a new component for this relation to the
+                    # schema that is under construction
+                    #
+                    # todo: figure out if we use `build_scalar_variable` at all
+                    comp = rel.signature(relname) # type: ignore
+
+                # Now assert the atom
+                comp(nameorvar)
+            else:
+                raise Exception(f"Illegal to range over the population of infinite type {tp.display()}")
+
+    def build_relation_variable(self, args, kwargs):
+
+        dashes = kwargs[DASHES] if DASHES in kwargs else 0
+
+        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 Schema declaration
+        #
+        if isinstance(tp, ConstrainedValueType):
+            return self.build_scalar_variable(args, kwargs)
+
+        nameorvar = args[1]
+        if isinstance(nameorvar, str):
+            name = nameorvar
+
+            if self.schema.disjunctive():
+                raise Exception("Cannot add a component directly to a disjunctive schema")
+
+            decl = RelationalComponent(name, tp, dashes)
+
+            self.schema.add_relational_component(decl)
+            return decl
+        else:
+            if isinstance(tp, AbstractEntityType):
+                rel = tp.population()
+                relname = rel.qualified_name()
+                ctx = self.schema
+                if ctx.has_relation_component(relname):
+                    comp = ctx.retrieve_relation_component(relname)
+                else:
+                    # Then add a new component for this relation to the
+                    # schema that is under construction
+                    #
+                    # todo: figure out if we use `build_relation_variable` at all
+                    comp = rel.signature(relname) # type: ignore
+
+                # Now assert the atom
+                comp(nameorvar)
+            else:
+                raise Exception(f"Illegal to range over the population of infinite type {tp.display()}")

v0/relationalai/early_access/dsl/schemas/exprs.py

@@ -0,0 +1,89 @@
+from v0.relationalai.early_access.dsl.core.constraints.predicate.atomic import Atom
+from v0.relationalai.early_access.dsl.core.exprs import Expr, Wildcard
+
+
+class Domain(Expr):
+
+    def __init__(self, v):
+        self.part = v
+
+    def display(self):
+        return f"dom {self.part.display()}"
+
+    def grounded_using(self, groundings): return False
+
+    def decorated(self) -> bool:
+        return self.part.decorated()
+
+    def entityid(self):
+        return hash((Domain, self.part.entityid()))
+
+    def project(self, comp):
+        nargs = self.part.typeof().arity() - 1
+        wc = Wildcard()
+
+        seq = [wc] * nargs
+        seq.insert(0, comp)
+
+        return Atom(self.part, seq)
+
+    def scalar_refs(self): return self.part.scalar_refs()
+
+    def refersto(self, varname: str) -> bool:
+        return self.part.refersto(varname)
+
+    def relational(self) -> bool: return True
+
+    def rename(self, renaming):
+        return Domain(self.part.rename(renaming))
+
+    def simplify(self): return self
+
+    def substitute(self, bindings):
+        p = self.part.substitute(bindings)
+        return Domain(p)
+
+    def undecorated(self) -> bool:
+        return self.part.undecorated()
+
+
+class Range(Expr):
+    def __init__(self, v):
+        self.part = v
+
+    def display(self):
+        return f"ran {self.part.display()}"
+
+    def entityid(self):
+        return hash((Range, self.part.entityid()))
+
+    def grounded_using(self, groundings): return False
+
+    def decorated(self) -> bool:
+        return self.part.decorated()
+
+    def project(self, comp):
+        nargs = self.part.arity()
+        seq = [Wildcard()] * nargs - 1
+        seq.append(comp)
+
+        return Atom(self.part, seq)
+
+    def scalar_refs(self): return self.part.scalar_refs()
+
+    def refersto(self, varname: str) -> bool:
+        return self.part.refersto(varname)
+
+    def relational(self) -> bool: return True
+
+    def rename(self, renaming):
+        return Range(self.part.rename(renaming))
+
+    def simplify(self): return self
+
+    def substitute(self, bindings):
+        p = self.part.substitute(bindings)
+        return Range(p)
+
+    def undecorated(self) -> bool:
+        return self.part.undecorated()