relationalai 0.13.5__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

relationalai/early_access/dsl/schemas/components.py

@@ -1,203 +0,0 @@
-from abc import abstractmethod
-from typing import Union
-
-from relationalai.early_access.dsl.core.exprs.relational import RelationVariable
-from relationalai.early_access.dsl.core.exprs.scalar import ScalarVariable
-from relationalai.early_access.dsl.core.relations import Relation
-from relationalai.early_access.dsl.core.types import Type
-from relationalai.early_access.dsl.schemas.exprs import Domain, Range
-from relationalai.early_access.dsl.core.constraints.predicate.universal import RelationalEqualityConstraint
-from 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:]

relationalai/early_access/dsl/schemas/contexts.py

@@ -1,156 +0,0 @@
-from relationalai.early_access.dsl.core.builders.logic import LogicBuilder
-from relationalai.early_access.dsl.core.constraints.predicate.universal import RelationalEqualityConstraint
-from relationalai.early_access.dsl.core.exprs import contextStack
-from relationalai.early_access.dsl.core.exprs.scalar import ScalarExprBuilder
-from relationalai.early_access.dsl.core.types.constrained import ConstrainedValueType
-from relationalai.early_access.dsl.constants import PRIME, DASHES
-from relationalai.early_access.dsl.schemas.components import RelationalComponent, ScalarComponent
-from 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()}")

relationalai/early_access/dsl/schemas/exprs.py

@@ -1,89 +0,0 @@
-from relationalai.early_access.dsl.core.constraints.predicate.atomic import Atom
-from 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()