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

cognite/neat/_graph/extractors/_classic_cdf/_classic.py

@@ -7,9 +7,9 @@ from cognite.client import CogniteClient
 from cognite.client.exceptions import CogniteAPIError
 from rdflib import Namespace
 
-from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._constants import CLASSIC_CDF_NAMESPACE
 from cognite.neat._graph.extractors._base import BaseExtractor
-from cognite.neat._issues.warnings import AuthWarning
+from cognite.neat._issues.warnings import CDFAuthWarning
 from cognite.neat._shared import Triple
 from cognite.neat._utils.collection_ import chunker
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri
@@ -98,7 +98,7 @@ class ClassicGraphExtractor(BaseExtractor):
             raise ValueError("Exactly one of data_set_external_id or root_asset_external_id must be set.")
         self._root_asset_external_id = root_asset_external_id
         self._data_set_external_id = data_set_external_id
-        self._namespace = namespace or DEFAULT_NAMESPACE
+        self._namespace = namespace or CLASSIC_CDF_NAMESPACE
         self._extractor_args = dict(namespace=self._namespace, unpack_metadata=False, as_write=True, camel_case=True)
 
         self._source_external_ids_by_type: dict[InstanceIdPrefix, set[str]] = defaultdict(set)
@@ -117,12 +117,12 @@ class ClassicGraphExtractor(BaseExtractor):
         try:
             yield from self._extract_labels()
         except CogniteAPIError as e:
-            warnings.warn(AuthWarning("extract labels", str(e)), stacklevel=2)
+            warnings.warn(CDFAuthWarning("extract labels", str(e)), stacklevel=2)
 
         try:
             yield from self._extract_data_sets()
         except CogniteAPIError as e:
-            warnings.warn(AuthWarning("extract data sets", str(e)), stacklevel=2)
+            warnings.warn(CDFAuthWarning("extract data sets", str(e)), stacklevel=2)
 
     def _extract_core_start_nodes(self):
         for core_node in self._classic_node_types:

cognite/neat/_graph/loaders/_rdf2dms.py

