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

v0/relationalai/early_access/dsl/ontologies/roles.py

@@ -0,0 +1,87 @@
+from abc import abstractmethod
+from typing import Optional
+
+from v0.relationalai.early_access.dsl.core.types import Type
+from v0.relationalai.early_access.dsl.core.utils import generate_stable_uuid, camel_to_snake
+
+
+class AbstractRole:
+    _postfix: Optional[str] = None
+    _prefix: Optional[str] = None
+    _sibling: Optional['AbstractRole'] = None
+
+    # Initialize an AbstractRole with a UUID to use to identify it, the
+    # Relationship of which it will be a part, and an optional name
+    #
+    def __init__(self, part_of, pos, name:Optional[str] = None):
+        self._part_of = part_of
+        self._pos = pos
+        self._name = name
+
+    def guid(self):
+        return generate_stable_uuid(f"{self._pos}_{self._part_of.guid()}")
+
+    def name(self) -> Optional[str]:
+        return self._name
+
+    def ref_name(self):
+        defined_name = self.name()
+        if not defined_name:
+            defined_name = camel_to_snake(self.verbalize())
+        return defined_name
+
+    @abstractmethod
+    def player(self)-> Type:
+        pass
+
+    def verbalization(self, prefix=None, postfix=None) -> 'AbstractRole':
+        self._prefix = prefix
+        self._postfix = postfix
+        return self
+
+    def verbalize(self):
+        vfrags = []
+        if self._prefix is not None:
+            vfrags.append(f"{self._prefix}-")
+        vfrags.append(f"{self.player().display()}")
+        if self._postfix is not None:
+            vfrags.append(f"-{self._postfix}")
+        return " ".join(vfrags)
+
+    def sibling(self):
+        if self._part_of.arity() == 2:
+            if not self._sibling:
+                roles = self._part_of.roles()
+                sibling = roles[1] if self == roles[0] else roles[0]
+                self._sibling = sibling
+        return self._sibling
+
+    @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"Role is already part of another relationship: {self._part_of}")
+        self._part_of = rel
+
+    @property
+    def postfix(self):
+        return self._postfix
+
+    @property
+    def prefix(self):
+        return self._prefix
+
+
+class Role(AbstractRole):
+
+    def __init__(self, t, rel, pos, name=None):
+        AbstractRole.__init__(self, rel, pos, name)
+        if not isinstance(t, Type):
+            raise Exception(f"Tried to create Role with unparsable player {t}")
+        self.player_type = t
+
+    def player(self):
+        return self.player_type

v0/relationalai/early_access/dsl/ontologies/subtyping.py

@@ -0,0 +1,55 @@
+from v0.relationalai.early_access.dsl.core.types import Type
+from v0.relationalai.early_access.dsl.core.utils import generate_stable_uuid
+from v0.relationalai.semantics.metamodel.util import OrderedSet
+
+
+class SubtypeArrow:
+    start: Type
+    end: Type
+
+    def __init__(self, start: Type, end: Type):
+        if end == start:
+            raise Exception("Invalid subtype arrow. End can't be same as start.")
+        self.start = start
+        self.end = end
+
+    def guid(self):
+        return generate_stable_uuid(f"{self.start.guid()}->{self.end.guid()}")
+
+    def pprint(self):
+        return f"{self.start.display()}->{self.end.display()}"
+
+    def to_name_tuple(self):
+        return self.start.display(), self.end.display()
+
+    def __eq__(self, other):
+        if isinstance(other, SubtypeArrow):
+            return self.guid() == other.guid()
+        return False
+
+    def __hash__(self):
+        return hash(self.guid())
+
+class SubtypeConstraint:
+    arrows: OrderedSet[SubtypeArrow]
+
+    def __init__(self, arrows: OrderedSet[SubtypeArrow]):
+        if len(arrows) < 2:
+            raise Exception("Invalid subtype constraint. Length of arrows is less than 2.")
+        entity = next(iter(arrows))
+        for arrow in arrows:
+            if arrow is not entity and arrow.end != entity.end:
+                raise Exception("Invalid subtype constraint. Subtype arrow end must be same for all arrows.")
+        self.arrows = arrows
+
+
+class ExclusiveSubtypeConstraint(SubtypeConstraint):
+
+    def __init__(self, arrows: OrderedSet[SubtypeArrow]):
+        super().__init__(arrows)
+
+
+class InclusiveSubtypeConstraint(SubtypeConstraint):
+
+    def __init__(self, arrows: OrderedSet[SubtypeArrow]):
+        super().__init__(arrows)

v0/relationalai/early_access/dsl/orm/constraints.py

@@ -0,0 +1,438 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Sequence, Optional, TypeVar, Generic, Union
+from v0.relationalai.early_access.dsl.core.utils import generate_stable_uuid
+from v0.relationalai.early_access.dsl.orm.relationships import Role
+from v0.relationalai.early_access.dsl.orm.types import Concept
+
+
+class Constraint(ABC):
+    @abstractmethod
+    def _validate(self, ontology) -> bool:
+        """Validate the constraint against the ontology."""
+
+    @abstractmethod
+    def _unique_name(self) -> str:
+        """Validate the constraint against the ontology."""
+
+    @abstractmethod
+    def _desugar(self):
+        """Declare QB constraints"""
+
+    def _guid(self):
+        return generate_stable_uuid(self._unique_name())
+
+    def __eq__(self, other):
+        if isinstance(other, Constraint):
+            return self._guid() == other._guid()
+        return False
+
+    def __hash__(self):
+        return hash(self._guid())
+
+class ConceptConstraint(Constraint):
+
+    def concept(self) -> Concept:
+        return self._concept
+
+    def __init__(self, concept: Concept):
+        self._concept = concept
+        self._name = f'{type(self).__name__}{concept._guid()}'
+
+    def _unique_name(self) -> str:
+        return self._name
+
+class RoleConstraint(Constraint):
+
+    def roles(self) -> list[Role]:
+        return self._roles
+
+    def __init__(self, roles: list[Role]):
+        self._roles = roles
+        self._name = f'{type(self).__name__}{"".join(role._guid() for role in self._roles)}'
+
+    def _unique_name(self) -> str:
+        return self._name
+
+    def _discharged(self) -> bool:
+        return False
+
+class RoleSequenceConstraint(Constraint):
+    def role_sequences(self):
+        return self._role_sequences
+
+    def __init__(self, role_sequences):
+        if all(isinstance(item, list) for item in role_sequences):
+            self._role_sequences = role_sequences
+        elif all(not isinstance(item, list) for item in role_sequences):
+            self._role_sequences = [[item] for item in role_sequences]
+        else:
+            raise TypeError("All items in role_sequences must be either all lists or all non-lists")
+
+        self._name = f'{type(self).__name__}{"".join(role._guid() for role_list in self._role_sequences for role in role_list)}'
+
+    def _unique_name(self) -> str:
+        return self._name
+
+class Unique(RoleConstraint):
+    def __init__(self, *roles: Role, is_preferred_identifier=False):
+        super().__init__(list(roles))
+        self.is_preferred_identifier = is_preferred_identifier
+
+    def _validate(self, ontology) -> bool:
+        # Implement uniqueness validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def _is_internal(self) -> bool:
+        # only when there is a single role
+        return len(self._roles) == 1
+
+    def __repr__(self):
+        return f'Unique(({", ".join(role._guid() for role in self._roles)}), preferred_identifier={self.is_preferred_identifier})'
+
+
+class Mandatory(RoleConstraint):
+    def __init__(self, role: Role):
+        super().__init__([role])
+
+    def _validate(self, ontology) -> bool:
+        # Implement mandatory validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'Mandatory({self._roles[0]._guid()})'
+
+
+class InclusiveRoleConstraint(RoleConstraint):
+    def __init__(self, *roles: Role):
+        super().__init__(list(roles))
+
+    def _validate(self, ontology) -> bool:
+        # Implement inclusive validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'InclusiveRoles(({", ".join(role._guid() for role in self._roles)})'
+
+
+class ExclusiveRoleConstraint(RoleSequenceConstraint):
+    def __init__(self, *role_sequences):
+        super().__init__(list(role_sequences))
+
+    def _validate(self, ontology) -> bool:
+        # Implement exclusive validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'ExclusiveRoles([{"], [".join(", ".join(ro._guid()) for ro_list in self.role_sequences() for ro in ro_list)}])'
+
+
+class RingType(Enum):
+    IRREFLEXIVE = 1
+    ANTISYMMETRIC = 2
+    ASYMMETRIC = 3
+    STRONGLY_INTRANSITIVE = 4
+    INTRANSITIVE = 5
+    ACYCLIC = 6
+    PURELY_REFLEXIVE = 7
+    REFLEXIVE = 8
+    SYMMETRIC = 9
+    TRANSITIVE = 10
+
+
+class RingConstraint(RoleConstraint):
+    def __init__(self, constraint_types: list[RingType], *roles: Role):
+        super().__init__(list(roles))
+        self.types = constraint_types
+
+    def _validate(self, ontology) -> bool:
+        # Implement ring constraint logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'Ring(({", ".join(str(type) for type in self.types)}), ({", ".join(role._guid() for role in self._roles)}))'
+
+
+class ValueComparisonType(Enum):
+    GREATER_THAN_OR_EQUAL = 1
+    LESS_THAN_OR_EQUAL = 2
+    GREATER_THAN = 3
+    LESS_THAN = 4
+    NOT_EQUAL = 5
+    EQUAL = 6
+
+
+class ValueComparisonConstraint(RoleConstraint):
+    def __init__(self, constraint_type: ValueComparisonType, *roles: Role):
+        super().__init__(list(roles))
+        self.type = constraint_type
+
+    def _validate(self, ontology) -> bool:
+        # Implement value comparison constraint logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'ValueComparison({self.type}, ({", ".join(role._guid() for role in self._roles)}))'
+
+
+class RoleSubsetConstraint(RoleSequenceConstraint):
+    def __init__(self, *role_sequences):
+        super().__init__(list(role_sequences))
+
+    def _validate(self, ontology) -> bool:
+        # Implement role subset validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'RoleSubsets([{"], [".join(", ".join(ro._guid()) for ro_list in self.role_sequences() for ro in ro_list)}])'
+
+
+class EqualityConstraint(RoleSequenceConstraint):
+    def __init__(self, *role_sequences):
+        super().__init__(list(role_sequences))
+
+    def _validate(self, ontology) -> bool:
+        # Implement equality validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'Equality([{"], [".join(", ".join(ro._guid()) for ro_list in self.role_sequences() for ro in ro_list)}])'
+
+
+class FrequencyConstraint(RoleConstraint):
+    def __init__(self, constraint_frequency: tuple, *roles: Role):
+        super().__init__(list(roles))
+        self.frequency = constraint_frequency
+
+    def _validate(self, ontology) -> bool:
+        # Implement frequency constraint logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'Frequency(({", ".join(str(freq) for freq in self.frequency)}), ({", ".join(role._guid() for role in self._roles)}))'
+
+
+# Role value constraint
+T = TypeVar('T', int, float, str)
+
+
+class Range(Generic[T]):
+
+    def __init__(self, start: Optional[T], end: Optional[T]):
+        if start is None and end is None:
+            raise ValueError("'start' and 'end' cannot be None")
+        if start is not None and end is not None:
+            if type(start) is not type(end):
+                raise TypeError("'start' and 'end' must be of same type")
+            if start > end:  # type: ignore[reportOperatorIssue]
+                raise ValueError("'start' must be less than 'end'")
+        self._start = start
+        self._end = end
+
+    def _matches(self, value: T) -> bool:
+        if self._start is not None and value < self._start:
+            return False
+        if self._end is not None and value > self._end:
+            return False
+        return True
+
+    def _type(self):
+        if self._start is not None:
+            return type(self._start)
+        else:
+            return type(self._end)
+
+    def __repr__(self):
+        return f"Range({self._start}, {self._end})"
+
+    @staticmethod
+    def between(start: T, end: T):
+        return Range(start, end)
+
+    @staticmethod
+    def to_value(value: T):
+        return Range(None, value)
+
+    @staticmethod
+    def from_value(value: T):
+        return Range(value, None)
+
+
+class RoleValueConstraint(RoleConstraint, Generic[T]):
+    def __init__(self, role: Role, values: Sequence[Union[T, Range[T]]]):
+        super().__init__([role])
+        self._values = values
+
+    def values(self):
+        return self._values
+
+    def _validate(self, ontology) -> bool:
+        # Implement role value validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'RoleValueConstraint({self._roles[0]._guid()}, values={self._values})'
+
+    def _discharged(self) -> bool:
+        # TODO: Implement logic to determine if the constraint is discharged when a unified reasoner is available
+        # See RAI-40577
+        return False
+
+
+class RoleCardinalityConstraint(RoleConstraint):
+    def __init__(self, role: Role, values: Sequence[Union[int, Range[int]]]):
+        if len(role._relationship._fields) > 1:
+            raise ValueError("Role cardinality constraints can only be applied to unary relationships roles.")
+        super().__init__([role])
+        self._values = values
+
+    def values(self):
+        return self._values
+
+    def _validate(self, ontology) -> bool:
+        # Implement role cardinality validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'RoleCardinalityConstraint({self._roles[0]._guid()}, values={self._values})'
+
+class CardinalityConstraint(ConceptConstraint, Generic[T]):
+    def __init__(self, concept: Concept, values: Sequence[Union[int, Range[int]]]):
+        super().__init__(concept)
+        self._values = values
+
+    def values(self):
+        return self._values
+
+    def _validate(self, ontology) -> bool:
+        # TODO
+        # Implement concept cardinality validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'CardinalityConstraint({self._concept._name}, values={self._values})'
+
+
+class ValueConstraint(ConceptConstraint, Generic[T]):
+    def __init__(self, concept: Concept, values: Sequence[Union[T, Range[T]]]):
+        super().__init__(concept)
+        self._values = values
+
+    def values(self):
+        return self._values
+
+    def _validate(self, ontology) -> bool:
+        # TODO
+        # Implement value type constraint validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+    def __repr__(self):
+        return f'ValueConstraint({self._concept._name}, values={self._values})'
+
+class SubtypeConstraint(Constraint):
+    _concepts: dict[str, Concept]
+
+    def __init__(self, *concepts: Concept):
+        self._concepts = {}
+        for concept in concepts:
+            self._concepts[concept._name] = concept
+        if len(concepts) < 2:
+            raise ValueError("Invalid subtype constraint. A constraint should hold at least 2 concepts")
+        first = next(iter(self._concepts.values()))
+        first_super_types = [super_type._id for super_type in first._extends]
+        for c in self._concepts.values():
+            if len(c._extends) == 0:
+                raise ValueError(f"Invalid subtype constraint. '{c}' is not a subtype")
+            c_super_types = [super_type._id for super_type in c._extends]
+            if first_super_types != c_super_types:
+                raise ValueError(f"Invalid subtype constraint. '{first}' and '{c}' must have the same parents")
+        self._name = f'{type(self).__name__}({", ".join(str(c) for c in sorted(self._concepts.values(), key=lambda c: str(c)))})'
+
+    def _unique_name(self) -> str:
+        return self._name
+
+    def concepts(self) -> dict[str, Concept]:
+        return self._concepts
+
+    def __repr__(self):
+        return self._name
+
+
+class ExclusiveSubtypeConstraint(SubtypeConstraint):
+
+    def __init__(self, *concepts: Concept):
+        super().__init__(*concepts)
+
+    def _validate(self, ontology) -> bool:
+        # Implement validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass
+
+
+class InclusiveSubtypeConstraint(SubtypeConstraint):
+
+    def __init__(self, *concepts: Concept):
+        super().__init__(*concepts)
+
+    def _validate(self, ontology) -> bool:
+        # Implement validation logic here
+        return True
+
+    def _desugar(self):
+        # todo: Implement QB representation
+        pass