cognite-neat 0.106.0__tar.gz → 0.107.0__tar.gz

{cognite_neat-0.106.0 → cognite_neat-0.107.0}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.3
 Name: cognite-neat
-Version: 0.106.0
+Version: 0.107.0
 Summary: Knowledge graph transformation
-Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0
 Author: Nikola Vasiljevic
 Author-email: nikola.vasiljevic@cognite.com
@@ -54,6 +53,7 @@ Requires-Dist: tomli (>=2.0.1,<3.0.0) ; python_version < "3.11"
 Requires-Dist: typing_extensions (>=4.8,<5.0) ; python_version < "3.11"
 Requires-Dist: urllib3 (>=2,<3)
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
+Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Repository, https://github.com/cognitedata/neat
 Description-Content-Type: text/markdown
 

{cognite_neat-0.106.0 → cognite_neat-0.107.0}/cognite/neat/_graph/extractors/__init__.py

@@ -1,6 +1,6 @@
 from cognite.neat._session.engine._interface import Extractor as EngineExtractor
 
-from ._base import BaseExtractor
+from ._base import BaseExtractor, KnowledgeGraphExtractor
 from ._classic_cdf._assets import AssetsExtractor
 from ._classic_cdf._classic import ClassicGraphExtractor
 from ._classic_cdf._data_sets import DataSetExtractor
@@ -12,6 +12,7 @@ from ._classic_cdf._sequences import SequencesExtractor
 from ._classic_cdf._timeseries import TimeSeriesExtractor
 from ._dexpi import DexpiExtractor
 from ._dms import DMSExtractor
+from ._dms_graph import DMSGraphExtractor
 from ._iodd import IODDExtractor
 from ._mock_graph_generator import MockGraphGenerator
 from ._rdf_file import RdfFileExtractor
@@ -21,11 +22,13 @@ __all__ = [
     "BaseExtractor",
     "ClassicGraphExtractor",
     "DMSExtractor",
+    "DMSGraphExtractor",
     "DataSetExtractor",
     "DexpiExtractor",
     "EventsExtractor",
     "FilesExtractor",
     "IODDExtractor",
+    "KnowledgeGraphExtractor",
     "LabelsExtractor",
     "MockGraphGenerator",
     "RdfFileExtractor",
@@ -51,6 +54,7 @@ TripleExtractors = (
     | ClassicGraphExtractor
     | DataSetExtractor
     | EngineExtractor
+    | DMSGraphExtractor
 )
 
 

cognite_neat-0.107.0/cognite/neat/_graph/extractors/_base.py

@@ -0,0 +1,58 @@
+from abc import abstractmethod
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+from rdflib import URIRef
+
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._rules.models import InformationRules
+from cognite.neat._shared import Triple
+from cognite.neat._utils.auxiliary import class_html_doc
+
+if TYPE_CHECKING:
+    from cognite.neat._store._provenance import Agent as ProvenanceAgent
+
+
+class BaseExtractor:
+    """This is the base class for all extractors. It defines the interface that
+    extractors must implement.
+    """
+
+    def _get_activity_names(self) -> list[str]:
+        """Returns the name of the activities that the extractor performs,
+        i.e., the actions that it performs when you call extract().."""
+        # This method can be overridden by subclasses that runs multiple extractors
+        # for example the ClassicGraphExtractor
+        return [type(self).__name__]
+
+    @abstractmethod
+    def extract(self) -> Iterable[Triple]:
+        raise NotImplementedError()
+
+    @classmethod
+    def _repr_html_(cls) -> str:
+        return class_html_doc(cls)
+
+
+class KnowledgeGraphExtractor(BaseExtractor):
+    """A knowledge graph extractor extracts triples with a schema"""
+
+    @abstractmethod
+    def get_information_rules(self) -> InformationRules:
+        """Returns the information rules that the extractor uses."""
+        raise NotImplementedError()
+
+    @property
+    def description(self) -> str:
+        return self.__doc__.strip().split("\n")[0] if self.__doc__ else "Missing"
+
+    @property
+    def source_uri(self) -> URIRef:
+        raise NotImplementedError
+
+    @property
+    def agent(self) -> "ProvenanceAgent":
+        """Provenance agent for the importer."""
+        from cognite.neat._store._provenance import Agent as ProvenanceAgent
+
+        return ProvenanceAgent(id_=DEFAULT_NAMESPACE[f"agent/{type(self).__name__}"])

{cognite_neat-0.106.0 → cognite_neat-0.107.0}/cognite/neat/_graph/extractors/_classic_cdf/_base.py

@@ -89,6 +89,7 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.items = items
@@ -99,6 +100,7 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
         self.skip_metadata_values = skip_metadata_values
         self.camel_case = camel_case
         self.as_write = as_write
+        self.prefix = prefix
 
     def extract(self) -> Iterable[Triple]:
         """Extracts an asset with the given asset_id."""
@@ -174,6 +176,8 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
         type_ = self._default_rdf_type
         if self.to_type:
             type_ = self.to_type(item) or type_
+        if self.prefix:
+            type_ = f"{self.prefix}{type_}"
         return self._SPACE_PATTERN.sub("_", type_)
 
     def _as_object(self, raw: Any, key: str) -> Literal | URIRef:
@@ -218,9 +222,12 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
     ):
         total, items = cls._handle_no_access(lambda: cls._from_dataset(client, data_set_external_id))
