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

cognite/neat/rules/exporters/_validation.py

@@ -1,11 +1,11 @@
-import re
 import warnings
 from typing import Literal, overload
 
 from cognite.neat.exceptions import wrangle_warnings
-from cognite.neat.rules import exceptions
+from cognite.neat.issues.neat_warnings.properties import PropertyRedefinedWarning
+from cognite.neat.rules.issues.dms import EntityIDNotDMSCompliantWarning
 from cognite.neat.rules.models import InformationRules
-from cognite.neat.rules.models._types._base import DMS_PROPERTY_ID_COMPLIANCE_REGEX, VIEW_ID_COMPLIANCE_REGEX
+from cognite.neat.utils.regex_patterns import DMS_PROPERTY_ID_COMPLIANCE_REGEX, PATTERNS, VIEW_ID_COMPLIANCE_REGEX
 
 
 @overload
@@ -26,35 +26,30 @@ def are_entity_names_dms_compliant(
     flag: bool = True
     with warnings.catch_warnings(record=True) as validation_warnings:
         for class_ in rules.classes:
-            if not re.match(VIEW_ID_COMPLIANCE_REGEX, str(class_.class_.suffix)):
+            if not PATTERNS.view_id_compliance.match(class_.class_.suffix):
                 warnings.warn(
-                    exceptions.EntityIDNotDMSCompliant(
-                        "Class", class_.class_.versioned_id, f"[Classes/Class/{class_.class_.versioned_id}]"
-                    ).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    EntityIDNotDMSCompliantWarning(class_.class_.versioned_id, "Class", VIEW_ID_COMPLIANCE_REGEX),
                     stacklevel=2,
                 )
                 flag = False
 
-        for row, property_ in enumerate(rules.properties):
+        for _, property_ in enumerate(rules.properties):
             # check class id which would resolve as view/container id
-            if not re.match(VIEW_ID_COMPLIANCE_REGEX, str(property_.class_.suffix)):
+            if not PATTERNS.view_id_compliance.match(property_.class_.suffix):
                 warnings.warn(
-                    exceptions.EntityIDNotDMSCompliant(
-                        "Class", property_.class_.versioned_id, f"[Properties/Class/{row}]"
-                    ).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    EntityIDNotDMSCompliantWarning(
+                        property_.class_.versioned_id,
+                        "Class",
+                        VIEW_ID_COMPLIANCE_REGEX,
+                    ),
                     stacklevel=2,
                 )
                 flag = False
 
             # check property id which would resolve as view/container id
-            if not re.match(DMS_PROPERTY_ID_COMPLIANCE_REGEX, property_.property_):
+            if not PATTERNS.dms_property_id_compliance.match(property_.property_):
                 warnings.warn(
-                    exceptions.EntityIDNotDMSCompliant(
-                        "Property", property_.property_, f"[Properties/Property/{row}]"
-                    ).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    EntityIDNotDMSCompliantWarning(property_.property_, "Property", DMS_PROPERTY_ID_COMPLIANCE_REGEX),
                     stacklevel=2,
                 )
                 flag = False
@@ -83,8 +78,7 @@ def are_properties_redefined(rules: InformationRules, return_report: bool = Fals
             elif property_.class_ in analyzed_properties[property_.property_]:
                 flag = True
                 warnings.warn(
-                    exceptions.PropertyRedefined(property_.property_, property_.class_.versioned_id).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    PropertyRedefinedWarning[str](property_.class_.versioned_id, "Class", property_.property_),
                     stacklevel=2,
                 )
 

cognite/neat/rules/importers/__init__.py

@@ -1,14 +1,16 @@
 from ._base import BaseImporter
 from ._dms2rules import DMSImporter
 from ._dtdl2rules import DTDLImporter
-from ._inference2rules import InferenceImporter
-from ._owl2rules import OWLImporter
+from ._rdf._imf2rules import IMFImporter
+from ._rdf._inference2rules import InferenceImporter
+from ._rdf._owl2rules import OWLImporter
 from ._spreadsheet2rules import ExcelImporter, GoogleSheetImporter
 from ._yaml2rules import YAMLImporter
 
 __all__ = [
     "BaseImporter",
     "OWLImporter",
+    "IMFImporter",
     "DMSImporter",
     "ExcelImporter",
     "GoogleSheetImporter",
@@ -25,7 +27,9 @@ def _repr_html_() -> str:
         [
             {
                 "Importer": name,
-                "Description": globals()[name].__doc__.strip().split("\n")[0] if globals()[name].__doc__ else "Missing",
+                "Description": (
+                    globals()[name].__doc__.strip().split("\n")[0] if globals()[name].__doc__ else "Missing"
+                ),
             }
             for name in __all__
             if name != "BaseImporter"

cognite/neat/rules/importers/_base.py

@@ -9,9 +9,9 @@ from typing import Any, Literal, overload
 from pydantic import ValidationError
 from rdflib import Namespace
 
+from cognite.neat.issues import IssueList, NeatError, NeatWarning
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.issues.base import (
-    IssueList,
     NeatValidationError,
     ValidationWarning,
 )
@@ -103,8 +103,8 @@ class _FutureResult:
 @contextmanager
 def _handle_issues(
     issues: IssueList,
-    error_cls: type[NeatValidationError] = NeatValidationError,
-    warning_cls: type[ValidationWarning] = ValidationWarning,
+    error_cls: type[NeatError] = NeatValidationError,
+    warning_cls: type[NeatWarning] = ValidationWarning,
     error_args: dict[str, Any] | None = None,
 ) -> Iterator[_FutureResult]:
     """This is an internal help function to handle issues and warnings.

cognite/neat/rules/importers/_dms2rules.py

@@ -18,9 +18,15 @@ from cognite.client.data_classes.data_modeling.views import (
 )
 from cognite.client.utils import ms_to_datetime
 
+from cognite.neat.issues import IssueList, NeatIssue
+from cognite.neat.issues.errors.resources import ResourceNotFoundError
+from cognite.neat.issues.neat_warnings.properties import (
+    PropertyTypeNotSupportedWarning,
+    ReferredPropertyNotFoundWarning,
+)
+from cognite.neat.issues.neat_warnings.resources import ReferredResourceNotFoundWarning
 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.rules.models import (
     DataModelType,
     DMSRules,
@@ -60,7 +66,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 +106,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(),
+                [
+                    ResourceNotFoundError[dm.DataModelId](
+                        dm.DataModelId.load(reference_model_id),  # type: ignore[arg-type]
+                        "DataModel",
+                        "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(),
+                    [
+                        ResourceNotFoundError[dm.DataModelId](
+                            dm.DataModelId.load(reference_model_id), "DataModel", "Data Model is missing in CDF"
+                        )
+                    ],
                 )
             ref_model: dm.DataModel[dm.View] | None = ref_models.latest_version()
         else:
@@ -200,7 +220,7 @@ class DMSImporter(BaseImporter):
             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(ResourceNotFoundError[str]("Unknown", "DataModel", "Identifier is missing"))
             return self._return_or_raise(self.issue_list, errors)
         model = self.root_schema.data_model
         with _handle_issues(
@@ -301,10 +321,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)),
+                ReferredResourceNotFoundWarning[dm.ContainerId, dm.PropertyId](
+                    dm.ContainerId.load(prop.container),
+                    "Container",
+                    view_entity.to_property_id(prop_id),
+                    "View Property",
                 )
             )
             return None
@@ -313,11 +334,9 @@ 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)),
-                )
+                ReferredPropertyNotFoundWarning[dm.ContainerId, dm.ViewId](
+                    prop.container, "Container", view_entity.as_id(), "View", prop_id
+                ),
             )
             return None
         if not isinstance(
@@ -329,7 +348,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 +413,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 +474,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,18 @@
 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.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.rules.importers._dtdl2rules.spec import (
     DTMI,
     Command,
     CommandV2,
     Component,
     DTDLBase,
+    DTDLBaseWithName,
     Enum,
     Interface,
     Object,
@@ -19,15 +23,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 +78,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[str](
+                    item.id_.model_dump() if item.id_ else item.display_name or "missing",
+                    item.type,
+                ),
             )
 
     def convert_interface(self, item: Interface, _: str | None) -> None:
@@ -94,11 +96,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 +132,10 @@ 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[str](
+                (item.id_.model_dump() if item.id_ else item.display_name) or "missing", item.type, "parent missing"
             )
         )
 
@@ -151,22 +151,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.id_.model_dump() if item.id_ else item.display_name or "missing",
+                    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 +206,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(),
+                    MissingIdentifierError(
+                        "Unknown",
+                        item.target.model_dump(),
                     )
                 )
                 value_type = Json()
@@ -239,9 +231,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,
+                MissingIdentifierError(
+                    resource_type=item.type,
+                    name=item.display_name,
                 )
             )
             return None
@@ -280,21 +272,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[str](
+                    (item.id_.model_dump() if item.id_ else item.display_name) or "missing",
+                    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,
+                    MissingIdentifierError(
+                        input_type.type,
+                        input_type.display_name,
                     )
                 )
                 return Json()
@@ -304,11 +295,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.id_.model_dump() if item.id_ else item.display_name or "missing",
+                    item.type,
+                    "schema",
+                    input_type.type if input_type else "missing",
                 )
             )
             return None

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

@@ -6,12 +6,13 @@ 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.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.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
@@ -36,7 +37,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
@@ -94,10 +95,10 @@ class DTDLImporter(BaseImporter):
     @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,7 +107,7 @@ 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"):

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 returnered 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)