cognite-neat 0.87.3__tar.gz → 0.87.6__tar.gz

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/PKG-INFO

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

cognite_neat-0.87.6/cognite/neat/_version.py

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

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/app/api/routers/rules.py

@@ -166,7 +166,7 @@ def get_original_rules_from_workflow(workflow_name: str):
         return {"error": f"Workflow {workflow_name} is not found"}
     context = workflow.get_context()
     rules_data = context["RulesData"]
-    if type(rules_data) != RulesData:
+    if type(rules_data) is not RulesData:
         return {"error": "RulesData is not found in workflow context"}
 
     return Response(content=rules_data.rules.model_dump_json(), media_type="application/json")

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/graph/extractors/_classic_cdf/_assets.py

@@ -30,6 +30,8 @@ class AssetsExtractor(BaseExtractor):
             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): A set of values to skip when unpacking
+            metadata. Defaults to frozenset({"nan", "null", "none", ""}).
     """
 
     _SPACE_PATTERN = re.compile(r"\s+")
@@ -42,6 +44,7 @@ class AssetsExtractor(BaseExtractor):
         total: int | None = None,
         limit: int | None = None,
         unpack_metadata: bool = True,
+        skip_metadata_values: set[str] | frozenset[str] | None = frozenset({"nan", "null", "none", ""}),
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.assets = assets
@@ -49,6 +52,7 @@ class AssetsExtractor(BaseExtractor):
         self.total = total
         self.limit = min(limit, total) if limit and total else limit
         self.unpack_metadata = unpack_metadata
+        self.skip_metadata_values = skip_metadata_values
 
     @classmethod
     def from_dataset(
@@ -162,7 +166,7 @@ class AssetsExtractor(BaseExtractor):
         if asset.source:
             triples.append((id_, self.namespace.source, Literal(asset.source)))
 
-        # properties ref creation and update
+        # properties' ref creation and update
         triples.append(
             (
                 id_,
@@ -193,7 +197,9 @@ class AssetsExtractor(BaseExtractor):
         if asset.metadata:
             if self.unpack_metadata:
                 for key, value in asset.metadata.items():
-                    if value:
+                    if value and (
+                        self.skip_metadata_values is None or value.casefold() not in self.skip_metadata_values
+                    ):
                         triples.append(
                             (
                                 id_,

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/graph/extractors/_mock_graph_generator.py

@@ -250,9 +250,9 @@ def _generate_mock_data_property_triples(
     python_type = value_type.python
     triples = []
     for id_ in instance_ids:
-        if python_type == int:
+        if python_type is int:
             triples.append((id_, URIRef(namespace[property_]), Literal(random.randint(1, 1983))))
-        elif python_type == float:
+        elif python_type is float:
             triples.append((id_, URIRef(namespace[property_]), Literal(numpy.float32(random.uniform(1, 1983)))))
         # generate string
         else:

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/graph/loaders/_base.py

@@ -48,18 +48,23 @@ class BaseLoader(ABC, Generic[T_Output]):
 class CDFLoader(BaseLoader[T_Output]):
     _UPLOAD_BATCH_SIZE: ClassVar[int] = 1000
 
-    def load_into_cdf(self, client: CogniteClient, dry_run: bool = False) -> UploadResultList:
-        return UploadResultList(self.load_into_cdf_iterable(client, dry_run))
-
-    def load_into_cdf_iterable(self, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadResult]:
-        missing_capabilities = client.iam.verify_capabilities(self._get_required_capabilities())
-        if missing_capabilities:
-            upload_result = UploadResult[Hashable](name=type(self).__name__)
-            upload_result.issues.append(
-                FailedAuthorizationError(action="Upload to CDF", reason=str(missing_capabilities))
-            )
-            yield upload_result
-            return
+    def load_into_cdf(
+        self, client: CogniteClient, dry_run: bool = False, check_client: bool = True
+    ) -> UploadResultList:
+        return UploadResultList(self.load_into_cdf_iterable(client, dry_run, check_client))
+
+    def load_into_cdf_iterable(
+        self, client: CogniteClient, dry_run: bool = False, check_client: bool = True
+    ) -> Iterable[UploadResult]:
+        if check_client:
+            missing_capabilities = client.iam.verify_capabilities(self._get_required_capabilities())
+            if missing_capabilities:
+                upload_result = UploadResult[Hashable](name=type(self).__name__)
+                upload_result.issues.append(
+                    FailedAuthorizationError(action="Upload to CDF", reason=str(missing_capabilities))
+                )
+                yield upload_result
+                return
 
         issues = NeatIssueList[NeatIssue]()
         items: list[T_Output] = []

cognite_neat-0.87.6/cognite/neat/graph/loaders/_rdf2asset.py

@@ -0,0 +1,418 @@
+import json
+from collections.abc import Iterable, Sequence
+from pathlib import Path
+from typing import Any, cast
+
+import yaml
+from cognite.client import CogniteClient
+from cognite.client.data_classes import (
+    AssetWrite,
+    LabelDefinitionWrite,
+    RelationshipWrite,
+)
+from cognite.client.data_classes.capabilities import (
+    AssetsAcl,
+    Capability,
+    RelationshipsAcl,
+)
+from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError
+
+from cognite.neat.graph._tracking.base import Tracker
+from cognite.neat.graph._tracking.log import LogTracker
+from cognite.neat.graph.issues import loader as loader_issues
+from cognite.neat.graph.stores import NeatGraphStore
+from cognite.neat.issues import NeatIssue, NeatIssueList
+from cognite.neat.rules.analysis._asset import AssetAnalysis
+from cognite.neat.rules.models import AssetRules
+from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
+from cognite.neat.utils.auxiliary import create_sha256_hash
+from cognite.neat.utils.upload import UploadResult
+
+from ._base import _END_OF_CLASS, CDFLoader
+
+
+class AssetLoader(CDFLoader[AssetWrite]):
+    """Load Assets and their relationships from NeatGraph to Cognite Data Fusions.
+
+    Args:
+        graph_store (NeatGraphStore): The graph store to load the data into.
+        rules (AssetRules): The rules to load the assets with.
+        data_set_id (int): The CDF data set id to load the Assets into.
+        use_orphanage (bool): Whether to use an orphanage for assets that are not part
+                              of the hierarchy. Defaults to False.
+        use_labels (bool): Whether to use labels for assets. Defaults to False.
+        external_id_prefix (str | None): The prefix to use for the external ids. Defaults to None.
+        create_issues (Sequence[NeatIssue] | None): A list of issues that occurred during reading. Defaults to None.
+        tracker (type[Tracker] | None): The tracker to use. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        graph_store: NeatGraphStore,
+        rules: AssetRules,
+        data_set_id: int,
+        use_orphanage: bool = False,
+        use_labels: bool = False,
+        external_id_prefix: str | None = None,
+        create_issues: Sequence[NeatIssue] | None = None,
+        tracker: type[Tracker] | None = None,
+    ):
+        super().__init__(graph_store)
+
+        self.rules = rules
+        self.data_set_id = data_set_id
+
+        self.use_labels = use_labels
+
+        self.orphanage = (
+            AssetWrite.load(
+                {
+                    "dataSetId": self.data_set_id,
+                    "externalId": (f"{external_id_prefix or ''}orphanage-{data_set_id}" if use_orphanage else None),
+                    "name": "Orphanage",
+                    "description": "Orphanage for assets whose parents do not exist",
+                }
+            )
+            if use_orphanage
+            else None
+        )
+
+        self.external_id_prefix = external_id_prefix
+
+        self.processed_assets: set[str] = set()
+        self._issues = NeatIssueList[NeatIssue](create_issues or [])
+        self._tracker: type[Tracker] = tracker or LogTracker
+
+    def _load(self, stop_on_exception: bool = False) -> Iterable[AssetWrite | NeatIssue | type[_END_OF_CLASS]]:
+        if self._issues.has_errors and stop_on_exception:
+            raise self._issues.as_exception()
+        elif self._issues.has_errors:
+            yield from self._issues
+            return
+        if not self.rules:
+            # There should already be an error in this case.
+            return
+
+        ordered_classes = AssetAnalysis(self.rules).class_topological_sort()
+
+        tracker = self._tracker(
+            type(self).__name__,
+            [repr(class_.id) for class_ in ordered_classes],
+            "classes",
+        )
+
+        if self.use_labels:
+            yield from self._create_labels()
+
+        if self.orphanage:
+            yield self.orphanage
+            self.processed_assets.add(cast(str, self.orphanage.external_id))
+
+        yield from self._create_assets(ordered_classes, tracker, stop_on_exception)
+        yield from self._create_relationship(ordered_classes, tracker, stop_on_exception)
+
+    def _create_labels(self) -> Iterable[Any]:
+        for label in AssetAnalysis(self.rules).define_labels():
+            yield LabelDefinitionWrite(name=label, external_id=label, data_set_id=self.data_set_id)
+        yield _END_OF_CLASS
+
+    def _create_assets(
+        self,
+        ordered_classes: list[ClassEntity],
+        tracker: Tracker,
+        stop_on_exception: bool,
+    ) -> Iterable[Any]:
+        for class_ in ordered_classes:
+            tracker.start(repr(class_.id))
+
+            property_renaming_config = AssetAnalysis(self.rules).define_asset_property_renaming_config(class_)
+
+            for identifier, properties in self.graph_store.read(class_.suffix):
+                identifier = f"{self.external_id_prefix or ''}{identifier}"
+
+                fields = _process_asset_properties(properties, property_renaming_config)
+                # set data set id and external id
+                fields["dataSetId"] = self.data_set_id
+                fields["externalId"] = identifier
+
+                if self.use_labels:
+                    fields["labels"] = [class_.suffix]
+
+                if parent_external_id := fields.get("parentExternalId", None):
+                    fields["parentExternalId"] = f"{self.external_id_prefix or ''}{parent_external_id}"
+
+                # check on parent
+                if "parentExternalId" in fields and fields["parentExternalId"] not in self.processed_assets:
+                    error = loader_issues.InvalidInstanceError(
+                        type_=EntityTypes.asset,
+                        identifier=identifier,
+                        reason=(
+                            f"Parent asset {fields['parentExternalId']} does not exist or failed creation"
+                            f""" {
+                                f', moving the asset {identifier} under orphanage {self.orphanage.external_id}'
+                                if self.orphanage
+                                else ''}"""
+                        ),
+                    )
+                    tracker.issue(error)
+                    if stop_on_exception:
+                        raise error.as_exception()
+                    yield error
+
+                    # if orphanage is set asset will use orphanage as parent
+                    if self.orphanage:
+                        fields["parentExternalId"] = self.orphanage.external_id
+
+                    # otherwise asset will be skipped
+                    else:
+                        continue
+
+                try:
+                    yield AssetWrite.load(fields)
+                    self.processed_assets.add(identifier)
+                except KeyError as e:
+                    error = loader_issues.InvalidInstanceError(
+                        type_=EntityTypes.asset, identifier=identifier, reason=str(e)
+                    )
+                    tracker.issue(error)
+                    if stop_on_exception:
+                        raise error.as_exception() from e
+                    yield error
+
+            yield _END_OF_CLASS
+
+    def _create_relationship(
+        self,
+        ordered_classes: list[ClassEntity],
+        tracker: Tracker,
+        stop_on_exception: bool,
+    ) -> Iterable[Any]:
+        for class_ in ordered_classes:
+            tracker.start(repr(class_.id))
+
+            property_renaming_config = AssetAnalysis(self.rules).define_relationship_property_renaming_config(class_)
+
+            # class does not have any relationship properties
+            if not property_renaming_config:
+                continue
+
+            for source_external_id, properties in self.graph_store.read(class_.suffix):
+                relationships = _process_relationship_properties(properties, property_renaming_config)
+
+                source_external_id = f"{self.external_id_prefix or ''}{source_external_id}"
+
+                # check if source asset exists
+                if source_external_id not in self.processed_assets:
+                    error = loader_issues.InvalidInstanceError(
+                        type_=EntityTypes.relationship,
+                        identifier=source_external_id,
+                        reason=(
+                            f"Asset {source_external_id} does not exist! "
+                            "Aborting creation of relationships which use this asset as the source."
+                        ),
+                    )
+                    tracker.issue(error)
+                    if stop_on_exception:
+                        raise error.as_exception()
+                    yield error
+                    continue
+
+                for label, target_external_ids in relationships.items():
+                    # we can have 1-many relationships
+                    for target_external_id in target_external_ids:
+                        target_external_id = f"{self.external_id_prefix or ''}{target_external_id}"
+                        # check if source asset exists
+                        if target_external_id not in self.processed_assets:
+                            error = loader_issues.InvalidInstanceError(
+                                type_=EntityTypes.relationship,
+                                identifier=target_external_id,
+                                reason=(
+                                    f"Asset {target_external_id} does not exist! "
+                                    f"Cannot create relationship between {source_external_id}"
+                                    f" and {target_external_id}. "
+                                ),
+                            )
+                            tracker.issue(error)
+                            if stop_on_exception:
+                                raise error.as_exception()
+                            yield error
+                            continue
+
+                        external_id = "relationship_" + create_sha256_hash(f"{source_external_id}_{target_external_id}")
+                        try:
+                            yield RelationshipWrite(
+                                external_id=external_id,
+                                source_external_id=source_external_id,
+                                target_external_id=target_external_id,
+                                source_type="asset",
+                                target_type="asset",
+                                data_set_id=self.data_set_id,
+                                labels=[label] if self.use_labels else None,
+                            )
+                        except KeyError as e:
+                            error = loader_issues.InvalidInstanceError(
+                                type_=EntityTypes.relationship,
+                                identifier=external_id,
+                                reason=str(e),
+                            )
+                            tracker.issue(error)
+                            if stop_on_exception:
+                                raise error.as_exception() from e
+                            yield error
+
+            yield _END_OF_CLASS
+
+    def _get_required_capabilities(self) -> list[Capability]:
+        return [
+            AssetsAcl(
+                actions=[
+                    AssetsAcl.Action.Write,
+                    AssetsAcl.Action.Read,
+                ],
+                scope=AssetsAcl.Scope.DataSet([self.data_set_id]),
+            ),
+            RelationshipsAcl(
+                actions=[
+                    RelationshipsAcl.Action.Write,
+                    RelationshipsAcl.Action.Read,
+                ],
+                scope=RelationshipsAcl.Scope.DataSet([self.data_set_id]),
+            ),
+        ]
+
+    def _upload_to_cdf(
+        self,
+        client: CogniteClient,
+        items: list[AssetWrite] | list[RelationshipWrite] | list[LabelDefinitionWrite],
+        dry_run: bool,
+        read_issues: NeatIssueList,
+    ) -> Iterable[UploadResult]:
+        if isinstance(items[0], AssetWrite) and all(isinstance(item, AssetWrite) for item in items):
+            yield from self._upload_assets_to_cdf(client, cast(list[AssetWrite], items), dry_run, read_issues)
+        elif isinstance(items[0], RelationshipWrite) and all(isinstance(item, RelationshipWrite) for item in items):
+            yield from self._upload_relationships_to_cdf(
+                client, cast(list[RelationshipWrite], items), dry_run, read_issues
+            )
+        elif isinstance(items[0], LabelDefinitionWrite) and all(
+            isinstance(item, LabelDefinitionWrite) for item in items
+        ):
+            yield from self._upload_labels_to_cdf(client, cast(list[LabelDefinitionWrite], items), dry_run, read_issues)
+        else:
+            raise ValueError(f"Item {items[0]} is not supported. This is a bug in neat please report it.")
+
+    def _upload_labels_to_cdf(
+        self,
+        client: CogniteClient,
+        items: list[LabelDefinitionWrite],
+        dry_run: bool,
+        read_issues: NeatIssueList,
+    ) -> Iterable[UploadResult]:
+        try:
+            created = client.labels.create(items)
+        except (CogniteAPIError, CogniteDuplicatedError) as e:
+            result = UploadResult[str](name="Label", issues=read_issues)
+            result.error_messages.append(str(e))
+            result.failed_created.update(item.external_id for item in e.failed + e.unknown)
+            result.created.update(item.external_id for item in e.successful)
+            yield result
+        else:
+            for label in created:
+                result = UploadResult[str](name="Label", issues=read_issues)
+                result.upserted.add(cast(str, label.external_id))
+                yield result
+
+    def _upload_assets_to_cdf(
+        self,
+        client: CogniteClient,
+        items: list[AssetWrite],
+        dry_run: bool,
+        read_issues: NeatIssueList,
+    ) -> Iterable[UploadResult]:
+        try:
+            upserted = client.assets.upsert(items, mode="replace")
+        except CogniteAPIError as e:
+            result = UploadResult[str](name="Asset", issues=read_issues)
+            result.error_messages.append(str(e))
+            result.failed_upserted.update(item.external_id for item in e.failed + e.unknown)
+            result.upserted.update(item.external_id for item in e.successful)
+            yield result
+        else:
+            for asset in upserted:
+                result = UploadResult[str](name="Asset", issues=read_issues)
+                result.upserted.add(cast(str, asset.external_id))
+                yield result
+
+    def _upload_relationships_to_cdf(
+        self,
+        client: CogniteClient,
+        items: list[RelationshipWrite],
+        dry_run: bool,
+        read_issues: NeatIssueList,
+    ) -> Iterable[UploadResult]:
+        try:
+            upserted = client.relationships.upsert(items, mode="replace")
+        except CogniteAPIError as e:
+            result = UploadResult[str](name="Relationship", issues=read_issues)
+            result.error_messages.append(str(e))
+            result.failed_upserted.update(item.external_id for item in e.failed + e.unknown)
+            result.upserted.update(item.external_id for item in e.successful)
+            yield result
+        else:
+            for relationship in upserted:
+                result = UploadResult[str](name="relationship", issues=read_issues)
+                result.upserted.add(cast(str, relationship.external_id))
+                yield result
+
+    def write_to_file(self, filepath: Path) -> None:
+        if filepath.suffix not in [".json", ".yaml", ".yml"]:
+            raise ValueError(f"File format {filepath.suffix} is not supported")
+        dumped: dict[str, list] = {"assets": [], "relationship": []}
+        for item in self.load(stop_on_exception=False):
+            key = {
+                AssetWrite: "assets",
+                RelationshipWrite: "relationship",
+                NeatIssue: "issues",
+                _END_OF_CLASS: "end_of_class",
+            }.get(type(item))
+            if key is None:
+                # This should never happen, and is a bug in neat
+                raise ValueError(f"Item {item} is not supported. This is a bug in neat please report it.")
+            if key == "end_of_class":
+                continue
+            dumped[key].append(item.dump())
+        with filepath.open("w", encoding=self._encoding, newline=self._new_line) as f:
+            if filepath.suffix == ".json":
+                json.dump(dumped, f, indent=2)
+            else:
+                yaml.safe_dump(dumped, f, sort_keys=False)
+
+
+def _process_asset_properties(properties: dict[str, list[str]], property_renaming_config: dict[str, str]) -> dict:
+    metadata: dict[str, str] = {}
+    fields: dict[str, str | dict] = {}
+
+    for original_property, values in properties.items():
+        if renamed_property := property_renaming_config.get(original_property, None):
+            if renamed_property.startswith("metadata."):
+                # Asset metadata contains only string values
+                metadata[original_property] = ", ".join(values)
+            else:
+                # Asset fields can contain only one value
+                fields[renamed_property] = values[0]
+
+    if metadata:
+        fields["metadata"] = metadata
+
+    return fields
+
+
+def _process_relationship_properties(
+    properties: dict[str, list[str]], property_renaming_config: dict[str, str]
+) -> dict:
+    relationships: dict[str, list[str]] = {}
+
+    for original_property, values in properties.items():
+        if renamed_property := property_renaming_config.get(original_property, None):
+            relationships[renamed_property] = values
+
+    return relationships

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/graph/loaders/_rdf2dms.py

