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

relationalai/early_access/dsl/state_mgmt/transitions.py

@@ -1,130 +0,0 @@
-from relationalai.early_access.dsl.state_mgmt import ComponentWrapper, StateManager, TransitionComponent, UndecoratedStateComponent, UndecoratedTransitionComponent
-
-class Transition(StateManager):
-
-    def __init__(self, sm):
-        self._state_chart = sm
-
-    # The transition that when fired activates this state machine from its
-    # declared start state. Users override this method to declare more precise
-    # effects of this operation.
-    #
-    def activate(self):
-        return self.And(self.top(),
-                        self._state_chart.inactive(),
-                        self._state_chart.active().decorate())
-
-    # An active transition starts and ends in the Active state. Most user-declared
-    # transitions will be either activate or active transitions.
-    #
-    def active(self):
-        return self.And(self.top(),
-                        self.state_chart().active(),
-                        self.state_chart().active().decorate())
-
-    def after_state(self): return self._state_chart.after_state()
-    def before_state(self): return self._state_chart.top()
-
-    def top(self):
-        return self.And(self.before_state(),
-                        self.after_state())
-
-    def state_chart(self): return self._state_chart
-
-class SimpleTransition(Transition):
-
-    def __init__(self, sm):
-        super().__init__(sm)
-
-    # The transition method of a SimpleTransition composes the transition
-    # by conjoining before and after instances of the state machine being managed.
-    # By default, these are the values returned by the before_state and after_state
-    # methods respectively, but these may be overridden by keyword arguments 'before'
-    # and 'after'.
-    #
-    def transition(self, **kwargs):
-        if len(kwargs) > 2:
-            raise Exception("Not possible")
-
-        for a in kwargs:
-            if a != 'before' and a != 'after':
-                raise Exception("Only permissible keyword arguments to SimpleTransition.transition are 'before' and 'after'")
-        if 'after' in kwargs:
-            after_state = kwargs['after']
-        else:
-            after_state = self.after_state()
-
-        if 'before' in kwargs:
-            before_state = kwargs['before']
-        else:
-            before_state = self.before_state()
-
-        return self.And(before_state, after_state)
-
-class CompositeTransition(Transition):
-
-    def __init__(self, sm):
-        super().__init__(sm)
-        self._components = {}
-
-        comps = sm._components
-        for c in comps:
-            comp = comps[c]
-            if isinstance(comp, UndecoratedStateComponent):
-                self.add_undecorated_component(c, comp.machine().transition_manager())
-            else:
-                self.add_component(c, comp.machine().transition_manager())
-
-    def activate(self):
-        t = super().activate()
-
-        transitions = []
-        for c in self._components.values():
-            transitions.append(c(c.manager().activate()))
-
-        return self.And(t, *tuple(transitions))
-
-    def add_component(self, compname, transm):
-        state_mgr = self._state_chart
-        state_components = state_mgr._components
-        renamings = {}
-        if compname in state_components:
-            renamings = state_components[compname]._renamings
-
-        self._components[compname] = TransitionComponent(compname, transm, renamings)
-        self.__setattr__(compname, ComponentWrapper(transm, compname))
-
-    def add_undecorated_component(self, compname, machine):
-        state_mgr = self._state_chart
-        state_components = state_mgr._components
-        renamings = {}
-        if compname in state_components:
-            renamings = state_components[compname]._renamings
-        self._components[compname] = UndecoratedTransitionComponent(compname, machine, renamings)
-        self.__setattr__(compname, ComponentWrapper(machine, compname))
-
-    def component(self, name): return self._components[name]
-
-    def top(self):
-        t = super().top()
-        t2 = self.transition({})
-        return self.And(t, t2)
-
-    def transition(self, *transitions):
-        component_transitions = {}
-        for d in transitions:
-           component_transitions = component_transitions | d
-
-        transitions = []
-        for c in self._components:
-            comp = self._components[c]
-            if c in component_transitions:
-                transitions.append(comp(component_transitions[c]))
-            else:
-                transitions.append(comp(comp._prototype))
-        return self.And(*tuple(transitions))
-
-    def join_operations(self, *transitions):
-        return self.And(self.active(),
-                        self.transition(*transitions))
-

relationalai/early_access/dsl/types/__init__.py

