cognite-neat 0.92.3__py3-none-any.whl → 0.94.0__py3-none-any.whl

cognite/neat/_graph/transformers/_value_type.py

@@ -0,0 +1,66 @@
+from rdflib import XSD, Graph, URIRef
+
+from cognite.neat._constants import UNKNOWN_TYPE
+from cognite.neat._graph.queries import Queries
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri
+
+from ._base import BaseTransformer
+
+
+class SplitMultiValueProperty(BaseTransformer):
+    description: str = (
+        "SplitMultiValueProperty is a transformer that splits a "
+        "multi-value property into multiple single-value properties."
+    )
+    _use_only_once: bool = True
+    _need_changes = frozenset({})
+
+    _object_property_template: str = """SELECT ?s ?o WHERE{{
+
+                                ?s a <{subject_uri}> .
+                                ?s <{property_uri}> ?o .
+                                ?o a <{object_uri}> .
+
+                            }}"""
+
+    _datatype_property_template: str = """SELECT ?s ?o WHERE {{
+
+                                ?s a <{subject_uri}> .
+                                ?s <{property_uri}> ?o .
+                                FILTER (datatype(?o) = <{object_uri}>)
+
+                                }}"""
+
+    _unknown_property_template: str = """SELECT ?s ?o WHERE {{
+
+                                ?s a <{subject_uri}> .
+                                ?s <{property_uri}> ?o .
+                                FILTER NOT EXISTS {{ ?o a ?objectType }}
+                                }}"""
+
+    def transform(self, graph: Graph) -> None:
+        # handle multi value type object properties
+        for subject_uri, property_uri, value_types in Queries(graph).multi_value_type_property():
+            for value_type_uri in value_types:
+                _args = {
+                    "subject_uri": subject_uri,
+                    "property_uri": property_uri,
+                    "object_uri": value_type_uri,
+                }
+
+                # Case 1: Unknown value type
+                if value_type_uri == UNKNOWN_TYPE:
+                    iterator = graph.query(self._unknown_property_template.format(**_args))
+
+                # Case 2: Datatype value type
+                elif value_type_uri.startswith(str(XSD)):
+                    iterator = graph.query(self._datatype_property_template.format(**_args))
+
+                # Case 3: Object value type
+                else:
+                    iterator = graph.query(self._object_property_template.format(**_args))
+
+                for s, o in iterator:  # type: ignore [misc]
+                    graph.remove((s, property_uri, o))
+                    new_property = URIRef(f"{property_uri}_{remove_namespace_from_uri(value_type_uri)}")
+                    graph.add((s, new_property, o))

cognite/neat/{issues → _issues}/_base.py

@@ -1,7 +1,7 @@
+import inspect
 import sys
 import warnings
 from abc import ABC
-from collections import UserList
 from collections.abc import Collection, Hashable, Iterable, Sequence
 from dataclasses import dataclass, fields
 from functools import total_ordering
@@ -11,11 +11,11 @@ from typing import Any, ClassVar, Literal, TypeAlias, TypeVar, get_args, get_ori
 from warnings import WarningMessage
 
 import pandas as pd
-from cognite.client.data_classes.data_modeling import ContainerId, ViewId
+from cognite.client.data_classes.data_modeling import ContainerId, PropertyId, ViewId
 from pydantic_core import ErrorDetails
 
-from cognite.neat.utils.spreadsheet import SpreadsheetRead
-from cognite.neat.utils.text import humanize_collection, to_camel, to_snake
+from cognite.neat._utils.spreadsheet import SpreadsheetRead
+from cognite.neat._utils.text import humanize_collection, to_camel, to_snake
 
 if sys.version_info < (3, 11):
     from exceptiongroup import ExceptionGroup
@@ -60,7 +60,7 @@ ResourceType: TypeAlias = (
 
 
 @total_ordering
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NeatIssue:
     """This is the base class for all exceptions and warnings (issues) used in Neat."""
 
@@ -107,6 +107,8 @@ class NeatIssue:
 
     @classmethod
     def _dump_value(cls, value: Any) -> list | int | bool | float | str | dict:
+        from cognite.neat._rules.models.entities import Entity
+
         if isinstance(value, str | int | bool | float):
             return value
         elif isinstance(value, frozenset):
@@ -117,13 +119,17 @@ class NeatIssue:
             return [cls._dump_value(item) for item in value]
         elif isinstance(value, ViewId | ContainerId):
             return value.dump(camel_case=True, include_type=True)
+        elif isinstance(value, Entity):
+            return value.dump()
+        elif isinstance(value, PropertyId):
+            return value.dump(camel_case=True)
         raise ValueError(f"Unsupported type: {type(value)}")
 
     @classmethod
     def load(cls, data: dict[str, Any]) -> "NeatIssue":
         """Create an instance of the issue from a dictionary."""
-        from cognite.neat.issues.errors import _NEAT_ERRORS_BY_NAME, NeatValueError
-        from cognite.neat.issues.warnings import _NEAT_WARNINGS_BY_NAME
+        from cognite.neat._issues.errors import _NEAT_ERRORS_BY_NAME, NeatValueError
+        from cognite.neat._issues.warnings import _NEAT_WARNINGS_BY_NAME
 
         if "NeatIssue" not in data:
             raise NeatValueError("The data does not contain a NeatIssue key.")
@@ -147,7 +153,9 @@ class NeatIssue:
         return neat_issue_cls(**args)
 
     @classmethod
-    def _load_value(cls, type_: type, value: Any) -> Any:
+    def _load_value(cls, type_: Any, value: Any) -> Any:
+        from cognite.neat._rules.models.entities import Entity
+
         if isinstance(type_, UnionType) or get_origin(type_) is UnionType:
             args = get_args(type_)
             return cls._load_value(args[0], value)
@@ -161,8 +169,12 @@ class NeatIssue:
             return tuple(cls._load_value(subtype, item) for item in value)
         elif type_ is ViewId:
             return ViewId.load(value)
+        elif type_ is PropertyId:
+            return PropertyId.load(value)
         elif type_ is ContainerId:
             return ContainerId.load(value)
+        elif inspect.isclass(type_) and issubclass(type_, Entity):
+            return type_.load(value)
         return value
 
     def __lt__(self, other: "NeatIssue") -> bool:
@@ -176,7 +188,7 @@ class NeatIssue:
         return (type(self).__name__, self.as_message()) == (type(other).__name__, other.as_message())
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NeatError(NeatIssue, Exception):
     """This is the base class for all exceptions (errors) used in Neat."""
 
@@ -212,8 +224,8 @@ class NeatError(NeatIssue, Exception):
 
     @staticmethod
     def _adjust_row_numbers(caught_error: "NeatError", read_info_by_sheet: dict[str, SpreadsheetRead]) -> None:
-        from cognite.neat.issues.errors._properties import PropertyDefinitionDuplicatedError
-        from cognite.neat.issues.errors._resources import ResourceNotDefinedError
+        from cognite.neat._issues.errors._properties import PropertyDefinitionDuplicatedError
+        from cognite.neat._issues.errors._resources import ResourceNotDefinedError
 
         reader = read_info_by_sheet.get("Properties", SpreadsheetRead())
 
@@ -238,7 +250,7 @@ class NeatError(NeatIssue, Exception):
                 object.__setattr__(caught_error, "row_number", new_row)
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class DefaultPydanticError(NeatError, ValueError):
     """{type}: {msg} [loc={loc}]"""
 
@@ -263,7 +275,7 @@ class DefaultPydanticError(NeatError, ValueError):
             return self.msg
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class RowError(NeatError, ValueError):
     """In {sheet_name}, row={row}, column={column}: {msg}. [type={type}, input_value={input}]"""
 
@@ -307,7 +319,7 @@ class RowError(NeatError, ValueError):
         return output
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NeatWarning(NeatIssue, UserWarning):
     """This is the base class for all warnings used in Neat."""
 
@@ -317,7 +329,7 @@ class NeatWarning(NeatIssue, UserWarning):
         return DefaultWarning.from_warning_message(warning)
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class DefaultWarning(NeatWarning):
     """{category}: {warning}"""
 
@@ -345,7 +357,7 @@ class DefaultWarning(NeatWarning):
 T_NeatIssue = TypeVar("T_NeatIssue", bound=NeatIssue)
 
 
-class NeatIssueList(UserList[T_NeatIssue], Sequence[T_NeatIssue], ABC):
+class NeatIssueList(list, Sequence[T_NeatIssue], ABC):
     """This is a generic list of NeatIssues."""
 
     def __init__(self, issues: Sequence[T_NeatIssue] | None = None, title: str | None = None):
@@ -406,7 +418,10 @@ class MultiValueError(ValueError):
 class IssueList(NeatIssueList[NeatIssue]):
     """This is a list of NeatIssues."""
 
-    ...
+    def _repr_html_(self) -> str | None:
+        if not self:
+            return "<p>'No issues found'</p>"
+        return super()._repr_html_()
 
 
 T_Cls = TypeVar("T_Cls")

cognite/neat/{issues → _issues}/errors/__init__.py

@@ -1,4 +1,4 @@
-from cognite.neat.issues._base import DefaultPydanticError, NeatError, RowError, _get_subclasses
+from cognite.neat._issues._base import DefaultPydanticError, NeatError, RowError, _get_subclasses
 
 from ._external import (
     AuthorizationError,

cognite/neat/{issues → _issues}/errors/_external.py

@@ -3,10 +3,10 @@ from pathlib import Path
 
 from yaml import YAMLError
 
-from cognite.neat.issues import NeatError
+from cognite.neat._issues import NeatError
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class AuthorizationError(NeatError, RuntimeError):
     """Missing authorization for {action}: {reason}"""
 
@@ -14,7 +14,7 @@ class AuthorizationError(NeatError, RuntimeError):
     reason: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class FileReadError(NeatError, RuntimeError):
     """Error when reading file, {filepath}: {reason}"""
 
@@ -23,7 +23,7 @@ class FileReadError(NeatError, RuntimeError):
     reason: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class FileNotFoundNeatError(NeatError, FileNotFoundError):
     """File {filepath} not found"""
 
@@ -31,7 +31,7 @@ class FileNotFoundNeatError(NeatError, FileNotFoundError):
     filepath: Path
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class FileMissingRequiredFieldError(NeatError, ValueError):
     """Missing required {field_name} in {filepath}: {field}"""
 
@@ -40,7 +40,7 @@ class FileMissingRequiredFieldError(NeatError, ValueError):
     field: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NeatYamlError(NeatError, YAMLError):
     """Invalid YAML: {reason}"""
 
@@ -51,7 +51,7 @@ class NeatYamlError(NeatError, YAMLError):
     expected_format: str | None = None
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class FileTypeUnexpectedError(NeatError, TypeError):
     """Unexpected file type: {filepath}. Expected format: {expected_format}"""
 
@@ -59,7 +59,7 @@ class FileTypeUnexpectedError(NeatError, TypeError):
     expected_format: frozenset[str]
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class FileNotAFileError(NeatError, FileNotFoundError):
     """{filepath} is not a file"""
 

cognite/neat/{issues → _issues}/errors/_general.py

@@ -1,23 +1,23 @@
 from dataclasses import dataclass
 
-from cognite.neat.issues import NeatError
+from cognite.neat._issues import NeatError
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NeatValueError(NeatError, ValueError):
     """{raw_message}"""
 
     raw_message: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NeatTypeError(NeatError, TypeError):
     """{raw_message}"""
 
     raw_message: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class RegexViolationError(NeatError, ValueError):
     """Value, {value} failed regex, {regex}, validation. Make sure that the name follows the regex pattern."""
 
@@ -25,7 +25,7 @@ class RegexViolationError(NeatError, ValueError):
     regex: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NeatImportError(NeatError, ImportError):
     """The functionality requires {module}. You can include it
     in your neat installation with `pip install "cognite-neat[{neat_extra}]"`.

cognite/neat/{issues → _issues}/errors/_properties.py

@@ -1,19 +1,19 @@
 from dataclasses import dataclass
 from typing import Generic
 
-from cognite.neat.issues._base import ResourceType
+from cognite.neat._issues._base import ResourceType
 
 from ._resources import ResourceError, T_Identifier, T_ReferenceIdentifier
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyError(ResourceError[T_Identifier]):
     """Base class for property errors {resource_type} with identifier {identifier}.{property_name}"""
 
     property_name: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyNotFoundError(PropertyError, Generic[T_Identifier, T_ReferenceIdentifier]):
     """The {resource_type} with identifier {identifier} does not have a property {property_name}"""
 
@@ -24,7 +24,7 @@ class PropertyNotFoundError(PropertyError, Generic[T_Identifier, T_ReferenceIden
     referred_type: ResourceType | None = None
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyTypeNotSupportedError(PropertyError[T_Identifier]):
     """The {resource_type} with identifier {identifier} has a property {property_name}
     of unsupported type {property_type}"""
@@ -33,14 +33,14 @@ class PropertyTypeNotSupportedError(PropertyError[T_Identifier]):
 
 
 # This is a generic error that should be used sparingly
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyDefinitionError(PropertyError[T_Identifier]):
     """Invalid property definition for {resource_type} {identifier}.{property_name}: {reason}"""
 
     reason: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyDefinitionDuplicatedError(PropertyError[T_Identifier]):
     """The {resource_type} with identifier {identifier} has multiple definitions for the property {property_name}
     with values {property_values}
@@ -53,7 +53,7 @@ class PropertyDefinitionDuplicatedError(PropertyError[T_Identifier]):
     location_name: str | None = None
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PropertyMappingDuplicatedError(PropertyError[T_Identifier], Generic[T_Identifier, T_ReferenceIdentifier]):
     """The {resource_type} with identifier {identifier}.{property_name} is mapped to by: {mappings}. Ensure
     that only one {mapping_type} maps to {resource_type} {identifier}.{property_name}"""

cognite/neat/{issues → _issues}/errors/_resources.py

@@ -1,11 +1,11 @@
 from dataclasses import dataclass
 from typing import Generic
 
-from cognite.neat.issues._base import NeatError, ResourceType, T_Identifier, T_ReferenceIdentifier
-from cognite.neat.utils.text import humanize_collection
+from cognite.neat._issues._base import NeatError, ResourceType, T_Identifier, T_ReferenceIdentifier
+from cognite.neat._utils.text import humanize_collection
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceError(NeatError, Generic[T_Identifier], RuntimeError):
     """Base class for resource errors {resource_type} with identifier {identifier}"""
 
@@ -13,7 +13,7 @@ class ResourceError(NeatError, Generic[T_Identifier], RuntimeError):
     resource_type: ResourceType
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceDuplicatedError(ResourceError[T_Identifier]):
     """The {resource_type} with identifier {identifier} is duplicated in {location}"""
 
@@ -21,14 +21,14 @@ class ResourceDuplicatedError(ResourceError[T_Identifier]):
     location: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceRetrievalError(ResourceError[T_Identifier]):
     """Failed to retrieve {resource_type} with identifier {identifier}. The error was: {error}"""
 
     error: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceNotFoundError(ResourceError, Generic[T_Identifier, T_ReferenceIdentifier]):
     """The {resource_type} with identifier {identifier} does not exist"""
 
@@ -50,7 +50,7 @@ class ResourceNotFoundError(ResourceError, Generic[T_Identifier, T_ReferenceIden
         return msg
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceNotDefinedError(ResourceError[T_Identifier]):
     """The {resource_type} {identifier} is not defined in the {location}"""
 
@@ -63,7 +63,7 @@ class ResourceNotDefinedError(ResourceError[T_Identifier]):
     sheet_name: str | None = None
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceConvertionError(ResourceError, ValueError):
     """Failed to convert the {resource_type} {identifier} to {target_format}: {reason}"""
 
@@ -72,14 +72,14 @@ class ResourceConvertionError(ResourceError, ValueError):
     reason: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceCreationError(ResourceError[T_Identifier], ValueError):
     """Failed to create {resource_type} with identifier {identifier}. The error was: {error}"""
 
     error: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceMissingIdentifierError(NeatError, ValueError):
     """The {resource_type} with name {name} is missing an identifier."""
 
@@ -87,7 +87,7 @@ class ResourceMissingIdentifierError(NeatError, ValueError):
     name: str | None = None
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class ResourceChangedError(ResourceError[T_Identifier]):
     """The {resource_type} with identifier {identifier} has changed{changed}"""
 

cognite/neat/{issues → _issues}/errors/_workflow.py

@@ -1,9 +1,9 @@
 from dataclasses import dataclass
 
-from cognite.neat.issues import NeatError
+from cognite.neat._issues import NeatError
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class WorkFlowMissingDataError(NeatError, ValueError):
     """In the workflow step {step_name} the following data is missing: {missing_data}."""
 
@@ -11,14 +11,14 @@ class WorkFlowMissingDataError(NeatError, ValueError):
     missing_data: frozenset[str]
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class WorkflowStepNotInitializedError(NeatError, RuntimeError):
     """Step {step_name} has not been initialized."""
 
     step_name: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class WorkflowConfigurationNotSetError(NeatError, RuntimeError):
     """The configuration variable '{config_variable}' is not set. Please set the configuration
     before running the workflow."""
@@ -26,7 +26,7 @@ class WorkflowConfigurationNotSetError(NeatError, RuntimeError):
     config_variable: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class WorkflowStepOutputError(NeatError, RuntimeError):
     """Object type {step_type} is not supported as step output.
 

cognite/neat/{issues → _issues}/warnings/__init__.py

@@ -2,7 +2,7 @@
 conflicts with the built-in Python warnings module. However, it is expected to always be used in an absolute
 import, and should thus not cause a naming conflict."""
 
-from cognite.neat.issues._base import DefaultWarning, NeatWarning, _get_subclasses
+from cognite.neat._issues._base import DefaultWarning, NeatWarning, _get_subclasses
 
 from . import user_modeling
 from ._external import (

cognite/neat/{issues → _issues}/warnings/_external.py

@@ -1,10 +1,10 @@
 from dataclasses import dataclass
 from pathlib import Path
 
-from cognite.neat.issues import NeatWarning
+from cognite.neat._issues import NeatWarning
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class FileReadWarning(NeatWarning):
     """Error when reading file, {filepath}: {reason}"""
 
@@ -12,7 +12,7 @@ class FileReadWarning(NeatWarning):
     reason: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class FileMissingRequiredFieldWarning(NeatWarning):
     """Missing required {field_name} in {filepath}: {field}. The file will be skipped"""
 
@@ -21,7 +21,7 @@ class FileMissingRequiredFieldWarning(NeatWarning):
     field: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class FileTypeUnexpectedWarning(NeatWarning):
     """Unexpected file type: {filepath}. Expected format: {expected_format}"""
 
@@ -32,7 +32,7 @@ class FileTypeUnexpectedWarning(NeatWarning):
     error_message: str | None = None
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class FileItemNotSupportedWarning(NeatWarning):
     """The item {item} in {filepath} is not supported. The item will be skipped"""
 

cognite/neat/{issues → _issues}/warnings/_general.py

@@ -1,23 +1,23 @@
 from dataclasses import dataclass
 
-from cognite.neat.issues import NeatWarning
+from cognite.neat._issues import NeatWarning
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NeatValueWarning(NeatWarning):
     """{value}"""
 
     value: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NotSupportedWarning(NeatWarning):
     """{feature} is not supported"""
 
     feature: str
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class RegexViolationWarning(NeatWarning):
     """The value '{value}' of {identifier} does not match the {pattern_name} pattern '{pattern}'"""
 

cognite/neat/{issues → _issues}/warnings/_models.py

@@ -4,13 +4,13 @@ from typing import ClassVar
 
 from cognite.client.data_classes.data_modeling import ViewId
 
-from cognite.neat.constants import DMS_VIEW_CONTAINER_SIZE_LIMIT
-from cognite.neat.issues import NeatWarning
+from cognite.neat._constants import DMS_VIEW_CONTAINER_SIZE_LIMIT
+from cognite.neat._issues import NeatWarning
 
 _BASE_URL = "https://cognite-neat.readthedocs-hosted.com/en/latest/data-modeling-principles.html"
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class BreakingModelingPrincipleWarning(NeatWarning, ABC):
     """{warning_class}: {specific} violates the {principle} principle.
     See {url} for more information."""
@@ -29,7 +29,7 @@ class BreakingModelingPrincipleWarning(NeatWarning, ABC):
         )
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PrincipleOneModelOneSpaceWarning(BreakingModelingPrincipleWarning):
     """{warning_class}: {specific} violates the {principle} principle.
     See {url} for more information."""
@@ -37,7 +37,7 @@ class PrincipleOneModelOneSpaceWarning(BreakingModelingPrincipleWarning):
     url = "all-data-models-are-kept-in-its-own-space"
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PrincipleMatchingSpaceAndVersionWarning(BreakingModelingPrincipleWarning):
     """{warning_class}: {specific} violates the {principle} principle.
     See {url} for more information."""
@@ -45,7 +45,7 @@ class PrincipleMatchingSpaceAndVersionWarning(BreakingModelingPrincipleWarning):
     url = "all-views-of-a-data-models-have-the-same-version-and-space-as-the-data-model"
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class PrincipleSolutionBuildsOnEnterpriseWarning(BreakingModelingPrincipleWarning):
     """{warning_class}: {specific} violates the {principle} principle.
     See {url} for more information."""
@@ -53,7 +53,7 @@ class PrincipleSolutionBuildsOnEnterpriseWarning(BreakingModelingPrincipleWarnin
     url = "solution-data-models-should-always-be-referencing-the-enterprise-data-model"
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class UserModelingWarning(NeatWarning, ABC):
     """This is a generic warning for user modeling issues.
     These warnings will not cause the resulting model to be invalid, but
@@ -62,7 +62,7 @@ class UserModelingWarning(NeatWarning, ABC):
     ...
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class CDFNotSupportedWarning(NeatWarning, ABC):
     """This is a base class for warnings for modeling issues that will
     likely lead to the CDF API rejecting the model."""
@@ -70,7 +70,7 @@ class CDFNotSupportedWarning(NeatWarning, ABC):
     ...
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NotSupportedViewContainerLimitWarning(CDFNotSupportedWarning):
     """The view {view_id} maps, {count} containers, which is more than the limit {limit}."""
 
@@ -81,7 +81,7 @@ class NotSupportedViewContainerLimitWarning(CDFNotSupportedWarning):
     limit: int = DMS_VIEW_CONTAINER_SIZE_LIMIT
 
 
-@dataclass(frozen=True)
+@dataclass(unsafe_hash=True)
 class NotSupportedHasDataFilterLimitWarning(CDFNotSupportedWarning):
     """The view {view_id} uses a hasData filter applied to {count} containers, which is more than the limit {limit}."""