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

cognite/neat/_graph/extractors/_classic_cdf/_sequences.py

@@ -1,37 +1,251 @@
-from collections.abc import Iterable
+import itertools
+import json
+from collections.abc import Callable, Iterable, Set
 from pathlib import Path
+from typing import Any
 
 from cognite.client import CogniteClient
-from cognite.client.data_classes import Sequence, SequenceFilter, SequenceList
+from cognite.client.data_classes import Sequence, SequenceFilter
+from rdflib import RDF, XSD, Literal, Namespace, URIRef
 
-from ._base import ClassicCDFBaseExtractor, InstanceIdPrefix
+from cognite.neat._client.data_classes.neat_sequence import NeatSequence, NeatSequenceList
+from cognite.neat._shared import Triple
 
+from ._base import DEFAULT_SKIP_METADATA_VALUES, ClassicCDFBaseExtractor, InstanceIdPrefix
 
-class SequencesExtractor(ClassicCDFBaseExtractor[Sequence]):
-    """Extract data from Cognite Data Fusions Sequences into Neat."""
+
+class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
+    """Extract data from Cognite Data Fusions Sequences into Neat.
+
+    Args:
+        items (Iterable[T_CogniteResource]): An iterable of classic resource.
+        namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
+        to_type (Callable[[T_CogniteResource], str | None], optional): A function to convert an item to a type.
+            Defaults to None. If None or if the function returns None, the asset will be set to the default type.
+        total (int, optional): The total number of items to load. If passed, you will get a progress bar if rich
+            is installed. Defaults to None.
+        limit (int, optional): The maximal number of items to load. Defaults to None. This is typically used for
+            testing setup of the extractor. For example, if you are extracting 100 000 assets, you might want to
+            limit the extraction to 1000 assets to test the setup.
+        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
+            a JSON string.
+        skip_metadata_values (set[str] | frozenset[str] | None, optional): If you are unpacking metadata, then
+           values in this set will be skipped.
+        camel_case (bool, optional): Whether to use camelCase instead of snake_case for property names.
+            Defaults to True.
+        as_write (bool, optional): Whether to use the write/request format of the items. Defaults to False.
+        unpack_columns (bool, optional): Whether to unpack columns. Defaults to False.
+    """
 
     _default_rdf_type = "Sequence"
+    _column_rdf_type = "ColumnClass"
     _instance_id_prefix = InstanceIdPrefix.sequence
 
+    def __init__(
+        self,
+        items: Iterable[NeatSequence],
+        namespace: Namespace | None = None,
+        to_type: Callable[[NeatSequence], str | None] | None = None,
+        total: int | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+        unpack_columns: bool = False,
+    ):
+        super().__init__(
+            items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write
+        )
+        self.unpack_columns = unpack_columns
+
     @classmethod
