cognite-neat 0.88.2__py3-none-any.whl → 0.89.0__py3-none-any.whl

cognite/neat/rules/importers/_dtdl2rules/dtdl_converter.py

@@ -1,11 +1,13 @@
 from collections import Counter
 from collections.abc import Callable, Sequence
 
-from cognite.neat.issues import IssueList, NeatIssue
-from cognite.neat.issues.errors.properties import PropertyTypeNotSupportedError
-from cognite.neat.issues.errors.resources import MissingIdentifierError, ResourceNotFoundError
-from cognite.neat.issues.neat_warnings.properties import PropertyTypeNotSupportedWarning
-from cognite.neat.issues.neat_warnings.resources import ResourceTypeNotSupportedWarning
+from cognite.neat.issues import IssueList
+from cognite.neat.issues.errors import (
+    PropertyTypeNotSupportedError,
+    ResourceMissingIdentifierError,
+    ResourceNotFoundError,
+)
+from cognite.neat.issues.warnings import PropertyTypeNotSupportedWarning, ResourceTypeNotSupportedWarning
 from cognite.neat.rules.importers._dtdl2rules.spec import (
     DTMI,
     Command,
@@ -25,17 +27,20 @@ from cognite.neat.rules.importers._dtdl2rules.spec import (
 )
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_NAME, DataType, Json, String
 from cognite.neat.rules.models.entities import ClassEntity
-from cognite.neat.rules.models.information import InformationClass, InformationProperty
+from cognite.neat.rules.models.information import (
+    InformationInputClass,
+    InformationInputProperty,
+)
 
 
 class _DTDLConverter:
-    def __init__(self, issues: list[NeatIssue] | None = None) -> None:
+    def __init__(self, issues: IssueList | None = None) -> None:
         self.issues = IssueList(issues or [])
-        self.properties: list[InformationProperty] = []
-        self.classes: list[InformationClass] = []
+        self.properties: list[InformationInputProperty] = []
+        self.classes: list[InformationInputClass] = []
         self._item_by_id: dict[DTMI, DTDLBase] = {}
 
-        self._method_by_type: dict[type[DTDLBase], Callable[[DTDLBase, str | None], None]] = {
+        self._method_by_type = {
             Interface: self.convert_interface,  # type: ignore[dict-item]
             Property: self.convert_property,  # type: ignore[dict-item]
             PropertyV2: self.convert_property,  # type: ignore[dict-item]
@@ -51,7 +56,11 @@ class _DTDLConverter:
     def get_most_common_prefix(self) -> str:
         if not self.classes:
             raise ValueError("No classes found")
-        counted = Counter(cls_.class_.prefix for cls_ in self.classes if isinstance(cls_.class_.prefix, str))
+        counted = Counter(
+            class_.prefix
+            for class_ in (cls_.class_ for cls_ in self.classes)
+            if isinstance(class_, ClassEntity) and isinstance(class_.prefix, str)
+        )
         if not counted:
             raise ValueError("No prefixes found")
         return counted.most_common(1)[0][0]
@@ -73,19 +82,20 @@ class _DTDLConverter:
             self.convert_item(item)
 
     def convert_item(self, item: DTDLBase, parent: str | None = None) -> None:
-        convert_method = self._method_by_type.get(type(item))
+        # Bug in mypy https://github.com/python/mypy/issues/17478
+        convert_method: Callable[[DTDLBase, str | None], None] | None = self._method_by_type.get(type(item))  # type: ignore[assignment]
         if convert_method is not None:
             convert_method(item, parent)
         else:
             self.issues.append(
-                ResourceTypeNotSupportedWarning[str](
-                    item.id_.model_dump() if item.id_ else item.display_name or "missing",
+                ResourceTypeNotSupportedWarning(
+                    item.identifier_with_fallback,
                     item.type,
                 ),
             )
 
     def convert_interface(self, item: Interface, _: str | None) -> None:
-        class_ = InformationClass(
+        class_ = InformationInputClass(
             class_=item.id_.as_class_id(),
             name=item.display_name,
             description=item.description,
@@ -105,9 +115,9 @@ class _DTDLConverter:
                 )
             elif isinstance(sub_item_or_id, DTMI):
                 sub_item = self._item_by_id[sub_item_or_id]
-                self.convert_item(sub_item, class_.class_.versioned_id)
+                self.convert_item(sub_item, class_.class_str)
             else:
-                self.convert_item(sub_item_or_id, class_.class_.versioned_id)
+                self.convert_item(sub_item_or_id, class_.class_str)
         # interface.schema objects are handled in the convert method
 
     def convert_property(
@@ -120,7 +130,7 @@ class _DTDLConverter:
         if value_type is None:
             return None
 
-        prop = InformationProperty(
+        prop = InformationInputProperty(
             class_=ClassEntity.load(parent),
             property_=item.name,
             name=item.display_name,
@@ -134,8 +144,11 @@ class _DTDLConverter:
 
     def _missing_parent_warning(self, item: DTDLBaseWithName):
         self.issues.append(
-            ResourceNotFoundError[str](
-                (item.id_.model_dump() if item.id_ else item.display_name) or "missing", item.type, "parent missing"
+            ResourceNotFoundError(
+                "UNKNOWN",
+                "parent",
+                item.identifier_with_fallback,
+                item.type,
             )
         )
 
@@ -152,7 +165,7 @@ class _DTDLConverter:
         if item.request is None:
             self.issues.append(
                 ResourceTypeNotSupportedWarning[str](
-                    item.id_.model_dump() if item.id_ else item.display_name or "missing",
+                    item.identifier_with_fallback,
                     f"{item.type}.request",
                 ),
             )
@@ -163,7 +176,7 @@ class _DTDLConverter:
         value_type = self.schema_to_value_type(item.request.schema_, item)
         if value_type is None:
             return
-        prop = InformationProperty(
+        prop = InformationInputProperty(
             class_=ClassEntity.load(parent),
             property_=item.name,
             name=item.display_name,
@@ -183,7 +196,7 @@ class _DTDLConverter:
         value_type = self.schema_to_value_type(item.schema_, item)
         if value_type is None:
             return
-        prop = InformationProperty(
+        prop = InformationInputProperty(
             class_=ClassEntity.load(parent),
             property_=item.name,
             name=item.display_name,
@@ -206,14 +219,14 @@ class _DTDLConverter:
             else:
                 # Falling back to json
                 self.issues.append(
-                    MissingIdentifierError(
-                        "Unknown",
+                    ResourceMissingIdentifierError(
+                        "unknown",
                         item.target.model_dump(),
                     )
                 )
                 value_type = Json()
 
-            prop = InformationProperty(
+            prop = InformationInputProperty(
                 class_=ClassEntity.load(parent),
                 property_=item.name,
                 name=item.display_name,
@@ -231,14 +244,14 @@ class _DTDLConverter:
     def convert_object(self, item: Object, _: str | None) -> None:
         if item.id_ is None:
             self.issues.append(
-                MissingIdentifierError(
+                ResourceMissingIdentifierError(
                     resource_type=item.type,
                     name=item.display_name,
                 )
             )
             return None
 
-        class_ = InformationClass(
+        class_ = InformationInputClass(
             class_=item.id_.as_class_id(),
             name=item.display_name,
             description=item.description,
@@ -250,7 +263,7 @@ class _DTDLConverter:
             value_type = self.schema_to_value_type(field_.schema_, item)
             if value_type is None:
                 continue
-            prop = InformationProperty(
+            prop = InformationInputProperty(
                 class_=class_.class_,
                 name=field_.name,
                 description=field_.description,
@@ -272,8 +285,8 @@ class _DTDLConverter:
             return _DATA_TYPE_BY_NAME[input_type.casefold()]()
         elif isinstance(input_type, str):
             self.issues.append(
-                PropertyTypeNotSupportedError[str](
-                    (item.id_.model_dump() if item.id_ else item.display_name) or "missing",
+                PropertyTypeNotSupportedError(
+                    item.identifier_with_fallback,
                     item.type,
                     "schema",
                     input_type,
@@ -283,7 +296,7 @@ class _DTDLConverter:
         elif isinstance(input_type, Object | Interface):
             if input_type.id_ is None:
                 self.issues.append(
-                    MissingIdentifierError(
+                    ResourceMissingIdentifierError(
                         input_type.type,
                         input_type.display_name,
                     )
@@ -292,12 +305,12 @@ class _DTDLConverter:
             else:
                 if isinstance(input_type, Object):
                     self.convert_object(input_type, None)
-                return ClassEntity.load(input_type.id_.as_class_id())
+                return input_type.id_.as_class_id()
         else:
             self.issues.append(
                 PropertyTypeNotSupportedWarning(
-                    item.id_.model_dump() if item.id_ else item.display_name or "missing",
-                    item.type,
+                    item.identifier_with_fallback,
+                    item.type,  # type: ignore[arg-type]
                     "schema",
                     input_type.type if input_type else "missing",
                 )

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

@@ -2,23 +2,27 @@ import json
 import zipfile
 from collections.abc import Iterable, Sequence
 from pathlib import Path
-from typing import Literal, overload
 
 from pydantic import ValidationError
 
 from cognite.neat.issues import IssueList, NeatIssue
-from cognite.neat.rules import issues
-from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.importers._base import BaseImporter, _handle_issues
+from cognite.neat.issues.warnings import (
+    FileItemNotSupportedWarning,
+    FileMissingRequiredFieldWarning,
+    FileReadWarning,
+    FileTypeUnexpectedWarning,
+    NeatValueWarning,
+)
+from cognite.neat.rules._shared import ReadRules
+from cognite.neat.rules.importers._base import BaseImporter
 from cognite.neat.rules.importers._dtdl2rules.dtdl_converter import _DTDLConverter
 from cognite.neat.rules.importers._dtdl2rules.spec import DTDL_CLS_BY_TYPE_BY_SPEC, DTDLBase, Interface
-from cognite.neat.rules.issues import ValidationIssue
-from cognite.neat.rules.models import InformationRules, RoleTypes, SchemaCompleteness, SheetList
-from cognite.neat.rules.models.information import InformationClass, InformationProperty
-from cognite.neat.utils.text import to_pascal
+from cognite.neat.rules.models import InformationInputRules, SchemaCompleteness
+from cognite.neat.rules.models.information import InformationInputMetadata
+from cognite.neat.utils.text import humanize_collection, to_pascal
 
 
-class DTDLImporter(BaseImporter):
+class DTDLImporter(BaseImporter[InformationInputRules]):
     """Importer from Azure Digital Twin - DTDL (Digital Twin Definition Language).
 
     This importer supports DTDL v2.0 and v3.0.
@@ -42,15 +46,15 @@ class DTDLImporter(BaseImporter):
     ) -> None:
         self._items = items
         self.title = title
-        self._read_issues = read_issues
+        self._read_issues = IssueList(read_issues)
         self._schema_completeness = schema
 
     @classmethod
-    def _from_file_content(cls, file_content: str, filepath: Path) -> Iterable[DTDLBase | ValidationIssue]:
+    def _from_file_content(cls, file_content: str, filepath: Path) -> Iterable[DTDLBase | NeatIssue]:
         raw = json.loads(file_content)
         if isinstance(raw, dict):
             if (context := raw.get("@context")) is None:
-                yield issues.fileread.InvalidFileFormatWarning(filepath=filepath, reason="Missing '@context' key.")
+                yield FileMissingRequiredFieldWarning(filepath, "@context", "Missing '@context' key.")
                 return
             raw_list = [raw]
         elif isinstance(raw, list):
@@ -58,13 +62,11 @@ class DTDLImporter(BaseImporter):
                 (entry["@context"] for entry in raw if isinstance(entry, dict) and "@context" in entry), None
             )
             if context is None:
-                yield issues.fileread.InvalidFileFormatWarning(filepath=filepath, reason="Missing '@context' key.")
+                yield FileMissingRequiredFieldWarning(filepath, "@context", "Missing '@context' key.")
                 return
             raw_list = raw
         else:
-            yield issues.fileread.InvalidFileFormatWarning(
-                filepath=filepath, reason="Content is not an object or array."
-            )
+            yield FileTypeUnexpectedWarning(filepath, frozenset(["dict", "list"]), "Content is not an object or array.")
             return
 
         if isinstance(context, list):
@@ -74,23 +76,27 @@ class DTDLImporter(BaseImporter):
         try:
             cls_by_type = DTDL_CLS_BY_TYPE_BY_SPEC[spec_version]
         except KeyError:
-            yield issues.fileread.UnsupportedSpecWarning(filepath=filepath, version=spec_version, spec_name="DTDL")
+            yield NeatValueWarning(
+                f"Unsupported DTDL spec version: {spec_version} in {filepath}. "
+                f"Supported versions are {humanize_collection(DTDL_CLS_BY_TYPE_BY_SPEC.keys())}."
+                " The file will be skipped."
+            )
             return
 
         for item in raw_list:
             if not (type_ := item.get("@type")):
-                yield issues.fileread.InvalidFileFormatWarning(filepath=filepath, reason="Missing '@type' key.")
+                yield FileMissingRequiredFieldWarning(filepath, "@type", "Missing '@type' key.")
                 continue
             cls_ = cls_by_type.get(type_)
             if cls_ is None:
-                yield issues.fileread.UnknownItemWarning(reason=f"Unknown '@type' {type_}.", filepath=filepath)
+                yield FileItemNotSupportedWarning(f"Unknown '@type' {type_}.", filepath=filepath)
                 continue
             try:
                 yield cls_.model_validate(item)
             except ValidationError as e:
-                yield issues.fileread.InvalidFileFormatWarning(filepath=filepath, reason=str(e))
+                yield FileTypeUnexpectedWarning(filepath, frozenset([cls.__name__]), str(e))
             except Exception as e:
-                yield issues.fileread.BugInImporterWarning(filepath=filepath, error=str(e), importer_name=cls.__name__)
+                yield FileReadWarning(filepath=filepath, reason=str(e))
 
     @classmethod
     def from_directory(cls, directory: Path) -> "DTDLImporter":
@@ -112,23 +118,13 @@ class DTDLImporter(BaseImporter):
             for filepath in z.namelist():
                 if filepath.endswith(".json"):
                     for item in cls._from_file_content(z.read(filepath).decode(), Path(filepath)):
-                        if isinstance(item, ValidationIssue):
+                        if isinstance(item, NeatIssue):
                             issues.append(item)
                         else:
                             items.append(item)
         return cls(items, zip_file.stem, read_issues=issues)
 
-    @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
-
-    @overload
-    def to_rules(
-        self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
-
-    def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    def to_rules(self) -> ReadRules[InformationInputRules]:
         converter = _DTDLConverter(self._read_issues)
 
         converter.convert(self._items)
@@ -145,16 +141,11 @@ class DTDLImporter(BaseImporter):
             ...
         else:
             metadata["prefix"] = most_common_prefix
-        with _handle_issues(converter.issues) as future:
-            rules = InformationRules(
-                metadata=metadata,
-                properties=SheetList[InformationProperty](data=converter.properties),
-                classes=SheetList[InformationClass](data=converter.classes),
-            )
-        if future.result == "failure":
-            if errors == "continue":
-                return None, converter.issues
-            else:
-                raise converter.issues.as_errors()
 
-        return self._to_output(rules, converter.issues, errors, role)
+        rules = InformationInputRules(
+            metadata=InformationInputMetadata.load(metadata),
+            properties=converter.properties,
+            classes=converter.classes,
+        )
+
+        return ReadRules(rules, converter.issues, {})

cognite/neat/rules/importers/_dtdl2rules/spec.py

@@ -13,6 +13,7 @@ from abc import ABC
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, TypeAlias
 
 from pydantic import BaseModel, Field, field_validator, model_serializer, model_validator
+from pydantic.fields import FieldInfo
 
 from cognite.neat.rules.models.entities import ClassEntity
 
@@ -134,6 +135,10 @@ class DTDLBase(BaseModel, ABC):
     display_name: str | None = Field(None, alias="displayName")
     description: str | None = None
 
+    @property
+    def identifier_with_fallback(self) -> str:
+        return (self.id_.model_dump() if self.id_ else self.display_name) or "MISSING"
+
 
 PrimitiveSchema: TypeAlias = Literal[
     "boolean", "date", "dateTime", "double", "duration", "float", "integer", "long", "string", "time"
@@ -317,6 +322,8 @@ class Interface(DTDLBase):
         if not isinstance(value, list):
             return value
         context = info.data.get("@context", cls.default_context)
+        if isinstance(context, FieldInfo):
+            context = context.default
         spec_version = context.rsplit(";", maxsplit=1)[1]
         try:
             cls_by_type = DTDL_CLS_BY_TYPE_BY_SPEC[spec_version]

cognite/neat/rules/importers/_rdf/_imf2rules/_imf2classes.py

@@ -37,23 +37,27 @@ def parse_imf_to_classes(graph: Graph, language: str = "en") -> list[dict]:
     query = """
     SELECT ?class ?name ?description ?parentClass ?reference ?match ?comment
     WHERE {
-        #Finding IMF - elements
+        # Finding IMF - elements
         VALUES ?type { imf:BlockType imf:TerminalType imf:AttributeType }
         ?imfClass a ?type .
         OPTIONAL {?imfClass rdfs:subClassOf ?parent }.
         OPTIONAL {?imfClass rdfs:label | skos:prefLabel ?name }.
-        OPTIONAL {?imfClass rdfs:comment | skos:description ?description} .
+
+        # Note: Bug in PCA has lead to the use non-existing term skos:description. This will be replaced
+        # with the correct skos:definition in the near future, so both terms are included here.
+        OPTIONAL {?imfClass rdfs:comment | skos:definition | skos:description ?description} .
 
         # Finding the last segment of the class IRI
         BIND(STR(?imfClass) AS ?classString)
-        BIND(REPLACE(?classString, "^.*[/#]([^/#]*)$", "$1") AS ?classSegment)
+        BIND(REPLACE(?classString, "^.*[/#]([^/#]*)$", "$1") AS ?tempSegment)
+        BIND(REPLACE(?tempSegment, "-", "_") AS ?classSegment)
         BIND(IF(CONTAINS(?classString, "imf/"), CONCAT("IMF_", ?classSegment) , ?classSegment) AS ?class)
 
         # Add imf:Attribute as parent class
         BIND(IF(!bound(?parent) && ?type = imf:AttributeType, imf:Attribute, ?parent) AS ?parentClass)
 
         # Rebind the IRI of the IMF-type to the ?reference variable to align with dataframe column headers
-        # This is solely for readability, the ?imfClass could have been returnered directly instead of ?reference
+        # This is solely for readability, the ?imfClass could have been returned directly instead of ?reference
         BIND(?imfClass AS ?reference)
 
         FILTER (!isBlank(?class))

cognite/neat/rules/importers/_rdf/_imf2rules/_imf2metadata.py

@@ -19,12 +19,12 @@ def parse_imf_metadata() -> dict:
     raw_metadata = {
         "role": RoleTypes.information,
         "schema": SchemaCompleteness.partial,
-        "prefix": "pca-imf",
-        "namespace": Namespace("http://posccaesar.org/imf/"),
+        "prefix": "pcaimf",
+        "namespace": Namespace("https://posccaesar.org/imf/"),
         "version": None,
         "created": None,
         "updated": None,
-        "title": "IMF - types",
+        "title": "IMF_types",
         "description": "IMF - types",
         "creator": None,
         "rights": None,

cognite/neat/rules/importers/_rdf/_imf2rules/_imf2properties.py

@@ -36,7 +36,7 @@ def parse_imf_to_properties(graph: Graph, language: str = "en") -> list[dict]:
     """
 
     query = """
-    SELECT ?class ?property ?name ?description ?valueType ?minCount ?maxCount ?default ?reference
+    SELECT DISTINCT ?class ?property ?name ?description ?valueType ?minCount ?maxCount ?default ?reference
     ?match ?comment ?propertyType
     WHERE
     {
@@ -48,7 +48,7 @@ def parse_imf_to_properties(graph: Graph, language: str = "en") -> list[dict]:
                 ?propertyShape sh:path ?imfProperty .
 
             OPTIONAL { ?imfProperty skos:prefLabel ?name . }
-            OPTIONAL { ?imfProperty skos:description ?description . }
+            OPTIONAL { ?imfProperty skos:definition | skos:description ?description . }
             OPTIONAL { ?imfProperty rdfs:range ?range . }
             OPTIONAL { ?imfProperty a ?type . }
             OPTIONAL { ?propertyShape sh:minCount ?minCardinality} .
@@ -62,22 +62,24 @@ def parse_imf_to_properties(graph: Graph, language: str = "en") -> list[dict]:
             ?imfClass a imf:AttributeType ;
                 ?imfProperty ?default .
 
-            # imf:predicate is required
-            BIND(IF(?imfProperty = <http://ns.imfid.org/imf#predicate>, 1, 0) AS ?minCardinality)
-
             # The following information is used to describe the attribute when it is connected to a block or a terminal
             # and not duplicated here.
-            FILTER(?imfProperty != rdf:type && ?imfProperty != skos:prefLabel && ?imfProperty != skos:description)
+            # Note: Bug in PCA has lead to the use non-existing term skos:description. This will be replaced
+            # with the correct skos:definition in the near future, so both terms are included here.
+            FILTER(?imfProperty != rdf:type && ?imfProperty != skos:prefLabel &&
+                ?imfProperty != skos:defintion && ?imfProperty != skos:description)
         }
 
         # Finding the last segment of the class IRI
         BIND(STR(?imfClass) AS ?classString)
-        BIND(REPLACE(?classString, "^.*[/#]([^/#]*)$", "$1") AS ?classSegment)
+        BIND(REPLACE(?classString, "^.*[/#]([^/#]*)$", "$1") AS ?tempClassSegment)
+        BIND(REPLACE(?tempClassSegment, "-", "_") AS ?classSegment)
         BIND(IF(CONTAINS(?classString, "imf/"), CONCAT("IMF_", ?classSegment) , ?classSegment) AS ?class)
 
         # Finding the last segment of the property IRI
         BIND(STR(?imfProperty) AS ?propertyString)
-        BIND(REPLACE(?propertyString, "^.*[/#]([^/#]*)$", "$1") AS ?propertySegment)
+        BIND(REPLACE(?propertyString, "^.*[/#]([^/#]*)$", "$1") AS ?tempPropertySegment)
+        BIND(REPLACE(?tempPropertySegment, "-", "_") AS ?propertySegment)
         BIND(IF(CONTAINS(?propertyString, "imf/"), CONCAT("IMF_", ?propertySegment) , ?propertySegment) AS ?property)
 
         # Set the value type for the property based on sh:class, sh:qualifiedValueType or rdfs:range
@@ -85,12 +87,17 @@ def parse_imf_to_properties(graph: Graph, language: str = "en") -> list[dict]:
 
         # Finding the last segment of value types
         BIND(STR(?valueIriType) AS ?valueTypeString)
-        BIND(REPLACE(?valueTypeString, "^.*[/#]([^/#]*)$", "$1") AS ?valueTypeSegment)
+        BIND(REPLACE(?valueTypeString, "^.*[/#]([^/#]*)$", "$1") AS ?tempValueTypeSegment)
+        BIND(REPLACE(?tempValueTypeSegment, "-", "_") AS ?valueTypeSegment)
         BIND(IF(CONTAINS(?valueTypeString, "imf/"), CONCAT("IMF_", ?valueTypeSegment) , ?valueTypeSegment)
             AS ?valueType)
 
-        # Helper variable to set property type if value type is not already set.
-        BIND(IF(BOUND(?type) && ?type = owl:DatatypeProperty, ?type , owl:ObjectProperty) AS ?propertyType)
+        # Helper variable to set owl datatype- or object-property if this is not already set.
+        BIND(IF( EXISTS {?imfProperty a ?tempPropertyType . FILTER(?tempPropertyType = owl:DatatypeProperty) },
+            owl:DatatypeProperty,
+            owl:ObjectProperty
+            )
+        AS ?propertyType)
 
         # Assert cardinality values if they do not exist
         BIND(IF(BOUND(?minCardinality), ?minCardinality, 0) AS ?minCount)

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

@@ -2,13 +2,14 @@
 there are loaders to TransformationRules pydantic class."""
 
 from pathlib import Path
-from typing import Literal, overload
 
 from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SH, SKOS, Graph
 
 from cognite.neat.issues import IssueList
-from cognite.neat.rules.importers._base import BaseImporter, Rules
-from cognite.neat.rules.models import InformationRules, RoleTypes
+from cognite.neat.issues.errors import FileReadError
+from cognite.neat.rules._shared import ReadRules
+from cognite.neat.rules.importers._base import BaseImporter
+from cognite.neat.rules.models import InformationInputRules
 from cognite.neat.rules.models.data_types import _XSD_TYPES
 
 from ._imf2classes import parse_imf_to_classes
@@ -16,7 +17,7 @@ from ._imf2metadata import parse_imf_metadata
 from ._imf2properties import parse_imf_to_properties
 
 
-class IMFImporter(BaseImporter):
+class IMFImporter(BaseImporter[InformationInputRules]):
     """Convert SHACL shapes to tables/ transformation rules / Excel file.
 
         Args:
@@ -36,24 +37,16 @@ class IMFImporter(BaseImporter):
     """
 
     def __init__(self, filepath: Path):
-        self.owl_filepath = filepath
-
-    @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
-
-    @overload
-    def to_rules(
-        self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
+        self.filepath = filepath
 
     def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+        self,
+    ) -> ReadRules[InformationInputRules]:
         graph = Graph()
         try:
-            graph.parse(self.owl_filepath)
+            graph.parse(self.filepath)
         except Exception as e:
-            raise Exception(f"Could not parse owl file: {e}") from e
+            return ReadRules(None, IssueList([FileReadError(self.filepath, f"Could not parse owl file: {e}")]), {})
 
         # bind key namespaces
         graph.bind("owl", OWL)
@@ -74,8 +67,8 @@ class IMFImporter(BaseImporter):
 
         components = make_components_compliant(components)
 
-        rules = InformationRules.model_validate(components)
-        return self._to_output(rules, IssueList(), errors, role)
+        rules = InformationInputRules.load(components)
+        return ReadRules(rules, IssueList(), {})
 
 
 def make_components_compliant(components: dict) -> dict: