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

cognite/neat/graph/queries/_shared.py

@@ -160,7 +160,7 @@ def triples2dictionary(triples: Iterable[tuple[URIRef, URIRef, str | URIRef]]) -
         value: str
         uri: URIRef
 
-        id_, property_, value = remove_namespace_from_uri(*triple)  # type: ignore[misc]
+        id_, property_, value = remove_namespace_from_uri(triple)  # type: ignore[misc]
         uri = triple[0]
 
         if uri not in dictionary:

cognite/neat/graph/stores/_base.py

@@ -66,6 +66,11 @@ class NeatGraphStore:
 
         self.queries = Queries(self.graph, self.rules)
 
+    @property
+    def type_(self) -> str:
+        "Return type of the graph store"
+        return type(self.graph.store).__name__
+
     def add_rules(self, rules: InformationRules) -> None:
         """This method is used to add rules to the graph store and it is the only correct
         way to add rules to the graph store, after the graph store has been initialized.
@@ -103,7 +108,7 @@ class NeatGraphStore:
 
     @classmethod
     def from_memory_store(cls, rules: InformationRules | None = None) -> "Self":
-        return cls(Graph(), rules)
+        return cls(Graph(identifier=DEFAULT_NAMESPACE), rules)
 
     @classmethod
     def from_sparql_store(
@@ -121,17 +126,17 @@ class NeatGraphStore:
             postAsEncoded=False,
             autocommit=False,
         )
-        graph = Graph(store=store)
+        graph = Graph(store=store, identifier=DEFAULT_NAMESPACE)
         return cls(graph, rules)
 
     @classmethod
     def from_oxi_store(cls, storage_dir: Path | None = None, rules: InformationRules | None = None) -> "Self":
         """Creates a NeatGraphStore from an Oxigraph store."""
         local_import("pyoxigraph", "oxi")
+        local_import("oxrdflib", "oxi")
+        import oxrdflib
         import pyoxigraph
 
-        from cognite.neat.graph.stores._oxrdflib import OxigraphStore
-
         # Adding support for both oxigraph in-memory and file-based storage
         for i in range(4):
             try:
@@ -144,8 +149,10 @@ class NeatGraphStore:
         else:
             raise Exception("Error initializing Oxigraph store")
 
-        graph = Graph(store=OxigraphStore(store=oxi_store))
-        graph.default_union = True
+        graph = Graph(
+            store=oxrdflib.OxigraphStore(store=oxi_store),
+            identifier=DEFAULT_NAMESPACE,
+        )
 
         return cls(graph, rules)
 
@@ -203,7 +210,8 @@ class NeatGraphStore:
         property_renaming_config = InformationAnalysis(self.rules).define_property_renaming_config(class_entity)
 
         for instance_id in instance_ids:
-            yield self.queries.describe(instance_id, property_renaming_config)
+            if res := self.queries.describe(instance_id, property_renaming_config):
+                yield res
 
     def _parse_file(
         self,
@@ -216,7 +224,7 @@ class NeatGraphStore:
         Args:
             filepath : File path to file containing graph data, by default None
             mime_type : MIME type of graph data, by default "application/rdf+xml"
-            add_base_iri : Add base IRI to graph, by default True
+            base_uri : Add base IRI to graph, by default True
         """
 
         # Oxigraph store, do not want to type hint this as it is an optional dependency
@@ -224,10 +232,15 @@ class NeatGraphStore:
 
             def parse_to_oxi_store():
                 local_import("pyoxigraph", "oxi")
-                from cognite.neat.graph.stores._oxrdflib import OxigraphStore
+                import pyoxigraph
 
-                cast(OxigraphStore, self.graph.store)._inner.bulk_load(str(filepath), mime_type, base_iri=base_uri)  # type: ignore[attr-defined]
-                cast(OxigraphStore, self.graph.store)._inner.optimize()  # type: ignore[attr-defined]
+                cast(pyoxigraph.Store, self.graph.store._store).bulk_load(
+                    str(filepath),
+                    mime_type,
+                    base_iri=base_uri,
+                    to_graph=pyoxigraph.NamedNode(self.graph.identifier),
+                )
+                cast(pyoxigraph.Store, self.graph.store._store).optimize()
 
             parse_to_oxi_store()
 

cognite/neat/graph/transformers/_rdfpath.py

