cognite-neat 0.88.1__py3-none-any.whl → 0.88.3__py3-none-any.whl

cognite/neat/rules/importers/_dms2rules.py

@@ -18,9 +18,14 @@ from cognite.client.data_classes.data_modeling.views import (
 )
 from cognite.client.utils import ms_to_datetime
 
-from cognite.neat.rules import issues
-from cognite.neat.rules.importers._base import BaseImporter, Rules, _handle_issues
-from cognite.neat.rules.issues import IssueList, ValidationIssue
+from cognite.neat.issues import IssueList, NeatIssue
+from cognite.neat.issues.errors import FileTypeUnexpectedError, ResourceMissingIdentifierError, ResourceRetrievalError
+from cognite.neat.issues.warnings import (
+    PropertyNotFoundWarning,
+    PropertyTypeNotSupportedWarning,
+    ResourceNotFoundWarning,
+)
+from cognite.neat.rules.importers._base import BaseImporter, VerifiedRules, _handle_issues
 from cognite.neat.rules.models import (
     DataModelType,
     DMSRules,
@@ -60,7 +65,7 @@ class DMSImporter(BaseImporter):
     def __init__(
         self,
         schema: DMSSchema,
-        read_issues: Sequence[ValidationIssue] | None = None,
+        read_issues: Sequence[NeatIssue] | None = None,
         metadata: DMSMetadata | None = None,
         ref_metadata: DMSMetadata | None = None,
     ):
@@ -100,14 +105,28 @@ class DMSImporter(BaseImporter):
 
         user_models = cls._find_model_in_list(data_models, data_model_id)
         if len(user_models) == 0:
-            return cls(DMSSchema(), [issues.importing.NoDataModelError(f"Data model {data_model_id} not found")])
+            return cls(
+                DMSSchema(),
+                [
+                    ResourceRetrievalError(
+                        dm.DataModelId.load(reference_model_id),  # type: ignore[arg-type]
+                        "data model",
+                        "Data Model is missing in CDF",
+                    )
+                ],
+            )
         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(), [issues.importing.NoDataModelError(f"Data model {reference_model_id} not found")]
+                    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:
@@ -178,29 +197,29 @@ class DMSImporter(BaseImporter):
     @classmethod
     def from_zip_file(cls, zip_file: str | Path) -> "DMSImporter":
         if Path(zip_file).suffix != ".zip":
-            return cls(DMSSchema(), [issues.fileread.InvalidFileFormatError(Path(zip_file), [".zip"])])
+            return cls(DMSSchema(), [FileTypeUnexpectedError(Path(zip_file), frozenset([".zip"]))])
         issue_list = IssueList()
         with _handle_issues(issue_list) as _:
             schema = DMSSchema.from_zip(zip_file)
         return cls(schema, issue_list)
 
     @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
+    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> VerifiedRules: ...
 
     @overload
     def to_rules(
         self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
+    ) -> tuple[VerifiedRules | None, IssueList]: ...
 
     def to_rules(
         self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         if self.issue_list.has_errors:
             # In case there were errors during the import, the to_rules method will return None
             return self._return_or_raise(self.issue_list, errors)
 
         if not self.root_schema.data_model:
-            self.issue_list.append(issues.importing.NoDataModelError("No data model found."))
+            self.issue_list.append(ResourceMissingIdentifierError("data model", type(self.root_schema).__name__))
             return self._return_or_raise(self.issue_list, errors)
         model = self.root_schema.data_model
         with _handle_issues(
@@ -301,10 +320,11 @@ class DMSImporter(BaseImporter):
     ) -> DMSProperty | None:
         if isinstance(prop, dm.MappedPropertyApply) and prop.container not in self._all_containers_by_id:
             self.issue_list.append(
-                issues.importing.MissingContainerWarning(
-                    view_id=str(view_entity),
-                    property_=prop_id,
-                    container_id=str(ContainerEntity.from_id(prop.container)),
+                ResourceNotFoundWarning[dm.ContainerId, dm.PropertyId](
+                    dm.ContainerId.load(prop.container),
+                    "container",
+                    view_entity.to_property_id(prop_id),
+                    "view property",
                 )
             )
             return None
@@ -313,11 +333,7 @@ class DMSImporter(BaseImporter):
             and prop.container_property_identifier not in self._all_containers_by_id[prop.container].properties
         ):
             self.issue_list.append(
-                issues.importing.MissingContainerPropertyWarning(
-                    view_id=str(view_entity),
-                    property_=prop_id,
-                    container_id=str(ContainerEntity.from_id(prop.container)),
-                )
+                PropertyNotFoundWarning(prop.container, "container", prop_id, view_entity.as_id(), "view"),
             )
             return None
         if not isinstance(
@@ -329,7 +345,7 @@ class DMSImporter(BaseImporter):
             | MultiReverseDirectRelationApply,
         ):
             self.issue_list.append(
-                issues.importing.UnknownPropertyTypeWarning(view_entity.versioned_id, prop_id, type(prop).__name__)
+                PropertyTypeNotSupportedWarning[dm.ViewId](view_entity.as_id(), "view", prop_id, type(prop).__name__)
             )
             return None
 
@@ -394,7 +410,9 @@ class DMSImporter(BaseImporter):
             else:
                 return DataType.load(container_prop.type._type)
         else:
-            self.issue_list.append(issues.importing.FailedToInferValueTypeWarning(str(view_entity), prop_id))
+            self.issue_list.append(
+                PropertyTypeNotSupportedWarning[dm.ViewId](view_entity.as_id(), "view", prop_id, type(prop).__name__)
+            )
             return None
 
     def _get_nullable(self, prop: ViewPropertyApply) -> bool | None:
@@ -453,8 +471,8 @@ class DMSImporter(BaseImporter):
                 continue
             else:
                 self.issue_list.append(
-                    issues.importing.UnknownContainerConstraintWarning(
-                        str(ContainerEntity.from_id(prop.container)), prop_id, type(constraint_obj).__name__
+                    PropertyTypeNotSupportedWarning[dm.ContainerId](
+                        prop.container, "container", prop_id, type(constraint_obj).__name__
                     )
                 )
         return unique_constraints or None

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

@@ -1,14 +1,20 @@
 from collections import Counter
 from collections.abc import Callable, Sequence
 
-import cognite.neat.rules.issues.importing
-from cognite.neat.rules import issues
+from cognite.neat.issues import IssueList, NeatIssue
+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,
     CommandV2,
     Component,
     DTDLBase,
+    DTDLBaseWithName,
     Enum,
     Interface,
     Object,
@@ -19,15 +25,14 @@ from cognite.neat.rules.importers._dtdl2rules.spec import (
     Telemetry,
     TelemetryV2,
 )
-from cognite.neat.rules.issues import IssueList, ValidationIssue
 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
 
 
 class _DTDLConverter:
-    def __init__(self, issues: list[ValidationIssue] | None = None) -> None:
-        self.issues: IssueList = IssueList(issues or [])
+    def __init__(self, issues: list[NeatIssue] | None = None) -> None:
+        self.issues = IssueList(issues or [])
         self.properties: list[InformationProperty] = []
         self.classes: list[InformationClass] = []
         self._item_by_id: dict[DTMI, DTDLBase] = {}
@@ -75,11 +80,10 @@ class _DTDLConverter:
             convert_method(item, parent)
         else:
             self.issues.append(
-                issues.importing.UnknownComponentWarning(
-                    component_type=item.type,
-                    instance_name=item.display_name,
-                    instance_id=item.id_.model_dump() if item.id_ else None,
-                )
+                ResourceTypeNotSupportedWarning(
+                    item.identifier_with_fallback,
+                    item.type,
+                ),
             )
 
     def convert_interface(self, item: Interface, _: str | None) -> None:
@@ -94,11 +98,11 @@ class _DTDLConverter:
         for sub_item_or_id in item.contents or []:
             if isinstance(sub_item_or_id, DTMI) and sub_item_or_id not in self._item_by_id:
                 self.issues.append(
-                    issues.importing.UnknownPropertyWarning(
-                        component_type=item.type,
-                        property_name=sub_item_or_id.path[-1],
-                        instance_name=item.display_name,
-                        instance_id=item.id_.model_dump(),
+                    PropertyTypeNotSupportedWarning(
+                        item.id_.model_dump() or item.display_name or "missing",
+                        item.type,
+                        sub_item_or_id.path[-1],
+                        ".".join(sub_item_or_id.path),
                     )
                 )
             elif isinstance(sub_item_or_id, DTMI):
@@ -130,12 +134,13 @@ class _DTDLConverter:
         )
         self.properties.append(prop)
 
-    def _missing_parent_warning(self, item):
+    def _missing_parent_warning(self, item: DTDLBaseWithName):
         self.issues.append(
-            cognite.neat.rules.issues.importing.MissingParentDefinitionError(
-                component_type=item.type,
-                instance_name=item.display_name,
-                instance_id=item.id_.model_dump() if item.id_ else None,
+            ResourceNotFoundError(
+                "UNKNOWN",
+                "parent",
+                item.identifier_with_fallback,
+                item.type,
             )
         )
 
@@ -151,22 +156,15 @@ class _DTDLConverter:
             return None
         if item.request is None:
             self.issues.append(
-                issues.importing.UnknownSubComponentWarning(
-                    component_type=item.type,
-                    sub_component="request",
-                    instance_name=item.display_name,
-                    instance_id=item.id_.model_dump() if item.id_ else None,
-                )
+                ResourceTypeNotSupportedWarning[str](
+                    item.identifier_with_fallback,
+                    f"{item.type}.request",
+                ),
             )
             return None
         if item.response is not None:
             # Currently, we do not know how to handle response
-            self.issues.append(
-                issues.importing.IgnoredComponentWarning(
-                    identifier=f"{parent}.response",
-                    reason="Neat does not have a concept of response for commands. This will be ignored.",
-                )
-            )
+            self.issues.append(ResourceTypeNotSupportedWarning[str](f"{parent}.response", "Command.Response"))
         value_type = self.schema_to_value_type(item.request.schema_, item)
         if value_type is None:
             return
@@ -213,10 +211,9 @@ class _DTDLConverter:
             else:
                 # Falling back to json
                 self.issues.append(
-                    cognite.neat.rules.issues.importing.MissingIdentifierError(
-                        component_type="Unknown",
-                        instance_name=item.target.model_dump(),
-                        instance_id=item.target.model_dump(),
+                    ResourceMissingIdentifierError(
+                        "unknown",
+                        item.target.model_dump(),
                     )
                 )
                 value_type = Json()
@@ -239,9 +236,9 @@ class _DTDLConverter:
     def convert_object(self, item: Object, _: str | None) -> None:
         if item.id_ is None:
             self.issues.append(
-                cognite.neat.rules.issues.importing.MissingIdentifierError(
-                    component_type=item.type,
-                    instance_name=item.display_name,
+                ResourceMissingIdentifierError(
+                    resource_type=item.type,
+                    name=item.display_name,
                 )
             )
             return None
@@ -280,21 +277,20 @@ class _DTDLConverter:
             return _DATA_TYPE_BY_NAME[input_type.casefold()]()
         elif isinstance(input_type, str):
             self.issues.append(
-                cognite.neat.rules.issues.importing.UnsupportedPropertyTypeError(
-                    component_type=item.type,
-                    property_type=input_type,
-                    property_name="schema",
-                    instance_name=item.display_name,
-                    instance_id=item.id_.model_dump() if item.id_ else None,
+                PropertyTypeNotSupportedError(
+                    item.identifier_with_fallback,
+                    item.type,
+                    "schema",
+                    input_type,
                 )
             )
             return None
         elif isinstance(input_type, Object | Interface):
             if input_type.id_ is None:
                 self.issues.append(
-                    cognite.neat.rules.issues.importing.MissingIdentifierError(
-                        component_type=input_type.type,
-                        instance_name=input_type.display_name,
+                    ResourceMissingIdentifierError(
+                        input_type.type,
+                        input_type.display_name,
                     )
                 )
                 return Json()
@@ -304,11 +300,11 @@ class _DTDLConverter:
                 return ClassEntity.load(input_type.id_.as_class_id())
         else:
             self.issues.append(
-                issues.importing.UnknownPropertyWarning(
-                    component_type=item.type,
-                    property_name="schema",
-                    instance_name=item.display_name,
-                    instance_id=item.id_.model_dump() if item.id_ else None,
+                PropertyTypeNotSupportedWarning(
+                    item.identifier_with_fallback,
+                    item.type,  # type: ignore[arg-type]
+                    "schema",
+                    input_type.type if input_type else "missing",
                 )
             )
             return None

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

@@ -6,15 +6,21 @@ from typing import Literal, overload
 
 from pydantic import ValidationError
 
-from cognite.neat.rules import issues
-from cognite.neat.rules._shared import Rules
+from cognite.neat.issues import IssueList, NeatIssue
+from cognite.neat.issues.warnings import (
+    FileItemNotSupportedWarning,
+    FileMissingRequiredFieldWarning,
+    FileReadWarning,
+    FileTypeUnexpectedWarning,
+    NeatValueWarning,
+)
+from cognite.neat.rules._shared import VerifiedRules
 from cognite.neat.rules.importers._base import BaseImporter, _handle_issues
 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 IssueList, 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.utils.text import humanize_collection, to_pascal
 
 
 class DTDLImporter(BaseImporter):
@@ -36,7 +42,7 @@ class DTDLImporter(BaseImporter):
         self,
         items: Sequence[DTDLBase],
         title: str | None = None,
-        read_issues: list[ValidationIssue] | None = None,
+        read_issues: list[NeatIssue] | None = None,
         schema: SchemaCompleteness = SchemaCompleteness.partial,
     ) -> None:
         self._items = items
@@ -45,11 +51,11 @@ class DTDLImporter(BaseImporter):
         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):
@@ -57,13 +63,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):
@@ -73,31 +77,35 @@ 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":
         items: list[DTDLBase] = []
-        issues: list[ValidationIssue] = []
+        issues: list[NeatIssue] = []
         for filepath in directory.glob("**/*.json"):
             for item in cls._from_file_content(filepath.read_text(), filepath):
-                if isinstance(item, ValidationIssue):
+                if isinstance(item, NeatIssue):
                     issues.append(item)
                 else:
                     items.append(item)
@@ -106,28 +114,28 @@ class DTDLImporter(BaseImporter):
     @classmethod
     def from_zip(cls, zip_file: Path) -> "DTDLImporter":
         items: list[DTDLBase] = []
-        issues: list[ValidationIssue] = []
+        issues: list[NeatIssue] = []
         with zipfile.ZipFile(zip_file) as z:
             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: ...
+    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> VerifiedRules: ...
 
     @overload
     def to_rules(
         self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
+    ) -> tuple[VerifiedRules | None, IssueList]: ...
 
     def to_rules(
         self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         converter = _DTDLConverter(self._read_issues)
 
         converter.convert(self._items)

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/__init__.py

@@ -0,0 +1,3 @@
+from ._imf2rules import IMFImporter
+
+__all__ = ["IMFImporter"]

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

@@ -0,0 +1,82 @@
+from typing import cast
+
+from rdflib import Graph
+
+from cognite.neat.rules.importers._rdf._shared import (
+    clean_up_classes,
+    make_classes_compliant,
+    parse_raw_classes_dataframe,
+)
+
+
+def parse_imf_to_classes(graph: Graph, language: str = "en") -> list[dict]:
+    """Parse IMF elements from RDF-graph and extract classes to pandas dataframe.
+
+    Args:
+        graph: Graph containing imf elements
+        language: Language to use for parsing, by default "en"
+
+    Returns:
+        Dataframe containing imf elements
+
+    !!! note "IMF Compliance"
+        The IMF elements are expressed in RDF, primarily using SHACL and OWL. To ensure
+        that the resulting classes are compliant with CDF, similar validation checks as
+        in the OWL ontology importer are applied.
+
+        For the IMF-types more of the compliance logic is placed directly in the SPARQL
+        query. Among these are the creation of class name not starting with a number,
+        and ensuring that all classes have a parent.
+
+        IMF-attributes are considered both classes and properties. This kind of punning
+        is necessary to capture additional information carried by attributes. They carry,
+        among other things, a set of relationsships to reference terms, units of measure,
+        and qualifiers that together make up the meaning of the attribute.
+    """
+
+    query = """
+    SELECT ?class ?name ?description ?parentClass ?reference ?match ?comment
+    WHERE {
+        #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} .
+
+        # Finding the last segment of the class IRI
+        BIND(STR(?imfClass) AS ?classString)
+        BIND(REPLACE(?classString, "^.*[/#]([^/#]*)$", "$1") 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 returned directly instead of ?reference
+        BIND(?imfClass AS ?reference)
+
+        FILTER (!isBlank(?class))
+        FILTER (!bound(?parentClass) || !isBlank(?parentClass))
+        FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "en"))
+        FILTER (!bound(?description) || LANG(?description) = "" || LANGMATCHES(LANG(?description), "en"))
+    }
+    """
+
+    # create raw dataframe
+    raw_df = parse_raw_classes_dataframe(cast(list[tuple], list(graph.query(query.replace("en", language)))))
+    if raw_df.empty:
+        return []
+
+    # group values and clean up
+    processed_df = clean_up_classes(raw_df)
+
+    # make compliant
+    processed_df = make_classes_compliant(processed_df, importer="IMF")
+
+    # Make Parent Class list elements into string joined with comma
+    processed_df["Parent Class"] = processed_df["Parent Class"].apply(
+        lambda x: ", ".join(x) if isinstance(x, list) and x else None
+    )
+
+    return processed_df.dropna(axis=0, how="all").replace(float("nan"), None).to_dict(orient="records")

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

@@ -0,0 +1,34 @@
+from rdflib import Namespace
+
+from cognite.neat.rules.importers._rdf._shared import make_metadata_compliant
+from cognite.neat.rules.models import RoleTypes, SchemaCompleteness
+
+
+def parse_imf_metadata() -> dict:
+    """Provide hardcoded IMF metadata to dict.
+
+    Returns:
+        Dictionary containing IMF metadata
+
+    !!! note "Compliant IMF metadata"
+        The current RDF provide IMF types as SHACL, but there are not any metadata describing
+        the actual content.
+
+    """
+
+    raw_metadata = {
+        "role": RoleTypes.information,
+        "schema": SchemaCompleteness.partial,
+        "prefix": "pca-imf",
+        "namespace": Namespace("http://posccaesar.org/imf/"),
+        "version": None,
+        "created": None,
+        "updated": None,
+        "title": "IMF - types",
+        "description": "IMF - types",
+        "creator": None,
+        "rights": None,
+        "license": None,
+    }
+
+    return make_metadata_compliant(raw_metadata)