@@ -34,7 +34,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         data_model (dm.DataModel[dm.View] | None): The data model to load.
         instance_space (str): The instance space to load the data into.
         class_by_view_id (dict[ViewId, str] | None): A mapping from view id to class name. Defaults to None.
-        creat_issues (Sequence[NeatIssue] | None): A list of issues that occurred during reading. Defaults to None.
+        create_issues (Sequence[NeatIssue] | None): A list of issues that occurred during reading. Defaults to None.
         tracker (type[Tracker] | None): The tracker to use. Defaults to None.
     """
 

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/legacy/graph/extractors/_mock_graph_generator.py

@@ -241,9 +241,9 @@ def _generate_mock_data_property_triples(
     python_type = XSD_VALUE_TYPE_MAPPINGS[value_type].python
     triples = []
     for id_ in instance_ids:
-        if python_type == int:
+        if python_type is int:
             triples.append((id_, URIRef(namespace[property_]), Literal(random.randint(1, 1983))))
-        elif python_type == float:
+        elif python_type is float:
             triples.append((id_, URIRef(namespace[property_]), Literal(numpy.float32(random.uniform(1, 1983)))))
         # generate string
         else:

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/legacy/rules/models/rules.py

@@ -886,7 +886,7 @@ class Property(Resource):
         if self.property_type == "DatatypeProperty" and self.default:
             default_value = self.default[0] if isinstance(self.default, list) else self.default
 
-            if type(default_value) != self.expected_value_type.python:
+            if type(default_value) is not self.expected_value_type.python:
                 try:
                     if isinstance(self.default, list):
                         updated_list = []

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/rules/analysis/_asset.py

@@ -128,7 +128,7 @@ class AssetAnalysis(BaseAnalysis[AssetRules, AssetClass, AssetProperty, ClassEnt
             implementation_type=EntityTypes.relationship,
         )
 
-    def define_property_renaming_config(self, class_: ClassEntity) -> dict[str, str]:
+    def define_asset_property_renaming_config(self, class_: ClassEntity) -> dict[str, str]:
         property_renaming_configuration = {}
 
         if asset_definition := self.asset_definition().get(class_, None):
@@ -141,3 +141,33 @@ class AssetAnalysis(BaseAnalysis[AssetRules, AssetClass, AssetProperty, ClassEnt
                     property_renaming_configuration[property_] = f"{asset_property}.{property_}"
 
         return property_renaming_configuration
+
+    def define_relationship_property_renaming_config(self, class_: ClassEntity) -> dict[str, str]:
+        property_renaming_configuration = {}
+
+        if relationship_definition := self.relationship_definition().get(class_, None):
+            for property_, transformation in relationship_definition.items():
+                relationship = cast(list[RelationshipEntity], transformation.implementation)[0]
+
+                if relationship.label:
+                    property_renaming_configuration[property_] = relationship.label
+                else:
+                    property_renaming_configuration[property_] = property_
+
+        return property_renaming_configuration
+
+    def define_labels(self) -> set:
+        labels = set()
+
+        for _, properties in AssetAnalysis(self.rules).relationship_definition().items():
+            for property_, definition in properties.items():
+                labels.add(
+                    cast(RelationshipEntity, definition.implementation[0]).label
+                    if cast(RelationshipEntity, definition.implementation[0]).label
+                    else property_
+                )
+
+        for class_ in AssetAnalysis(self.rules).asset_definition().keys():
+            labels.add(class_.suffix)
+
+        return labels

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/rules/importers/_dms2rules.py

@@ -346,6 +346,7 @@ class DMSImporter(BaseImporter):
             value_type=value_type,
             is_list=self._get_is_list(prop),
             nullable=self._get_nullable(prop),
+            immutable=self._get_immutable(prop),
             default=self._get_default(prop),
             container=ContainerEntity.from_id(prop.container) if isinstance(prop, dm.MappedPropertyApply) else None,
             container_property=prop.container_property_identifier if isinstance(prop, dm.MappedPropertyApply) else None,
@@ -402,6 +403,12 @@ class DMSImporter(BaseImporter):
         else:
             return None
 
+    def _get_immutable(self, prop: ViewPropertyApply) -> bool | None:
+        if isinstance(prop, dm.MappedPropertyApply):
+            return self._container_prop_unsafe(prop).immutable
+        else:
+            return None
+
     def _get_is_list(self, prop: ViewPropertyApply) -> bool | None:
         if isinstance(prop, dm.MappedPropertyApply):
             prop_type = self._container_prop_unsafe(prop).type

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/rules/models/dms/_exporter.py

@@ -290,7 +290,9 @@ class _DMSExporter:
                     type_ = type_cls()
                 container.properties[prop.container_property] = dm.ContainerProperty(
                     type=type_,
+                    # If not set, nullable is True and immutable is False
                     nullable=prop.nullable if prop.nullable is not None else True,
+                    immutable=prop.immutable if prop.immutable is not None else False,
                     default_value=prop.default,
                     name=prop.name,
                     description=prop.description,

{cognite_neat-0.87.3 → cognite_neat-0.87.6}/cognite/neat/rules/models/dms/_rules.py

@@ -177,6 +177,7 @@ class DMSProperty(SheetEntity):
     connection: Literal["direct", "edge", "reverse"] | None = Field(None, alias="Connection")
     value_type: DataType | ViewPropertyEntity | ViewEntity | DMSUnknownEntity = Field(alias="Value Type")
     nullable: bool | None = Field(default=None, alias="Nullable")
+    immutable: bool | None = Field(default=None, alias="Immutable")
     is_list: bool | None = Field(default=None, alias="Is List")
     default: str | int | dict | None = Field(None, alias="Default")
     reference: URLEntity | ReferenceEntity | None = Field(default=None, alias="Reference", union_mode="left_to_right")