cognite-neat 0.103.1__py3-none-any.whl → 0.105.0__py3-none-any.whl

cognite/neat/_rules/_shared.py

@@ -1,8 +1,6 @@
-from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Any, Generic, TypeAlias, TypeVar
 
-from cognite.neat._issues import IssueList
 from cognite.neat._rules.models import (
     DMSRules,
     InformationRules,
@@ -11,46 +9,32 @@ from cognite.neat._rules.models.dms._rules_input import DMSInputRules
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
 
 VerifiedRules: TypeAlias = InformationRules | DMSRules
-InputRules: TypeAlias = DMSInputRules | InformationInputRules
-Rules: TypeAlias = DMSInputRules | InformationInputRules | InformationRules | DMSRules
-T_Rules = TypeVar("T_Rules", bound=Rules)
+
 T_VerifiedRules = TypeVar("T_VerifiedRules", bound=VerifiedRules)
+InputRules: TypeAlias = DMSInputRules | InformationInputRules
 T_InputRules = TypeVar("T_InputRules", bound=InputRules)
 
 
 @dataclass
-class OutRules(Generic[T_Rules], ABC):
-    """This is a base class for all rule states."""
-
-    @abstractmethod
-    def get_rules(self) -> T_Rules | None:
-        """Get the rules from the state."""
-        raise NotImplementedError()
-
-
-@dataclass
-class JustRules(OutRules[T_Rules]):
-    """This represents a rule that exists"""
+class ReadRules(Generic[T_InputRules]):
+    """This represents a rules that has been read."""
 
-    rules: T_Rules
-
-    def get_rules(self) -> T_Rules:
-        return self.rules
-
-
-@dataclass
-class MaybeRules(OutRules[T_Rules]):
-    """This represents a rule that may or may not exist"""
+    rules: T_InputRules | None
+    read_context: dict[str, Any]
 
-    rules: T_Rules | None
-    issues: IssueList
+    @classmethod
+    def display_type_name(cls) -> str:
+        return "UnverifiedModel"
 
-    def get_rules(self) -> T_Rules | None:
-        return self.rules
+    @property
+    def display_name(self):
+        if self.rules is None:
+            return "FailedRead"
+        return self.rules.display_name
 
 
-@dataclass
-class ReadRules(MaybeRules[T_Rules]):
-    """This represents a rule that does not exist"""
+ReadInputRules: TypeAlias = ReadRules[DMSInputRules] | ReadRules[InformationInputRules]
+T_ReadInputRules = TypeVar("T_ReadInputRules", bound=ReadInputRules)
 
-    read_context: dict[str, Any]
+Rules: TypeAlias = InformationRules | DMSRules | ReadRules[DMSInputRules] | ReadRules[InformationInputRules]
+T_Rules = TypeVar("T_Rules", bound=Rules)

cognite/neat/_rules/exporters/_base.py

@@ -1,13 +1,19 @@
 from abc import ABC, abstractmethod
 from collections.abc import Iterable
+from functools import lru_cache
 from pathlib import Path
-from typing import Generic, TypeVar
+from types import UnionType
+from typing import TYPE_CHECKING, Generic, TypeVar, Union, get_args, get_origin
 
 from cognite.neat._client import NeatClient
+from cognite.neat._constants import DEFAULT_NAMESPACE
 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
 
+if TYPE_CHECKING:
+    from cognite.neat._store._provenance import Agent as ProvenanceAgent
+
 T_Export = TypeVar("T_Export")
 
 
@@ -27,8 +33,28 @@ class BaseExporter(ABC, Generic[T_VerifiedRules, T_Export]):
     def _repr_html_(cls) -> str:
         return class_html_doc(cls, include_factory_methods=False)
 
+    @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__}"])
+
+    @property
+    def description(self) -> str:
+        return "MISSING DESCRIPTION"
+
+    @classmethod
+    @lru_cache(maxsize=1)
+    def source_types(cls) -> tuple[type, ...]:
+        base_exporter = cls.__orig_bases__[0]  # type: ignore[attr-defined]
+        source_type = get_args(base_exporter)[0]
+        if get_origin(source_type) in [Union, UnionType]:
+            return get_args(source_type)
+        return (source_type,)
+
 