@@ -19,7 +19,7 @@ from rdflib import RDF
 from cognite.neat._graph._tracking import LogTracker, Tracker
 from cognite.neat._issues import IssueList, NeatIssue, NeatIssueList
 from cognite.neat._issues.errors import (
-    ResourceConvertionError,
+    ResourceConversionError,
     ResourceCreationError,
     ResourceDuplicatedError,
     ResourceRetrievalError,
@@ -88,7 +88,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             data_model = rules.as_schema().as_read_model()
         except Exception as e:
             issues.append(
-                ResourceConvertionError(
+                ResourceConversionError(
                     identifier=rules.metadata.as_identifier(),
                     resource_type="DMS Rules",
                     target_format="read DMS model",

cognite/neat/_graph/transformers/_classic_cdf.py

@@ -254,7 +254,7 @@ class RelationshipToSchemaTransformer(BaseTransformer):
         self._namespace = namespace
 
     _NOT_PROPERTIES: frozenset[str] = frozenset(
-        {"source_external_id", "target_external_id", "external_id", "source_type", "target_type"}
+        {"sourceExternalId", "targetExternalId", "externalId", "sourceType", "targetType"}
     )
     _RELATIONSHIP_NODE_TYPES: tuple[str, ...] = tuple(["Asset", "Event", "File", "Sequence", "TimeSeries"])
     description = "Replaces relationships with a schema"
@@ -266,8 +266,8 @@ class RelationshipToSchemaTransformer(BaseTransformer):
 SELECT (COUNT(?instance) AS ?instanceCount)
 WHERE {{
   ?instance a classic:Relationship .
-  ?instance classic:source_type classic:{source_type} .
-  ?instance classic:target_type classic:{target_type} .
+  ?instance classic:sourceType classic:{source_type} .
+  ?instance classic:targetType classic:{target_type} .
 }}"""
 
     _instances = """PREFIX classic: <{namespace}>
@@ -275,15 +275,15 @@ WHERE {{
 SELECT ?instance
 WHERE {{
     ?instance a classic:Relationship .
-    ?instance classic:source_type classic:{source_type} .
-    ?instance classic:target_type classic:{target_type} .
+    ?instance classic:sourceType classic:{source_type} .
+    ?instance classic:targetType classic:{target_type} .
 }}"""
     _lookup_entity_query = """PREFIX classic: <{namespace}>
 
 SELECT ?entity
 WHERE {{
     ?entity a classic:{entity_type} .
-    ?entity classic:external_id "{external_id}" .
+    ?entity classic:externalId "{external_id}" .
 }}"""
 
     def transform(self, graph: Graph) -> None:
@@ -309,8 +309,8 @@ WHERE {{
         object_by_predicates = cast(
             dict[str, URIRef | Literal], {remove_namespace_from_uri(row[1]): row[2] for row in result}
         )
-        source_external_id = cast(URIRef, object_by_predicates["source_external_id"])
-        target_source_id = cast(URIRef, object_by_predicates["target_external_id"])
+        source_external_id = cast(URIRef, object_by_predicates["sourceExternalId"])
+        target_source_id = cast(URIRef, object_by_predicates["targetExternalId"])
         try:
             source_id = self._lookup_entity(graph, source_type, source_external_id)
         except ValueError:
@@ -321,7 +321,7 @@ WHERE {{
         except ValueError:
             warnings.warn(ResourceNotFoundWarning(target_source_id, "class", str(instance_id), "class"), stacklevel=2)
             return None
-        external_id = str(object_by_predicates["external_id"])
+        external_id = str(object_by_predicates["externalId"])
         # If there is properties on the relationship, we create a new intermediate node
         self._create_node(graph, object_by_predicates, external_id, source_id, target_id, self._predicate(target_type))
 
@@ -347,7 +347,7 @@ WHERE {{
         predicate: URIRef,
     ) -> None:
         """Creates a new intermediate node for the relationship with properties."""
-        # Create new node
+        # Create the entity with the properties
         instance_id = self._namespace[external_id]
         graph.add((instance_id, RDF.type, self._namespace["Edge"]))
         for prop_name, object_ in objects_by_predicates.items():
@@ -355,9 +355,20 @@ WHERE {{
                 continue
             graph.add((instance_id, self._namespace[prop_name], object_))
 
-        # Connect the new node to the source and target nodes
-        graph.add((source_id, predicate, instance_id))
-        graph.add((instance_id, self._namespace["end_node"], target_id))
+        # Target and Source IDs will always be a combination of Asset, Sequence, Event, TimeSeries, and File.
+        # If we assume source ID is an asset and target ID is a time series, then
+        # before we had relationship pointing to both: timeseries <- relationship -> asset
+        # After, we want asset -> timeseries, and asset.edgeSource -> Edge
+        # and the new edge will point to the asset and the timeseries through startNode and endNode
+
+        # Link the two entities directly,
+        graph.add((source_id, predicate, target_id))
+        # Create the new edge
+        graph.add((instance_id, self._namespace["startNode"], source_id))
+        graph.add((instance_id, self._namespace["endNode"], target_id))
+
+        # Link the source to the edge properties
+        graph.add((source_id, self._namespace["edgeSource"], instance_id))
 
     def _predicate(self, target_type: str) -> URIRef:
         return self._namespace[f"relationship{target_type.capitalize()}"]

cognite/neat/_issues/_base.py

@@ -210,7 +210,7 @@ class NeatError(NeatIssue, Exception):
     """This is the base class for all exceptions (errors) used in Neat."""
 
     @classmethod
-    def from_pydantic_errors(cls, errors: list[ErrorDetails], **kwargs) -> "list[NeatError]":
+    def from_errors(cls, errors: "list[ErrorDetails | NeatError]", **kwargs) -> "list[NeatError]":
         """Convert a list of pydantic errors to a list of Error instances.
 
         This is intended to be overridden in subclasses to handle specific error types.
@@ -219,24 +219,36 @@ class NeatError(NeatIssue, Exception):
         read_info_by_sheet = kwargs.get("read_info_by_sheet")
 
         for error in errors:
-            if error["type"] == "is_instance_of" and error["loc"][1] == "is-instance[SheetList]":
+            if (
+                isinstance(error, dict)
+                and error["type"] == "is_instance_of"
+                and error["loc"][1] == "is-instance[SheetList]"
+            ):
                 # Skip the error for SheetList, as it is not relevant for the user. This is an
                 # internal class used to have helper methods for a lists as .to_pandas()
                 continue
-            ctx = error.get("ctx")
-            if isinstance(ctx, dict) and isinstance(multi_error := ctx.get("error"), MultiValueError):
+            neat_error: NeatError | None = None
+            if isinstance(error, dict) and isinstance(ctx := error.get("ctx"), dict) and "error" in ctx:
+                neat_error = ctx["error"]
+            elif isinstance(error, NeatError | MultiValueError):
+                neat_error = error
+
+            if isinstance(neat_error, MultiValueError):
                 if read_info_by_sheet:
-                    for caught_error in multi_error.errors:
+                    for caught_error in neat_error.errors:
                         cls._adjust_row_numbers(caught_error, read_info_by_sheet)  # type: ignore[arg-type]
-                all_errors.extend(multi_error.errors)  # type: ignore[arg-type]
-            elif isinstance(ctx, dict) and isinstance(single_error := ctx.get("error"), NeatError):
+                all_errors.extend(neat_error.errors)  # type: ignore[arg-type]
+            elif isinstance(neat_error, NeatError):
                 if read_info_by_sheet:
-                    cls._adjust_row_numbers(single_error, read_info_by_sheet)
-                all_errors.append(single_error)
-            elif len(error["loc"]) >= 4 and read_info_by_sheet:
+                    cls._adjust_row_numbers(neat_error, read_info_by_sheet)
+                all_errors.append(neat_error)
+            elif isinstance(error, dict) and len(error["loc"]) >= 4 and read_info_by_sheet:
                 all_errors.append(RowError.from_pydantic_error(error, read_info_by_sheet))
-            else:
+            elif isinstance(error, dict):
                 all_errors.append(DefaultPydanticError.from_pydantic_error(error))
+            else:
+                # This is unreachable. However, in case it turns out to be reachable, we want to know about it.
+                raise ValueError(f"Unsupported error type: {error}")
         return all_errors
 
     @staticmethod
@@ -511,13 +523,10 @@ def catch_issues(
         try:
             yield future_result
         except ValidationError as e:
-            issues.extend(error_cls.from_pydantic_errors(e.errors(), **(error_args or {})))
-            future_result._result = "failure"
-        except MultiValueError as e:
-            issues.extend(e.errors)
+            issues.extend(error_cls.from_errors(e.errors(), **(error_args or {})))  # type: ignore[arg-type]
             future_result._result = "failure"
-        except NeatError as e:
-            issues.append(e)
+        except (NeatError, MultiValueError) as e:
+            issues.extend(error_cls.from_errors([e], **(error_args or {})))  # type: ignore[arg-type, list-item]
             future_result._result = "failure"
         else:
             future_result._result = "success"

cognite/neat/_issues/errors/__init__.py

@@ -2,6 +2,7 @@ from cognite.neat._issues._base import DefaultPydanticError, NeatError, RowError
 
 from ._external import (
     AuthorizationError,
+    CDFMissingClientError,
     FileMissingRequiredFieldError,
     FileNotAFileError,
     FileNotFoundNeatError,
@@ -20,7 +21,7 @@ from ._properties import (
 )
 from ._resources import (
     ResourceChangedError,
-    ResourceConvertionError,
+    ResourceConversionError,
     ResourceCreationError,
     ResourceDuplicatedError,
     ResourceError,
@@ -58,7 +59,7 @@ __all__ = [
     "ResourceError",
     "ResourceNotDefinedError",
     "ResourceMissingIdentifierError",
-    "ResourceConvertionError",
+    "ResourceConversionError",
     "WorkflowConfigurationNotSetError",
     "WorkFlowMissingDataError",
     "WorkflowStepNotInitializedError",
@@ -70,6 +71,7 @@ __all__ = [
     "RowError",
     "NeatTypeError",
     "ReversedConnectionNotFeasibleError",
+    "CDFMissingClientError",
 ]
 
 _NEAT_ERRORS_BY_NAME = {error.__name__: error for error in _get_subclasses(NeatError, include_base=True)}

cognite/neat/_issues/errors/_external.py

@@ -65,3 +65,10 @@ class FileNotAFileError(NeatError, FileNotFoundError):
 
     fix = "Make sure to provide a valid file"
     filepath: Path
+
+
+@dataclass(unsafe_hash=True)
+class CDFMissingClientError(NeatError, RuntimeError):
+    """CDF client is required: {reason}"""
+
+    reason: str

cognite/neat/_issues/errors/_properties.py

@@ -34,14 +34,9 @@ class PropertyTypeNotSupportedError(PropertyError[T_Identifier]):
 
 @dataclass(unsafe_hash=True)
 class ReversedConnectionNotFeasibleError(PropertyError[T_Identifier]):
-    """The {resource_type} {property_name} with identifier {identifier} of the view {target_view_id} cannot be made
-    since view {source_view_id} does not have direct connection {direct_connection} defined,
-    or {direct_connection} value type is not {target_view_id}
-    """
+    """The {resource_type} {identifier}.{property_name} cannot be created: {reason}"""
 
-    target_view_id: str
-    source_view_id: str
-    direct_connection: str
+    reason: str
 
 
 # This is a generic error that should be used sparingly

cognite/neat/_issues/errors/_resources.py

@@ -64,7 +64,7 @@ class ResourceNotDefinedError(ResourceError[T_Identifier]):
 
 
 @dataclass(unsafe_hash=True)
-class ResourceConvertionError(ResourceError, ValueError):
+class ResourceConversionError(ResourceError, ValueError):
     """Failed to convert the {resource_type} {identifier} to {target_format}: {reason}"""
 
     fix = "Check the error message and correct the rules."

cognite/neat/_issues/warnings/__init__.py

@@ -6,7 +6,8 @@ from cognite.neat._issues._base import DefaultWarning, NeatWarning, _get_subclas
 
 from . import user_modeling
 from ._external import (
-    AuthWarning,
+    CDFAuthWarning,
+    CDFMaxIterationsWarning,
     FileItemNotSupportedWarning,
     FileMissingRequiredFieldWarning,
     FileReadWarning,
@@ -69,8 +70,9 @@ __all__ = [
     "NotSupportedViewContainerLimitWarning",
     "NotSupportedHasDataFilterLimitWarning",
     "UndefinedViewWarning",
-    "AuthWarning",
+    "CDFAuthWarning",
     "user_modeling",
+    "CDFMaxIterationsWarning",
 ]
 
 _NEAT_WARNINGS_BY_NAME = {warning.__name__: warning for warning in _get_subclasses(NeatWarning, include_base=True)}

cognite/neat/_issues/warnings/_external.py

@@ -41,8 +41,16 @@ class FileItemNotSupportedWarning(NeatWarning):
 
 
 @dataclass(unsafe_hash=True)
-class AuthWarning(NeatWarning):
+class CDFAuthWarning(NeatWarning):
     """Failed to {action} due to {reason}"""
 
     action: str
     reason: str
+
+
+@dataclass(unsafe_hash=True)
+class CDFMaxIterationsWarning(NeatWarning):
+    """The maximum number of iterations ({max_iterations}) has been reached. {message}"""
+
+    message: str
+    max_iterations: int

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

@@ -106,13 +106,9 @@ VIEW_ID_COMPLIANCE_REGEX = (
 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]?$)"
-)
+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/exporters/_rules2dms.py

@@ -39,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.
 
@@ -58,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
@@ -106,7 +102,8 @@ 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: NeatClient, dry_run: bool = False, skip_space: bool = False
@@ -115,7 +112,8 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
 
         # 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):
+        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)

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

@@ -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
@@ -97,7 +94,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         cls,
         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(NeatClient(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)
-        ref_metadata = cls._create_metadata_from_model(ref_model) if ref_model else None
 
-        return cls(schema, issue_list, metadata, ref_metadata)
+        return cls(schema, issue_list, metadata, None)
 
     @classmethod
     def _find_model_in_list(

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"]