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

cognite/neat/rules/exporters/_base.py

@@ -5,7 +5,7 @@ from typing import Generic, TypeVar
 
 from cognite.client import CogniteClient
 
-from cognite.neat.rules._shared import Rules
+from cognite.neat.rules._shared import VerifiedRules
 from cognite.neat.rules.models import DMSRules, InformationRules, RoleTypes
 from cognite.neat.utils.auxiliary import class_html_doc
 from cognite.neat.utils.upload import UploadResult, UploadResultList
@@ -18,14 +18,14 @@ class BaseExporter(ABC, Generic[T_Export]):
     _encoding = "utf-8"
 
     @abstractmethod
-    def export_to_file(self, rules: Rules, filepath: Path) -> None:
+    def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def export(self, rules: Rules) -> T_Export:
+    def export(self, rules: VerifiedRules) -> T_Export:
         raise NotImplementedError
 
-    def _convert_to_output_role(self, rules: Rules, output_role: RoleTypes | None = None) -> Rules:
+    def _convert_to_output_role(self, rules: VerifiedRules, output_role: RoleTypes | None = None) -> VerifiedRules:
         if rules.metadata.role is output_role or output_role is None:
             return rules
         elif output_role is RoleTypes.dms and isinstance(rules, InformationRules):
@@ -43,9 +43,9 @@ class BaseExporter(ABC, Generic[T_Export]):
 class CDFExporter(BaseExporter[T_Export]):
     @abstractmethod
     def export_to_cdf_iterable(
-        self, rules: Rules, client: CogniteClient, dry_run: bool = False
+        self, rules: VerifiedRules, client: CogniteClient, dry_run: bool = False
     ) -> Iterable[UploadResult]:
         raise NotImplementedError
 
-    def export_to_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> UploadResultList:
+    def export_to_cdf(self, rules: VerifiedRules, client: CogniteClient, dry_run: bool = False) -> UploadResultList:
         return UploadResultList(self.export_to_cdf_iterable(rules, client, dry_run))

cognite/neat/rules/exporters/_rules2dms.py

