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

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -11,8 +11,13 @@ from typing import Literal, cast, overload
 import pandas as pd
 from pandas import ExcelFile
 
-from cognite.neat.rules import issues
-from cognite.neat.rules.issues import IssueList
+from cognite.neat.issues import IssueList, NeatError
+from cognite.neat.issues.errors import (
+    FileMissingRequiredFieldError,
+    FileNotFoundNeatError,
+    FileReadError,
+    PropertyDefinitionDuplicatedError,
+)
 from cognite.neat.rules.models import (
     RULES_PER_ROLE,
     AssetRules,
@@ -27,8 +32,9 @@ from cognite.neat.rules.models.dms import DMSRulesInput
 from cognite.neat.rules.models.information import InformationRulesInput
 from cognite.neat.utils.auxiliary import local_import
 from cognite.neat.utils.spreadsheet import SpreadsheetRead, read_individual_sheet
+from cognite.neat.utils.text import humanize_collection
 
-from ._base import BaseImporter, Rules, _handle_issues
+from ._base import BaseImporter, VerifiedRules, _handle_issues
 
 SOURCE_SHEET__TARGET_FIELD__HEADERS = [
     (
@@ -77,12 +83,12 @@ class MetadataRaw(UserDict):
 
     def is_valid(self, issue_list: IssueList, filepath: Path) -> bool:
         if not self.has_role_field:
-            issue_list.append(issues.spreadsheet_file.RoleMissingOrUnsupportedError(filepath))
+            issue_list.append(FileMissingRequiredFieldError(filepath, "metadata", "role"))
             return False
 
         # check if there is a schema field if role is not domain expert
         if self.role != RoleTypes.domain_expert and not self.has_schema_field:
-            issue_list.append(issues.spreadsheet_file.SchemaMissingOrUnsupportedError(filepath))
+            issue_list.append(FileMissingRequiredFieldError(filepath, "metadata", "schema"))
             return False
         return True
 
@@ -153,11 +159,7 @@ class SpreadsheetReader:
     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
-                    )
-                )
+                self.issue_list.append(FileMissingRequiredFieldError(filepath, "sheet", self.metadata_sheet_name))
             return None
 
         metadata = MetadataRaw.from_excel(excel_file, self.metadata_sheet_name)
@@ -178,7 +180,9 @@ class SpreadsheetReader:
         if missing_sheets := expected_sheet_names.difference(set(excel_file.sheet_names)):
             if self.required:
                 self.issue_list.append(
-                    issues.spreadsheet_file.SheetMissingError(cast(Path, excel_file.io), list(missing_sheets))
+                    FileMissingRequiredFieldError(
+                        cast(Path, excel_file.io), "sheets", humanize_collection(missing_sheets)
+                    )
                 )
             return None, read_info_by_sheet
 
@@ -197,7 +201,7 @@ class SpreadsheetReader:
                     excel_file, source_sheet_name, return_read_info=True, expected_headers=[headers]
                 )
             except Exception as e:
-                self.issue_list.append(issues.spreadsheet_file.ReadSpreadsheetsError(cast(Path, excel_file.io), str(e)))
+                self.issue_list.append(FileReadError(cast(Path, excel_file.io), str(e)))
                 continue
 
         return sheets, read_info_by_sheet
@@ -214,21 +218,21 @@ class ExcelImporter(BaseImporter):
         self.filepath = filepath
 
     @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
