cognite-neat 0.98.0__py3-none-any.whl → 0.99.1__py3-none-any.whl

cognite/neat/_issues/warnings/_resources.py

@@ -24,6 +24,30 @@ class ResourceNotFoundWarning(ResourceNeatWarning, Generic[T_Identifier, T_Refer
     referred_type: str
 
 
+@dataclass(unsafe_hash=True)
+class ResourceNotDefinedWarning(ResourceNeatWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} {identifier} is not defined in the {location}"""
+
+    extra = "{column_name} {row_number} in {sheet_name}"
+    fix = "Define the {resource_type} {identifier} in {location}."
+
+    location: str
+    column_name: str | None = None
+    row_number: int | None = None
+    sheet_name: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class ResourceRedefinedWarning(ResourceNeatWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} {identifier} feature {feature} is being redefine from {current_value} to {new_value}.
+    This will be ignored."""
+
+    fix = "Avoid redefinition {resource_type} features"
+    feature: str
+    current_value: str
+    new_value: str
+
+
 @dataclass(unsafe_hash=True)
 class ResourcesDuplicatedWarning(NeatWarning, Generic[T_Identifier]):
     """Duplicated {resource_type} with identifiers {resources} were found. {default_action}"""
@@ -37,12 +61,12 @@ class ResourcesDuplicatedWarning(NeatWarning, Generic[T_Identifier]):
 
 @dataclass(unsafe_hash=True)
 class ResourceRetrievalWarning(NeatWarning, Generic[T_Identifier]):
-    """Failed to retrieve {resource_type} with identifiers {resources}. Continuing without
+    """Failed to retrieve {resource_type} with identifier(s) {resources}. Continuing without
     these resources."""
 
     extra = "The error was: {error}"
 
-    fix = "Check the error."
+    fix = "Check the error and fix accordingly."
 
     resources: frozenset[T_Identifier]
     resource_type: ResourceType

cognite/neat/_issues/warnings/user_modeling.py

@@ -17,7 +17,7 @@ __all__ = [
     "HasDataFilterOnNoPropertiesViewWarning",
     "NodeTypeFilterOnParentViewWarning",
     "HasDataFilterOnViewWithReferencesWarning",
-    "ViewPropertyLimitWarning",
+    "ContainerPropertyLimitWarning",
     "NotNeatSupportedFilterWarning",
     "ParentInDifferentSpaceWarning",
 ]
@@ -89,15 +89,15 @@ class HasDataFilterOnViewWithReferencesWarning(UserModelingWarning):
 
 
 @dataclass(unsafe_hash=True)
-class ViewPropertyLimitWarning(UserModelingWarning):
-    """The number of properties in the {view_id} view is {count} which
+class ContainerPropertyLimitWarning(UserModelingWarning):
+    """The number of properties in the {container_id} view is {count} which
     is more than the API limit {limit} properties.
     This can lead to performance issues.
     Reduce the number of properties in the view."""
 
     fix = "Reduce the number of properties in the view"
 
-    view_id: ViewId
+    container_id: ContainerId
     count: int
     limit: int = DMS_CONTAINER_PROPERTY_SIZE_LIMIT
 

cognite/neat/_rules/_constants.py

@@ -1,6 +1,7 @@
 import re
 import sys
 from functools import cached_property
+from typing import Literal
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -42,7 +43,7 @@ class EntityTypes(StrEnum):
     space = "space"
 
 
-def get_reserved_words() -> dict[str, list[str]]:
+def get_reserved_words(key: Literal["class", "view", "property", "space"]) -> list[str]:
     return {
         "class": ["Class", "class"],
         "view": [
@@ -82,7 +83,7 @@ def get_reserved_words() -> dict[str, list[str]]:
             "extensions",
         ],
         "space": ["space", "cdf", "dms", "pg3", "shared", "system", "node", "edge"],
-    }
+    }[key]
 
 
 ENTITY_PATTERN = re.compile(r"^(?P<prefix>.*?):?(?P<suffix>[^(:]*)(\((?P<content>.+)\))?$")
@@ -93,25 +94,21 @@ MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX = r"([_-]{2,})"
 PREFIX_COMPLIANCE_REGEX = r"^([a-zA-Z]+)([a-zA-Z0-9]*[_-]{0,1}[a-zA-Z0-9_-]*)([a-zA-Z0-9]*)$"
 
 SPACE_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['space'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('space'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$)"
 )
 
 
 DATA_MODEL_COMPLIANCE_REGEX = r"^[a-zA-Z]([a-zA-Z0-9_]{0,253}[a-zA-Z0-9])?$"
 
 VIEW_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['view'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('view'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
 )
 DMS_PROPERTY_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['property'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
-)
-CLASS_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['class'])})$)" r"(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('property'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
 )
+CLASS_ID_COMPLIANCE_REGEX = rf"(?!^({'|'.join(get_reserved_words('class'))})$)" r"(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 
-INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX = (
-    r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
-)
+INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX = r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
 
 

cognite/neat/_rules/analysis/_base.py

@@ -109,14 +109,14 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
         raise NotImplementedError
 
     # Todo Lru cache this method.
-    def class_parent_pairs(self) -> dict[T_ClassEntity, list[T_ClassEntity]]:
+    def class_parent_pairs(self, allow_different_space: bool = False) -> dict[T_ClassEntity, list[T_ClassEntity]]:
         """This only returns class - parent pairs only if parent is in the same data model"""
         class_subclass_pairs: dict[T_ClassEntity, list[T_ClassEntity]] = {}
         for cls_ in self._get_classes():
             entity = self._get_cls_entity(cls_)
             class_subclass_pairs[entity] = []
             for parent in self._get_cls_parents(cls_) or []:
-                if parent.prefix == entity.prefix:
+                if parent.prefix == entity.prefix or allow_different_space:
                     class_subclass_pairs[entity].append(parent)
                 else:
                     warnings.warn(
@@ -126,11 +126,15 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
 
         return class_subclass_pairs
 
-    def classes_with_properties(self, consider_inheritance: bool = False) -> dict[T_ClassEntity, list[T_Property]]:
+    def classes_with_properties(
+        self, consider_inheritance: bool = False, allow_different_namespace: bool = False
+    ) -> dict[T_ClassEntity, list[T_Property]]:
         """Returns classes that have been defined in the data model.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
+            allow_different_namespace: When considering inheritance, whether to allow parents from
+                different namespaces or not. Defaults False
 
         Returns:
             Dictionary of classes with a list of properties defined for them
@@ -150,7 +154,7 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
             class_property_pairs[self._get_cls_entity(property_)].append(property_)  # type: ignore
 
         if consider_inheritance:
-            class_parent_pairs = self.class_parent_pairs()
+            class_parent_pairs = self.class_parent_pairs(allow_different_namespace)
             for class_ in class_parent_pairs:
                 self._add_inherited_properties(class_, class_property_pairs, class_parent_pairs)
 

cognite/neat/_rules/exporters/_base.py

@@ -3,8 +3,7 @@ from collections.abc import Iterable
 from pathlib import Path
 from typing import Generic, TypeVar
 
-from cognite.client import CogniteClient
-
+from cognite.neat._client import NeatClient
 from cognite.neat._rules._shared import T_VerifiedRules
 from cognite.neat._utils.auxiliary import class_html_doc
 from cognite.neat._utils.upload import UploadResult, UploadResultList
@@ -32,11 +31,11 @@ class BaseExporter(ABC, Generic[T_VerifiedRules, T_Export]):
 class CDFExporter(BaseExporter[T_VerifiedRules, T_Export]):
     @abstractmethod
     def export_to_cdf_iterable(
-        self, rules: T_VerifiedRules, client: CogniteClient, dry_run: bool = False, fallback_one_by_one: bool = False
+        self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
     ) -> Iterable[UploadResult]:
         raise NotImplementedError
 
     def export_to_cdf(
-        self, rules: T_VerifiedRules, client: CogniteClient, dry_run: bool = False, fallback_one_by_one: bool = False
+        self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
     ) -> UploadResultList:
         return UploadResultList(self.export_to_cdf_iterable(rules, client, dry_run, fallback_one_by_one))

cognite/neat/_rules/exporters/_rules2dms.py

@@ -3,7 +3,6 @@ from collections.abc import Collection, Hashable, Iterable, Sequence
 from pathlib import Path
 from typing import Literal, TypeAlias, cast
 
-from cognite.client import CogniteClient
 from cognite.client.data_classes._base import CogniteResource, CogniteResourceList
 from cognite.client.data_classes.data_modeling import (
     ContainerApplyList,
@@ -15,23 +14,14 @@ from cognite.client.data_classes.data_modeling import (
 )
 from cognite.client.exceptions import CogniteAPIError
 
+from cognite.neat._client import DataModelingLoader, NeatClient
+from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.warnings import (
     PrincipleOneModelOneSpaceWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat._rules.models.dms import DMSRules, DMSSchema, PipelineSchema
-from cognite.neat._utils.cdf.loaders import (
-    ContainerLoader,
-    DataModelingLoader,
-    DataModelLoader,
-    RawDatabaseLoader,
-    RawTableLoader,
-    ResourceLoader,
-    SpaceLoader,
-    TransformationLoader,
-    ViewLoader,
-)
+from cognite.neat._rules.models.dms import DMSRules
 from cognite.neat._utils.upload import UploadResult
 
 from ._base import CDFExporter
@@ -49,8 +39,6 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
             If set, only export components in the given spaces. Defaults to None which means all spaces.
         existing_handling (Literal["fail", "skip", "update", "force"], optional): How to handle existing components.
             Defaults to "update". See below for details.
-        export_pipeline (bool, optional): Whether to export the pipeline. Defaults to False. This means setting
-            up transformations, RAW databases and tables to populate the data model.
         instance_space (str, optional): The space to use for the instance. Defaults to None.
         suppress_warnings (bool, optional): Suppress warnings. Defaults to False.
 
@@ -68,14 +56,12 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         export_components: Component | Collection[Component] = "all",
         include_space: set[str] | None = None,
         existing_handling: Literal["fail", "skip", "update", "force"] = "update",
-        export_pipeline: bool = False,
         instance_space: str | None = None,
         suppress_warnings: bool = False,
     ):
         self.export_components = {export_components} if isinstance(export_components, str) else set(export_components)
         self.include_space = include_space
         self.existing_handling = existing_handling
-        self.export_pipeline = export_pipeline
         self.instance_space = instance_space
         self.suppress_warnings = suppress_warnings
         self._schema: DMSSchema | None = None
@@ -116,17 +102,19 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         return exclude
 
     def export(self, rules: DMSRules) -> DMSSchema:
-        return rules.as_schema(include_pipeline=self.export_pipeline, instance_space=self.instance_space)
+        # We do not want to include CogniteCore/CogniteProcess Inudstries in the schema
+        return rules.as_schema(instance_space=self.instance_space, remove_cdf_spaces=True)
 
     def delete_from_cdf(
-        self, rules: DMSRules, client: CogniteClient, dry_run: bool = False, skip_space: bool = False
+        self, rules: DMSRules, client: NeatClient, dry_run: bool = False, skip_space: bool = False
     ) -> Iterable[UploadResult]:
-        to_export = self._prepare_exporters(rules, client)
+        to_export = self._prepare_exporters(rules)
 
         # we need to reverse order in which we are picking up the items to delete
         # as they are sorted in the order of creation and we need to delete them in reverse order
-        for items, loader in reversed(to_export):
-            if skip_space and isinstance(loader, SpaceLoader):
+        for items in reversed(to_export):
+            loader = client.loaders.get_loader(items)
+            if skip_space and isinstance(items, SpaceApplyList):
                 continue
             item_ids = loader.get_ids(items)
             existing_items = loader.retrieve(item_ids)
@@ -166,9 +154,9 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
             )
 
     def export_to_cdf_iterable(
-        self, rules: DMSRules, client: CogniteClient, dry_run: bool = False, fallback_one_by_one: bool = False
+        self, rules: DMSRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
     ) -> Iterable[UploadResult]:
-        to_export = self._prepare_exporters(rules, client)
+        to_export = self._prepare_exporters(rules)
 
         result_by_name = {}
         if self.existing_handling == "force":
@@ -176,17 +164,18 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 result_by_name[delete_result.name] = delete_result
 
         redeploy_data_model = False
-        for items, loader in to_export:
+        for items in to_export:
             # The conversion from DMS to GraphQL does not seem to be triggered even if the views
             # are changed. This is a workaround to force the conversion.
-            is_redeploying = loader is DataModelingLoader and redeploy_data_model
+            is_redeploying = isinstance(items, DataModelApplyList) and redeploy_data_model
+            loader = client.loaders.get_loader(items)
 
             to_create, to_delete, to_update, unchanged = self._categorize_items_for_upload(
                 loader, items, is_redeploying
             )
 
             issue_list = IssueList()
-            warning_list = self._validate(loader, items)
+            warning_list = self._validate(loader, items, client)
             issue_list.extend(warning_list)
 
             created: set[Hashable] = set()
@@ -206,6 +195,8 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                     failed_changed.update(loader.get_id(item) for item in to_update)
                 else:
                     raise ValueError(f"Unsupported existing_handling {self.existing_handling}")
+                created.update(loader.get_id(item) for item in to_create)
+                deleted.update(loader.get_id(item) for item in to_delete)
             else:
                 if to_delete:
                     try:
@@ -226,7 +217,7 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                     else:
                         deleted.update(loader.get_id(item) for item in to_delete)
 
-                if isinstance(loader, DataModelingLoader):
+                if isinstance(items, DataModelApplyList):
                     to_create = loader.sort_by_dependencies(to_create)
 
                 try:
@@ -292,11 +283,11 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 issues=issue_list,
             )
 
-            if loader is ViewLoader and (created or changed):
+            if isinstance(items, ViewApplyList) and (created or changed):
                 redeploy_data_model = True
 
     def _categorize_items_for_upload(
-        self, loader: ResourceLoader, items: Sequence[CogniteResource], is_redeploying
+        self, loader: DataModelingLoader, items: Sequence[CogniteResource], is_redeploying
     ) -> tuple[list[CogniteResource], list[CogniteResource], list[CogniteResource], list[CogniteResource]]:
         item_ids = loader.get_ids(items)
         cdf_items = loader.retrieve(item_ids)
@@ -304,7 +295,7 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         to_create, to_update, unchanged, to_delete = [], [], [], []
         for item in items:
             if (
-                isinstance(loader, DataModelingLoader)
+                isinstance(items, DataModelApplyList)
                 and self.include_space is not None
                 and not loader.in_space(item, self.include_space)
             ):
@@ -322,28 +313,24 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 to_update.append(item)
         return to_create, to_delete, to_update, unchanged
 
-    def _prepare_exporters(self, rules, client) -> list[tuple[CogniteResourceList, ResourceLoader]]:
+    def _prepare_exporters(self, rules: DMSRules) -> list[CogniteResourceList]:
         schema = self.export(rules)
-        to_export: list[tuple[CogniteResourceList, ResourceLoader]] = []
+        to_export: list[CogniteResourceList] = []
         if self.export_components.intersection({"all", "spaces"}):
-            to_export.append((SpaceApplyList(schema.spaces.values()), SpaceLoader(client)))
+            to_export.append(SpaceApplyList(schema.spaces.values()))
         if self.export_components.intersection({"all", "containers"}):
-            to_export.append((ContainerApplyList(schema.containers.values()), ContainerLoader(client)))
+            to_export.append(ContainerApplyList(schema.containers.values()))
         if self.export_components.intersection({"all", "views"}):
-            to_export.append((ViewApplyList(schema.views.values()), ViewLoader(client, self.existing_handling)))
+            to_export.append(ViewApplyList(schema.views.values()))
         if self.export_components.intersection({"all", "data_models"}):
-            to_export.append((DataModelApplyList([schema.data_model]), DataModelLoader(client)))
-        if isinstance(schema, PipelineSchema):
-            to_export.append((schema.databases, RawDatabaseLoader(client)))
-            to_export.append((schema.raw_tables, RawTableLoader(client)))
-            to_export.append((schema.transformations, TransformationLoader(client)))
+            to_export.append(DataModelApplyList([schema.data_model]))
         return to_export
 
-    def _validate(self, loader: ResourceLoader, items: CogniteResourceList) -> IssueList:
+    def _validate(self, loader: DataModelingLoader, items: CogniteResourceList, client: NeatClient) -> IssueList:
         issue_list = IssueList()
-        if isinstance(loader, DataModelLoader):
+        if isinstance(items, DataModelApplyList):
             models = cast(list[DataModelApply], items)
-            if other_models := self._exist_other_data_models(loader, models):
+            if other_models := self._exist_other_data_models(client, models):
                 warning = PrincipleOneModelOneSpaceWarning(
                     f"There are multiple data models in the same space {models[0].space}. "
                     f"Other data models in the space are {other_models}.",
@@ -355,13 +342,13 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         return issue_list
 
     @classmethod
-    def _exist_other_data_models(cls, loader: DataModelLoader, models: list[DataModelApply]) -> list[DataModelId]:
+    def _exist_other_data_models(cls, client: NeatClient, models: list[DataModelApply]) -> list[DataModelId]:
         if not models:
             return []
         space = models[0].space
         external_id = models[0].external_id
         try:
-            data_models = loader.client.data_modeling.data_models.list(space=space, limit=25, all_versions=False)
+            data_models = client.data_modeling.data_models.list(space=space, limit=25, all_versions=False)
         except CogniteAPIError as e:
             warnings.warn(ResourceRetrievalWarning(frozenset({space}), "space", str(e)), stacklevel=2)
             return []

cognite/neat/_rules/importers/__init__.py

@@ -1,9 +1,7 @@
 from ._base import BaseImporter
 from ._dms2rules import DMSImporter
 from ._dtdl2rules import DTDLImporter
-from ._rdf._imf2rules import IMFImporter
-from ._rdf._inference2rules import InferenceImporter
-from ._rdf._owl2rules import OWLImporter
+from ._rdf import IMFImporter, InferenceImporter, OWLImporter
 from ._spreadsheet2rules import ExcelImporter, GoogleSheetImporter
 from ._yaml2rules import YAMLImporter
 

cognite/neat/_rules/importers/_base.py

@@ -85,7 +85,7 @@ def _handle_issues(
         try:
             yield future_result
         except ValidationError as e:
-            issues.extend(error_cls.from_pydantic_errors(e.errors(), **(error_args or {})))
+            issues.extend(error_cls.from_errors(e.errors(), **(error_args or {})))  # type: ignore[arg-type]
             future_result._result = "failure"
         else:
             future_result._result = "success"

cognite/neat/_rules/importers/_dms2rules.py

@@ -4,7 +4,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Literal, cast
 
-from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex, InvertedIndex
@@ -19,6 +18,7 @@ from cognite.client.data_classes.data_modeling.views import (
 )
 from cognite.client.utils import ms_to_datetime
 
+from cognite.neat._client import NeatClient
 from cognite.neat._issues import IssueList, NeatIssue
 from cognite.neat._issues.errors import FileTypeUnexpectedError, ResourceMissingIdentifierError, ResourceRetrievalError
 from cognite.neat._issues.warnings import (
@@ -80,9 +80,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         self.issue_list = IssueList(read_issues)
         self._all_containers_by_id = schema.containers.copy()
         self._all_views_by_id = schema.views.copy()
-        if schema.reference:
-            self._all_containers_by_id.update(schema.reference.containers.items())
-            self._all_views_by_id.update(schema.reference.views.items())
 
     def update_referenced_containers(self, containers: Iterable[dm.ContainerApply]) -> None:
         """Update the referenced containers. This is useful to add Cognite containers identified after the root schema
@@ -95,9 +92,8 @@ class DMSImporter(BaseImporter[DMSInputRules]):
     @classmethod
     def from_data_model_id(
         cls,
-        client: CogniteClient,
+        client: NeatClient,
         data_model_id: DataModelIdentifier,
-        reference_model_id: DataModelIdentifier | None = None,
     ) -> "DMSImporter":
         """Create a DMSImporter ready to convert the given data model to rules.
 
@@ -111,7 +107,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             DMSImporter: DMSImporter instance
         """
 
-        data_model_ids = [data_model_id, reference_model_id] if reference_model_id else [data_model_id]
+        data_model_ids = [data_model_id]
         data_models = client.data_modeling.data_models.retrieve(data_model_ids, inline_views=True)
 
         user_models = cls._find_model_in_list(data_models, data_model_id)
@@ -128,34 +124,16 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             )
         user_model = user_models.latest_version()
 
-        if reference_model_id:
-            ref_models = cls._find_model_in_list(data_models, reference_model_id)
-            if len(ref_models) == 0:
-                return cls(
-                    DMSSchema(),
-                    [
-                        ResourceRetrievalError(
-                            dm.DataModelId.load(reference_model_id),
-                            "data model",
-                            "Data Model is missing in CDF",
-                        )
-                    ],
-                )
-            ref_model: dm.DataModel[dm.View] | None = ref_models.latest_version()
-        else:
-            ref_model = None
-
         issue_list = IssueList()
         with _handle_issues(issue_list) as result:
-            schema = DMSSchema.from_data_model(client, user_model, ref_model)
+            schema = NeatClient(client).schema.retrieve_data_model(user_model)
 
         if result.result == "failure" or issue_list.has_errors:
             return cls(DMSSchema(), issue_list)
 
-        metadata = cls._create_metadata_from_model(user_model, has_reference=ref_model is not None)
-        ref_metadata = cls._create_metadata_from_model(ref_model) if ref_model else None
+        metadata = cls._create_metadata_from_model(user_model)
 
-        return cls(schema, issue_list, metadata, ref_metadata)
+        return cls(schema, issue_list, metadata, None)
 
     @classmethod
     def _find_model_in_list(
@@ -174,7 +152,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
     def _create_metadata_from_model(
         cls,
         model: dm.DataModel[dm.View] | dm.DataModelApply,
-        has_reference: bool = False,
     ) -> DMSInputMetadata:
         description, creator = DMSInputMetadata._get_description_and_creator(model.description)
 

cognite/neat/_rules/importers/_rdf/__init__.py

@@ -0,0 +1,5 @@
+from ._imf2rules import IMFImporter
+from ._inference2rules import InferenceImporter
+from ._owl2rules import OWLImporter
+
+__all__ = ["IMFImporter", "OWLImporter", "InferenceImporter"]

cognite/neat/_rules/importers/_rdf/_base.py

@@ -1,13 +1,16 @@
+from datetime import datetime
 from pathlib import Path
 
 from cognite.client import data_modeling as dm
-from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SH, SKOS, XSD, Graph, Namespace, URIRef
+from rdflib import Graph, Namespace, URIRef
 
+from cognite.neat._constants import get_default_prefixes
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import FileReadError
 from cognite.neat._issues.errors._general import NeatValueError
 from cognite.neat._rules._shared import ReadRules
 from cognite.neat._rules.importers._base import BaseImporter
+from cognite.neat._rules.models._base_rules import RoleTypes
 from cognite.neat._rules.models.data_types import AnyURI
 from cognite.neat._rules.models.entities import UnknownEntity
 from cognite.neat._rules.models.information import (
@@ -30,6 +33,13 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         graph: Knowledge graph
         data_model_id: Data model id to be used for the imported rules
         space: CDF Space to be used for the imported rules
+        language: Language for description and human readable entity names
+
+
+
+    !!! note "Language"
+        Language is provided as ISO 639-1 code. If not provided, English will be used as default.
+
     """
 
     def __init__(
@@ -39,6 +49,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         data_model_id: dm.DataModelId | tuple[str, str, str],
         max_number_of_instance: int,
         non_existing_node_type: UnknownEntity | AnyURI,
+        language: str,
     ) -> None:
         self.issue_list = issue_list
         self.graph = graph
@@ -48,6 +59,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
 
         self.max_number_of_instance = max_number_of_instance
         self.non_existing_node_type = non_existing_node_type
+        self.language = language
 
     @classmethod
     def from_graph_store(
@@ -56,6 +68,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_RDF_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
+        language: str = "en",
     ):
         return cls(
             IssueList(title=f"{cls.__name__} issues"),
@@ -63,6 +76,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
             data_model_id=data_model_id,
             max_number_of_instance=max_number_of_instance,
             non_existing_node_type=non_existing_node_type,
+            language=language,
         )
 
     @classmethod
@@ -72,6 +86,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_RDF_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
+        language: str = "en",
     ):
         issue_list = IssueList(title=f"{cls.__name__} issues")
 
@@ -82,15 +97,8 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
             issue_list.append(FileReadError(filepath, str(e)))
 
         # bind key namespaces
-        graph.bind("owl", OWL)
-        graph.bind("rdf", RDF)
-        graph.bind("rdfs", RDFS)
-        graph.bind("dcterms", DCTERMS)
-        graph.bind("dc", DC)
-        graph.bind("skos", SKOS)
-        graph.bind("sh", SH)
-        graph.bind("xsd", XSD)
-        graph.bind("imf", "http://ns.imfid.org/imf#")
+        for prefix, namespace in get_default_prefixes().items():
+            graph.bind(prefix, namespace)
 
         return cls(
             issue_list,
@@ -98,6 +106,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
             data_model_id=data_model_id,
             max_number_of_instance=max_number_of_instance,
             non_existing_node_type=non_existing_node_type,
+            language=language,
         )
 
     def to_rules(
@@ -129,4 +138,18 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
             prefixes: Dict of prefixes and namespaces
         """
         if Namespace(get_namespace(URI)) not in prefixes.values():
-            prefixes[f"prefix-{len(prefixes)+1}"] = Namespace(get_namespace(URI))
+            prefixes[f"prefix_{len(prefixes)+1}"] = Namespace(get_namespace(URI))
+
+    @property
+    def _metadata(self) -> dict:
+        return {
+            "role": RoleTypes.information,
+            "space": self.data_model_id.space,
+            "external_id": self.data_model_id.external_id,
+            "version": self.data_model_id.version,
+            "created": datetime.now().replace(microsecond=0),
+            "updated": datetime.now().replace(microsecond=0),
+            "name": None,
+            "description": f"Data model imported using {type(self).__name__}",
+            "creator": "Neat",
+        }