-class CDFExporter(BaseExporter[T_VerifiedRules, T_Export]):
+class CDFExporter(BaseExporter[T_VerifiedRules, T_Export], ABC):
     @abstractmethod
     def export_to_cdf_iterable(
         self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False

cognite/neat/_rules/exporters/_rules2dms.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Generic, Literal
 
+from cognite.client import data_modeling as dm
 from cognite.client.data_classes._base import (
     T_CogniteResourceList,
     T_WritableCogniteResource,
@@ -19,7 +20,7 @@ from cognite.client.exceptions import CogniteAPIError
 
 from cognite.neat._client import DataModelingLoader, NeatClient
 from cognite.neat._client._api.data_modeling_loaders import MultiCogniteAPIError, T_WritableCogniteResourceList
-from cognite.neat._client.data_classes.data_modeling import Component
+from cognite.neat._client.data_classes.data_modeling import Component, ViewApplyDict
 from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.warnings import (
@@ -109,6 +110,10 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         self._schema: DMSSchema | None = None
         self.remove_cdf_spaces = remove_cdf_spaces
 
+    @property
+    def description(self) -> str:
+        return "Export verified DMS Model to CDF."
+
     def export_to_file(self, rules: DMSRules, filepath: Path) -> None:
         """Export the rules to a file(s).
 
@@ -195,6 +200,10 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
     ) -> Iterable[UploadResult]:
         schema = self.export(rules)
 
+        # The CDF UI does not deal well with a child view overwriting a parent property with the same name
+        # This is a workaround to remove the duplicated properties
+        self._remove_duplicated_properties(schema.views, client)
+
         categorized_items_by_loader = self._categorize_by_loader(client, schema)
 
         is_failing = self.existing == "fail" and any(
@@ -372,3 +381,32 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 for data_model in data_models
                 if (data_model.space, data_model.external_id) != (space, external_id)
             ]
+
+    @staticmethod
+    def _remove_duplicated_properties(views: ViewApplyDict, client: NeatClient) -> None:
+        parent_view_ids = {parent for view in views.values() for parent in view.implements}
+        parent_view_list = client.data_modeling.views.retrieve(
+            list(parent_view_ids), include_inherited_properties=False
+        )
+        parent_view_by_id = {view.as_id(): view.as_write() for view in parent_view_list}
+        for view in views.values():
+            if view.implements is None:
+                continue
+            for parent_id in view.implements:
+                if not (parent_view := parent_view_by_id.get(parent_id)):
+                    continue
+                for shared_prop_id in set(view.properties or {}) & set(parent_view.properties or {}):
+                    if view.properties is None or parent_view.properties is None:
+                        continue
+                    prop = view.properties[shared_prop_id]
+                    parent_prop = parent_view.properties[shared_prop_id]
+                    if (
+                        isinstance(prop, dm.MappedPropertyApply)
+                        and isinstance(parent_prop, dm.MappedPropertyApply)
+                        and (
+                            prop.container_property_identifier == parent_prop.container_property_identifier
+                            and prop.container == parent_prop.container
+                            and prop.source == parent_prop.source
+                        )
+                    ):
+                        view.properties.pop(shared_prop_id)

cognite/neat/_rules/exporters/_rules2excel.py

@@ -68,6 +68,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         styling: Style = "default",
         new_model_id: tuple[str, str] | None = None,
         sheet_prefix: str | None = None,
+        reference_rules_with_prefix: tuple[VerifiedRules, str] | None = None,
     ):
         self.sheet_prefix = sheet_prefix or ""
         if styling not in self.style_options:
@@ -75,6 +76,11 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         self.styling = styling
         self._styling_level = self.style_options.index(styling)
         self.new_model_id = new_model_id
+        self.reference_rules_with_prefix = reference_rules_with_prefix
+
+    @property
+    def description(self) -> str:
+        return "Export verified model to Excel."
 
     def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
         """Exports transformation rules to excel file."""
@@ -94,6 +100,11 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
 
         self._write_metadata_sheet(workbook, dumped_user_rules["Metadata"], sheet_prefix=self.sheet_prefix)
         self._write_sheets(workbook, dumped_user_rules, rules, sheet_prefix=self.sheet_prefix)
+        if self.reference_rules_with_prefix:
+            reference_rules, prefix = self.reference_rules_with_prefix
+            dumped_reference_rules = reference_rules.dump(entities_exclude_defaults=False, by_alias=True)
+            self._write_sheets(workbook, dumped_reference_rules, reference_rules, sheet_prefix=prefix)
+            self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix=prefix)
 
         if isinstance(rules, InformationRules) and rules.prefixes:
             self._write_prefixes_sheet(workbook, rules.prefixes)
@@ -218,8 +229,8 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                 if isinstance(selected_column, MergedCell):
                     selected_column = column_cells[1]
 
-                current = sheet.column_dimensions[selected_column.column_letter].width or (max_length + 0.5)
-                sheet.column_dimensions[selected_column.column_letter].width = min(
+                current = sheet.column_dimensions[selected_column.column_letter].width or (max_length + 0.5)  # type: ignore[union-attr]
+                sheet.column_dimensions[selected_column.column_letter].width = min(  # type: ignore[union-attr]
                     max(current, max_length + 0.5), MAX_COLUMN_WIDTH
                 )
         return None

cognite/neat/_rules/exporters/_rules2instance_template.py

@@ -42,6 +42,10 @@ class InstanceTemplateExporter(BaseExporter[InformationRules, Workbook]):
         self.auto_identifier_type = auto_identifier_type
         self.add_drop_down_list = add_drop_down_list
 
+    @property
+    def description(self) -> str:
+        return "Export verified information instance template to Excel."
+
     def export(
         self,
         rules: InformationRules,

cognite/neat/_rules/exporters/_rules2ontology.py

@@ -46,6 +46,10 @@ class OWLExporter(GraphExporter):
     def export(self, rules: InformationRules) -> Graph:
         return Ontology.from_rules(rules).as_owl()
 
+    @property
+    def description(self) -> str:
+        return "Export verified information model to OWL."
+
 
 class SHACLExporter(GraphExporter):
     """Exports rules to a SHACL graph."""
@@ -53,13 +57,21 @@ class SHACLExporter(GraphExporter):
     def export(self, rules: InformationRules) -> Graph:
         return Ontology.from_rules(rules).as_shacl()
 
+    @property
+    def description(self) -> str:
+        return "Export verified information model to SHACL."
+
 
 class SemanticDataModelExporter(GraphExporter):
-    """Exports verified information rules to a semantic data model."""
+    """Exports verified information model to a semantic data model."""
 
     def export(self, rules: InformationRules) -> Graph:
         return Ontology.from_rules(rules).as_semantic_data_model()
 
+    @property
+    def description(self) -> str:
+        return "Export verified information model to a semantic data model."
+
 
 class OntologyModel(BaseModel):
     model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True, strict=False, extra="allow")

cognite/neat/_rules/exporters/_rules2yaml.py

@@ -43,6 +43,10 @@ class YAMLExporter(BaseExporter[VerifiedRules, str]):
         self.files = files
         self.output = output
 
+    @property
+    def description(self) -> str:
+        return "Export verified model to YAML."
+
     def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
         """Exports transformation rules to YAML/JSON file(s)."""
         if self.files == "single":

cognite/neat/_rules/importers/_base.py

@@ -6,6 +6,7 @@ from datetime import datetime
 from typing import TYPE_CHECKING, Any, Generic, Literal
 
 from pydantic import ValidationError
+from rdflib import URIRef
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._issues import IssueList, NeatError, NeatWarning
@@ -56,6 +57,14 @@ class BaseImporter(ABC, Generic[T_InputRules]):
 
         return ProvenanceAgent(id_=DEFAULT_NAMESPACE[f"agent/{type(self).__name__}"])
 
+    @property
+    def description(self) -> str:
+        return "MISSING DESCRIPTION"
+
+    @property
+    def source_uri(self) -> URIRef:
+        return DEFAULT_NAMESPACE["UNKNOWN"]
+
 
 class _FutureResult:
     def __init__(self) -> None:

cognite/neat/_rules/importers/_dms2rules.py

@@ -1,6 +1,6 @@
-from collections import Counter, defaultdict
+from collections import defaultdict
 from collections.abc import Collection, Iterable, Sequence
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
 from typing import Literal, cast
 
@@ -19,13 +19,20 @@ 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 import IssueList, MultiValueError, NeatIssue
+from cognite.neat._issues.errors import (
+    FileTypeUnexpectedError,
+    NeatValueError,
+    ResourceMissingIdentifierError,
+    ResourceRetrievalError,
+)
 from cognite.neat._issues.warnings import (
+    MissingCogniteClientWarning,
     PropertyNotFoundWarning,
     PropertyTypeNotSupportedWarning,
     ResourceNotFoundWarning,
     ResourcesDuplicatedWarning,
+    ResourceUnknownWarning,
 )
 from cognite.neat._rules._shared import ReadRules
 from cognite.neat._rules.importers._base import BaseImporter, _handle_issues
@@ -60,7 +67,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         schema: The schema containing the data model.
         read_issues: A list of issues that occurred during the import.
         metadata: Metadata for the data model.
-        ref_metadata: Metadata for the reference data model.
 
     """
 
@@ -69,25 +75,26 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         schema: DMSSchema,
         read_issues: Sequence[NeatIssue] | None = None,
         metadata: DMSInputMetadata | None = None,
-        ref_metadata: DMSInputMetadata | None = None,
+        referenced_containers: Iterable[dm.ContainerApply] | None = None,
     ):
-        # Calling this root schema to distinguish it from
-        # * User Schema
-        # * Reference Schema
-        self.root_schema = schema
+        self.schema = schema
         self.metadata = metadata
-        self.ref_metadata = ref_metadata
         self.issue_list = IssueList(read_issues)
         self._all_containers_by_id = schema.containers.copy()
         self._all_views_by_id = schema.views.copy()
+        if referenced_containers is not None:
+            for container in referenced_containers:
+                if container.as_id() in self._all_containers_by_id:
+                    continue
+                self._all_containers_by_id[container.as_id()] = container
 
-    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
-        is read"""
-        for container in containers:
-            if container.as_id() in self._all_containers_by_id:
-                continue
-            self._all_containers_by_id[container.as_id()] = container
+    @property
+    def description(self) -> str:
+        if self.schema.data_model is not None:
+            identifier = f"{self.schema.data_model.as_id().as_tuple()!s}"
+        else:
+            identifier = "Unknown"
+        return f"DMS Data model {identifier} read as unverified data model"
 
     @classmethod
     def from_data_model_id(
@@ -99,8 +106,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
 
         Args:
             client: Instantiated CogniteClient to retrieve data model.
-            reference_model_id: The reference data model to retrieve. This is the data model that
-                the given data model is built on top of, typically, an enterprise data model.
             data_model_id: Data Model to retrieve.
 
         Returns:
@@ -133,7 +138,12 @@ class DMSImporter(BaseImporter[DMSInputRules]):
 
         metadata = cls._create_metadata_from_model(user_model)
 
-        return cls(schema, issue_list, metadata, None)
+        return cls(
+            schema,
+            issue_list,
+            metadata,
+            referenced_containers=cls._lookup_referenced_containers(schema, issue_list, client),
+        )
 
     @classmethod
     def _find_model_in_list(
@@ -174,15 +184,17 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         )
 
     @classmethod
-    def from_directory(cls, directory: str | Path) -> "DMSImporter":
+    def from_directory(cls, directory: str | Path, client: NeatClient | None = None) -> "DMSImporter":
         issue_list = IssueList()
         with _handle_issues(issue_list) as _:
             schema = DMSSchema.from_directory(directory)
         # If there were errors during the import, the to_rules
-        return cls(schema, issue_list)
+        return cls(
+            schema, issue_list, referenced_containers=cls._lookup_referenced_containers(schema, issue_list, client)
+        )
 
     @classmethod
-    def from_zip_file(cls, zip_file: str | Path) -> "DMSImporter":
+    def from_zip_file(cls, zip_file: str | Path, client: NeatClient | None = None) -> "DMSImporter":
         if Path(zip_file).suffix != ".zip":
             return cls(
                 DMSSchema(),
@@ -191,30 +203,53 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         issue_list = IssueList()
         with _handle_issues(issue_list) as _:
             schema = DMSSchema.from_zip(zip_file)
-        return cls(schema, issue_list)
+        return cls(
+            schema, issue_list, referenced_containers=cls._lookup_referenced_containers(schema, issue_list, client)
+        )
+
+    @classmethod
+    def _lookup_referenced_containers(
+        cls, schema: DMSSchema, issue_list: IssueList, client: NeatClient | None = None
+    ) -> Iterable[dm.ContainerApply]:
+        ref_containers = schema.externally_referenced_containers()
+        if not ref_containers:
+            return []
+        elif client is None:
+            id_ = ""
+            if schema.data_model:
+                id_ = f" {schema.data_model.as_id()!r}"
+            issue_list.append(MissingCogniteClientWarning(f"importing full DMS model{id_}"))
+            return []
+        return client.loaders.containers.retrieve(list(ref_containers), format="write")
+
+    @classmethod
+    def from_path(cls, path: Path, client: NeatClient | None = None) -> "DMSImporter":
+        if path.is_file():
+            return cls.from_zip_file(path, client)
+        elif path.is_dir():
+            return cls.from_directory(path, client)
+        else:
+            raise NeatValueError(f"Unsupported YAML format: {format}")
 
     def to_rules(self) -> ReadRules[DMSInputRules]:
         if self.issue_list.has_errors:
             # In case there were errors during the import, the to_rules method will return None
-            self._end = datetime.now(timezone.utc)
-            return ReadRules(None, self.issue_list, {})
-
-        if not self.root_schema.data_model:
-            self.issue_list.append(ResourceMissingIdentifierError("data model", type(self.root_schema).__name__))
-            self._end = datetime.now(timezone.utc)
-            return ReadRules(None, self.issue_list, {})
+            self.issue_list.trigger_warnings()
+            raise MultiValueError(self.issue_list.errors)
 
-        model = self.root_schema.data_model
+        if not self.schema.data_model:
+            self.issue_list.append(ResourceMissingIdentifierError("data model", type(self.schema).__name__))
+            self.issue_list.trigger_warnings()
+            raise MultiValueError(self.issue_list.errors)
 
-        user_rules = self._create_rule_components(
-            model,
-            self.root_schema,
-            self.metadata,
-        )
+        model = self.schema.data_model
 
-        self._end = datetime.now(timezone.utc)
+        user_rules = self._create_rule_components(model, self.schema, self.metadata)
 
-        return ReadRules(user_rules, self.issue_list, {})
+        self.issue_list.trigger_warnings()
+        if self.issue_list.has_errors:
+            raise MultiValueError(self.issue_list.errors)
+        return ReadRules(user_rules, {})
 
     def _create_rule_components(
         self,
@@ -222,7 +257,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         schema: DMSSchema,
         metadata: DMSInputMetadata | None = None,
     ) -> DMSInputRules:
-        enum_by_container_property = self._create_enum_collections(schema.containers.values())
+        enum_by_container_property = self._create_enum_collections(self._all_containers_by_id.values())
         enum_collection_by_container_property = {
             key: enum_list[0].collection for key, enum_list in enum_by_container_property.items() if enum_list
         }
@@ -255,21 +290,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             enum=[enum for enum_list in enum_by_container_property.values() for enum in enum_list] or None,
         )
 
-    @classmethod
-    def _create_default_metadata(
-        cls, views: Sequence[dm.View | dm.ViewApply], is_ref: bool = False
-    ) -> DMSInputMetadata:
-        now = datetime.now().replace(microsecond=0)
-        space = Counter(view.space for view in views).most_common(1)[0][0]
-        return DMSInputMetadata(
-            space=space,
-            external_id="Unknown",
-            version="0.1.0",
-            creator="Unknown",
-            created=now,
-            updated=now,
-        )
-
     def _create_dms_property(
         self,
         prop_id: str,
@@ -372,8 +392,11 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         elif isinstance(prop, dm.MappedPropertyApply):
             container_prop = self._container_prop_unsafe(cast(dm.MappedPropertyApply, prop))
             if isinstance(container_prop.type, dm.DirectRelation):
-                if prop.source is None or prop.source not in self._all_views_by_id:
+                if prop.source is None:
                     return DMSUnknownEntity()
+                elif prop.source not in self._all_views_by_id:
+                    self.issue_list.append(ResourceUnknownWarning(prop.source, "view", view_entity.as_id(), "view"))
+                    return ViewEntity.from_id(prop.source)
                 else:
                     return ViewEntity.from_id(prop.source)
             elif isinstance(container_prop.type, PropertyTypeWithUnit) and container_prop.type.unit:

cognite/neat/_rules/importers/_dtdl2rules/dtdl_importer.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 from pydantic import ValidationError
 
-from cognite.neat._issues import IssueList, NeatIssue
+from cognite.neat._issues import IssueList, MultiValueError, NeatIssue
 from cognite.neat._issues.warnings import (
     FileItemNotSupportedWarning,
     FileMissingRequiredFieldWarning,
@@ -144,5 +144,8 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
             properties=converter.properties,
             classes=converter.classes,
         )
+        converter.issues.trigger_warnings()
+        if converter.issues.has_errors:
+            raise MultiValueError(converter.issues.errors)
 
-        return ReadRules(rules, converter.issues, {})
+        return ReadRules(rules, {})

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

@@ -5,7 +5,7 @@ from cognite.client import data_modeling as dm
 from rdflib import Graph, Namespace, URIRef
 
 from cognite.neat._constants import get_default_prefixes_and_namespaces
-from cognite.neat._issues import IssueList
+from cognite.neat._issues import IssueList, MultiValueError
 from cognite.neat._issues.errors import FileReadError
 from cognite.neat._issues.errors._general import NeatValueError
 from cognite.neat._rules._shared import ReadRules
@@ -13,9 +13,7 @@ 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 (
-    InformationInputRules,
-)
+from cognite.neat._rules.models.information import InformationInputRules
 from cognite.neat._store import NeatGraphStore
 from cognite.neat._utils.rdf_ import get_namespace
 
@@ -50,6 +48,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         max_number_of_instance: int,
         non_existing_node_type: UnknownEntity | AnyURI,
         language: str,
+        source_name: str = "Unknown",
     ) -> None:
         self.issue_list = issue_list
         self.graph = graph
@@ -60,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
+        self.source_name = source_name
 
     @classmethod
     def from_graph_store(
@@ -87,6 +87,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
         language: str = "en",
+        source_name: str = "Unknown",
     ):
         issue_list = IssueList(title=f"{cls.__name__} issues")
 
@@ -107,6 +108,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
             max_number_of_instance=max_number_of_instance,
             non_existing_node_type=non_existing_node_type,
             language=language,
+            source_name=source_name,
         )
 
     def to_rules(
@@ -115,16 +117,16 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
         """
         Creates `Rules` object from the data for target role.
         """
-
         if self.issue_list.has_errors:
             # In case there were errors during the import, the to_rules method will return None
-            return ReadRules(None, self.issue_list, {})
+            self.issue_list.trigger_warnings()
+            raise MultiValueError(self.issue_list.errors)
 
         rules_dict = self._to_rules_components()
 
         rules = InformationInputRules.load(rules_dict)
-
-        return ReadRules(rules, self.issue_list, {})
+        self.issue_list.trigger_warnings()
+        return ReadRules(rules, {})
 
     def _to_rules_components(self) -> dict:
         raise NotImplementedError()

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

@@ -74,6 +74,10 @@ PROPERTIES_QUERY = """
 class IMFImporter(BaseRDFImporter):
     """Convert IMF Types provided as SHACL shapes to Input Rules."""
 
+    @property
+    def description(self) -> str:
+        return f"IMF Types {self.source_name} read as unverified data model"
+
     def _to_rules_components(
         self,
     ) -> dict: