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

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/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/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/{rules/issues → 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/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/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

cognite/neat/issues/neat_warnings/models.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from typing import Any
+
+from cognite.neat.issues import NeatWarning
+
+
+@dataclass(frozen=True)
+class InvalidClassWarning(NeatWarning):
+    description = "The class {class_name} is invalid and will be skipped. {reason}"
+    fix = "Check the error message and correct the class."
+
+    class_name: str
+    reason: str
+
+    def message(self) -> str:
+        return self.description.format(class_name=self.class_name, reason=self.reason)
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["class_name"] = self.class_name
+        output["reason"] = self.reason
+        return output

cognite/neat/issues/neat_warnings/properties.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass
+from typing import Any, Generic
+
+from .resources import ResourceWarning, T_Identifier, T_ReferenceIdentifier
+
+
+@dataclass(frozen=True)
+class PropertyTypeNotSupportedWarning(ResourceWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has a property {property_name}
+    of unsupported type {property_type}. This will be ignored."""
+
+    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
+
+
+@dataclass(frozen=True)
+class ReferredPropertyNotFoundWarning(ResourceWarning, 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. This will be ignored.
+    """
+
+    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 PropertyRedefinedWarning(ResourceWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has a property {property_name} redefined."""
+
+    property_id: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type, identifier=repr(self.identifier), property_name=self.property_id
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["property_id"] = self.property_id
+        output["resource_type"] = self.resource_type
+        output["identifier"] = self.identifier
+        return output

cognite/neat/issues/neat_warnings/resources.py

@@ -0,0 +1,125 @@
+from collections.abc import Hashable
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar
+
+from cognite.neat.issues import NeatWarning
+
+T_Identifier = TypeVar("T_Identifier", bound=Hashable)
+
+T_ReferenceIdentifier = TypeVar("T_ReferenceIdentifier", bound=Hashable)
+
+
+@dataclass(frozen=True)
+class ResourceWarning(NeatWarning, Generic[T_Identifier]):
+    """Base class for resource warnings"""
+
+    identifier: T_Identifier
+    resource_type: str
+
+
+@dataclass(frozen=True)
+class ResourceNotFoundWarning(ResourceWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} is missing: {reason}. This will be ignored."""
+
+    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
+
+
+@dataclass(frozen=True)
+class ReferredResourceNotFoundWarning(ResourceWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} with identifier {identifier} referred by {referred_type} {referred_by} does not exist.
+    This will be ignored."""
+
+    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 MultipleResourcesWarning(NeatWarning, Generic[T_Identifier]):
+    """Multiple resources of type {resource_type} with identifiers {resources} were found. This will be ignored."""
+
+    fix = "Remove the duplicate resources"
+
+    resources: frozenset[T_Identifier]
+    resource_type: str
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type,
+            resources=self.resources,
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["resources"] = self.resources
+        return output
+
+
+@dataclass(frozen=True)
+class FailedLoadingResourcesWarning(NeatWarning, Generic[T_Identifier]):
+    """Failed to load resources of type {resource_type} with identifiers {resources}. Continuing without
+    these resources."""
+
+    extra = "The error was: {error}"
+
+    fix = "Check the error."
+
+    resources: frozenset[T_Identifier]
+    resource_type: str
+    error: str | None = None
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(
+            resource_type=self.resource_type,
+            resources=self.resources,
+        ) + (self.extra.format(error=self.error) if self.error else "")
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["resources"] = self.resources
+        return output
+
+
+class ResourceTypeNotSupportedWarning(ResourceWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} is not supported. This will be ignored."""
+
+    def message(self) -> str:
+        return (self.__doc__ or "").format(resource_type=self.resource_type, identifier=repr(self.identifier))
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["resource_type"] = self.resource_type
+        output["identifier"] = self.identifier
+        return output

cognite/neat/rules/exporters/_rules2dms.py

@@ -15,9 +15,10 @@ 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.rules.issues import IssueList
 from cognite.neat.rules.models import InformationRules
 from cognite.neat.rules.models.dms import DMSRules, DMSSchema, PipelineSchema
 from cognite.neat.utils.cdf.loaders import (
@@ -313,7 +314,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(issues.importing.APIWarning(str(e)), stacklevel=2)
+            warnings.warn(FailedLoadingResourcesWarning[str](frozenset({space}), "Space", str(e)), stacklevel=2)
             return []
         else:
             return [

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