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

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

@@ -26,17 +26,20 @@ from cognite.client.data_classes.data_modeling.views import (
 from cognite.client.data_classes.transformations.common import Edges, EdgeType, Nodes, ViewInfo
 
 from cognite.neat.issues import NeatError
-from cognite.neat.issues.errors.properties import ReferredPropertyNotFoundError
-from cognite.neat.issues.errors.resources import ReferredResourceNotFoundError
-from cognite.neat.issues.neat_warnings.resources import FailedLoadingResourcesWarning, MultipleResourcesWarning
-from cognite.neat.rules import issues
-from cognite.neat.rules.issues.dms import (
-    ContainerPropertyUsedMultipleTimesError,
-    DirectRelationMissingSourceWarning,
-    DuplicatedViewInDataModelError,
-    IncompleteSchemaError,
-    MissingViewInModelWarning,
+from cognite.neat.issues.errors import (
+    NeatYamlError,
+    PropertyMappingDuplicatedError,
+    PropertyNotFoundError,
+    ResourceDuplicatedError,
+    ResourceNotFoundError,
 )
+from cognite.neat.issues.warnings import (
+    FileTypeUnexpectedWarning,
+    ResourceNotFoundWarning,
+    ResourceRetrievalWarning,
+    ResourcesDuplicatedWarning,
+)
+from cognite.neat.issues.warnings.user_modeling import DirectRelationMissingSourceWarning
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE
 from cognite.neat.utils.cdf.data_classes import (
     CogniteResourceDict,
@@ -93,11 +96,11 @@ class DMSSchema:
         directly_referenced_containers = view_by_id[view_id].referenced_containers()
         inherited_referenced_containers = set()
 
-        for view_id in view_inheritance:
-            if implemented_view := view_by_id.get(view_id):
+        for parent_id in view_inheritance:
+            if implemented_view := view_by_id.get(parent_id):
                 inherited_referenced_containers |= implemented_view.referenced_containers()
             else:
-                raise IncompleteSchemaError(missing_component=view_id).as_exception()
+                raise ResourceNotFoundError(parent_id, "view", view_id, "view")
 
         return directly_referenced_containers | inherited_referenced_containers
 
@@ -164,10 +167,14 @@ class DMSSchema:
             connection_referenced_view_ids |= cls._connection_references(view)
         connection_referenced_view_ids = connection_referenced_view_ids - existing_view_ids
         if connection_referenced_view_ids:
-            warnings.warn(MissingViewInModelWarning(data_model.as_id(), connection_referenced_view_ids), stacklevel=2)
+            for view_id in connection_referenced_view_ids:
+                warnings.warn(
+                    ResourceNotFoundWarning(view_id, "view", data_model_write.as_id(), "data model"),
+                    stacklevel=2,
+                )
             connection_referenced_views = view_loader.retrieve(list(connection_referenced_view_ids))
             if failed := connection_referenced_view_ids - set(connection_referenced_views.as_ids()):
-                warnings.warn(FailedLoadingResourcesWarning[dm.ViewId](frozenset(failed), "View"), stacklevel=2)
+                warnings.warn(ResourceRetrievalWarning(frozenset(failed), "view"), stacklevel=2)
             views.extend(connection_referenced_views)
 
         # We need to include parent views in the schema to make sure that the schema is valid.
@@ -262,10 +269,11 @@ class DMSSchema:
                     data.setdefault(attr_name, [])
                     context.setdefault(attr_name, [])
                     try:
-                        # Using CSafeLoader over safe_load for ~10x speedup
                         loaded = yaml.safe_load(yaml_file.read_text())
                     except Exception as e:
-                        warnings.warn(issues.fileread.InvalidFileFormatWarning(yaml_file, str(e)), stacklevel=2)
+                        warnings.warn(
+                            FileTypeUnexpectedWarning(yaml_file, frozenset([".yaml", ".yml"]), str(e)), stacklevel=2
+                        )
                         continue
 
                     if isinstance(loaded, list):
@@ -355,7 +363,9 @@ class DMSSchema:
                         try:
                             loaded = yaml.safe_load(zip_ref.read(file_info).decode())
                         except Exception as e:
-                            warnings.warn(issues.fileread.InvalidFileFormatWarning(filename, str(e)), stacklevel=2)
+                            warnings.warn(
+                                FileTypeUnexpectedWarning(filename, frozenset([".yaml", ".yml"]), str(e)), stacklevel=2
+                            )
                             continue
                         if isinstance(loaded, list):
                             data[attr_name].extend(loaded)
@@ -411,11 +421,9 @@ class DMSSchema:
             try:
                 data_dict = yaml.safe_load(data)
             except Exception as e:
-                raise issues.fileread.FailedStringLoadError(".yaml", str(e)).as_exception() from None
+                raise NeatYamlError(str(e)) from None
             if not isinstance(data_dict, dict) and all(isinstance(v, list) for v in data_dict.values()):
-                raise issues.fileread.FailedStringLoadError(
-                    "dict[str, list[Any]]", f"Invalid data structure: {type(data)}"
-                ).as_exception() from None
+                raise NeatYamlError(f"Invalid data structure: {type(data)}", "dict[str, list[Any]]") from None
         else:
             data_dict = data
         loaded: dict[str, Any] = {}
@@ -423,20 +431,32 @@ class DMSSchema:
             if items := data_dict.get(attr.name) or data_dict.get(to_camel(attr.name)):
                 if attr.name == "data_model":
                     if isinstance(items, list) and len(items) > 1:
-                        warnings.warn(
-                            MultipleResourcesWarning[str](
-                                frozenset([item.get("externalId", "Unknown") for item in items]),
-                                "DataModel",
-                            ),
-                            stacklevel=2,
-                        )
+                        try:
+                            data_model_ids = [dm.DataModelId.load(item) for item in items]
+                        except Exception as e:
+                            data_model_file = context.get(attr.name, [Path("UNKNOWN")])[0]
+                            warnings.warn(
+                                FileTypeUnexpectedWarning(
+                                    data_model_file, frozenset([dm.DataModelApply.__name__]), str(e)
+                                ),
+                                stacklevel=2,
+                            )
+                        else:
+                            warnings.warn(
+                                ResourcesDuplicatedWarning(
+                                    frozenset(data_model_ids),
+                                    "data model",
+                                    "Will use the first DataModel.",
+                                ),
+                                stacklevel=2,
+                            )
                     item = items[0] if isinstance(items, list) else items
                     try:
                         loaded[attr.name] = dm.DataModelApply.load(item)
                     except Exception as e:
                         data_model_file = context.get(attr.name, [Path("UNKNOWN")])[0]
                         warnings.warn(
-                            issues.fileread.FailedLoadWarning(data_model_file, dm.DataModelApply.__name__, str(e)),
+                            FileTypeUnexpectedWarning(data_model_file, frozenset([dm.DataModelApply.__name__]), str(e)),
                             stacklevel=2,
                         )
                 else:
@@ -453,7 +473,7 @@ class DMSSchema:
         resources = attr.type([])
         if not hasattr(attr.type, "_RESOURCE"):
             warnings.warn(
-                issues.fileread.FailedLoadWarning(Path("UNKNOWN"), attr.type.__name__, trigger_error), stacklevel=2
+                FileTypeUnexpectedWarning(Path("UNKNOWN"), frozenset([attr.type.__name__]), trigger_error), stacklevel=2
             )
             return resources
         # Fallback to load individual resources.
@@ -467,7 +487,9 @@ class DMSSchema:
                 except IndexError:
                     filepath = Path("UNKNOWN")
                 # We use repr(e) instead of str(e) to include the exception type in the warning message
-                warnings.warn(issues.fileread.FailedLoadWarning(filepath, single_cls.__name__, repr(e)), stacklevel=2)
+                warnings.warn(
+                    FileTypeUnexpectedWarning(filepath, frozenset([single_cls.__name__]), repr(e)), stacklevel=2
+                )
             else:
                 resources.append(loaded_instance)
         return resources
@@ -529,41 +551,31 @@ class DMSSchema:
         for container in self.containers.values():
             if container.space not in defined_spaces:
                 errors.add(
-                    ReferredResourceNotFoundError[str, dm.ContainerId](
-                        container.space, "Space", container.as_id(), "Container"
-                    )
+                    ResourceNotFoundError[str, dm.ContainerId](container.space, "space", container.as_id(), "container")
                 )
 
         for view in self.views.values():
             view_id = view.as_id()
             if view.space not in defined_spaces:
-                errors.add(ReferredResourceNotFoundError[str, dm.ViewId](view.space, "Space", view_id, "View"))
+                errors.add(ResourceNotFoundError(view.space, "space", view_id, "view"))
 
             for parent in view.implements or []:
                 if parent not in defined_views:
-                    errors.add(
-                        ReferredPropertyNotFoundError[dm.ViewId, dm.ViewId](
-                            parent, "View", view_id, "View", property_name="implements"
-                        )
-                    )
+                    errors.add(PropertyNotFoundError(parent, "view", "implements", view_id, "view"))
 
             for prop_name, prop in (view.properties or {}).items():
                 if isinstance(prop, dm.MappedPropertyApply):
                     ref_container = defined_containers.get(prop.container)
                     if ref_container is None:
-                        errors.add(
-                            ReferredResourceNotFoundError[dm.ContainerId, dm.ViewId](
-                                prop.container, "Container", view_id, "View"
-                            )
-                        )
+                        errors.add(ResourceNotFoundError(prop.container, "container", view_id, "view"))
                     elif prop.container_property_identifier not in ref_container.properties:
                         errors.add(
-                            ReferredPropertyNotFoundError[dm.ContainerId, dm.ViewId](
+                            PropertyNotFoundError(
                                 prop.container,
-                                "Container",
+                                "container",
+                                prop.container_property_identifier,
                                 view_id,
-                                "View",
-                                property_name=prop.container_property_identifier,
+                                "view",
                             )
                         )
                     else:
@@ -571,26 +583,19 @@ class DMSSchema:
 
                         if isinstance(container_property.type, dm.DirectRelation) and prop.source is None:
                             warnings.warn(
-                                DirectRelationMissingSourceWarning(view_id=view_id, property=prop_name), stacklevel=2
+                                DirectRelationMissingSourceWarning(view_id, prop_name),
+                                stacklevel=2,
                             )
 
                 if isinstance(prop, dm.EdgeConnectionApply) and prop.source not in defined_views:
-                    errors.add(
-                        ReferredPropertyNotFoundError[dm.ViewId, dm.ViewId](
-                            prop.source, "View", view_id, "View", property_name=prop_name
-                        )
-                    )
+                    errors.add(PropertyNotFoundError(prop.source, "view", prop_name, view_id, "view"))
 
                 if (
                     isinstance(prop, dm.EdgeConnectionApply)
                     and prop.edge_source is not None
                     and prop.edge_source not in defined_views
                 ):
-                    errors.add(
-                        ReferredPropertyNotFoundError[dm.ViewId, dm.ViewId](
-                            prop.edge_source, "View", view_id, "View", property_name=prop_name
-                        )
-                    )
+                    errors.add(PropertyNotFoundError(prop.edge_source, "view", prop_name, view_id, "view"))
 
             # This allows for multiple view properties to be mapped to the same container property,
             # as long as they have different external_id, otherwise this will lead to raising
@@ -615,36 +620,36 @@ class DMSSchema:
                         == (container_id, container_property_identifier)
                     ]
                     errors.add(
-                        ContainerPropertyUsedMultipleTimesError(
-                            container=container_id,
-                            property=container_property_identifier,
-                            referred_by=frozenset({(view_id, prop_name) for prop_name in view_properties}),
+                        PropertyMappingDuplicatedError(
+                            container_id,
+                            "container",
+                            container_property_identifier,
+                            frozenset({dm.PropertyId(view_id, prop_name) for prop_name in view_properties}),
+                            "view property",
                         )
                     )
 
         if self.data_model:
             model = self.data_model
             if model.space not in defined_spaces:
-                errors.add(
-                    ReferredResourceNotFoundError[str, dm.DataModelId](
-                        model.space, "Space", model.as_id(), "Data Model"
-                    )
-                )
+                errors.add(ResourceNotFoundError(model.space, "space", model.as_id(), "data model"))
 
             view_counts: dict[dm.ViewId, int] = defaultdict(int)
             for view_id_or_class in model.views or []:
                 view_id = view_id_or_class if isinstance(view_id_or_class, dm.ViewId) else view_id_or_class.as_id()
                 if view_id not in defined_views:
-                    errors.add(
-                        ReferredResourceNotFoundError[dm.ViewId, dm.DataModelId](
-                            view_id, "View", model.as_id(), "DataModel"
-                        )
-                    )
+                    errors.add(ResourceNotFoundError(view_id, "view", model.as_id(), "data model"))
                 view_counts[view_id] += 1
 
             for view_id, count in view_counts.items():
                 if count > 1:
-                    errors.add(DuplicatedViewInDataModelError(referred_by=model.as_id(), view=view_id))
+                    errors.add(
+                        ResourceDuplicatedError(
+                            view_id,
+                            "view",
+                            repr(model.as_id()),
+                        )
+                    )
 
         return list(errors)
 
@@ -852,7 +857,9 @@ class PipelineSchema(DMSSchema):
                 try:
                     loaded = yaml.safe_load(yaml_file.read_text())
                 except Exception as e:
-                    warnings.warn(issues.fileread.InvalidFileFormatWarning(yaml_file, str(e)), stacklevel=2)
+                    warnings.warn(
+                        FileTypeUnexpectedWarning(yaml_file, frozenset([".yaml", ".yml"]), str(e)), stacklevel=2
+                    )
                     continue
                 if isinstance(loaded, list):
                     data[attr_name].extend(loaded)
@@ -918,7 +925,9 @@ class PipelineSchema(DMSSchema):
                         try:
                             loaded = yaml.safe_load(zip_ref.read(file_info).decode())
                         except Exception as e:
-                            warnings.warn(issues.fileread.InvalidFileFormatWarning(filepath, str(e)), stacklevel=2)
+                            warnings.warn(
+                                FileTypeUnexpectedWarning(filepath, frozenset([".yaml", ".yml"]), str(e)), stacklevel=2
+                            )
                             continue
                         if isinstance(loaded, list):
                             data[attr_name].extend(loaded)

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

@@ -3,10 +3,22 @@ from typing import Any, ClassVar
 
 from cognite.client import data_modeling as dm
 
-from cognite.neat.issues import IssueList, NeatIssueList
-from cognite.neat.rules import issues
+from cognite.neat.issues import IssueList, NeatError, NeatIssue, NeatIssueList
+from cognite.neat.issues.errors import (
+    PropertyDefinitionDuplicatedError,
+    ResourceChangedError,
+    ResourceNotDefinedError,
+)
+from cognite.neat.issues.warnings import (
+    NotSupportedHasDataFilterLimitWarning,
+    NotSupportedViewContainerLimitWarning,
+)
+from cognite.neat.issues.warnings.user_modeling import (
+    NotNeatSupportedFilterWarning,
+    ViewPropertyLimitWarning,
+)
 from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness
-from cognite.neat.rules.models._constants import DMS_CONTAINER_SIZE_LIMIT
+from cognite.neat.rules.models._constants import DMS_CONTAINER_PROPERTY_SIZE_LIMIT
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ContainerEntity
 from cognite.neat.rules.models.wrapped_entities import RawFilter
@@ -51,7 +63,7 @@ class DMSPostValidation:
             if prop.container and prop.container_property:
                 container_properties_by_id[(prop.container, prop.container_property)].append((prop_no, prop))
 
-        errors: list[issues.spreadsheet.InconsistentContainerDefinitionError] = []
+        errors: list[NeatError] = []
         for (container, prop_name), properties in container_properties_by_id.items():
             if len(properties) == 1:
                 continue
@@ -63,42 +75,78 @@ class DMSPostValidation:
             is_all_direct = all(prop.connection == "direct" for _, prop in properties)
             if len(value_types) > 1 and not is_all_direct:
                 errors.append(
-                    issues.spreadsheet.MultiValueTypeError(
+                    PropertyDefinitionDuplicatedError[dm.ContainerId](
                         container_id,
+                        "container",
                         prop_name,
-                        row_numbers,
-                        {v.dms._type if isinstance(v, DataType) else str(v) for v in value_types},
+                        frozenset({v.dms._type if isinstance(v, DataType) else str(v) for v in value_types}),
+                        tuple(row_numbers),
+                        "rows",
                     )
                 )
             list_definitions = {prop.is_list for _, prop in properties if prop.is_list is not None}
             if len(list_definitions) > 1:
                 errors.append(
-                    issues.spreadsheet.MultiValueIsListError(container_id, prop_name, row_numbers, list_definitions)
+                    PropertyDefinitionDuplicatedError[dm.ContainerId](
+                        container_id,
+                        "container",
+                        prop_name,
+                        frozenset(list_definitions),
+                        tuple(row_numbers),
+                        "rows",
+                    )
                 )
             nullable_definitions = {prop.nullable for _, prop in properties if prop.nullable is not None}
             if len(nullable_definitions) > 1:
                 errors.append(
-                    issues.spreadsheet.MultiNullableError(container_id, prop_name, row_numbers, nullable_definitions)
+                    PropertyDefinitionDuplicatedError[dm.ContainerId](
+                        container_id,
+                        "container",
+                        prop_name,
+                        frozenset(nullable_definitions),
+                        tuple(row_numbers),
+                        "rows",
+                    )
                 )
             default_definitions = {prop.default for _, prop in properties if prop.default is not None}
             if len(default_definitions) > 1:
                 errors.append(
-                    issues.spreadsheet.MultiDefaultError(
-                        container_id, prop_name, row_numbers, list(default_definitions)
+                    PropertyDefinitionDuplicatedError[dm.ContainerId](
+                        container_id,
+                        "container",
+                        prop_name,
+                        frozenset(
+                            tuple(f"{k}:{v}" for k, v in def_.items()) if isinstance(def_, dict) else def_
+                            for def_ in default_definitions
+                        ),
+                        tuple(row_numbers),
+                        "rows",
                     )
                 )
             index_definitions = {",".join(prop.index) for _, prop in properties if prop.index is not None}
             if len(index_definitions) > 1:
                 errors.append(
-                    issues.spreadsheet.MultiIndexError(container_id, prop_name, row_numbers, index_definitions)
+                    PropertyDefinitionDuplicatedError[dm.ContainerId](
+                        container_id,
+                        "container",
+                        prop_name,
+                        frozenset(index_definitions),
+                        tuple(row_numbers),
+                        "rows",
+                    )
                 )
             constraint_definitions = {
                 ",".join(prop.constraint) for _, prop in properties if prop.constraint is not None
             }
             if len(constraint_definitions) > 1:
                 errors.append(
-                    issues.spreadsheet.MultiUniqueConstraintError(
-                        container_id, prop_name, row_numbers, constraint_definitions
+                    PropertyDefinitionDuplicatedError[dm.ContainerId](
+                        container_id,
+                        "container",
+                        prop_name,
+                        frozenset(constraint_definitions),
+                        tuple(row_numbers),
+                        "rows",
                     )
                 )
 
@@ -125,32 +173,25 @@ class DMSPostValidation:
             defined_views |= {view.view.as_id() for view in self.rules.last.views}
 
         property_count_by_view: dict[dm.ViewId, int] = defaultdict(int)
-        errors: list[issues.ValidationIssue] = []
+        errors: list[NeatIssue] = []
         for prop_no, prop in enumerate(self.properties):
             view_id = prop.view.as_id()
             if view_id not in defined_views:
                 errors.append(
-                    issues.spreadsheet.NonExistingViewError(
-                        column="View",
-                        row=prop_no,
-                        type="value_error.missing",
-                        view_id=view_id,
-                        msg="",
-                        input=None,
-                        url=None,
-                    )
+                    ResourceNotDefinedError[dm.ViewId](
+                        identifier=view_id,
+                        resource_type="view",
+                        location="Views Sheet",
+                        column_name="View",
+                        row_number=prop_no,
+                        sheet_name="Properties",
+                    ),
                 )
             else:
                 property_count_by_view[view_id] += 1
         for view_id, count in property_count_by_view.items():
-            if count > DMS_CONTAINER_SIZE_LIMIT:
-                errors.append(
-                    issues.dms.ViewSizeWarning(
-                        view_id=view_id,
-                        limit=DMS_CONTAINER_SIZE_LIMIT,
-                        count=count,
-                    )
-                )
+            if count > DMS_CONTAINER_PROPERTY_SIZE_LIMIT:
+                errors.append(ViewPropertyLimitWarning(view_id, count))
         if self.metadata.schema_ is SchemaCompleteness.complete:
             defined_containers = {container.container.as_id() for container in self.containers or []}
             if self.metadata.data_model_type == DataModelType.solution and self.rules.reference:
@@ -161,28 +202,26 @@ class DMSPostValidation:
             for prop_no, prop in enumerate(self.properties):
                 if prop.container and (container_id := prop.container.as_id()) not in defined_containers:
                     errors.append(
-                        issues.spreadsheet.NonExistingContainerError(
-                            column="Container",
-                            row=prop_no,
-                            type="value_error.missing",
-                            container_id=container_id,
-                            msg="",
-                            input=None,
-                            url=None,
+                        ResourceNotDefinedError[dm.ContainerId](
+                            identifier=container_id,
+                            resource_type="container",
+                            location="Containers Sheet",
+                            column_name="Container",
+                            row_number=prop_no,
+                            sheet_name="Properties",
                         )
                     )
             for _container_no, container in enumerate(self.containers or []):
                 for constraint_no, constraint in enumerate(container.constraint or []):
                     if constraint.as_id() not in defined_containers:
                         errors.append(
-                            issues.spreadsheet.NonExistingContainerError(
-                                column="Constraint",
-                                row=constraint_no,
-                                type="value_error.missing",
-                                container_id=constraint.as_id(),
-                                msg="",
-                                input=None,
-                                url=None,
+                            ResourceNotDefinedError[dm.ContainerId](
+                                identifier=constraint.as_id(),
+                                resource_type="container",
+                                location="Containers Sheet",
+                                column_name="Constraint",
+                                row_number=constraint_no,
+                                sheet_name="Properties",
                             )
                         )
         self.issue_list.extend(errors)
@@ -212,10 +251,11 @@ class DMSPostValidation:
                 new_dumped, existing_dumped
             )
             self.issue_list.append(
-                issues.dms.ChangingContainerError(
-                    container_id=container_id,
-                    changed_properties=changed_properties or None,
-                    changed_attributes=changed_attributes or None,
+                ResourceChangedError(
+                    container_id,
+                    "container",
+                    changed_properties=frozenset(changed_properties),
+                    changed_attributes=frozenset(changed_attributes),
                 )
             )
 
@@ -241,10 +281,11 @@ class DMSPostValidation:
                 # Only added new properties, no problem
                 continue
             self.issue_list.append(
-                issues.dms.ChangingViewError(
-                    view_id=view_id,
-                    changed_properties=changed_properties or None,
-                    changed_attributes=changed_attributes or None,
+                ResourceChangedError(
+                    view_id,
+                    "view",
+                    changed_properties=frozenset(changed_properties),
+                    changed_attributes=frozenset(changed_attributes),
                 )
             )
 
@@ -254,9 +295,9 @@ class DMSPostValidation:
 
             if mapped_containers and len(mapped_containers) > 10:
                 self.issue_list.append(
-                    issues.dms.ViewMapsToTooManyContainersWarning(
-                        view_id=view_id,
-                        container_ids=mapped_containers,
+                    NotSupportedViewContainerLimitWarning(
+                        view_id,
+                        len(mapped_containers),
                     )
                 )
                 if (
@@ -265,9 +306,9 @@ class DMSPostValidation:
                     and len(view.filter.dump()["hasData"]) > 10
                 ):
                     self.issue_list.append(
-                        issues.dms.HasDataFilterAppliedToTooManyContainersWarning(
-                            view_id=view_id,
-                            container_ids=mapped_containers,
+                        NotSupportedHasDataFilterLimitWarning(
+                            view_id,
+                            len(view.filter.dump()["hasData"]),
                         )
                     )
 
@@ -275,9 +316,7 @@ class DMSPostValidation:
         for view in self.views:
             if view.filter_ and isinstance(view.filter_, RawFilter):
                 self.issue_list.append(
-                    issues.dms.RawFilterAppliedToViewWarning(
-                        view_id=view.view.as_id(),
-                    )
+                    NotNeatSupportedFilterWarning(view.view.as_id()),
                 )
 
     @staticmethod

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

@@ -12,7 +12,7 @@ from cognite.neat.rules.models._base import (
     SchemaCompleteness,
     SheetList,
 )
-from cognite.neat.rules.models._constants import DMS_CONTAINER_SIZE_LIMIT
+from cognite.neat.rules.models._constants import DMS_CONTAINER_PROPERTY_SIZE_LIMIT
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.domain import DomainRules
 from cognite.neat.rules.models.entities import (
@@ -266,7 +266,7 @@ class _InformationRulesConverter:
         else:
             container_entity = prop.class_.as_container_entity(default_space)
 
-        while self.property_count_by_container[container_entity] >= DMS_CONTAINER_SIZE_LIMIT:
+        while self.property_count_by_container[container_entity] >= DMS_CONTAINER_PROPERTY_SIZE_LIMIT:
             container_entity.suffix = self._bump_suffix(container_entity.suffix)
 
         self.property_count_by_container[container_entity] += 1

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

@@ -8,9 +8,7 @@ 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.issues.spreadsheet import DefaultValueTypeNotProperError
+from cognite.neat.issues.errors import PropertyDefinitionError
 from cognite.neat.rules.models._base import (
     BaseMetadata,
     BaseRules,
@@ -228,11 +226,12 @@ class InformationProperty(SheetEntity):
                         self.default = self.value_type.python(self.default)
 
                 except Exception:
-                    raise DefaultValueTypeNotProperError(
+                    raise PropertyDefinitionError(
+                        self.class_,
+                        "Class",
                         self.property_,
-                        type(self.default),
-                        str(self.value_type.python),
-                    ).as_exception() from None
+                        f"Default value {self.default} is not of type {self.value_type.python}",
+                    ) from None
         return self
 
     @property
@@ -306,7 +305,7 @@ class InformationRules(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(