cognite-neat 0.109.4__py3-none-any.whl → 0.111.0__py3-none-any.whl

cognite/neat/_session/_to.py

@@ -5,14 +5,18 @@ from pathlib import Path
 from typing import Any, Literal, overload
 
 from cognite.client import data_modeling as dm
+from cognite.client.data_classes.data_modeling import DataModelIdentifier
 
 from cognite.neat._alpha import AlphaFlags
 from cognite.neat._constants import COGNITE_MODELS
 from cognite.neat._graph import loaders
+from cognite.neat._issues import IssueList, NeatIssue, catch_issues
 from cognite.neat._rules import exporters
 from cognite.neat._rules._constants import PATTERNS
 from cognite.neat._rules._shared import VerifiedRules
 from cognite.neat._rules.exporters._rules2dms import Component
+from cognite.neat._rules.importers import DMSImporter
+from cognite.neat._rules.models import DMSRules, InformationRules
 from cognite.neat._rules.models.dms import DMSMetadata
 from cognite.neat._utils.upload import UploadResultList
 
@@ -31,14 +35,40 @@ class ToAPI:
         self._state = state
         self._verbose = verbose
         self.cdf = CDFToAPI(state, verbose)
+        self._python = ToPythonAPI(state, verbose)
+
+    def ontology(self, io: Any) -> None:
+        """Export the data model to ontology.
+
+        Args:
+            io: The file path to file-like object to write the session to.
+
+        Example:
+            Export the session to a file
+            ```python
+            ontology_file_name = "neat_session.ttl"
+            neat.to.ontology(ontology_file_name)
+            ```
+        """
+        warnings.filterwarnings("default")
+        AlphaFlags.to_ontology.warn()
+
+        filepath = Path(io)
+        if filepath.suffix != ".ttl":
+            warnings.warn("File extension is not .ttl, adding it to the file name", stacklevel=2)
+            filepath = filepath.with_suffix(".ttl")
+
+        exporter = exporters.OWLExporter()
+        self._state.rule_store.export_to_file(exporter, Path(io))
+        return None
 
     def excel(
         self,
         io: Any,
-        include_reference: bool = True,
+        include_reference: bool | DataModelIdentifier = True,
         include_properties: Literal["same-space", "all"] = "all",
         add_empty_rows: bool = False,
-    ) -> None:
+    ) -> IssueList | None:
         """Export the verified data model to Excel.
 
         Args:
@@ -46,6 +76,7 @@ class ToAPI:
             include_reference: If True, the reference data model will be included. Defaults to True.
                 Note that this only applies if you have created the data model using the
                 create.enterprise_model(...), create.solution_model(), or create.data_product_model() methods.
+                You can also provide a DataModelIdentifier directly, which will be read from CDF
             include_properties: The properties to include in the Excel file. Defaults to "all".
                 - "same-space": Only properties that are in the same space as the data model will be included.
             add_empty_rows: If True, empty rows will be added between each component. Defaults to False.
@@ -71,19 +102,45 @@ class ToAPI:
             dms_rules_file_name = "dms_rules.xlsx"
             neat.to.excel(dms_rules_file_name, include_reference=True)
             ```
+
+        Example:
+            Read the data model ("my_space", "ISA95Model", "v5") and export it to an excel file with the
+            CogniteCore model in the reference sheets.
+            ```python
+            client = CogniteClient()
+            neat = NeatSession(client)
+
+            neat.read.cdf(("my_space", "ISA95Model", "v5"))
+            dms_rules_file_name = "dms_rules.xlsx"
+            neat.to.excel(dms_rules_file_name, include_reference=("cdf_cdm", "CogniteCore", "v1"))
         """
         reference_rules_with_prefix: tuple[VerifiedRules, str] | None = None
         include_properties = include_properties.strip().lower()
 
-        if include_reference and self._state.last_reference:
-            if (
-                isinstance(self._state.last_reference.metadata, DMSMetadata)
-                and self._state.last_reference.metadata.as_data_model_id() in COGNITE_MODELS
-            ):
-                prefix = "CDM"
+        if include_reference is not False:
+            if include_reference is True and self._state.last_reference is not None:
+                ref_rules: InformationRules | DMSRules | None = self._state.last_reference
+            elif include_reference is True:
+                ref_rules = None
             else:
