cognite-neat 0.121.0__py3-none-any.whl → 0.121.2__py3-none-any.whl

cognite/neat/core/{_graph → _instances}/extractors/_mock_graph_generator.py

@@ -11,13 +11,13 @@ import numpy
 import pandas as pd
 from rdflib import RDF, Literal, Namespace, URIRef
 
-from cognite.neat.core._rules._constants import EntityTypes
-from cognite.neat.core._rules.analysis import RulesAnalysis
-from cognite.neat.core._rules.models import DMSRules, InformationRules
-from cognite.neat.core._rules.models.data_types import DataType
-from cognite.neat.core._rules.models.entities import ClassEntity
-from cognite.neat.core._rules.models.information import InformationProperty
-from cognite.neat.core._rules.transformers import SubsetInformationRules
+from cognite.neat.core._data_model._constants import EntityTypes
+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 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
 
@@ -38,31 +38,31 @@ class MockGraphGenerator(BaseExtractor):
 
     def __init__(
         self,
-        rules: InformationRules | 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._rules.transformers import DMSToInformation
+            from cognite.neat.core._data_model.transformers import PhysicalToConceptual
 
-            self.rules = DMSToInformation().transform(rules)
-        elif isinstance(rules, InformationRules):
-            self.rules = rules
+            self.rules = PhysicalToConceptual().transform(data_model)
+        elif isinstance(data_model, ConceptualDataModel):
+            self.rules = data_model
         else:
             raise ValueError("Rules must be of type InformationRules or DMSRules!")
 
-        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.rules).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.rules.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!")
 
@@ -78,87 +78,90 @@ class MockGraphGenerator(BaseExtractor):
         """
         return generate_triples(
             self.rules,
-            self.class_count,
+            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: InformationRules,
-    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
+        concept_count: Target class count for each class in the ontology
         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 +169,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 +184,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 +220,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 +296,41 @@ def _generate_mock_data_property_triples(
 
 
 def _generate_mock_object_property_triples(
-    class_: ClassEntity,
-    property_definition: InformationProperty,
-    class_property_pairs: dict[ClassEntity, list[InformationProperty]],
-    sym_pairs: set[tuple[ClassEntity, ClassEntity]],
-    instance_ids: dict[ClassEntity, list[URIRef]],
+    concept: ConceptEntity,
+    property_definition: ConceptualProperty,
+    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 +339,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 +361,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[InformationProperty]],
-    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 +388,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/{_graph → _instances}/extractors/_rdf_file.py

@@ -8,8 +8,8 @@ from rdflib.util import guess_format
 from typing_extensions import Self
 
 from cognite.neat.core._constants import DEFAULT_BASE_URI
-from cognite.neat.core._graph._shared import RDFTypes
-from cognite.neat.core._graph.extractors._base import BaseExtractor
+from cognite.neat.core._instances._shared import RDFTypes
+from cognite.neat.core._instances.extractors._base import BaseExtractor
 from cognite.neat.core._issues._base import IssueList
 from cognite.neat.core._issues.errors import (
     FileNotFoundNeatError,

cognite/neat/core/{_graph → _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,7 +29,7 @@ class BaseLoader(ABC, Generic[T_Output]):
     _new_line = "\n"
     _encoding = "utf-8"
 
-    def __init__(self, graph_store: NeatGraphStore):
+    def __init__(self, graph_store: NeatInstanceStore):
         self.graph_store = graph_store
 
     @abstractmethod

cognite/neat/core/{_graph → _instances}/loaders/_rdf2dms.py

@@ -25,6 +25,17 @@ from cognite.neat.core._constants import (
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
     is_readonly_property,
 )
+from cognite.neat.core._data_model.analysis import DataModelAnalysis
+from cognite.neat.core._data_model.analysis._base import ViewQuery, ViewQueryDict
+from cognite.neat.core._data_model.models import PhysicalDataModel
+from cognite.neat.core._data_model.models.conceptual._verified import (
+    ConceptualDataModel,
+)
+from cognite.neat.core._data_model.models.data_types import (
+    _DATA_TYPE_BY_DMS_TYPE,
+    Json,
+    String,
+)
 from cognite.neat.core._issues import IssueList, NeatError, NeatIssue, catch_issues
 from cognite.neat.core._issues.errors import (
     AuthorizationError,
@@ -39,17 +50,8 @@ from cognite.neat.core._issues.warnings import (
     PropertyTypeNotSupportedWarning,
     ResourceNeatWarning,
 )
-from cognite.neat.core._rules.analysis import RulesAnalysis
-from cognite.neat.core._rules.analysis._base import ViewQuery, ViewQueryDict
-from cognite.neat.core._rules.models import DMSRules
-from cognite.neat.core._rules.models.data_types import (
-    _DATA_TYPE_BY_DMS_TYPE,
-    Json,
-    String,
-)
-from cognite.neat.core._rules.models.information._rules import InformationRules
 from cognite.neat.core._shared import InstanceType
-from cognite.neat.core._store import NeatGraphStore
+from cognite.neat.core._store import NeatInstanceStore
 from cognite.neat.core._utils.auxiliary import create_sha256_hash
 from cognite.neat.core._utils.collection_ import (
     iterate_progress_bar_if_above_config_threshold,
@@ -113,9 +115,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
     def __init__(
         self,
-        dms_rules: DMSRules,
-        info_rules: InformationRules,
-        graph_store: NeatGraphStore,
+        dms_rules: PhysicalDataModel,
+        info_rules: ConceptualDataModel,
+        graph_store: NeatInstanceStore,
         instance_space: str,
         space_property: str | None = None,
         use_source_space: bool = False,
@@ -207,7 +209,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             yield _END_OF_CLASS
 
     def _create_view_iterations(self) -> tuple[list[_ViewIterator], IssueList]:
-        view_query_by_id = RulesAnalysis(self.info_rules, self.dms_rules).view_query_by_id
+        view_query_by_id = DataModelAnalysis(self.info_rules, self.dms_rules).view_query_by_id
         iterations_by_view_id = self._select_views_with_instances(view_query_by_id)
         if self._client:
             issues = IssueList()

cognite/neat/core/{_graph → _instances}/transformers/_base.py

@@ -100,10 +100,13 @@ class BaseTransformerStandardised(ABC):
         if self._skip_count_query():
             skipped_count_res = list(graph.query(self._skip_count_query()))
             skipped_count = int(skipped_count_res[0][0])  # type: ignore [index, arg-type]
-            warnings.warn(
-                NeatValueWarning(f"Skipping {skipped_count} properties in transformation {self.__class__.__name__}"),
-                stacklevel=2,
-            )
+            if skipped_count > 0:
+                warnings.warn(
+                    NeatValueWarning(
+                        f"Skipping {skipped_count} properties in transformation {self.__class__.__name__}"
+                    ),
+                    stacklevel=2,
+                )
             outcome.skipped = skipped_count
 
         if iteration_count == 0:

cognite/neat/core/{_graph → _instances}/transformers/_classic_cdf.py

@@ -9,7 +9,7 @@ from rdflib import RDF, Graph, Literal, Namespace, URIRef
 from rdflib.query import ResultRow
 
 from cognite.neat.core._constants import CLASSIC_CDF_NAMESPACE, DEFAULT_NAMESPACE
-from cognite.neat.core._graph import extractors
+from cognite.neat.core._instances import extractors
 from cognite.neat.core._issues.errors import NeatValueError
 from cognite.neat.core._issues.warnings import ResourceNotFoundWarning
 from cognite.neat.core._utils.collection_ import iterate_progress_bar

cognite/neat/core/{_graph → _instances}/transformers/_value_type.py

@@ -10,11 +10,7 @@ from rdflib.query import ResultRow
 from cognite.neat.core._constants import NEAT
 from cognite.neat.core._issues.warnings import PropertyDataTypeConversionWarning
 from cognite.neat.core._utils.auxiliary import string_to_ideal_type
-from cognite.neat.core._utils.rdf_ import (
-    Triple,
-    get_namespace,
-    remove_namespace_from_uri,
-)
+from cognite.neat.core._utils.rdf_ import Triple, get_namespace, remove_namespace_from_uri, uri_to_cdf_id
 
 from ._base import BaseTransformerStandardised, RowTransformationOutput
 
@@ -303,7 +299,7 @@ class ConnectionToLiteral(BaseTransformerStandardised):
         row_output = RowTransformationOutput()
 
         instance, object_entity = cast(tuple[URIRef, URIRef], query_result_row)
-        value = remove_namespace_from_uri(object_entity)
+        value = uri_to_cdf_id(object_entity)
 
         row_output.add_triples.add((instance, self.subject_predicate, rdflib.Literal(value)))
         row_output.remove_triples.add((instance, self.subject_predicate, object_entity))

cognite/neat/core/_issues/_base.py

@@ -119,7 +119,7 @@ class NeatIssue:
 
     @classmethod
     def _dump_value(cls, value: Any) -> list | int | bool | float | str | dict:
-        from cognite.neat.core._rules.models.entities import Entity
+        from cognite.neat.core._data_model.models.entities import ConceptualEntity
 
         if isinstance(value, str | int | bool | float):
             return value
@@ -131,7 +131,7 @@ class NeatIssue:
             return [cls._dump_value(item) for item in value]
         elif isinstance(value, ViewId | ContainerId):
             return value.dump(camel_case=True, include_type=True)
-        elif isinstance(value, Entity):
+        elif isinstance(value, ConceptualEntity):
             return value.dump()
         elif isinstance(value, PropertyId):
             return value.dump(camel_case=True)
@@ -173,7 +173,7 @@ class NeatIssue:
 
     @classmethod
     def _load_value(cls, type_: Any, value: Any) -> Any:
-        from cognite.neat.core._rules.models.entities import Entity
+        from cognite.neat.core._data_model.models.entities import ConceptualEntity
 
         if isinstance(type_, UnionType) or get_origin(type_) is UnionType:
             args = get_args(type_)
@@ -194,7 +194,7 @@ class NeatIssue:
             return PropertyId.load(value)
         elif type_ is ContainerId:
             return ContainerId.load(value)
-        elif inspect.isclass(type_) and issubclass(type_, Entity):
+        elif inspect.isclass(type_) and issubclass(type_, ConceptualEntity):
             return type_.load(value)
         elif type_ is NeatError:
             return cls.load(value)

cognite/neat/core/_issues/errors/__init__.py

@@ -33,7 +33,7 @@ from ._resources import (
     ResourceRetrievalError,
 )
 from ._wrapper import (
-    ClassValueError,
+    ConceptValueError,
     ContainerValueError,
     EnumValueError,
     MetadataValueError,
@@ -47,7 +47,7 @@ __all__ = [
     "AuthorizationError",
     "CDFMissingClientError",
     "CDFMissingResourcesError",
-    "ClassValueError",
+    "ConceptValueError",
     "ContainerValueError",
     "EnumValueError",
     "FileMissingRequiredFieldError",

cognite/neat/core/_issues/errors/_wrapper.py

@@ -67,8 +67,8 @@ class PropertyValueError(SpreadsheetListError):
 
 
 @dataclass(unsafe_hash=True)
-class ClassValueError(SpreadsheetListError):
-    _name = "Classes"
+class ConceptValueError(SpreadsheetListError):
+    _name = "Concepts"
 
 
 @dataclass(unsafe_hash=True)

cognite/neat/core/_issues/warnings/__init__.py

@@ -40,6 +40,7 @@ from ._properties import (
     PropertyOverwritingWarning,
     PropertyTypeNotSupportedWarning,
     PropertyValueTypeUndefinedWarning,
+    ReversedConnectionNotFeasibleWarning,
 )
 from ._resources import (
     ResourceNeatWarning,
@@ -85,6 +86,7 @@ __all__ = [
     "ResourceTypeNotSupportedWarning",
     "ResourceUnknownWarning",
     "ResourcesDuplicatedWarning",
+    "ReversedConnectionNotFeasibleWarning",
     "UndefinedViewWarning",
     "UserModelingWarning",
     "user_modeling",

cognite/neat/core/_issues/warnings/_models.py

@@ -93,12 +93,12 @@ class NotSupportedHasDataFilterLimitWarning(CDFNotSupportedWarning):
 
 
 @dataclass(unsafe_hash=True)
-class UndefinedClassWarning(UserModelingWarning):
-    """Class {class_id} has no explicit properties defined neither implements other class"""
+class UndefinedConceptWarning(UserModelingWarning):
+    """Class {concept_id} has no explicit properties defined neither implements other concepts"""
 
-    fix = "Define properties for class or inherit properties by implementing another class."
+    fix = "Define properties for concept or inherit properties by implementing another concept."
 
-    class_id: str
+    concept_id: str
 
 
 @dataclass(unsafe_hash=True)

cognite/neat/core/_issues/warnings/_properties.py

@@ -88,3 +88,10 @@ class PropertyMultipleValueWarning(PropertyWarning[T_Identifier]):
     Selecting the first value {value}, the rest will be ignored."""
 
     value: str
+
+
+@dataclass(unsafe_hash=True)
+class ReversedConnectionNotFeasibleWarning(PropertyWarning[T_Identifier]):
+    """The {resource_type} {identifier}.{property_name} cannot be created: {reason}"""
+
+    reason: str