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

v0/relationalai/early_access/dsl/serialize/exporter.py

@@ -0,0 +1,163 @@
+import runpy
+
+from v0.relationalai.early_access.dsl.core.types.standard import standard_value_types
+from v0.relationalai.early_access.dsl.bindings.legacy import binding_models
+from v0.relationalai.early_access.dsl.ontologies import models, constraints
+from v0.relationalai.early_access.dsl.serialize.binding_model import BindingModelObject, BindingObject, BoundRole, BoundAttribute, \
+    DataTransformerApplication, DataTransformer, EntityMapRef, Pattern
+from v0.relationalai.early_access.dsl.serialize.model import ValueType, ModelObject, DataType, EntityType, Role, Reading, SubtypeArrow, \
+    Relationship,UniqueConstraint, MandatoryConstraint, Model, Constraints, Concepts
+
+ENTITY_PATTERN_NAME = 'Entity'
+
+
+def export_models(ontology_paths) -> list[ModelObject]:
+    result = []
+
+    # Add standard Data Types
+    data_types_list = []
+    for vt in standard_value_types.values():
+        data_types_list.append(DataType(id=vt.guid(), name=vt.display()))
+
+    # Scan for Models in given paths
+    for path in ontology_paths:
+        module_globals = runpy.run_path(path)
+        value_types_list = []
+        entity_types_list = []
+        relationships_list = []
+        subtype_arrows_list = []
+        has_primary = False
+        for var in module_globals:
+            obj = module_globals[var]
+            if isinstance(obj, models.Model):
+                if has_primary and obj.is_primary:
+                    raise ValueError('Only one primary model per ontology is allowed.')
+                if obj.is_primary:
+                    has_primary = True
+
+                uniqueness_list = []
+                mandatory_list = []
+
+                for vt in obj._value_types.values():
+                    decl = vt._params[0].decl
+                    value_types_list.append(
+                        ValueType(id=vt.guid(), name=vt.display(), data_type=decl.guid(), data_type_name=decl.display()))
+
+                for et in obj._entity_types.values():
+                    entity_types_list.append(
+                        EntityType(id=et.guid(), name=et.display(), domain=list(map(lambda d: d.display(), et._domain))))
+
+                for rel in obj._relationships.values():
+                    rel_roles = []
+                    for role in rel._rolemap.values():
+                        rel_roles.append(
+                            Role(id=role.guid(), name=role.name(), role_player=role.player().guid(),
+                                 role_player_name=role.player().display(),
+                                 pre_bound_text=role._prefix,
+                                 post_bound_text=role._postfix))
+
+                    rel_readings = []
+                    for reading in rel.readings():
+                        rel_readings.append(Reading(id=reading.guid(), text=reading.template(),
+                                                    roles=list(map(lambda r: r.guid(), reading.roles))))
+
+                    relationships_list.append(
+                        Relationship(id=rel.guid(), name=rel._name(), roles=rel_roles, readings=rel_readings,
+                                     is_subtype=rel._is_subtype))
+
+                for c in obj._constraints:
+                    if isinstance(c, constraints.Unique):
+                        uniqueness_list.append(
+                            UniqueConstraint(id=c.guid(), roles=list(map(lambda r: r.guid(), c.roles())),
+                                             is_preferred_identifier=c.is_preferred_identifier))
+                    elif isinstance(c, constraints.Mandatory):
+                        mandatory_list.append(MandatoryConstraint(id=c.guid(), roles=[c.role.guid()]))
+
+                for a in obj._subtype_arrows:
+                    subtype_arrows_list.append(
+                        SubtypeArrow(id=a.guid(), start=a.start.guid(), end=a.end.guid(), start_name=a.start.display(),
+                                     end_name=a.end.display()))
+
+                result.append(ModelObject(model=Model(id=obj.guid(), name=obj.name, is_primary=obj.is_primary,
+                                                      concepts=Concepts(value_types=value_types_list,
+                                                                        entity_types=entity_types_list),
+                                                      relationships=relationships_list,
+                                                      constraints=Constraints(uniqueness=uniqueness_list,
+                                                                              mandatory=mandatory_list),
+                                                      data_types=data_types_list,
+                                                      subtype_arrows=subtype_arrows_list)))
+    return result
+
+
+def export_model_json(ontology: list[ModelObject]) -> str:
+    return ModelObject.schema().dumps(ontology, many=True) # type: ignore
+
+
+def export_binding_model(binding_model_path) -> BindingModelObject:
+    module_globals = runpy.run_path(binding_model_path)
+    binding_list = []
+    data_transformer_list = []
+    # Reification pattern support is a TODO
+    pattern_list = []
+    entity_map_list = []
+    for var in module_globals:
+        obj = module_globals[var]
+        if isinstance(obj, binding_models.BindingModel):
+            for b in obj._bindings:
+                ro = b.role
+                col = b.column
+                attr = BoundAttribute(
+                    name=col.name,
+                    source=col.part_of.name,
+                    hasValue=b.has_value,
+                ) if col is not None else None
+                bo = BindingObject(
+                    id=b.guid(),
+                    role=BoundRole(
+                        player=ro.player_type._name,
+                        relationship=ro.part_of._name(),
+                        entityMapRef=b.entity_map.name if b.entity_map is not None else None),
+                    attribute=attr,
+                )
+                # Filter out potential None values then flatten the list first if it becomes (single) nested
+                b._applied_transformations = list(filter(lambda x: x is not None, b._applied_transformations))
+                b._applied_transformations = [item for sublist in b._applied_transformations for item in sublist]
+                if b._applied_transformations and len(b._applied_transformations) > 0:
+                    bo.transformations = list(
+                        map(
+                            lambda t: DataTransformerApplication(transformer=t._relname),
+                            b._applied_transformations
+                        )
+                    )
+                binding_list.append(bo)
+            data_transformer_list = list(map(
+                lambda kv: DataTransformer(
+                    name=kv[0],
+                    sourceType=kv[1][0]._name.upper(),
+                    targetType=kv[1][1]._name.upper()
+                ),
+                obj._transformers.items()
+            ))
+            entity_map_list = list(map(
+                lambda kv: EntityMapRef(
+                    name=kv.name,
+                    source=kv.source.name,
+                    entityType=kv.entity_type._name,
+                    relation=kv.relation.qualified_name()
+                ),
+                obj._entity_maps.values()
+            ))
+            pattern_list = list(map(
+                lambda kv: Pattern(
+                    conceptName=kv[0].__name__,
+                    # We use a little different naming convention for entity reificaiton pattern
+                    pattern=kv[1].__name__.replace(EntityType.__name__, ENTITY_PATTERN_NAME)
+                ),
+                obj._patterns.items()
+            ))
+    return BindingModelObject(bindings=binding_list, patterns=pattern_list, dataTransformers=data_transformer_list,
+                              entityMaps=entity_map_list)
+
+
+def export_binding_model_json(binding_model: BindingModelObject) -> str:
+    return BindingModelObject.schema().dumps(binding_model) # type: ignore

