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

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

@@ -1,256 +0,0 @@
-from __future__ import annotations
-
-from collections import OrderedDict
-from typing import Optional, Any, Sequence, Union, TypeVar
-
-import v0.relationalai.semantics as qb
-from v0.relationalai.semantics.std import constraints as c
-from v0.relationalai import Config
-from v0.relationalai.early_access.dsl.bindings.common import Binding
-from v0.relationalai.early_access.dsl.bindings.csv import CsvTable
-from v0.relationalai.early_access.dsl.bindings.snowflake import SnowflakeTable
-from v0.relationalai.early_access.dsl.codegen.weaver import Weaver
-from v0.relationalai.early_access.dsl.core.utils import generate_stable_uuid, to_pascal_case
-from v0.relationalai.early_access.dsl.orm.constraints import Unique, Mandatory, RoleValueConstraint, Range, \
-    ExclusiveSubtypeConstraint, InclusiveSubtypeConstraint, InclusiveRoleConstraint, ExclusiveRoleConstraint, \
-    RingConstraint, ValueComparisonConstraint, RoleSubsetConstraint, EqualityConstraint, FrequencyConstraint, \
-    CardinalityConstraint, RoleCardinalityConstraint, ValueConstraint
-from v0.relationalai.early_access.dsl.orm.reasoners import OntologyReasoner
-from v0.relationalai.early_access.dsl.orm.relationships import Relationship, Role, RelationshipReading
-from v0.relationalai.early_access.dsl.orm.types import Concept
-from v0.relationalai.early_access.dsl.snow.api import Executor
-from v0.relationalai.semantics.metamodel.util import OrderedSet
-
-T = TypeVar('T', int, float, str)
-
-class Model:
-    def __init__(
-            self,
-            name: str,
-            is_primary: bool = True,
-            dry_run: bool = False,
-            use_lqp: bool | None = None,
-            use_sql: bool = False,
-            wide_outputs: bool = False,
-            config: Optional[Config] = None
-    ):
-        self.name = name
-        self._qb_model = qb.Model(name, dry_run=dry_run, strict=True, config=config, use_lqp=use_lqp, use_sql=use_sql, wide_outputs=wide_outputs)
-        self.is_primary = is_primary
-        self._constraints = OrderedSet()
-        self._entity_to_id_relationship = OrderedDict()
-        self._bindable_tables = OrderedDict()
-        self._relationship_iuc: dict[qb.Relationship, list[Unique]] = {}
-        self._bindings = []
-        self._executor = None
-        self._reasoner = OntologyReasoner()
-        self._weaver = None
-        self._queries = OrderedSet()
-        self.Enum = self._qb_model.Enum
-
-    def guid(self):
-        return generate_stable_uuid(self.name)
-
-    def Concept(self, name: str, extends: list[Any] = [], identify_by:dict[str, Any]={}) -> Concept:
-        name = to_pascal_case(name)
-        return Concept(self, name, extends, identify_by)
-
-    def qb_model(self):
-        return self._qb_model
-    
-    def reasoner(self):
-        return self._reasoner
-
-    def Relationship(self, reading: Any, short_name:str="") -> qb.Relationship:
-        """
-        Create a new relationship with the given reading.
-        """
-        return Relationship(self, reading, short_name=short_name)
-
-    def constraint(self, constraint):
-        # Generic constraint addition with validation
-        self._constraints.add(constraint)
-        self._reasoner.new_constraint(constraint)
-        constraint._desugar()
-
-    def unique(self, *roles):
-        uc = Unique(*roles)
-        self.constraint(uc)
-        c.unique(*roles)
-        first_part_of = roles[0]._part_of()
-        if isinstance(first_part_of, RelationshipReading):
-            relationship = first_part_of._alt_of
-        else:
-            relationship = first_part_of
-        # check if UC is internal
-        if all(role._part_of()._id == first_part_of._id for role in roles):
-            internal_ucs = self._relationship_iuc.get(relationship, [])
-            internal_ucs.append(uc)
-            self._relationship_iuc[relationship] = internal_ucs  # todo: this logic should be part of reactive reasoner
-
-    def mandatory(self, role):
-        self.constraint(Mandatory(role))
-
-    def inclusive_roles(self, *roles):
-        self.constraint(InclusiveRoleConstraint(*roles))
-
-    def exclusive_roles(self, *role_sequences):
-        self.constraint(ExclusiveRoleConstraint(*role_sequences))
-
-    def ring(self, constraint_types, *roles):
-        self.constraint(RingConstraint(constraint_types, *roles))
-
-    def value_comparison(self, constraint_type, *roles):
-        self.constraint(ValueComparisonConstraint(constraint_type, *roles))
-
-    def role_subset(self, *role_sequences):
-        self.constraint(RoleSubsetConstraint(*role_sequences))
-
-    def equality(self, *role_sequences):
-        self.constraint(EqualityConstraint(*role_sequences))
-
-    def frequency(self, frequency, *role_sequences):
-        self.constraint(FrequencyConstraint(frequency, *role_sequences))
-
-    def cardinality(self, concept: Concept, values: Sequence[Union[int, Range[int]]]):
-        self.constraint(CardinalityConstraint(concept, values))
-
-    def role_cardinality(self, role: Role, values: Sequence[Union[int, Range[int]]]):
-        self.constraint(RoleCardinalityConstraint(role, values))
-
-    def value_constraint(self, concept: Concept, values: Sequence[Union[T, Range[T]]]):
-        self.constraint(ValueConstraint(concept, values))
-
-    def role_value_constraint(self, role: Role, values: Sequence[Union[T, Range[T]]]):
-        # TODO: check if a role value constraint is incompatible with an existing value constraint
-        first_type = values[0]._type() if isinstance(values[0], Range) else type(values[0])
-        for v in values[1:]:
-            t = v._type() if isinstance(v, Range) else type(v)
-            if t != first_type:
-                raise Exception("Values for role value constraint must have the same type.")
-        if role.player()._is_primitive() or role.player()._is_value_type():
-            self.constraint(RoleValueConstraint(role, values))
-        else:
-            raise Exception("A role value constraint can only be applied to roles played by value types")
-
-    def exclusive_subtype_constraint(self, *concepts:Concept):
-        self.constraint(ExclusiveSubtypeConstraint(*concepts))
-
-    def inclusive_subtype_constraint(self, *concepts:Concept):
-        self.constraint(InclusiveSubtypeConstraint(*concepts))
-
-    def _add_concept(self, concept: Concept) -> Concept:
-        self._validate_type_name(concept._name)
-        if concept._name not in self.qb_model().concepts:
-            self.qb_model().concepts[concept._name] = [concept]
-        return concept
-
-    def _ref_scheme_constraints(self, *relations:Relationship):
-        if len(relations) == 1:
-            # binary case, internal UC
-            role = relations[0][1]
-            self._internal_preferred_uc(role)
-        else:
-            roles = [rel[1] for rel in relations]
-            self._composite_preferred_uc(*roles)
-
-    def _internal_preferred_uc(self, role):
-        rel = role._part_of()
-        if rel._arity() != 2:
-            raise Exception("The relationship should be binary to apply preferred identifier constraint")
-        # mark the role as preferred identifier
-        self.constraint(Unique(role, is_preferred_identifier=True))
-        # mark the sibling role as mandatory and unique
-        sibling = role.sibling()
-        self.mandatory(sibling)
-        self.unique(sibling)
-
-    def _composite_preferred_uc(self, *roles):
-        for role in roles:
-            sibling = role.sibling()
-            if not sibling:
-                raise Exception("Composite preferred identifier constraint should be applied on binary relationships")
-            self.mandatory(sibling)
-            self.unique(sibling)
-        self.constraint(Unique(*roles, is_preferred_identifier=True))
-
-    def lookup_concept(self, name) -> Optional[qb.Concept]:
-        name = to_pascal_case(name)
-        if name in self._qb_model.concepts:
-            return self._qb_model.concepts[name][0]
-        return None
-
-    def constraints(self):
-        """Getter for the _constraints property"""
-        return self._constraints
-
-    def queries(self):
-        return self._queries
-
-    def concepts(self):
-        c = list()
-        for concepts in self._qb_model.concepts.values():
-            c.append(concepts[0])
-        return c
-
-    def concepts_map(self):
-        d = dict()
-        for k, v in self._qb_model.concepts.items():
-            d[k] = v[0]
-        return d
-
-    def enums(self):
-        return list(self._qb_model.enums.values())
-
-    def enums_map(self):
-        return self._qb_model.enums
-
-    def value_types(self):
-        return list(filter(lambda c: c._is_primitive(), self.concepts()))
-
-    def value_types_map(self):
-        return dict(filter(lambda item: item[1]._is_primitive(), self.concepts_map().items()))
-
-    def entity_types(self):
-        return list(filter(lambda c: not c._is_primitive(), self.concepts()))
-
-    def entity_types_map(self):
-        return dict(filter(lambda item: not item[1]._is_primitive(), self.concepts_map().items()))
-
-    def relationships(self):
-        return self._qb_model.relationships
-
-    def bindable_tables(self):
-        return self._bindable_tables
-
-    def api(self):
-        self._executor = self._executor or Executor(self._qb_model._config)
-        return self._executor
-
-    def table(self, name: str, schema:dict[str, str|qb.Concept]|None=None) -> SnowflakeTable:
-        table = SnowflakeTable(name, self, schema=schema)
-        self._bindable_tables[name] = table
-        return table
-
-    def csv_table(self, name: str, schema: dict[str, qb.Concept]) -> CsvTable:
-        table = CsvTable(name, schema, self)
-        self._bindable_tables[name] = table
-        return table
-
-    def binding(self, binding: Binding):
-        self._bindings.append(binding)
-
-    def generate_model_rules(self, config: Optional[dict]=None):
-        if self._weaver is None:
-            self._weaver = Weaver(self, config)
-        else:
-            raise Exception("Model rules have already been generated.")
-        self._weaver.generate()
-
-    def delete(self):
-        self.api().provider().delete_model(self.name)
-
-    def _validate_type_name(self, name):
-        if name in self._qb_model.concepts:
-            raise Exception(
-                f"The name '{name}' is used to declare a Concept.")

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

@@ -1,344 +0,0 @@
-import typing
-
-from v0.relationalai.early_access.dsl.orm.printer import Printer, _sort_dependency_graph, InterfacePrinter
-from v0.relationalai.early_access.dsl.orm.models import Model
-from v0.relationalai.early_access.dsl.orm.types import Concept
-
-SPACE_INDENT = "    "
-TAB_INDENT = "\t"
-
-class ObjectOrientedPrinter(Printer):
-    _indent: str
-
-    def __init__(self, io: typing.Optional[typing.IO[str]] = None, space_indent: bool= False):
-        super().__init__(io)
-        object.__setattr__(self, '_indent', SPACE_INDENT if space_indent else TAB_INDENT)
-
-    def to_string(self, model: Model, enums_enabled: bool = False, pyi_enabled: bool = False) -> None:
-        self._process_constraints(model)
-
-        self._print_nl("from typing import Any, Sequence, Union, TypeVar")
-        self._print_nl("import relationalai.semantics.internal as qb")
-        self._print_nl("import relationalai.semantics.internal.internal as builder")
-        self._print_nl("from relationalai.early_access.dsl.orm.models import Model")
-        if pyi_enabled:
-            self._print_nl("from relationalai.early_access.dsl.orm.models import Concept")
-        self._print_nl("from relationalai.early_access.dsl.orm.relationships import Role")
-        self._print_nl("from relationalai.early_access.dsl.orm.constraints import Range")
-        self._print_nl("from relationalai.early_access.dsl.orm.constraints import RingType")
-        self._print_nl("from relationalai.early_access.dsl.orm.constraints import ValueComparisonType")
-        self._nl()
-
-        self._handle_concepts_declaration(model, enums_enabled, pyi_enabled)
-        self._nl()
-        self._print_nl("class OntologyBase:\n"
-                       f'{self._indent}"""Represents an Ontology."""')
-        self._nl()
-        self._print_nl(f"{self._indent}def __init__(self, model: Model):\n"
-                       f"{self._indent}{self._indent}self.model = model")
-        self._nl()
-        self._print_nl(f"{self._indent}def generate_model_rules(self):\n"
-                       f"{self._indent}{self._indent}self.model.generate_model_rules()")
-        self._nl()
-        if not pyi_enabled:
-            self._print_nl(f"{self._indent}def Concept(self, name: str, extends: list[Any] = [], identify_by:dict[str, Any]={{}}):\n"
-                           f"{self._indent}{self._indent}return self.model.Concept(name, extends, identify_by)")
-        if enums_enabled:
-            self._print_nl(f"{self._indent}def Enum(self):\n"
-                           f"{self._indent}{self._indent}return self.model.Enum()")
-        self._print_nl(f"{self._indent}def Relationship(self, reading: Any, short_name:str=\"\") -> qb.Relationship:\n"
-                       f"{self._indent}{self._indent}return self.model.Relationship(reading, short_name)")
-        self._print_nl(f"{self._indent}def Unique(self, *roles):\n"
-                       f"{self._indent}{self._indent}self.model.unique(*roles)")
-        self._print_nl(f"{self._indent}def Mandatory(self, role):\n"
-                       f"{self._indent}{self._indent}self.model.mandatory(role)")
-        self._print_nl(f"{self._indent}T = TypeVar('T', int, float, str)")
-        self._print_nl(f"{self._indent}def RoleValueConstraint(self, role: Role, values: Sequence[Union[T, Range[T]]]):\n"
-                       f"{self._indent}{self._indent}self.model.role_value_constraint(role, values)")
-        self._print_nl(f"{self._indent}def InclusiveSubtypeConstraint(self, *concepts: Concept):\n"
-                       f"{self._indent}{self._indent}self.model.inclusive_subtype_constraint(*concepts)")
-        self._print_nl(f"{self._indent}def ExclusiveSubtypeConstraint(self, *concepts: Concept):\n"
-                       f"{self._indent}{self._indent}self.model.exclusive_subtype_constraint(*concepts)")
-        self._print_nl(f"{self._indent}def InclusiveRoleConstraint(self, *roles):\n"
-                       f"{self._indent}{self._indent}self.model.inclusive_roles(*roles)")
-        self._print_nl(f"{self._indent}def ExclusiveRoleConstraint(self, *role_sequences):\n"
-                       f"{self._indent}{self._indent}self.model.exclusive_roles(*role_sequences)")
-        self._print_nl(f"{self._indent}def RingConstraint(self, *roles):\n"
-                       f"{self._indent}{self._indent}self.model.ring(*roles)")
-        self._print_nl(f"{self._indent}def ValueComparisonConstraint(self, constraint_type, *roles):\n"
-                       f"{self._indent}{self._indent}self.model.value_comparison(constraint_type, *roles)")
-        self._print_nl(f"{self._indent}def RoleSubsetConstraint(self, *role_sequences):\n"
-                       f"{self._indent}{self._indent}self.model.role_subset(*role_sequences)")
-        self._print_nl(f"{self._indent}def EqualityConstraint(self, *role_sequences):\n"
-                       f"{self._indent}{self._indent}self.model.equality(*role_sequences)")
-        self._print_nl(f"{self._indent}def FrequencyConstraint(self, frequency, *role_sequences):\n"
-                       f"{self._indent}{self._indent}self.model.frequency(frequency, *role_sequences)")
-        self._print_nl(
-            f"{self._indent}def CardinalityConstraint(self, concept: Concept, values: Sequence[Union[int, Range[int]]]):\n"
-            f"{self._indent}{self._indent}self.model.cardinality(concept, values)")
-        self._print_nl(f"{self._indent}def RoleCardinalityConstraint(self, role: Role, values: Sequence[Union[int, Range[int]]]):\n"
-                       f"{self._indent}{self._indent}self.model.role_cardinality(role, values)")
-        self._print_nl(f"{self._indent}def ValueConstraint(self, concept: Concept, values: Sequence[Union[T, Range[T]]]):\n"
-                       f"{self._indent}{self._indent}self.model.value_constraint(concept, values)")
-
-        self._nl()
-        self._print_nl("class ORMOntology(OntologyBase):")
-        self._print_nl(f'{self._indent}"""Represents an Ontology generated from an ORM file."""')
-        self._nl()
-        self._print_nl(f"{self._indent}def __init__(self, model: Model):")
-        self._print_nl(f"{self._indent}{self._indent}super().__init__(model)")
-        self._nl()
-        self._handle_concepts(model, enums_enabled, pyi_enabled)
-        self._nl()
-        self._handle_relationships(model)
-
-        self._nl()
-        self._handle_ref_schemes(model)
-
-        if self._unique_constraints:
-            self._nl()
-            self._handle_uniqueness_constraints()
-
-        if self._mandatory_constraints:
-            self._nl()
-            self._handle_mandatory_constraints()
-
-        if self._role_value_constraints:
-            self._nl()
-            self._handle_role_value_constraints()
-
-        if self._inclusive_subtype_constraints or self._exclusive_subtype_constraints:
-            self._nl()
-            self._handle_subtype_constraints()
-
-        if self._inclusive_role_constraints:
-            self._nl()
-            self._handle_inclusive_role_constraints()
-
-        if self._exclusive_role_constraints:
-            self._nl()
-            self._handle_exclusive_role_constraints()
-
-        if self._ring_constraints:
-            self._nl()
-            self._handle_ring_constraints()
-
-        if self._value_comparison_constraints:
-            self._nl()
-            self._handle_value_comparison_constraints()
-
-        if self._role_subset_constraints:
-            self._nl()
-            self._handle_role_subset_constraints()
-
-        if self._equality_constraints:
-            self._nl()
-            self._handle_equality_constraints()
-
-        if self._frequency_constraints:
-            self._nl()
-            self._handle_frequency_constraints()
-
-        if self._cardinality_constraints:
-            self._nl()
-            self._handle_cardinality_constraints()
-
-        if self._role_cardinality_constraints:
-            self._nl()
-            self._handle_role_cardinality_constraints()
-
-        if self._value_constraints:
-            self._nl()
-            self._handle_value_constraints()
-
-    def _handle_concepts_declaration(self, model: Model, enums_enabled: bool, pyi_enabled: bool) -> None:
-        concepts_map = model.concepts_map()
-        sorted_concepts = _sort_dependency_graph(model.concepts())
-        # print Concept classes
-        if pyi_enabled:
-            for name in sorted_concepts:
-                c = concepts_map.get(name)
-                if c is None:
-                    raise ValueError(f"The concept '{name}' was not declared but used as concept domain.")
-                # skip enums when they are enabled for printer
-                if c._is_enum() and enums_enabled:
-                    continue
-                extends = [f"{e._name}Concept" for e in c._extends if not e._is_primitive()]
-                self._print_nl(f"class {name}Concept({', '.join(extends) if extends else 'Concept'}):")
-                self._print_nl(f'{self._indent}"""Represents {name} concept."""')
-            self._nl()
-
-    def _handle_concepts(self, model: Model, enums_enabled: bool, pyi_enabled: bool) -> None:
-        concepts_map = model.concepts_map()
-        enums_map = model.enums_map()
-        sorted_concepts = _sort_dependency_graph(model.concepts())
-        for name in sorted_concepts:
-            c = concepts_map.get(name)
-            if c is None:
-                raise ValueError(f"The concept '{name}' was not declared but used as concept domain.")
-            if enums_enabled and c._is_enum():
-                self._print_nl(f"{self._indent}{self._indent}self.{name} = model.Enum('{name}', {[e.name for e in enums_map[name]]})")
-            else:
-                extends = c._extends
-                if not enums_enabled and c._is_enum():
-                    # todo: derive enum type
-                    # ORM adapter produces only string enums
-                    extends_elements = ["qb.String"]
-                else:
-                    extends_elements = [f"self.{self._get_type(ext)}" if not self._get_type(ext).startswith(
-                        "qb.") and not self._get_type(ext).startswith("builder.") else self._get_type(ext) for ext in
-                                        extends]
-                extends_str = f", extends=[{', '.join(extends_elements)}]" if extends else ""
-                concept_class = name + 'Concept' if pyi_enabled else 'model.Concept'
-                params = f"({'model, ' if pyi_enabled else ''}'{name}'{extends_str})"
-                self._print_nl(f"{self._indent}{self._indent}self.{name} = {concept_class}{params}")
-
-    def _handle_relationships(self, model: Model) -> None:
-        for rel in model.relationships():
-            # skip autogenerated 'name' Relationship for Enums
-            if rel._name == 'name' and rel._parent is not None and rel._parent._is_enum():
-                continue
-            # print a root Relationship
-            self._print_nl(f"{self._indent}{self._indent}self.{self._get_relationship_name(rel)} = "
-                           f"model.Relationship('{rel._madlib}'{self._print_if_not_empty_and_not_equal('short_name', rel._passed_short_name, rel._name)})")
-
-            # print remaining RelationshipReadings if any
-            for r in rel._readings[1:]:
-                self._print_nl(f"{self._indent}{self._indent}self.{self._get_relationship_name(r)} = "
-                               f"self.{self._get_relationship_name(rel)}.alt('{r._madlib}'{self._print_if_not_empty_and_not_equal('short_name', r._passed_short_name, r._name)})")
-
-    def _handle_ref_schemes(self, model: Model) -> None:
-        for concept_name, concept in model.entity_types_map().items():
-            if not isinstance(concept, Concept) or not concept._reference_schemes:
-                continue
-
-            for ref_scheme in concept._reference_schemes:
-                rel_names = [f"self.{self._get_relationship_name(rel)}" for rel in ref_scheme]
-                self._print_nl(f"{self._indent}{self._indent}self.{concept_name}.identify_by({', '.join(rel_names)})")
-
-    def _handle_uniqueness_constraints(self) -> None:
-        for constraint in self._unique_constraints:
-            if not constraint.is_preferred_identifier:
-                elements = [f"self.{self._get_role_name(role)}" for role in constraint.roles()]
-                self._print_nl(f"{self._indent}{self._indent}self.Unique({', '.join(elements)})")
-
-    def _handle_mandatory_constraints(self):
-        for constraint in self._mandatory_constraints:
-            role = constraint.roles()[0]
-            role_name = self._get_role_name(role)
-            self._print_nl(f"{self._indent}{self._indent}self.Mandatory(self.{role_name})")
-
-    def _handle_role_value_constraints(self) -> None:
-        for constraint in self._role_value_constraints:
-            role = constraint.roles()[0]
-            elements = self._get_constraint_values(constraint)
-            role_name = f"self.{self._get_role_name(role)}"
-            self._print_nl(f"{self._indent}{self._indent}self.RoleValueConstraint({role_name}, [{', '.join(elements)}])")
-
-    def _handle_inclusive_role_constraints(self):
-        for constraint in self._inclusive_role_constraints:
-            roles = [f"self.{self._get_role_name(r)}" for r in constraint.roles()]
-            self._print_nl(f"{self._indent}{self._indent}self.InclusiveRoleConstraint({', '.join(roles)})")
-
-    def _handle_exclusive_role_constraints(self):
-        self._emit_role_sequence_constraints(self._exclusive_role_constraints, "ExclusiveRoleConstraint")
-
-    def _handle_ring_constraints(self):
-        for constraint in self._ring_constraints:
-            elements = [f"self.{self._get_role_name(role)}" for role in constraint.roles()]
-            cst_types = [f"{tp}" for tp in constraint.types]
-            self._print_nl(f"{self._indent}{self._indent}self.RingConstraint([{', '.join(cst_types)}], {', '.join(elements)})")
-
-    def _handle_value_comparison_constraints(self):
-        for constraint in self._value_comparison_constraints:
-            elements = [f"self.{self._get_role_name(role)}" for role in constraint.roles()]
-            self._print_nl(f"{self._indent}{self._indent}self.ValueComparisonConstraint({constraint.type}, {', '.join(elements)})")
-
-    def _handle_frequency_constraints(self):
-        for constraint in self._frequency_constraints:
-            elements = [f"self.{self._get_role_name(role)}" for role in constraint.roles()]
-            self._print_nl(f"{self._indent}{self._indent}self.FrequencyConstraint(({', '.join(constraint.frequency)}), {', '.join(elements)})")
-
-    def _handle_cardinality_constraints(self):
-        for constraint in self._cardinality_constraints:
-            elements = self._get_constraint_values(constraint)
-            self._print_nl(
-                f"{self._indent}{self._indent}self.CardinalityConstraint(self.{constraint.concept()._name}, [{', '.join(elements)}])")
-
-    def _handle_role_cardinality_constraints(self):
-        for constraint in self._role_cardinality_constraints:
-            elements = self._get_constraint_values(constraint)
-            self._print_nl(
-                f"{self._indent}{self._indent}self.RoleCardinalityConstraint(self.{self._get_role_name(constraint.roles()[0])}, [{', '.join(elements)}])")
-
-    def _handle_value_constraints(self):
-        for constraint in self._value_constraints:
-            elements = self._get_constraint_values(constraint)
-            self._print_nl(f"{self._indent}{self._indent}self.ValueConstraint(self.{constraint.concept()._name}, [{', '.join(elements)}])")
-
-    def _emit_role_sequence_constraints(self, constraints, constraint_type: str):
-        for constraint in constraints:
-            role_sequences = [[f"self.{self._get_role_name(r)}" for r in ro_list] for ro_list in
-                              constraint.role_sequences()]
-            if self._is_complex_role_sequence(role_sequences):
-                self._print_nl(
-                    f"{self._indent}{self._indent}self.{constraint_type}([{'], ['.join(', '.join(ro_list) for ro_list in role_sequences)}])")
-            else:
-                self._print_nl(
-                    f"{self._indent}{self._indent}self.{constraint_type}({', '.join(', '.join(ro_list) for ro_list in role_sequences)})")
-
-    def _emit_subtype_constraints(self, constraints, constraint_type: str):
-        for constraint in constraints:
-            concepts = [f"self.{self._get_type(c)}" for c in constraint.concepts().values()]
-            self._print_nl(f"{self._indent}{self._indent}self.{constraint_type}({', '.join(concepts)})")
-
-
-EXCLUDED_RELATIONSHIPS = ["shape"]
-
-
-class ObjectOrientedInterfacePrinter(InterfacePrinter):
-    _indent: str
-
-    def __init__(self, io: typing.Optional[typing.IO[str]] = None, space_indent: bool=False):
-        # Set the base class field (frozen)
-        super().__init__(io)
-        object.__setattr__(self, '_indent', SPACE_INDENT if space_indent else TAB_INDENT)
-
-    def to_string(self, model: Model, enums_enabled: bool = False) -> None:
-        if enums_enabled:
-            self._print_nl("from enum import Enum")
-        self._print_nl("from typing import Union")
-        self._print_nl("import relationalai.semantics.internal as qb")
-        self._print_nl("import relationalai.semantics.internal.internal as builder")
-        self._print_nl("from relationalai.early_access.dsl.orm.models import Concept")
-        self._nl()
-        if enums_enabled:
-            self._handle_enums(model)
-        self._handle_concepts(model, enums_enabled)
-
-    def _handle_concepts(self, model: Model, enums_enabled) -> None:
-        concepts_map = model.concepts_map()
-        sorted_concepts = _sort_dependency_graph(model.concepts())
-        for name in sorted_concepts:
-            c = concepts_map.get(name)
-            if c is None:
-                raise ValueError(f"The concept '{name}' was not declared but used as concept domain.")
-            if enums_enabled and c._is_enum():
-                continue
-            exclude_list = list(EXCLUDED_RELATIONSHIPS)
-            # when enum is declared but enums are disabled print it as a Concept without "name" Relationship
-            if c._is_enum():
-                exclude_list.append("name")
-            extends = [f"{e._name}Concept" for e in c._extends if not e._is_primitive()]
-            self._print_nl(f"class {name}Concept({', '.join(extends) if extends else 'Concept'}):")
-            rel_strs = self._get_declared_relationships(c, exclude_list)
-            self._print_nl(f"{self._indent}pass" if len(rel_strs) == 0 else "\n".join(rel_strs))
-            self._nl()
-        self._print_nl("class ORMOntology:")
-        for name in sorted_concepts:
-            c = concepts_map.get(name)
-            if c:
-                if c._is_enum() and enums_enabled:
-                    self._print_nl(f"{self._indent}{c._name}: {c._name}")
-                else:
-                    self._print_nl(f"{self._indent}{c._name}: {c._name}Concept")