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

cognite/neat/rules/importers/_dms2rules.py

@@ -1,14 +1,15 @@
 from collections import Counter
-from collections.abc import Sequence
+from collections.abc import Collection, Sequence
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Literal, cast, overload
+from typing import Literal, cast
 
 from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex, InvertedIndex
-from cognite.client.data_classes.data_modeling.data_types import ListablePropertyType
+from cognite.client.data_classes.data_modeling.data_types import Enum as DMSEnum
+from cognite.client.data_classes.data_modeling.data_types import ListablePropertyType, PropertyTypeWithUnit
 from cognite.client.data_classes.data_modeling.views import (
     MultiEdgeConnectionApply,
     MultiReverseDirectRelationApply,
@@ -24,34 +25,37 @@ from cognite.neat.issues.warnings import (
     PropertyNotFoundWarning,
     PropertyTypeNotSupportedWarning,
     ResourceNotFoundWarning,
+    ResourcesDuplicatedWarning,
 )
-from cognite.neat.rules.importers._base import BaseImporter, VerifiedRules, _handle_issues
+from cognite.neat.rules._shared import ReadRules
+from cognite.neat.rules.importers._base import BaseImporter, _handle_issues
 from cognite.neat.rules.models import (
     DataModelType,
-    DMSRules,
+    DMSInputRules,
     DMSSchema,
-    ExtensionCategory,
-    RoleTypes,
     SchemaCompleteness,
-    SheetList,
 )
-from cognite.neat.rules.models.data_types import DataType
+from cognite.neat.rules.models.data_types import DataType, Enum
 from cognite.neat.rules.models.dms import (
-    DMSContainer,
-    DMSMetadata,
-    DMSProperty,
-    DMSView,
+    DMSInputContainer,
+    DMSInputEnum,
+    DMSInputMetadata,
+    DMSInputNode,
+    DMSInputProperty,
+    DMSInputView,
 )
 from cognite.neat.rules.models.entities import (
     ClassEntity,
     ContainerEntity,
+    DMSNodeEntity,
     DMSUnknownEntity,
+    EdgeEntity,
+    ReverseConnectionEntity,
     ViewEntity,
-    ViewPropertyEntity,
 )
 
 
-class DMSImporter(BaseImporter):
+class DMSImporter(BaseImporter[DMSInputRules]):
     """Imports a Data Model from Cognite Data Fusion.
 
     Args:
@@ -66,8 +70,8 @@ class DMSImporter(BaseImporter):
         self,
         schema: DMSSchema,
         read_issues: Sequence[NeatIssue] | None = None,
-        metadata: DMSMetadata | None = None,
-        ref_metadata: DMSMetadata | None = None,
+        metadata: DMSInputMetadata | None = None,
+        ref_metadata: DMSInputMetadata | None = None,
     ):
         # Calling this root schema to distinguish it from
         # * User Schema
@@ -77,10 +81,10 @@ class DMSImporter(BaseImporter):
         self.ref_metadata = ref_metadata
         self.issue_list = IssueList(read_issues)
         self._all_containers_by_id = schema.containers.copy()
-        self._all_view_ids = set(self.root_schema.views.keys())
-        if self.root_schema.reference:
-            self._all_containers_by_id.update(self.root_schema.reference.containers)
-            self._all_view_ids.update(self.root_schema.reference.views.keys())
+        self._all_views_by_id = schema.views.copy()
+        if schema.reference:
+            self._all_containers_by_id.update(schema.reference.containers.items())
+            self._all_views_by_id.update(schema.reference.views.items())
 
     @classmethod
     def from_data_model_id(
@@ -162,8 +166,8 @@ class DMSImporter(BaseImporter):
         cls,
         model: dm.DataModel[dm.View] | dm.DataModelApply,
         has_reference: bool = False,
-    ) -> DMSMetadata:
-        description, creator = DMSMetadata._get_description_and_creator(model.description)
+    ) -> DMSInputMetadata:
+        description, creator = DMSInputMetadata._get_description_and_creator(model.description)
 
         if isinstance(model, dm.DataModel):
             created = ms_to_datetime(model.created_time)
@@ -172,17 +176,17 @@ class DMSImporter(BaseImporter):
             now = datetime.now().replace(microsecond=0)
             created = now
             updated = now
-        return DMSMetadata(
-            schema_=SchemaCompleteness.complete,
-            data_model_type=DataModelType.solution if has_reference else DataModelType.enterprise,
-            extension=ExtensionCategory.addition,
+        return DMSInputMetadata(
+            schema_="complete",
+            data_model_type="solution" if has_reference else "enterprise",
+            extension="addition",
             space=model.space,
             external_id=model.external_id,
             name=model.name or model.external_id,
             version=model.version or "0.1.0",
             updated=updated,
             created=created,
-            creator=creator,
+            creator=",".join(creator),
             description=description,
         )
 
@@ -203,71 +207,52 @@ class DMSImporter(BaseImporter):
             schema = DMSSchema.from_zip(zip_file)
         return cls(schema, issue_list)
 
-    @overload
-    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[VerifiedRules | None, IssueList]: ...
-
-    def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
+    def to_rules(self) -> ReadRules[DMSInputRules]:
         if self.issue_list.has_errors:
             # In case there were errors during the import, the to_rules method will return None
-            return self._return_or_raise(self.issue_list, errors)
+            return ReadRules(None, self.issue_list, {})
 
         if not self.root_schema.data_model:
             self.issue_list.append(ResourceMissingIdentifierError("data model", type(self.root_schema).__name__))
-            return self._return_or_raise(self.issue_list, errors)
+            return ReadRules(None, self.issue_list, {})
+
         model = self.root_schema.data_model
-        with _handle_issues(
-            self.issue_list,
-        ) as future:
-            schema_completeness = SchemaCompleteness.complete
-            data_model_type = DataModelType.enterprise
-            reference: DMSRules | None = None
-            if (ref_schema := self.root_schema.reference) and (ref_model := ref_schema.data_model):
-                # Reference should always be an enterprise model.
-                reference = DMSRules(
-                    **self._create_rule_components(
-                        ref_model,
-                        ref_schema,
-                        self.ref_metadata
-                        or self._create_default_metadata(list(ref_schema.views.values()), is_ref=True),
-                        DataModelType.enterprise,
-                    )
-                )
-                data_model_type = DataModelType.solution
-
-            user_rules = DMSRules(
-                **self._create_rule_components(
-                    model,
-                    self.root_schema,
-                    self.metadata,
-                    data_model_type,
-                    schema_completeness,
-                    has_reference=reference is not None,
-                ),
-                reference=reference,
-            )
 
-        if future.result == "failure" or self.issue_list.has_errors:
-            return self._return_or_raise(self.issue_list, errors)
+        schema_completeness = SchemaCompleteness.complete
+        data_model_type = DataModelType.enterprise
+        reference: DMSInputRules | None = None
+        if (ref_schema := self.root_schema.reference) and (ref_model := ref_schema.data_model):
+            # Reference should always be an enterprise model.
+            reference = self._create_rule_components(
+                ref_model,
+                ref_schema,
+                self.ref_metadata or self._create_default_metadata(list(ref_schema.views.values()), is_ref=True),
+                DataModelType.enterprise,
+            )
+            data_model_type = DataModelType.solution
+
+        user_rules = self._create_rule_components(
+            model,
+            self.root_schema,
+            self.metadata,
+            data_model_type,
+            schema_completeness,
+            has_reference=reference is not None,
+        )
+        user_rules.reference = reference
 
-        return self._to_output(user_rules, self.issue_list, errors, role)
+        return ReadRules(user_rules, self.issue_list, {})
 
     def _create_rule_components(
         self,
         data_model: dm.DataModelApply,
         schema: DMSSchema,
-        metadata: DMSMetadata | None = None,
+        metadata: DMSInputMetadata | None = None,
         data_model_type: DataModelType | None = None,
         schema_completeness: SchemaCompleteness | None = None,
         has_reference: bool = False,
-    ) -> dict[str, Any]:
-        properties = SheetList[DMSProperty]()
+    ) -> DMSInputRules:
+        properties: list[DMSInputProperty] = []
         for view_id, view in schema.views.items():
             view_entity = ViewEntity.from_id(view_id)
             class_entity = view_entity.as_class()
@@ -280,44 +265,47 @@ class DMSImporter(BaseImporter):
             view.as_id() if isinstance(view, dm.View | dm.ViewApply) else view for view in data_model.views or []
         }
 
-        metadata = metadata or DMSMetadata.from_data_model(data_model, has_reference)
+        metadata = metadata or DMSInputMetadata.from_data_model(data_model, has_reference)
         if data_model_type is not None:
-            metadata.data_model_type = data_model_type
+            metadata.data_model_type = str(data_model_type)  # type: ignore[assignment]
         if schema_completeness is not None:
-            metadata.schema_ = schema_completeness
-        return dict(
+            metadata.schema_ = str(schema_completeness)  # type: ignore[assignment]
+
+        enum = self._create_enum_collections(schema.containers.values())
+
+        return DMSInputRules(
             metadata=metadata,
             properties=properties,
-            containers=SheetList[DMSContainer](
-                data=[DMSContainer.from_container(container) for container in schema.containers.values()]
-            ),
-            views=SheetList[DMSView](
-                data=[
-                    DMSView.from_view(view, in_model=view_id in data_model_view_ids)
-                    for view_id, view in schema.views.items()
-                ]
-            ),
+            containers=[DMSInputContainer.from_container(container) for container in schema.containers.values()],
+            views=[
+                DMSInputView.from_view(view, in_model=view_id in data_model_view_ids)
+                for view_id, view in schema.views.items()
+            ],
+            nodes=[DMSInputNode.from_node_type(node_type) for node_type in schema.node_types.values()],
+            enum=enum,
         )
 
     @classmethod
-    def _create_default_metadata(cls, views: Sequence[dm.View | dm.ViewApply], is_ref: bool = False) -> DMSMetadata:
+    def _create_default_metadata(
+        cls, views: Sequence[dm.View | dm.ViewApply], is_ref: bool = False
+    ) -> DMSInputMetadata:
         now = datetime.now().replace(microsecond=0)
         space = Counter(view.space for view in views).most_common(1)[0][0]
-        return DMSMetadata(
-            schema_=SchemaCompleteness.complete,
-            extension=ExtensionCategory.addition,
-            data_model_type=DataModelType.enterprise if is_ref else DataModelType.solution,
+        return DMSInputMetadata(
+            schema_="complete",
+            extension="addition",
+            data_model_type="enterprise" if is_ref else "solution",
             space=space,
             external_id="Unknown",
             version="0.1.0",
-            creator=["Unknown"],
+            creator="Unknown",
             created=now,
             updated=now,
         )
 
     def _create_dms_property(
         self, prop_id: str, prop: ViewPropertyApply, view_entity: ViewEntity, class_entity: ClassEntity
-    ) -> DMSProperty | None:
+    ) -> DMSInputProperty | None:
         if isinstance(prop, dm.MappedPropertyApply) and prop.container not in self._all_containers_by_id:
             self.issue_list.append(
                 ResourceNotFoundWarning[dm.ContainerId, dm.PropertyId](
@@ -353,20 +341,22 @@ class DMSImporter(BaseImporter):
         if value_type is None:
             return None
 
-        return DMSProperty(
-            class_=class_entity,
+        return DMSInputProperty(
+            class_=str(class_entity),
             property_=prop_id,
             description=prop.description,
             name=prop.name,
-            connection=self._get_relation_type(prop),
-            value_type=value_type,
+            connection=self._get_connection_type(prop_id, prop, view_entity.as_id()),
+            value_type=str(value_type),
             is_list=self._get_is_list(prop),
             nullable=self._get_nullable(prop),
             immutable=self._get_immutable(prop),
             default=self._get_default(prop),
-            container=ContainerEntity.from_id(prop.container) if isinstance(prop, dm.MappedPropertyApply) else None,
+            container=str(ContainerEntity.from_id(prop.container))
+            if isinstance(prop, dm.MappedPropertyApply)
+            else None,
             container_property=prop.container_property_identifier if isinstance(prop, dm.MappedPropertyApply) else None,
-            view=view_entity,
+            view=str(view_entity),
             view_property=prop_id,
             index=self._get_index(prop, prop_id),
             constraint=self._get_constraint(prop, prop_id),
@@ -376,13 +366,22 @@ class DMSImporter(BaseImporter):
         """This method assumes you have already checked that the container with property exists."""
         return self._all_containers_by_id[prop.container].properties[prop.container_property_identifier]
 
-    def _get_relation_type(self, prop: ViewPropertyApply) -> Literal["edge", "reverse", "direct"] | None:
+    def _get_connection_type(
+        self, prop_id: str, prop: ViewPropertyApply, view_id: dm.ViewId
+    ) -> Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None:
         if isinstance(prop, SingleEdgeConnectionApply | MultiEdgeConnectionApply) and prop.direction == "outwards":
-            return "edge"
+            properties = ViewEntity.from_id(prop.edge_source) if prop.edge_source is not None else None
+            return EdgeEntity(properties=properties, type=DMSNodeEntity.from_reference(prop.type), direction="outwards")
         elif isinstance(prop, SingleEdgeConnectionApply | MultiEdgeConnectionApply) and prop.direction == "inwards":
-            return "reverse"
+            if reverse_prop := self._find_reverse_edge(prop_id, prop, view_id):
+                return ReverseConnectionEntity(property=reverse_prop)
+            else:
+                properties = ViewEntity.from_id(prop.source) if prop.edge_source is not None else None
+                return EdgeEntity(
+                    properties=properties, type=DMSNodeEntity.from_reference(prop.type), direction="inwards"
+                )
         elif isinstance(prop, SingleReverseDirectRelationApply | MultiReverseDirectRelationApply):
-            return "reverse"
+            return ReverseConnectionEntity(property=prop.through.property)
         elif isinstance(prop, dm.MappedPropertyApply) and isinstance(
             self._container_prop_unsafe(prop).type, dm.DirectRelation
         ):
@@ -392,21 +391,26 @@ class DMSImporter(BaseImporter):
 
     def _get_value_type(
         self, prop: ViewPropertyApply, view_entity: ViewEntity, prop_id
-    ) -> DataType | ViewEntity | ViewPropertyEntity | DMSUnknownEntity | None:
-        if isinstance(prop, SingleEdgeConnectionApply | MultiEdgeConnectionApply) and prop.direction == "outwards":
-            return ViewEntity.from_id(prop.source)
-        elif isinstance(prop, SingleReverseDirectRelationApply | MultiReverseDirectRelationApply):
-            return ViewPropertyEntity.from_id(prop.through)
-        elif isinstance(prop, SingleEdgeConnectionApply | MultiEdgeConnectionApply) and prop.direction == "inwards":
+    ) -> DataType | ViewEntity | DMSUnknownEntity | None:
+        if isinstance(
+            prop,
+            SingleEdgeConnectionApply
+            | MultiEdgeConnectionApply
+            | SingleReverseDirectRelationApply
+            | MultiReverseDirectRelationApply,
+        ):
             return ViewEntity.from_id(prop.source)
         elif isinstance(prop, dm.MappedPropertyApply):
             container_prop = self._container_prop_unsafe(cast(dm.MappedPropertyApply, prop))
             if isinstance(container_prop.type, dm.DirectRelation):
-                if prop.source is None or prop.source not in self._all_view_ids:
-                    # The warning is issued when the DMS Rules are created.
+                if prop.source is None or prop.source not in self._all_views_by_id:
                     return DMSUnknownEntity()
                 else:
                     return ViewEntity.from_id(prop.source)
+            elif isinstance(container_prop.type, PropertyTypeWithUnit) and container_prop.type.unit:
+                return DataType.load(f"{container_prop.type._type}(unit={container_prop.type.unit.external_id})")
+            elif isinstance(container_prop.type, DMSEnum):
+                return Enum(collection=ClassEntity(suffix=prop_id), unknownValue=container_prop.type.unknown_value)
             else:
                 return DataType.load(container_prop.type._type)
         else:
@@ -476,3 +480,55 @@ class DMSImporter(BaseImporter):
                     )
                 )
         return unique_constraints or None
+
+    def _find_reverse_edge(
+        self, prop_id: str, prop: SingleEdgeConnectionApply | MultiEdgeConnectionApply, view_id: dm.ViewId
+    ) -> str | None:
+        if prop.source not in self._all_views_by_id:
+            return None
+        view = self._all_views_by_id[prop.source]
+        candidates = []
+        for prop_name, reverse_prop in (view.properties or {}).items():
+            if isinstance(reverse_prop, SingleEdgeConnectionApply | MultiEdgeConnectionApply):
+                if (
+                    reverse_prop.type == prop.type
+                    and reverse_prop.source == view_id
+                    and reverse_prop.direction != prop.direction
+                ):
+                    candidates.append(prop_name)
+        if len(candidates) == 0:
+            self.issue_list.append(
+                PropertyNotFoundWarning(
+                    prop.source,
+                    "view property",
+                    f"reverse edge of {prop_id}",
+                    dm.PropertyId(view_id, prop_id),
+                    "view property",
+                )
+            )
+            return None
+        if len(candidates) > 1:
+            self.issue_list.append(
+                ResourcesDuplicatedWarning(
+                    frozenset(dm.PropertyId(view.as_id(), candidate) for candidate in candidates),
+                    "view property",
+                    default_action="Multiple reverse edges found for "
+                    f"{dm.PropertyId(view_id, prop_id)!r}. Will use {candidates[0]}",
+                )
+            )
+
+        return candidates[0]
+
+    @staticmethod
+    def _create_enum_collections(containers: Collection[dm.ContainerApply]) -> list[DMSInputEnum] | None:
+        enum_collections: list[DMSInputEnum] = []
+        for container in containers:
+            for prop_id, prop in container.properties.items():
+                if isinstance(prop.type, DMSEnum):
+                    for identifier, value in prop.type.values.items():
+                        enum_collections.append(
+                            DMSInputEnum(
+                                collection=prop_id, value=identifier, name=value.name, description=value.description
+                            )
+                        )
+        return enum_collections

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

@@ -1,7 +1,7 @@
 from collections import Counter
 from collections.abc import Callable, Sequence
 
-from cognite.neat.issues import IssueList, NeatIssue
+from cognite.neat.issues import IssueList
 from cognite.neat.issues.errors import (
     PropertyTypeNotSupportedError,
     ResourceMissingIdentifierError,
@@ -27,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]
@@ -53,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]
@@ -75,7 +82,8 @@ 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:
@@ -87,7 +95,7 @@ class _DTDLConverter:
             )
 
     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,
@@ -107,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(
@@ -122,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,
@@ -168,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,
@@ -188,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,
@@ -218,7 +226,7 @@ class _DTDLConverter:
                 )
                 value_type = Json()
 
-            prop = InformationProperty(
+            prop = InformationInputProperty(
                 class_=ClassEntity.load(parent),
                 property_=item.name,
                 name=item.display_name,
@@ -243,7 +251,7 @@ class _DTDLConverter:
             )
             return None
 
-        class_ = InformationClass(
+        class_ = InformationInputClass(
             class_=item.id_.as_class_id(),
             name=item.display_name,
             description=item.description,
@@ -255,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,
@@ -297,7 +305,7 @@ 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(

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

@@ -2,7 +2,6 @@ import json
 import zipfile
 from collections.abc import Iterable, Sequence
 from pathlib import Path
-from typing import Literal, overload
 
 from pydantic import ValidationError
 
@@ -14,16 +13,16 @@ from cognite.neat.issues.warnings import (
     FileTypeUnexpectedWarning,
     NeatValueWarning,
 )
-from cognite.neat.rules._shared import VerifiedRules
-from cognite.neat.rules.importers._base import BaseImporter, _handle_issues
+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.models import InformationRules, RoleTypes, SchemaCompleteness, SheetList
-from cognite.neat.rules.models.information import InformationClass, InformationProperty
+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.
@@ -47,7 +46,7 @@ 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
@@ -125,17 +124,7 @@ class DTDLImporter(BaseImporter):
                             items.append(item)
         return cls(items, zip_file.stem, read_issues=issues)
 
-    @overload
-    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[VerifiedRules | None, IssueList]: ...
-
-    def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
+    def to_rules(self) -> ReadRules[InformationInputRules]:
         converter = _DTDLConverter(self._read_issues)
 
         converter.convert(self._items)
@@ -152,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, {})