v0/relationalai/early_access/dsl/snow/api.py

@@ -0,0 +1,104 @@
+from typing import cast, Optional
+
+import v0.relationalai as rai
+from v0.relationalai import Config
+from v0.relationalai.early_access.dsl.snow.common import TabularMetadata, ColumnMetadata, SchemaMetadata, \
+    ForeignKey, ColumnRef
+
+
+class Executor:
+    def __init__(self, config: Optional[Config] = None):
+        self._provider = cast(rai.clients.snowflake.Provider, rai.Provider(config=config))
+        self._table_meta_cache = {}
+        self._schema_fk_cache = {}
+
+    def table_metadata(self, name: str):
+        self._validate_table_name(name)
+        if name in self._table_meta_cache:
+            return self._table_meta_cache[name]
+        # name comes in the form of `{database_name}.{schema_name}.{table_name}`
+        database_nm, schema_nm, table_nm = name.upper().split(".")
+        query = f"""
+        SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE, IS_NULLABLE, NUMERIC_PRECISION, NUMERIC_PRECISION_RADIX, NUMERIC_SCALE
+        FROM {database_nm}.INFORMATION_SCHEMA.COLUMNS
+        WHERE TABLE_SCHEMA = '{schema_nm}' AND TABLE_NAME = '{table_nm}'
+        ORDER BY TABLE_NAME, COLUMN_NAME, DATA_TYPE
+        """
+        # execute SQL
+        rez = self._provider.sql(query)
+        meta = self._parse_table_metadata(name, rez)
+        # supplement with FKs
+        schema_nm = f"{database_nm}.{schema_nm}".lower()
+        self._supplement_with_foreign_keys(meta, schema_nm)
+        # cache before returning
+        self._table_meta_cache[name] = meta
+        return meta
+
+    def _supplement_with_foreign_keys(self, tb_meta, schema_name: str):
+        schema_fk_meta = self.schema_foreign_keys(schema_name)
+        # suboptimal but works for now
+        for fk in schema_fk_meta.foreign_keys:
+            if tb_meta.name == fk.source_columns[0].table:
+                tb_meta.foreign_keys.add(fk)
+
+    @staticmethod
+    def _parse_table_metadata(name, result):
+        meta = TabularMetadata(name=name)
+        for row in result:
+            attr = ColumnMetadata(
+                name=row['COLUMN_NAME'],
+                datatype=row['DATA_TYPE'],
+                is_nullable=row['IS_NULLABLE'] == 'YES',
+                numeric_precision=row['NUMERIC_PRECISION'],
+                numeric_precision_radix=row['NUMERIC_PRECISION_RADIX'],
+                numeric_scale=row['NUMERIC_SCALE']
+            )
+            meta.columns.append(attr)
+        return meta
+
+    @staticmethod
+    def _validate_table_name(name):
+        # check if the table name is in the form of `{database_name}.{schema_name}.{table_name}`
+        if len(name.split('.')) != 3:
+            raise ValueError(f'Table name {name} is not in the correct format')
+
+    def schema_foreign_keys(self, name):
+        self._validate_schema_name(name)
+        if name in self._schema_fk_cache:
+            return self._schema_fk_cache[name]
+
+        # name comes in the form of `{database_name}.{schema_name}`
+        query = f"""
+        SHOW IMPORTED KEYS IN SCHEMA {name};
+        """
+        rez = self._provider.sql(query)
+        meta = self._parse_schema_foreign_keys(name, rez)
+        self._schema_fk_cache[name] = meta
+        return meta
+
+    @staticmethod
+    def _parse_schema_foreign_keys(name, results):
+        metadata = SchemaMetadata(name=name)
+        for row in results:
+            fk_table_nm = f'{row["fk_database_name"]}.{row["fk_schema_name"]}.{row["fk_table_name"]}'.lower()
+            pk_table_nm = f'{row["pk_database_name"]}.{row["pk_schema_name"]}.{row["pk_table_name"]}'.lower()
+            # get columns refs, since FK may be composite, we need to handle multiple columns
+            # TODO: implement multi-col FK support
+            source_cols = [ColumnRef(fk_table_nm, row['fk_column_name'])]
+            target_cols = [ColumnRef(pk_table_nm, row['pk_column_name'])]
+            fk = ForeignKey(
+                name=row['fk_name'],
+                source_columns=source_cols,
+                target_columns=target_cols
+            )
+            metadata.foreign_keys.append(fk)
+        return metadata
+
+    @staticmethod
+    def _validate_schema_name(name):
+        # check if the schema name is in the form of `{database_name}.{schema_name}`
+        if len(name.split('.')) != 2:
+            raise ValueError(f'Schema name {name} is not in the correct format')
+
+    def provider(self):
+        return self._provider