@@ -1,4 +1,4 @@
-from rdflib import RDF, Graph
+from rdflib import Graph
 
 from cognite.neat.rules.analysis import InformationAnalysis
 from cognite.neat.rules.models._rdfpath import RDFPath, SingleProperty
@@ -17,6 +17,7 @@ class AddSelfReferenceProperty(BaseTransformer):
     description: str = "Adds property that contains id of reference to all references of given class in Rules"
     _use_only_once: bool = True
     _need_changes = frozenset({})
+    _ref_template: str = """SELECT ?s WHERE {{?s a <{type_}>}}"""
 
     def __init__(
         self,
@@ -32,7 +33,7 @@ class AddSelfReferenceProperty(BaseTransformer):
 
             namespace = self.rules.prefixes[prefix] if prefix in self.rules.prefixes else self.rules.metadata.namespace
 
-            for reference in graph.subjects(RDF.type, namespace[suffix]):
+            for (reference,) in graph.query(self._ref_template.format(type_=namespace[suffix])):  # type: ignore [misc]
                 graph.add(
                     (
                         reference,

cognite/neat/issues.py

@@ -9,6 +9,7 @@ from typing import Any, ClassVar, TypeVar
 from warnings import WarningMessage
 
 import pandas as pd
+from pydantic_core import PydanticCustomError
 
 if sys.version_info < (3, 11):
     from exceptiongroup import ExceptionGroup
@@ -56,6 +57,13 @@ class NeatError(NeatIssue, ABC):
     def as_exception(self) -> ValueError:
         return ValueError(self.message())
 
+    def as_pydantic_exception(self) -> PydanticCustomError:
+        return PydanticCustomError(
+            self.__class__.__name__,
+            self.message(),
+            dict(description=self.description, fix=self.fix),
+        )
+
 
 @dataclass(frozen=True)
 class NeatWarning(NeatIssue, ABC, UserWarning):

cognite/neat/rules/exporters/_rules2ontology.py

@@ -9,8 +9,19 @@ from rdflib import DCTERMS, OWL, RDF, RDFS, XSD, BNode, Graph, Literal, Namespac
 from rdflib.collection import Collection as GraphCollection
 
 from cognite.neat.constants import DEFAULT_NAMESPACE as NEAT_NAMESPACE
-from cognite.neat.rules import exceptions
 from cognite.neat.rules.analysis import InformationAnalysis
+from cognite.neat.rules.issues.ontology import (
+    MetadataSheetNamespaceNotDefinedError,
+    MissingDataModelPrefixOrNamespaceWarning,
+    OntologyMultiDefinitionPropertyWarning,
+    OntologyMultiDomainPropertyWarning,
+    OntologyMultiLabeledPropertyWarning,
+    OntologyMultiRangePropertyWarning,
+    OntologyMultiTypePropertyWarning,
+    PrefixMissingError,
+    PropertiesDefinedMultipleTimesError,
+    PropertyDefinitionsNotForSamePropertyError,
+)
 from cognite.neat.rules.models import DMSRules
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
@@ -102,13 +113,15 @@ class Ontology(OntologyModel):
 
         properties_redefined, redefinition_warnings = are_properties_redefined(rules, return_report=True)
         if properties_redefined:
-            raise exceptions.PropertiesDefinedMultipleTimes(report=generate_exception_report(redefinition_warnings))
+            raise PropertiesDefinedMultipleTimesError(
+                report=generate_exception_report(redefinition_warnings)
+            ).as_exception()
 
         if rules.prefixes is None:
-            raise exceptions.PrefixMissing()
+            raise PrefixMissingError().as_exception()
 
         if rules.metadata.namespace is None:
-            raise exceptions.MissingDataModelPrefixOrNamespace()
+            raise MissingDataModelPrefixOrNamespaceWarning()
 
         class_dict = InformationAnalysis(rules).as_class_dict()
         return cls(
@@ -172,7 +185,7 @@ class Ontology(OntologyModel):
             owl.bind(prefix, namespace)
 
         if self.metadata.namespace is None:
-            raise exceptions.MetadataSheetNamespaceNotDefined()
+            raise MetadataSheetNamespaceNotDefinedError().as_exception()
 
         owl.add((URIRef(self.metadata.namespace), RDF.type, OWL.Ontology))
         for property_ in self.properties:
@@ -221,7 +234,7 @@ class OWLMetadata(InformationMetadata):
     def triples(self) -> list[tuple]:
         # Mandatory triples originating from Metadata mandatory fields
         if self.namespace is None:
-            raise exceptions.MetadataSheetNamespaceNotDefined()
+            raise MetadataSheetNamespaceNotDefinedError().as_exception()
         triples: list[tuple] = [
             (URIRef(self.namespace), DCTERMS.hasVersion, Literal(self.version)),
             (URIRef(self.namespace), OWL.versionInfo, Literal(self.version)),
@@ -319,7 +332,7 @@ class OWLProperty(OntologyModel):
         """Here list of properties is a list of properties with the same id, but different definitions."""
 
         if not cls.same_property_id(definitions):
-            raise exceptions.PropertyDefinitionsNotForSameProperty()
+            raise PropertyDefinitionsNotForSamePropertyError().as_exception()
 
         owl_property = cls.model_construct(
             id_=namespace[definitions[0].property_],
@@ -350,10 +363,9 @@ class OWLProperty(OntologyModel):
     def is_multi_type(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiTypeProperty(
+                OntologyMultiTypePropertyWarning(
                     remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
-                ).message,
-                category=exceptions.OntologyMultiTypeProperty,
+                ),
                 stacklevel=2,
             )
         return v
@@ -362,10 +374,9 @@ class OWLProperty(OntologyModel):
     def is_multi_range(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiRangeProperty(
+                OntologyMultiRangePropertyWarning(
                     remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
-                ).message,
-                category=exceptions.OntologyMultiRangeProperty,
+                ),
                 stacklevel=2,
             )
         return v
@@ -374,10 +385,9 @@ class OWLProperty(OntologyModel):
     def is_multi_domain(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiDomainProperty(
+                OntologyMultiDomainPropertyWarning(
                     remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
-                ).message,
-                category=exceptions.OntologyMultiDomainProperty,
+                ),
                 stacklevel=2,
             )
         return v
@@ -386,8 +396,7 @@ class OWLProperty(OntologyModel):
     def has_multi_name(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiLabeledProperty(remove_namespace_from_uri(info.data["id_"]), v).message,
-                category=exceptions.OntologyMultiLabeledProperty,
+                OntologyMultiLabeledPropertyWarning(remove_namespace_from_uri(info.data["id_"]), v),
                 stacklevel=2,
             )
         return v
@@ -396,8 +405,7 @@ class OWLProperty(OntologyModel):
     def has_multi_comment(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiDefinitionProperty(remove_namespace_from_uri(info.data["id_"])).message,
-                category=exceptions.OntologyMultiDefinitionProperty,
+                OntologyMultiDefinitionPropertyWarning(remove_namespace_from_uri(info.data["id_"])),
                 stacklevel=2,
             )
         return v

cognite/neat/rules/exporters/_validation.py

@@ -1,11 +1,11 @@
-import re
 import warnings
 from typing import Literal, overload
 
 from cognite.neat.exceptions import wrangle_warnings
-from cognite.neat.rules import exceptions
+from cognite.neat.rules.issues.dms import EntityIDNotDMSCompliantWarning
+from cognite.neat.rules.issues.importing import PropertyRedefinedWarning
 from cognite.neat.rules.models import InformationRules
-from cognite.neat.rules.models._types._base import DMS_PROPERTY_ID_COMPLIANCE_REGEX, VIEW_ID_COMPLIANCE_REGEX
+from cognite.neat.utils.regex_patterns import DMS_PROPERTY_ID_COMPLIANCE_REGEX, PATTERNS, VIEW_ID_COMPLIANCE_REGEX
 
 
 @overload
@@ -26,35 +26,30 @@ def are_entity_names_dms_compliant(
     flag: bool = True
     with warnings.catch_warnings(record=True) as validation_warnings:
         for class_ in rules.classes:
-            if not re.match(VIEW_ID_COMPLIANCE_REGEX, str(class_.class_.suffix)):
+            if not PATTERNS.view_id_compliance.match(class_.class_.suffix):
                 warnings.warn(
-                    exceptions.EntityIDNotDMSCompliant(
-                        "Class", class_.class_.versioned_id, f"[Classes/Class/{class_.class_.versioned_id}]"
-                    ).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    EntityIDNotDMSCompliantWarning(class_.class_.versioned_id, "Class", VIEW_ID_COMPLIANCE_REGEX),
                     stacklevel=2,
                 )
                 flag = False
 
-        for row, property_ in enumerate(rules.properties):
+        for _, property_ in enumerate(rules.properties):
             # check class id which would resolve as view/container id
-            if not re.match(VIEW_ID_COMPLIANCE_REGEX, str(property_.class_.suffix)):
+            if not PATTERNS.view_id_compliance.match(property_.class_.suffix):
                 warnings.warn(
-                    exceptions.EntityIDNotDMSCompliant(
-                        "Class", property_.class_.versioned_id, f"[Properties/Class/{row}]"
-                    ).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    EntityIDNotDMSCompliantWarning(
+                        property_.class_.versioned_id,
+                        "Class",
+                        VIEW_ID_COMPLIANCE_REGEX,
+                    ),
                     stacklevel=2,
                 )
                 flag = False
 
             # check property id which would resolve as view/container id
-            if not re.match(DMS_PROPERTY_ID_COMPLIANCE_REGEX, property_.property_):
+            if not PATTERNS.dms_property_id_compliance.match(property_.property_):
                 warnings.warn(
-                    exceptions.EntityIDNotDMSCompliant(
-                        "Property", property_.property_, f"[Properties/Property/{row}]"
-                    ).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    EntityIDNotDMSCompliantWarning(property_.property_, "Property", DMS_PROPERTY_ID_COMPLIANCE_REGEX),
                     stacklevel=2,
                 )
                 flag = False
@@ -83,8 +78,7 @@ def are_properties_redefined(rules: InformationRules, return_report: bool = Fals
             elif property_.class_ in analyzed_properties[property_.property_]:
                 flag = True
                 warnings.warn(
-                    exceptions.PropertyRedefined(property_.property_, property_.class_.versioned_id).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    PropertyRedefinedWarning(property_.property_, property_.class_.versioned_id),
                     stacklevel=2,
                 )
 

cognite/neat/rules/importers/_inference2rules.py

@@ -1,4 +1,4 @@
-import re
+from collections import Counter, defaultdict
 from datetime import datetime
 from pathlib import Path
 from typing import Literal, cast, overload
@@ -201,6 +201,7 @@ class InferenceImporter(BaseImporter):
         classes: dict[str, dict] = {}
         properties: dict[str, dict] = {}
         prefixes: dict[str, Namespace] = get_default_prefixes()
+        count_by_value_type_by_property: dict[str, dict[str, int]] = defaultdict(Counter)
 
         query = INSTANCE_PROPERTIES_JSON_DEFINITION if self.check_for_json_string else INSTANCE_PROPERTIES_DEFINITION
         # Adds default namespace to prefixes
@@ -255,12 +256,10 @@ class InferenceImporter(BaseImporter):
                             f"{uri_to_short_form(class_definition['reference'], prefixes)}"
                             f"({uri_to_short_form(cast(URIRef, property_uri), prefixes)})"
                         ),
-                        "comment": (
-                            f"Class <{class_id}> has property <{property_id}> with "
-                            f"value type <{value_type_id}> which occurs <1> times in the graph"
-                        ),
                     }
 
+                    count_by_value_type_by_property[id_][value_type_id] += 1
+
                     # USE CASE 1: If property is not present in properties
                     if id_ not in properties:
                         properties[id_] = definition
@@ -268,27 +267,41 @@ class InferenceImporter(BaseImporter):
                     # USE CASE 2: first time redefinition, value type change to multi
                     elif id_ in properties and definition["value_type"] not in properties[id_]["value_type"]:
                         properties[id_]["value_type"] = properties[id_]["value_type"] + " | " + definition["value_type"]
-                        properties[id_]["comment"] = (
-                            properties[id_]["comment"] + ", with" + definition["comment"].split("with")[1]
-                        )
 
                     # USE CASE 3: existing but max count is different
                     elif (
                         id_ in properties
                         and definition["value_type"] in properties[id_]["value_type"]
-                        and not (properties[id_]["max_count"] == definition["max_count"])
+                        and properties[id_]["max_count"] != definition["max_count"]
                     ):
                         properties[id_]["max_count"] = max(properties[id_]["max_count"], definition["max_count"])
 
-                        properties[id_]["comment"] = self._update_value_type_occurrence_in_comment(
-                            definition["value_type"], properties[id_]["comment"]
-                        )
-
-                    # USE CASE 4: Just update the comment with occurrence
-                    else:
-                        properties[id_]["comment"] = self._update_value_type_occurrence_in_comment(
-                            definition["value_type"], properties[id_]["comment"]
-                        )
+        # Add comments
+        for id_, property_ in properties.items():
+            if id_ not in count_by_value_type_by_property:
+                continue
+
+            count_by_value_type = count_by_value_type_by_property[id_]
+            count_list = sorted(count_by_value_type.items(), key=lambda item: item[1], reverse=True)
+            # Make the comment more readable by adapting to the number of value types
+            base_string = "<{value_type}> which occurs <{count}> times"
+            if len(count_list) == 1:
+                type_, count = count_list[0]
+                counts_str = f"with value type {base_string.format(value_type=type_, count=count)} in the graph"
+            elif len(count_list) == 1:
+                first = base_string.format(value_type=count_list[0][0], count=count_list[0][1])
+                second = base_string.format(value_type=count_list[1][0], count=count_list[1][1])
+                counts_str = f"with value types {first} and {second} in the graph"
+            else:
+                first_part = ", ".join(
+                    base_string.format(value_type=type_, count=count) for type_, count in count_list[:-1]
+                )
+                last = base_string.format(value_type=count_list[-1][0], count=count_list[-1][1])
+                counts_str = f"with value types {first_part} and {last} in the graph"
+
+            class_id = property_["class_"]
+            property_id = property_["property_"]
+            property_["comment"] = f"Class <{class_id}> has property <{property_id}> {counts_str}"
 
         return {
             "metadata": self._default_metadata().model_dump(),
@@ -319,20 +332,3 @@ class InferenceImporter(BaseImporter):
             prefix=self.prefix,
             namespace=DEFAULT_NAMESPACE,
         )
-
-    @classmethod
-    def _update_value_type_occurrence_in_comment(cls, value_type: str, comment: str) -> str:
-        occurrence = cls._read_value_type_occurrence_from_comment(value_type, comment)
-        return comment.replace(
-            f"with value type <{value_type}> which occurs <{occurrence}> times in the graph",
-            f"with value type <{value_type}> which occurs <{occurrence+1}> times in the graph",
-        )
-
-    @classmethod
-    def _read_value_type_occurrence_from_comment(cls, value_type: str, comment: str) -> int:
-        if result := re.search(
-            rf"with value type <{value_type}> which occurs <(\d+)> times in the graph",
-            comment,
-        ):
-            return int(result.group(1))
-        return 0

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

@@ -1,16 +1,12 @@
 import datetime
-import re
 
 from rdflib import Graph, Namespace
 
 from cognite.neat.constants import DEFAULT_NAMESPACE
 from cognite.neat.rules.models import RoleTypes, SchemaCompleteness
-from cognite.neat.rules.models._types._base import (
-    PREFIX_COMPLIANCE_REGEX,
-    VERSION_COMPLIANCE_REGEX,
-)
 from cognite.neat.utils.collection_ import remove_none_elements_from_set
 from cognite.neat.utils.rdf_ import convert_rdflib_content
+from cognite.neat.utils.regex_patterns import PATTERNS
 
 
 def parse_owl_metadata(graph: Graph) -> dict:
@@ -144,7 +140,7 @@ def fix_description(metadata: dict, default: str = "This model has been inferred
 
 def fix_prefix(metadata: dict, default: str = "neat") -> dict:
     if prefix := metadata.get("prefix", None):
-        if not isinstance(prefix, str) or not re.match(PREFIX_COMPLIANCE_REGEX, prefix):
+        if not isinstance(prefix, str) or not PATTERNS.prefix_compliance.match(prefix):
             metadata["prefix"] = default
     else:
         metadata["prefix"] = default
@@ -189,7 +185,7 @@ def fix_date(
 
 def fix_version(metadata: dict, default: str = "1.0.0") -> dict:
     if version := metadata.get("version", None):
-        if not re.match(VERSION_COMPLIANCE_REGEX, version):
+        if not PATTERNS.version_compliance.match(version):
             metadata["version"] = default
     else:
         metadata["version"] = default

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -131,25 +131,24 @@ class SpreadsheetReader:
         names = MANDATORY_SHEETS_BY_ROLE[role]
         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:
-            self._seen_files.add(filepath)
-            self._seen_sheets.update(map(str, 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:
+    def read(self, excel_file: pd.ExcelFile, filepath: Path) -> None | ReadResult:
+        self._seen_files.add(filepath)
+        self._seen_sheets.update(map(str, 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["Metadata"] = dict(metadata)
 
-            return ReadResult(sheets, read_info_by_sheet, metadata)
+        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:
@@ -232,17 +231,21 @@ class ExcelImporter(BaseImporter):
             issue_list.append(issues.spreadsheet_file.SpreadsheetNotFoundError(self.filepath))
             return self._return_or_raise(issue_list, errors)
 
-        user_reader = SpreadsheetReader(issue_list)
-        user_read = user_reader.read(self.filepath)
-        if user_read is None or issue_list.has_errors:
-            return self._return_or_raise(issue_list, errors)
+        with pd.ExcelFile(self.filepath) as excel_file:
+            user_reader = SpreadsheetReader(issue_list)
 
-        last_read: ReadResult | None = None
-        if any(sheet_name.startswith("Last") for sheet_name in user_reader.seen_sheets):
-            last_read = SpreadsheetReader(issue_list, required=False, sheet_prefix="Last").read(self.filepath)
-        reference_read: ReadResult | None = None
-        if any(sheet_name.startswith("Ref") for sheet_name in user_reader.seen_sheets):
-            reference_read = SpreadsheetReader(issue_list, sheet_prefix="Ref").read(self.filepath)
+            user_read = user_reader.read(excel_file, self.filepath)
+            if user_read is None or issue_list.has_errors:
+                return self._return_or_raise(issue_list, errors)
+
+            last_read: ReadResult | None = None
+            if any(sheet_name.startswith("Last") for sheet_name in user_reader.seen_sheets):
+                last_read = SpreadsheetReader(issue_list, required=False, sheet_prefix="Last").read(
+                    excel_file, self.filepath
+                )
+            reference_read: ReadResult | None = None
+            if any(sheet_name.startswith("Ref") for sheet_name in user_reader.seen_sheets):
+                reference_read = SpreadsheetReader(issue_list, sheet_prefix="Ref").read(excel_file, self.filepath)
 
         if issue_list.has_errors:
             return self._return_or_raise(issue_list, errors)

cognite/neat/rules/issues/dms.py

@@ -432,6 +432,26 @@ class ChangingViewError(DMSSchemaError):
         return output
 
 
+@dataclass(frozen=True)
+class EntityIDNotDMSCompliantWarning(DMSSchemaWarning):
+    description = "The entity ID, {entity_id} of type {entity_type}, is not DMS compliant. Violating regex {regex}"
+    fix = "Change the entity ID to be DMS compliant"
+    error_name: ClassVar[str] = "EntityIDNotDMSCompliantWarning"
+    entity_id: str
+    entity_type: str
+    regex: str
+
+    def message(self) -> str:
+        return self.description.format(entity_id=self.entity_id, entity_type=self.entity_type, regex=self.regex)
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["entity_id"] = self.entity_id
+        output["dms_type"] = self.entity_type
+        output["regex"] = self.regex
+        return output
+
+
 @dataclass(frozen=True)
 class EmptyContainerWarning(DMSSchemaWarning):
     description = "The container is empty"

cognite/neat/rules/issues/importing.py

@@ -126,6 +126,21 @@ class UnknownPropertyWarning(ValidationWarning):
         return f"{prefix} This will be ignored in the imports."
 
 
+@dataclass(frozen=True)
+class PropertyRedefinedWarning(ValidationWarning):
+    description = "Property, {property}, redefined in {class_}. This will be ignored in the imports."
+    fix = "Check if the property is defined only once."
+
+    property_id: str
+    class_id: str
+
+    def dump(self) -> dict[str, str]:
+        return {"property_id": self.property_id, "class_id": self.class_id}
+
+    def message(self) -> str:
+        return self.description.format(property=self.property_id, class_=self.class_id)
+
+
 @dataclass(frozen=True)
 class UnknownValueTypeWarning(ModelImportWarning):
     description = "Unknown value type. This limits validation done by NEAT. "