@@ -16,9 +16,11 @@ from cognite.client.data_classes.data_modeling import (
 from cognite.client.exceptions import CogniteAPIError
 
 from cognite.neat.issues import IssueList
-from cognite.neat.issues.neat_warnings.resources import FailedLoadingResourcesWarning
-from cognite.neat.rules import issues
-from cognite.neat.rules._shared import Rules
+from cognite.neat.issues.warnings import (
+    PrincipleOneModelOneSpaceWarning,
+    ResourceRetrievalWarning,
+)
+from cognite.neat.rules._shared import VerifiedRules
 from cognite.neat.rules.models import InformationRules
 from cognite.neat.rules.models.dms import DMSRules, DMSSchema, PipelineSchema
 from cognite.neat.utils.cdf.loaders import (
@@ -80,7 +82,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
         self.suppress_warnings = suppress_warnings
         self._schema: DMSSchema | None = None
 
-    def export_to_file(self, rules: Rules, filepath: Path) -> None:
+    def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
         """Export the rules to a file(s).
 
         If the file is a directory, the components will be exported to separate files, otherwise they will be
@@ -95,12 +97,12 @@ class DMSExporter(CDFExporter[DMSSchema]):
         else:
             self._export_to_zip_file(filepath, rules)
 
-    def _export_to_directory(self, directory: Path, rules: Rules) -> None:
+    def _export_to_directory(self, directory: Path, rules: VerifiedRules) -> None:
         schema = self.export(rules)
         exclude = self._create_exclude_set()
         schema.to_directory(directory, exclude=exclude, new_line=self._new_line, encoding=self._encoding)
 
-    def _export_to_zip_file(self, filepath: Path, rules: Rules) -> None:
+    def _export_to_zip_file(self, filepath: Path, rules: VerifiedRules) -> None:
         if filepath.suffix not in {".zip"}:
             warnings.warn("File extension is not .zip, adding it to the file name", stacklevel=2)
             filepath = filepath.with_suffix(".zip")
@@ -115,7 +117,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
             exclude = {"spaces", "data_models", "views", "containers", "node_types"} - self.export_components
         return exclude
 
-    def export(self, rules: Rules) -> DMSSchema:
+    def export(self, rules: VerifiedRules) -> DMSSchema:
         if isinstance(rules, DMSRules):
             dms_rules = rules
         elif isinstance(rules, InformationRules):
@@ -124,7 +126,9 @@ class DMSExporter(CDFExporter[DMSSchema]):
             raise ValueError(f"{type(rules).__name__} cannot be exported to DMS")
         return dms_rules.as_schema(include_pipeline=self.export_pipeline, instance_space=self.instance_space)
 
-    def delete_from_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadResult]:
+    def delete_from_cdf(
+        self, rules: VerifiedRules, client: CogniteClient, dry_run: bool = False
+    ) -> Iterable[UploadResult]:
         to_export = self._prepare_exporters(rules, client)
 
         # we need to reverse order in which we are picking up the items to delete
@@ -168,7 +172,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
             )
 
     def export_to_cdf_iterable(
-        self, rules: Rules, client: CogniteClient, dry_run: bool = False
+        self, rules: VerifiedRules, client: CogniteClient, dry_run: bool = False
     ) -> Iterable[UploadResult]:
         to_export = self._prepare_exporters(rules, client)
 
@@ -298,7 +302,10 @@ class DMSExporter(CDFExporter[DMSSchema]):
         if isinstance(loader, DataModelLoader):
             models = cast(list[DataModelApply], items)
             if other_models := self._exist_other_data_models(loader, models):
-                warning = issues.dms.OtherDataModelsInSpaceWarning(models[0].space, other_models)
+                warning = PrincipleOneModelOneSpaceWarning(
+                    f"There are multiple data models in the same space {models[0].space}. "
+                    f"Other data models in the space are {other_models}.",
+                )
                 if not self.suppress_warnings:
                     warnings.warn(warning, stacklevel=2)
                 issue_list.append(warning)
@@ -314,7 +321,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
         try:
             data_models = loader.client.data_modeling.data_models.list(space=space, limit=25, all_versions=False)
         except CogniteAPIError as e:
-            warnings.warn(FailedLoadingResourcesWarning[str](frozenset({space}), "Space", str(e)), stacklevel=2)
+            warnings.warn(ResourceRetrievalWarning(frozenset({space}), "space", str(e)), stacklevel=2)
             return []
         else:
             return [

cognite/neat/rules/exporters/_rules2excel.py

@@ -12,7 +12,7 @@ from openpyxl.cell import MergedCell
 from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
 from openpyxl.worksheet.worksheet import Worksheet
 
-from cognite.neat.rules._shared import Rules
+from cognite.neat.rules._shared import VerifiedRules
 from cognite.neat.rules.models import (
     DataModelType,
     ExtensionCategory,
@@ -89,7 +89,7 @@ class ExcelExporter(BaseExporter[Workbook]):
         self.new_model_id = new_model_id
         self.dump_as = dump_as
 
-    def export_to_file(self, rules: Rules, filepath: Path) -> None:
+    def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
         """Exports transformation rules to excel file."""
         data = self.export(rules)
         try:
@@ -98,7 +98,7 @@ class ExcelExporter(BaseExporter[Workbook]):
             data.close()
         return None
 
-    def export(self, rules: Rules) -> Workbook:
+    def export(self, rules: VerifiedRules) -> Workbook:
         rules = self._convert_to_output_role(rules, self.output_role)
         workbook = Workbook()
         # Remove default sheet named "Sheet"
@@ -147,7 +147,7 @@ class ExcelExporter(BaseExporter[Workbook]):
         self,
         workbook: Workbook,
         dumped_rules: dict[str, Any],
-        rules: Rules,
+        rules: VerifiedRules,
         sheet_prefix: str = "",
     ):
         for sheet_name, headers in rules.headers_by_sheet(by_alias=True).items():

cognite/neat/rules/exporters/_rules2ontology.py

@@ -9,19 +9,12 @@ 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.analysis import InformationAnalysis
-from cognite.neat.rules.issues.ontology import (
-    MetadataSheetNamespaceNotDefinedError,
-    MissingDataModelPrefixOrNamespaceWarning,
-    OntologyMultiDefinitionPropertyWarning,
-    OntologyMultiDomainPropertyWarning,
-    OntologyMultiLabeledPropertyWarning,
-    OntologyMultiRangePropertyWarning,
-    OntologyMultiTypePropertyWarning,
-    PrefixMissingError,
-    PropertiesDefinedMultipleTimesError,
-    PropertyDefinitionsNotForSamePropertyError,
+from cognite.neat.issues import MultiValueError
+from cognite.neat.issues.errors import (
+    PropertyDefinitionDuplicatedError,
 )
+from cognite.neat.issues.warnings import PropertyDefinitionDuplicatedWarning
+from cognite.neat.rules.analysis import InformationAnalysis
 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
@@ -31,43 +24,42 @@ from cognite.neat.rules.models.information import (
     InformationProperty,
     InformationRules,
 )
-from cognite.neat.utils.auxiliary import generate_exception_report
 from cognite.neat.utils.rdf_ import remove_namespace_from_uri
 
 from ._base import BaseExporter
-from ._validation import are_properties_redefined
+from ._validation import duplicated_properties
 
 if sys.version_info >= (3, 11):
     from typing import Self
 else:
     from typing_extensions import Self
 
-from cognite.neat.rules._shared import Rules
+from cognite.neat.rules._shared import VerifiedRules
 
 
 class GraphExporter(BaseExporter[Graph], ABC):
-    def export_to_file(self, rules: Rules, filepath: Path) -> None:
+    def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
         self.export(rules).serialize(destination=filepath, encoding=self._encoding, newline=self._new_line)
 
 
 class OWLExporter(GraphExporter):
     """Exports rules to an OWL ontology."""
 
-    def export(self, rules: Rules) -> Graph:
+    def export(self, rules: VerifiedRules) -> Graph:
         return Ontology.from_rules(rules).as_owl()
 
 
 class SHACLExporter(GraphExporter):
     """Exports rules to a SHACL graph."""
 
-    def export(self, rules: Rules) -> Graph:
+    def export(self, rules: VerifiedRules) -> Graph:
         return Ontology.from_rules(rules).as_shacl()
 
 
 class SemanticDataModelExporter(GraphExporter):
     """Exports rules to a semantic data model."""
 
-    def export(self, rules: Rules) -> Graph:
+    def export(self, rules: VerifiedRules) -> Graph:
         return Ontology.from_rules(rules).as_semantic_data_model()
 
 
@@ -94,7 +86,7 @@ class Ontology(OntologyModel):
     prefixes: dict[str, Namespace]
 
     @classmethod
-    def from_rules(cls, input_rules: Rules) -> Self:
+    def from_rules(cls, input_rules: VerifiedRules) -> Self:
         """
         Generates an ontology from a set of transformation rules.
 
@@ -111,17 +103,20 @@ class Ontology(OntologyModel):
         else:
             raise ValueError(f"{type(input_rules).__name__} cannot be exported to Ontology")
 
-        properties_redefined, redefinition_warnings = are_properties_redefined(rules, return_report=True)
-        if properties_redefined:
-            raise PropertiesDefinedMultipleTimesError(
-                report=generate_exception_report(redefinition_warnings)
-            ).as_exception()
-
-        if rules.prefixes is None:
-            raise PrefixMissingError().as_exception()
-
-        if rules.metadata.namespace is None:
-            raise MissingDataModelPrefixOrNamespaceWarning()
+        if duplicates := duplicated_properties(rules.properties):
+            errors = []
+            for (class_, property_), definitions in duplicates.items():
+                errors.append(
+                    PropertyDefinitionDuplicatedError(
+                        class_,
+                        "class",
+                        property_,
+                        frozenset({str(definition[1].value_type) for definition in definitions}),
+                        tuple(definition[0] for definition in definitions),
+                        "rows",
+                    )
+                )
+            raise MultiValueError(errors)
 
         class_dict = InformationAnalysis(rules).as_class_dict()
         return cls(
@@ -184,9 +179,6 @@ class Ontology(OntologyModel):
         for prefix, namespace in self.prefixes.items():
             owl.bind(prefix, namespace)
 
-        if self.metadata.namespace is None:
-            raise MetadataSheetNamespaceNotDefinedError().as_exception()
-
         owl.add((URIRef(self.metadata.namespace), RDF.type, OWL.Ontology))
         for property_ in self.properties:
             for triple in property_.triples:
@@ -233,8 +225,6 @@ class OWLMetadata(InformationMetadata):
     @property
     def triples(self) -> list[tuple]:
         # Mandatory triples originating from Metadata mandatory fields
-        if self.namespace is None:
-            raise MetadataSheetNamespaceNotDefinedError().as_exception()
         triples: list[tuple] = [
             (URIRef(self.namespace), DCTERMS.hasVersion, Literal(self.version)),
             (URIRef(self.namespace), OWL.versionInfo, Literal(self.version)),
@@ -323,16 +313,17 @@ class OWLProperty(OntologyModel):
     range_: set[URIRef]
     namespace: Namespace
 
-    @staticmethod
-    def same_property_id(definitions: list[InformationProperty]) -> bool:
-        return len({definition.property_ for definition in definitions}) == 1
-
     @classmethod
     def from_list_of_properties(cls, definitions: list[InformationProperty], namespace: Namespace) -> "OWLProperty":
         """Here list of properties is a list of properties with the same id, but different definitions."""
-
-        if not cls.same_property_id(definitions):
-            raise PropertyDefinitionsNotForSamePropertyError().as_exception()
+        property_ids = {definition.property_ for definition in definitions}
+        if len(property_ids) != 1:
+            raise PropertyDefinitionDuplicatedError(
+                definitions[0].class_,
+                "class",
+                definitions[0].property_,
+                frozenset(property_ids),
+            )
 
         owl_property = cls.model_construct(
             id_=namespace[definitions[0].property_],
@@ -363,8 +354,15 @@ class OWLProperty(OntologyModel):
     def is_multi_type(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                OntologyMultiTypePropertyWarning(
-                    remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
+                PropertyDefinitionDuplicatedWarning(
+                    remove_namespace_from_uri(info.data["id"]),
+                    "class",
+                    "type",
+                    frozenset({remove_namespace_from_uri(t) for t in v}),
+                    "This warning occurs when a same property is define for two object/classes where"
+                    " its expected value type is different in one definition, e.g. acts as an edge, while in "
+                    "other definition acts as and attribute",
+                    "If a property takes different value types for different objects, simply define new property",
                 ),
                 stacklevel=2,
             )
@@ -374,8 +372,14 @@ class OWLProperty(OntologyModel):
     def is_multi_range(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                OntologyMultiRangePropertyWarning(
-                    remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
+                PropertyDefinitionDuplicatedWarning(
+                    remove_namespace_from_uri(info.data["id_"]),
+                    "class",
+                    "range",
+                    frozenset({remove_namespace_from_uri(t) for t in v}),
+                    "This warning occurs when a property takes range of "
+                    "values which consists of union of multiple value types.",
+                    "If value types for different objects, simply define new property",
                 ),
                 stacklevel=2,
             )
@@ -385,8 +389,15 @@ class OWLProperty(OntologyModel):
     def is_multi_domain(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                OntologyMultiDomainPropertyWarning(
-                    remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
+                PropertyDefinitionDuplicatedWarning(
+                    remove_namespace_from_uri(info.data["id_"]),
+                    "class",
+                    "domain",
+                    frozenset({remove_namespace_from_uri(t) for t in v}),
+                    "This warning occurs when a same property is define for two object/classes where"
+                    " its expected value type is different in one definition, e.g. acts as an edge, while in "
+                    "other definition acts as and attribute",
+                    "If value types for different objects, simply define new property",
                 ),
                 stacklevel=2,
             )
@@ -396,7 +407,13 @@ class OWLProperty(OntologyModel):
     def has_multi_name(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                OntologyMultiLabeledPropertyWarning(remove_namespace_from_uri(info.data["id_"]), v),
+                PropertyDefinitionDuplicatedWarning(
+                    remove_namespace_from_uri(info.data["id_"]),
+                    "class",
+                    "label",
+                    frozenset(v),
+                    f"Only the first label (name) will be used, {v[0]}",
+                ),
                 stacklevel=2,
             )
         return v
@@ -405,7 +422,13 @@ class OWLProperty(OntologyModel):
     def has_multi_comment(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                OntologyMultiDefinitionPropertyWarning(remove_namespace_from_uri(info.data["id_"])),
+                PropertyDefinitionDuplicatedWarning(
+                    remove_namespace_from_uri(info.data["id_"]),
+                    "class",
+                    "comment",
+                    frozenset(v),
+                    "All definitions will be concatenated to form a single definition.",
+                ),
                 stacklevel=2,
             )
         return v

cognite/neat/rules/exporters/_rules2yaml.py

@@ -5,7 +5,7 @@ from typing import Literal, get_args
 
 import yaml
 
-from cognite.neat.rules._shared import Rules
+from cognite.neat.rules._shared import VerifiedRules
 from cognite.neat.rules.models import RoleTypes
 
 from ._base import BaseExporter
@@ -47,7 +47,7 @@ class YAMLExporter(BaseExporter[str]):
         self.output = output
         self.output_role = output_role
 
-    def export_to_file(self, rules: Rules, filepath: Path) -> None:
+    def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
         """Exports transformation rules to YAML/JSON file(s)."""
         if self.files == "single":
             if filepath.suffix != f".{self.output}":
@@ -57,7 +57,7 @@ class YAMLExporter(BaseExporter[str]):
         else:
             raise NotImplementedError(f"Exporting to {self.files} files is not supported")
 
-    def export(self, rules: Rules) -> str:
+    def export(self, rules: VerifiedRules) -> str:
         """Export rules to YAML (or JSON) format.
 
         Args:

cognite/neat/rules/exporters/_validation.py

@@ -1,99 +1,14 @@
-import warnings
-from typing import Literal, overload
+from collections import defaultdict
+from collections.abc import Iterable
 
-from cognite.neat.exceptions import wrangle_warnings
-from cognite.neat.issues.neat_warnings.properties import PropertyRedefinedWarning
-from cognite.neat.rules.issues.dms import EntityIDNotDMSCompliantWarning
-from cognite.neat.rules.models import InformationRules
-from cognite.neat.utils.regex_patterns import DMS_PROPERTY_ID_COMPLIANCE_REGEX, PATTERNS, VIEW_ID_COMPLIANCE_REGEX
+from cognite.neat.rules.models.entities import ClassEntity
+from cognite.neat.rules.models.information import InformationProperty
 
 
-@overload
-def are_entity_names_dms_compliant(
-    rules: InformationRules, return_report: Literal[True]
-) -> tuple[bool, list[dict]]: ...
-
-
-@overload
-def are_entity_names_dms_compliant(rules: InformationRules, return_report: Literal[False] = False) -> bool: ...
-
-
-def are_entity_names_dms_compliant(
-    rules: InformationRules, return_report: bool = False
-) -> bool | tuple[bool, list[dict]]:
-    """Check if data model definitions are valid."""
-
-    flag: bool = True
-    with warnings.catch_warnings(record=True) as validation_warnings:
-        for class_ in rules.classes:
-            if not PATTERNS.view_id_compliance.match(class_.class_.suffix):
-                warnings.warn(
-                    EntityIDNotDMSCompliantWarning(class_.class_.versioned_id, "Class", VIEW_ID_COMPLIANCE_REGEX),
-                    stacklevel=2,
-                )
-                flag = False
-
-        for _, property_ in enumerate(rules.properties):
-            # check class id which would resolve as view/container id
-            if not PATTERNS.view_id_compliance.match(property_.class_.suffix):
-                warnings.warn(
-                    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 PATTERNS.dms_property_id_compliance.match(property_.property_):
-                warnings.warn(
-                    EntityIDNotDMSCompliantWarning(property_.property_, "Property", DMS_PROPERTY_ID_COMPLIANCE_REGEX),
-                    stacklevel=2,
-                )
-                flag = False
-
-    if return_report:
-        return flag, wrangle_warnings(validation_warnings)
-    else:
-        return flag
-
-
-@overload
-def are_properties_redefined(rules: InformationRules, return_report: Literal[True]) -> tuple[bool, list[dict]]: ...
-
-
-@overload
-def are_properties_redefined(rules: InformationRules, return_report: Literal[False] = False) -> bool: ...
-
-
-def are_properties_redefined(rules: InformationRules, return_report: bool = False) -> bool | tuple[bool, list[dict]]:
-    flag: bool = False
-    with warnings.catch_warnings(record=True) as validation_warnings:
-        analyzed_properties: dict[str, list[str]] = {}
-        for property_ in rules.properties:
-            if property_.property_ not in analyzed_properties:
-                analyzed_properties[property_.property_] = [property_.class_.versioned_id]
-            elif property_.class_ in analyzed_properties[property_.property_]:
-                flag = True
-                warnings.warn(
-                    PropertyRedefinedWarning[str](property_.class_.versioned_id, "Class", property_.property_),
-                    stacklevel=2,
-                )
-
-            else:
-                analyzed_properties[property_.property_].append(property_.class_.versioned_id)
-
-    if return_report:
-        return flag, wrangle_warnings(validation_warnings)
-    else:
-        return flag
-
-
-def property_ids_camel_case_compliant(rules) -> bool | tuple[bool, list[dict]]:
-    raise NotImplementedError()
-
-
-def class_id_pascal_case_compliant(rules) -> bool | tuple[bool, list[dict]]:
-    raise NotImplementedError()
+def duplicated_properties(
+    properties: Iterable[InformationProperty],
+) -> dict[tuple[ClassEntity, str], list[tuple[int, InformationProperty]]]:
+    class_properties_by_id: dict[tuple[ClassEntity, str], list[tuple[int, InformationProperty]]] = defaultdict(list)
+    for prop_no, prop in enumerate(properties):
+        class_properties_by_id[(prop.class_, prop.property_)].append((prop_no, prop))
+    return {k: v for k, v in class_properties_by_id.items() if len(v) > 1}

cognite/neat/rules/importers/_base.py

@@ -10,11 +10,7 @@ from pydantic import ValidationError
 from rdflib import Namespace
 
 from cognite.neat.issues import IssueList, NeatError, NeatWarning
-from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.issues.base import (
-    NeatValidationError,
-    ValidationWarning,
-)
+from cognite.neat.rules._shared import VerifiedRules
 from cognite.neat.rules.models import AssetRules, DMSRules, InformationRules, RoleTypes
 from cognite.neat.utils.auxiliary import class_html_doc
 
@@ -25,19 +21,19 @@ class BaseImporter(ABC):
     """
 
     @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]: ...
 
     @abstractmethod
     def to_rules(
         self,
         errors: Literal["raise", "continue"] = "continue",
         role: RoleTypes | None = None,
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         """
         Creates `Rules` object from the data for target role.
         """
@@ -46,11 +42,11 @@ class BaseImporter(ABC):
     @classmethod
     def _to_output(
         cls,
-        rules: Rules,
+        rules: VerifiedRules,
         issues: IssueList,
         errors: Literal["raise", "continue"] = "continue",
         role: RoleTypes | None = None,
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         """Converts the rules to the output format."""
 
         if rules.metadata.role is role or role is None:
@@ -103,8 +99,8 @@ class _FutureResult:
 @contextmanager
 def _handle_issues(
     issues: IssueList,
-    error_cls: type[NeatError] = NeatValidationError,
-    warning_cls: type[NeatWarning] = ValidationWarning,
+    error_cls: type[NeatError] = NeatError,
+    warning_cls: type[NeatWarning] = NeatWarning,
     error_args: dict[str, Any] | None = None,
 ) -> Iterator[_FutureResult]:
     """This is an internal help function to handle issues and warnings.