v0/relationalai/early_access/dsl/snow/common.py

@@ -0,0 +1,76 @@
+import dataclasses
+from typing import Optional
+
+from v0.relationalai.semantics.internal import internal as builder
+from v0.relationalai.semantics import Float, Int128, String, Bool, Date, DateTime, Concept as QBConcept
+
+#=
+# Physical metadata for a Snowflake table.
+#=
+
+@dataclasses.dataclass(frozen=True)
+class ColumnRef:
+    table: str
+    column: str
+
+@dataclasses.dataclass
+class ForeignKey:
+    name: str
+    source_columns: list[ColumnRef] = dataclasses.field(default_factory=list)
+    target_columns: list[ColumnRef] = dataclasses.field(default_factory=list)
+
+    def __hash__(self):
+        return hash(self.name)
+
+@dataclasses.dataclass
+class SchemaMetadata:
+    name: str
+    foreign_keys: list[ForeignKey] = dataclasses.field(default_factory=list)
+
+@dataclasses.dataclass
+class ColumnMetadata:
+    name: str
+    datatype: str
+    is_nullable: bool
+    numeric_precision: Optional[int] = None
+    numeric_precision_radix: Optional[int] = None
+    numeric_scale: Optional[int] = None
+
+@dataclasses.dataclass
+class CsvColumnMetadata:
+    name: str
+    datatype: QBConcept
+
+@dataclasses.dataclass
+class TabularMetadata:
+    name: str
+    columns: list[ColumnMetadata] = dataclasses.field(default_factory=list)
+    foreign_keys: set[ForeignKey] = dataclasses.field(default_factory=set)
+
+
+_sf_type_mapping = {
+    'varchar': String,
+    'char': String,
+    'text': String,
+    'date': Date,
+    'datetime': DateTime,
+    'timestamp_ntz': DateTime,
+    'timestamp_tz': DateTime,
+    'boolean': Bool,
+    'float': Float,
+}
+
+def _map_rai_type(col: ColumnMetadata) -> QBConcept:
+    datatype = col.datatype.lower()
+    if datatype == 'number' or datatype == 'fixed':
+        if col.numeric_scale is not None and col.numeric_scale > 0:
+            return _map_decimal_type(col.numeric_precision, col.numeric_scale)
+        else:
+            return Int128
+    else:
+        return _sf_type_mapping[datatype]
+
+def _map_decimal_type(precision: Optional[int], scale: Optional[int]) -> QBConcept:
+    if precision is None or scale is None:
+       raise ValueError("Size and scale must be provided for decimal type mapping")
+    return builder.decimal_concept(precision, scale)

