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

cognite/neat/_rules/models/information/_validation.py

@@ -12,6 +12,7 @@ from cognite.neat._issues.warnings._resources import (
 from cognite.neat._rules._constants import PATTERNS, EntityTypes
 from cognite.neat._rules.models.entities import ClassEntity, UnknownEntity
 from cognite.neat._rules.models.entities._multi_value import MultiValueTypeInfo
+from cognite.neat._utils.spreadsheet import SpreadsheetRead
 
 from ._rules import InformationRules
 
@@ -20,8 +21,9 @@ class InformationValidation:
     """This class does all the validation of the Information rules that have dependencies
     between components."""
 
-    def __init__(self, rules: InformationRules):
+    def __init__(self, rules: InformationRules, read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None):
         self.rules = rules
+        self.read_info_by_spreadsheet = read_info_by_spreadsheet
         self.metadata = rules.metadata
         self.properties = rules.properties
         self.classes = rules.classes

cognite/neat/_rules/transformers/__init__.py

@@ -14,11 +14,14 @@ from ._converters import (
     PrefixEntities,
     SetIDDMSModel,
     StandardizeNaming,
+    StandardizeSpaceAndVersion,
+    SubsetDMSRules,
+    SubsetInformationRules,
     ToCompliantEntities,
     ToDataProductModel,
+    ToDMSCompliantEntities,
     ToEnterpriseModel,
     ToExtensionModel,
-    ToInformationCompliantEntities,
     ToSolutionModel,
 )
 from ._mapping import AsParentPropertyId, MapOneToOne, RuleMapper
@@ -43,11 +46,14 @@ __all__ = [
     "RulesTransformer",
     "SetIDDMSModel",
     "StandardizeNaming",
+    "StandardizeSpaceAndVersion",
+    "SubsetDMSRules",
+    "SubsetInformationRules",
     "ToCompliantEntities",
+    "ToDMSCompliantEntities",
     "ToDataProductModel",
     "ToEnterpriseModel",
     "ToExtensionModel",
-    "ToInformationCompliantEntities",
     "ToSolutionModel",
     "VerifiedRulesTransformer",
     "VerifyAnyRules",

cognite/neat/_rules/transformers/_converters.py

@@ -6,11 +6,12 @@ from collections import Counter, defaultdict
 from collections.abc import Collection, Mapping
 from datetime import date, datetime
 from functools import cached_property
-from typing import ClassVar, Literal, TypeVar, cast, overload
+from typing import Any, ClassVar, Literal, TypeVar, cast, overload
 
 from cognite.client.data_classes import data_modeling as dms
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier, ViewId
 from cognite.client.utils.useful_types import SequenceNotStr
+from pydantic import ValidationError
 from rdflib import Namespace
 
 from cognite.neat._client import NeatClient
@@ -33,7 +34,7 @@ from cognite.neat._rules._shared import (
     ReadRules,
     VerifiedRules,
 )
-from cognite.neat._rules.analysis import DMSAnalysis
+from cognite.neat._rules.analysis import RulesAnalysis
 from cognite.neat._rules.importers import DMSImporter
 from cognite.neat._rules.models import (
     DMSInputRules,
@@ -43,8 +44,6 @@ from cognite.neat._rules.models import (
     SheetList,
     data_types,
 )
-from cognite.neat._rules.models._rdfpath import Entity as RDFPathEntity
-from cognite.neat._rules.models._rdfpath import RDFPath, SingleProperty
 from cognite.neat._rules.models.data_types import AnyURI, DataType, Enum, File, String, Timeseries
 from cognite.neat._rules.models.dms import DMSMetadata, DMSProperty, DMSValidation, DMSView
 from cognite.neat._rules.models.dms._rules import DMSContainer, DMSEnum, DMSNode
@@ -60,7 +59,8 @@ from cognite.neat._rules.models.entities import (
     ViewEntity,
 )
 from cognite.neat._rules.models.information import InformationClass, InformationMetadata, InformationProperty
-from cognite.neat._utils.text import NamingStandardization, to_camel
+from cognite.neat._utils.rdf_ import get_inheritance_path
+from cognite.neat._utils.text import NamingStandardization, to_camel_case
 
 from ._base import RulesTransformer, T_VerifiedIn, T_VerifiedOut, VerifiedRulesTransformer
 from ._verification import VerifyDMSRules
@@ -75,22 +75,20 @@ class ConversionTransformer(VerifiedRulesTransformer[T_VerifiedIn, T_VerifiedOut
     ...
 
 
-class ToInformationCompliantEntities(
-    RulesTransformer[ReadRules[InformationInputRules], ReadRules[InformationInputRules]]
-):
+class ToDMSCompliantEntities(RulesTransformer[ReadRules[InformationInputRules], ReadRules[InformationInputRules]]):
     """Converts input rules to rules that is compliant with the Information Model.
 
     This is typically used with importers from arbitrary sources to ensure that classes and properties have valid
     names.
 
     Args:
-        renaming: How to handle renaming of entities that are not compliant with the Information Model.
-            - "warning": Raises a warning and renames the entity.
+        rename_warning: How to handle renaming of entities that are not compliant with the Information Model.
+            - "raise": Raises a warning and renames the entity.
             - "skip": Renames the entity without raising a warning.
     """
 
-    def __init__(self, renaming: Literal["warning", "skip"] = "skip") -> None:
-        self._renaming = renaming
+    def __init__(self, rename_warning: Literal["raise", "skip"] = "skip") -> None:
+        self._renaming = rename_warning
 
     @property
     def description(self) -> str:
@@ -107,9 +105,9 @@ class ToInformationCompliantEntities(
         new_by_old_class_suffix: dict[str, str] = {}
         for cls in copy.classes:
             cls_entity = cast(ClassEntity, cls.class_)  # Safe due to the dump above
-            if not PATTERNS.class_id_compliance.match(cls_entity.suffix):
+            if not PATTERNS.view_id_compliance.match(cls_entity.suffix):
                 new_suffix = self._fix_cls_suffix(cls_entity.suffix)
-                if self._renaming == "warning":
+                if self._renaming == "raise":
                     warnings.warn(
                         NeatValueWarning(f"Invalid class name {cls_entity.suffix!r}.Renaming to {new_suffix}"),
                         stacklevel=2,
@@ -123,7 +121,7 @@ class ToInformationCompliantEntities(
                         cls_.implements[i].suffix = new_by_old_class_suffix[parent.suffix]  # type: ignore[union-attr]
 
         for prop in copy.properties:
-            if not PATTERNS.information_property_id_compliance.match(prop.property_):
+            if not PATTERNS.dms_property_id_compliance.match(prop.property_):
                 new_property = self._fix_property(prop.property_)
                 if self._renaming == "warning":
                     warnings.warn(
@@ -174,6 +172,65 @@ class ToInformationCompliantEntities(
         return property_
 
 
+class StandardizeSpaceAndVersion(VerifiedRulesTransformer[DMSRules, DMSRules]):  # type: ignore[misc]
+    """This transformer standardizes the space and version of the DMSRules.
+
+    typically used to ensure all the views are moved to the same version as the data model.
+
+    """
+
+    @property
+    def description(self) -> str:
+        return "Ensures uniform version and space of the views belonging to the data model."
+
+    def transform(self, rules: DMSRules) -> DMSRules:
+        copy = rules.model_copy(deep=True)
+
+        space = copy.metadata.space
+        version = copy.metadata.version
+
+        copy.views = self._standardize_views(copy.views, space, version)
+        copy.properties = self._standardize_properties(copy.properties, space, version)
+        return copy
+
+    def _standardize_views(self, views: SheetList[DMSView], space: str, version: str) -> SheetList[DMSView]:
+        for view in views:
+            if view.view.space not in COGNITE_SPACES:
+                view.view.version = version
+                view.view.prefix = space
+
+            if view.implements:
+                for i, parent in enumerate(view.implements):
+                    if parent.space not in COGNITE_SPACES:
+                        view.implements[i].version = version
+                        view.implements[i].prefix = space
+        return views
+
+    def _standardize_properties(
+        self, properties: SheetList[DMSProperty], space: str, version: str
+    ) -> SheetList[DMSProperty]:
+        for property_ in properties:
+            if property_.view.space not in COGNITE_SPACES:
+                property_.view.version = version
+                property_.view.prefix = space
+
+            if isinstance(property_.value_type, ViewEntity) and property_.value_type.space not in COGNITE_SPACES:
+                property_.value_type.version = version
+                property_.value_type.prefix = space
+
+            # for edge connection
+            if (
+                property_.connection
+                and isinstance(property_.connection, EdgeEntity)
+                and property_.connection.properties
+            ):
+                if property_.connection.properties.space not in COGNITE_SPACES:
+                    property_.connection.properties.version = version
+                    property_.connection.properties.prefix = space
+
+        return properties
+
+
 class ToCompliantEntities(VerifiedRulesTransformer[InformationRules, InformationRules]):  # type: ignore[misc]
     """Converts input rules to rules with compliant entity IDs that match regex patters used
     by DMS schema components."""
@@ -649,7 +706,7 @@ class ToEnterpriseModel(ToExtensionModel):
 
             container = DMSContainer(container=container_entity)
 
-            property_id = f"{to_camel(view_entity.suffix)}{self.dummy_property}"
+            property_id = f"{to_camel_case(view_entity.suffix)}{self.dummy_property}"
             property_ = DMSProperty(
                 view=view_entity,
                 view_property=property_id,
@@ -759,13 +816,16 @@ class ToSolutionModel(ToExtensionModel):
 
     @staticmethod
     def _expand_properties(rules: DMSRules) -> DMSRules:
-        probe = DMSAnalysis(rules)
-        ancestor_properties_by_view = probe.classes_with_properties(
-            consider_inheritance=True, allow_different_namespace=True
+        probe = RulesAnalysis(dms=rules)
+        ancestor_properties_by_view = probe.properties_by_view(
+            include_ancestors=True,
+            include_different_space=True,
         )
         property_ids_by_view = {
             view: {prop.view_property for prop in properties}
-            for view, properties in probe.classes_with_properties(consider_inheritance=False).items()
+            for view, properties in probe.properties_by_view(
+                include_ancestors=False, include_different_space=True
+            ).items()
         }
         for view, property_ids in property_ids_by_view.items():
             ancestor_properties = ancestor_properties_by_view.get(view, [])
@@ -852,7 +912,7 @@ class ToSolutionModel(ToExtensionModel):
             if view.view in read_view_by_new_view:
                 read_view = read_view_by_new_view[view.view]
                 container_entity = ContainerEntity(space=self.new_model_id.space, externalId=view.view.external_id)
-                prefix = to_camel(view.view.suffix)
+                prefix = to_camel_case(view.view.suffix)
                 if self.properties == "repeat" and self.dummy_property:
                     property_ = DMSProperty(
                         view=view.view,
@@ -937,7 +997,7 @@ class ToDataProductModel(ToSolutionModel):
         self.include = include
 
     def transform(self, rules: DMSRules) -> DMSRules:
-        # Overwrite this to avoid the warning.
+        # Overwrite transform to avoid the warning.
         return self._to_solution(rules)
 
 
@@ -1011,7 +1071,7 @@ class DropModelViews(VerifiedRulesTransformer[DMSRules, DMSRules]):
             }
         new_model = rules.model_copy(deep=True)
 
-        properties_by_view = DMSAnalysis(new_model).classes_with_properties(consider_inheritance=True)
+        properties_by_view = RulesAnalysis(dms=new_model).properties_by_view(include_ancestors=True)
 
         new_model.views = SheetList[DMSView]([view for view in new_model.views if view.view not in exclude_views])
         new_properties = SheetList[DMSProperty]()
@@ -1155,6 +1215,7 @@ class ClassicPrepareCore(VerifiedRulesTransformer[InformationRules, InformationR
             class_=ClassEntity(prefix=prefix, suffix="ClassicSourceSystem"),
             description="A source system that provides data to the data model.",
             neatId=namespace["ClassicSourceSystem"],
+            instance_source=self.instance_namespace["ClassicSourceSystem"],
         )
         output.classes.append(source_system_class)
         for prop in output.properties:
@@ -1183,15 +1244,7 @@ class ClassicPrepareCore(VerifiedRulesTransformer[InformationRules, InformationR
                 value_type=String(),
                 class_=ClassEntity(prefix=prefix, suffix="ClassicSourceSystem"),
                 max_count=1,
-                instance_source=RDFPath(
-                    traversal=SingleProperty(
-                        class_=RDFPathEntity(
-                            prefix=instance_prefix,
-                            suffix="ClassicSourceSystem",
-                        ),
-                        property=RDFPathEntity(prefix=instance_prefix, suffix="name"),
-                    ),
-                ),
+                instance_source=[self.instance_namespace["name"]],
             )
         )
         return output
@@ -1673,7 +1726,6 @@ class _DMSRulesConverter:
             classes.append(info_class)
 
         prefixes = get_default_prefixes_and_namespaces()
-        instance_prefix: str | None = None
         if self.instance_namespace:
             instance_prefix = next((k for k, v in prefixes.items() if v == self.instance_namespace), None)
             if instance_prefix is None:
@@ -1696,15 +1748,6 @@ class _DMSRulesConverter:
             else:
                 raise ValueError(f"Unsupported value type: {property_.value_type.type_}")
 
-            transformation: RDFPath | None = None
-            if instance_prefix is not None:
-                transformation = RDFPath(
-                    traversal=SingleProperty(
-                        class_=RDFPathEntity(prefix=instance_prefix, suffix=property_.view.external_id),
-                        property=RDFPathEntity(prefix=instance_prefix, suffix=property_.view_property),
-                    )
-                )
-
             info_property = InformationProperty(
                 # Removing version
                 class_=ClassEntity(suffix=property_.view.suffix, prefix=property_.view.prefix),
@@ -1713,7 +1756,6 @@ class _DMSRulesConverter:
                 description=property_.description,
                 min_count=(0 if property_.nullable or property_.nullable is None else 1),
                 max_count=(float("inf") if property_.is_list or property_.nullable is None else 1),
-                instance_source=transformation,
             )
 
             # Linking
@@ -1746,3 +1788,146 @@ class _DMSRulesConverter:
             created=metadata.created,
             updated=metadata.updated,
         )
+
+
+class SubsetDMSRules(VerifiedRulesTransformer[DMSRules, DMSRules]):
+    """Subsets DMSRules to only include the specified views."""
+
+    def __init__(self, views: set[ViewEntity]):
+        self._views = views
+
+    def transform(self, rules: DMSRules) -> DMSRules:
+        analysis = RulesAnalysis(dms=rules)
+
+        views_by_view = analysis.view_by_view_entity
+        implements_by_view = analysis.implements_by_view()
+
+        available = analysis.defined_views(include_ancestors=True)
+        subset = available.intersection(self._views)
+
+        ancestors: set[ViewEntity] = set()
+        for view in subset:
+            ancestors = ancestors.union({ancestor for ancestor in get_inheritance_path(view, implements_by_view)})
+        subset = subset.union(ancestors)
+
+        if not subset:
+            raise NeatValueError("None of the requested views are defined in the rules!")
+
+        if nonexisting := self._views - subset:
+            raise NeatValueError(
+                "Following requested views do not exist"
+                f" in the rules: [{','.join([view.external_id for view in nonexisting])}]. Aborting."
+            )
+
+        subsetted_rules: dict[str, Any] = {
+            "metadata": rules.metadata.model_copy(),
+            "views": SheetList[DMSView](),
+            "properties": SheetList[DMSProperty](),
+            "containers": SheetList[DMSContainer](),
+            "enum": rules.enum,
+            "nodes": rules.nodes,
+        }
+
+        # add views
+        for view in subset:
+            subsetted_rules["views"].append(views_by_view[view])
+
+        used_containers = set()
+
+        # add properties
+        for view, properties in analysis.properties_by_view(include_ancestors=False).items():
+            if view not in subset:
+                continue
+
+            for property_ in properties:
+                if (
+                    isinstance(property_.value_type, DataType)
+                    or isinstance(property_.value_type, DMSUnknownEntity)
+                    or (isinstance(property_.value_type, ViewEntity) and property_.value_type in subset)
+                ):
+                    subsetted_rules["properties"].append(property_)
+
+                    if property_.container:
+                        used_containers.add(property_.container)
+
+        # add containers
+        if rules.containers:
+            for container in rules.containers:
+                if container.container in used_containers:
+                    subsetted_rules["containers"].append(container)
+
+        try:
+            return DMSRules.model_validate(subsetted_rules)
+        except ValidationError as e:
+            raise NeatValueError(f"Cannot subset rules: {e}") from e
+
+
+class SubsetInformationRules(VerifiedRulesTransformer[InformationRules, InformationRules]):
+    """Subsets InformationRules to only include the specified classes."""
+
+    def __init__(self, classes: set[ClassEntity]):
+        self._classes = classes
+
+    def transform(self, rules: InformationRules) -> InformationRules:
+        analysis = RulesAnalysis(information=rules)
+
+        class_by_class_entity = analysis.class_by_class_entity
+        parent_entity_by_class_entity = analysis.parents_by_class()
+
+        available = analysis.defined_classes(include_ancestors=True)
+        subset = available.intersection(self._classes)
+
+        # need to add all the parent classes of the desired classes to the possible classes
+        ancestors: set[ClassEntity] = set()
+        for class_ in subset:
+            ancestors = ancestors.union(
+                {ancestor for ancestor in get_inheritance_path(class_, parent_entity_by_class_entity)}
+            )
+        subset = subset.union(ancestors)
+
+        if not subset:
+            raise NeatValueError("None of the requested classes are defined in the rules!")
+
+        if nonexisting := self._classes - subset:
+            raise NeatValueError(
+                "Following requested classes do not exist"
+                f" in the rules: [{','.join([class_.suffix for class_ in nonexisting])}]"
+                ". Aborting."
+            )
+
+        subsetted_rules: dict[str, Any] = {
+            "metadata": rules.metadata.model_copy(),
+            "prefixes": (rules.prefixes or {}).copy(),
+            "classes": SheetList[InformationClass](),
+            "properties": SheetList[InformationProperty](),
+        }
+
+        for class_ in subset:
+            subsetted_rules["classes"].append(class_by_class_entity[class_])
+
+        for class_, properties in analysis.properties_by_class(include_ancestors=False).items():
+            if class_ not in subset:
+                continue
+            for property_ in properties:
+                # datatype property can be added directly
+                if (
+                    isinstance(property_.value_type, DataType)
+                    or (isinstance(property_.value_type, ClassEntity) and property_.value_type in subset)
+                    or isinstance(property_.value_type, UnknownEntity)
+                ):
+                    subsetted_rules["properties"].append(property_)
+                # object property can be added if the value type is in the subset
+                elif isinstance(property_.value_type, MultiValueTypeInfo):
+                    allowed = [t for t in property_.value_type.types if t in subset or isinstance(t, DataType)]
+                    if allowed:
+                        subsetted_rules["properties"].append(
+                            property_.model_copy(
+                                deep=True,
+                                update={"value_type": MultiValueTypeInfo(types=allowed)},
+                            )
+                        )
+
+        try:
+            return InformationRules.model_validate(subsetted_rules)
+        except ValidationError as e:
+            raise NeatValueError(f"Cannot subset rules: {e}") from e

cognite/neat/_rules/transformers/_verification.py

@@ -35,27 +35,22 @@ class VerificationTransformer(RulesTransformer[T_ReadInputRules, T_VerifiedRules
         in_ = rules.rules
         if in_ is None:
             raise NeatValueError("Cannot verify rules. The reading of the rules failed.")
-        error_args = rules.read_context
         verified_rules: T_VerifiedRules | None = None
         # We need to catch issues as we use the error args to provide extra context for the errors/warnings
-        # For example, which row in the spreadsheet the error occurred o
-        with catch_issues(error_args=error_args) as issues:
+        # For example, which row in the spreadsheet the error occurred.
+        with catch_issues(rules.read_context) as issues:
             rules_cls = self._get_rules_cls(rules)
             dumped = in_.dump()
             verified_rules = rules_cls.model_validate(dumped)  # type: ignore[assignment]
             if self.validate:
                 validation_cls = self._get_validation_cls(verified_rules)  # type: ignore[arg-type]
                 if issubclass(validation_cls, DMSValidation):
-                    validation_issues = DMSValidation(verified_rules, self._client).validate()  # type: ignore[arg-type]
+                    validation_issues = DMSValidation(verified_rules, self._client, rules.read_context).validate()  # type: ignore[arg-type]
                 elif issubclass(validation_cls, InformationValidation):
-                    validation_issues = InformationValidation(verified_rules).validate()  # type: ignore[arg-type]
+                    validation_issues = InformationValidation(verified_rules, rules.read_context).validate()  # type: ignore[arg-type]
                 else:
                     raise NeatValueError("Unsupported rule type")
-
-                # Need to trigger and raise such that the catch_issues can add the extra context
-                validation_issues.trigger_warnings()
-                if validation_issues.has_errors:
-                    raise MultiValueError(validation_issues.errors)
+                issues.extend(validation_issues)
 
         # Raise issues which is expected to be handled outside of this method
         issues.trigger_warnings()

cognite/neat/_session/_base.py

@@ -16,7 +16,7 @@ from cognite.neat._rules.transformers import (
     InformationToDMS,
     MergeDMSRules,
     MergeInformationRules,
-    ToInformationCompliantEntities,
+    ToDMSCompliantEntities,
     VerifyInformationRules,
 )
 from cognite.neat._store._rules_store import RulesEntity
@@ -33,6 +33,7 @@ from ._read import ReadAPI
 from ._set import SetAPI
 from ._show import ShowAPI
 from ._state import SessionState
+from ._subset import SubsetAPI
 from ._to import ToAPI
 from .engine import load_neat_engine
 from .exceptions import session_class_wrapper
@@ -101,6 +102,7 @@ class NeatSession:
         self.inspect = InspectAPI(self._state)
         self.mapping = MappingAPI(self._state)
         self.drop = DropAPI(self._state)
+        self.subset = SubsetAPI(self._state)
         self.create = CreateAPI(self._state)
         self.opt = OptAPI()
         self.opt._display()
@@ -236,9 +238,7 @@ class NeatSession:
 
         def action() -> tuple[InformationRules, DMSRules | None]:
             unverified_information = importer.to_rules()
-            unverified_information = ToInformationCompliantEntities(renaming="warning").transform(
-                unverified_information
-            )
+            unverified_information = ToDMSCompliantEntities(rename_warning="raise").transform(unverified_information)
 
             extra_info = VerifyInformationRules().transform(unverified_information)
             if not last_entity:

cognite/neat/_session/_prepare.py

@@ -1,3 +1,4 @@
+import warnings
 from collections.abc import Callable
 from typing import Any
 
@@ -14,6 +15,7 @@ from cognite.neat._graph.transformers._rdfpath import MakeConnectionOnExactMatch
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._rules.transformers import PrefixEntities, StandardizeNaming
+from cognite.neat._rules.transformers._converters import StandardizeSpaceAndVersion
 from cognite.neat._utils.text import humanize_collection
 
 from ._state import SessionState
@@ -270,5 +272,15 @@ class DataModelPrepareAPI:
         For classes/views/containers, the naming will be standardized to PascalCase.
         For properties, the naming will be standardized to camelCase.
         """
+        warnings.filterwarnings("default")
         AlphaFlags.standardize_naming.warn()
         return self._state.rule_transform(StandardizeNaming())
+
+    def standardize_space_and_version(self) -> IssueList:
+        """Standardize space and version in the data model.
+
+        This method will standardize the space and version in the data model to the Cognite standard.
+        """
+        warnings.filterwarnings("default")
+        AlphaFlags.standardize_space_and_version.warn()
+        return self._state.rule_transform(StandardizeSpaceAndVersion())

cognite/neat/_session/_read.py

@@ -50,6 +50,7 @@ class ReadAPI:
         self.csv = CSVReadAPI(state, verbose)
         self.yaml = YamlReadAPI(state, verbose)
         self.xml = XMLReadAPI(state, verbose)
+        self.examples = Examples(state)
 
     def session(self, io: Any) -> None:
         """Reads a Neat Session from a zip file.
@@ -256,9 +257,6 @@ class CDFClassicAPI(BaseReadAPI):
         prepare_issues = self._state.rule_store.transform(
             ClassicPrepareCore(namespace, reference_timeseries, reference_files)
         )
-        # Update the instance store with the latest rules
-        information_rules = self._state.rule_store.last_verified_information_rules
-        self._state.instances.store.rules[self._state.instances.store.default_named_graph] = information_rules
 
         all_issues = IssueList(extract_issues + prepare_issues)
         # Update the provenance with all issue.
@@ -286,7 +284,6 @@ class ExcelReadAPI(BaseReadAPI):
 
     def __init__(self, state: SessionState, verbose: bool) -> None:
         super().__init__(state, verbose)
-        self.examples = ExcelExampleAPI(state, verbose)
 
     def __call__(self, io: Any, enable_manual_edit: bool = False) -> IssueList:
         """Reads a Neat Excel Rules sheet to the graph store. The rules sheet may stem from an Information architect,
@@ -310,16 +307,6 @@ class ExcelReadAPI(BaseReadAPI):
         return self._state.rule_import(importers.ExcelImporter(path), enable_manual_edit)
 
 
-@session_class_wrapper
-class ExcelExampleAPI(BaseReadAPI):
-    """Used as example for reading some data model into the NeatSession."""
-
-    def pump_example(self) -> IssueList:
-        """Reads the Hello World pump example into the NeatSession."""
-        importer: importers.ExcelImporter = importers.ExcelImporter(catalog.hello_world_pump)
-        return self._state.rule_import(importer)
-
-
 @session_class_wrapper
 class YamlReadAPI(BaseReadAPI):
     def __call__(self, io: Any, format: Literal["neat", "toolkit"] = "neat") -> IssueList:
@@ -519,7 +506,6 @@ class RDFReadAPI(BaseReadAPI):
 
     def __init__(self, state: SessionState, verbose: bool) -> None:
         super().__init__(state, verbose)
-        self.examples = RDFExamples(state)
 
     def ontology(self, io: Any) -> IssueList:
         """Reads an OWL ontology source into NeatSession.
@@ -582,13 +568,31 @@ class RDFReadAPI(BaseReadAPI):
 
 
 @session_class_wrapper
-class RDFExamples:
-    """Used as example for reading some triples into the NeatSession knowledge grapgh."""
+class Examples:
+    """Used as example for reading various sources into NeatSession."""
 
     def __init__(self, state: SessionState) -> None:
         self._state = state
 
+    @property
+    def _get_client(self) -> NeatClient:
+        if self._state.client is None:
+            raise NeatValueError("No client provided. Please provide a client to read a data model.")
+        return self._state.client
+
     def nordic44(self) -> IssueList:
         """Reads the Nordic 44 knowledge graph into the NeatSession graph store."""
         self._state.instances.store.write(extractors.RdfFileExtractor(instances_examples.nordic44_knowledge_graph))
         return IssueList()
+
+    def pump_example(self) -> IssueList:
+        """Reads the Hello World pump example into the NeatSession."""
+        importer: importers.ExcelImporter = importers.ExcelImporter(catalog.hello_world_pump)
+        return self._state.rule_import(importer)
+
+    def core_data_model(self) -> IssueList:
+        """Reads the core data model example into the NeatSession."""
+
+        cdm_v1 = DataModelId.load(("cdf_cdm", "CogniteCore", "v1"))
+        importer: importers.DMSImporter = importers.DMSImporter.from_data_model_id(self._get_client, cdm_v1)
+        return self._state.rule_import(importer)