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

cognite/neat/core/{_rules → _data_model}/transformers/_verification.py

@@ -1,22 +1,22 @@
 from abc import ABC
 
 from cognite.neat.core._client import NeatClient
-from cognite.neat.core._issues import MultiValueError, catch_issues
-from cognite.neat.core._issues.errors import NeatTypeError, NeatValueError
-from cognite.neat.core._rules._shared import (
+from cognite.neat.core._data_model._shared import (
     ReadRules,
     T_ReadInputRules,
     T_VerifiedRules,
     VerifiedRules,
 )
-from cognite.neat.core._rules.models import (
+from cognite.neat.core._data_model.models import (
+    ConceptualDataModel,
     DMSInputRules,
     DMSRules,
-    InformationInputRules,
-    InformationRules,
+    UnverifiedConceptualDataModel,
 )
-from cognite.neat.core._rules.models.dms import DMSValidation
-from cognite.neat.core._rules.models.information import InformationValidation
+from cognite.neat.core._data_model.models.conceptual import InformationValidation
+from cognite.neat.core._data_model.models.dms import DMSValidation
+from cognite.neat.core._issues import MultiValueError, catch_issues
+from cognite.neat.core._issues.errors import NeatTypeError, NeatValueError
 
 from ._base import RulesTransformer
 
@@ -81,13 +81,13 @@ class VerifyDMSRules(VerificationTransformer[ReadRules[DMSInputRules], DMSRules]
         return super().transform(rules)
 
 
-class VerifyInformationRules(VerificationTransformer[ReadRules[InformationInputRules], InformationRules]):
+class VerifyInformationRules(VerificationTransformer[ReadRules[UnverifiedConceptualDataModel], ConceptualDataModel]):
     """Class to verify Information rules."""
 
-    _rules_cls = InformationRules
+    _rules_cls = ConceptualDataModel
     _validation_cls = InformationValidation
 
-    def transform(self, rules: ReadRules[InformationInputRules]) -> InformationRules:
+    def transform(self, rules: ReadRules[UnverifiedConceptualDataModel]) -> ConceptualDataModel:
         return super().transform(rules)
 
 
@@ -95,15 +95,15 @@ class VerifyAnyRules(VerificationTransformer[T_ReadInputRules, VerifiedRules]):
     """Class to verify arbitrary rules"""
 
     def _get_rules_cls(self, in_: T_ReadInputRules) -> type[VerifiedRules]:
-        if isinstance(in_.rules, InformationInputRules):
-            return InformationRules
+        if isinstance(in_.rules, UnverifiedConceptualDataModel):
+            return ConceptualDataModel
         elif isinstance(in_.rules, DMSInputRules):
             return DMSRules
         else:
             raise NeatTypeError(f"Unsupported rules type: {type(in_)}")
 
     def _get_validation_cls(self, rules: VerifiedRules) -> type:
-        if isinstance(rules, InformationRules):
+        if isinstance(rules, ConceptualDataModel):
             return InformationValidation
         elif isinstance(rules, DMSRules):
             return DMSValidation

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

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from rdflib import URIRef
 
 from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._rules.models import InformationRules
+from cognite.neat.core._data_model.models import ConceptualDataModel
 from cognite.neat.core._shared import Triple
 from cognite.neat.core._utils.auxiliary import class_html_doc
 
@@ -38,7 +38,7 @@ class KnowledgeGraphExtractor(BaseExtractor):
     """A knowledge graph extractor extracts triples with a schema"""
 
     @abstractmethod
-    def get_information_rules(self) -> InformationRules:
+    def get_information_rules(self) -> ConceptualDataModel:
         """Returns the information rules that the extractor uses."""
         raise NotImplementedError()
 

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

@@ -18,7 +18,7 @@ from rdflib import RDF, XSD, Literal, Namespace, URIRef
 from typing_extensions import Self
 
 from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._graph.extractors._base import BaseExtractor
+from cognite.neat.core._instances.extractors._base import BaseExtractor
 from cognite.neat.core._issues.errors import NeatValueError
 from cognite.neat.core._issues.warnings import CDFAuthWarning, NeatValueWarning
 from cognite.neat.core._shared import Triple

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

@@ -14,12 +14,15 @@ from cognite.neat.core._constants import (
     DEFAULT_NAMESPACE,
     get_default_prefixes_and_namespaces,
 )
-from cognite.neat.core._graph.extractors._base import KnowledgeGraphExtractor
+from cognite.neat.core._data_model._shared import ReadRules
+from cognite.neat.core._data_model.catalog import classic_model
+from cognite.neat.core._data_model.models import (
+    ConceptualDataModel,
+    UnverifiedConceptualDataModel,
+)
+from cognite.neat.core._instances.extractors._base import KnowledgeGraphExtractor
 from cognite.neat.core._issues.errors import NeatValueError, ResourceNotFoundError
 from cognite.neat.core._issues.warnings import CDFAuthWarning, NeatValueWarning
-from cognite.neat.core._rules._shared import ReadRules
-from cognite.neat.core._rules.catalog import classic_model
-from cognite.neat.core._rules.models import InformationInputRules, InformationRules
 from cognite.neat.core._shared import Triple
 from cognite.neat.core._utils.collection_ import chunker, iterate_progress_bar
 from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri
@@ -205,11 +208,14 @@ class ClassicGraphExtractor(KnowledgeGraphExtractor):
 
         yield from self._extract_asset_parent_data_sets()
 
-    def get_information_rules(self) -> InformationRules:
+    def get_information_rules(self) -> ConceptualDataModel:
         # To avoid circular imports
-        from cognite.neat.core._rules.importers import ExcelImporter
+        from cognite.neat.core._data_model.importers import ExcelImporter
 
-        unverified = cast(ReadRules[InformationInputRules], ExcelImporter(classic_model).to_rules())
+        unverified = cast(
+            ReadRules[UnverifiedConceptualDataModel],
+            ExcelImporter(classic_model).to_rules(),
+        )
         if unverified.rules is None:
             raise NeatValueError(f"Could not read the classic model rules from {classic_model}.")
 

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

@@ -7,18 +7,18 @@ 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.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._issues import IssueList, NeatIssue, catch_warnings
 from cognite.neat.core._issues.warnings import (
     CDFAuthWarning,
     ResourceNotFoundWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat.core._rules.importers import DMSImporter
-from cognite.neat.core._rules.models import DMSRules, InformationRules
-from cognite.neat.core._rules.models.data_types import Json
-from cognite.neat.core._rules.models.entities import UnknownEntity
-from cognite.neat.core._rules.models.information import InformationProperty
-from cognite.neat.core._rules.transformers import DMSToInformation, VerifyDMSRules
 from cognite.neat.core._shared import Triple
 
 from ._base import KnowledgeGraphExtractor
@@ -47,7 +47,7 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
         self._str_to_ideal_type = str_to_ideal_type
 
         self._views: list[dm.View] | None = None
-        self._information_rules: InformationRules | None = None
+        self._information_rules: ConceptualDataModel | None = None
         self._dms_rules: DMSRules | None = None
 
     @classmethod
@@ -164,7 +164,7 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
                     self._issues.append(ResourceNotFoundWarning(dm_view, "view", data_model_id, "data model"))
         return views
 
-    def get_information_rules(self) -> InformationRules:
+    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()
@@ -180,7 +180,7 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
         """Returns the issues that occurred during the extraction."""
         return self._issues
 
-    def _create_rules(self) -> tuple[InformationRules, DMSRules]:
+    def _create_rules(self) -> tuple[ConceptualDataModel, DMSRules]:
         # The DMS and Information rules must be created together to link them property.
         importer = DMSImporter.from_data_model(self._client, self._data_model)
         unverified_dms = importer.to_rules()
@@ -217,7 +217,7 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
                 cls_ = classes_by_prefix[view.external_id]
                 for property_ in ("startNode", "endNode"):
                     information_rules.properties.append(
-                        InformationProperty(
+                        ConceptualProperty(
                             class_=cls_.class_,
                             property_=property_,
                             value_type=UnknownEntity(),

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 RulesAnalysis
+from cognite.neat.core._data_model.models import ConceptualDataModel, DMSRules
+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._shared import Triple
 from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri
 
@@ -38,17 +38,17 @@ class MockGraphGenerator(BaseExtractor):
 
     def __init__(
         self,
-        rules: InformationRules | DMSRules,
+        rules: ConceptualDataModel | DMSRules,
         class_count: dict[str | ClassEntity, int] | None = None,
         stop_on_exception: bool = False,
         allow_isolated_classes: bool = True,
     ):
         if isinstance(rules, DMSRules):
             # fixes potential issues with circular dependencies
-            from cognite.neat.core._rules.transformers import DMSToInformation
+            from cognite.neat.core._data_model.transformers import DMSToInformation
 
             self.rules = DMSToInformation().transform(rules)
-        elif isinstance(rules, InformationRules):
+        elif isinstance(rules, ConceptualDataModel):
             self.rules = rules
         else:
             raise ValueError("Rules must be of type InformationRules or DMSRules!")
@@ -85,7 +85,7 @@ class MockGraphGenerator(BaseExtractor):
 
 
 def generate_triples(
-    rules: InformationRules,
+    rules: ConceptualDataModel,
     class_count: dict[ClassEntity, int],
     stop_on_exception: bool = False,
     allow_isolated_classes: bool = True,
@@ -294,8 +294,8 @@ def _generate_mock_data_property_triples(
 
 def _generate_mock_object_property_triples(
     class_: ClassEntity,
-    property_definition: InformationProperty,
-    class_property_pairs: dict[ClassEntity, list[InformationProperty]],
+    property_definition: ConceptualProperty,
+    class_property_pairs: dict[ClassEntity, list[ConceptualProperty]],
     sym_pairs: set[tuple[ClassEntity, ClassEntity]],
     instance_ids: dict[ClassEntity, list[URIRef]],
     namespace: Namespace,
@@ -365,7 +365,7 @@ def _generate_mock_object_property_triples(
 
 def _generate_triples_per_class(
     class_: ClassEntity,
-    class_properties_pairs: dict[ClassEntity, list[InformationProperty]],
+    class_properties_pairs: dict[ClassEntity, list[ConceptualProperty]],
     sym_pairs: set[tuple[ClassEntity, ClassEntity]],
     instance_ids: dict[ClassEntity, list[URIRef]],
     namespace: 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/_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 RulesAnalysis
+from cognite.neat.core._data_model.analysis._base import ViewQuery, ViewQueryDict
+from cognite.neat.core._data_model.models import DMSRules
+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,15 +50,6 @@ 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._utils.auxiliary import create_sha256_hash
@@ -114,7 +116,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
     def __init__(
         self,
         dms_rules: DMSRules,
-        info_rules: InformationRules,
+        info_rules: ConceptualDataModel,
         graph_store: NeatGraphStore,
         instance_space: str,
         space_property: str | None = None,

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/_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 Entity
 
         if isinstance(value, str | int | bool | float):
             return value
@@ -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 Entity
 
         if isinstance(type_, UnionType) or get_origin(type_) is UnionType:
             args = get_args(type_)

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/_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

cognite/neat/core/_store/_graph_store.py

@@ -12,10 +12,10 @@ from rdflib import Dataset, Graph, Namespace, URIRef
 from rdflib.graph import DATASET_DEFAULT_GRAPH_ID
 from rdflib.plugins.stores.sparqlstore import SPARQLUpdateStore
 
-from cognite.neat.core._graph._shared import quad_formats, rdflib_to_oxi_type
-from cognite.neat.core._graph.extractors import RdfFileExtractor, TripleExtractors
-from cognite.neat.core._graph.queries import Queries
-from cognite.neat.core._graph.transformers import Transformers
+from cognite.neat.core._instances._shared import quad_formats, rdflib_to_oxi_type
+from cognite.neat.core._instances.extractors import RdfFileExtractor, TripleExtractors
+from cognite.neat.core._instances.queries import Queries
+from cognite.neat.core._instances.transformers import Transformers
 from cognite.neat.core._issues import IssueList, catch_issues
 from cognite.neat.core._issues.errors import NeatValueError, OxigraphStorageLockedError
 from cognite.neat.core._shared import InstanceType, Triple

cognite/neat/core/_store/_rules_store.py

@@ -12,22 +12,22 @@ from rdflib import URIRef
 
 from cognite.neat.core._client import NeatClient
 from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._graph.extractors import (
+from cognite.neat.core._data_model._shared import T_VerifiedRules, VerifiedRules
+from cognite.neat.core._data_model.exporters import BaseExporter
+from cognite.neat.core._data_model.exporters._base import CDFExporter, T_Export
+from cognite.neat.core._data_model.importers import BaseImporter
+from cognite.neat.core._data_model.models import ConceptualDataModel, DMSRules
+from cognite.neat.core._data_model.transformers import (
+    DMSToInformation,
+    VerifiedRulesTransformer,
+    VerifyAnyRules,
+)
+from cognite.neat.core._instances.extractors import (
     DMSGraphExtractor,
     KnowledgeGraphExtractor,
 )
 from cognite.neat.core._issues import IssueList, catch_issues
 from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._rules._shared import T_VerifiedRules, VerifiedRules
-from cognite.neat.core._rules.exporters import BaseExporter
-from cognite.neat.core._rules.exporters._base import CDFExporter, T_Export
-from cognite.neat.core._rules.importers import BaseImporter
-from cognite.neat.core._rules.models import DMSRules, InformationRules
-from cognite.neat.core._rules.transformers import (
-    DMSToInformation,
-    VerifiedRulesTransformer,
-    VerifyAnyRules,
-)
 from cognite.neat.core._utils.upload import UploadResultList
 
 from ._provenance import (
@@ -43,7 +43,7 @@ from .exceptions import EmptyStore, InvalidActivityInput
 
 @dataclass(frozen=True)
 class RulesEntity(Entity):
-    information: InformationRules
+    information: ConceptualDataModel
     dms: DMSRules | None = None
 
     @property
@@ -85,11 +85,11 @@ class NeatRulesStore:
         importer: BaseImporter,
         validate: bool,
         client: NeatClient | None = None,
-    ) -> tuple[InformationRules, DMSRules | None]:
+    ) -> tuple[ConceptualDataModel, DMSRules | None]:
         """Action that imports rules, verifies them and optionally converts them."""
         read_rules = importer.to_rules()
         verified = VerifyAnyRules(validate, client).transform(read_rules)  # type: ignore[arg-type]
-        if isinstance(verified, InformationRules):
+        if isinstance(verified, ConceptualDataModel):
             return verified, None
         elif isinstance(verified, DMSRules):
             return DMSToInformation().transform(verified), verified
@@ -100,7 +100,7 @@ class NeatRulesStore:
     def _graph_import_verify_convert(
         self,
         extractor: KnowledgeGraphExtractor,
-    ) -> tuple[InformationRules, DMSRules | None]:
+    ) -> tuple[ConceptualDataModel, DMSRules | None]:
         info = extractor.get_information_rules()
         dms: DMSRules | None = None
         if isinstance(extractor, DMSGraphExtractor):
@@ -229,12 +229,12 @@ class NeatRulesStore:
 
             def action(
                 transformer_item: VerifiedRulesTransformer = agent_tool,
-            ) -> tuple[InformationRules, DMSRules | None]:
+            ) -> tuple[ConceptualDataModel, DMSRules | None]:
                 last_change = self.provenance[-1]
                 source_entity = last_change.target_entity
                 transformer_input = self._get_transformer_input(source_entity, transformer_item)
                 transformer_output = transformer_item.transform(transformer_input)
-                if isinstance(transformer_output, InformationRules):
+                if isinstance(transformer_output, ConceptualDataModel):
                     return transformer_output, None
                 return last_change.target_entity.information, transformer_output
 
@@ -260,7 +260,7 @@ class NeatRulesStore:
 
     def do_activity(
         self,
-        action: Callable[[], tuple[InformationRules, DMSRules | None]],
+        action: Callable[[], tuple[ConceptualDataModel, DMSRules | None]],
         agent_tool: BaseImporter | VerifiedRulesTransformer | KnowledgeGraphExtractor,
     ) -> IssueList:
         result, issue_list, start, end = self._do_activity(action)
@@ -273,7 +273,7 @@ class NeatRulesStore:
     def _update_provenance(
         self,
         agent_tool: BaseImporter | VerifiedRulesTransformer | KnowledgeGraphExtractor,
-        result: tuple[InformationRules, DMSRules | None],
+        result: tuple[ConceptualDataModel, DMSRules | None],
         issue_list: IssueList,
         activity_start: datetime,
         activity_end: datetime,
@@ -318,11 +318,11 @@ class NeatRulesStore:
 
     def _do_activity(
         self,
-        action: Callable[[], tuple[InformationRules, DMSRules | None]],
-    ) -> tuple[tuple[InformationRules, DMSRules | None], IssueList, datetime, datetime]:
+        action: Callable[[], tuple[ConceptualDataModel, DMSRules | None]],
+    ) -> tuple[tuple[ConceptualDataModel, DMSRules | None], IssueList, datetime, datetime]:
         """This private method is used to execute an activity and return the result and issues."""
         start = datetime.now(timezone.utc)
-        result: tuple[InformationRules, DMSRules | None] | None = None
+        result: tuple[ConceptualDataModel, DMSRules | None] | None = None
         with catch_issues() as issue_list:
             result = action()
         end = datetime.now(timezone.utc)
@@ -340,7 +340,7 @@ class NeatRulesStore:
         elif isinstance(source_entity.information, expected_types):
             input_ = cast(VerifiedRules, source_entity.information).model_copy(deep=True)
         else:
-            available: list[type] = [InformationRules]
+            available: list[type] = [ConceptualDataModel]
             if source_entity.dms is not None:
                 available.append(DMSRules)
             raise InvalidActivityInput(expected=expected_types, have=tuple(available))
@@ -390,19 +390,19 @@ class NeatRulesStore:
     @staticmethod
     def _get_transformer_input(
         source_entity: RulesEntity, transformer: VerifiedRulesTransformer
-    ) -> InformationRules | DMSRules:
+    ) -> ConceptualDataModel | DMSRules:
         # Case 1: We only have information rules
         if source_entity.dms is None:
             if transformer.is_valid_input(source_entity.information):
                 return source_entity.information
-            raise InvalidActivityInput(expected=(DMSRules,), have=(InformationRules,))
+            raise InvalidActivityInput(expected=(DMSRules,), have=(ConceptualDataModel,))
         # Case 2: We have both information and dms rules and the transformer is compatible with dms rules
         elif isinstance(source_entity.dms, DMSRules) and transformer.is_valid_input(source_entity.dms):
             return source_entity.dms
         # Case 3: We have both information and dms rules and the transformer is compatible with information rules
-        raise InvalidActivityInput(expected=(InformationRules,), have=(DMSRules,))
+        raise InvalidActivityInput(expected=(ConceptualDataModel,), have=(DMSRules,))
 
-    def _get_source_id(self, result: tuple[InformationRules, DMSRules | None]) -> rdflib.URIRef | None:
+    def _get_source_id(self, result: tuple[ConceptualDataModel, DMSRules | None]) -> rdflib.URIRef | None:
         """Return the source of the result.
 
         !!! note
@@ -411,7 +411,7 @@ class NeatRulesStore:
         info, dms = result
         return dms.metadata.source_id if dms else info.metadata.source_id
 
-    def _create_id(self, info: InformationRules, dms: DMSRules | None) -> rdflib.URIRef:
+    def _create_id(self, info: ConceptualDataModel, dms: DMSRules | None) -> rdflib.URIRef:
         if dms is None:
             identifier = info.metadata.identifier
         else:
@@ -437,7 +437,7 @@ class NeatRulesStore:
         return self.provenance[-1].target_entity.dms
 
     @property
-    def try_get_last_information_rules(self) -> InformationRules | None:
+    def try_get_last_information_rules(self) -> ConceptualDataModel | None:
         if not self.provenance:
             return None
         return self.provenance[-1].target_entity.information
@@ -451,13 +451,13 @@ class NeatRulesStore:
         return self.provenance[-1].target_entity.dms
 
     @property
-    def last_verified_information_rules(self) -> InformationRules:
+    def last_verified_information_rules(self) -> ConceptualDataModel:
         if not self.provenance:
             raise EmptyStore()
         return self.provenance[-1].target_entity.information
 
     @property
-    def last_verified_rules(self) -> InformationRules | DMSRules | None:
+    def last_verified_rules(self) -> ConceptualDataModel | DMSRules | None:
         if not self.provenance:
             return None
         last_entity = self.provenance[-1].target_entity

cognite/neat/core/_store/exceptions.py

@@ -2,10 +2,10 @@
 
 from dataclasses import dataclass
 
-from cognite.neat.core._graph.extractors import KnowledgeGraphExtractor
+from cognite.neat.core._data_model.importers import BaseImporter
+from cognite.neat.core._data_model.transformers import VerifiedRulesTransformer
+from cognite.neat.core._instances.extractors import KnowledgeGraphExtractor
 from cognite.neat.core._issues import IssueList
-from cognite.neat.core._rules.importers import BaseImporter
-from cognite.neat.core._rules.transformers import VerifiedRulesTransformer
 
 from ._provenance import Activity
 

cognite/neat/core/_utils/spreadsheet.py

@@ -8,7 +8,7 @@ from openpyxl import load_workbook
 from openpyxl.worksheet.datavalidation import DataValidation
 from openpyxl.worksheet.worksheet import Worksheet
 
-from cognite.neat.core._rules._constants import get_internal_properties
+from cognite.neat.core._data_model._constants import get_internal_properties
 
 
 @dataclass

cognite/neat/core/_utils/text.py

@@ -4,7 +4,7 @@ from collections.abc import Collection, Set
 from re import Pattern
 from typing import Any
 
-from cognite.neat.core._rules._constants import get_reserved_words
+from cognite.neat.core._data_model._constants import get_reserved_words
 
 PREPOSITIONS = frozenset(
     {

cognite/neat/session/_base.py

@@ -6,19 +6,21 @@ from cognite.client import data_modeling as dm
 
 from cognite.neat import _version
 from cognite.neat.core._client import NeatClient
-from cognite.neat.core._issues import IssueList
-from cognite.neat.core._issues.errors import RegexViolationError
-from cognite.neat.core._issues.errors._general import NeatImportError
-from cognite.neat.core._rules import importers
-from cognite.neat.core._rules.models import DMSRules
-from cognite.neat.core._rules.models.information._rules import InformationRules
-from cognite.neat.core._rules.transformers import (
+from cognite.neat.core._data_model import importers
+from cognite.neat.core._data_model.models import DMSRules
+from cognite.neat.core._data_model.models.conceptual._verified import (
+    ConceptualDataModel,
+)
+from cognite.neat.core._data_model.transformers import (
     InformationToDMS,
     MergeDMSRules,
     MergeInformationRules,
     ToDMSCompliantEntities,
     VerifyInformationRules,
 )
+from cognite.neat.core._issues import IssueList
+from cognite.neat.core._issues.errors import RegexViolationError
+from cognite.neat.core._issues.errors._general import NeatImportError
 from cognite.neat.core._store._rules_store import RulesEntity
 from cognite.neat.core._utils.auxiliary import local_import
 
@@ -242,7 +244,7 @@ class NeatSession:
             data_model_id=dm.DataModelId.load(model_id) if last_entity is None else None,
         )
 
-        def action() -> tuple[InformationRules, DMSRules | None]:
+        def action() -> tuple[ConceptualDataModel, DMSRules | None]:
             unverified_information = importer.to_rules()
             unverified_information = ToDMSCompliantEntities(rename_warning="raise").transform(unverified_information)
 

cognite/neat/session/_drop.py

@@ -6,8 +6,8 @@ from cognite.client.utils.useful_types import SequenceNotStr
 from rdflib import URIRef
 
 from cognite.neat.core._constants import COGNITE_MODELS
+from cognite.neat.core._data_model.transformers import DropModelViews
 from cognite.neat.core._issues import IssueList
-from cognite.neat.core._rules.transformers import DropModelViews
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, session_class_wrapper