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

relationalai/early_access/dsl/serialize/exporter.py

@@ -1,163 +0,0 @@
-import runpy
-
-from relationalai.early_access.dsl.core.types.standard import standard_value_types
-from relationalai.early_access.dsl.bindings.legacy import binding_models
-from relationalai.early_access.dsl.ontologies import models, constraints
-from relationalai.early_access.dsl.serialize.binding_model import BindingModelObject, BindingObject, BoundRole, BoundAttribute, \
-    DataTransformerApplication, DataTransformer, EntityMapRef, Pattern
-from 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

relationalai/early_access/dsl/snow/api.py

@@ -1,105 +0,0 @@
-from typing import cast, Optional
-
-import relationalai as rai
-from relationalai import Config
-from relationalai.clients.resources.snowflake import Provider
-from relationalai.early_access.dsl.snow.common import TabularMetadata, ColumnMetadata, SchemaMetadata, \
-    ForeignKey, ColumnRef
-
-
-class Executor:
-    def __init__(self, config: Optional[Config] = None):
-        self._provider = cast(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

relationalai/early_access/dsl/snow/common.py

@@ -1,76 +0,0 @@
-import dataclasses
-from typing import Optional
-
-from relationalai.semantics.internal import internal as builder
-from 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)

relationalai/early_access/dsl/state_mgmt/__init__.py

@@ -1,129 +0,0 @@
-from relationalai.early_access.dsl.schemas import ConjunctiveSchema, DisjunctiveSchema
-from 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

relationalai/early_access/dsl/state_mgmt/state_charts.py

@@ -1,125 +0,0 @@
-from abc import abstractmethod
-
-from relationalai.early_access.dsl.schemas import Schema
-from 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({})