-        return cls(items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write)
+        return cls(
+            items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write, prefix
+        )
 
     @classmethod
     @abstractmethod
@@ -241,9 +248,12 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
     ):
         total, items = cls._handle_no_access(lambda: cls._from_hierarchy(client, root_asset_external_id))
-        return cls(items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write)
+        return cls(
+            items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write, prefix
+        )
 
     @classmethod
     @abstractmethod
@@ -263,9 +273,12 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
     ):
         total, items = cls._from_file(file_path)
-        return cls(items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write)
+        return cls(
+            items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write, prefix
+        )
 
     @classmethod
     @abstractmethod

{cognite_neat-0.106.0 → cognite_neat-0.107.0}/cognite/neat/_graph/extractors/_classic_cdf/_classic.py

@@ -1,18 +1,25 @@
 import warnings
 from collections import defaultdict
 from collections.abc import Iterable, Sequence
-from typing import ClassVar, NamedTuple
+from typing import ClassVar, NamedTuple, cast
 
 from cognite.client import CogniteClient
 from cognite.client.exceptions import CogniteAPIError
-from rdflib import Namespace
+from rdflib import Namespace, URIRef
 
-from cognite.neat._constants import CLASSIC_CDF_NAMESPACE
-from cognite.neat._graph.extractors._base import BaseExtractor
+from cognite.neat._constants import CLASSIC_CDF_NAMESPACE, DEFAULT_NAMESPACE, get_default_prefixes_and_namespaces
+from cognite.neat._graph.extractors._base import KnowledgeGraphExtractor
+from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._issues.warnings import CDFAuthWarning
+from cognite.neat._rules._shared import ReadRules
+from cognite.neat._rules.catalog import classic_model
+from cognite.neat._rules.models import InformationInputRules, InformationRules
+from cognite.neat._rules.models._rdfpath import Entity as RDFPathEntity
+from cognite.neat._rules.models._rdfpath import RDFPath, SingleProperty
 from cognite.neat._shared import Triple
 from cognite.neat._utils.collection_ import chunker, iterate_progress_bar
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri
+from cognite.neat._utils.text import to_snake
 
 from ._assets import AssetsExtractor
 from ._base import ClassicCDFBaseExtractor, InstanceIdPrefix
@@ -37,7 +44,7 @@ class _ClassicCoreType(NamedTuple):
     api_name: str
 
 
-class ClassicGraphExtractor(BaseExtractor):
+class ClassicGraphExtractor(KnowledgeGraphExtractor):
     """This extractor extracts all classic CDF Resources.
 
     The Classic Graph consists of the following core resource type.
@@ -93,6 +100,7 @@ class ClassicGraphExtractor(BaseExtractor):
         root_asset_external_id: str | None = None,
         namespace: Namespace | None = None,
         limit_per_type: int | None = None,
+        prefix: str | None = None,
     ):
         self._client = client
         if sum([bool(data_set_external_id), bool(root_asset_external_id)]) != 1:
@@ -101,8 +109,14 @@ class ClassicGraphExtractor(BaseExtractor):
         self._data_set_external_id = data_set_external_id
         self._namespace = namespace or CLASSIC_CDF_NAMESPACE
         self._extractor_args = dict(
-            namespace=self._namespace, unpack_metadata=False, as_write=True, camel_case=True, limit=limit_per_type
+            namespace=self._namespace,
+            unpack_metadata=False,
+            as_write=True,
+            camel_case=True,
+            limit=limit_per_type,
+            prefix=prefix,
         )
+        self._prefix = prefix
         self._limit_per_type = limit_per_type
 
         self._source_external_ids_by_type: dict[InstanceIdPrefix, set[str]] = defaultdict(set)
@@ -144,6 +158,59 @@ class ClassicGraphExtractor(BaseExtractor):
         else:
             self._extracted_data_sets = True
 
+    def get_information_rules(self) -> InformationRules:
+        # To avoid circular imports
+        from cognite.neat._rules.importers import ExcelImporter
+
+        unverified = cast(ReadRules[InformationInputRules], ExcelImporter(classic_model).to_rules())
+        if unverified.rules is None:
+            raise NeatValueError(f"Could not read the classic model rules from {classic_model}.")
+
+        verified = unverified.rules.as_verified_rules()
+        prefixes = get_default_prefixes_and_namespaces()
+        instance_prefix: str | None = next((k for k, v in prefixes.items() if v == self._namespace), None)
+        if instance_prefix is None:
+            # We need to add a new prefix
+            instance_prefix = f"prefix_{len(prefixes) + 1}"
+            prefixes[instance_prefix] = self._namespace
+        verified.prefixes = prefixes
+
+        is_snake_case = self._extractor_args["camel_case"] is False
+        for prop in verified.properties:
+            prop_id = prop.property_
+            if is_snake_case:
+                prop_id = to_snake(prop_id)
+            prop.instance_source = RDFPath(
+                traversal=SingleProperty(
+                    class_=RDFPathEntity(prefix=instance_prefix, suffix=prop.class_.suffix),
+                    property=RDFPathEntity(prefix=instance_prefix, suffix=prop_id),
+                )
+            )
+        return verified
+
+    @property
+    def description(self) -> str:
+        if self._data_set_external_id:
+            source = f"data set {self._data_set_external_id}."
+        elif self._root_asset_external_id:
+            source = f"root asset {self._root_asset_external_id}."
+        else:
+            source = "unknown source."
+        return f"Extracting clasic CDF Graph (Assets, TimeSeries, Sequences, Events, Files) from {source}."
+
+    @property
+    def source_uri(self) -> URIRef:
+        if self._data_set_external_id:
+            resource = "dataset"
+            external_id = self._data_set_external_id
+        elif self._root_asset_external_id:
+            resource = "asset"
+            external_id = self._root_asset_external_id
+        else:
+            resource = "unknown"
+            external_id = "unknown"
+        return DEFAULT_NAMESPACE[f"{self._client.config.project}/{resource}/{external_id}"]
+
     def _extract_core_start_nodes(self):
         for core_node in self._classic_node_types:
             if self._data_set_external_id:
@@ -217,7 +284,7 @@ class ClassicGraphExtractor(BaseExtractor):
                 self._source_external_ids_by_type[resource_type].add(remove_namespace_from_uri(triple[2]))
             elif triple[1] == self._namespace.labels:
                 self._labels.add(remove_namespace_from_uri(triple[2]).removeprefix(InstanceIdPrefix.label))
-            elif triple[1] == self._namespace.datasetId:
+            elif triple[1] == self._namespace.dataSetId:
                 self._data_set_ids.add(
                     int(remove_namespace_from_uri(triple[2]).removeprefix(InstanceIdPrefix.data_set))
                 )

{cognite_neat-0.106.0 → cognite_neat-0.107.0}/cognite/neat/_graph/extractors/_classic_cdf/_relationships.py

@@ -28,6 +28,7 @@ class RelationshipsExtractor(ClassicCDFBaseExtractor[Relationship]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
     ):
         super().__init__(
             items,
@@ -39,6 +40,7 @@ class RelationshipsExtractor(ClassicCDFBaseExtractor[Relationship]):
             skip_metadata_values=skip_metadata_values,
             camel_case=camel_case,
             as_write=as_write,
+            prefix=prefix,
         )
         # This is used by the ClassicExtractor to log the target nodes, such
         # that it can extract them.

{cognite_neat-0.106.0 → cognite_neat-0.107.0}/cognite/neat/_graph/extractors/_classic_cdf/_sequences.py

@@ -52,10 +52,11 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
         unpack_columns: bool = False,
     ):
         super().__init__(
-            items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write
+            items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write, prefix
         )
         self.unpack_columns = unpack_columns
 
@@ -71,6 +72,7 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
         unpack_columns: bool = False,
     ):
         total, items = cls._handle_no_access(lambda: cls._from_dataset(client, data_set_external_id))
@@ -84,6 +86,7 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
             skip_metadata_values,
             camel_case,
             as_write,
+            prefix,
             unpack_columns,
         )
 
@@ -99,6 +102,7 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
         unpack_columns: bool = False,
     ):
         total, items = cls._handle_no_access(lambda: cls._from_hierarchy(client, root_asset_external_id))
@@ -112,6 +116,7 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
             skip_metadata_values,
             camel_case,
             as_write,
+            prefix,
             unpack_columns,
         )
 
@@ -126,6 +131,7 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
         unpack_columns: bool = False,
     ):
         total, items = cls._from_file(file_path)
@@ -139,6 +145,7 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
             skip_metadata_values,
             camel_case,
             as_write,
+            prefix,
             unpack_columns,
         )
 

{cognite_neat-0.106.0 → cognite_neat-0.107.0}/cognite/neat/_graph/extractors/_dms.py

@@ -1,3 +1,4 @@
+import urllib.parse
 from collections.abc import Iterable, Iterator
 from typing import cast
 
@@ -5,6 +6,7 @@ from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 from cognite.client.data_classes.data_modeling.instances import Instance, PropertyValue
+from cognite.client.utils.useful_types import SequenceNotStr
 from rdflib import RDF, XSD, Literal, Namespace, URIRef
 
 from cognite.neat._constants import DEFAULT_SPACE_URI
@@ -38,7 +40,12 @@ class DMSExtractor(BaseExtractor):
 
     @classmethod
     def from_data_model(
-        cls, client: CogniteClient, data_model: DataModelIdentifier, limit: int | None = None
+        cls,
+        client: CogniteClient,
+        data_model: DataModelIdentifier,
+        limit: int | None = None,
+        overwrite_namespace: Namespace | None = None,
+        instance_space: str | SequenceNotStr[str] | None = None,
     ) -> "DMSExtractor":
         """Create an extractor from a data model.
 
@@ -46,22 +53,38 @@ class DMSExtractor(BaseExtractor):
             client: The Cognite client to use.
             data_model: The data model to extract.
             limit: The maximum number of instances to extract.
+            overwrite_namespace: If provided, this will overwrite the space of the extracted items.
+            instance_space: The space to extract instances from.
         """
         retrieved = client.data_modeling.data_models.retrieve(data_model, inline_views=True)
         if not retrieved:
             raise ResourceRetrievalError(dm.DataModelId.load(data_model), "data model", "Data Model is missing in CDF")
-        return cls.from_views(client, retrieved.latest_version().views, limit)
+        return cls.from_views(client, retrieved.latest_version().views, limit, overwrite_namespace, instance_space)
 
     @classmethod
-    def from_views(cls, client: CogniteClient, views: Iterable[dm.View], limit: int | None = None) -> "DMSExtractor":
+    def from_views(
+        cls,
+        client: CogniteClient,
+        views: Iterable[dm.View],
+        limit: int | None = None,
+        overwrite_namespace: Namespace | None = None,
+        instance_space: str | SequenceNotStr[str] | None = None,
+    ) -> "DMSExtractor":
         """Create an extractor from a set of views.
 
         Args:
             client: The Cognite client to use.
             views: The views to extract.
             limit: The maximum number of instances to extract.