+                if not self._state.client:
+                    raise NeatSessionError("No client provided!")
+                ref_rules = None
+                with catch_issues() as issues:
+                    ref_read = DMSImporter.from_data_model_id(self._state.client, include_reference).to_rules()
+                    if ref_read.rules is not None:
+                        ref_rules = ref_read.rules.as_verified_rules()
+                if ref_rules is None or issues.has_errors:
+                    issues.action = f"Read {include_reference}"
+                    return issues
+            if ref_rules is not None:
                 prefix = "Ref"
-            reference_rules_with_prefix = self._state.last_reference, prefix
+                if (
+                    isinstance(ref_rules.metadata, DMSMetadata)
+                    and ref_rules.metadata.as_data_model_id() in COGNITE_MODELS
+                ):
+                    prefix = "CDM"
+                reference_rules_with_prefix = ref_rules, prefix
 
         if include_properties == "same-space":
             warnings.filterwarnings("default")
@@ -95,7 +152,8 @@ class ToAPI:
             add_empty_rows=add_empty_rows,
             include_properties=include_properties,  # type: ignore
         )
-        return self._state.rule_store.export_to_file(exporter, Path(io))
+        self._state.rule_store.export_to_file(exporter, Path(io))
+        return None
 
     def session(self, io: Any) -> None:
         """Export the current session to a file.
@@ -177,6 +235,7 @@ class ToAPI:
             neat.to.yaml(your_folder_name, format="toolkit")
             ```
         """
+
         if format == "neat":
             exporter = exporters.YAMLExporter()
             if io is None:
@@ -212,35 +271,67 @@ class CDFToAPI:
     def instances(
         self,
         space: str | None = None,
+        space_property: str | None = None,
     ) -> UploadResultList:
         """Export the verified DMS instances to CDF.
 
         Args:
             space: Name of instance space to use. Default is to suffix the schema space with '_instances'.
-            Note this space is required to be different than the space with the data model.
+                Note this space is required to be different from the space with the data model.
+            space_property: This is an alternative to the 'space' argument. If provided, the space will set to the
+                value of the property with the given name for each instance. If the property is not found, the
+                'space' argument will be used. Defaults to None.
+
+        Returns:
+            UploadResultList: The result of the upload.
+
+        Example:
+            Export instances to CDF
+            ```python
+            neat.to.cdf.instances()
+            ```
+
+            Export instances to CDF using the `dataSetId` property as the space
+            ```python
+            neat.to.cdf.instances(space_property="dataSetId")
+            ```
 
         """
+        return self._instances(instance_space=space, space_from_property=space_property)
+
+    def _instances(
+        self,
+        instance_space: str | None = None,
+        space_from_property: str | None = None,
+        use_source_space: bool = False,
+    ) -> UploadResultList:
         if not self._state.client:
             raise NeatSessionError("No CDF client provided!")
         client = self._state.client
-        space = space or f"{self._state.rule_store.last_verified_dms_rules.metadata.space}_instances"
+        dms_rules = self._state.rule_store.last_verified_dms_rules
+        instance_space = instance_space or f"{dms_rules.metadata.space}_instances"
 
-        if space and space == self._state.rule_store.last_verified_dms_rules.metadata.space:
+        if instance_space and instance_space == dms_rules.metadata.space:
             raise NeatSessionError("Space for instances must be different from the data model space.")
-        elif not PATTERNS.space_compliance.match(str(space)):
+        elif not PATTERNS.space_compliance.match(str(instance_space)):
             raise NeatSessionError("Please provide a valid space name. {PATTERNS.space_compliance.pattern}")
 
-        if not client.data_modeling.spaces.retrieve(space):
-            client.data_modeling.spaces.apply(dm.SpaceApply(space=space))
+        if not client.data_modeling.spaces.retrieve(instance_space):
+            client.data_modeling.spaces.apply(dm.SpaceApply(space=instance_space))
 
-        loader = loaders.DMSLoader.from_rules(
+        loader = loaders.DMSLoader(
             self._state.rule_store.last_verified_dms_rules,
+            self._state.rule_store.last_verified_information_rules,
             self._state.instances.store,
-            instance_space=space,
+            instance_space=instance_space,
             client=client,
+            space_property=space_from_property,
+            use_source_space=use_source_space,
             # In case urllib.parse.quote() was run on the extraction, we need to run
             # urllib.parse.unquote() on the load.
-            unquote_external_ids=self._state.quoted_source_identifiers,
+            unquote_external_ids=True,
+            neat_prefix_by_predicate_uri=self._state.instances.neat_prefix_by_predicate_uri,
+            neat_prefix_by_type_uri=self._state.instances.neat_prefix_by_type_uri,
         )
 
         result = loader.load_into_cdf(client)
@@ -283,3 +374,70 @@ class CDFToAPI:
         result = self._state.rule_store.export_to_cdf(exporter, self._state.client, dry_run)
         print("You can inspect the details with the .inspect.outcome.data_model(...) method.")
         return result
+
+
+@session_class_wrapper
+class ToPythonAPI:
+    """API used to write the contents of a NeatSession to Python objects"""
+
+    def __init__(self, state: SessionState, verbose: bool) -> None:
+        self._state = state
+        self._verbose = verbose
+
+    def instances(
+        self,
+        instance_space: str | None = None,
+        space_from_property: str | None = None,
+        use_source_space: bool = False,
+    ) -> tuple[list[dm.InstanceApply], IssueList]:
+        """Export the verified DMS instances to Python objects.
+
+        Args:
+            instance_space: The name of the instance space to use. Defaults to None.
+            space_from_property: This is an alternative to the 'instance_space' argument. If provided,
+                the space will be set to the value of the property with the given name for each instance.
+                If the property is not found, the 'instance_space' argument will be used. Defaults to None.
+            use_source_space: If True, the instance space will be set to the source space of the instance.
+                This is only relevant if the instances were extracted from CDF data models. Defaults to False.
+
+        Returns:
+            list[dm.InstanceApply]: The instances as Python objects.
+
+        Example:
+            Export instances to Python objects
+            ```python
+            instances = neat.to._python.instances()
+            ```
+
+            Export instances to Python objects using the `dataSetId` property as the space
+            ```python
+            instances = neat.to._python.instances(space_from_property="dataSetId")
+            ```
+        """
+        dms_rules = self._state.rule_store.last_verified_dms_rules
+        instance_space = instance_space or f"{dms_rules.metadata.space}_instances"
+
+        if instance_space and instance_space == dms_rules.metadata.space:
+            raise NeatSessionError("Space for instances must be different from the data model space.")
+        elif not PATTERNS.space_compliance.match(str(instance_space)):
+            raise NeatSessionError(f"Please provide a valid space name. {PATTERNS.space_compliance.pattern}")
+
+        loader = loaders.DMSLoader(
+            self._state.rule_store.last_verified_dms_rules,
+            self._state.rule_store.last_verified_information_rules,
+            self._state.instances.store,
+            instance_space=instance_space,
+            space_property=space_from_property,
+            use_source_space=use_source_space,
+            unquote_external_ids=True,
+            neat_prefix_by_predicate_uri=self._state.instances.neat_prefix_by_predicate_uri,
+            neat_prefix_by_type_uri=self._state.instances.neat_prefix_by_type_uri,
+        )
+        issue_list = IssueList()
+        instances: list[dm.InstanceApply] = []
+        for item in loader.load(stop_on_exception=False):
+            if isinstance(item, dm.InstanceApply):
+                instances.append(item)
+            elif isinstance(item, NeatIssue):
+                issue_list.append(item)
+        return instances, issue_list

cognite/neat/_store/_graph_store.py

@@ -3,7 +3,7 @@ import warnings
 from collections.abc import Iterable
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import cast, overload
+from typing import Any, cast, overload
 from zipfile import ZipExtFile
 
 import pandas as pd
@@ -18,9 +18,6 @@ from cognite.neat._graph.queries import Queries
 from cognite.neat._graph.transformers import Transformers
 from cognite.neat._issues import IssueList, catch_issues
 from cognite.neat._issues.errors import OxigraphStorageLockedError
-from cognite.neat._rules.analysis import InformationAnalysis
-from cognite.neat._rules.models import InformationRules
-from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._shared import InstanceType, Triple
 from cognite.neat._utils.auxiliary import local_import
 from cognite.neat._utils.rdf_ import add_triples_in_batch, remove_namespace_from_uri
@@ -55,9 +52,6 @@ class NeatGraphStore:
         dataset: Dataset,
         default_named_graph: URIRef | None = None,
     ):
-        self.rules: dict[URIRef, InformationRules] = {}
-        self.base_namespace: dict[URIRef, Namespace] = {}
-
         _start = datetime.now(timezone.utc)
         self.dataset = dataset
         self.provenance = Provenance[Entity](
@@ -72,8 +66,7 @@ class NeatGraphStore:
         )
 
         self.default_named_graph = default_named_graph or DATASET_DEFAULT_GRAPH_ID
