cognite-neat 0.103.1__py3-none-any.whl → 0.105.0__py3-none-any.whl

cognite/neat/_graph/transformers/_value_type.py

@@ -5,17 +5,18 @@ from urllib.parse import quote
 
 import rdflib
 from rdflib import RDF, XSD, Graph, Namespace, URIRef
+from rdflib.query import ResultRow
 
 from cognite.neat._constants import UNKNOWN_TYPE
 from cognite.neat._graph.queries import Queries
-from cognite.neat._issues.warnings import NeatValueWarning, PropertyDataTypeConversionWarning
+from cognite.neat._issues.warnings import PropertyDataTypeConversionWarning
 from cognite.neat._utils.auxiliary import string_to_ideal_type
-from cognite.neat._utils.collection_ import iterate_progress_bar
 from cognite.neat._utils.rdf_ import get_namespace, remove_namespace_from_uri
 
-from ._base import BaseTransformer
+from ._base import BaseTransformer, BaseTransformerStandardised, RowTransformationOutput
 
 
+# TODO: Standardise
 class SplitMultiValueProperty(BaseTransformer):
     description: str = (
         "SplitMultiValueProperty is a transformer that splits a "
@@ -75,34 +76,11 @@ class SplitMultiValueProperty(BaseTransformer):
                     graph.add((s, new_property, o))
 
 
-class ConvertLiteral(BaseTransformer):
+class ConvertLiteral(BaseTransformerStandardised):
     description: str = "ConvertLiteral is a transformer that improve data typing of a literal value."
     _use_only_once: bool = False
     _need_changes = frozenset({})
 
-    _count_by_properties = """SELECT (COUNT(?value) AS ?valueCount)
-    WHERE {{
-      ?instance a <{subject_type}> .
-      ?instance <{subject_predicate}> ?value
-       FILTER(isLiteral(?value))
-    }}"""
-
-    _count_by_properties_uri = """SELECT (COUNT(?value) AS ?valueCount)
-        WHERE {{
-          ?instance a <{subject_type}> .
-          ?instance <{subject_predicate}> ?value
-           FILTER(isIRI(?value))
-        }}"""
-
-    _properties = """SELECT ?instance ?value
-    WHERE {{
-      ?instance a <{subject_type}> .
-      ?instance <{subject_predicate}> ?value
-
-      FILTER(isLiteral(?value))
-
-    }}"""
-
     def __init__(
         self,
         subject_type: URIRef,
@@ -115,89 +93,55 @@ class ConvertLiteral(BaseTransformer):
         self._type_name = remove_namespace_from_uri(subject_type)
         self._property_name = remove_namespace_from_uri(subject_predicate)
 
-    def transform(self, graph: Graph) -> None:
-        count_connection_query = self._count_by_properties_uri.format(
-            subject_type=self.subject_type, subject_predicate=self.subject_predicate
-        )
-        connection_count_res = list(graph.query(count_connection_query))
-        connection_count = int(connection_count_res[0][0])  # type: ignore [index, arg-type]
-
-        if connection_count > 0:
+    def _skip_count_query(self) -> str:
+        query = """SELECT (COUNT(?value) AS ?valueCount)
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?value
+                       FILTER(isIRI(?value))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _count_query(self) -> str:
+        query = """SELECT (COUNT(?value) AS ?valueCount)
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?value
+                       FILTER(isLiteral(?value))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _iterate_query(self) -> str:
+        query = """SELECT ?instance ?value
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?value
+                      FILTER(isLiteral(?value))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+
+        instance, literal = query_result_row
+        value = cast(rdflib.Literal, literal).toPython()
+
+        try:
+            converted_value = self.conversion(value)
+        except Exception as e:
             warnings.warn(
-                NeatValueWarning(
-                    f"Skipping {connection_count} of {self._type_name}.{self._property_name} "
-                    f"as these are connections and not data values."
-                ),
+                PropertyDataTypeConversionWarning(str(instance), self._type_name, self._property_name, str(e)),
                 stacklevel=2,
             )
+        row_output.add_triples.append((instance, self.subject_predicate, rdflib.Literal(converted_value)))  # type: ignore[arg-type]
+        row_output.remove_triples.append((instance, self.subject_predicate, literal))  # type: ignore[arg-type]
+        row_output.instances_modified_count += 1
 
-        count_query = self._count_by_properties.format(
-            subject_type=self.subject_type, subject_predicate=self.subject_predicate
-        )
-
-        property_count_res = list(graph.query(count_query))
-        property_count = int(property_count_res[0][0])  # type: ignore [index, arg-type]
-        iterate_query = self._properties.format(
-            subject_type=self.subject_type, subject_predicate=self.subject_predicate
-        )
-
-        for instance, literal in iterate_progress_bar(  # type: ignore[misc]
-            graph.query(iterate_query),
-            total=property_count,
-            description=f"Converting {self._type_name}.{self._property_name}.",
-        ):
-            value = cast(rdflib.Literal, literal).toPython()
-            try:
-                converted_value = self.conversion(value)
-            except Exception as e:
-                warnings.warn(
-                    PropertyDataTypeConversionWarning(str(instance), self._type_name, self._property_name, str(e)),
-                    stacklevel=2,
-                )
-                continue
-
-            graph.add((instance, self.subject_predicate, rdflib.Literal(converted_value)))
-            graph.remove((instance, self.subject_predicate, literal))
-
-
-class LiteralToEntity(BaseTransformer):
-    description = "Converts a literal value to new entity"
+        return row_output
 
-    _count_properties_of_type = """SELECT (COUNT(?property) AS ?propertyCount)
-    WHERE {{
-      ?instance a <{subject_type}> .
-      ?instance <{subject_predicate}> ?property
-      FILTER(isLiteral(?property))
-    }}"""
-    _count_connections_of_type = """SELECT (COUNT(?property) AS ?propertyCount)
-    WHERE {{
-      ?instance a <{subject_type}> .
-      ?instance <{subject_predicate}> ?property
-      FILTER(isIRI(?property))
-    }}"""
-
-    _properties_of_type = """SELECT ?instance ?property
-    WHERE {{
-      ?instance a <{subject_type}> .
-      ?instance <{subject_predicate}> ?property
-      FILTER(isLiteral(?property))
-    }}"""
-
-    _count_properties = """SELECT (COUNT(?property) AS ?propertyCount)
-    WHERE {{
-      ?instance <{subject_predicate}> ?property
-      FILTER(isLiteral(?property))
-    }}"""
-    _count_connections = """SELECT (COUNT(?property) AS ?propertyCount)
-        WHERE {{
-          ?instance <{subject_predicate}> ?property
-          FILTER(isIRI(?property))
-        }}"""
-    _properties = """SELECT ?instance ?property
-    WHERE {{
-      ?instance <{subject_predicate}> ?property
-      FILTER(isLiteral(?property))
-    }}"""
+
+class LiteralToEntity(BaseTransformerStandardised):
+    description = "Converts a literal value to new entity"
 
     def __init__(
         self, subject_type: URIRef | None, subject_predicate: URIRef, entity_type: str, new_property: str | None = None
@@ -207,54 +151,147 @@ class LiteralToEntity(BaseTransformer):
         self.entity_type = entity_type
         self.new_property = new_property
 
-    def transform(self, graph: Graph) -> None:
+    def _iterate_query(self) -> str:
         if self.subject_type is None:
-            count_query = self._count_properties.format(subject_predicate=self.subject_predicate)
-            iterate_query = self._properties.format(subject_predicate=self.subject_predicate)
-            connection_count_query = self._count_connections.format(subject_predicate=self.subject_predicate)
+            query = """SELECT ?instance ?property
+            WHERE {{
+              ?instance <{subject_predicate}> ?property
+              FILTER(isLiteral(?property))
+            }}"""
+            return query.format(subject_predicate=self.subject_predicate)
         else:
-            count_query = self._count_properties_of_type.format(
-                subject_type=self.subject_type, subject_predicate=self.subject_predicate
-            )
-            iterate_query = self._properties_of_type.format(
-                subject_type=self.subject_type, subject_predicate=self.subject_predicate
-            )
-            connection_count_query = self._count_connections_of_type.format(
-                subject_type=self.subject_type, subject_predicate=self.subject_predicate
-            )
+            query = """SELECT ?instance ?property
+                WHERE {{
+                  ?instance a <{subject_type}> .
+                  ?instance <{subject_predicate}> ?property
+                  FILTER(isLiteral(?property))
+                }}"""
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _skip_count_query(self) -> str:
+        if self.subject_type is None:
+            query = """SELECT (COUNT(?property) AS ?propertyCount)
+                        WHERE {{
+                          ?instance <{subject_predicate}> ?property
+                          FILTER(isIRI(?property))
+                        }}"""
+            return query.format(subject_predicate=self.subject_predicate)
+        else:
+            query = """SELECT (COUNT(?property) AS ?propertyCount)
+                        WHERE {{
+                          ?instance a <{subject_type}> .
+                          ?instance <{subject_predicate}> ?property
+                          FILTER(isIRI(?property))
+                        }}"""
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _count_query(self) -> str:
+        if self.subject_type is None:
+            query = """SELECT (COUNT(?property) AS ?propertyCount)
+                WHERE {{
+                  ?instance <{subject_predicate}> ?property
+                  FILTER(isLiteral(?property))
+                }}"""
+            return query.format(subject_predicate=self.subject_predicate)
+        else:
+            query = """SELECT (COUNT(?property) AS ?propertyCount)
+                        WHERE {{
+                          ?instance a <{subject_type}> .
+                          ?instance <{subject_predicate}> ?property
+                          FILTER(isLiteral(?property))
+                        }}"""
 
-        connection_count_res = list(graph.query(connection_count_query))
-        connection_count = int(connection_count_res[0][0])  # type: ignore [index, arg-type]
-        if connection_count > 0:
-            warnings.warn(
-                NeatValueWarning(
-                    f"Skipping {connection_count} of {remove_namespace_from_uri(self.subject_predicate)} "
-                    f"as these are connections and not data values."
-                ),
-                stacklevel=2,
-            )
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
 
-        property_count_res = list(graph.query(count_query))
-        property_count = int(property_count_res[0][0])  # type: ignore [index, arg-type]
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
 
-        instance: URIRef
-        description = f"Creating {remove_namespace_from_uri(self.subject_predicate)}."
-        if self.subject_type is not None:
-            description = (
-                f"Creating {remove_namespace_from_uri(self.subject_type)}."
-                f"{remove_namespace_from_uri(self.subject_predicate)}."
-            )
-        for instance, literal in iterate_progress_bar(  # type: ignore[misc, assignment]
-            graph.query(iterate_query),
-            total=property_count,
-            description=description,
-        ):
-            value = cast(rdflib.Literal, literal).toPython()
-            namespace = Namespace(get_namespace(instance))
-            entity_type = namespace[self.entity_type]
-            new_entity = namespace[f"{self.entity_type}_{quote(value)!s}"]
-            graph.add((new_entity, RDF.type, entity_type))
-            if self.new_property is not None:
-                graph.add((new_entity, namespace[self.new_property], rdflib.Literal(value)))
-            graph.add((instance, self.subject_predicate, new_entity))
-            graph.remove((instance, self.subject_predicate, literal))
+        instance, literal = query_result_row
+        value = cast(rdflib.Literal, literal).toPython()
+        namespace = Namespace(get_namespace(instance))  # type: ignore[arg-type]
+        entity_type = namespace[self.entity_type]
+        new_entity = namespace[f"{self.entity_type}_{quote(value)!s}"]
+        row_output.add_triples.append((new_entity, RDF.type, entity_type))
+        row_output.instances_added_count += 1  # we add one new entity
+
+        if self.new_property is not None:
+            row_output.add_triples.append((new_entity, namespace[self.new_property], rdflib.Literal(value)))  # type: ignore[arg-type]
+            row_output.instances_modified_count += 1  # we modify the new entity
+
+        row_output.add_triples.append((instance, self.subject_predicate, new_entity))  # type: ignore[arg-type]
+        row_output.remove_triples.append((instance, self.subject_predicate, literal))  # type: ignore[arg-type]
+        row_output.instances_modified_count += 1  # we modify the old entity
+
+        return row_output
+
+
+class ConnectionToLiteral(BaseTransformerStandardised):
+    description = "Converts an entity connection to a literal value"
+
+    def __init__(self, subject_type: URIRef | None, subject_predicate: URIRef) -> None:
+        self.subject_type = subject_type
+        self.subject_predicate = subject_predicate
+
+    def _iterate_query(self) -> str:
+        if self.subject_type is None:
+            query = """SELECT ?instance ?object
+            WHERE {{
+              ?instance <{subject_predicate}> ?object
+              FILTER(isIRI(?object))
+            }}"""
+            return query.format(subject_predicate=self.subject_predicate)
+        else:
+            query = """SELECT ?instance ?object
+                WHERE {{
+                  ?instance a <{subject_type}> .
+                  ?instance <{subject_predicate}> ?object
+                  FILTER(isIRI(?object))
+                }}"""
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _skip_count_query(self) -> str:
+        if self.subject_type is None:
+            query = """SELECT (COUNT(?object) AS ?objectCount)
+                        WHERE {{
+                          ?instance <{subject_predicate}> ?object
+                          FILTER(isLiteral(?object))
+                        }}"""
+            return query.format(subject_predicate=self.subject_predicate)
+        else:
+            query = """SELECT (COUNT(?object) AS ?objectCount)
+                        WHERE {{
+                          ?instance a <{subject_type}> .
+                          ?instance <{subject_predicate}> ?object
+                          FILTER(isLiteral(?object))
+                        }}"""
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _count_query(self) -> str:
+        if self.subject_type is None:
+            query = """SELECT (COUNT(?object) AS ?objectCount)
+                WHERE {{
+                  ?instance <{subject_predicate}> ?object
+                  FILTER(isIRI(?object))
+                }}"""
+            return query.format(subject_predicate=self.subject_predicate)
+        else:
+            query = """SELECT (COUNT(?object) AS ?objectCount)
+                        WHERE {{
+                          ?instance a <{subject_type}> .
+                          ?instance <{subject_predicate}> ?object
+                          FILTER(isIRI(?object))
+                        }}"""
+
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+
+        instance, object_entity = cast(tuple[URIRef, URIRef], query_result_row)
+        value = remove_namespace_from_uri(object_entity)
+
+        row_output.add_triples.append((instance, self.subject_predicate, rdflib.Literal(value)))
+        row_output.remove_triples.append((instance, self.subject_predicate, object_entity))
+        row_output.instances_modified_count += 1
+
+        return row_output

cognite/neat/_issues/__init__.py

@@ -3,7 +3,6 @@ as some helper classes to handle them like NeatIssueList"""
 
 from ._base import (
     DefaultWarning,
-    FutureResult,
     IssueList,
     MultiValueError,
     NeatError,
@@ -16,7 +15,6 @@ from ._base import (
 
 __all__ = [
     "DefaultWarning",
-    "FutureResult",
     "IssueList",
     "MultiValueError",
     "NeatError",

cognite/neat/_issues/_base.py

@@ -390,11 +390,16 @@ 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, action: str | None = None
+        self,
+        issues: Sequence[T_NeatIssue] | None = None,
+        title: str | None = None,
+        action: str | None = None,
+        hint: str | None = None,
     ):
         super().__init__(issues or [])
         self.title = title
         self.action = action
+        self.hint = hint
 
     @property
     def errors(self) -> Self:
@@ -406,6 +411,11 @@ class NeatIssueList(list, Sequence[T_NeatIssue], ABC):
         """Return True if this list contains any errors."""
         return any(isinstance(issue, NeatError) for issue in self)
 
+    @property
+    def has_warnings(self) -> bool:
+        """Return True if this list contains any warnings."""
+        return any(isinstance(issue, NeatWarning) for issue in self)
+
     @property
     def warnings(self) -> Self:
         """Return all the warnings in this list."""
@@ -415,6 +425,10 @@ class NeatIssueList(list, Sequence[T_NeatIssue], ABC):
         """Return True if this list contains any errors of the given type."""
         return any(isinstance(issue, error_type) for issue in self)
 
+    def has_warning_type(self, warning_type: type[NeatWarning]) -> bool:
+        """Return True if this list contains any warnings of the given type."""
+        return any(isinstance(issue, warning_type) for issue in self)
+
     def as_errors(self, operation: str = "Operation failed") -> ExceptionGroup:
         """Return an ExceptionGroup with all the errors in this list."""
         return ExceptionGroup(
@@ -455,14 +469,31 @@ 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>"
-        df = self.to_pandas()
-        agg_df = df["NeatIssue"].value_counts().to_frame()
-        if len(agg_df) < 10:
-            return agg_df._repr_html_()  # type: ignore[operator]
+        if self.action and not self:
+            header = f"Success: {self.action}"
+        elif self.action and self.has_errors:
+            header = f"Failed: {self.action}"
+        elif self.action and self.has_warnings:
+            header = f"Succeeded with warnings: {self.action}"
+        elif not self:
+            header = "No issues found"
         else:
-            return agg_df.head()._repr_html_()  # type: ignore[operator]
+            header = ""
+
+        body = f"<p>{header}</p>"
+
+        if self:
+            df = self.to_pandas()
+            agg_df = df["NeatIssue"].value_counts().to_frame()
+            if len(agg_df) < 10:
+                table = agg_df._repr_html_()  # type: ignore[operator]
+            else:
+                table = agg_df.head()._repr_html_()  # type: ignore[operator]
+            body += f"<br />{table}"
+
+            if self.hint:
+                body += f"<br />Hint: {self.hint}"
+        return body
 
 
 T_Cls = TypeVar("T_Cls")
@@ -478,55 +509,35 @@ def _get_subclasses(cls_: type[T_Cls], include_base: bool = False) -> Iterable[t
 
 
 @contextmanager
-def catch_warnings(
-    issues: IssueList | None = None,
-    warning_cls: type[NeatWarning] = DefaultWarning,
-) -> Iterator[None]:
+def catch_warnings() -> Iterator[IssueList]:
     """Catch warnings and append them to the issues list."""
+    issues = IssueList()
     with warnings.catch_warnings(record=True) as warning_logger:
         warnings.simplefilter("always")
         try:
-            yield None
+            yield issues
         finally:
-            if warning_logger and issues is not None:
-                issues.extend([warning_cls.from_warning(warning) for warning in warning_logger])  # type: ignore[misc]
-
-
-class FutureResult:
-    def __init__(self) -> None:
-        self._result: Literal["success", "failure", "pending"] = "pending"
-
-    @property
-    def result(self) -> Literal["success", "failure", "pending"]:
-        return self._result
+            if warning_logger:
+                issues.extend([NeatWarning.from_warning(warning) for warning in warning_logger])  # type: ignore[misc]
 
 
 @contextmanager
-def catch_issues(
-    issues: IssueList,
-    error_cls: type[NeatError] = NeatError,
-    warning_cls: type[NeatWarning] = NeatWarning,
-    error_args: dict[str, Any] | None = None,
-) -> Iterator[FutureResult]:
+def catch_issues(error_args: dict[str, Any] | None = None) -> Iterator[IssueList]:
     """This is an internal help function to handle issues and warnings.
 
     Args:
-        issues: The issues list to append to.
-        error_cls: The class used to convert errors to issues.
-        warning_cls:  The class used to convert warnings to issues.
+        error_args: Additional arguments to pass to the error class. The only use case as of (2025-01-03) is to pass
+            the read_info_by_sheet to the error class such that the row numbers can be adjusted to match the source
+            spreadsheet.
 
     Returns:
-        FutureResult: A future result object that can be used to check the result of the context manager.
+        IssueList: The list of issues.
+
     """
-    with catch_warnings(issues, warning_cls):
-        future_result = FutureResult()
+    with catch_warnings() as issues:
         try:
-            yield future_result
+            yield issues
         except ValidationError as e:
-            issues.extend(error_cls.from_errors(e.errors(), **(error_args or {})))  # type: ignore[arg-type]
-            future_result._result = "failure"
+            issues.extend(NeatError.from_errors(e.errors(), **(error_args or {})))  # type: ignore[arg-type]
         except (NeatError, MultiValueError) as e:
-            issues.extend(error_cls.from_errors([e], **(error_args or {})))  # type: ignore[arg-type, list-item]
-            future_result._result = "failure"
-        else:
-            future_result._result = "success"
+            issues.extend(NeatError.from_errors([e], **(error_args or {})))  # type: ignore[arg-type, list-item]

cognite/neat/_issues/warnings/__init__.py

@@ -13,7 +13,7 @@ from ._external import (
     FileReadWarning,
     FileTypeUnexpectedWarning,
 )
-from ._general import NeatValueWarning, NotSupportedWarning, RegexViolationWarning
+from ._general import MissingCogniteClientWarning, NeatValueWarning, NotSupportedWarning, RegexViolationWarning
 from ._models import (
     BreakingModelingPrincipleWarning,
     CDFNotSupportedWarning,
@@ -41,6 +41,7 @@ from ._resources import (
     ResourceRetrievalWarning,
     ResourcesDuplicatedWarning,
     ResourceTypeNotSupportedWarning,
+    ResourceUnknownWarning,
 )
 
 __all__ = [
@@ -53,6 +54,7 @@ __all__ = [
     "FileMissingRequiredFieldWarning",
     "FileReadWarning",
     "FileTypeUnexpectedWarning",
+    "MissingCogniteClientWarning",
     "NeatValueWarning",
     "NotSupportedHasDataFilterLimitWarning",
     "NotSupportedViewContainerLimitWarning",
@@ -73,6 +75,7 @@ __all__ = [
     "ResourceRegexViolationWarning",
     "ResourceRetrievalWarning",
     "ResourceTypeNotSupportedWarning",
+    "ResourceUnknownWarning",
     "ResourcesDuplicatedWarning",
     "UndefinedViewWarning",
     "UserModelingWarning",

cognite/neat/_issues/warnings/_general.py

@@ -27,3 +27,10 @@ class RegexViolationWarning(NeatWarning):
     identifier: str
     pattern_name: str
     motivation: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class MissingCogniteClientWarning(NeatWarning):
+    """Missing Cognite Client required for {functionality}"""
+
+    functionality: str

cognite/neat/_issues/warnings/_resources.py

@@ -21,7 +21,7 @@ class ResourceRegexViolationWarning(ResourceNeatWarning):
 
     fix = (
         "Either export the data model and make the necessary changes manually"
-        " or run prepare.cdf_compliant_external_ids."
+        " or run prepare.data_model.cdf_compliant_external_ids."
     )
 
     location: str
@@ -39,6 +39,17 @@ class ResourceNotFoundWarning(ResourceNeatWarning, Generic[T_Identifier, T_Refer
     referred_type: str
 
 
+@dataclass(unsafe_hash=True)
+class ResourceUnknownWarning(ResourceNeatWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} with identifier {identifier} referred by {referred_type} {referred_by} is unknown.
+    Will continue, but the model is incomplete."""
+
+    referred_by: T_ReferenceIdentifier
+    referred_type: str
+
+    fix = "You can maybe retrieve the resource from the CDF."
+
+
 @dataclass(unsafe_hash=True)
 class ResourceNotDefinedWarning(ResourceNeatWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
     """The {resource_type} {identifier} is not defined in the {location}"""