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

relationalai/early_access/dsl/adapters/orm/parser.py

@@ -0,0 +1,636 @@
+import json
+import re
+import warnings
+
+import xmltodict
+from collections import defaultdict
+from relationalai.early_access.dsl.adapters.orm.model import ORMEntityType, ORMValueType, ORMRole, ORMSubtypeFact, \
+    ORMUniquenessConstraint, ORMExclusionConstraint, ORMMandatoryConstraint, ORMReadingRole, ORMReading, \
+    ExclusiveInclusiveSubtypeFact, InclusiveSubtypeFact, ExclusiveSubtypeFact, SubtypeFact, ORMInclusionConstraint, \
+    ORMRoleValueConstraint, ORMValueComparisonConstraint, ORMValueComparisonOperator, ORMRingConstraint, ORMRingType, \
+    ORMRoleSubsetConstraint, ORMInclusiveRoleConstraint, ORMExclusiveRoleConstraint, ORMEqualityConstraint, \
+    ORMFrequencyConstraint, ORMCardinalityConstraint, ORMRange, ORMRoleCardinalityConstraint, \
+    ORMValueTypeValueConstraint
+from relationalai.semantics.metamodel.util import ordered_set
+from relationalai.util.graph import topological_sort
+
+
+class ORMParser:
+
+    def __init__(self, orm_file_path):
+        with open(orm_file_path) as orm_file:
+            data = xmltodict.parse(orm_file.read())
+
+        self._ontology = json.loads(json.dumps(data))
+
+        self._role_to_player = dict()
+        self._cardinality_constraints = dict()
+        self._role_cardinality_constraints = dict()
+        self._value_type_value_constraints = dict()
+
+        self._model_name = self._parse_model_name()
+        self._entity_types = self._parse_entity_types()
+        self._value_types = self._parse_value_types()
+        self._object_types = {**self._value_types, **self._entity_types}
+        self._roles, self._ignored_roles = self._parse_roles()
+        self._fact_type_to_roles = self._parse_fact_type_to_roles()
+        self._role_value_constraints = self._parse_role_value_constraints()
+        self._internal_uniqueness_constraints, self._external_uniqueness_constraints = self._parse_uniqueness_constraints()
+        (self._unique_roles, self._fact_type_to_internal_ucs, self._fact_type_to_complex_ucs,
+         self._identifier_fact_type_to_entity_type) = self._process_internal_uniqueness_constraints()
+        self._exclusion_constraints = self._parse_exclusion_constraints()
+        self._inclusion_constraints = self._parse_inclusion_constraints()
+        self._inclusive_role_constraints = self._parse_inclusive_role_constraints()
+        self._exclusive_role_constraints = self._parse_exclusive_role_constraints()
+        self._mandatory_constraints = self._parse_mandatory_constraints()
+        self._ring_constraints = self._parse_ring_constraints()
+        self._frequency_constraints = self._parse_frequency_constraints()
+        self._value_comparison_constraints = self._parse_value_comparison_constraints()
+        self._role_subset_constraints = self._parse_role_subset_constraints()
+        self._equality_constraints = self._parse_equality_constraints()
+        self._subtype_facts = self._parse_subtype_facts()
+        self._sorted_subtype_facts = self._sort_subtype_facts()
+        self._fact_type_readings = self._parse_fact_types_reading_orders()
+        self._mandatory_roles = self._parse_mandatory_roles()
+        self._object_types_to_cardinality_constraints = self._parse_object_types_to_cardinality_constraints()
+
+    def model_name(self):
+        return self._model_name
+
+    def entity_types(self) -> dict[str, ORMEntityType]:
+        return self._entity_types
+
+    def object_types(self):
+        return self._object_types
+
+    def value_types(self):
+        return self._value_types
+
+    def roles(self):
+        return self._roles
+
+    def role_value_constraints(self):
+        return self._role_value_constraints
+
+    def subtype_facts(self):
+        return self._subtype_facts
+
+    def external_uniqueness_constraints(self):
+        return self._external_uniqueness_constraints
+
+    def value_comparison_constraints(self):
+        return self._value_comparison_constraints
+
+    def inclusion_constraints(self):
+        return self._inclusion_constraints
+
+    def exclusion_constraints(self):
+        return self._exclusion_constraints
+
+    def inclusive_role_constraints(self):
+        return self._inclusive_role_constraints
+
+    def exclusive_role_constraints(self):
+        return self._exclusive_role_constraints
+
+    def ring_constraints(self):
+        return self._ring_constraints
+
+    def frequency_constraints(self):
+        return self._frequency_constraints
+
+    def role_subset_constraints(self):
+        return self._role_subset_constraints
+
+    def equality_constraints(self):
+        return self._equality_constraints
+
+    def cardinality_constraints(self):
+        return self._cardinality_constraints
+
+    def value_type_value_constraints(self):
+        return self._value_type_value_constraints
+    
+    def role_cardinality_constraints(self):
+        return self._role_cardinality_constraints
+
+    def unique_roles(self):
+        return self._unique_roles
+
+    def mandatory_roles(self):
+        return self._mandatory_roles
+
+    def fact_type_readings(self):
+        return self._fact_type_readings
+
+    def fact_type_to_internal_ucs(self):
+        return self._fact_type_to_internal_ucs
+
+    def fact_type_to_complex_ucs(self):
+        return self._fact_type_to_complex_ucs
+
+    def fact_type_to_roles(self):
+        return self._fact_type_to_roles
+
+    def identifier_fact_type_to_entity_type(self):
+        return self._identifier_fact_type_to_entity_type
+
+    def sorted_subtype_facts(self):
+        return self._sorted_subtype_facts
+
+    def objects_type_to_cardinality_constraints(self):
+        return self._object_types_to_cardinality_constraints
+
+    def _parse_fact_type_to_roles(self):
+        fact_type_data = defaultdict(list)
+        for role in self._roles.values():
+            relationship_name = role.relationship_name
+            fact_type_data[relationship_name].append(role)
+        return fact_type_data
+
+    def _parse_object_types_to_cardinality_constraints(self):
+        object_types_constraints = {}
+        for cc in self._cardinality_constraints.values():
+            object_type_name = self._object_types[cc.object_type].name
+            object_types_constraints[object_type_name] = cc
+        return object_types_constraints
+
+    def _parse_model_name(self):
+        model_name = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel", "@Name")
+        return model_name if model_name else "ORMModel"
+
+    def _parse_entity_types(self):
+        entity_types = {}
+        orm_entity_types = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                            "orm:Objects", "orm:EntityType")
+        if orm_entity_types:
+            for et in self._single_object_to_list(orm_entity_types):
+                id = et["@id"]
+                name = et['@Name']
+                ref_mode = et.get("@_ReferenceMode") or None
+                entity_types[id] = ORMEntityType(id, name, ref_mode)
+                self._parse_role_to_player_reference(et)
+                self._parse_cardinality_constraint(et)
+        return entity_types
+
+    def _parse_value_types(self):
+        value_types = {}
+        data_types = self._parse_data_types()
+        orm_value_types = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                           "orm:Objects", "orm:ValueType")
+        if orm_value_types:
+            for vt in self._single_object_to_list(orm_value_types):
+                if not vt.get("@IsImplicitBooleanValue"):
+                    id = vt["@id"]
+                    name = vt["@Name"]
+                    data_type = data_types[self._get_nested(vt, "orm:ConceptualDataType", "@ref")]
+                    value_types[id] = ORMValueType(id, name, data_type)
+                    self._parse_role_to_player_reference(vt)
+                    self._parse_cardinality_constraint(vt)
+                    self._parse_value_type_value_constraints(vt)
+        return value_types
+
+    def _parse_value_type_value_constraints(self, vt):
+        vt_id = vt.get("@id")
+        value_constraint = self._get_nested(vt,  "orm:ValueRestriction", "orm:ValueConstraint")
+        if value_constraint:
+            vc_id = value_constraint.get("@id")
+            range_values = self._parse_constraint_range(value_constraint)
+            self._value_type_value_constraints[vt_id] = ORMValueTypeValueConstraint(vc_id, vt, range_values)
+
+    def _parse_data_types(self):
+        data_types = {}
+        orm_data_types = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel", "orm:DataTypes")
+        if orm_data_types:
+            for k, v in orm_data_types.items():
+                if v is not None:
+                    data_types[v["@id"]] = k[4:]
+        return data_types
+
+    def _parse_roles(self):
+        roles = {}
+        ignored_roles = []
+        orm_fact_types = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel", "orm:Facts", "orm:Fact")
+        if orm_fact_types:
+            for ft in self._single_object_to_list(orm_fact_types):
+                relationship_name = ft['@_Name']
+                unary_pattern = ft.get("@UnaryPattern", None)  # unary patterns are not supported
+                orm_roles = self._get_nested(ft, "orm:FactRoles", "orm:Role")
+                if orm_roles:
+                    for ro in self._single_object_to_list(orm_roles):
+                        role_id = ro["@id"]
+                        role_name = ro["@Name"]
+                        if (unary_pattern is not None and unary_pattern == "Negation") or role_id not in self._role_to_player.keys():
+                            ignored_roles.append(role_id)
+                        else:
+                            roles[role_id] = ORMRole(role_id, role_name, relationship_name, self._role_to_player[role_id])
+                            self._parse_role_cardinality_constraint(ro)
+        return roles, ignored_roles
+
+    def _parse_role_to_player_reference(self, object_type):
+        roles = self._get_nested(object_type, "orm:PlayedRoles", "orm:Role")
+        if roles:
+            for role in self._single_object_to_list(roles):
+                self._role_to_player[role["@ref"]] = object_type["@id"]
+
+    def _parse_role_value_constraints(self):
+        role_value_constraints = {}
+        orm_fact_types = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel", "orm:Facts", "orm:Fact")
+        if orm_fact_types:
+            for ft in self._single_object_to_list(orm_fact_types):
+                roles = self._get_nested(ft, "orm:FactRoles", "orm:Role")
+                if roles and isinstance(roles, list):
+                    for ro in roles:
+                        role_id = ro.get("@id")
+                        if role_id not in self._ignored_roles:
+                            role_value_constraint = self._get_nested(ro, "orm:ValueRestriction", "orm:RoleValueConstraint")
+                            if role_value_constraint:
+                                range_values = self._parse_constraint_range(role_value_constraint)
+                                role_value_constraints[role_id] = ORMRoleValueConstraint(self._roles[role_id], range_values)
+        return role_value_constraints
+
+    def _parse_constraint_range(self, orm_constraint_object):
+        values = []
+        value_range = self._get_nested(orm_constraint_object, "orm:ValueRanges", "orm:ValueRange")
+        if value_range:
+            for rvc in self._single_object_to_list(value_range):
+                min_value = rvc.get("@MinValue")
+                max_value = rvc.get("@MaxValue")
+                if min_value and max_value:
+                    if min_value == max_value:
+                        values.append(min_value)
+                    else:
+                        values.append(ORMRange(min_value, max_value))
+                else:
+                    raise ValueError("Range value must have both MinValue and MaxValue defined.")
+        return values
+
+    def _parse_inclusive_role_constraints(self):
+        constraints = []
+        for ec in self._inclusion_constraints.values():
+            if ec.roles and set(ec.roles).issubset(self._roles) and all(ro not in self._ignored_roles for ro in ec.roles):
+                constraints.append(ORMInclusiveRoleConstraint(ec.id, ec.roles))
+        return constraints
+
+    def _parse_exclusive_role_constraints(self):
+        constraints = []
+        for ec in self._exclusion_constraints.values():
+            flat_roles = [role for role_list in ec.roles for role in role_list]
+            if ec.roles and set(flat_roles).issubset(self._roles) and all(ro not in self._ignored_roles for ro in flat_roles):
+                constraints.append(ORMExclusiveRoleConstraint(ec.id, ec.roles))
+        return constraints
+
+    def _parse_subtype_facts(self):
+        subtype_of = defaultdict(list)
+        for subtype_arrow in self._parse_subtype_arrows():
+            subtype_object = self._build_subtype_object(subtype_arrow)
+            subtype_of[subtype_object.supertype_name].append(subtype_object)
+        return subtype_of
+
+    def _parse_subtype_arrows(self):
+        subtype_of = []
+        orm_subtype_facts = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                             "orm:Facts", "orm:SubtypeFact")
+        if orm_subtype_facts:
+            for sft in self._single_object_to_list(orm_subtype_facts):
+                subtype_of.append(self._parse_subtype_arrow(sft))
+        return subtype_of
+
+    def _parse_subtype_arrow(self, subtype_fact):
+        fact_roles = subtype_fact["orm:FactRoles"]
+        subtype_id = self._get_nested(fact_roles, "orm:SubtypeMetaRole", "@id")
+        subtype = self._get_nested(fact_roles, "orm:SubtypeMetaRole", "orm:RolePlayer", "@ref")
+        supertype_id = self._get_nested(fact_roles, "orm:SupertypeMetaRole", "@id")
+        supertype = self._get_nested(fact_roles, "orm:SupertypeMetaRole", "orm:RolePlayer", "@ref")
+        return ORMSubtypeFact(subtype_id, subtype, supertype_id, supertype)
+
+    def _parse_uniqueness_constraints(self):
+        internal = {}
+        external = {}
+        orm_ucs = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                   "orm:Constraints", "orm:UniquenessConstraint")
+        if orm_ucs:
+            for uc in self._single_object_to_list(orm_ucs):
+                uc_id = uc["@id"]
+                pid = uc.get("orm:PreferredIdentifierFor", None)
+                identifies = None
+                if pid is not None and pid["@ref"] in self._entity_types:
+                    identifies = pid["@ref"]
+                roles = self._parse_role_sequence(uc)
+                if roles:
+                    target = internal if uc.get("@IsInternal") == "true" else external
+                    target[uc_id] = ORMUniquenessConstraint(uc_id, roles, identifies)
+        return internal, external
+
+    def _process_internal_uniqueness_constraints(self):
+        unique_roles = []
+        fact_type_to_internal_uc = defaultdict(list)
+        fact_type_to_complex_uc = defaultdict(list)
+        identifier_fact_type_to_entity_type = defaultdict()
+
+        for uc in self._internal_uniqueness_constraints.values():
+            if uc.identifies is None and len(uc.roles) == 1:
+                unique_roles.extend(uc.roles)
+
+            role_id = uc.roles[0]
+            role = self._roles.get(role_id)
+            if not role or not role.relationship_name:
+                continue
+
+            fact_type = role.relationship_name
+
+            fact_type_to_internal_uc[fact_type].append(uc)
+
+            if uc.identifies is None:
+                if len(uc.roles) > 1:
+                    fact_type_to_complex_uc[fact_type].append(uc)
+            else:
+                identifier_fact_type_to_entity_type[fact_type] = self._entity_types[uc.identifies]
+
+        return unique_roles, fact_type_to_internal_uc, fact_type_to_complex_uc, identifier_fact_type_to_entity_type
+
+    def _parse_mandatory_constraints(self):
+        mandatory_constraints = {}
+        orm_mcs = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                   "orm:Constraints", "orm:MandatoryConstraint")
+        if orm_mcs:
+            for mc in self._single_object_to_list(orm_mcs):
+                mc_id = mc["@id"]
+                if mc.get("@IsSimple", None) is not None:
+                    roles = self._parse_role_sequence(mc)
+                    if roles:
+                        mandatory_constraints[mc_id] = ORMMandatoryConstraint(mc_id, roles)
+        return mandatory_constraints
+
+    def _parse_value_comparison_constraints(self):
+        value_comparison_constraints = {}
+        orm_vccs = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                    "orm:Constraints", "orm:ValueComparisonConstraint")
+        if orm_vccs:
+            for vcc in self._single_object_to_list(orm_vccs):
+                vcc_id = vcc["@id"]
+                vcc_op = vcc["@Operator"]
+                roles = self._parse_role_sequence(vcc)
+                if roles:
+                    constraint = ORMValueComparisonConstraint(vcc_id, ORMValueComparisonOperator(vcc_op), roles)
+                    value_comparison_constraints[vcc_id] = constraint
+        return value_comparison_constraints
+
+    def _parse_role_subset_constraints(self):
+        return self._parse_role_sequence_constraints("orm:SubsetConstraint", ORMRoleSubsetConstraint)
+
+    def _parse_equality_constraints(self):
+        return self._parse_role_sequence_constraints("orm:EqualityConstraint", ORMEqualityConstraint)
+
+    def _parse_role_sequence_constraints(self, json_name, constraint_type: type):
+        role_sequence_constraints = {}
+        orm_constraints = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                    "orm:Constraints", json_name)
+        if orm_constraints:
+            for role_sequence_constraint in self._single_object_to_list(orm_constraints):
+                id = role_sequence_constraint["@id"]
+                roles = self._parse_role_sequences(role_sequence_constraint)
+                if roles:
+                    role_sequence_constraints[id] = constraint_type(id, roles)
+        return role_sequence_constraints
+
+    def _parse_inclusion_constraints(self):
+        inclusion_constraints = {}
+        orm_mcs = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                   "orm:Constraints", "orm:MandatoryConstraint")
+        if orm_mcs:
+            for mc in self._single_object_to_list(orm_mcs):
+                mc_id = mc["@id"]
+                mc_name = mc["@Name"]
+                if mc_name.startswith("InclusiveOrConstraint"):
+                    exclusive = mc.get("orm:ExclusiveOrExclusionConstraint", None) is not None
+                    roles = self._parse_role_sequence(mc)
+                    if roles:
+                        inclusion_constraints[mc_id] = ORMInclusionConstraint(mc_id, roles, exclusive)
+        return inclusion_constraints
+
+    def _parse_exclusion_constraints(self):
+        exclusion_constraints = {}
+        orm_mcs = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                   "orm:Constraints", "orm:ExclusionConstraint")
+        if orm_mcs:
+            for ec in self._single_object_to_list(orm_mcs):
+                ec_id = ec["@id"]
+                inclusive = ec.get("orm:ExclusiveOrMandatoryConstraint", None) is not None
+                role_sequences = self._parse_role_sequences(ec)
+                if role_sequences:
+                    exclusion_constraints[ec_id] = ORMExclusionConstraint(ec_id, role_sequences, inclusive)
+        return exclusion_constraints
+
+    def _parse_ring_constraints(self):
+        ring_constraints = {}
+        orm_rcs = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                   "orm:Constraints", "orm:RingConstraint")
+        if orm_rcs:
+            for rc in self._single_object_to_list(orm_rcs):
+                rc_id = rc["@id"]
+                rc_type = rc["@Type"]
+                roles = self._parse_role_sequence(rc)
+                if roles:
+                    ring_constraints[rc_id] = ORMRingConstraint(rc_id, roles, self._process_ring_constraint(rc_type))
+        return ring_constraints
+
+    def _parse_frequency_constraints(self):
+        frequency_constraints = {}
+        orm_fcs = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel",
+                                   "orm:Constraints", "orm:FrequencyConstraint")
+        if orm_fcs:
+            for fc in self._single_object_to_list(orm_fcs):
+                fc_id = fc["@id"]
+                min_freq = fc["@MinFrequency"]
+                max_freq = fc["@MaxFrequency"]
+                roles = self._parse_role_sequence(fc)
+                if roles:
+                    frequency_constraints[fc_id] = ORMFrequencyConstraint(fc_id, min_freq, max_freq, roles)
+        return frequency_constraints
+
+    def _parse_fact_types_reading_orders(self):
+        fact_types_readings = defaultdict(list)
+        fact_types = self._get_nested(self._ontology, "ormRoot:ORM2", "orm:ORMModel", "orm:Facts", "orm:Fact")
+        if fact_types:
+            for ft in self._single_object_to_list(fact_types):
+                relationship_name = (ft['@_Name'])
+                reading_orders = self._get_nested(ft, "orm:ReadingOrders", "orm:ReadingOrder")
+                if reading_orders:
+                    for ro in self._single_object_to_list(reading_orders):
+                        reading_order = self._parse_fact_types_reading_order(ro)
+                        if reading_order:
+                            fact_types_readings[relationship_name].append(reading_order)
+        return fact_types_readings
+
+    def _parse_fact_types_reading_order(self, reading_order):
+        results = []
+        readings = self._get_nested(reading_order, "orm:Readings", "orm:Reading",)
+        if readings:
+            for rd in self._single_object_to_list(readings):
+                expanded_data = self._get_nested(rd,  "orm:ExpandedData")
+                if expanded_data:
+                    front_text = expanded_data.get("@FrontText", None)
+                    if front_text:
+                        front_text = front_text.strip()
+
+                    role_texts = self._get_nested(expanded_data,"orm:RoleText")
+                    if role_texts:
+                        # Step 1: Build roles with whatever RoleText exists
+                        index_to_role = {}
+                        for rt in self._single_object_to_list(role_texts):
+                            index = int(rt["@RoleIndex"])
+                            index_to_role[index] = ORMReadingRole(
+                                index=index,
+                                prefix=rt.get("@PreBoundText", "").strip() or None,
+                                postfix=rt.get("@PostBoundText", "").strip() or None,
+                                text=rt.get("@FollowingText", "").strip() or None,
+                                role=None
+                            )
+
+                        # Step 2: Ensure all roles from RoleSequence are represented, even if no RoleText exists
+                        roles = self._get_nested(reading_order, "orm:RoleSequence", "orm:Role")
+                        if roles:
+                            for i, role in enumerate(self._single_object_to_list(roles)):
+                                role_id = role.get("@ref")
+                                orm_role = self._roles.get(role_id, None)
+                                if i in index_to_role:
+                                    index_to_role[i].role = orm_role
+                                else:
+                                    # Fill in with None/defaults if RoleText is missing
+                                    index_to_role[i] = ORMReadingRole(
+                                        index=i,
+                                        prefix=None,
+                                        postfix=None,
+                                        text=None,
+                                        role=orm_role
+                                    )
+                        results.append(ORMReading(front_text, [index_to_role[i] for i in sorted(index_to_role)]))
+        if len(results) > 1:
+            warnings.warn("Multiple readings for the same reading order are not supported. Using the first one.")
+        return results[0] if results else None
+
+    def _parse_cardinality_constraint_range(self, cardinality_constraint):
+        ranges = self._get_nested(cardinality_constraint, "orm:Ranges", "orm:CardinalityRange")
+        # At least a range is always present within a cardinality constraint
+        orm_ranges = []
+        for rg in self._single_object_to_list(ranges):
+            range_from = rg.get("@From")
+            range_to = rg.get("@To")
+            orm_ranges.append(ORMRange(range_from, range_to))
+        return orm_ranges
+
+    def _parse_cardinality_constraint(self, object_type):
+        orm_cc = self._get_nested(object_type, "orm:CardinalityRestriction", "orm:CardinalityConstraint")
+        if orm_cc:
+            object_type_id = object_type.get("@id")
+            cc_id = orm_cc.get("@id")
+            ranges = self._parse_cardinality_constraint_range(orm_cc)
+            self._cardinality_constraints[cc_id] = ORMCardinalityConstraint(cc_id, object_type_id, ranges)
+
+    def _parse_role_cardinality_constraint(self, role):
+        orm_rcc = self._get_nested(role, "orm:CardinalityRestriction", "orm:UnaryRoleCardinalityConstraint")
+        if orm_rcc:
+            role_id = role.get("@id")
+            cc_id = orm_rcc.get("@id")
+            ranges = self._parse_cardinality_constraint_range(orm_rcc)
+            self._role_cardinality_constraints[role_id] = ORMRoleCardinalityConstraint(cc_id, role_id, ranges)
+
+    @staticmethod
+    def _get_nested(d, *keys):
+        for key in keys:
+            d = d.get(key)
+            if d is None:
+                return None
+        return d
+
+    def _build_subtype_object(self, subtype_arrow):
+        sub_name = self._object_types[subtype_arrow.subtype].name
+        sup_name = self._object_types[subtype_arrow.supertype].name
+        # Look at exclusion constraints
+        for ec_metadata in self._exclusion_constraints.values():
+            flat_role_sequence = [role for role_list in ec_metadata.roles for role in role_list]
+            if subtype_arrow.supertype_role_id in flat_role_sequence:
+                if ec_metadata.inclusive:
+                    return ExclusiveInclusiveSubtypeFact(sub_name, sup_name)
+                else:
+                    return ExclusiveSubtypeFact(sub_name, sup_name)
+        # Look at inclusion constraints
+        for ic_metadata in self._inclusion_constraints.values():
+            if subtype_arrow.supertype_role_id in ic_metadata.roles:
+                if ic_metadata.exclusive:
+                    return ExclusiveInclusiveSubtypeFact(sub_name, sup_name)
+                else:
+                    return InclusiveSubtypeFact(sub_name, sup_name)
+        # Default case, no constraints found
+        return SubtypeFact(sub_name, sup_name)
+
+    def _parse_mandatory_roles(self):
+        mandatory_roles = []
+        for mc in self._mandatory_constraints.values():
+            mandatory_roles.extend(mc.roles)
+        return mandatory_roles
+
+    def _parse_role_sequences(self, orm_constraint):
+        result = []
+        role_sequences = self._get_nested(orm_constraint, "orm:RoleSequences", "orm:RoleSequence")
+        if role_sequences:
+            for rs in self._single_object_to_list(role_sequences):
+                role_sequence = []
+                roles = self._get_nested(rs, "orm:Role")
+                if roles:
+                    for ro in self._single_object_to_list(roles):
+                        role_id = ro["@ref"]
+                        # Ignore the entire constraint if it involves an ignored role
+                        if role_id in self._ignored_roles:
+                            return None
+                        else:
+                            role_sequence.append(role_id)
+                    result.append(role_sequence)
+        return result
+
+    def _parse_role_sequence(self, orm_constraint):
+        roles = self._get_nested(orm_constraint, "orm:RoleSequence", "orm:Role")
+        role_sequence = []
+        if roles:
+            for ro in self._single_object_to_list(roles):
+                role_id = ro["@ref"]
+                # Ignore the entire constraint if it involves an ignored role
+                if role_id in self._ignored_roles:
+                    role_sequence = None
+                    break
+                else:
+                    role_sequence.append(role_id)
+        return role_sequence
+
+    def _sort_subtype_facts(self):
+        # Build a dependency graph to sort subtype facts so that child entity are declared
+        # after the parent entity that they extend
+        subtype_facts = self._subtype_facts
+        edges = []
+        nodes = ordered_set()
+        sorted_subtype_facts = []
+        # Parent depends on child, i.e., parent entity must be declared before child entity
+        for parent in subtype_facts:
+            nodes.add(parent)
+            for child in subtype_facts[parent]:
+                target = child.subtype_name
+                edges.append((parent, target))
+                nodes.add(target)
+        for parent in topological_sort(list(nodes), edges):
+            sorted_subtype_facts.extend(subtype_facts[parent])
+        return sorted_subtype_facts
+
+    @staticmethod
+    def _process_ring_constraint(rc_type):
+        pattern = '|'.join(r_type.value for r_type in ORMRingType)
+        matches = re.finditer(pattern, rc_type)
+
+        ring_types = []
+        for match in matches:
+            ring_types.append(ORMRingType(match.group(0)))
+        return ring_types
+
+    @staticmethod
+    def _single_object_to_list(parsed_object):
+        return parsed_object if isinstance(parsed_object, list) else [parsed_object]