cognite-neat 0.88.1__tar.gz → 0.88.2__tar.gz

{cognite_neat-0.88.1 → cognite_neat-0.88.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.88.1
+Version: 0.88.2
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.88.2/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.88.2"

{cognite_neat-0.88.1 → cognite_neat-0.88.2}/cognite/neat/exceptions.py

@@ -121,12 +121,12 @@ def wrangle_warnings(list_of_warnings: list[WarningMessage]) -> list[dict]:
 def _neat_warning_to_dict(warning: WarningMessage) -> dict:
     category: Any = warning.category
     return {
-        "type": category.type_,
+        "type": category.resource_type,
         "loc": (),
         "msg": str(warning.message),
         "input": None,
         "ctx": dict(
-            type_=category.type_,
+            type_=category.resource_type,
             code=category.code,
             description=category.description,
             example=category.example,

{cognite_neat-0.88.1 → cognite_neat-0.88.2}/cognite/neat/graph/loaders/_base.py

@@ -7,8 +7,8 @@ from cognite.client import CogniteClient
 from cognite.client.data_classes.capabilities import Capability
 
 from cognite.neat.graph import NeatGraphStore
-from cognite.neat.graph.issues.loader import FailedAuthorizationError
-from cognite.neat.issues import NeatIssue, NeatIssueList
+from cognite.neat.issues import IssueList, NeatIssue, NeatIssueList
+from cognite.neat.issues.errors.external import FailedAuthorizationError
 from cognite.neat.utils.auxiliary import class_html_doc
 from cognite.neat.utils.upload import UploadResult, UploadResultList
 
@@ -66,7 +66,7 @@ class CDFLoader(BaseLoader[T_Output]):
                 yield upload_result
                 return
 
-        issues = NeatIssueList[NeatIssue]()
+        issues = IssueList()
         items: list[T_Output] = []
         for result in self._load(stop_on_exception=False):
             if isinstance(result, NeatIssue):
@@ -79,7 +79,7 @@ class CDFLoader(BaseLoader[T_Output]):
 
             if len(items) >= self._UPLOAD_BATCH_SIZE or result is _END_OF_CLASS:
                 yield from self._upload_to_cdf(client, items, dry_run, issues)
-                issues = NeatIssueList[NeatIssue]()
+                issues = IssueList()
                 items = []
         if items:
             yield from self._upload_to_cdf(client, items, dry_run, issues)

{cognite_neat-0.88.1 → cognite_neat-0.88.2}/cognite/neat/graph/loaders/_rdf2asset.py

@@ -19,9 +19,9 @@ from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError
 
 from cognite.neat.graph._tracking.base import Tracker
 from cognite.neat.graph._tracking.log import LogTracker
-from cognite.neat.graph.issues import loader as loader_issues
 from cognite.neat.graph.stores import NeatGraphStore
-from cognite.neat.issues import NeatIssue, NeatIssueList
+from cognite.neat.issues import IssueList, NeatIssue, NeatIssueList
+from cognite.neat.issues.errors.resources import InvalidResourceError
 from cognite.neat.rules.analysis._asset import AssetAnalysis
 from cognite.neat.rules.models import AssetRules
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
@@ -80,7 +80,7 @@ class AssetLoader(CDFLoader[AssetWrite]):
         self.external_id_prefix = external_id_prefix
 
         self.processed_assets: set[str] = set()
-        self._issues = NeatIssueList[NeatIssue](create_issues or [])
+        self._issues = IssueList(create_issues or [])
         self._tracker: type[Tracker] = tracker or LogTracker
 
     def _load(self, stop_on_exception: bool = False) -> Iterable[AssetWrite | NeatIssue | type[_END_OF_CLASS]]:
@@ -143,8 +143,8 @@ class AssetLoader(CDFLoader[AssetWrite]):
 
                 # check on parent
                 if "parentExternalId" in fields and fields["parentExternalId"] not in self.processed_assets:
-                    error = loader_issues.InvalidInstanceError(
-                        type_=EntityTypes.asset,
+                    error = InvalidResourceError(
+                        resource_type=EntityTypes.asset,
                         identifier=identifier,
                         reason=(
                             f"Parent asset {fields['parentExternalId']} does not exist or failed creation"
@@ -171,9 +171,7 @@ class AssetLoader(CDFLoader[AssetWrite]):
                     yield AssetWrite.load(fields)
                     self.processed_assets.add(identifier)
                 except KeyError as e:
-                    error = loader_issues.InvalidInstanceError(
-                        type_=EntityTypes.asset, identifier=identifier, reason=str(e)
-                    )
+                    error = InvalidResourceError(resource_type=EntityTypes.asset, identifier=identifier, reason=str(e))
                     tracker.issue(error)
                     if stop_on_exception:
                         raise error.as_exception() from e
@@ -203,8 +201,8 @@ class AssetLoader(CDFLoader[AssetWrite]):
 
                 # check if source asset exists
                 if source_external_id not in self.processed_assets:
-                    error = loader_issues.InvalidInstanceError(
-                        type_=EntityTypes.relationship,
+                    error = InvalidResourceError(
+                        resource_type=EntityTypes.relationship,
                         identifier=source_external_id,
                         reason=(
                             f"Asset {source_external_id} does not exist! "
@@ -223,8 +221,8 @@ class AssetLoader(CDFLoader[AssetWrite]):
                         target_external_id = f"{self.external_id_prefix or ''}{target_external_id}"
                         # check if source asset exists
                         if target_external_id not in self.processed_assets:
-                            error = loader_issues.InvalidInstanceError(
-                                type_=EntityTypes.relationship,
+                            error = InvalidResourceError(
+                                resource_type=EntityTypes.relationship,
                                 identifier=target_external_id,
                                 reason=(
                                     f"Asset {target_external_id} does not exist! "
@@ -250,8 +248,8 @@ class AssetLoader(CDFLoader[AssetWrite]):
                                 labels=[label] if self.use_labels else None,
                             )
                         except KeyError as e:
-                            error = loader_issues.InvalidInstanceError(
-                                type_=EntityTypes.relationship,
+                            error = InvalidResourceError(
+                                resource_type=EntityTypes.relationship,
                                 identifier=external_id,
                                 reason=str(e),
                             )

{cognite_neat-0.88.1 → cognite_neat-0.88.2}/cognite/neat/graph/loaders/_rdf2dms.py

@@ -14,10 +14,12 @@ from cognite.client.data_classes.data_modeling.views import SingleEdgeConnection
 from cognite.client.exceptions import CogniteAPIError
 from pydantic import BaseModel, ValidationInfo, create_model, field_validator
 
+import cognite.neat.issues.errors.resources
 from cognite.neat.graph._tracking import LogTracker, Tracker
-from cognite.neat.graph.issues import loader as loader_issues
 from cognite.neat.graph.stores import NeatGraphStore
-from cognite.neat.issues import NeatIssue, NeatIssueList
+from cognite.neat.issues import IssueList, NeatIssue, NeatIssueList
+from cognite.neat.issues.errors.resources import FailedConvertError, InvalidResourceError, ResourceNotFoundError
+from cognite.neat.issues.neat_warnings.models import InvalidClassWarning
 from cognite.neat.rules.models import DMSRules
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json
 from cognite.neat.utils.auxiliary import create_sha256_hash
@@ -51,7 +53,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         self.data_model = data_model
         self.instance_space = instance_space
         self.class_by_view_id = class_by_view_id or {}
-        self._issues = NeatIssueList[NeatIssue](create_issues or [])
+        self._issues = IssueList(create_issues or [])
         self._tracker: type[Tracker] = tracker or LogTracker
 
     @classmethod
@@ -67,7 +69,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         try:
             data_model = client.data_modeling.data_models.retrieve(data_model_id, inline_views=True).latest_version()
         except Exception as e:
-            issues.append(loader_issues.MissingDataModelError(identifier=repr(data_model_id), reason=str(e)))
+            issues.append(
+                ResourceNotFoundError(identifier=repr(data_model_id), resource_type="Data Model", reason=str(e))
+            )
 
         return cls(graph_store, data_model, instance_space, {}, issues)
 
@@ -79,7 +83,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             data_model = rules.as_schema().as_read_model()
         except Exception as e:
             issues.append(
-                loader_issues.FailedConvertError(
+                FailedConvertError(
                     identifier=rules.metadata.as_identifier(),
                     target_format="read DMS model",
                     reason=str(e),
@@ -110,7 +114,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 try:
                     yield self._create_node(identifier, properties, pydantic_cls, view_id)
                 except ValueError as e:
-                    error = loader_issues.InvalidInstanceError(type_="node", identifier=identifier, reason=str(e))
+                    error = InvalidResourceError(resource_type="node", identifier=identifier, reason=str(e))
                     tracker.issue(error)
                     if stop_on_exception:
                         raise error.as_exception() from e
@@ -141,7 +145,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
     def _create_validation_classes(
         self, view: dm.View
     ) -> tuple[type[BaseModel], dict[str, dm.EdgeConnection], NeatIssueList]:
-        issues = NeatIssueList[NeatIssue]()
+        issues = IssueList()
         field_definitions: dict[str, tuple[type, Any]] = {}
         edge_by_property: dict[str, dm.EdgeConnection] = {}
         validators: dict[str, classmethod] = {}
@@ -158,7 +162,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                     data_type = _DATA_TYPE_BY_DMS_TYPE.get(prop.type._type)
                     if not data_type:
                         issues.append(
-                            loader_issues.InvalidClassWarning(
+                            InvalidClassWarning(
                                 class_name=repr(view.as_id()),
                                 reason=f"Unknown data type for property {prop_name}: {prop.type._type}",
                             )
@@ -247,8 +251,8 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 continue
             edge = edge_by_properties[prop]
             if isinstance(edge, SingleEdgeConnection) and len(values) > 1:
-                error = loader_issues.InvalidInstanceError(
-                    type_="edge",
+                error = cognite.neat.issues.errors.resources.InvalidResourceError(
+                    resource_type="edge",
                     identifier=identifier,
                     reason=f"Multiple values for single edge {edge}. Expected only one.",
                 )

cognite_neat-0.88.2/cognite/neat/issues/__init__.py

@@ -0,0 +1,16 @@
+"""This is module contains all the Neat Exceptions (Errors) and Warnings as well
+as
+
+"""
+
+from ._base import DefaultWarning, IssueList, MultiValueError, NeatError, NeatIssue, NeatIssueList, NeatWarning
+
+__all__ = [
+    "NeatIssue",
+    "NeatError",
+    "NeatWarning",
+    "DefaultWarning",
+    "NeatIssueList",
+    "IssueList",
+    "MultiValueError",
+]

cognite_neat-0.88.1/cognite/neat/issues.py → cognite_neat-0.88.2/cognite/neat/issues/_base.py

@@ -9,7 +9,7 @@ from typing import Any, ClassVar, TypeVar
 from warnings import WarningMessage
 
 import pandas as pd
-from pydantic_core import PydanticCustomError
+from pydantic_core import ErrorDetails, PydanticCustomError
 
 if sys.version_info < (3, 11):
     from exceptiongroup import ExceptionGroup
@@ -18,11 +18,24 @@ else:
     from typing import Self
 
 
+__all__ = [
+    "NeatIssue",
+    "NeatError",
+    "NeatWarning",
+    "DefaultWarning",
+    "NeatIssueList",
+    "MultiValueError",
+]
+
+
 @total_ordering
 @dataclass(frozen=True)
 class NeatIssue(ABC):
+    """This is the base class for all exceptions and warnings (issues) used in Neat."""
+
     description: ClassVar[str]
-    fix: ClassVar[str]
+    extra: ClassVar[str | None] = None
+    fix: ClassVar[str | None] = None
 
     def message(self) -> str:
         """Return a human-readable message for the issue.
@@ -31,7 +44,7 @@ class NeatIssue(ABC):
         It is recommended to override this method in subclasses with a more
         specific message.
         """
-        return self.description
+        return self.__doc__ or "Missing"
 
     @abstractmethod
     def dump(self) -> dict[str, Any]:
@@ -59,11 +72,63 @@ class NeatError(NeatIssue, ABC):
 
     def as_pydantic_exception(self) -> PydanticCustomError:
         return PydanticCustomError(
-            self.__class__.__name__,
+            type(self).__name__,
             self.message(),
-            dict(description=self.description, fix=self.fix),
+            dict(description=self.__doc__, fix=self.fix),
+        )
+
+    @classmethod
+    def from_pydantic_errors(cls, errors: list[ErrorDetails], **kwargs) -> "list[NeatError]":
+        """Convert a list of pydantic errors to a list of Error instances.
+
+        This is intended to be overridden in subclasses to handle specific error types.
+        """
+        all_errors: list[NeatError] = []
+        for error in errors:
+            if isinstance(ctx := error.get("ctx"), dict) and isinstance(
+                multi_error := ctx.get("error"), MultiValueError
+            ):
+                all_errors.extend(multi_error.errors)  # type: ignore[arg-type]
+            else:
+                all_errors.append(DefaultPydanticError.from_pydantic_error(error))
+        return all_errors
+
+
+@dataclass(frozen=True)
+class DefaultPydanticError(NeatError):
+    type: str
+    loc: tuple[int | str, ...]
+    msg: str
+    input: Any
+    ctx: dict[str, Any] | None
+
+    @classmethod
+    def from_pydantic_error(cls, error: ErrorDetails) -> "DefaultPydanticError":
+        return cls(
+            type=error["type"],
+            loc=error["loc"],
+            msg=error["msg"],
+            input=error.get("input"),
+            ctx=error.get("ctx"),
         )
 
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["type"] = self.type
+        output["loc"] = self.loc
+        output["msg"] = self.msg
+        output["input"] = self.input
+        output["ctx"] = self.ctx
+        return output
+
+    def message(self) -> str:
+        if self.loc and len(self.loc) == 1:
+            return f"{self.loc[0]} sheet: {self.msg}"
+        elif self.loc and len(self.loc) == 2:
+            return f"{self.loc[0]} sheet field/column <{self.loc[1]}>: {self.msg}"
+        else:
+            return self.msg
+
 
 @dataclass(frozen=True)
 class NeatWarning(NeatIssue, ABC, UserWarning):
@@ -156,3 +221,6 @@ class MultiValueError(ValueError):
 
     def __init__(self, errors: Sequence[T_NeatIssue]):
         self.errors = list(errors)
+
+
+class IssueList(NeatIssueList[NeatIssue]): ...

cognite_neat-0.88.2/cognite/neat/issues/errors/external.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import Any
+
+from cognite.neat.issues import NeatError
+
+
+@dataclass(frozen=True)
+class FailedAuthorizationError(NeatError):
+    description = "Missing authorization for {action}: {reason}"
+
+    action: str
+    reason: str
+
+    def message(self) -> str:
+        return self.description.format(action=self.action, reason=self.reason)
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["action"] = self.action
+        output["reason"] = self.reason
+        return output

cognite_neat-0.88.2/cognite/neat/issues/errors/properties.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+from typing import Any, Generic
+
+from .resources import ResourceError, T_Identifier, T_ReferenceIdentifier
+
+
+@dataclass(frozen=True)
+class PropertyNotFoundError(ResourceError[T_Identifier]):
+    """The {resource_type} with identifier {identifier} does not have a property {property_name}"""
+
+    property_name: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type, identifier=repr(self.identifier), property_name=self.property_name
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["property_name"] = self.property_name
+        return output
+
+
+@dataclass(frozen=True)
+class ReferredPropertyNotFoundError(ResourceError, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} with identifier {identifier} does not have a property {property_name} referred
+    to by {referred_type} {referred_by} does not exist
+    """
+
+    fix = "Ensure the {resource_type} {identifier} has a {property_name} property"
+
+    referred_by: T_ReferenceIdentifier
+    referred_type: str
+    property_name: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type,
+            identifier=repr(self.identifier),
+            referred_type=self.referred_type,
+            referred_by=repr(self.referred_by),
+            property_name=self.property_name,
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["identifier"] = self.identifier
+        output["referred_by"] = self.referred_by
+        output["referred_type"] = self.referred_type
+        output["property_name"] = self.property_name
+        return output
+
+
+@dataclass(frozen=True)
+class PropertyTypeNotSupportedError(ResourceError[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has a property {property_name}
+    of unsupported type {property_type}"""
+
+    property_name: str
+    property_type: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type,
+            identifier=repr(self.identifier),
+            property_name=self.property_name,
+            property_type=self.property_type,
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["property_name"] = self.property_name
+        output["property_type"] = self.property_type
+        return output

cognite_neat-0.88.2/cognite/neat/issues/errors/resources.py

@@ -0,0 +1,123 @@
+from collections.abc import Hashable
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar
+
+from cognite.neat.issues import NeatError
+
+T_Identifier = TypeVar("T_Identifier", bound=Hashable)
+
+
+@dataclass(frozen=True)
+class ResourceError(NeatError, Generic[T_Identifier]):
+    """Base class for resource errors"""
+
+    identifier: T_Identifier
+    resource_type: str
+
+
+@dataclass(frozen=True)
+class ResourceNotFoundError(ResourceError[T_Identifier]):
+    """The {resource_type} with identifier {identifier} is missing: {reason}"""
+
+    fix = "Check the {resource_type} {identifier} and try again."
+    reason: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type, identifier=repr(self.identifier), reason=self.reason
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["identifier"] = self.identifier
+        output["reason"] = self.reason
+        return output
+
+
+T_ReferenceIdentifier = TypeVar("T_ReferenceIdentifier", bound=Hashable)
+
+
+@dataclass(frozen=True)
+class ReferredResourceNotFoundError(ResourceError, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} with identifier {identifier} referred by {referred_type} {referred_by} does not exist"""
+
+    fix = "Create the {resource_type}"
+
+    referred_by: T_ReferenceIdentifier
+    referred_type: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type,
+            identifier=repr(self.identifier),
+            referred_type=self.referred_type,
+            referred_by=repr(self.referred_by),
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["identifier"] = self.identifier
+        output["referred_by"] = self.referred_by
+        output["referred_type"] = self.referred_type
+        return output
+
+
+@dataclass(frozen=True)
+class FailedConvertError(NeatError):
+    description = "Failed to convert the {identifier} to {target_format}: {reason}"
+    fix = "Check the error message and correct the rules."
+    identifier: str
+    target_format: str
+    reason: str
+
+    def message(self) -> str:
+        return self.description.format(identifier=self.identifier, target_format=self.target_format, reason=self.reason)
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["identifier"] = self.identifier
+        output["targetFormat"] = self.target_format
+        output["reason"] = self.reason
+        return output
+
+
+@dataclass(frozen=True)
+class InvalidResourceError(NeatError):
+    """The {resource_type} with identifier {identifier} is invalid and will be skipped. {reason}"""
+
+    fix = "Check the error message and correct the instance."
+
+    resource_type: str
+    identifier: str
+    reason: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type, identifier=self.identifier, reason=self.reason
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["type"] = self.resource_type
+        output["identifier"] = self.identifier
+        output["reason"] = self.reason
+        return output
+
+
+@dataclass(frozen=True)
+class MissingIdentifierError(NeatError):
+    """The {resource_type} with name {name} is missing an identifier."""
+
+    resource_type: str
+    name: str | None = None
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(resource_type=self.resource_type, name=self.name or "unknown")
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["type"] = self.resource_type
+        output["name"] = self.name
+        return output

{cognite_neat-0.88.1/cognite/neat/rules → cognite_neat-0.88.2/cognite/neat}/issues/formatters.py

@@ -3,7 +3,7 @@ import xml.etree.ElementTree as ET
 from abc import ABC, abstractmethod
 from pathlib import Path
 
-from .base import IssueList, NeatValidationError, ValidationWarning
+from ._base import NeatError, NeatIssueList, NeatWarning
 
 __all__ = ["Formatter", "BasicHTML", "FORMATTER_BY_NAME"]
 
@@ -13,14 +13,14 @@ class Formatter(ABC):
     default_file_prefix: str = "validation_report"
 
     @abstractmethod
-    def create_report(self, issues: IssueList) -> str:
+    def create_report(self, issues: NeatIssueList) -> str:
         raise NotImplementedError()
 
     @property
     def default_file_name(self) -> str:
         return f"{self.default_file_prefix}_{type(self).__name__.lower()}{self.file_suffix}"
 
-    def write_to_file(self, issues: IssueList, file_or_dir_path: Path | None = None) -> None:
+    def write_to_file(self, issues: NeatIssueList, file_or_dir_path: Path | None = None) -> None:
         if file_or_dir_path is None:
             file_or_dir_path = Path(self.default_file_name)
         elif file_or_dir_path.is_dir():
@@ -41,9 +41,9 @@ class BasicHTML(Formatter):
         self._doc = ET.Element("html")
         self._body = ET.SubElement(self._doc, "body")
 
-    def create_report(self, issues: IssueList) -> str:
-        errors = [issue for issue in issues if isinstance(issue, NeatValidationError)]
-        warnings_ = [issue for issue in issues if isinstance(issue, ValidationWarning)]
+    def create_report(self, issues: NeatIssueList) -> str:
+        errors = [issue for issue in issues if isinstance(issue, NeatError)]
+        warnings_ = [issue for issue in issues if isinstance(issue, NeatWarning)]
         self._doc.clear()
         self._body = ET.SubElement(self._doc, "body")
         h1 = ET.SubElement(self._body, "h1")
@@ -61,11 +61,11 @@ class BasicHTML(Formatter):
 
         return ET.tostring(self._doc, encoding="unicode")
 
-    def _write_errors_or_warnings(self, issues: list[NeatValidationError] | list[ValidationWarning]) -> None:
-        issue_name = "errors" if isinstance(issues[0], NeatValidationError) else "warnings"
+    def _write_errors_or_warnings(self, issues: list[NeatError] | list[NeatWarning]) -> None:
+        issue_name = "errors" if isinstance(issues[0], NeatError) else "warnings"
         main_categories = {base_ for issue in issues for base_ in type(issue).__bases__}
         for category in main_categories:
-            issues_in_category: list[NeatValidationError] | list[ValidationWarning] = [  # type: ignore[assignment]
+            issues_in_category: list[NeatError] | list[NeatWarning] = [  # type: ignore[assignment]
                 issue for issue in issues if isinstance(issue, category)
             ]
             h3 = ET.SubElement(self._body, "h3")

cognite_neat-0.88.2/cognite/neat/issues/neat_warnings/__init__.py

@@ -0,0 +1,2 @@
+"""All warnings raised by the neat package are defined here. Note this module is called 'neat_warnings' instead
+of 'warnings' to avoid conflicts with the built-in Python warnings module."""

cognite_neat-0.88.2/cognite/neat/issues/neat_warnings/identifier.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from typing import Any
+
+from cognite.neat.issues import NeatWarning
+
+
+@dataclass(frozen=True)
+class RegexViolationWarning(NeatWarning):
+    """The value '{value}' of {identifier} does not match the {pattern_name} pattern '{pattern}'"""
+
+    value: str
+    pattern: str
+    identifier: str
+    pattern_name: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            value=self.value, pattern=self.pattern, identifier=self.identifier, pattern_name=self.pattern_name
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["value"] = self.value
+        output["pattern"] = self.pattern
+        output["identifier"] = self.identifier
+        output["pattern_name"] = self.pattern_name
+        return output