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

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

@@ -0,0 +1,256 @@
+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

@@ -0,0 +1,344 @@
+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")