@@ -1,40 +0,0 @@
-from typing import Optional
-
-from relationalai.early_access.dsl.core.relations import Relation, AbstractRelation
-
-
-class AbstractConcept:
-
-    # We can add relation components to a ConceptModule by invoking it
-    # with arguments that interleave reading text with the Types used
-    # to play various Roles
-    #
-    def __setattr__(self, key, value):
-        if key in dir(self) and key not in self.__dict__:
-            raise Exception(f"Cannot override method {key} of Type {self._name} as an attribute.")
-        else:
-            if key[0] != '_':
-                self._relations[key] = value
-            return super().__setattr__(key, value)
-
-    def __getitem__(self, key):
-        return self.__dict__[key]
-
-    def __init__(self, model, name):
-        self._name = name
-        self._model = model
-        self._relations = {}
-
-    def relation(self, *args, name: Optional[str] = None, functional: bool=False) -> Relation:
-        if len(args) == 1 and not isinstance(args[0], str):
-            raise ValueError("For binary or higher order relations parameter 'args' should contain "
-                            "Sequence of text fragments followed by Types.")
-        relationship = self._model.relationship(*[self, *args], relation_name=name)
-        rel = next(iter(relationship.relations()), None)
-        if rel is not None:
-            rel.signature().set_functional(functional)
-            return rel
-        raise Exception(f"Could not find relation for relationship {relationship.name()}")
-
-    def _add_relation(self, relation: AbstractRelation):
-        self.__setattr__(relation._relname, relation)

relationalai/early_access/dsl/types/concepts.py

@@ -1,12 +0,0 @@
-from typing import Optional
-
-from relationalai.early_access.dsl.core.types.concepts import Concept as CoreConcept
-from relationalai.early_access.dsl.types import AbstractConcept
-from relationalai.early_access.dsl.core.types import Type as CoreType
-
-
-class Concept(AbstractConcept, CoreConcept):
-
-    def __init__(self, model, name, extends: Optional[CoreType]=None):
-        super().__init__(model, name)
-        CoreConcept.__init__(self, name, extends)

relationalai/early_access/dsl/types/entities.py

@@ -1,135 +0,0 @@
-from typing import Optional
-
-from relationalai.early_access.dsl import ExternalRelation, EntityPopulationRelation, Namespace
-from relationalai.early_access.dsl.core.exprs import _
-from relationalai.early_access.dsl.core.relations import RelationSignature, rule, EntityInstanceRelation
-from relationalai.early_access.dsl.core.rules import Rule, Vars
-from relationalai.early_access.dsl.core.types.standard import standard_value_types, Hash
-from relationalai.early_access.dsl.types import AbstractConcept
-from relationalai.early_access.dsl.core.types import Type as CoreType
-
-
-class AbstractEntityType(AbstractConcept, CoreType):
-
-    def __init__(self, model, name):
-        super().__init__(model, name)
-        CoreType.__init__(self, name)
-        self._poprel = None
-
-    def population(self):
-        if self._poprel is None:
-            self._poprel = EntityPopulationRelation(self.namespace(), self.display(), RelationSignature(self))
-        return self._poprel
-
-    def ctor_name(self): return f"^{self.display()}"
-
-    def entity(self): return True
-
-    def addrule(self, rule):
-        relation = self.population()
-        self._model._add_relation(relation)
-        if not isinstance(rule, Rule):
-            # Assume that rule is a Python function that, when invoked can build a rule
-            rule = Rule(relation).elaborate(rule)
-        relation._rules.append(rule)
-        return rule
-
-    def entity_instance_relation(self, name:str, namespace: Optional[Namespace]=None):
-        rel = EntityInstanceRelation(namespace, name, RelationSignature(self))
-        self._add_relation(rel)
-        return rel
-
-    @staticmethod
-    def root_unconstrained_type():
-        return standard_value_types['Hash']
-
-class EntityType(AbstractEntityType):
-
-    def __init__(self, model, nm, *args, ref_schema_name: Optional[str] = None):
-        super().__init__(model, nm)
-        self._domain = [*args]
-        self._constructor = None
-        self._ref_schema_name = ref_schema_name
-
-    def __xor__(self, args):
-        ctr = self.constructor()
-        if ctr is None:
-            raise Exception(
-                f"Entity '{self.display()}' domain is empty or this Entity is not a subtype of another EntityType with constructor")
-        return ctr(*args)
-
-    def build_relation_variable(self, args, kwargs):
-        if len(args) == 0:
-            raise Exception(f"Unexpected error in EntityType {self.display()}")
-
-        if len(args) > 1:
-            raise Exception(f"Cannot declare type variable of EntityType {self.display()} by supplying more than a type")
-
-        if len(kwargs) != 0:
-            raise Exception(
-                f"Cannot use keyword arguments when instantiating a type parameter for EntityType {self.display()}")
-
-        type = args[0]
-        self._domain.append(type)
-        return type
-
-    def build_scalar_variable(self, args, kwargs):
-        if len(args) == 0:
-            raise Exception(f"Unexpected error in EntityType {self.display()}")
-
-        if len(args) > 1:
-            raise Exception(f"Cannot declare type variable of EntityType {self.display()} by supplying more than a type")
-
-        if len(kwargs) != 0:
-            raise Exception(
-                f"Cannot use keyword arguments when instantiating a type parameter for EntityType {self.display()}")
-
-        type = args[0]
-        self._domain.append(type)
-        return type
-
-    # An EntityTypeConstructor is an n-ary functional Relation that maps tuples of
-    # arity (n-1) to instances of the EntityType.
-    def constructor(self):
-        if self._constructor is None:
-            # Create a constructor function (relation) when this EntityType is created
-            ctortype = self.domain().copy()
-            ctortype.append(self)
-            self._constructor = ExternalRelation(self.namespace(),
-                                                 self.ctor_name(),
-                                                 RelationSignature(*tuple(ctortype)))
-        return self._constructor
-
-    def first(self, relation):
-        with self:
-            @rule()
-            def r(e):
-                relation(e, _)
-
-    def filtered_by(self, filter, value):
-        with self:
-            @rule()
-            def r(e):
-                v = Vars(Hash)
-                #
-                value(v)
-                filter(e, v)
-
-    def qualified_name(self):
-        return self._name
-
-    def domain(self):
-        return self._domain
-
-    def is_composite(self):
-        return len(self._domain) > 1
-
-    def ref_schema_name(self):
-        return self._ref_schema_name
-
-    def pprint(self):
-        domain_str = ", ".join([f"x{i} in {t.display()}" for i, t in enumerate(self._domain)])
-        return f"entity type {self.display()}({domain_str})"
-
-    def __str__(self):
-        return f'EntityType({self.display()})'

