cognite-neat 0.76.1__py3-none-any.whl → 0.76.3__py3-none-any.whl

cognite/neat/rules/importers/_dms2rules.py

@@ -2,7 +2,7 @@ from collections import Counter
 from collections.abc import Sequence
 from datetime import datetime
 from pathlib import Path
-from typing import Literal, cast, overload
+from typing import Any, Literal, cast, overload
 
 from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
@@ -20,7 +20,22 @@ 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.rules.models import (
+    DataModelType,
+    DMSRules,
+    DMSSchema,
+    ExtensionCategory,
+    RoleTypes,
+    SchemaCompleteness,
+    SheetList,
+)
 from cognite.neat.rules.models.data_types import DataType
+from cognite.neat.rules.models.dms import (
+    DMSContainer,
+    DMSMetadata,
+    DMSProperty,
+    DMSView,
+)
 from cognite.neat.rules.models.entities import (
     ClassEntity,
     ContainerEntity,
@@ -29,15 +44,6 @@ from cognite.neat.rules.models.entities import (
     ViewEntity,
     ViewPropertyEntity,
 )
-from cognite.neat.rules.models.rules import DMSRules, DMSSchema, RoleTypes
-from cognite.neat.rules.models.rules._base import DataModelType, ExtensionCategory, SchemaCompleteness
-from cognite.neat.rules.models.rules._dms_architect_rules import (
-    DMSContainer,
-    DMSMetadata,
-    DMSProperty,
-    DMSView,
-    SheetList,
-)
 
 
 class DMSImporter(BaseImporter):
@@ -47,10 +53,17 @@ class DMSImporter(BaseImporter):
         read_issues: Sequence[ValidationIssue] | None = None,
         metadata: DMSMetadata | None = None,
     ):
-        self.schema = schema
+        # Calling this root schema to distinguish it from
+        # * User Schema
+        # * Reference Schema
+        self.root_schema = schema
         self.metadata = metadata
         self.issue_list = IssueList(read_issues)
-        self._container_by_id = {container.as_id(): container for container in schema.containers}
+        self._all_containers_by_id = {container.as_id(): container for container in schema.containers}
+        if self.root_schema.reference:
+            self._all_containers_by_id.update(
+                {container.as_id(): container for container in self.root_schema.reference.containers}
+            )
 
     @classmethod
     def from_data_model_id(cls, client: CogniteClient, data_model_id: DataModelIdentifier) -> "DMSImporter":
@@ -134,130 +147,102 @@ class DMSImporter(BaseImporter):
             # 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 len(self.schema.data_models) == 0:
+        if len(self.root_schema.data_models) == 0:
             self.issue_list.append(issues.importing.NoDataModelError("No data model found."))
             return self._return_or_raise(self.issue_list, errors)
 
-        if len(self.schema.data_models) > 2:
+        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:
+                # Reference should always be an enterprise model.
+                reference = DMSRules(
+                    **self._create_rule_components(
+                        ref_schema, self._create_default_metadata(ref_schema.views), DataModelType.enterprise
+                    )
+                )
+                schema_completeness = SchemaCompleteness.extended
+                data_model_type = DataModelType.solution
+
+            user_rules = DMSRules(
+                **self._create_rule_components(self.root_schema, self.metadata, data_model_type, schema_completeness),
+                reference=reference,
+            )
+
+        if future.result == "failure" or self.issue_list.has_errors:
+            return self._return_or_raise(self.issue_list, errors)
+
+        return self._to_output(user_rules, self.issue_list, errors, role)
+
+    def _create_rule_components(
+        self,
+        schema: DMSSchema,
+        metadata: DMSMetadata | None = None,
+        data_model_type: DataModelType | None = None,
+        schema_completeness: SchemaCompleteness | None = None,
+    ) -> dict[str, Any]:
+        if len(schema.data_models) > 2:
             # Creating a DataModelEntity to convert the data model id to a string.
             self.issue_list.append(
                 issues.importing.MultipleDataModelsWarning(
-                    [str(DataModelEntity.from_id(model.as_id())) for model in self.schema.data_models]
+                    [str(DataModelEntity.from_id(model.as_id())) for model in schema.data_models]
                 )
             )
 