v0/relationalai/early_access/dsl/state_mgmt/__init__.py

@@ -0,0 +1,129 @@
+from v0.relationalai.early_access.dsl.schemas import ConjunctiveSchema, DisjunctiveSchema
+from v0.relationalai.early_access.dsl.schemas.components import prefix_concat, SchemaComponent
+
+class StateManager:
+
+    def And(self, *args): return ConjunctiveSchema(*args)
+    def Or(self, *args): return DisjunctiveSchema(*args)
+
+
+class ComponentWrapper:
+
+    class Wrapper:
+        def __init__(self, pref, m, k):
+            self._prefix = pref
+            self._machine = m
+            self._funcname = k
+
+        def __call__(self, *args, **kwargs):
+            func = getattr(self._machine, self._funcname)
+            return { self._prefix: func(*args, **kwargs) }
+
+    def __init__(self, machine, prefix):
+        for key, val in vars(machine.__class__).items():
+            if callable(val):
+                setattr(self, key, ComponentWrapper.Wrapper(prefix, machine, key))
+
+class VarWrapper:
+
+    def __init__(self, comp, container):
+        self._comp = comp
+        for key, val in vars(comp._prototype).items():
+            if isinstance(val, SchemaComponent):
+                if key in comp._renamings:
+                    c2 = getattr(container, comp._renamings[key])
+                else:
+                    c2 = getattr(container, comp._decorate_component_name(val.display())) # type: ignore
+                setattr(self, key, c2)
+
+class StateComponent:
+
+    def __init__(self, compname, machine, renamings):
+        self._compname = compname
+        self._machine = machine
+        self._prototype = machine.top()
+        self._renamings = renamings
+
+    def __call__(self, proto=None):
+        if proto is None:
+            state = self._prototype
+        else:
+            state = proto
+
+        s = self._decorate(state)
+        map = {}
+        for r in self._renamings:
+            nm = self._decorate_component_name(r)
+            map[nm] = self._renamings[r]
+        return s.sync(map)
+
+    def _decorate(self, proto_state): return proto_state.prefix(self._compname)
+    def _decorate_component_name(self, nm): return prefix_concat(self._compname, nm)
+
+    def machine(self): return self._machine
+
+    def var_wrapper(self, container):
+        return VarWrapper(self, container)
+
+class UndecoratedStateComponent(StateComponent):
+
+    def __init__(self, compname, machine, renamings):
+        super().__init__(compname, machine, renamings)
+
+    def _decorate(self, proto_state): return proto_state
+    def _decorate_component_name(self, nm): return nm
+
+
+class TransitionComponent:
+
+    def __init__(self, compname, trans, renamings):
+        self._compname = compname
+        self._trans = trans
+        self._prototype = trans.top()
+        self._renamings = renamings
+
+    def __call__(self, proto=None):
+        if proto is None:
+            trans = self._prototype
+        else:
+            trans = proto
+
+        t = self._decorate(trans)
+
+        # Rename before-state variables according to renamings
+        before_var_prior_to_rename = {}
+        map = {}
+        for r in self._renamings:
+            nm = self._decorate_component_name(r)
+            before_var_prior_to_rename[r] = getattr(t, nm)    # [REKS: Use a more direct way to lookup component by name]
+            map[nm] = self._renamings[r]
+        t2 = t.sync(map)
+
+        before_var_after_rename = {}
+        for r in self._renamings:
+            renamed = self._renamings[r]
+            if isinstance(renamed, str):
+                before_var_after_rename[r] = getattr(t2, self._renamings[r])
+            else:
+                before_var_after_rename[r] = renamed
+
+        after_renamings = {}
+        for r in self._renamings:
+            after_renamings = after_renamings | before_var_prior_to_rename[r].after.sync_with(before_var_after_rename[r].after)
+
+        # Rename after-state variables according to renamings
+
+        return t2.sync(after_renamings)
+
+    def _decorate(self, proto_trans): return proto_trans.prefix(self._compname)
+    def _decorate_component_name(self, nm): return prefix_concat(self._compname, nm)
+
+    def manager(self): return self._trans
+
+class UndecoratedTransitionComponent(TransitionComponent):
+
+    def __init__(self, compname, trans, renamings):
+        super().__init__(compname, trans, renamings)
+
+    def _decorate(self, proto_trans): return proto_trans
+    def _decorate_component_name(self, nm): return nm

v0/relationalai/early_access/dsl/state_mgmt/state_charts.py

@@ -0,0 +1,125 @@
+from abc import abstractmethod
+
+from v0.relationalai.early_access.dsl.schemas import Schema
+from v0.relationalai.early_access.dsl.state_mgmt import ComponentWrapper, StateManager, StateComponent, UndecoratedStateComponent
+
+class StateChart(StateManager):
+
+    def after_state(self, parent_state=None):
+        if parent_state is None:
+            parent_state = self.top()
+        return parent_state.decorate()
+
+    # User asserts that relation rel is empty in this state
+    #
+    def is_empty(self, rel): return self.top().add_predicate_constraint(rel.empty())
+
+    def manage_transitions(self, tm):
+        self._transition_mgr = tm
+
+    # User-declared start state for this state machine
+    #
+    @abstractmethod
+    def inactive(self) -> Schema:
+        pass
+
+    # Method for constructing a state of this machine from parameters, described
+    # in subclasses that override this method.
+    #
+    @abstractmethod
+    def state(self) -> Schema:
+        pass
+
+    # User-declared top-state for this state machine
+    #
+    @abstractmethod
+    def top(self) -> Schema:
+        pass
+
+    def transition_manager(self): return self._transition_mgr
+
+class SimpleStateChart(StateChart):
+
+    def active(self): return self.top()
+    def inactive(self): return self.top()
+
+    # Returns a blank state (no variables or constraints). This will be the
+    # prototype from which to fill in the variables and constraints of a
+    # simple state machine
+    #
+    def blank_state(self): return self.And()
+
+    # Generates a state (schema) for this StateChart. If an optional
+    # parent state is provided, then the state returned by this method
+    # will be a substate of the parent state.
+    #
+    def state(self, parent_state=None):
+        if parent_state is None:
+            parent_state = self.top()
+
+        # Return a copy of parent_state so that clients can add variables
+        # and constraints without overriding the parent_state
+        #
+        return self.And(parent_state)
+
+class CompositeStateChart(StateChart):
+
+    def __init__(self):
+        self._components = {}
+
+    def add_component(self, compname, machine, *syncs):
+        renamings = {}
+        for r in syncs:
+           renamings = renamings | r
+        self._components[compname] = StateComponent(compname, machine, renamings)
+        self.__setattr__(compname, ComponentWrapper(machine, compname))
+
+    def add_undecorated_component(self, compname, machine, *syncs):
+        renamings = {}
+        for r in syncs:
+           renamings = renamings | r
+        self._components[compname] = UndecoratedStateComponent(compname, machine, renamings)
+        self.__setattr__(compname, ComponentWrapper(machine, compname))
+
+    def active(self):
+        comp_state = {}
+        for c in self._components:
+            comp = self._components[c]
+            comp_state[c] = comp.machine().active()
+        return self.state(comp_state)
+
+    def component(self, name): return self._components[name]
+
+    def component_machine(self, name):
+        return self.component(name).machine()
+
+    def inactive(self):
+        comp_state = {}
+        for c in self._components:
+            comp = self._components[c]
+            comp_state[c] = comp.machine().inactive()
+        return self.state(comp_state)
+
+    # Generates a state (schema) for this CompositeStateChart given
+    # a dictionary mapping component names to specifications of the
+    # desired state of each component.
+    #
+    def state(self, *comp_state):
+        component_states = {}
+        for d in comp_state:
+           component_states = component_states | d
+
+        states = []
+        for c in self._components:
+            comp = self._components[c]
+            if c in component_states:
+                states.append(comp(component_states[c]))
+            else:
+                states.append(comp(comp._prototype))
+        s = self.And(*tuple(states))
+
+        for c in self._components.values():
+            s.__setattr__(c._compname, c.var_wrapper(s))
+        return s
+
+    def top(self): return self.state({})