+            overwrite_namespace: If provided, this will overwrite the space of the extracted items.
+            instance_space: The space to extract instances from.
         """
-        return cls(_InstanceIterator(client, views), total=None, limit=limit)
+        return cls(
+            _InstanceIterator(client, views, instance_space),
+            total=None,
+            limit=limit,
+            overwrite_namespace=overwrite_namespace,
+        )
 
     def extract(self) -> Iterable[Triple]:
         for count, item in enumerate(self.items, 1):
@@ -105,6 +128,10 @@ class DMSExtractor(BaseExtractor):
         else:
             raise NotImplementedError(f"Unknown instance type {type(instance)}")
 
+        if self.overwrite_namespace:
+            # If the namespace is overwritten, keep the original space as a property to avoid losing information.
+            yield id_, self._get_namespace(instance.space)["space"], Literal(instance.space)
+
         for view_id, properties in instance.properties.items():
             namespace = self._get_namespace(view_id.space)
             for key, value in properties.items():
@@ -124,35 +151,42 @@ class DMSExtractor(BaseExtractor):
                 yield from self._get_objects(item)
 
     def _as_uri_ref(self, instance: Instance | dm.DirectRelationReference) -> URIRef:
-        return self._get_namespace(instance.space)[instance.external_id]
+        return self._get_namespace(instance.space)[urllib.parse.quote(instance.external_id)]
 
     def _get_namespace(self, space: str) -> Namespace:
         if self.overwrite_namespace:
             return self.overwrite_namespace
-        return Namespace(DEFAULT_SPACE_URI.format(space=space))
+        return Namespace(DEFAULT_SPACE_URI.format(space=urllib.parse.quote(space)))
 
 
-class _InstanceIterator(Iterator[Instance]):
-    def __init__(self, client: CogniteClient, views: Iterable[dm.View]):
+class _InstanceIterator(Iterable[Instance]):
+    def __init__(
+        self, client: CogniteClient, views: Iterable[dm.View], instance_space: str | SequenceNotStr[str] | None = None
+    ):
         self.client = client
         self.views = views
+        self.instance_space = instance_space
 
     def __iter__(self) -> Iterator[Instance]:
-        return self
-
-    def __next__(self) -> Instance:  # type: ignore[misc]
         for view in self.views:
+            view_id = view.as_id()
             # All nodes and edges with properties
-            yield from self.client.data_modeling.instances(chunk_size=None, instance_type="node", sources=[view])
-            yield from self.client.data_modeling.instances(chunk_size=None, instance_type="edge", sources=[view])
+            if view.used_for in ("node", "all"):
+                yield from self.client.data_modeling.instances(
+                    chunk_size=None, instance_type="node", sources=[view_id], space=self.instance_space
+                )
+            if view.used_for in ("edge", "all"):
+                yield from self.client.data_modeling.instances(
+                    chunk_size=None, instance_type="edge", sources=[view_id], space=self.instance_space
+                )
 
             for prop in view.properties.values():
                 if isinstance(prop, dm.EdgeConnection):
-                    # Get all edges with properties
                     yield from self.client.data_modeling.instances(
                         chunk_size=None,
                         instance_type="edge",
                         filter=dm.filters.Equals(
                             ["edge", "type"], {"space": prop.type.space, "externalId": prop.type.external_id}
                         ),
+                        space=self.instance_space,
                     )

cognite_neat-0.107.0/cognite/neat/_graph/extractors/_dms_graph.py

@@ -0,0 +1,149 @@
+from collections.abc import Iterable, Sequence
+
+from cognite.client import data_modeling as dm
+from cognite.client.exceptions import CogniteAPIError
+from cognite.client.utils.useful_types import SequenceNotStr
+from rdflib import Namespace, URIRef
+
+from cognite.neat._client import NeatClient
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._issues import IssueList, NeatIssue, catch_warnings
+from cognite.neat._issues.warnings import CDFAuthWarning, ResourceNotFoundWarning, ResourceRetrievalWarning
+from cognite.neat._rules.importers import DMSImporter
+from cognite.neat._rules.models import DMSRules, InformationRules
+from cognite.neat._rules.transformers import DMSToInformation, VerifyDMSRules
+from cognite.neat._shared import Triple
+
+from ._base import KnowledgeGraphExtractor
+from ._dms import DMSExtractor
+
+
+class DMSGraphExtractor(KnowledgeGraphExtractor):
+    def __init__(
+        self,
+        data_model: dm.DataModel[dm.View],
+        client: NeatClient,
+        namespace: Namespace = DEFAULT_NAMESPACE,
+        issues: Sequence[NeatIssue] | None = None,
+        instance_space: str | SequenceNotStr[str] | None = None,
+    ) -> None:
+        self._client = client
+        self._data_model = data_model
+        self._namespace = namespace or DEFAULT_NAMESPACE
+        self._issues = IssueList(issues)
+        self._instance_space = instance_space
+
+        self._views: list[dm.View] | None = None
+        self._information_rules: InformationRules | None = None
+        self._dms_rules: DMSRules | None = None
+
+    @classmethod
+    def from_data_model_id(
+        cls,
+        data_model_id: dm.DataModelIdentifier,
+        client: NeatClient,
+        namespace: Namespace = DEFAULT_NAMESPACE,
+        instance_space: str | SequenceNotStr[str] | None = None,
+    ) -> "DMSGraphExtractor":
+        issues: list[NeatIssue] = []
+        try:
+            data_model = client.data_modeling.data_models.retrieve(data_model_id, inline_views=True)
+        except CogniteAPIError as e:
+            issues.append(CDFAuthWarning("retrieving data model", str(e)))
+            return cls(
+                cls._create_empty_model(dm.DataModelId.load(data_model_id)), client, namespace, issues, instance_space
+            )
+        if not data_model:
+            issues.append(ResourceRetrievalWarning(frozenset({data_model_id}), "data model"))
+            return cls(
+                cls._create_empty_model(dm.DataModelId.load(data_model_id)), client, namespace, issues, instance_space
+            )
+        return cls(data_model.latest_version(), client, namespace, issues, instance_space)
+
+    @classmethod
+    def _create_empty_model(cls, data_model_id: dm.DataModelId) -> dm.DataModel:
+        return dm.DataModel(
+            data_model_id.space,
+            data_model_id.external_id,
+            data_model_id.version or "MISSING",
+            is_global=False,
+            last_updated_time=0,
+            created_time=0,
+            description=None,
+            name=None,
+            views=[],
+        )
+
+    @property
+    def _model_views(self) -> list[dm.View]:
+        if self._views is None:
+            self._views = self._get_views()
+        return self._views
+
+    @property
+    def description(self) -> str:
+        return "Extracts a data model with nodes and edges."
+
+    @property
+    def source_uri(self) -> URIRef:
+        space, external_id, version = self._data_model.as_id().as_tuple()
+        return DEFAULT_NAMESPACE[f"{self._client.config.project}/{space}/{external_id}/{version}"]
+
+    def extract(self) -> Iterable[Triple]:
+        """Extracts the knowledge graph from the data model."""
+        views = self._model_views
+        yield from DMSExtractor.from_views(
+            self._client,
+            views,
+            overwrite_namespace=self._namespace,
+            instance_space=self._instance_space,
+        ).extract()
+
+    def _get_views(self) -> list[dm.View]:
+        view_by_id: dict[dm.ViewId, dm.View] = {}
+        if view_ids := [view_id for view_id in self._data_model.views if isinstance(view_id, dm.ViewId)]:
+            try:
+                # MyPy does not understand the isinstance check above.
+                retrieved = self._client.data_modeling.views.retrieve(ids=view_ids)  #  type: ignore[arg-type]
+            except CogniteAPIError as e:
+                self._issues.append(CDFAuthWarning("retrieving views", str(e)))
+            else:
+                view_by_id.update({view.as_id(): view for view in retrieved})
+        views: list[dm.View] = []
+        data_model_id = self._data_model.as_id()
+        for dm_view in self._data_model.views:
+            if isinstance(dm_view, dm.View):
+                views.append(dm_view)
+            elif isinstance(dm_view, dm.ViewId):
+                if view := view_by_id.get(dm_view):
+                    views.append(view)
+                else:
+                    self._issues.append(ResourceNotFoundWarning(dm_view, "view", data_model_id, "data model"))
+        return views
+
+    def get_information_rules(self) -> InformationRules:
+        """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_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_issues(self) -> IssueList:
+        """Returns the issues that occurred during the extraction."""
+        return self._issues
+
+    def _create_rules(self) -> tuple[InformationRules, 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()
+        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)
+        self._issues.extend(issues)
+        return information_rules, verified_dms