cognite-neat 0.85.12__py3-none-any.whl → 0.87.0__py3-none-any.whl

cognite/neat/legacy/rules/models/rules.py

@@ -29,7 +29,7 @@ from pydantic import (
 from pydantic.fields import FieldInfo
 from rdflib import XSD, Literal, Namespace, URIRef
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import get_default_prefixes
 from cognite.neat.legacy.rules import exceptions
 from cognite.neat.legacy.rules.models._base import (
     ENTITY_ID_REGEX_COMPILED,
@@ -49,7 +49,10 @@ from cognite.neat.legacy.rules.models.rdfpath import (
     Traversal,
     parse_rule,
 )
-from cognite.neat.legacy.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS, ValueType
+from cognite.neat.legacy.rules.models.value_types import (
+    XSD_VALUE_TYPE_MAPPINGS,
+    ValueType,
+)
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -82,7 +85,10 @@ def replace_nan_floats_with_default(values: dict, model_fields: dict[str, FieldI
             output[field_name] = model_fields[field_name].default
         else:
             # field_name may be an alias
-            source_name = next((name for name, field in model_fields.items() if field.alias == field_name), None)
+            source_name = next(
+                (name for name, field in model_fields.items() if field.alias == field_name),
+                None,
+            )
             if source_name:
                 output[field_name] = model_fields[source_name].default
             else:
@@ -335,7 +341,9 @@ class Metadata(RuleModel):
         if value.endswith("#") or value.endswith("/"):
             return value
         warnings.warn(
-            exceptions.NamespaceEndingFixed(value).message, category=exceptions.NamespaceEndingFixed, stacklevel=2
+            exceptions.NamespaceEndingFixed(value).message,
+            category=exceptions.NamespaceEndingFixed,
+            stacklevel=2,
         )
         return Namespace(f"{value}#")
 
@@ -444,10 +452,14 @@ class Resource(RuleModel):
         default=None,
     )
     source_entity_name: str | None = Field(
-        alias="Source Entity Name", description="Closest entity in source, e.g. Substation", default=None
+        alias="Source Entity Name",
+        description="Closest entity in source, e.g. Substation",
+        default=None,
     )
     match_type: str | None = Field(
-        alias="Match Type", description="Type of match between source entity and one being defined", default=None
+        alias="Match Type",
+        description="Type of match between source entity and one being defined",
+        default=None,
     )
     comment: str | None = Field(alias="Comment", description="Comment about mapping", default=None)
 
@@ -656,7 +668,9 @@ class Property(Resource):
     # Specialization of cdf_resource_type to allow definition of both
     # Asset and Relationship at the same time
     cdf_resource_type: list[str] = Field(
-        alias="Resource Type", default_factory=list, description="This is typically 'Asset' or 'Relationship'"
+        alias="Resource Type",
+        default_factory=list,
+        description="This is typically 'Asset' or 'Relationship'",
     )
 
     # Transformation rule (domain to solution)
@@ -701,7 +715,11 @@ class Property(Resource):
             return ValueType.from_string(entity_string=value, type_=EntityTypes.object_value_type, mapping=None)
         else:
             return ValueType(
-                prefix="undefined", suffix=value, name=value, type_=EntityTypes.object_value_type, mapping=None
+                prefix="undefined",
+                suffix=value,
+                name=value,
+                type_=EntityTypes.object_value_type,
+                mapping=None,
             )
         #     return ValueType(
 
@@ -820,7 +838,9 @@ class Property(Resource):
     def set_relationship_label(self):
         if self.label is None:
             warnings.warn(
-                exceptions.MissingLabel(self.property_id).message, category=exceptions.MissingLabel, stacklevel=2
+                exceptions.MissingLabel(self.property_id).message,
+                category=exceptions.MissingLabel,
+                stacklevel=2,
             )
             self.label = self.property_id
         return self
@@ -899,7 +919,7 @@ class Prefixes(RuleModel):
         prefixes: Dict of prefixes
     """
 
-    prefixes: dict[str, Namespace] = PREFIXES
+    prefixes: dict[str, Namespace] = get_default_prefixes()
 
 
 class Instance(RuleModel):
@@ -1019,7 +1039,7 @@ class Rules(RuleModel):
         classes: Classes defined in the data model
         properties: Class properties defined in the data model with accompanying transformation rules
                     to transform data from source to target representation
-        prefixes: Prefixes used in the data model. Defaults to PREFIXES
+        prefixes: Prefixes used in the data model. Defaults to internal prefixes
         instances: Instances defined in the data model. Defaults to None
         validators_to_skip: List of validators to skip. Defaults to []
 
@@ -1035,7 +1055,7 @@ class Rules(RuleModel):
     metadata: Metadata
     classes: Classes
     properties: Properties
-    prefixes: dict[str, Namespace] = PREFIXES.copy()
+    prefixes: dict[str, Namespace] = get_default_prefixes()
     instances: list[Instance] = Field(default_factory=list)
 
     @property

cognite/neat/rules/_shared.py

@@ -1,5 +1,10 @@
 from typing import TypeAlias
 
-from cognite.neat.rules.models import AssetRules, DMSRules, DomainRules, InformationRules
+from cognite.neat.rules.models import (
+    AssetRules,
+    DMSRules,
+    DomainRules,
+    InformationRules,
+)
 
 Rules: TypeAlias = DomainRules | InformationRules | DMSRules | AssetRules

cognite/neat/rules/analysis/__init__.py

@@ -1,6 +1,6 @@
-from ._information_rules import (
-    AssetArchitectRulesAnalysis,
-    InformationArchitectRulesAnalysis,
+from ._asset import AssetAnalysis
+from ._information import (
+    InformationAnalysis,
 )
 
-__all__ = ["InformationArchitectRulesAnalysis", "AssetArchitectRulesAnalysis"]
+__all__ = ["InformationAnalysis", "AssetAnalysis"]

cognite/neat/rules/analysis/_asset.py

@@ -0,0 +1,128 @@
+import warnings
+from typing import cast
+
+from cognite.neat.rules.models import AssetRules
+from cognite.neat.rules.models._rdfpath import RDFPath
+from cognite.neat.rules.models.asset import AssetClass, AssetProperty
+from cognite.neat.rules.models.entities import (
+    AssetEntity,
+    ClassEntity,
+    EntityTypes,
+    ReferenceEntity,
+    RelationshipEntity,
+)
+
+from ._base import BaseAnalysis
+
+
+class AssetAnalysis(BaseAnalysis[AssetRules, AssetClass, AssetProperty, ClassEntity, str]):
+    """Assumes analysis over only the complete schema"""
+
+    def _get_reference(self, class_or_property: AssetClass | AssetProperty) -> ReferenceEntity | None:
+        return class_or_property.reference if isinstance(class_or_property.reference, ReferenceEntity) else None
+
+    def _get_cls_entity(self, class_: AssetClass | AssetProperty) -> ClassEntity:
+        return class_.class_
+
+    def _get_prop_entity(self, property_: AssetProperty) -> str:
+        return property_.property_
+
+    def _get_cls_parents(self, class_: AssetClass) -> list[ClassEntity] | None:
+        return list(class_.parent or []) or None
+
+    def _get_reference_rules(self) -> AssetRules | None:
+        return self.rules.reference
+
+    @classmethod
+    def _set_cls_entity(cls, property_: AssetProperty, class_: ClassEntity) -> None:
+        property_.class_ = class_
+
+    def _get_object(self, property_: AssetProperty) -> ClassEntity | None:
+        return property_.value_type if isinstance(property_.value_type, ClassEntity) else None
+
+    def _get_max_occurrence(self, property_: AssetProperty) -> int | float | None:
+        return property_.max_count
+
+    def _get_classes(self) -> list[AssetClass]:
+        return list(self.rules.classes)
+
+    def _get_properties(self) -> list[AssetProperty]:
+        return list(self.rules.properties)
+
+    def subset_rules(self, desired_classes: set[ClassEntity]) -> AssetRules:
+        raise NotImplementedError("Method not implemented")
+
+    def class_property_pairs(
+        self,
+        only_rdfpath: bool = False,
+        consider_inheritance: bool = False,
+        implementation_type: EntityTypes = EntityTypes.asset,
+    ) -> dict[ClassEntity, dict[str, AssetProperty]]:
+        class_property_pairs = {}
+
+        T_implementation = AssetEntity if implementation_type == EntityTypes.asset else RelationshipEntity
+
+        for class_, properties in self.classes_with_properties(consider_inheritance).items():
+            processed_properties = {}
+            for property_ in properties:
+                if property_.property_ in processed_properties:
+                    # TODO: use appropriate Warning class from _exceptions.py
+                    # if missing make one !
+                    warnings.warn(
+                        f"Property {property_.property_} for {class_} has been defined more than once!"
+                        " Only the first definition will be considered, skipping the rest..",
+                        stacklevel=2,
+                    )
+                    continue
+
+                if (
+                    property_.implementation
+                    and any(isinstance(implementation, T_implementation) for implementation in property_.implementation)
+                    and (not only_rdfpath or (only_rdfpath and isinstance(property_.transformation, RDFPath)))
+                ):
+                    implementation = [
+                        implementation
+                        for implementation in property_.implementation
+                        if isinstance(implementation, T_implementation)
+                    ]
+
+                    processed_properties[property_.property_] = property_.model_copy(
+                        deep=True, update={"implementation": implementation}
+                    )
+
+            if processed_properties:
+                class_property_pairs[class_] = processed_properties
+
+        return class_property_pairs
+
+    def asset_definition(
+        self, only_rdfpath: bool = False, consider_inheritance: bool = False
+    ) -> dict[ClassEntity, dict[str, AssetProperty]]:
+        return self.class_property_pairs(
+            consider_inheritance=consider_inheritance,
+            only_rdfpath=only_rdfpath,
+            implementation_type=EntityTypes.asset,
+        )
+
+    def relationship_definition(
+        self, only_rdfpath: bool = False, consider_inheritance: bool = False
+    ) -> dict[ClassEntity, dict[str, AssetProperty]]:
+        return self.class_property_pairs(
+            consider_inheritance=consider_inheritance,
+            only_rdfpath=only_rdfpath,
+            implementation_type=EntityTypes.relationship,
+        )
+
+    def define_property_renaming_config(self, class_: ClassEntity) -> dict[str, str]:
+        property_renaming_configuration = {}
+
+        if asset_definition := self.asset_definition().get(class_, None):
+            for property_, transformation in asset_definition.items():
+                asset_property = cast(list[AssetEntity], transformation.implementation)[0].property_
+
+                if asset_property != "metadata":
+                    property_renaming_configuration[property_] = str(asset_property)
+                else:
+                    property_renaming_configuration[property_] = f"{asset_property}.{property_}"
+
+        return property_renaming_configuration

cognite/neat/rules/analysis/_base.py

@@ -1,13 +1,392 @@
+import itertools
+import warnings
 from abc import ABC, abstractmethod
+from collections import defaultdict
+from collections.abc import Set
+from dataclasses import dataclass
 from typing import Generic, TypeVar
 
-from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.models.entities import ClassEntity
+import pandas as pd
+from pydantic import BaseModel
 
-T_Rules = TypeVar("T_Rules", bound=Rules)
+from cognite.neat.rules.models._base import BaseRules
+from cognite.neat.rules.models._rdfpath import RDFPath
+from cognite.neat.rules.models.entities import (
+    ClassEntity,
+    Entity,
+    ReferenceEntity,
+)
+from cognite.neat.rules.models.information import InformationProperty
+from cognite.neat.utils.utils import get_inheritance_path
 
+T_Rules = TypeVar("T_Rules", bound=BaseRules)
+T_Property = TypeVar("T_Property", bound=BaseModel)
+T_Class = TypeVar("T_Class", bound=BaseModel)
+T_ClassEntity = TypeVar("T_ClassEntity", bound=Entity)
+T_PropertyEntity = TypeVar("T_PropertyEntity", bound=Entity | str)
+
+
+@dataclass(frozen=True)
+class Linkage(Generic[T_ClassEntity, T_PropertyEntity]):
+    source_class: T_ClassEntity
+    connecting_property: T_PropertyEntity
+    target_class: T_ClassEntity
+    max_occurrence: int | float | None
+
+
+class LinkageSet(set, Generic[T_ClassEntity, T_PropertyEntity], Set[Linkage[T_ClassEntity, T_PropertyEntity]]):
+    @property
+    def source_class(self) -> set[T_ClassEntity]:
+        return {link.source_class for link in self}
+
+    @property
+    def target_class(self) -> set[T_ClassEntity]:
+        return {link.target_class for link in self}
+
+    def get_target_classes_by_source(self) -> dict[T_ClassEntity, set[T_ClassEntity]]:
+        target_classes_by_source: dict[T_ClassEntity, set[T_ClassEntity]] = defaultdict(set)
+        for link in self:
+            target_classes_by_source[link.source_class].add(link.target_class)
+        return target_classes_by_source
+
+    def to_pandas(self) -> pd.DataFrame:
+        # Todo: Remove this method
+        return pd.DataFrame(
+            [
+                {
+                    "source_class": link.source_class,
+                    "connecting_property": link.connecting_property,
+                    "target_class": link.target_class,
+                    "max_occurrence": link.max_occurrence,
+                }
+                for link in self
+            ]
+        )
+
+
+class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_PropertyEntity]):
+    def __init__(self, rules: T_Rules) -> None:
+        self.rules = rules
+
+    @abstractmethod
+    def _get_classes(self) -> list[T_Class]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_properties(self) -> list[T_Property]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_reference(self, class_or_property: T_Class | T_Property) -> ReferenceEntity | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_cls_entity(self, class_: T_Class | T_Property) -> T_ClassEntity:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_prop_entity(self, property_: T_Property) -> T_PropertyEntity:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_cls_parents(self, class_: T_Class) -> list[T_ClassEntity] | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_reference_rules(self) -> T_Rules | None:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def _set_cls_entity(cls, property_: T_Property, class_: T_ClassEntity) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_object(self, property_: T_Property) -> T_ClassEntity | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_max_occurrence(self, property_: T_Property) -> int | float | None:
+        raise NotImplementedError
+
+    @property
+    def directly_referred_classes(self) -> set[ClassEntity]:
+        ref_rules = self._get_reference_rules()
+        if ref_rules is None:
+            return set()
+        prefix = ref_rules.metadata.get_prefix()
+        return {
+            ref.as_class_entity()
+            for class_ in self._get_classes()
+            if isinstance((ref := self._get_reference(class_)), ReferenceEntity) and ref.prefix == prefix
+        }
+
+    @property
+    def inherited_referred_classes(self) -> set[ClassEntity]:
+        dir_referred_classes = self.directly_referred_classes
+        inherited_referred_classes = []
+        for class_ in dir_referred_classes:
+            inherited_referred_classes.extend(self.class_inheritance_path(class_))
+        return set(inherited_referred_classes)
+
+    # Todo Lru cache this method.
+    def class_parent_pairs(self) -> dict[T_ClassEntity, list[T_ClassEntity]]:
+        """This only returns class - parent pairs only if parent is in the same data model"""
+        class_subclass_pairs: dict[T_ClassEntity, list[T_ClassEntity]] = {}
+        for cls_ in self._get_classes():
+            entity = self._get_cls_entity(cls_)
+            class_subclass_pairs[entity] = []
+            for parent in self._get_cls_parents(cls_) or []:
+                if parent.prefix == entity.prefix:
+                    class_subclass_pairs[entity].append(parent)
+                else:
+                    warnings.warn(
+                        f"Parent class {parent} of class {cls_} is not in the same namespace, skipping !",
+                        stacklevel=2,
+                    )
+
+        return class_subclass_pairs
+
+    def classes_with_properties(self, consider_inheritance: bool = False) -> dict[T_ClassEntity, list[T_Property]]:
+        """Returns classes that have been defined in the data model.
+
+        Args:
+            consider_inheritance: Whether to consider inheritance or not. Defaults False
+
+        Returns:
+            Dictionary of classes with a list of properties defined for them
+
+        !!! note "consider_inheritance"
+            If consider_inheritance is True, properties from parent classes will also be considered.
+            This means if a class has a parent class, and the parent class has properties defined for it,
+            while we do not have any properties defined for the child class, we will still consider the
+            properties from the parent class. If consider_inheritance is False, we will only consider
+            properties defined for the child class, thus if no properties are defined for the child class,
+            it will not be included in the returned dictionary.
+        """
+
+        class_property_pairs: dict[T_ClassEntity, list[T_Property]] = defaultdict(list)
+
+        for property_ in self._get_properties():
+            class_property_pairs[self._get_cls_entity(property_)].append(property_)  # type: ignore
+
+        if consider_inheritance:
+            class_parent_pairs = self.class_parent_pairs()
+            for class_ in class_parent_pairs:
+                self._add_inherited_properties(class_, class_property_pairs, class_parent_pairs)
+
+        return class_property_pairs
+
+    def class_inheritance_path(self, class_: ClassEntity) -> list[ClassEntity]:
+        class_parent_pairs = self.class_parent_pairs()
+        return get_inheritance_path(class_, class_parent_pairs)
+
+    @classmethod
+    def _add_inherited_properties(
+        cls,
+        class_: T_ClassEntity,
+        class_property_pairs: dict[T_ClassEntity, list[T_Property]],
+        class_parent_pairs: dict[T_ClassEntity, list[T_ClassEntity]],
+    ):
+        inheritance_path = get_inheritance_path(class_, class_parent_pairs)
+        for parent in inheritance_path:
+            # ParentClassEntity -> ClassEntity to match the type of class_property_pairs
+            if parent in class_property_pairs:
+                for property_ in class_property_pairs[parent]:
+                    property_ = property_.model_copy()
+
+                    # This corresponds to importing properties from parent class
+                    # making sure that the property is attached to desired child class
+                    cls._set_cls_entity(property_, class_)
+
+                    # need same if we have RDF path to make sure that the starting class is the
+                    if class_ in class_property_pairs:
+                        class_property_pairs[class_].append(property_)
+                    else:
+                        class_property_pairs[class_] = [property_]
+
+    def class_property_pairs(
+        self, only_rdfpath: bool = False, consider_inheritance: bool = False
+    ) -> dict[T_ClassEntity, dict[T_PropertyEntity, T_Property]]:
+        """Returns a dictionary of classes with a dictionary of properties associated with them.
+
+        Args:
+            only_rdfpath : To consider only properties which have rule `rdfpath` set. Defaults False
+            consider_inheritance: Whether to consider inheritance or not. Defaults False
+
+        Returns:
+            Dictionary of classes with a dictionary of properties associated with them.
+
+        !!! note "difference to get_classes_with_properties"
+            This method returns a dictionary of classes with a dictionary of properties associated with them.
+            While get_classes_with_properties returns a dictionary of classes with a list of
+            properties defined for them,
+            here we filter the properties based on the `only_rdfpath` parameter and only consider
+            the first definition of a property if it is defined more than once.
+
+        !!! note "only_rdfpath"
+            If only_rdfpath is True, only properties with RuleType.rdfpath will be returned as
+            a part of the dictionary of properties related to a class. Otherwise, all properties
+            will be returned.
+
+        !!! note "consider_inheritance"
+            If consider_inheritance is True, properties from parent classes will also be considered.
+            This means if a class has a parent class, and the parent class has properties defined for it,
+            while we do not have any properties defined for the child class, we will still consider the
+            properties from the parent class. If consider_inheritance is False, we will only consider
+            properties defined for the child class, thus if no properties are defined for the child class,
+            it will not be included in the returned dictionary.
+        """
+        # TODO: https://cognitedata.atlassian.net/jira/software/projects/NEAT/boards/893?selectedIssue=NEAT-78
+
+        class_property_pairs: dict[T_ClassEntity, dict[T_PropertyEntity, T_Property]] = {}
+
+        for class_, properties in self.classes_with_properties(consider_inheritance).items():
+            processed_properties: dict[T_PropertyEntity, T_Property] = {}
+            for property_ in properties:
+                prop_entity = self._get_prop_entity(property_)
+                if prop_entity in processed_properties:
+                    # TODO: use appropriate Warning class from _exceptions.py
+                    # if missing make one !
+                    warnings.warn(
+                        f"Property {processed_properties} for {class_} has been defined more than once!"
+                        " Only the first definition will be considered, skipping the rest..",
+                        stacklevel=2,
+                    )
+                    continue
+
+                if (
+                    only_rdfpath
+                    and isinstance(property_, InformationProperty)
+                    and isinstance(property_.transformation, RDFPath)
+                ) or not only_rdfpath:
+                    processed_properties[prop_entity] = property_
+            class_property_pairs[class_] = processed_properties
+
+        return class_property_pairs
+
+    def class_linkage(self, consider_inheritance: bool = False) -> LinkageSet[T_ClassEntity, T_PropertyEntity]:
+        """Returns a set of class linkages in the data model.
+
+        Args:
+            consider_inheritance: Whether to consider inheritance or not. Defaults False
+
+        Returns:
+
+        """
+        class_linkage = LinkageSet[T_ClassEntity, T_PropertyEntity]()
+
+        class_property_pairs = self.classes_with_properties(consider_inheritance)
+        properties = list(itertools.chain.from_iterable(class_property_pairs.values()))
+
+        for property_ in properties:
+            object_ = self._get_object(property_)
+            if object_ is not None:
+                class_linkage.add(
+                    Linkage(
+                        source_class=self._get_cls_entity(property_),
+                        connecting_property=self._get_prop_entity(property_),
+                        target_class=object_,
+                        max_occurrence=self._get_max_occurrence(property_),
+                    )
+                )
+
+        return class_linkage
+
+    def connected_classes(self, consider_inheritance: bool = False) -> set[T_ClassEntity]:
+        """Return a set of classes that are connected to other classes.
+
+        Args:
+            consider_inheritance: Whether to consider inheritance or not. Defaults False
+
+        Returns:
+            Set of classes that are connected to other classes
+        """
+        class_linkage = self.class_linkage(consider_inheritance)
+        return class_linkage.source_class.union(class_linkage.target_class)
+
+    def defined_classes(self, consider_inheritance: bool = False) -> set[T_ClassEntity]:
+        """Returns classes that have properties defined for them in the data model.
+
+        Args:
+            consider_inheritance: Whether to consider inheritance or not. Defaults False
+
+        Returns:
+            Set of classes that have been defined in the data model
+        """
+        class_property_pairs = self.classes_with_properties(consider_inheritance)
+        properties = list(itertools.chain.from_iterable(class_property_pairs.values()))
+
+        return {self._get_cls_entity(property) for property in properties}
+
+    def disconnected_classes(self, consider_inheritance: bool = False) -> set[T_ClassEntity]:
+        """Return a set of classes that are disconnected (i.e. isolated) from other classes.
+
+        Args:
+            consider_inheritance: Whether to consider inheritance or not. Defaults False
+
+        Returns:
+            Set of classes that are disconnected from other classes
+        """
+        return self.defined_classes(consider_inheritance) - self.connected_classes(consider_inheritance)
+
+    def symmetrically_connected_classes(
+        self, consider_inheritance: bool = False
+    ) -> set[tuple[ClassEntity, ClassEntity]]:
+        """Returns a set of pairs of symmetrically linked classes.
+
+        Args:
+            consider_inheritance: Whether to consider inheritance or not. Defaults False
+
+        Returns:
+            Set of pairs of symmetrically linked classes
+
+        !!! note "Symmetrically Connected Classes"
+            Symmetrically connected classes are classes that are connected to each other
+            in both directions. For example, if class A is connected to class B, and class B
+            is connected to class A, then classes A and B are symmetrically connected.
+        """
+
+        # TODO: Find better name for this method
+        sym_pairs: set[tuple[ClassEntity, ClassEntity]] = set()
+
+        class_linkage = self.class_linkage(consider_inheritance)
+        if not class_linkage:
+            return sym_pairs
+
+        targets_by_source = class_linkage.get_target_classes_by_source()
+        for link in class_linkage:
+            source = link.source_class
+            target = link.target_class
+
+            if source in targets_by_source[source] and (source, target) not in sym_pairs:
+                sym_pairs.add((source, target))
+        return sym_pairs
+
+    def as_property_dict(
+        self,
+    ) -> dict[T_PropertyEntity, list[T_Property]]:
+        """This is used to capture all definitions of a property in the data model."""
+        property_dict: dict[T_PropertyEntity, list[T_Property]] = defaultdict(list)
+        for definition in self._get_properties():
+            property_dict[self._get_prop_entity(definition)].append(definition)
+        return property_dict
+
+    def as_class_dict(self) -> dict[str, T_Class]:
+        """This is to simplify access to classes through dict."""
+        class_dict: dict[str, T_Class] = {}
+        for definition in self._get_classes():
+            entity = self._get_cls_entity(definition)
+            if entity.suffix in class_dict:
+                warnings.warn(
+                    f"Class {entity} has been defined more than once! Only the first definition "
+                    "will be considered, skipping the rest..",
+                    stacklevel=2,
+                )
+                continue
+            class_dict[entity.suffix] = definition
+        return class_dict
 
-class BaseAnalysis(ABC, Generic[T_Rules]):
     @abstractmethod
-    def subset_rules(self, desired_classes: set[ClassEntity]) -> T_Rules:
-        raise NotImplementedError()
+    def subset_rules(self, desired_classes: set[T_ClassEntity]) -> T_Rules:
+        raise NotImplementedError