-    def _from_dataset(cls, client: CogniteClient, data_set_external_id: str) -> tuple[int | None, Iterable[Sequence]]:
+    def from_dataset(
+        cls,
+        client: CogniteClient,
+        data_set_external_id: str,
+        namespace: Namespace | None = None,
+        to_type: Callable[[NeatSequence], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+        unpack_columns: bool = False,
+    ):
+        total, items = cls._from_dataset(client, data_set_external_id)
+        return cls(
+            items,
+            namespace,
+            to_type,
+            total,
+            limit,
+            unpack_metadata,
+            skip_metadata_values,
+            camel_case,
+            as_write,
+            unpack_columns,
+        )
+
+    @classmethod
+    def from_hierarchy(
+        cls,
+        client: CogniteClient,
+        root_asset_external_id: str,
+        namespace: Namespace | None = None,
+        to_type: Callable[[NeatSequence], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+        unpack_columns: bool = False,
+    ):
+        total, items = cls._from_hierarchy(client, root_asset_external_id)
+        return cls(
+            items,
+            namespace,
+            to_type,
+            total,
+            limit,
+            unpack_metadata,
+            skip_metadata_values,
+            camel_case,
+            as_write,
+            unpack_columns,
+        )
+
+    @classmethod
+    def from_file(
+        cls,
+        file_path: str | Path,
+        namespace: Namespace | None = None,
+        to_type: Callable[[NeatSequence], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+        unpack_columns: bool = False,
+    ):
+        total, items = cls._from_file(file_path)
+        return cls(
+            items,
+            namespace,
+            to_type,
+            total,
+            limit,
+            unpack_metadata,
+            skip_metadata_values,
+            camel_case,
+            as_write,
+            unpack_columns,
+        )
+
+    @classmethod
+    def _from_dataset(
+        cls, client: CogniteClient, data_set_external_id: str
+    ) -> tuple[int | None, Iterable[NeatSequence]]:
         total = client.sequences.aggregate_count(
             filter=SequenceFilter(data_set_ids=[{"externalId": data_set_external_id}])
         )
         items = client.sequences(data_set_external_ids=data_set_external_id)
-        return total, items
+        return total, cls._lookup_rows(items, client)
 
     @classmethod
     def _from_hierarchy(
         cls, client: CogniteClient, root_asset_external_id: str
-    ) -> tuple[int | None, Iterable[Sequence]]:
+    ) -> tuple[int | None, Iterable[NeatSequence]]:
         total = client.sequences.aggregate_count(
             filter=SequenceFilter(asset_subtree_ids=[{"externalId": root_asset_external_id}])
         )
         items = client.sequences(asset_subtree_external_ids=[root_asset_external_id])
-        return total, items
+        return total, cls._lookup_rows(items, client)
 
     @classmethod
-    def _from_file(cls, file_path: str | Path) -> tuple[int | None, Iterable[Sequence]]:
-        sequences = SequenceList.load(Path(file_path).read_text())
+    def _from_file(cls, file_path: str | Path) -> tuple[int | None, Iterable[NeatSequence]]:
+        sequences = NeatSequenceList.load(Path(file_path).read_text())
         return len(sequences), sequences
+
+    @classmethod
+    def _lookup_rows(cls, sequence_iterable: Iterable[Sequence], client: CogniteClient) -> Iterable[NeatSequence]:
+        iterator = iter(sequence_iterable)
+        for sequences in iter(lambda: list(itertools.islice(iterator, client.config.max_workers)), []):
+            # The PySDK uses max_workers to limit the number of requests made in parallel.
+            # We can only get one set of sequence rows per request, so we chunk the sequences up into groups of
+            # max_workers and then make a request to get all the rows for those sequences in one go.
+            sequence_list = list(sequences)
+            row_list = client.sequences.rows.retrieve(id=[seq.id for seq in sequence_list])
+            rows_by_sequence_id = {row.id: row.rows for row in row_list}
+            for seq in sequence_list:
+                yield NeatSequence.from_cognite_sequence(seq, rows_by_sequence_id.get(seq.id))
+
+    def _item2triples_special_cases(self, id_: URIRef, dumped: dict[str, Any]) -> list[Triple]:
+        """For sequences, columns and rows are special cases.'"""
+        if self.unpack_columns:
+            return self._unpack_columns(id_, dumped)
+        else:
+            return self._default_columns_and_rows(id_, dumped)
+
+    def _default_columns_and_rows(self, id_: URIRef, dumped: dict[str, Any]) -> list[Triple]:
+        triples: list[Triple] = []
+        if "columns" in dumped:
+            columns = dumped.pop("columns")
+            triples.extend(
+                [
+                    (
+                        id_,
+                        self.namespace.columns,
+                        # Rows have a rowNumber, so we introduce colNumber here to be consistent.
+                        Literal(json.dumps({"colNumber": no, **col}), datatype=XSD._NS["json"]),
+                    )
+                    for no, col in enumerate(columns, 1)
+                ]
+            )
+        if "rows" in dumped:
+            rows = dumped.pop("rows")
+            triples.extend(
+                [(id_, self.namespace.rows, Literal(json.dumps(row), datatype=XSD._NS["json"])) for row in rows]
+            )
+        return triples
+
+    def _unpack_columns(self, id_: URIRef, dumped: dict[str, Any]) -> list[Triple]:
+        triples: list[Triple] = []
+        columnValueTypes: list[str] = []
+        column_order: list[str] = []
+        if columns := dumped.pop("columns", None):
+            for col in columns:
+                external_id = col.pop("externalId")
+                column_order.append(external_id)
+                value_type = col.pop("valueType")
+                columnValueTypes.append(value_type)
+
+                col_id = self.namespace[f"Column_{external_id}"]
+                triples.append((id_, self.namespace[external_id], col_id))
+                type_ = self.namespace[self._column_rdf_type]
+                triples.append((col_id, RDF.type, type_))
+                if metadata := col.pop("metadata", None):
+                    triples.extend(self._metadata_to_triples(col_id, metadata))
+                # Should only be name and description left in col
+                for key, value in col.items():
+                    if value is None:
+                        continue
+                    triples.append((col_id, self.namespace[key], Literal(value, datatype=XSD.string)))
+
+            triples.append(
+                (id_, self.namespace.columnOrder, Literal(json.dumps(column_order), datatype=XSD._NS["json"]))
+            )
+            triples.append(
+                (id_, self.namespace.columnValueTypes, Literal(json.dumps(columnValueTypes), datatype=XSD._NS["json"]))
+            )
+        if rows := dumped.pop("rows", None):
+            values_by_column: list[list[Any]] = [[] for _ in column_order]
+            for row in rows:
+                for i, value in enumerate(row["values"]):
+                    values_by_column[i].append(value)
+            for col_name, values in zip(column_order, values_by_column, strict=False):
+                triples.append(
+                    (id_, self.namespace[f"{col_name}Values"], Literal(json.dumps(values), datatype=XSD._NS["json"]))
+                )
+
+        return triples

cognite/neat/_graph/extractors/_mock_graph_generator.py

@@ -183,7 +183,7 @@ def _get_generation_order(
     parent_col: str = "source_class",
     child_col: str = "target_class",
 ) -> dict:
-    parent_child_list: list[list[str]] = class_linkage[[parent_col, child_col]].values.tolist()
+    parent_child_list: list[list[str]] = class_linkage[[parent_col, child_col]].values.tolist()  # type: ignore[assignment]
     # Build a directed graph and a list of all names that have no parent
     graph: dict[str, set] = {name: set() for tup in parent_child_list for name in tup}
     has_parent: dict[str, bool] = {name: False for tup in parent_child_list for name in tup}

cognite/neat/_graph/loaders/_rdf2dms.py

@@ -19,6 +19,7 @@ from pydantic import BaseModel, ValidationInfo, create_model, field_validator
 from rdflib import RDF, URIRef
 
 from cognite.neat._client import NeatClient
+from cognite.neat._constants import is_readonly_property
 from cognite.neat._graph._tracking import LogTracker, Tracker
 from cognite.neat._issues import IssueList, NeatIssue, NeatIssueList
 from cognite.neat._issues.errors import (
@@ -303,6 +304,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             if isinstance(prop, dm.EdgeConnection):
                 edge_by_property[prop_id] = prop_id, prop
             if isinstance(prop, dm.MappedProperty):
+                if is_readonly_property(prop.container, prop.container_property_identifier):
+                    continue
+
                 if isinstance(prop.type, dm.DirectRelation):
                     if prop.container == dm.ContainerId("cdf_cdm", "CogniteTimeSeries") and prop_id == "unit":
                         unit_properties.append(prop_id)
@@ -343,9 +347,14 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
             return value
 
-        def parse_json_string(cls, value: Any, info: ValidationInfo) -> dict:
+        def parse_json_string(cls, value: Any, info: ValidationInfo) -> dict | list:
             if isinstance(value, dict):
                 return value
+            elif isinstance(value, list):
+                try:
+                    return [json.loads(v) if isinstance(v, str) else v for v in value]
+                except json.JSONDecodeError as error:
+                    raise ValueError(f"Not valid JSON string for {info.field_name}: {value}, error {error}") from error
             elif isinstance(value, str):
                 try:
                     return json.loads(value)
@@ -401,7 +410,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             space=self.instance_space,
             external_id=identifier,
             type=(dm.DirectRelationReference(view_id.space, view_id.external_id) if type_ is not None else None),
-            sources=[dm.NodeOrEdgeData(source=view_id, properties=dict(created.model_dump().items()))],
+            sources=[
+                dm.NodeOrEdgeData(source=view_id, properties=dict(created.model_dump(exclude_unset=True).items()))
+            ],
         )
 
     def _create_edges(

cognite/neat/_graph/transformers/__init__.py

@@ -15,7 +15,7 @@ from ._prune_graph import (
     PruneTypes,
 )
 from ._rdfpath import AddSelfReferenceProperty, MakeConnectionOnExactMatch
-from ._value_type import ConvertLiteral, LiteralToEntity, SplitMultiValueProperty
+from ._value_type import ConnectionToLiteral, ConvertLiteral, LiteralToEntity, SplitMultiValueProperty
 
 __all__ = [
     "AddAssetDepth",
@@ -26,6 +26,7 @@ __all__ = [
     "AssetSequenceConnector",
     "AssetTimeSeriesConnector",
     "AttachPropertyFromTargetToSource",
+    "ConnectionToLiteral",
     "ConvertLiteral",
     "LiteralToEntity",
     "MakeConnectionOnExactMatch",
@@ -55,4 +56,5 @@ Transformers = (
     | PruneInstancesOfUnknownType
     | ConvertLiteral
     | LiteralToEntity
+    | ConnectionToLiteral
 )

cognite/neat/_graph/transformers/_classic_cdf.py

@@ -375,7 +375,8 @@ WHERE {{
     ) -> list[Triple]:
         relationship_triples = cast(list[Triple], list(graph.query(f"DESCRIBE <{relationship_id}>")))
         object_by_predicates = cast(
-            dict[str, URIRef | Literal], {remove_namespace_from_uri(row[1]): row[2] for row in relationship_triples}
+            dict[str, URIRef | Literal],
+            {remove_namespace_from_uri(row[1]): row[2] for row in relationship_triples if row[1] != RDF.type},
         )
         source_external_id = cast(URIRef, object_by_predicates["sourceExternalId"])
         target_source_id = cast(URIRef, object_by_predicates["targetExternalId"])

cognite/neat/_graph/transformers/_value_type.py

@@ -223,3 +223,75 @@ class LiteralToEntity(BaseTransformerStandardised):
         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

@@ -425,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(
@@ -505,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

@@ -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}"""

cognite/neat/_rules/exporters/_rules2dms.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Generic, Literal
 
+from cognite.client import data_modeling as dm
 from cognite.client.data_classes._base import (
     T_CogniteResourceList,
     T_WritableCogniteResource,
@@ -19,7 +20,7 @@ from cognite.client.exceptions import CogniteAPIError
 
 from cognite.neat._client import DataModelingLoader, NeatClient
 from cognite.neat._client._api.data_modeling_loaders import MultiCogniteAPIError, T_WritableCogniteResourceList
-from cognite.neat._client.data_classes.data_modeling import Component
+from cognite.neat._client.data_classes.data_modeling import Component, ViewApplyDict
 from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.warnings import (
@@ -199,6 +200,10 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
     ) -> Iterable[UploadResult]:
         schema = self.export(rules)
 
+        # The CDF UI does not deal well with a child view overwriting a parent property with the same name
+        # This is a workaround to remove the duplicated properties
+        self._remove_duplicated_properties(schema.views, client)
+
         categorized_items_by_loader = self._categorize_by_loader(client, schema)
 
         is_failing = self.existing == "fail" and any(
@@ -376,3 +381,32 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 for data_model in data_models
                 if (data_model.space, data_model.external_id) != (space, external_id)
             ]
+
+    @staticmethod
+    def _remove_duplicated_properties(views: ViewApplyDict, client: NeatClient) -> None:
+        parent_view_ids = {parent for view in views.values() for parent in view.implements}
+        parent_view_list = client.data_modeling.views.retrieve(
+            list(parent_view_ids), include_inherited_properties=False
+        )
+        parent_view_by_id = {view.as_id(): view.as_write() for view in parent_view_list}
+        for view in views.values():
+            if view.implements is None:
+                continue
+            for parent_id in view.implements:
+                if not (parent_view := parent_view_by_id.get(parent_id)):
+                    continue
+                for shared_prop_id in set(view.properties or {}) & set(parent_view.properties or {}):
+                    if view.properties is None or parent_view.properties is None:
+                        continue
+                    prop = view.properties[shared_prop_id]
+                    parent_prop = parent_view.properties[shared_prop_id]
+                    if (
+                        isinstance(prop, dm.MappedPropertyApply)
+                        and isinstance(parent_prop, dm.MappedPropertyApply)
+                        and (
+                            prop.container_property_identifier == parent_prop.container_property_identifier
+                            and prop.container == parent_prop.container
+                            and prop.source == parent_prop.source
+                        )
+                    ):
+                        view.properties.pop(shared_prop_id)

cognite/neat/_rules/exporters/_rules2excel.py

@@ -229,8 +229,8 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                 if isinstance(selected_column, MergedCell):
                     selected_column = column_cells[1]
 
-                current = sheet.column_dimensions[selected_column.column_letter].width or (max_length + 0.5)
-                sheet.column_dimensions[selected_column.column_letter].width = min(
+                current = sheet.column_dimensions[selected_column.column_letter].width or (max_length + 0.5)  # type: ignore[union-attr]
+                sheet.column_dimensions[selected_column.column_letter].width = min(  # type: ignore[union-attr]
                     max(current, max_length + 0.5), MAX_COLUMN_WIDTH
                 )
         return None