-        data_model = self.schema.data_models[0]
+        data_model = schema.data_models[0]
 
         properties = SheetList[DMSProperty]()
-        ref_properties = SheetList[DMSProperty]()
-        for view in self.schema.views:
+        for view in schema.views:
             view_id = view.as_id()
             view_entity = ViewEntity.from_id(view_id)
             class_entity = view_entity.as_class()
             for prop_id, prop in (view.properties or {}).items():
                 dms_property = self._create_dms_property(prop_id, prop, view_entity, class_entity)
                 if dms_property is not None:
-                    if view_id in self.schema.frozen_ids:
-                        ref_properties.append(dms_property)
-                    else:
-                        properties.append(dms_property)
+                    properties.append(dms_property)
 
         data_model_view_ids: set[dm.ViewId] = {
             view.as_id() if isinstance(view, dm.View | dm.ViewApply) else view for view in data_model.views or []
         }
 
-        metadata = self.metadata or DMSMetadata.from_data_model(data_model)
-        metadata.data_model_type = self._infer_data_model_type(metadata.space)
-        if ref_properties:
-            metadata.schema_ = SchemaCompleteness.extended
-
-        with _handle_issues(
-            self.issue_list,
-        ) as future:
-            user_rules = DMSRules(
-                metadata=metadata,
-                properties=properties,
-                containers=SheetList[DMSContainer](
-                    data=[
-                        DMSContainer.from_container(container)
-                        for container in self.schema.containers
-                        if container.as_id() not in self.schema.frozen_ids
-                    ]
-                ),
-                views=SheetList[DMSView](
-                    data=[
-                        DMSView.from_view(view, in_model=view.as_id() in data_model_view_ids)
-                        for view in self.schema.views
-                        if view.as_id() not in self.schema.frozen_ids
-                    ]
-                ),
-                reference=self._create_reference_rules(ref_properties),
-            )
-
-        if future.result == "failure" or self.issue_list.has_errors:
-            return self._return_or_raise(self.issue_list, errors)
-
-        return self._to_output(user_rules, self.issue_list, errors, role)
-
-    def _create_reference_rules(self, properties: SheetList[DMSProperty]) -> DMSRules | None:
-        if not properties:
-            return None
-
-        if len(self.schema.data_models) == 2:
-            data_model = self.schema.data_models[1]
-            data_model_view_ids: set[dm.ViewId] = {
-                view.as_id() if isinstance(view, dm.View | dm.ViewApply) else view for view in data_model.views or []
-            }
-            metadata = self._create_metadata_from_model(data_model)
-        else:
-            data_model_view_ids = set()
-            now = datetime.now().replace(microsecond=0)
-            space = Counter(prop.view.space for prop in properties).most_common(1)[0][0]
-            metadata = DMSMetadata(
-                schema_=SchemaCompleteness.complete,
-                extension=ExtensionCategory.addition,
-                space=space,
-                external_id="Unknown",
-                version="0.1.0",
-                creator=["Unknown"],
-                created=now,
-                updated=now,
-            )
-
-        metadata.data_model_type = DataModelType.enterprise
-        return DMSRules(
+        metadata = metadata or DMSMetadata.from_data_model(data_model)
+        if data_model_type is not None:
+            metadata.data_model_type = data_model_type
+        if schema_completeness is not None:
+            metadata.schema_ = schema_completeness
+        return dict(
             metadata=metadata,
             properties=properties,
-            views=SheetList[DMSView](
-                data=[
-                    DMSView.from_view(view, in_model=not data_model_view_ids or (view.as_id() in data_model_view_ids))
-                    for view in self.schema.views
-                    if view.as_id() in self.schema.frozen_ids
-                ]
-            ),
             containers=SheetList[DMSContainer](
-                data=[
-                    DMSContainer.from_container(container)
-                    for container in self.schema.containers
-                    if container.as_id() in self.schema.frozen_ids
-                ]
+                data=[DMSContainer.from_container(container) for container in schema.containers]
+            ),
+            views=SheetList[DMSView](
+                data=[DMSView.from_view(view, in_model=view.as_id() in data_model_view_ids) for view in schema.views]
             ),
-            reference=None,
         )
 
-    def _infer_data_model_type(self, space: str) -> DataModelType:
-        if self.schema.referenced_spaces() - {space}:
-            # If the data model has containers, views, node types in another space
-            # we assume it is a solution model.
-            return DataModelType.solution
-        else:
-            # All containers, views, node types are in the same space as the data model
-            return DataModelType.enterprise
+    @classmethod
+    def _create_default_metadata(cls, views: Sequence[dm.View | dm.ViewApply]) -> DMSMetadata:
+        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,
+            space=space,
+            external_id="Unknown",
+            version="0.1.0",
+            creator=["Unknown"],
+            created=now,
+            updated=now,
+        )
 
     def _create_dms_property(
         self, prop_id: str, prop: ViewPropertyApply, view_entity: ViewEntity, class_entity: ClassEntity
     ) -> DMSProperty | None:
-        if isinstance(prop, dm.MappedPropertyApply) and prop.container not in self._container_by_id:
+        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),
@@ -268,7 +253,7 @@ class DMSImporter(BaseImporter):
             return None
         if (
             isinstance(prop, dm.MappedPropertyApply)
-            and prop.container_property_identifier not in self._container_by_id[prop.container].properties
+            and prop.container_property_identifier not in self._all_containers_by_id[prop.container].properties
         ):
             self.issue_list.append(
                 issues.importing.MissingContainerPropertyWarning(
@@ -315,7 +300,7 @@ class DMSImporter(BaseImporter):
 
     def _container_prop_unsafe(self, prop: dm.MappedPropertyApply) -> dm.ContainerProperty:
         """This method assumes you have already checked that the container with property exists."""
-        return self._container_by_id[prop.container].properties[prop.container_property_identifier]
+        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:
         if isinstance(prop, SingleEdgeConnectionApply | MultiEdgeConnectionApply) and prop.direction == "outwards":
@@ -380,7 +365,7 @@ class DMSImporter(BaseImporter):
     def _get_index(self, prop: ViewPropertyApply, prop_id) -> list[str] | None:
         if not isinstance(prop, dm.MappedPropertyApply):
             return None
-        container = self._container_by_id[prop.container]
+        container = self._all_containers_by_id[prop.container]
         index: list[str] = []
         for index_name, index_obj in (container.indexes or {}).items():
             if isinstance(index_obj, BTreeIndex | InvertedIndex) and prop_id in index_obj.properties:
@@ -390,7 +375,7 @@ class DMSImporter(BaseImporter):
     def _get_constraint(self, prop: ViewPropertyApply, prop_id: str) -> list[str] | None:
         if not isinstance(prop, dm.MappedPropertyApply):
             return None
-        container = self._container_by_id[prop.container]
+        container = self._all_containers_by_id[prop.container]
         unique_constraints: list[str] = []
         for constraint_name, constraint_obj in (container.constraints or {}).items():
             if isinstance(constraint_obj, dm.RequiresConstraint):

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

@@ -23,7 +23,7 @@ from cognite.neat.rules.importers._dtdl2rules.spec import (
 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, ParentClassEntity
-from cognite.neat.rules.models.rules._information_rules import InformationClass, InformationProperty
+from cognite.neat.rules.models.information import InformationClass, InformationProperty
 
 
 class _DTDLConverter:

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

@@ -12,9 +12,8 @@ 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.rules import InformationRules, RoleTypes
-from cognite.neat.rules.models.rules._base import SchemaCompleteness, SheetList
-from cognite.neat.rules.models.rules._information_rules import InformationClass, InformationProperty
+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
 
 

cognite/neat/rules/importers/_owl2rules/_owl2classes.py

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 from rdflib import OWL, Graph
 
-from cognite.neat.rules.models.rules._base import MatchType
+from cognite.neat.rules.models._base import MatchType
 from cognite.neat.utils.utils import remove_namespace
 
 

cognite/neat/rules/importers/_owl2rules/_owl2metadata.py

@@ -4,8 +4,8 @@ import re
 from rdflib import Graph, Namespace
 
 from cognite.neat.constants import DEFAULT_NAMESPACE
-from cognite.neat.rules.models.rules._base import RoleTypes, SchemaCompleteness
-from cognite.neat.rules.models.rules._types._base import (
+from cognite.neat.rules.models import RoleTypes, SchemaCompleteness
+from cognite.neat.rules.models._types._base import (
     PREFIX_COMPLIANCE_REGEX,
     VERSION_COMPLIANCE_REGEX,
 )

cognite/neat/rules/importers/_owl2rules/_owl2properties.py

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 from rdflib import Graph
 
-from cognite.neat.rules.models.rules._base import MatchType
+from cognite.neat.rules.models._base import MatchType
 from cognite.neat.utils.utils import remove_namespace
 
 from ._owl2classes import _data_type_property_class, _object_property_class, _thing_class

cognite/neat/rules/importers/_owl2rules/_owl2rules.py

@@ -10,8 +10,8 @@ from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SKOS, Graph
 
 from cognite.neat.rules.importers._base import BaseImporter, Rules
 from cognite.neat.rules.issues import IssueList
+from cognite.neat.rules.models import InformationRules, RoleTypes
 from cognite.neat.rules.models.data_types import _XSD_TYPES
-from cognite.neat.rules.models.rules import InformationRules, RoleTypes
 
 from ._owl2classes import parse_owl_classes
 from ._owl2metadata import parse_owl_metadata

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -13,9 +13,15 @@ from pandas import ExcelFile
 
 from cognite.neat.rules import issues
 from cognite.neat.rules.issues import IssueList
-from cognite.neat.rules.models.rules import RULES_PER_ROLE, DMSRules, DomainRules, InformationRules
-from cognite.neat.rules.models.rules._base import RoleTypes, SchemaCompleteness
-from cognite.neat.rules.models.rules._dms_rules_write import DMSRulesWrite
+from cognite.neat.rules.models import (
+    RULES_PER_ROLE,
+    DMSRules,
+    DomainRules,
+    InformationRules,
+    RoleTypes,
+    SchemaCompleteness,
+)
+from cognite.neat.rules.models.dms import DMSRulesInput
 from cognite.neat.utils.auxiliary import local_import
 from cognite.neat.utils.spreadsheet import SpreadsheetRead, read_individual_sheet
 
@@ -81,71 +87,95 @@ class MetadataRaw(UserDict):
 class ReadResult:
     sheets: dict[str, dict | list]
     read_info_by_sheet: dict[str, SpreadsheetRead]
-    role: RoleTypes
-    schema: SchemaCompleteness | None
+    metadata: MetadataRaw
+
+    @property
+    def role(self) -> RoleTypes:
+        return self.metadata.role
+
+    @property
+    def schema(self) -> SchemaCompleteness | None:
+        return self.metadata.schema
 
 
 class SpreadsheetReader:
-    def __init__(self, issue_list: IssueList, is_reference: bool = False):
+    def __init__(
+        self,
+        issue_list: IssueList,
+        required: bool = True,
+        metadata: MetadataRaw | None = None,
+        sheet_prefix: Literal["", "Last", "Ref"] = "",
+    ):
         self.issue_list = issue_list
-        self._is_reference = is_reference
+        self.required = required
+        self.metadata = metadata
+        self._sheet_prefix = sheet_prefix
 
     @property
     def metadata_sheet_name(self) -> str:
-        metadata_name = "Metadata"
-        return self.to_reference_sheet(metadata_name) if self._is_reference else metadata_name
+        return f"{self._sheet_prefix}Metadata"
 
     def sheet_names(self, role: RoleTypes) -> set[str]:
         names = MANDATORY_SHEETS_BY_ROLE[role]
-        return {self.to_reference_sheet(sheet_name) for sheet_name in names} if self._is_reference else names
-
-    @classmethod
-    def to_reference_sheet(cls, sheet_name: str) -> str:
-        return f"Ref{sheet_name}"
+        return {f"{self._sheet_prefix}{sheet_name}" for sheet_name in names if sheet_name != "Metadata"}
 
     def read(self, filepath: Path) -> None | ReadResult:
         with pd.ExcelFile(filepath) as excel_file:
-            if self.metadata_sheet_name not in excel_file.sheet_names:
+            metadata: MetadataRaw | None
+            if self.metadata is not None:
+                metadata = self.metadata
+            else:
+                metadata = self._read_metadata(excel_file, filepath)
+                if metadata is None:
+                    # The reading of metadata failed, so we can't continue
+                    return None
+
+            sheets, read_info_by_sheet = self._read_sheets(excel_file, metadata.role)
+            if sheets is None or self.issue_list.has_errors:
+                return None
+            sheets["Metadata"] = dict(metadata)
+
+            return ReadResult(sheets, read_info_by_sheet, metadata)
+
+    def _read_metadata(self, excel_file: ExcelFile, filepath: Path) -> MetadataRaw | None:
+        if self.metadata_sheet_name not in excel_file.sheet_names:
+            if self.required:
                 self.issue_list.append(
                     issues.spreadsheet_file.MetadataSheetMissingOrFailedError(
                         filepath, sheet_name=self.metadata_sheet_name
                     )
                 )
-                return None
-
-            metadata = MetadataRaw.from_excel(excel_file, self.metadata_sheet_name)
+            return None
 
-            if not metadata.is_valid(self.issue_list, filepath):
-                return None
+        metadata = MetadataRaw.from_excel(excel_file, self.metadata_sheet_name)
 
-            sheets, read_info_by_sheet = self._read_sheets(metadata, excel_file)
-            if sheets is None or self.issue_list.has_errors:
-                return None
-
-            return ReadResult(sheets, read_info_by_sheet, metadata.role, metadata.schema)
+        if not metadata.is_valid(self.issue_list, filepath):
+            return None
+        return metadata
 
     def _read_sheets(
-        self, metadata: MetadataRaw, excel_file: ExcelFile
+        self, excel_file: ExcelFile, read_role: RoleTypes
     ) -> tuple[dict[str, dict | list] | None, dict[str, SpreadsheetRead]]:
         read_info_by_sheet: dict[str, SpreadsheetRead] = defaultdict(SpreadsheetRead)
 
-        sheets: dict[str, dict | list] = {"Metadata": dict(metadata)}
+        sheets: dict[str, dict | list] = {}
 
-        expected_sheet_names = self.sheet_names(metadata.role)
+        expected_sheet_names = self.sheet_names(read_role)
 
         if missing_sheets := expected_sheet_names.difference(set(excel_file.sheet_names)):
-            self.issue_list.append(
-                issues.spreadsheet_file.SheetMissingError(cast(Path, excel_file.io), list(missing_sheets))
-            )
+            if self.required:
+                self.issue_list.append(
+                    issues.spreadsheet_file.SheetMissingError(cast(Path, excel_file.io), list(missing_sheets))
+                )
             return None, read_info_by_sheet
 
         for source_sheet_name, target_sheet_name, headers_input in SOURCE_SHEET__TARGET_FIELD__HEADERS:
-            source_sheet_name = self.to_reference_sheet(source_sheet_name) if self._is_reference else source_sheet_name
+            source_sheet_name = f"{self._sheet_prefix}{source_sheet_name}"
 
             if source_sheet_name not in excel_file.sheet_names:
                 continue
             if isinstance(headers_input, dict):
-                headers = headers_input[metadata.role]
+                headers = headers_input[read_role]
             else:
                 headers = headers_input
 
@@ -182,42 +212,37 @@ class ExcelImporter(BaseImporter):
             issue_list.append(issues.spreadsheet_file.SpreadsheetNotFoundError(self.filepath))
             return self._return_or_raise(issue_list, errors)
 
-        user_result = SpreadsheetReader(issue_list, is_reference=False).read(self.filepath)
-        if user_result is None or issue_list.has_errors:
+        user_read = SpreadsheetReader(issue_list).read(self.filepath)
+        if user_read is None or issue_list.has_errors:
             return self._return_or_raise(issue_list, errors)
 
-        reference_result: ReadResult | None = None
-        if (
-            user_result
-            and user_result.role != RoleTypes.domain_expert
-            and user_result.schema == SchemaCompleteness.extended
-        ):
-            reference_result = SpreadsheetReader(issue_list, is_reference=True).read(self.filepath)
+        last_read: ReadResult | None = None
+        reference_read: ReadResult | None = None
+        if user_read.schema == SchemaCompleteness.extended:
+            # Last does not have its own metadata sheet. It is the same as the user's metadata sheet.
+            last_read = SpreadsheetReader(
+                issue_list, required=False, metadata=user_read.metadata, sheet_prefix="Last"
+            ).read(self.filepath)
+            reference_read = SpreadsheetReader(issue_list, sheet_prefix="Ref").read(self.filepath)
             if issue_list.has_errors:
                 return self._return_or_raise(issue_list, errors)
 
-        if user_result and reference_result and user_result.role != reference_result.role:
+        if reference_read and user_read.role != reference_read.role:
             issue_list.append(issues.spreadsheet_file.RoleMismatchError(self.filepath))
             return self._return_or_raise(issue_list, errors)
 
-        if user_result and reference_result:
-            user_result.sheets["reference"] = reference_result.sheets
-            sheets = user_result.sheets
-            original_role = user_result.role
-            read_info_by_sheet = user_result.read_info_by_sheet
-            read_info_by_sheet.update(reference_result.read_info_by_sheet)
-        elif user_result:
-            sheets = user_result.sheets
-            original_role = user_result.role
-            read_info_by_sheet = user_result.read_info_by_sheet
-        elif reference_result:
-            sheets = reference_result.sheets
-            original_role = reference_result.role
-            read_info_by_sheet = reference_result.read_info_by_sheet
-        else:
-            raise ValueError(
-                "No rules were generated. This should have been caught earlier. " f"Bug in {type(self).__name__}."
-            )
+        sheets = user_read.sheets
+        original_role = user_read.role
+        read_info_by_sheet = user_read.read_info_by_sheet
+        if last_read:
+            sheets["last"] = last_read.sheets
+            read_info_by_sheet.update(last_read.read_info_by_sheet)
+            if reference_read:
+                # The last rules will also be validated against the reference rules
+                sheets["last"]["reference"] = reference_read.sheets  # type: ignore[call-overload]
+        if reference_read:
+            sheets["reference"] = reference_read.sheets
+            read_info_by_sheet.update(reference_read.read_info_by_sheet)
 
         rules_cls = RULES_PER_ROLE[original_role]
         with _handle_issues(
@@ -227,7 +252,7 @@ class ExcelImporter(BaseImporter):
         ) as future:
             rules: Rules
             if rules_cls is DMSRules:
-                rules = DMSRulesWrite.load(sheets).as_read()
+                rules = DMSRulesInput.load(sheets).as_rules()
             else:
                 rules = rules_cls.model_validate(sheets)  # type: ignore[attr-defined]
 

cognite/neat/rules/importers/_yaml2rules.py

@@ -5,8 +5,8 @@ import yaml
 
 from cognite.neat.rules import issues
 from cognite.neat.rules.issues import IssueList, NeatValidationError, ValidationIssue
-from cognite.neat.rules.models.rules import RULES_PER_ROLE, DMSRules, RoleTypes
-from cognite.neat.rules.models.rules._dms_rules_write import DMSRulesWrite
+from cognite.neat.rules.models import RULES_PER_ROLE, DMSRules, RoleTypes
+from cognite.neat.rules.models.dms import DMSRulesInput
 
 from ._base import BaseImporter, Rules, _handle_issues
 
@@ -98,7 +98,7 @@ class YAMLImporter(BaseImporter):
         with _handle_issues(issue_list) as future:
             rules: Rules
             if rules_model is DMSRules:
-                rules = DMSRulesWrite.load(self.raw_data).as_read()
+                rules = DMSRulesInput.load(self.raw_data).as_rules()
             else:
                 rules = rules_model.model_validate(self.raw_data)
 

cognite/neat/rules/issues/base.py

@@ -1,4 +1,5 @@
 import sys
+import warnings
 from abc import ABC, abstractmethod
 from collections import UserList
 from collections.abc import Sequence
@@ -182,6 +183,10 @@ class IssueList(UserList[ValidationIssue]):
             [ValueError(issue.message()) for issue in self if isinstance(issue, NeatValidationError)],
         )
 
+    def trigger_warnings(self) -> None:
+        for warning in [issue for issue in self if isinstance(issue, ValidationWarning)]:
+            warnings.warn(warning, stacklevel=2)
+
     def to_pandas(self) -> pd.DataFrame:
         return pd.DataFrame([issue.dump() for issue in self])