relationalai/early_access/dsl/types/values.py

@@ -1,17 +0,0 @@
-from relationalai.early_access.dsl.types import AbstractConcept
-from relationalai.early_access.dsl.core.types.constrained.nominal import ValueType as CoreValueType
-from relationalai.early_access.dsl.core.types.constrained.subtype import ValueSubtype as CoreValueSubtype
-
-
-class ValueType(AbstractConcept, CoreValueType):
-
-    def __init__(self, model, nm, *args):
-        super().__init__(model, nm)
-        CoreValueType.__init__(self, nm, *args)
-
-
-class ValueSubtype(AbstractConcept, CoreValueSubtype):
-
-    def __init__(self, model, nm, *args):
-        super().__init__(model, nm)
-        CoreValueSubtype.__init__(self, nm, *args)

relationalai/early_access/dsl/utils.py

@@ -1,102 +0,0 @@
-from relationalai.early_access.dsl.core.types import Type
-from relationalai.early_access.dsl.core.utils import camel_to_snake, to_rai_way_string, to_pascal_case
-from relationalai.early_access.dsl.constants import VERBAL_PART_CONNECTION
-from relationalai.early_access.dsl.ontologies.roles import Role
-
-def normalize(s):
-    return "\n".join(line.strip() for line in s.splitlines() if line.strip())
-
-def build_relation_name(roles, verbal_parts):
-    """
-    Build the relation name from the verbal parts and roles. The relation name does not include the namespace.
-    We can derive the name of the relation from the Role names and the reading (verbal_parts).
-
-    Simple case: the Relationship is either unary or binary.
-    In case when the reading starts with:
-    - "is": we use the reading omitting "is";
-    - "has": we use the reading omitting "has";
-    if role doesn't have a name then role's player name transformed from camel case to snake is used.
-    - otherwise, the reading is used.
-    Examples:
-    - reading: "{Person} is female" -> namespace: "person", relation name: "female"
-    - reading: "{Person} has birth {Date}" -> namespace: "person", relation name: "birth"
-    - reading: "{Account} has {AccountNr}" -> namespace: "account", relation name: "nr" (or "account_nr" when role has no name)
-    - reading: "{Account} created on {Date}" -> namespace: "account", relation name: "created_on"
-
-    Complex case: the Relationship has more than two Roles.
-    We typically omit the name of the first Role in the reading, use the rest of the reading filling in
-    the role name positions with the names.
-    Examples:
-    - reading: "{Person} has {Child} born on {Date}" -> namespace: "person", relation name: "has_child_born_on_date"
-    - reading: "{Account} on {Date} has activation- {Event}" -> namespace: "account", relation name: "on_date_has_activation_event"
-
-    """
-    rel_name = ""
-    if len(roles) == 1:  # for unary relations
-        if len(verbal_parts) > 0:
-            rel_name = to_rai_way_string(verbal_parts[0])
-        if not rel_name:
-            rel_name = _get_role_name(roles[0])
-    elif len(roles) == 2:  # for binary relations
-        s_role = roles[1]
-        if len(verbal_parts) > 0:
-            rel_name = to_rai_way_string(verbal_parts[0])
-            if verbal_parts[0].strip().startswith(("has", "is")):
-                if not rel_name:
-                    rel_name += _get_role_name(s_role)
-        else:
-            rel_name = _get_role_name(s_role)
-    else:
-        # assumption that len(roles) - 1 == len(verbal_parts)
-        join_parts = [to_rai_way_string(verbal_parts[0], False)]
-        for i in range(1, len(roles)): # skip the first role
-            role = roles[i]
-            join_parts.append(_get_role_name(role))
-            if i < len(roles) - 1:  # append verbal part after each iteration except the last one
-                join_parts.append(to_rai_way_string(verbal_parts[i]))
-        rel_name = VERBAL_PART_CONNECTION.join(join_parts)
-    return rel_name
-
-def build_relationship_name(roles, verbal_parts):
-    """
-    Build the relationship name from the verbal parts and roles.
-
-    """
-    relationship_name = ""
-    for i in range(len(roles)):
-        relationship_name += to_pascal_case(roles[i].verbalize())
-        # assumption that len(roles) >= than len(verbal_parts)
-        if i < len(verbal_parts):
-            relationship_name += to_pascal_case(verbal_parts[i])
-
-    return relationship_name
-
-def extract_relation_text_with_signature(*args):
-    types = []
-    text_frags = []
-    if len(args) < 2:
-        raise Exception("Invalid declaration for the unary relation. Type should be followed by a text.")
-
-    for i in range(len(args)):
-        a = args[i]
-        # even must be 'Type' and odd must be 'str'
-        if i % 2 == 0:
-            if not isinstance(a, Type):
-                raise Exception(f"Invalid declaration for the relation. Argument {i + 1} is not a type.")
-            types.append(a)
-        else:
-            if not isinstance(a, str):
-                raise Exception(f"Invalid declaration for the relation. Argument {i + 1} is not a text.")
-            text_frags.append(a)
-    # check that N-ary relation ends with Type. Exclude the case for unary when args == 2: (Person, "is adult")
-    if len(text_frags) == len(types) and len(args) > 2:
-        raise Exception("Invalid declaration for the relation. Relations with arity > 2 must end with a type.")
-
-    return text_frags, types
-
-def _get_role_name(role) -> str:
-    if isinstance(role, Type):
-        return camel_to_snake(role.display())
-    elif isinstance(role, Role):
-        return to_rai_way_string(role.ref_name(), False) if role.name else camel_to_snake(role.player().display())
-    raise Exception(f"Invalid declaration for the relation. Argument {role} is not a 'Type' or a 'Role'.")

relationalai/early_access/graphs/__init__.py

@@ -1,13 +0,0 @@
-__version__ = "0.0.0"
-import warnings
-
-from relationalai.semantics.reasoners.graph.core import Graph
-
-__all__ = ["Graph"]
-
-warnings.warn(
-    "relationalai.early_access.graphs.* is deprecated. "
-    "Please migrate to relationalai.semantics.reasoners.graph.*",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/__init__.py

@@ -1,12 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp import ir, model2lqp, result_helpers, utils
-
-__all__ = ['ir', 'model2lqp', 'result_helpers', 'utils']
-
-warnings.warn(
-    "relationalai.early_access.lqp.* is deprecated. "
-    "Please migrate to relationalai.semantics.lqp.*",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/compiler/__init__.py

@@ -1,12 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp.compiler import Compiler
-
-__all__ = ["Compiler"]
-
-warnings.warn(
-    "relationalai.early_access.lqp.compiler is deprecated, "
-    "Please migrate to relationalai.semantics.lqp.compiler",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/constructors/__init__.py

@@ -1,18 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp.constructors import (
-    mk_abstraction, mk_and, mk_exists, mk_or, mk_pragma, mk_primitive,
-    mk_specialized_value, mk_type, mk_value
-)
-
-__all__ = [
-    "mk_abstraction", "mk_and", "mk_exists", "mk_or", "mk_pragma", "mk_primitive", "mk_specialized_value", "mk_type",
-    "mk_value"
-]
-
-warnings.warn(
-    "relationalai.early_access.lqp.constructors is deprecated. "
-    "Please migrate to relationalai.semantics.lqp.constructors",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/executor/__init__.py

@@ -1,12 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp.executor import LQPExecutor
-
-__all__ = ["LQPExecutor"]
-
-warnings.warn(
-    "relationalai.early_access.lqp.executor is deprecated, "
-    "Please migrate to relationalai.semantics.lqp.executor",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/ir/__init__.py

@@ -1,12 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp.ir import convert_transaction, validate_lqp
-
-__all__ = ["convert_transaction", "validate_lqp"]
-
-warnings.warn(
-    "relationalai.early_access.lqp.ir is deprecated. "
-    "Please migrate to relationalai.semantics.lqp.ir",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/passes/__init__.py

@@ -1,12 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp.passes import lqp_passes
-
-__all__ = ["lqp_passes"]
-
-warnings.warn(
-    "relationalai.early_access.lqp.passes is deprecated. "
-    "Please migrate to relationalai.semantics.lqp.passes",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/pragmas/__init__.py

@@ -1,12 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp.pragmas import pragma_to_lqp_name
-
-__all__ = ["pragma_to_lqp_name"]
-
-warnings.warn(
-    "relationalai.early_access.lqp.pragmas is deprecated, "
-    "Please migrate to relationalai.semantics.lqp.pragmas",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/primitives/__init__.py

@@ -1,12 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp.primitives import lqp_avg_op, lqp_operator, build_primitive
-
-__all__ = ["lqp_avg_op", "lqp_operator", "build_primitive"]
-
-warnings.warn(
-    "relationalai.early_access.lqp.primitives is deprecated. "
-    "Please migrate to relationalai.semantics.lqp.primitives",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/types/__init__.py

@@ -1,12 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp.types import lqp_type_to_sql, meta_type_to_lqp, is_numeric
-
-__all__ = ['lqp_type_to_sql', 'meta_type_to_lqp', 'is_numeric']
-
-warnings.warn(
-    "relationalai.early_access.lqp.types is deprecated, "
-    "Please migrate to relationalai.semantics.lqp.types",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/utils/__init__.py

@@ -1,12 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp.utils import TranslationCtx, gen_unique_var, output_names, UniqueNames
-
-__all__ = ["TranslationCtx", "gen_unique_var", "output_names", "UniqueNames"]
-
-warnings.warn(
-    "relationalai.early_access.lqp.utils is deprecated. "
-    "Please migrate to relationalai.semantics.lqp.utils",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/lqp/validators/__init__.py

@@ -1,12 +0,0 @@
-import warnings
-
-from relationalai.semantics.lqp.validators import assert_valid_input
-
-__all__ = ["assert_valid_input"]
-
-warnings.warn(
-    "relationalai.early_access.lqp.validators is deprecated. "
-    "Please migrate to relationalai.semantics.lqp.validators",
-    DeprecationWarning,
-    stacklevel=2,
-)

relationalai/early_access/metamodel/__init__.py

@@ -1,58 +0,0 @@
-import warnings
-
-from relationalai.semantics.metamodel import (types, util, ir, factory, helpers, builtins, compiler, executor, dependency,
-                                              Node, Model, Capability, Engine, Type, ScalarType, ListType, UnionType,
-                                              Field, Relation, Task, Logical, Union, Sequence, Match, Until, Wait, Not,
-                                              Exists, ForAll, Loop, Break, Var, Literal, Value, Annotation, Effect,
-                                              Update, Lookup, Output, Construct, Aggregate)
-
-__all__ = [
-    "types",
-    "util",
-    "ir",
-    "factory",
-    "helpers",
-    "builtins",
-    "compiler",
-    "executor",
-    "dependency",
-    "Node",
-    "Model",
-    "Capability",
-    "Engine",
-    "Type",
-    "ScalarType",
-    "ListType",
-    "UnionType",
-    "Field",
-    "Relation",
-    "Task",
-    "Logical",
-    "Union",
-    "Sequence",
-    "Match",
-    "Until",
-    "Wait",
-    "Not",
-    "Exists",
-    "ForAll",
-    "Loop",
-    "Break",
-    "Var",
-    "Literal",
-    "Value",
-    "Annotation",
-    "Effect",
-    "Update",
-    "Lookup",
-    "Output",
-    "Construct",
-    "Aggregate",
-]
-
-warnings.warn(
-    "relationalai.early_access.metamodel.* is deprecated. "
-    "Please migrate to relationalai.semantics.metamodel.*",
-    DeprecationWarning,
-    stacklevel=2,
-)