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

cognite/neat/issues/neat_warnings/properties.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass
+from typing import Any, Generic
+
+from .resources import ResourceWarning, T_Identifier, T_ReferenceIdentifier
+
+
+@dataclass(frozen=True)
+class PropertyTypeNotSupportedWarning(ResourceWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has a property {property_name}
+    of unsupported type {property_type}. This will be ignored."""
+
+    property_name: str
+    property_type: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type,
+            identifier=repr(self.identifier),
+            property_name=self.property_name,
+            property_type=self.property_type,
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["property_name"] = self.property_name
+        output["property_type"] = self.property_type
+        return output
+
+
+@dataclass(frozen=True)
+class ReferredPropertyNotFoundWarning(ResourceWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} with identifier {identifier} does not have a property {property_name} referred
+    to by {referred_type} {referred_by} does not exist. This will be ignored.
+    """
+
+    fix = "Ensure the {resource_type} {identifier} has a {property_name} property"
+
+    referred_by: T_ReferenceIdentifier
+    referred_type: str
+    property_name: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type,
+            identifier=repr(self.identifier),
+            referred_type=self.referred_type,
+            referred_by=repr(self.referred_by),
+            property_name=self.property_name,
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["identifier"] = self.identifier
+        output["referred_by"] = self.referred_by
+        output["referred_type"] = self.referred_type
+        output["property_name"] = self.property_name
+        return output
+
+
+@dataclass(frozen=True)
+class PropertyRedefinedWarning(ResourceWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has a property {property_name} redefined."""
+
+    property_id: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type, identifier=repr(self.identifier), property_name=self.property_id
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["property_id"] = self.property_id
+        output["resource_type"] = self.resource_type
+        output["identifier"] = self.identifier
+        return output

cognite/neat/issues/neat_warnings/resources.py

@@ -0,0 +1,125 @@
+from collections.abc import Hashable
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar
+
+from cognite.neat.issues import NeatWarning
+
+T_Identifier = TypeVar("T_Identifier", bound=Hashable)
+
+T_ReferenceIdentifier = TypeVar("T_ReferenceIdentifier", bound=Hashable)
+
+
+@dataclass(frozen=True)
+class ResourceWarning(NeatWarning, Generic[T_Identifier]):
+    """Base class for resource warnings"""
+
+    identifier: T_Identifier
+    resource_type: str
+
+
+@dataclass(frozen=True)
+class ResourceNotFoundWarning(ResourceWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} is missing: {reason}. This will be ignored."""
+
+    fix = "Check the {resource_type} {identifier} and try again."
+    reason: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type, identifier=repr(self.identifier), reason=self.reason
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["identifier"] = self.identifier
+        output["reason"] = self.reason
+        return output
+
+
+@dataclass(frozen=True)
+class ReferredResourceNotFoundWarning(ResourceWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} with identifier {identifier} referred by {referred_type} {referred_by} does not exist.
+    This will be ignored."""
+
+    fix = "Create the {resource_type}"
+
+    referred_by: T_ReferenceIdentifier
+    referred_type: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type,
+            identifier=repr(self.identifier),
+            referred_type=self.referred_type,
+            referred_by=repr(self.referred_by),
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["identifier"] = self.identifier
+        output["referred_by"] = self.referred_by
+        output["referred_type"] = self.referred_type
+        return output
+
+
+@dataclass(frozen=True)
+class MultipleResourcesWarning(NeatWarning, Generic[T_Identifier]):
+    """Multiple resources of type {resource_type} with identifiers {resources} were found. This will be ignored."""
+
+    fix = "Remove the duplicate resources"
+
+    resources: frozenset[T_Identifier]
+    resource_type: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type,
+            resources=self.resources,
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["resources"] = self.resources
+        return output
+
+
+@dataclass(frozen=True)
+class FailedLoadingResourcesWarning(NeatWarning, Generic[T_Identifier]):
+    """Failed to load resources of type {resource_type} with identifiers {resources}. Continuing without
+    these resources."""
+
+    extra = "The error was: {error}"
+
+    fix = "Check the error."
+
+    resources: frozenset[T_Identifier]
+    resource_type: str
+    error: str | None = None
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type,
+            resources=self.resources,
+        ) + (self.extra.format(error=self.error) if self.error else "")
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["resources"] = self.resources
+        return output
+
+
+class ResourceTypeNotSupportedWarning(ResourceWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} is not supported. This will be ignored."""
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(resource_type=self.resource_type, identifier=repr(self.identifier))
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["identifier"] = self.identifier
+        return output

cognite/neat/rules/exporters/_rules2dms.py

@@ -15,9 +15,10 @@ from cognite.client.data_classes.data_modeling import (
 )
 from cognite.client.exceptions import CogniteAPIError
 
+from cognite.neat.issues import IssueList
+from cognite.neat.issues.neat_warnings.resources import FailedLoadingResourcesWarning
 from cognite.neat.rules import issues
 from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.models import InformationRules
 from cognite.neat.rules.models.dms import DMSRules, DMSSchema, PipelineSchema
 from cognite.neat.utils.cdf.loaders import (
@@ -313,7 +314,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
         try:
             data_models = loader.client.data_modeling.data_models.list(space=space, limit=25, all_versions=False)
         except CogniteAPIError as e:
-            warnings.warn(issues.importing.APIWarning(str(e)), stacklevel=2)
+            warnings.warn(FailedLoadingResourcesWarning[str](frozenset({space}), "Space", str(e)), stacklevel=2)
             return []
         else:
             return [

cognite/neat/rules/exporters/_validation.py

@@ -2,8 +2,8 @@ import warnings
 from typing import Literal, overload
 
 from cognite.neat.exceptions import wrangle_warnings
+from cognite.neat.issues.neat_warnings.properties import PropertyRedefinedWarning
 from cognite.neat.rules.issues.dms import EntityIDNotDMSCompliantWarning
-from cognite.neat.rules.issues.importing import PropertyRedefinedWarning
 from cognite.neat.rules.models import InformationRules
 from cognite.neat.utils.regex_patterns import DMS_PROPERTY_ID_COMPLIANCE_REGEX, PATTERNS, VIEW_ID_COMPLIANCE_REGEX
 
@@ -78,7 +78,7 @@ def are_properties_redefined(rules: InformationRules, return_report: bool = Fals
             elif property_.class_ in analyzed_properties[property_.property_]:
                 flag = True
                 warnings.warn(
-                    PropertyRedefinedWarning(property_.property_, property_.class_.versioned_id),
+                    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"]