-
-        self.queries = Queries(self.dataset, self.rules, self.default_named_graph)
+        self.queries = Queries(self.dataset, self.default_named_graph)
 
     def graph(self, named_graph: URIRef | None = None) -> Graph:
         """Get named graph from the dataset to query over"""
@@ -116,36 +109,6 @@ class NeatGraphStore:
         else:
             return self.dataset.serialize(format="ox-trig" if self.type_ == "OxigraphStore" else "trig")
 
-    def add_rules(self, rules: InformationRules, named_graph: URIRef | None = None) -> None:
-        """This method is used to add rules to a named graph stored in the graph store.
-
-        Args:
-            rules: InformationRules object containing rules to be added to the named graph
-            named_graph: URIRef of the named graph to store the rules in, by default None
-                        rules will be added to the default graph
-
-        """
-
-        named_graph = named_graph or self.default_named_graph
-
-        if named_graph in self.named_graphs:
-            # attaching appropriate namespace to the rules
-            # as well base_namespace
-            self.rules[named_graph] = rules
-            self.base_namespace[named_graph] = rules.metadata.namespace
-            self.queries = Queries(self.dataset, self.rules)
-            self.provenance.append(
-                Change.record(
-                    activity=f"{type(self)}.rules",
-                    start=datetime.now(timezone.utc),
-                    end=datetime.now(timezone.utc),
-                    description=f"Added {type(self.rules).__name__} to {named_graph} named graph",
-                )
-            )
-
-            if self.rules[named_graph].prefixes:
-                self._upsert_prefixes(self.rules[named_graph].prefixes, named_graph)
-
     def _upsert_prefixes(self, prefixes: dict[str, Namespace], named_graph: URIRef) -> None:
         """Adds prefixes to the graph store."""
         _start = datetime.now(timezone.utc)
@@ -271,226 +234,26 @@ class NeatGraphStore:
             last_change.target_entity.issues.extend(issue_list)
         return issue_list
 
-    def _read_via_rules_linkage(
+    def read(
         self,
-        class_neat_id: URIRef,
-        property_link_pairs: dict[str, URIRef] | None,
+        class_uri: URIRef,
         named_graph: URIRef | None = None,
-    ) -> Iterable[tuple[str, dict[str | InstanceType, list[str]]]]:
-        named_graph = named_graph or self.default_named_graph
-
-        if named_graph not in self.named_graphs:
-            warnings.warn(
-                f"Named graph {named_graph} not found in graph store, cannot read",
-                stacklevel=2,
-            )
-            return
-
-        if not self.rules or named_graph not in self.rules:
-            warnings.warn(
-                f"Rules for named graph {named_graph} not found in graph store!",
-                stacklevel=2,
-            )
-            return
-
-        if self.multi_type_instances:
-            warnings.warn(
-                "Multi typed instances detected, issues with loading can occur!",
-                stacklevel=2,
-            )
-
-        analysis = InformationAnalysis(self.rules[named_graph])
-
-        if cls := analysis.classes_by_neat_id.get(class_neat_id):
-            if property_link_pairs:
-                property_renaming_config = {
-                    prop_uri: prop_name
-                    for prop_name, prop_neat_id in property_link_pairs.items()
-                    if (prop_uri := analysis.neat_id_to_instance_source_property_uri(prop_neat_id))
-                }
-                if information_properties := analysis.classes_with_properties(consider_inheritance=True).get(
-                    cls.class_
-                ):
-                    for prop in information_properties:
-                        if prop.neatId is None:
-                            continue
-                        # Include renaming done in the Information rules that are not present in the
-                        # property_link_pairs. The use case for this renaming to startNode and endNode
-                        # properties that are not part of DMSRules but will typically be present
-                        # in the Information rules.
-                        if (
-                            uri := analysis.neat_id_to_instance_source_property_uri(prop.neatId)
-                        ) and uri not in property_renaming_config:
-                            property_renaming_config[uri] = prop.property_
-
-                yield from self._read_via_class_entity(cls.class_, property_renaming_config)
-                return
-            else:
-                warnings.warn("Rules not linked", stacklevel=2)
-                return
-        else:
-            warnings.warn("Class with neat id {class_neat_id} found in rules", stacklevel=2)
-            return
-
-    def _read_via_class_entity(
-        self,
-        class_entity: ClassEntity,
         property_renaming_config: dict[URIRef, str] | None = None,
-        named_graph: URIRef | None = None,
-    ) -> Iterable[tuple[str, dict[str | InstanceType, list[str]]]]:
+        remove_uri_namespace: bool = True,
+    ) -> Iterable[tuple[URIRef, dict[str | InstanceType, list[Any]]]]:
         named_graph = named_graph or self.default_named_graph
 
