cognite-neat 0.121.1__py3-none-any.whl → 0.122.0__py3-none-any.whl

cognite/neat/core/_instances/extractors/_dms_graph.py

@@ -8,11 +8,14 @@ from rdflib import Namespace, URIRef
 from cognite.neat.core._client import NeatClient
 from cognite.neat.core._constants import COGNITE_SPACES, DEFAULT_NAMESPACE
 from cognite.neat.core._data_model.importers import DMSImporter
-from cognite.neat.core._data_model.models import ConceptualDataModel, DMSRules
+from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
 from cognite.neat.core._data_model.models.conceptual import ConceptualProperty
 from cognite.neat.core._data_model.models.data_types import Json
 from cognite.neat.core._data_model.models.entities import UnknownEntity
-from cognite.neat.core._data_model.transformers import DMSToInformation, VerifyDMSRules
+from cognite.neat.core._data_model.transformers import (
+    PhysicalToConceptual,
+    VerifyPhysicalDataModel,
+)
 from cognite.neat.core._issues import IssueList, NeatIssue, catch_warnings
 from cognite.neat.core._issues.warnings import (
     CDFAuthWarning,
@@ -47,8 +50,8 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
         self._str_to_ideal_type = str_to_ideal_type
 
         self._views: list[dm.View] | None = None
-        self._information_rules: ConceptualDataModel | None = None
-        self._dms_rules: DMSRules | None = None
+        self._conceptual_data_model: ConceptualDataModel | None = None
+        self._physical_data_model: PhysicalDataModel | None = None
 
     @classmethod
     def from_data_model_id(
@@ -164,32 +167,32 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
                     self._issues.append(ResourceNotFoundWarning(dm_view, "view", data_model_id, "data model"))
         return views
 
-    def get_information_rules(self) -> ConceptualDataModel:
-        """Returns the information rules that the extractor uses."""
-        if self._information_rules is None:
-            self._information_rules, self._dms_rules = self._create_rules()
-        return self._information_rules
+    def get_conceptual_data_model(self) -> ConceptualDataModel:
+        """Returns the conceptual data model that the extractor uses."""
+        if self._conceptual_data_model is None:
+            self._conceptual_data_model, self._physical_data_model = self._create_data_models()
+        return self._conceptual_data_model
 
-    def get_dms_rules(self) -> DMSRules:
-        """Returns the DMS rules that the extractor uses."""
-        if self._dms_rules is None:
-            self._information_rules, self._dms_rules = self._create_rules()
-        return self._dms_rules
+    def get_physical_data_model(self) -> PhysicalDataModel:
+        """Returns the physical data model that the extractor uses."""
+        if self._physical_data_model is None:
+            self._conceptual_data_model, self._physical_data_model = self._create_data_models()
+        return self._physical_data_model
 
     def get_issues(self) -> IssueList:
         """Returns the issues that occurred during the extraction."""
         return self._issues
 
-    def _create_rules(self) -> tuple[ConceptualDataModel, DMSRules]:
-        # The DMS and Information rules must be created together to link them property.
+    def _create_data_models(self) -> tuple[ConceptualDataModel, PhysicalDataModel]:
+        # The physical and conceptual data model must be created together to link them property.
         importer = DMSImporter.from_data_model(self._client, self._data_model)
-        unverified_dms = importer.to_rules()
-        if self._unpack_json and (dms_rules := unverified_dms.rules):
-            # Drop the JSON properties from the DMS rules as these are no longer valid.
+        imported_physical_data_model = importer.to_data_model()
+        if self._unpack_json and (unverified_physical_data_model := imported_physical_data_model.unverified_data_model):
+            # Drop the JSON properties from the physical data model as these are no longer valid.
             json_name = Json().name  # To avoid instantiating Json multiple times.
-            dms_rules.properties = [
+            unverified_physical_data_model.properties = [
                 prop
-                for prop in dms_rules.properties
+                for prop in unverified_physical_data_model.properties
                 if not (
                     (
                         isinstance(prop.value_type, Json)
@@ -202,23 +205,28 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
 
         with catch_warnings() as issues:
             # Any errors occur will be raised and caught outside the extractor.
-            verified_dms = VerifyDMSRules(client=self._client).transform(unverified_dms)
-            information_rules = DMSToInformation(self._namespace).transform(verified_dms)
+            verified_physical_data_model = VerifyPhysicalDataModel(client=self._client).transform(
+                imported_physical_data_model
+            )
+            verified_conceptual_data_model = PhysicalToConceptual(self._namespace).transform(
+                verified_physical_data_model
+            )
 
-        # We need to sync the metadata between the two rules, such that the `.sync_with_info_rules` method works.
-        information_rules.metadata.physical = verified_dms.metadata.identifier
-        verified_dms.metadata.logical = information_rules.metadata.identifier
-        verified_dms.sync_with_info_rules(information_rules)
+        # We need to sync the metadata between the two data model, such that the
+        # `.sync_with_conceptual_data_model` method works.
+        verified_conceptual_data_model.metadata.physical = verified_physical_data_model.metadata.identifier
+        verified_physical_data_model.metadata.conceptual = verified_conceptual_data_model.metadata.identifier
+        verified_physical_data_model.sync_with_conceptual_data_model(verified_conceptual_data_model)
 
-        # Adding startNode and endNode to the information rules for views that are used for edges.
-        classes_by_prefix = {cls_.class_.prefix: cls_ for cls_ in information_rules.classes}
+        # Adding startNode and endNode to the conceptual data model for views that are used for edges.
+        concepts_by_prefix = {concept.concept.prefix: concept for concept in verified_conceptual_data_model.concepts}
         for view in self._model_views:
-            if view.used_for == "edge" and view.external_id in classes_by_prefix:
-                cls_ = classes_by_prefix[view.external_id]
+            if view.used_for == "edge" and view.external_id in concepts_by_prefix:
+                cls_ = concepts_by_prefix[view.external_id]
                 for property_ in ("startNode", "endNode"):
-                    information_rules.properties.append(
+                    verified_conceptual_data_model.properties.append(
                         ConceptualProperty(
-                            class_=cls_.class_,
+                            concept=cls_.concept,
                             property_=property_,
                             value_type=UnknownEntity(),
                             min_count=0,
@@ -227,4 +235,4 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
                     )
 
         self._issues.extend(issues)
-        return information_rules, verified_dms
+        return verified_conceptual_data_model, verified_physical_data_model

cognite/neat/core/_instances/extractors/_mock_graph_generator.py

@@ -12,12 +12,12 @@ import pandas as pd
 from rdflib import RDF, Literal, Namespace, URIRef
 
 from cognite.neat.core._data_model._constants import EntityTypes
-from cognite.neat.core._data_model.analysis import RulesAnalysis
-from cognite.neat.core._data_model.models import ConceptualDataModel, DMSRules
+from cognite.neat.core._data_model.analysis import DataModelAnalysis
+from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
 from cognite.neat.core._data_model.models.conceptual import ConceptualProperty
 from cognite.neat.core._data_model.models.data_types import DataType
-from cognite.neat.core._data_model.models.entities import ClassEntity
-from cognite.neat.core._data_model.transformers import SubsetInformationRules
+from cognite.neat.core._data_model.models.entities import ConceptEntity
+from cognite.neat.core._data_model.transformers import SubsetConceptualDataModel
 from cognite.neat.core._shared import Triple
 from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri
 
@@ -29,8 +29,8 @@ class MockGraphGenerator(BaseExtractor):
     Class used to generate mock graph data for purposes of testing of NEAT.
 
     Args:
-        rules: Transformation rules defining the classes with their properties.
-        class_count: Target class count for each class in the ontology
+        data_model: Data model defining the concepts with their properties.
+        concept_count: Target concept count for each concept/class in the data model
         stop_on_exception: To stop if exception is encountered or not, default is False
         allow_isolated_classes: To allow generation of instances for classes that are not
                                  connected to any other class, default is True
@@ -38,127 +38,131 @@ class MockGraphGenerator(BaseExtractor):
 
     def __init__(
         self,
-        rules: ConceptualDataModel | DMSRules,
-        class_count: dict[str | ClassEntity, int] | None = None,
+        data_model: ConceptualDataModel | PhysicalDataModel,
+        concept_count: dict[str | ConceptEntity, int] | None = None,
         stop_on_exception: bool = False,
         allow_isolated_classes: bool = True,
     ):
-        if isinstance(rules, DMSRules):
+        if isinstance(data_model, PhysicalDataModel):
             # fixes potential issues with circular dependencies
-            from cognite.neat.core._data_model.transformers import DMSToInformation
+            from cognite.neat.core._data_model.transformers import PhysicalToConceptual
 
-            self.rules = DMSToInformation().transform(rules)
-        elif isinstance(rules, ConceptualDataModel):
-            self.rules = rules
+            self.data_model = PhysicalToConceptual().transform(data_model)
+        elif isinstance(data_model, ConceptualDataModel):
+            self.data_model = data_model
         else:
-            raise ValueError("Rules must be of type InformationRules or DMSRules!")
+            raise ValueError("Data model must be of type Conceptual or Physical!")
 
-        if not class_count:
-            self.class_count = {
-                class_: 1 for class_ in RulesAnalysis(self.rules).defined_classes(include_ancestors=True)
+        if not concept_count:
+            self.concept_count = {
+                concept: 1 for concept in DataModelAnalysis(self.data_model).defined_concepts(include_ancestors=True)
             }
-        elif all(isinstance(key, str) for key in class_count.keys()):
-            self.class_count = {
-                ClassEntity.load(f"{self.rules.metadata.prefix}:{key}"): value for key, value in class_count.items()
+        elif all(isinstance(key, str) for key in concept_count.keys()):
+            self.concept_count = {
+                ConceptEntity.load(f"{self.data_model.metadata.prefix}:{key}"): value
+                for key, value in concept_count.items()
             }
-        elif all(isinstance(key, ClassEntity) for key in class_count.keys()):
-            self.class_count = cast(dict[ClassEntity, int], class_count)
+        elif all(isinstance(key, ConceptEntity) for key in concept_count.keys()):
+            self.concept_count = cast(dict[ConceptEntity, int], concept_count)
         else:
-            raise ValueError("Class count keys must be of type str! or ClassEntity! or empty dict!")
+            raise ValueError("Class count keys must be of type str! or ConceptEntity! or empty dict!")
 
         self.stop_on_exception = stop_on_exception
         self.allow_isolated_classes = allow_isolated_classes
 
     def extract(self) -> list[Triple]:
-        """Generate mock triples based on data model defined transformation rules and desired number
-        of class instances
+        """Generate mock triples based on data model and desired number
+        of concept instances
 
         Returns:
             List of RDF triples, represented as tuples `(subject, predicate, object)`, that define data model instances
         """
         return generate_triples(
-            self.rules,
-            self.class_count,
+            self.data_model,
+            self.concept_count,
             stop_on_exception=self.stop_on_exception,
-            allow_isolated_classes=self.allow_isolated_classes,
+            allow_isolated_concepts=self.allow_isolated_classes,
         )
 
 
 def generate_triples(
-    rules: ConceptualDataModel,
-    class_count: dict[ClassEntity, int],
+    data_model: ConceptualDataModel,
+    concept_count: dict[ConceptEntity, int],
     stop_on_exception: bool = False,
-    allow_isolated_classes: bool = True,
+    allow_isolated_concepts: bool = True,
 ) -> list[Triple]:
-    """Generate mock triples based on data model defined in rules and desired number
+    """Generate mock triples based on the conceptual data model defined and desired number
     of class instances
 
     Args:
-        rules : Rules defining the data model
-        class_count: Target class count for each class in the ontology
+        data_model : Data model
+        concept_count: Target concept count for each class in the data model
         stop_on_exception: To stop if exception is encountered or not, default is False
-        allow_isolated_classes: To allow generation of instances for classes that are not
+        allow_isolated_concepts: To allow generation of instances for classes that are not
                                  connected to any other class, default is True
 
     Returns:
         List of RDF triples, represented as tuples `(subject, predicate, object)`, that define data model instances
     """
 
-    namespace = rules.metadata.namespace
-    analysis = RulesAnalysis(rules)
-    defined_classes = analysis.defined_classes(include_ancestors=True)
+    namespace = data_model.metadata.namespace
+    analysis = DataModelAnalysis(data_model)
+    defined_concepts = analysis.defined_concepts(include_ancestors=True)
 
-    if non_existing_classes := set(class_count.keys()) - defined_classes:
-        msg = f"Class count contains classes {non_existing_classes} for which properties are not defined in Data Model!"
+    if non_existing_concepts := set(concept_count.keys()) - defined_concepts:
+        msg = (
+            f"Concept count contains concepts {non_existing_concepts} for which"
+            " properties are not defined in Data Model!"
+        )
         if stop_on_exception:
             raise ValueError(msg)
         else:
             msg += " These classes will be ignored."
             warnings.warn(msg, stacklevel=2)
-            for class_ in non_existing_classes:
-                class_count.pop(class_)
+            for concept in non_existing_concepts:
+                concept_count.pop(concept)
 
     # Subset data model to only classes that are defined in class count
-    rules = (
-        SubsetInformationRules(classes=set(class_count.keys())).transform(rules)
-        if defined_classes != set(class_count.keys())
-        else rules
+    data_model = (
+        SubsetConceptualDataModel(concepts=set(concept_count.keys())).transform(data_model)
+        if defined_concepts != set(concept_count.keys())
+        else data_model
     )
 
-    class_linkage = analysis.class_linkage().to_pandas()
+    concept_linkage = analysis.concept_linkage().to_pandas()
 
     # Remove one of symmetric pairs from class linkage to maintain proper linking
     # among instances of symmetrically linked classes
-    if sym_pairs := analysis.symmetrically_connected_classes():
-        class_linkage = _remove_higher_occurring_sym_pair(class_linkage, sym_pairs)
+    if sym_pairs := analysis.symmetrically_connected_concepts():
+        concept_linkage = _remove_higher_occurring_sym_pair(concept_linkage, sym_pairs)
 
     # Remove any of symmetric pairs containing classes that are not present class count
-    class_linkage = _remove_non_requested_sym_pairs(class_linkage, class_count)
+    concept_linkage = _remove_non_requested_sym_pairs(concept_linkage, concept_count)
 
     # Generate generation order for classes instances
-    generation_order = _prettify_generation_order(_get_generation_order(class_linkage))
+    generation_order = _prettify_generation_order(_get_generation_order(concept_linkage))
 
     # Generated simple view of data model
-    class_property_pairs = analysis.properties_by_class(include_ancestors=True)
+    properties_by_concepts = analysis.properties_by_concepts(include_ancestors=True)
 
     # pregenerate instance ids for each remaining class
     instance_ids = {
-        key: [URIRef(namespace[f"{key.suffix}-{i + 1}"]) for i in range(value)] for key, value in class_count.items()
+        key: [URIRef(namespace[f"{key.suffix}-{i + 1}"]) for i in range(value)] for key, value in concept_count.items()
     }
 
     # create triple for each class instance defining its type
     triples: list[Triple] = []
-    for class_ in class_count:
+    for concept in concept_count:
         triples += [
-            (class_instance_id, RDF.type, URIRef(namespace[str(class_.suffix)]))
-            for class_instance_id in instance_ids[class_]
+            (concept_instance_id, RDF.type, URIRef(namespace[str(concept.suffix)]))
+            for concept_instance_id in instance_ids[concept]
         ]
 
     # generate triples for connected classes
-    for class_ in generation_order:
+    for concept in generation_order:
         triples += _generate_triples_per_class(
-            class_,
-            class_property_pairs,
+            concept,
+            properties_by_concepts,
             sym_pairs,
             instance_ids,
             namespace,
@@ -166,11 +170,11 @@ def generate_triples(
         )
 
     # generate triples for isolated classes
-    if allow_isolated_classes:
-        for class_ in set(class_count.keys()) - set(generation_order):
+    if allow_isolated_concepts:
+        for concept in set(concept_count.keys()) - set(generation_order):
             triples += _generate_triples_per_class(
-                class_,
-                class_property_pairs,
+                concept,
+                properties_by_concepts,
                 sym_pairs,
                 instance_ids,
                 namespace,
@@ -181,11 +185,11 @@ def generate_triples(
 
 
 def _get_generation_order(
-    class_linkage: pd.DataFrame,
+    concept_linkage: pd.DataFrame,
     parent_col: str = "source_class",
     child_col: str = "target_class",
 ) -> dict:
-    parent_child_list: list[list[str]] = class_linkage[[parent_col, child_col]].values.tolist()  # type: ignore[assignment]
+    parent_child_list: list[list[str]] = concept_linkage[[parent_col, child_col]].values.tolist()  # type: ignore[assignment]
     # Build a directed graph and a list of all names that have no parent
     graph: dict[str, set] = {name: set() for tup in parent_child_list for name in tup}
     has_parent: dict[str, bool] = {name: False for tup in parent_child_list for name in tup}
@@ -217,44 +221,44 @@ def _prettify_generation_order(generation_order: dict, depth: dict | None = None
 
 
 def _remove_higher_occurring_sym_pair(
-    class_linkage: pd.DataFrame, sym_pairs: set[tuple[ClassEntity, ClassEntity]]
+    concept_linkage: pd.DataFrame, sym_pairs: set[tuple[ConceptEntity, ConceptEntity]]
 ) -> pd.DataFrame:
     """Remove symmetric pair which is higher in occurrence."""
     rows_to_remove = set()
     for source, target in sym_pairs:
-        first_sym_property_occurrence = class_linkage[
-            (class_linkage.source_class == source) & (class_linkage.target_class == target)
+        first_sym_property_occurrence = concept_linkage[
+            (concept_linkage.source_class == source) & (concept_linkage.target_class == target)
         ].max_occurrence.values[0]
-        second_sym_property_occurrence = class_linkage[
-            (class_linkage.source_class == target) & (class_linkage.target_class == source)
+        second_sym_property_occurrence = concept_linkage[
+            (concept_linkage.source_class == target) & (concept_linkage.target_class == source)
         ].max_occurrence.values[0]
 
         if first_sym_property_occurrence is None:
             # this means that source occurrence is unbounded
-            index = class_linkage[
-                (class_linkage.source_class == source) & (class_linkage.target_class == target)
+            index = concept_linkage[
+                (concept_linkage.source_class == source) & (concept_linkage.target_class == target)
             ].index.values[0]
         elif second_sym_property_occurrence is None or (
             first_sym_property_occurrence <= second_sym_property_occurrence
             and second_sym_property_occurrence > first_sym_property_occurrence
         ):
             # this means that target occurrence is unbounded
-            index = class_linkage[
-                (class_linkage.source_class == target) & (class_linkage.target_class == source)
+            index = concept_linkage[
+                (concept_linkage.source_class == target) & (concept_linkage.target_class == source)
             ].index.values[0]
         else:
-            index = class_linkage[
-                (class_linkage.source_class == source) & (class_linkage.target_class == target)
+            index = concept_linkage[
+                (concept_linkage.source_class == source) & (concept_linkage.target_class == target)
             ].index.values[0]
         rows_to_remove.add(index)
 
-    return class_linkage.drop(list(rows_to_remove))
+    return concept_linkage.drop(list(rows_to_remove))
 
 
-def _remove_non_requested_sym_pairs(class_linkage: pd.DataFrame, class_count: dict) -> pd.DataFrame:
+def _remove_non_requested_sym_pairs(class_linkage: pd.DataFrame, concept_count: dict) -> pd.DataFrame:
     """Remove symmetric pairs which classes are not found in class count."""
-    rows_to_remove = set(class_linkage[~(class_linkage["source_class"].isin(set(class_count.keys())))].index.values)
-    rows_to_remove |= set(class_linkage[~(class_linkage["target_class"].isin(set(class_count.keys())))].index.values)
+    rows_to_remove = set(class_linkage[~(class_linkage["source_class"].isin(set(concept_count.keys())))].index.values)
+    rows_to_remove |= set(class_linkage[~(class_linkage["target_class"].isin(set(concept_count.keys())))].index.values)
 
     return class_linkage.drop(list(rows_to_remove))
 
@@ -293,41 +297,41 @@ def _generate_mock_data_property_triples(
 
 
 def _generate_mock_object_property_triples(
-    class_: ClassEntity,
+    concept: ConceptEntity,
     property_definition: ConceptualProperty,
-    class_property_pairs: dict[ClassEntity, list[ConceptualProperty]],
-    sym_pairs: set[tuple[ClassEntity, ClassEntity]],
-    instance_ids: dict[ClassEntity, list[URIRef]],
+    concept_property_pairs: dict[ConceptEntity, list[ConceptualProperty]],
+    sym_pairs: set[tuple[ConceptEntity, ConceptEntity]],
+    instance_ids: dict[ConceptEntity, list[URIRef]],
     namespace: Namespace,
     stop_on_exception: bool,
 ) -> list[tuple[URIRef, URIRef, URIRef]]:
     """Generates triples for object properties."""
     if property_definition.value_type not in instance_ids:
-        msg = f"Class {property_definition.value_type} not found in class count! "
+        msg = f"Concept {property_definition.value_type} not found in concept count! "
         if stop_on_exception:
             raise ValueError(msg)
         else:
             msg += (
                 f"Skipping creating triples for property {property_definition.name} "
-                f"of class {class_.suffix} which expects values of this type!"
+                f"of concept {concept.suffix} which expects values of this type!"
             )
             warnings.warn(msg, stacklevel=2)
             return []
 
     # Handling symmetric property
 
-    if tuple((class_, property_definition.value_type)) in sym_pairs:
-        symmetric_class_properties = class_property_pairs[cast(ClassEntity, property_definition.value_type)]
+    if tuple((concept, property_definition.value_type)) in sym_pairs:
+        symmetric_concept_properties = concept_property_pairs[cast(ConceptEntity, property_definition.value_type)]
         candidates = list(
             filter(
-                lambda instance: instance.value_type == class_,
-                symmetric_class_properties,
+                lambda instance: instance.value_type == concept,
+                symmetric_concept_properties,
             )
         )
         symmetric_property = candidates[0]
         if len(candidates) > 1:
             warnings.warn(
-                f"Multiple symmetric properties found for class {property_definition.value_type}! "
+                f"Multiple symmetric properties found for concept {property_definition.value_type}! "
                 f"Only one will be used for creating symmetric triples.",
                 stacklevel=2,
             )
@@ -336,9 +340,9 @@ def _generate_mock_object_property_triples(
 
     triples = []
 
-    for i, source in enumerate(instance_ids[class_]):
-        target = instance_ids[cast(ClassEntity, property_definition.value_type)][
-            i % len(instance_ids[cast(ClassEntity, property_definition.value_type)])
+    for i, source in enumerate(instance_ids[concept]):
+        target = instance_ids[cast(ConceptEntity, property_definition.value_type)][
+            i % len(instance_ids[cast(ConceptEntity, property_definition.value_type)])
         ]
         triples += [
             (
@@ -358,26 +362,26 @@ def _generate_mock_object_property_triples(
             ]
 
     if symmetric_property:
-        class_property_pairs[cast(ClassEntity, property_definition.value_type)].remove(symmetric_property)
+        concept_property_pairs[cast(ConceptEntity, property_definition.value_type)].remove(symmetric_property)
 
     return triples
 
 
 def _generate_triples_per_class(
-    class_: ClassEntity,
-    class_properties_pairs: dict[ClassEntity, list[ConceptualProperty]],
-    sym_pairs: set[tuple[ClassEntity, ClassEntity]],
-    instance_ids: dict[ClassEntity, list[URIRef]],
+    concept: ConceptEntity,
+    concept_properties_pairs: dict[ConceptEntity, list[ConceptualProperty]],
+    sym_pairs: set[tuple[ConceptEntity, ConceptEntity]],
+    instance_ids: dict[ConceptEntity, list[URIRef]],
     namespace: Namespace,
     stop_on_exception: bool,
 ) -> list[Triple]:
     """Generate triples for a given class."""
     triples: list[Triple] = []
 
-    for property_ in class_properties_pairs[class_]:
+    for property_ in concept_properties_pairs[concept]:
         if property_.type_ == EntityTypes.data_property:
             triples += _generate_mock_data_property_triples(
-                instance_ids[class_],
+                instance_ids[concept],
                 property_.property_,
                 namespace,
                 cast(DataType, property_.value_type),
@@ -385,9 +389,9 @@ def _generate_triples_per_class(
 
         elif property_.type_ == EntityTypes.object_property:
             triples += _generate_mock_object_property_triples(
-                class_,
+                concept,
                 property_,
-                class_properties_pairs,
+                concept_properties_pairs,
                 sym_pairs,
                 instance_ids,
                 namespace,

cognite/neat/core/_instances/loaders/_base.py

@@ -8,7 +8,7 @@ from cognite.client.data_classes.capabilities import Capability
 
 from cognite.neat.core._issues import IssueList, NeatIssue
 from cognite.neat.core._issues.errors import AuthorizationError
-from cognite.neat.core._store import NeatGraphStore
+from cognite.neat.core._store import NeatInstanceStore
 from cognite.neat.core._utils.auxiliary import class_html_doc
 from cognite.neat.core._utils.upload import UploadResult, UploadResultList
 
@@ -29,8 +29,8 @@ class BaseLoader(ABC, Generic[T_Output]):
     _new_line = "\n"
     _encoding = "utf-8"
 
-    def __init__(self, graph_store: NeatGraphStore):
-        self.graph_store = graph_store
+    def __init__(self, instance_store: NeatInstanceStore):
+        self.instance_store = instance_store
 
     @abstractmethod
     def write_to_file(self, filepath: Path) -> None: