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

relationalai/early_access/dsl/physical_metadata/tables.py

@@ -0,0 +1,133 @@
+import re
+from typing import Optional
+
+from simple_ddl_parser import DDLParser
+
+from relationalai.early_access.dsl.core.types.standard import Integer, String, Date, Boolean, Decimal, Float, DateTime
+from relationalai.early_access.dsl.core.utils import generate_stable_uuid
+
+_type_mapping = {
+    'varchar': String,
+    'char': String,
+    'text': String,
+    'int': Integer,
+    'integer': Integer,
+    'smallint': Integer,
+    'bigint': Integer,
+    'decimal': Decimal,
+    'double': Float,
+    'float': Float,
+    'date': Date,
+    'datetime': DateTime,
+    'boolean': Boolean,
+}
+
+#=
+# Deprecated old way to define a table via a DDL string.
+#=
+
+class Table:
+    def __init__(self, name: Optional[str] = None, ddl_str: Optional[str] = None):
+        if name and not ddl_str:
+            super().__setattr__('name', name)
+            super().__setattr__('columns', {})
+        elif ddl_str:
+            super().__setattr__('columns', {})
+            parsed_dsl = self._parse_ddl(ddl_str)
+            if name and name != parsed_dsl['table_name']:
+                raise ValueError(
+                    f'Provided table name {name} does not match the table name in the DDL'
+                )
+            else:
+                super().__setattr__('name', parsed_dsl['table_name'])
+            for col in parsed_dsl['columns']:
+                self.columns[col['name']] = Column(
+                    col['name'], _type_mapping[col['type'].lower()], self
+                )
+        else:
+            raise ValueError('Either name or DDL must be provided')
+
+    def __setattr__(self, key: str, value: 'Column') -> None:
+        if key in self.__dict__:
+            super().__setattr__(key, value)
+        elif isinstance(value, Column):
+            value.part_of = self
+            self.columns[key] = value
+            super().__setattr__(key, value)
+        else:
+           raise TypeError(
+               f'Expected a Column instance for "{key}", got {type(value)}'
+           )
+
+    def __getattr__(self, key):
+        if key in self.columns:
+            return self.columns[key]
+        else:
+            raise AttributeError(f'Table {self.name} has no column named {key}')
+
+    def pprint(self):
+        return (
+                f'Table: {self.name} ('
+                + '\n'
+                + ',\n'.join(
+            [f' {col.name} {col.type.pprint()}' for _, col in self.columns.items()]
+        )
+                + '\n)'
+        )
+
+    @staticmethod
+    def _parse_ddl(ddl: str):
+        pattern = re.compile(r'constraint_[A-Za-z_]+')
+        ddl_cleaned = pattern.sub('', ddl)
+        ddl_json = DDLParser(ddl_cleaned, silent=False).run()
+        return ddl_json[0]
+
+
+class TemporalTable(Table):
+    @property
+    def temporal_col(self):
+        return self._temporal_col
+
+    def __init__(self, temporal_col_name: str, name: Optional[str] = None, ddl_str: Optional[str] = None):
+        super().__init__(name, ddl_str)
+        # no checks can be made here, as the columns are not yet necessarily defined
+        self._temporal_col = Column(nm=temporal_col_name, type=DateTime, source=self)
+
+    def pprint(self):
+        return (
+                f'Temporal Table: {self.name} ('
+                + '\n'
+                + ',\n'.join(
+            [f' {col.name} {col.type.pprint()}' for _, col in filter(lambda kv: kv[0] != '_temporal_col', self.columns.items()) ]
+        )
+                + '\n)'
+                + f'\ntemporal_col: {self._temporal_col.name}'
+        )
+
+
+class Column:
+    _part_of: Table
+
+    def __init__(self, nm, type, source=None):
+        self.name = nm
+        self.type = type
+        if source:
+            self._part_of = source
+
+    @property
+    def part_of(self):
+        return self._part_of
+
+    @part_of.setter
+    def part_of(self, rel):
+        if self._part_of is not None and self._part_of != rel:
+            raise ValueError(
+                f'Column is already part of another source: {self._part_of}'
+            )
+        self._part_of = rel
+
+    def pprint(self):
+        return f'{self.name} {self.type.pprint()}'
+
+    def guid(self):
+        return generate_stable_uuid(f'{self._part_of.name}_{self.name}')

relationalai/early_access/dsl/relations.py

@@ -0,0 +1,170 @@
+from relationalai.early_access.dsl.core.relations import AbstractRelationSignature, RelationSignature
+from relationalai.early_access.dsl.core.types import Type
+from relationalai.early_access.dsl.core.types.standard import PositiveInteger, UnsignedInteger
+
+class AbstractFunctionSignature(AbstractRelationSignature):
+
+    def functional(self): return True
+
+class EmptyRelation:
+
+    def __init__(self, sig):
+        self._signature = sig
+
+    def display(self): return 'EMPTYSET'
+
+    def entityid(self): return hash((EmptyRelation, self._signature.entityid()))
+
+    def pprint(self):
+        return self.display() + self._signature.display()
+
+    def rename(self, bdgs): return self
+
+class FunctionSignature(AbstractFunctionSignature):
+    pass
+
+class Sequence(AbstractFunctionSignature):
+
+    def __init__(self, T, *types):
+        super().__init__(*types)
+        self._range = T
+
+    def range(self): return self._range
+
+class SequenceOne(Sequence):
+
+    def __init__(self, T):
+        super().__init__(T, PositiveInteger, T)
+
+    def display(self):
+        return f"seq {self.range().display()}"
+
+    def entityid(self):
+        return hash((Sequence, self.range().entityid()))
+
+class SequenceZero(Sequence):
+
+    def __init__(self, T):
+        super().__init__(T, UnsignedInteger, T)
+
+    def display(self):
+        return f"seq0 {self.range().display()}"
+
+    def entityid(self):
+        return hash((SequenceZero, self.range().entityid()))
+
+class InjectiveSequenceOne(SequenceOne):
+
+    def __init__(self, T):
+        Sequence.__init__(self, T)
+
+    def display(self):
+        return f"iseq {self.range().display()}"
+
+    def entityid(self):
+        return hash((InjectiveSequenceOne, self.range().entityid()))
+
+
+class InjectiveSequenceZero(SequenceZero):
+
+    def __init__(self, T):
+        Sequence.__init__(self, T)
+
+    def display(self):
+        return f"iseq0 {self.range().display()}"
+
+    def entityid(self):
+        return hash((InjectiveSequenceZero, self.range().entityid()))
+
+class FunctionFactory:
+
+    def __call__(self, *args):
+
+        nargs = len(args)
+
+        if nargs < 2 or nargs > 3:
+            raise Exception("Must instantiate functions with two type arguments and an optional name")
+
+        dtype = args[0]
+        rtype = args[1]
+
+        if not isinstance(dtype, Type):
+            raise Exception(f"Function signature domain must be a valid Type, not {dtype}")
+
+        if not isinstance(rtype, Type):
+            raise Exception(f"Function signature range must be a valid Type, not {rtype}")
+
+        rsig = FunctionSignature((dtype, rtype))
+
+        if nargs == 3:
+            name = args[2]
+            if isinstance(name, str):
+                return rsig(name)
+            else:
+                raise Exception("Component name provide when instantiating Func is not a string")
+        else:
+            return rsig
+
+
+class RelationFactory:
+
+    def __call__(self, *args):
+
+        if len(args) == 0:
+            raise Exception("Must instantiate relations with one or more column types and an optional name")
+
+        nargs = len(args)
+        includes_name = isinstance(args[nargs - 1], str)
+        columns = nargs - 1 if includes_name else nargs
+        column_types = []
+        for i in range(columns):
+            if not isinstance(args[i], Type):
+                raise Exception(f"Relation signatures must comprise a types, not {args[i]}")
+
+            column_types.append(args[i])
+        rsig = RelationSignature(*column_types)
+
+        if includes_name:
+            return rsig(args[nargs - 1])
+        else:
+            return rsig
+
+
+class SequenceFactory:
+
+    def __init__(self, ctor):
+        self._ctor = ctor
+
+    def __call__(self, *args):
+
+        if len(args) == 0:
+            raise Exception("Must instantiate sequence types with an element type")
+
+        if len(args) > 2:
+            raise Exception("Cannot create sequences of composite element type")
+
+        element_type = args[0]
+        if not isinstance(element_type, Type):
+            raise Exception("First parameter of Sequence instance must be an element type")
+
+        seq = self._ctor(element_type)
+        if len(args) == 2:
+            if isinstance(args[1], str):
+                return seq(args[1])
+            else:
+                raise Exception("Can only instantiate sequence type with a string name")
+        else:
+            return seq
+
+
+# Constructors that can be used in Schema declarations for relations of
+# various kinds that are not declared in an ontology.
+#
+
+Rel = RelationFactory()
+Func = FunctionFactory()
+
+Seq = SequenceFactory(SequenceOne)
+Seq0 = SequenceFactory(SequenceZero)
+Iseq = SequenceFactory(InjectiveSequenceOne)
+Iseq0 = SequenceFactory(InjectiveSequenceZero)

relationalai/early_access/dsl/rulesets.py

@@ -0,0 +1,69 @@
+from relationalai.early_access.dsl.core.constraints import disjoint_union_of
+from relationalai.early_access.dsl.core.logic import LogicFragment
+from relationalai.early_access.dsl.core.logic.exists import existentially_quantify
+
+
+class RuleSet(LogicFragment):
+
+    def __init__(self, datoms, sconsts, uatoms):
+
+        def bound_variables(fvars, C):
+
+            bvars = {}
+            for c in C:
+                cdict = c.scalar_refs()
+                for v in cdict:
+                    if v not in fvars:
+                        bvars[v] = cdict[v]
+            return bvars
+
+        self._inline = False
+        LogicFragment.__init__(self)
+
+        self._decorated_atoms = datoms
+        freevars = {}
+        for a in datoms.values():
+            cdict = a.scalar_refs()
+            for v in cdict:
+                freevars[v] = cdict[v]
+
+        propcs = disjoint_union_of(sconsts, uatoms)
+        boundvars = bound_variables(freevars, propcs.values())
+
+        (self._sconstraints, self._atoms, econs) = existentially_quantify(boundvars, sconsts, uatoms)
+
+        rels = {}
+        for a in uatoms.values():
+            r = a.component()
+            rels[r.entityid()] = r
+
+        self._scalars = {v: freevars[v] for v in freevars}
+        for v in boundvars:
+            self._scalars[v] = boundvars[v]
+
+        self._relations = rels
+        if econs is not None:
+            self.add_existential_constraint(econs)
+
+    def body_formula(self):
+        return self.rel_formula()
+
+    def make_inline(self): self._inline = True
+
+    def pprint(self):
+
+        indent = "    "
+
+        datoms = self._decorated_atoms
+        head = [a.rule_head() for a in datoms.values()]
+
+        head_atoms = [atom.pprint() for atom in head]
+        head = f",\n{indent}".join(head_atoms)
+
+        body = indent + self.body_formula().replace("\n", f"\n{indent}")
+
+        rule = f"def {head}:\n{body}"
+        if self._inline:
+            return '@inline\n' + rule
+        else:
+            return rule