-        if named_graph not in self.named_graphs:
-            warnings.warn(
-                f"Named graph {named_graph} not found in graph store, cannot read",
-                stacklevel=2,
-            )
-            return
-
-        if not self.rules or named_graph not in self.rules:
-            warnings.warn(
-                f"Rules for named graph {named_graph} not found in graph store!",
-                stacklevel=2,
-            )
-            return
-        if self.multi_type_instances:
-            warnings.warn(
-                "Multi typed instances detected, issues with loading can occur!",
-                stacklevel=2,
-            )
-
-        if class_entity not in [definition.class_ for definition in self.rules[named_graph].classes]:
-            warnings.warn("Desired type not found in graph!", stacklevel=2)
-            return
-
-        if not (class_uri := InformationAnalysis(self.rules[named_graph]).class_uri(class_entity)):
-            warnings.warn(
-                f"Class {class_entity.suffix} does not have namespace defined for prefix {class_entity.prefix} Rules!",
-                stacklevel=2,
-            )
-            return
-
-        has_hop_transformations = InformationAnalysis(self.rules[named_graph]).has_hop_transformations()
-        has_self_reference_transformations = InformationAnalysis(
-            self.rules[named_graph]
-        ).has_self_reference_property_transformations()
-        if has_hop_transformations or has_self_reference_transformations:
-            msg = (
-                f"Rules contain [{'Hop' if has_hop_transformations else ''}"
-                f", {'SelfReferenceProperty' if has_self_reference_transformations else ''}]"
-                " rdfpath."
-                f" Run [{'ReduceHopTraversal' if has_hop_transformations else ''}"
-                f", {'AddSelfReferenceProperty' if has_self_reference_transformations else ''}]"
-                " transformer(s) first!"
-            )
-
-            warnings.warn(
-                msg,
-                stacklevel=2,
-            )
-            return
-
-        # get all the instances for give class_uri
-        instance_ids = self.queries.list_instances_ids_of_class(class_uri)
-
-        # get potential property renaming config
-        property_renaming_config = property_renaming_config or InformationAnalysis(
-            self.rules[named_graph]
-        ).define_property_renaming_config(class_entity)
+        instance_ids = self.queries.list_instances_ids(class_uri, named_graph=named_graph)
 
         for instance_id in instance_ids:
             if res := self.queries.describe(
                 instance_id=instance_id,
-                instance_type=class_entity.suffix,
+                instance_type=class_uri,
                 property_renaming_config=property_renaming_config,
+                remove_uri_namespace=remove_uri_namespace,
             ):
                 yield res
 