+    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> VerifiedRules: ...
 
     @overload
     def to_rules(
         self,
         errors: Literal["continue"] = "continue",
         role: RoleTypes | None = None,
-    ) -> tuple[Rules | None, IssueList]: ...
+    ) -> tuple[VerifiedRules | None, IssueList]: ...
 
     def to_rules(
         self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         issue_list = IssueList(title=f"'{self.filepath.name}'")
         if not self.filepath.exists():
-            issue_list.append(issues.spreadsheet_file.SpreadsheetNotFoundError(self.filepath))
+            issue_list.append(FileNotFoundNeatError(self.filepath))
             return self._return_or_raise(issue_list, errors)
 
         with pd.ExcelFile(self.filepath) as excel_file:
@@ -251,7 +255,16 @@ class ExcelImporter(BaseImporter):
             return self._return_or_raise(issue_list, errors)
 
         if reference_read and user_read.role != reference_read.role:
-            issue_list.append(issues.spreadsheet_file.RoleMismatchError(self.filepath))
+            issue_list.append(
+                PropertyDefinitionDuplicatedError(
+                    self.filepath.as_posix(),
+                    "spreadsheet.metadata",  # type: ignore[arg-type]
+                    "role",
+                    frozenset({user_read.role, reference_read.role}),
+                    ("user", "reference"),
+                    "sheet",
+                )
+            )
             return self._return_or_raise(issue_list, errors)
 
         sheets = user_read.sheets
@@ -270,10 +283,10 @@ class ExcelImporter(BaseImporter):
         rules_cls = RULES_PER_ROLE[original_role]
         with _handle_issues(
             issue_list,
-            error_cls=issues.spreadsheet.InvalidSheetError,
+            error_cls=NeatError,
             error_args={"read_info_by_sheet": read_info_by_sheet},
         ) as future:
-            rules: Rules
+            rules: VerifiedRules
             if rules_cls is DMSRules:
                 rules = DMSRulesInput.load(sheets).as_rules()
             elif rules_cls is InformationRules:
@@ -311,16 +324,16 @@ class GoogleSheetImporter(BaseImporter):
         self.skiprows = skiprows
 
     @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
+    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> VerifiedRules: ...
 
     @overload
     def to_rules(
         self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
+    ) -> tuple[VerifiedRules | None, IssueList]: ...
 
     def to_rules(
         self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         local_import("gspread", "google")
         import gspread  # type: ignore[import]
 

cognite/neat/rules/importers/_yaml2rules.py

@@ -3,12 +3,18 @@ from typing import Any, Literal, overload
 
 import yaml
 
-from cognite.neat.rules import issues
-from cognite.neat.rules.issues import IssueList, NeatValidationError, ValidationIssue
+from cognite.neat.issues import IssueList, NeatIssue
+from cognite.neat.issues.errors import (
+    FileMissingRequiredFieldError,
+    FileNotAFileError,
+    FileNotFoundNeatError,
+    FileTypeUnexpectedError,
+)
+from cognite.neat.issues.warnings import NeatValueWarning
 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
+from ._base import BaseImporter, VerifiedRules, _handle_issues
 
 
 class YAMLImporter(BaseImporter):
@@ -28,7 +34,7 @@ class YAMLImporter(BaseImporter):
     def __init__(
         self,
         raw_data: dict[str, Any],
-        read_issues: list[ValidationIssue] | None = None,
+        read_issues: list[NeatIssue] | None = None,
         filepaths: list[Path] | None = None,
     ) -> None:
         self.raw_data = raw_data
@@ -38,25 +44,25 @@ class YAMLImporter(BaseImporter):
     @classmethod
     def from_file(cls, filepath: Path):
         if not filepath.exists():
-            return cls({}, [issues.fileread.FileNotFoundError(filepath)])
-        if not filepath.is_file():
-            return cls({}, [issues.fileread.FileNotAFileError(filepath)])
+            return cls({}, [FileNotFoundNeatError(filepath)])
+        elif not filepath.is_file():
+            return cls({}, [FileNotAFileError(filepath)])
         elif filepath.suffix not in [".yaml", ".yml"]:
-            return cls({}, [issues.fileread.InvalidFileFormatError(filepath, [".yaml", ".yml"])])
+            return cls({}, [FileTypeUnexpectedError(filepath, frozenset([".yaml", ".yml"]))])
         return cls(yaml.safe_load(filepath.read_text()), filepaths=[filepath])
 
     @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
+    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> VerifiedRules: ...
 
     @overload
     def to_rules(
         self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
+    ) -> tuple[VerifiedRules | None, IssueList]: ...
 
     def to_rules(
         self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
-        if any(issue for issue in self._read_issues if isinstance(issue, NeatValidationError)) or not self.raw_data:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
+        if self._read_issues.has_errors or not self.raw_data:
             if errors == "raise":
                 raise self._read_issues.as_errors()
             return None, self._read_issues
@@ -64,8 +70,8 @@ class YAMLImporter(BaseImporter):
 
         if not self._filepaths:
             issue_list.append(
-                issues.fileread.BugInImporterWarning(
-                    importer_name=type(self).__name__, error="No filepaths when there is content", filepath=Path()
+                NeatValueWarning(
+                    f"{type(self).__name__} was called without filepaths when there is content",
                 )
             )
             metadata_file = Path()
@@ -74,9 +80,7 @@ class YAMLImporter(BaseImporter):
             metadata_file = metadata_file_nullable or self._filepaths[0]
 
         if "metadata" not in self.raw_data:
-            self._read_issues.append(
-                issues.spreadsheet_file.MetadataSheetMissingOrFailedError(metadata_file, "Metadata not found in file")
-            )
+            self._read_issues.append(FileMissingRequiredFieldError(metadata_file, "section", "metadata"))
             if errors == "raise":
                 raise self._read_issues.as_errors()
             return None, self._read_issues
@@ -84,9 +88,7 @@ class YAMLImporter(BaseImporter):
         metadata = self.raw_data["metadata"]
 
         if "role" not in metadata:
-            self._read_issues.append(
-                issues.spreadsheet_file.MetadataSheetMissingOrFailedError(metadata_file, "Role not found in metadata")
-            )
+            self._read_issues.append(FileMissingRequiredFieldError(metadata, "metadata", "role"))
             if errors == "raise":
                 raise self._read_issues.as_errors()
             return None, self._read_issues
@@ -96,7 +98,7 @@ class YAMLImporter(BaseImporter):
         rules_model = RULES_PER_ROLE[role_enum]
 
         with _handle_issues(issue_list) as future:
-            rules: Rules
+            rules: VerifiedRules
             if rules_model is DMSRules:
                 rules = DMSRulesInput.load(self.raw_data).as_rules()
             else:

cognite/neat/rules/models/_constants.py

@@ -1 +1,2 @@
-DMS_CONTAINER_SIZE_LIMIT = 100
+DMS_CONTAINER_PROPERTY_SIZE_LIMIT = 100
+DMS_VIEW_CONTAINER_SIZE_LIMIT = 10

cognite/neat/rules/models/_rdfpath.py

@@ -8,7 +8,7 @@ from typing import ClassVar, Literal
 
 from pydantic import BaseModel, field_validator, model_serializer
 
-from cognite.neat.rules.issues.tables import NotValidRAWLookUpError, NotValidRDFPathError, NotValidTableLookUpError
+from cognite.neat.issues.errors import NeatValueError
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -313,7 +313,7 @@ def parse_traversal(raw: str) -> SelfReferenceProperty | SingleProperty | Hop:
     elif result := HOP_REGEX_COMPILED.match(raw):
         return Hop.from_string(class_=result.group("origin"), traversal=result.group(_traversal))
     else:
-        raise NotValidRDFPathError(raw).as_pydantic_exception()
+        raise NeatValueError(f"Invalid RDF Path: {raw!r}")
 
 
 def parse_table_lookup(raw: str) -> TableLookup:
@@ -323,7 +323,7 @@ def parse_table_lookup(raw: str) -> TableLookup:
             key=result.group(Lookup.key),
             value=result.group(Lookup.value),
         )
-    raise NotValidTableLookUpError(raw).as_pydantic_exception()
+    raise NeatValueError(f"Invalid table lookup: {raw!r}")
 
 
 def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPath:
@@ -334,7 +334,7 @@ def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPa
         case TransformationRuleType.rawlookup:
             rule_raw = rule_raw.replace(" ", "")
             if Counter(rule_raw).get("|") != 1:
-                raise NotValidRAWLookUpError(rule_raw).as_pydantic_exception()
+                raise NeatValueError(f"Invalid rawlookup rule: {rule_raw!r}")
             traversal, table_lookup = rule_raw.split("|")
             return RawLookup(
                 traversal=parse_traversal(traversal),

cognite/neat/rules/models/_types/_field.py

@@ -14,10 +14,9 @@ from pydantic import (
     WrapValidator,
 )
 from pydantic.functional_serializers import PlainSerializer
-from pydantic_core import PydanticCustomError
 
-from cognite.neat.rules.issues.importing import MoreThanOneNonAlphanumericCharacterWarning
-from cognite.neat.rules.issues.spreadsheet import RegexViolationError
+from cognite.neat.issues.errors import RegexViolationError
+from cognite.neat.issues.warnings import RegexViolationWarning
 from cognite.neat.utils.regex_patterns import (
     PATTERNS,
     PREFIX_COMPLIANCE_REGEX,
@@ -36,10 +35,6 @@ def _custom_error(exc_factory: Callable[[str | None, Exception], Any]) -> Any:
     return WrapValidator(_validator)
 
 
-def _raise(exception: PydanticCustomError):
-    raise exception
-
-
 StrOrListType = Annotated[
     str | list[str],
     BeforeValidator(lambda value: value.replace(", ", ",").split(",") if isinstance(value, str) and value else value),
@@ -72,7 +67,7 @@ NamespaceType = Annotated[
 PrefixType = Annotated[
     str,
     StringConstraints(pattern=PREFIX_COMPLIANCE_REGEX),
-    _custom_error(lambda _, value: RegexViolationError(value, PREFIX_COMPLIANCE_REGEX).as_pydantic_exception()),
+    _custom_error(lambda _, value: RegexViolationError(value, PREFIX_COMPLIANCE_REGEX)),
 ]
 
 ExternalIdType = Annotated[
@@ -83,15 +78,18 @@ ExternalIdType = Annotated[
 VersionType = Annotated[
     str,
     StringConstraints(pattern=VERSION_COMPLIANCE_REGEX),
-    _custom_error(lambda _, value: RegexViolationError(value, VERSION_COMPLIANCE_REGEX).as_pydantic_exception()),
+    _custom_error(lambda _, value: RegexViolationError(value, VERSION_COMPLIANCE_REGEX)),
 ]
 
 
 def _property_validation(value: str) -> str:
     if not PATTERNS.property_id_compliance.match(value):
-        _raise(RegexViolationError(value, PROPERTY_ID_COMPLIANCE_REGEX).as_pydantic_exception())
+        raise RegexViolationError(value, PROPERTY_ID_COMPLIANCE_REGEX)
     if PATTERNS.more_than_one_alphanumeric.search(value):
-        warnings.warn(MoreThanOneNonAlphanumericCharacterWarning("property", value), stacklevel=2)
+        warnings.warn(
+            RegexViolationWarning(value, PROPERTY_ID_COMPLIANCE_REGEX, "property", "MoreThanOneNonAlphanumeric"),
+            stacklevel=2,
+        )
     return value
 
 

cognite/neat/rules/models/asset/_rules.py

@@ -6,8 +6,6 @@ from pydantic.main import IncEx
 from rdflib import Namespace
 
 from cognite.neat.constants import get_default_prefixes
-from cognite.neat.issues import MultiValueError
-from cognite.neat.rules import issues
 from cognite.neat.rules.models._base import BaseRules, RoleTypes, SheetList
 from cognite.neat.rules.models.domain import DomainRules
 from cognite.neat.rules.models.entities import (
@@ -109,7 +107,7 @@ class AssetRules(BaseRules):
         if issue_list.warnings:
             issue_list.trigger_warnings()
         if issue_list.has_errors:
-            raise MultiValueError([error for error in issue_list if isinstance(error, issues.NeatValidationError)])
+            raise issue_list.as_exception()
         return self
 
     def dump(

cognite/neat/rules/models/asset/_validation.py

@@ -1,8 +1,8 @@
 from graphlib import CycleError
 from typing import cast
 
-from cognite.neat.rules import issues
-from cognite.neat.rules.issues.base import IssueList
+from cognite.neat.issues import IssueList
+from cognite.neat.issues.errors import NeatValueError, PropertyDefinitionError
 from cognite.neat.rules.models._base import SheetList
 from cognite.neat.rules.models.asset._rules import AssetProperty, AssetRules
 from cognite.neat.rules.models.entities import AssetEntity, AssetFields, ClassEntity
@@ -17,7 +17,6 @@ class AssetPostValidation(InformationPostValidation):
         return self.issue_list
 
     def _parent_property_point_to_class(self) -> None:
-        class_property_with_data_value_type = []
         for property_ in cast(SheetList[AssetProperty], self.properties):
             for implementation in property_.implementation:
                 if (
@@ -25,12 +24,15 @@ class AssetPostValidation(InformationPostValidation):
                     and implementation.property_ == AssetFields.parentExternalId
                     and not isinstance(property_.value_type, ClassEntity)
                 ):
-                    class_property_with_data_value_type.append((property_.class_.suffix, property_.property_))
-
-        if class_property_with_data_value_type:
-            self.issue_list.append(
-                issues.spreadsheet.AssetParentPropertyPointsToDataValueTypeError(class_property_with_data_value_type)
-            )
+                    self.issue_list.append(
+                        PropertyDefinitionError(
+                            property_.class_,
+                            "class",
+                            property_.property_,
+                            "parentExternalId is only allowed to "
+                            f"point to a Class not {type(property_.value_type).__name__}",
+                        )
+                    )
 
     def _circular_dependency(self) -> None:
         from cognite.neat.rules.analysis import AssetAnalysis
@@ -38,4 +40,6 @@ class AssetPostValidation(InformationPostValidation):
         try:
             _ = AssetAnalysis(cast(AssetRules, self.rules)).class_topological_sort()
         except CycleError as error:
-            self.issue_list.append(issues.spreadsheet.AssetRulesHaveCircularDependencyError(error.args[1]))
+            self.issue_list.append(
+                NeatValueError(f"Invalid Asset Hierarchy, circular dependency detected: {error.args[1]}")
+            )

cognite/neat/rules/models/dms/_converter.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, cast
 
 from rdflib import Namespace
 
-from cognite.neat.rules import issues
+from cognite.neat.issues.warnings.user_modeling import ParentInDifferentSpaceWarning
 from cognite.neat.rules.models._base import SheetList
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.domain import DomainRules
@@ -123,9 +123,7 @@ class _DMSRulesConverter:
             return None
         if len(parents_other_namespace) > 1:
             warnings.warn(
-                issues.dms.MultipleReferenceWarning(
-                    view_id=view.view.as_id(), implements=[v.as_id() for v in parents_other_namespace]
-                ),
+                ParentInDifferentSpaceWarning(view.view.as_id()),
                 stacklevel=2,
             )
         other_parent = parents_other_namespace[0]

cognite/neat/rules/models/dms/_exporter.py

@@ -12,7 +12,13 @@ from cognite.client.data_classes.data_modeling.views import (
     ViewPropertyApply,
 )
 
-from cognite.neat.rules import issues
+from cognite.neat.issues.warnings import NotSupportedWarning, PropertyNotFoundWarning
+from cognite.neat.issues.warnings.user_modeling import (
+    EmptyContainerWarning,
+    HasDataFilterOnNoPropertiesViewWarning,
+    HasDataFilterOnViewWithReferencesWarning,
+    NodeTypeFilterOnParentViewWarning,
+)
 from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import (
@@ -213,7 +219,11 @@ class _DMSExporter:
             if isinstance(view_filter, NodeTypeFilter):
                 unique_node_types.update(view_filter.nodes)
                 if view.as_id() in parent_views:
-                    warnings.warn(issues.dms.NodeTypeFilterOnParentViewWarning(view.as_id()), stacklevel=2)
+                    warnings.warn(
+                        NodeTypeFilterOnParentViewWarning(view.as_id()),
+                        stacklevel=2,
+                    )
+
             elif isinstance(view_filter, HasDataFilter) and data_model_type == DataModelType.solution:
                 if dms_view and isinstance(dms_view.reference, ReferenceEntity):
                     references = {dms_view.reference.as_view_id()}
@@ -226,7 +236,8 @@ class _DMSExporter:
                 else:
                     continue
                 warnings.warn(
-                    issues.dms.HasDataFilterOnViewWithReferencesWarning(view.as_id(), list(references)), stacklevel=2
+                    HasDataFilterOnViewWithReferencesWarning(view.as_id(), frozenset(references)),
+                    stacklevel=2,
                 )
 
             if data_model_type == DataModelType.enterprise:
@@ -273,7 +284,10 @@ class _DMSExporter:
         for container in containers:
             container_id = container.as_id()
             if not (container_properties := container_properties_by_id.get(container_id)):
-                warnings.warn(issues.dms.EmptyContainerWarning(container_id=container_id), stacklevel=2)
+                warnings.warn(
+                    EmptyContainerWarning(container_id),
+                    stacklevel=2,
+                )
                 container_to_drop.add(container_id)
                 continue
             for prop in container_properties:
@@ -409,7 +423,10 @@ class _DMSExporter:
         if not ref_containers or selected_filter_name == HasDataFilter.name:
             # Child filter without container properties
             if selected_filter_name == HasDataFilter.name:
-                warnings.warn(issues.dms.HasDataFilterOnNoPropertiesViewWarning(view.as_id()), stacklevel=2)
+                warnings.warn(
+                    HasDataFilterOnNoPropertiesViewWarning(view.as_id()),
+                    stacklevel=2,
+                )
             return NodeTypeFilter(inner=[DMSNodeEntity(space=view.space, externalId=view.external_id)])
         else:
             # HasData or not provided (this is the default)
@@ -493,7 +510,13 @@ class _DMSExporter:
 
             if reverse_prop is None:
                 warnings.warn(
-                    issues.dms.ReverseRelationMissingOtherSideWarning(source_view_id, prop.view_property),
+                    PropertyNotFoundWarning(
+                        source_view_id,
+                        "view",
+                        reverse_prop_id or "MISSING",
+                        dm.PropertyId(prop.view.as_id(), prop.view_property),
+                        "view property",
+                    ),
                     stacklevel=2,
                 )
 
@@ -523,7 +546,6 @@ class _DMSExporter:
 
         elif prop.view and prop.view_property and prop.connection:
             warnings.warn(
-                issues.dms.UnsupportedConnectionWarning(prop.view.as_id(), prop.view_property, prop.connection or ""),
-                stacklevel=2,
+                NotSupportedWarning(f"{prop.connection} in {prop.view.as_id()!r}.{prop.view_property}"), stacklevel=2
             )
         return None

cognite/neat/rules/models/dms/_rules.py

@@ -11,8 +11,11 @@ from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic.main import IncEx
 from pydantic_core.core_schema import ValidationInfo
 
-from cognite.neat.rules import issues
-from cognite.neat.rules.issues import MultiValueError
+from cognite.neat.issues import MultiValueError
+from cognite.neat.issues.warnings import (
+    PrincipleMatchingSpaceAndVersionWarning,
+    PrincipleSolutionBuildsOnEnterpriseWarning,
+)
 from cognite.neat.rules.models._base import (
     BaseMetadata,
     BaseRules,
@@ -320,8 +323,9 @@ class DMSRules(BaseRules):
             raise ValueError("Reference rules cannot have a reference")
         if value.metadata.data_model_type == DataModelType.solution and (metadata := info.data.get("metadata")):
             warnings.warn(
-                issues.dms.SolutionOnTopOfSolutionModelWarning(
-                    metadata.as_data_model_id(), value.metadata.as_data_model_id()
+                PrincipleSolutionBuildsOnEnterpriseWarning(
+                    f"The solution model {metadata.as_data_model_id()} is referencing another "
+                    f"solution model {value.metadata.as_data_model_id()}",
                 ),
                 stacklevel=2,
             )
@@ -333,9 +337,21 @@ class DMSRules(BaseRules):
             return value
         model_version = metadata.version
         if different_version := [view.view.as_id() for view in value if view.view.version != model_version]:
-            warnings.warn(issues.dms.ViewModelVersionNotMatchingWarning(different_version, model_version), stacklevel=2)
+            for view_id in different_version:
+                warnings.warn(
+                    PrincipleMatchingSpaceAndVersionWarning(
+                        f"The view {view_id!r} has a different version than the data model version, {model_version}",
+                    ),
+                    stacklevel=2,
+                )
         if different_space := [view.view.as_id() for view in value if view.view.space != metadata.space]:
-            warnings.warn(issues.dms.ViewModelSpaceNotMatchingWarning(different_space, metadata.space), stacklevel=2)
+            for view_id in different_space:
+                warnings.warn(
+                    PrincipleMatchingSpaceAndVersionWarning(
+                        f"The view {view_id!r} is in a different space than the data model space, {metadata.space}",
+                    ),
+                    stacklevel=2,
+                )
         return value
 
     @model_validator(mode="after")
@@ -346,7 +362,7 @@ class DMSRules(BaseRules):
         if issue_list.warnings:
             issue_list.trigger_warnings()
         if issue_list.has_errors:
-            raise MultiValueError([error for error in issue_list if isinstance(error, issues.NeatValidationError)])
+            raise MultiValueError(issue_list.errors)
         return self
 
     def dump(