-    def read(
-        self, class_: str, named_graph: URIRef | None = None
-    ) -> Iterable[tuple[str, dict[str | InstanceType, list[str]]]]:
-        """Read instances for given class from the graph store.
-
-        !!! note "Assumption"
-            This method assumes that the class_ belongs to the same (name)space as
-            the rules which are attached to the graph store.
-
-        """
-        named_graph = named_graph or self.default_named_graph
-
-        if named_graph not in self.named_graphs:
-            warnings.warn(
-                f"Named graph {named_graph} not found in graph store, cannot read",
-                stacklevel=2,
-            )
-            return
-
-        if not self.rules or named_graph not in self.rules:
-            warnings.warn(
-                f"Rules for named graph {named_graph} not found in graph store!",
-                stacklevel=2,
-            )
-            return
-        if self.multi_type_instances:
-            warnings.warn(
-                "Multi typed instances detected, issues with loading can occur!",
-                stacklevel=2,
-            )
-
-        class_entity = ClassEntity(prefix=self.rules[named_graph].metadata.prefix, suffix=class_)
-
-        if class_entity not in [definition.class_ for definition in self.rules[named_graph].classes]:
-            warnings.warn("Desired type not found in graph!", stacklevel=2)
-            return
-
-        yield from self._read_via_class_entity(class_entity)
-
-    def count_of_id(self, neat_id: URIRef, named_graph: URIRef | None = None) -> int:
-        """Count the number of instances of a given type
-
-        Args:
-            neat_id: Type for which instances are to be counted
-
-        Returns:
-            Number of instances
-        """
-        named_graph = named_graph or self.default_named_graph
-
-        if named_graph not in self.named_graphs:
-            warnings.warn(
-                f"Named graph {named_graph} not found in graph store, cannot count",
-                stacklevel=2,
-            )
-            return 0
-
-        if not self.rules or named_graph not in self.rules:
-            warnings.warn(
-                f"Rules for named graph {named_graph} not found in graph store!",
-                stacklevel=2,
-            )
-            return 0
-
-        class_entity = next(
-            (definition.class_ for definition in self.rules[named_graph].classes if definition.neatId == neat_id),
-            None,
-        )
-        if not class_entity:
-            warnings.warn("Desired type not found in graph!", stacklevel=2)
-            return 0
-
-        if not (class_uri := InformationAnalysis(self.rules[named_graph]).class_uri(class_entity)):
-            warnings.warn(
-                f"Class {class_entity.suffix} does not have namespace defined for prefix {class_entity.prefix} Rules!",
-                stacklevel=2,
-            )
-            return 0
-
-        return self.count_of_type(class_uri)
-
-    def count_of_type(self, class_uri: URIRef) -> int:
-        query = f"SELECT (COUNT(?instance) AS ?instanceCount) WHERE {{ ?instance a <{class_uri}> }}"
-        return int(next(iter(self.dataset.query(query)))[0])  # type: ignore[arg-type, index]
-
     def _parse_file(
         self,
         named_graph: URIRef,

cognite/neat/_utils/rdf_.py

@@ -7,6 +7,8 @@ from pydantic import HttpUrl, TypeAdapter, ValidationError
 from rdflib import Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
+from cognite.neat._constants import SPACE_URI_PATTERN
+
 Triple: TypeAlias = tuple[URIRef, URIRef, RdfLiteral | URIRef]
 
 
@@ -100,12 +102,41 @@ def get_namespace(URI: URIRef, special_separator: str = "#_") -> str:
     str
         Entity id without namespace
     """
+    return split_uri(URI, special_separator)[0]
+
+
+def namespace_as_space(namespace: str) -> str | None:
+    if match := SPACE_URI_PATTERN.match(namespace):
+        return match.group("space")
+    return None
+
+
+def split_uri(URI: URIRef, special_separator: str = "#_") -> tuple[str, str]:
+    """Splits URI into namespace and entity name
+
+    Parameters
+    ----------
+    URI : URIRef
+        URI of an entity
+    special_separator : str
+        Special separator to use instead of # or / if present in URI
+        Set by default to "#_" which covers special client use case
+
+    Returns
+    -------
+    tuple[str, str]
+        Tuple of namespace and entity name
+    """
     if special_separator in URI:
-        return URI.split(special_separator)[0] + special_separator
+        namespace, rest = URI.split(special_separator, maxsplit=1)
+        namespace += special_separator
     elif "#" in URI:
-        return URI.split("#")[0] + "#"
+        namespace, rest = URI.split("#", maxsplit=1)
+        namespace += "#"
     else:
-        return "/".join(URI.split("/")[:-1]) + "/"
+        namespace, rest = URI.rsplit("/", maxsplit=1)
+        namespace += "/"
+    return namespace, rest
 
 
 def as_neat_compliant_uri(uri: URIRef) -> URIRef:
@@ -154,7 +185,7 @@ def _traverse(hierarchy: dict, graph: dict, names: list[str]) -> dict:
     return hierarchy
 
 
-def get_inheritance_path(child: Any, child_parent: dict[Any, list[Any]]) -> list:
+def get_inheritance_path(child: Any, child_parent: dict[Any, set[Any]]) -> list[Any]:
     """Returns the inheritance path for a given child
 
     Args:
@@ -167,7 +198,7 @@ def get_inheritance_path(child: Any, child_parent: dict[Any, list[Any]]) -> list
     !!! note "No Circular Inheritance"
         This method assumes that the child_parent dictionary is a tree and does not contain any cycles.
     """
-    path = []
+    path: list[Any] = []
     if child in child_parent:
         path.extend(child_parent[child])
         for parent in child_parent[child]: