cognite-neat 0.105.2__py3-none-any.whl → 0.107.0__py3-none-any.whl

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

@@ -52,10 +52,11 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
         unpack_columns: bool = False,
     ):
         super().__init__(
-            items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write
+            items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write, prefix
         )
         self.unpack_columns = unpack_columns
 
@@ -71,9 +72,10 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
         unpack_columns: bool = False,
     ):
-        total, items = cls._from_dataset(client, data_set_external_id)
+        total, items = cls._handle_no_access(lambda: cls._from_dataset(client, data_set_external_id))
         return cls(
             items,
             namespace,
@@ -84,6 +86,7 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
             skip_metadata_values,
             camel_case,
             as_write,
+            prefix,
             unpack_columns,
         )
 
@@ -99,9 +102,10 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
         unpack_columns: bool = False,
     ):
-        total, items = cls._from_hierarchy(client, root_asset_external_id)
+        total, items = cls._handle_no_access(lambda: cls._from_hierarchy(client, root_asset_external_id))
         return cls(
             items,
             namespace,
@@ -112,6 +116,7 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
             skip_metadata_values,
             camel_case,
             as_write,
+            prefix,
             unpack_columns,
         )
 
@@ -126,6 +131,7 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
         camel_case: bool = True,
         as_write: bool = False,
+        prefix: str | None = None,
         unpack_columns: bool = False,
     ):
         total, items = cls._from_file(file_path)
@@ -139,6 +145,7 @@ class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
             skip_metadata_values,
             camel_case,
             as_write,
+            prefix,
             unpack_columns,
         )
 

cognite/neat/_graph/extractors/_dms.py

@@ -1,3 +1,4 @@
+import urllib.parse
 from collections.abc import Iterable, Iterator
 from typing import cast
 
@@ -5,6 +6,7 @@ from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 from cognite.client.data_classes.data_modeling.instances import Instance, PropertyValue
+from cognite.client.utils.useful_types import SequenceNotStr
 from rdflib import RDF, XSD, Literal, Namespace, URIRef
 
 from cognite.neat._constants import DEFAULT_SPACE_URI
@@ -38,7 +40,12 @@ class DMSExtractor(BaseExtractor):
 
     @classmethod
     def from_data_model(
-        cls, client: CogniteClient, data_model: DataModelIdentifier, limit: int | None = None
+        cls,
+        client: CogniteClient,
+        data_model: DataModelIdentifier,
+        limit: int | None = None,
+        overwrite_namespace: Namespace | None = None,
+        instance_space: str | SequenceNotStr[str] | None = None,
     ) -> "DMSExtractor":
         """Create an extractor from a data model.
 
@@ -46,22 +53,38 @@ class DMSExtractor(BaseExtractor):
             client: The Cognite client to use.
             data_model: The data model to extract.
             limit: The maximum number of instances to extract.
+            overwrite_namespace: If provided, this will overwrite the space of the extracted items.
+            instance_space: The space to extract instances from.
         """
         retrieved = client.data_modeling.data_models.retrieve(data_model, inline_views=True)
         if not retrieved:
             raise ResourceRetrievalError(dm.DataModelId.load(data_model), "data model", "Data Model is missing in CDF")
-        return cls.from_views(client, retrieved.latest_version().views, limit)
+        return cls.from_views(client, retrieved.latest_version().views, limit, overwrite_namespace, instance_space)
 
     @classmethod
-    def from_views(cls, client: CogniteClient, views: Iterable[dm.View], limit: int | None = None) -> "DMSExtractor":
+    def from_views(
+        cls,
+        client: CogniteClient,
+        views: Iterable[dm.View],
+        limit: int | None = None,
+        overwrite_namespace: Namespace | None = None,
+        instance_space: str | SequenceNotStr[str] | None = None,
+    ) -> "DMSExtractor":
         """Create an extractor from a set of views.
 
         Args:
             client: The Cognite client to use.
             views: The views to extract.
             limit: The maximum number of instances to extract.
+            overwrite_namespace: If provided, this will overwrite the space of the extracted items.
+            instance_space: The space to extract instances from.
         """
-        return cls(_InstanceIterator(client, views), total=None, limit=limit)
+        return cls(
+            _InstanceIterator(client, views, instance_space),
+            total=None,
+            limit=limit,
+            overwrite_namespace=overwrite_namespace,
+        )
 
     def extract(self) -> Iterable[Triple]:
         for count, item in enumerate(self.items, 1):
@@ -105,6 +128,10 @@ class DMSExtractor(BaseExtractor):
         else:
             raise NotImplementedError(f"Unknown instance type {type(instance)}")
 
+        if self.overwrite_namespace:
+            # If the namespace is overwritten, keep the original space as a property to avoid losing information.
+            yield id_, self._get_namespace(instance.space)["space"], Literal(instance.space)
+
         for view_id, properties in instance.properties.items():
             namespace = self._get_namespace(view_id.space)
             for key, value in properties.items():
@@ -124,35 +151,42 @@ class DMSExtractor(BaseExtractor):
                 yield from self._get_objects(item)
 
     def _as_uri_ref(self, instance: Instance | dm.DirectRelationReference) -> URIRef:
-        return self._get_namespace(instance.space)[instance.external_id]
+        return self._get_namespace(instance.space)[urllib.parse.quote(instance.external_id)]
 
     def _get_namespace(self, space: str) -> Namespace:
         if self.overwrite_namespace:
             return self.overwrite_namespace
-        return Namespace(DEFAULT_SPACE_URI.format(space=space))
+        return Namespace(DEFAULT_SPACE_URI.format(space=urllib.parse.quote(space)))
 
 
-class _InstanceIterator(Iterator[Instance]):
-    def __init__(self, client: CogniteClient, views: Iterable[dm.View]):
+class _InstanceIterator(Iterable[Instance]):
+    def __init__(
+        self, client: CogniteClient, views: Iterable[dm.View], instance_space: str | SequenceNotStr[str] | None = None
+    ):
         self.client = client
         self.views = views
+        self.instance_space = instance_space
 
     def __iter__(self) -> Iterator[Instance]:
-        return self
-
-    def __next__(self) -> Instance:  # type: ignore[misc]
         for view in self.views:
+            view_id = view.as_id()
             # All nodes and edges with properties
-            yield from self.client.data_modeling.instances(chunk_size=None, instance_type="node", sources=[view])
-            yield from self.client.data_modeling.instances(chunk_size=None, instance_type="edge", sources=[view])
+            if view.used_for in ("node", "all"):
+                yield from self.client.data_modeling.instances(
+                    chunk_size=None, instance_type="node", sources=[view_id], space=self.instance_space
+                )
+            if view.used_for in ("edge", "all"):
+                yield from self.client.data_modeling.instances(
+                    chunk_size=None, instance_type="edge", sources=[view_id], space=self.instance_space
+                )
 
             for prop in view.properties.values():
                 if isinstance(prop, dm.EdgeConnection):
-                    # Get all edges with properties
                     yield from self.client.data_modeling.instances(
                         chunk_size=None,
                         instance_type="edge",
                         filter=dm.filters.Equals(
                             ["edge", "type"], {"space": prop.type.space, "externalId": prop.type.external_id}
                         ),
+                        space=self.instance_space,
                     )

cognite/neat/_graph/extractors/_dms_graph.py

@@ -0,0 +1,149 @@
+from collections.abc import Iterable, Sequence
+
+from cognite.client import data_modeling as dm
+from cognite.client.exceptions import CogniteAPIError
+from cognite.client.utils.useful_types import SequenceNotStr
+from rdflib import Namespace, URIRef
+
+from cognite.neat._client import NeatClient
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._issues import IssueList, NeatIssue, catch_warnings
+from cognite.neat._issues.warnings import CDFAuthWarning, ResourceNotFoundWarning, ResourceRetrievalWarning
+from cognite.neat._rules.importers import DMSImporter
+from cognite.neat._rules.models import DMSRules, InformationRules
+from cognite.neat._rules.transformers import DMSToInformation, VerifyDMSRules
+from cognite.neat._shared import Triple
+
+from ._base import KnowledgeGraphExtractor
+from ._dms import DMSExtractor
+
+
+class DMSGraphExtractor(KnowledgeGraphExtractor):
+    def __init__(
+        self,
+        data_model: dm.DataModel[dm.View],
+        client: NeatClient,
+        namespace: Namespace = DEFAULT_NAMESPACE,
+        issues: Sequence[NeatIssue] | None = None,
+        instance_space: str | SequenceNotStr[str] | None = None,
+    ) -> None:
+        self._client = client
+        self._data_model = data_model
+        self._namespace = namespace or DEFAULT_NAMESPACE
+        self._issues = IssueList(issues)
+        self._instance_space = instance_space
+
+        self._views: list[dm.View] | None = None
+        self._information_rules: InformationRules | None = None
+        self._dms_rules: DMSRules | None = None
+
+    @classmethod
+    def from_data_model_id(
+        cls,
+        data_model_id: dm.DataModelIdentifier,
+        client: NeatClient,
+        namespace: Namespace = DEFAULT_NAMESPACE,
+        instance_space: str | SequenceNotStr[str] | None = None,
+    ) -> "DMSGraphExtractor":
+        issues: list[NeatIssue] = []
+        try:
+            data_model = client.data_modeling.data_models.retrieve(data_model_id, inline_views=True)
+        except CogniteAPIError as e:
+            issues.append(CDFAuthWarning("retrieving data model", str(e)))
+            return cls(
+                cls._create_empty_model(dm.DataModelId.load(data_model_id)), client, namespace, issues, instance_space
+            )
+        if not data_model:
+            issues.append(ResourceRetrievalWarning(frozenset({data_model_id}), "data model"))
+            return cls(
+                cls._create_empty_model(dm.DataModelId.load(data_model_id)), client, namespace, issues, instance_space
+            )
+        return cls(data_model.latest_version(), client, namespace, issues, instance_space)
+
+    @classmethod
+    def _create_empty_model(cls, data_model_id: dm.DataModelId) -> dm.DataModel:
+        return dm.DataModel(
+            data_model_id.space,
+            data_model_id.external_id,
+            data_model_id.version or "MISSING",
+            is_global=False,
+            last_updated_time=0,
+            created_time=0,
+            description=None,
+            name=None,
+            views=[],
+        )
+
+    @property
+    def _model_views(self) -> list[dm.View]:
+        if self._views is None:
+            self._views = self._get_views()
+        return self._views
+
+    @property
+    def description(self) -> str:
+        return "Extracts a data model with nodes and edges."
+
+    @property
+    def source_uri(self) -> URIRef:
+        space, external_id, version = self._data_model.as_id().as_tuple()
+        return DEFAULT_NAMESPACE[f"{self._client.config.project}/{space}/{external_id}/{version}"]
+
+    def extract(self) -> Iterable[Triple]:
+        """Extracts the knowledge graph from the data model."""
+        views = self._model_views
+        yield from DMSExtractor.from_views(
+            self._client,
+            views,
+            overwrite_namespace=self._namespace,
+            instance_space=self._instance_space,
+        ).extract()
+
+    def _get_views(self) -> list[dm.View]:
+        view_by_id: dict[dm.ViewId, dm.View] = {}
+        if view_ids := [view_id for view_id in self._data_model.views if isinstance(view_id, dm.ViewId)]:
+            try:
+                # MyPy does not understand the isinstance check above.
+                retrieved = self._client.data_modeling.views.retrieve(ids=view_ids)  #  type: ignore[arg-type]
+            except CogniteAPIError as e:
+                self._issues.append(CDFAuthWarning("retrieving views", str(e)))
+            else:
+                view_by_id.update({view.as_id(): view for view in retrieved})
+        views: list[dm.View] = []
+        data_model_id = self._data_model.as_id()
+        for dm_view in self._data_model.views:
+            if isinstance(dm_view, dm.View):
+                views.append(dm_view)
+            elif isinstance(dm_view, dm.ViewId):
+                if view := view_by_id.get(dm_view):
+                    views.append(view)
+                else:
+                    self._issues.append(ResourceNotFoundWarning(dm_view, "view", data_model_id, "data model"))
+        return views
+
+    def get_information_rules(self) -> InformationRules:
+        """Returns the information rules that the extractor uses."""
+        if self._information_rules is None:
+            self._information_rules, self._dms_rules = self._create_rules()
+        return self._information_rules
+
+    def get_dms_rules(self) -> DMSRules:
+        """Returns the DMS rules that the extractor uses."""
+        if self._dms_rules is None:
+            self._information_rules, self._dms_rules = self._create_rules()
+        return self._dms_rules
+
+    def get_issues(self) -> IssueList:
+        """Returns the issues that occurred during the extraction."""
+        return self._issues
+
+    def _create_rules(self) -> tuple[InformationRules, DMSRules]:
+        # The DMS and Information rules must be created together to link them property.
+        importer = DMSImporter.from_data_model(self._client, self._data_model)
+        unverified_dms = importer.to_rules()
+        with catch_warnings() as issues:
+            # Any errors occur will be raised and caught outside the extractor.
+            verified_dms = VerifyDMSRules(client=self._client).transform(unverified_dms)
+            information_rules = DMSToInformation(self._namespace).transform(verified_dms)
+        self._issues.extend(issues)
+        return information_rules, verified_dms

cognite/neat/_graph/extractors/_rdf_file.py

@@ -1,6 +1,7 @@
+import zipfile
 from collections.abc import Iterable
 from pathlib import Path
-from typing import get_args
+from typing import cast, get_args
 
 from rdflib import URIRef
 from rdflib.util import guess_format
@@ -10,6 +11,7 @@ from cognite.neat._graph._shared import RDFTypes
 from cognite.neat._graph.extractors._base import BaseExtractor
 from cognite.neat._issues._base import IssueList
 from cognite.neat._issues.errors import FileNotFoundNeatError, FileTypeUnexpectedError
+from cognite.neat._issues.errors._general import NeatValueError
 from cognite.neat._shared import Triple
 
 
@@ -24,25 +26,50 @@ class RdfFileExtractor(BaseExtractor):
 
     def __init__(
         self,
-        filepath: Path,
+        filepath: Path | zipfile.ZipExtFile,
         base_uri: URIRef = DEFAULT_BASE_URI,
         issue_list: IssueList | None = None,
     ):
         self.issue_list = issue_list or IssueList(title=f"{filepath.name}")
         self.base_uri = base_uri
         self.filepath = filepath
-        self.format = guess_format(str(self.filepath))
 
-        if not self.filepath.exists():
+        self.format = guess_format(str(self.filepath) if isinstance(self.filepath, Path) else self.filepath.name)
+
+        print(self.format)
+        if isinstance(self.filepath, Path) and not self.filepath.exists():
             self.issue_list.append(FileNotFoundNeatError(self.filepath))
 
         if not self.format:
             self.issue_list.append(
                 FileTypeUnexpectedError(
-                    self.filepath,
+                    (self.filepath if isinstance(self.filepath, Path) else Path(self.filepath.name)),
                     frozenset(get_args(RDFTypes)),
                 )
             )
 
     def extract(self) -> Iterable[Triple]:
         raise NotImplementedError()
+
+    @classmethod
+    def from_zip(
+        cls,
+        filepath: Path,
+        filename: str = "neat-session/instances/instances.ttl",
+        base_uri: URIRef = DEFAULT_BASE_URI,
+        issue_list: IssueList | None = None,
+    ):
+        if not filepath.exists():
+            raise FileNotFoundNeatError(filepath)
+        if filepath.suffix not in {".zip"}:
+            raise NeatValueError("Expected a zip file, got {filepath.suffix}")
+
+        with zipfile.ZipFile(filepath, "r") as zip_ref:
+            for file_info in zip_ref.infolist():
+                if file_info.filename == filename:
+                    # We need to open the file in the zip file, and close it upon
+                    # triple extraction ...
+                    file = zip_ref.open(file_info)
+                    return cls(cast(zipfile.ZipExtFile, file), base_uri, issue_list)
+
+        raise NeatValueError(f"Cannot extract {filename} from zip file {filepath}")

cognite/neat/_graph/loaders/_rdf2dms.py

@@ -32,11 +32,12 @@ from cognite.neat._issues.errors import (
 from cognite.neat._issues.warnings import PropertyDirectRelationLimitWarning, PropertyTypeNotSupportedWarning
 from cognite.neat._rules.analysis._dms import DMSAnalysis
 from cognite.neat._rules.models import DMSRules
-from cognite.neat._rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json
+from cognite.neat._rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json, String
 from cognite.neat._rules.models.entities._single_value import ViewEntity
 from cognite.neat._shared import InstanceType
 from cognite.neat._store import NeatGraphStore
 from cognite.neat._utils.auxiliary import create_sha256_hash
+from cognite.neat._utils.collection_ import iterate_progress_bar_if_above_config_threshold
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 from cognite.neat._utils.upload import UploadResult
 
@@ -157,8 +158,8 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 view_ids.append(f"{view_id!r} (self)")
 
         tracker = self._tracker(type(self).__name__, view_ids, "views")
-        for view_id, (view, _) in view_and_count_by_id.items():
-            pydantic_cls, edge_by_type, issues = self._create_validation_classes(view)  # type: ignore[var-annotated]
+        for view_id, (view, instance_count) in view_and_count_by_id.items():
+            pydantic_cls, edge_by_type, edge_by_prop_id, issues = self._create_validation_classes(view)  # type: ignore[var-annotated]
             yield from issues
             tracker.issue(issues)
 
@@ -194,21 +195,66 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                     # this assumes no changes in the suffix of view and class
                     reader = self.graph_store.read(view.external_id)
 
-                for identifier, properties in reader:
+                instance_iterable = iterate_progress_bar_if_above_config_threshold(
+                    reader, instance_count, f"Loading {track_id}"
+                )
+
+                for identifier, properties in instance_iterable:
+                    start_node, end_node = self._pop_start_end_node(properties)
+                    is_edge = start_node and end_node
+                    if (is_edge and view.used_for == "node") or (not is_edge and view.used_for == "edge"):
+                        instance_type = "edge" if is_edge else "node"
+                        creation_error = ResourceCreationError(
+                            identifier,
+                            instance_type,
+                            error=f"{instance_type.capitalize()} found in {view.used_for} view",
+                        )
+                        tracker.issue(creation_error)
+                        if stop_on_exception:
+                            raise creation_error
+                        yield creation_error
+                        continue
+
                     if skip_properties:
                         properties = {k: v for k, v in properties.items() if k not in skip_properties}
-                    try:
-                        yield self._create_node(identifier, properties, pydantic_cls, view_id)
-                    except ValueError as e:
-                        error_node = ResourceCreationError(identifier, "node", error=str(e))
-                        tracker.issue(error_node)
-                        if stop_on_exception:
-                            raise error_node from e
-                        yield error_node
-                    yield from self._create_edges(identifier, properties, edge_by_type, tracker)
+
+                    if start_node and end_node:
+                        # Is an edge
+                        try:
+                            yield self._create_edge_with_properties(
+                                identifier, properties, start_node, end_node, pydantic_cls, view_id
+                            )
+                        except ValueError as e:
+                            error_edge = ResourceCreationError(identifier, "edge", error=str(e))
+                            tracker.issue(error_edge)
+                            if stop_on_exception:
+                                raise error_edge from e
+                            yield error_edge
+                    else:
+                        try:
+                            yield self._create_node(identifier, properties, pydantic_cls, view_id)
+                        except ValueError as e:
+                            error_node = ResourceCreationError(identifier, "node", error=str(e))
+                            tracker.issue(error_node)
+                            if stop_on_exception:
+                                raise error_node from e
+                            yield error_node
+                        yield from self._create_edges_without_properties(
+                            identifier, properties, edge_by_type, edge_by_prop_id, tracker
+                        )
                 tracker.finish(track_id)
                 yield _END_OF_CLASS
 
+    @staticmethod
+    def _pop_start_end_node(properties: dict[str | InstanceType, list[str]]) -> tuple[str | None, str | None]:
+        start_node = properties.pop("startNode", [None])[0]
+        if not start_node:
+            start_node = properties.pop("start_node", [None])[0]
+        end_node = properties.pop("endNode", [None])[0]
+        if not end_node:
+            end_node = properties.pop("end_node", [None])[0]
+        return start_node, end_node
+
     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")
@@ -293,17 +339,30 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
     def _create_validation_classes(
         self, view: dm.View
-    ) -> tuple[type[BaseModel], dict[str, tuple[str, dm.EdgeConnection]], NeatIssueList]:
+    ) -> tuple[
+        type[BaseModel],
+        dict[str, tuple[str, dm.EdgeConnection]],
+        dict[str, tuple[str, dm.EdgeConnection]],
+        NeatIssueList,
+    ]:
         issues = IssueList()
         field_definitions: dict[str, tuple[type, Any]] = {}
-        edge_by_property: dict[str, tuple[str, dm.EdgeConnection]] = {}
+        edge_by_type: dict[str, tuple[str, dm.EdgeConnection]] = {}
+        edge_by_prop_id: dict[str, tuple[str, dm.EdgeConnection]] = {}
         validators: dict[str, classmethod] = {}
         direct_relation_by_property: dict[str, dm.DirectRelation] = {}
         unit_properties: list[str] = []
         json_fields: list[str] = []
+        text_fields: list[str] = []
         for prop_id, prop in view.properties.items():
             if isinstance(prop, dm.EdgeConnection):
-                edge_by_property[prop_id] = prop_id, prop
+                if prop.edge_source:
+                    # Edges with properties are created separately
+                    continue
+
+                edge_by_type[prop.type.external_id] = prop_id, prop
+                edge_by_prop_id[prop_id] = prop_id, prop
+
             if isinstance(prop, dm.MappedProperty):
                 if is_readonly_property(prop.container, prop.container_property_identifier):
                     continue
@@ -329,6 +388,8 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
                     if data_type == Json:
                         json_fields.append(prop_id)
+                    elif data_type == String:
+                        text_fields.append(prop_id)
                     python_type = data_type.python
                 if isinstance(prop.type, ListablePropertyType) and prop.type.is_list:
                     python_type = list[python_type]
@@ -364,11 +425,20 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             else:
                 raise ValueError(f"Expect valid JSON string or dict for {info.field_name}: {value}")
 
+        def parse_text(cls, value: Any, info: ValidationInfo) -> Any:
+            if isinstance(value, list):
+                return [remove_namespace_from_uri(v) for v in value]
+            else:
+                return remove_namespace_from_uri(value)
+
         if json_fields:
             validators["parse_json_string"] = field_validator(*json_fields, mode="before")(parse_json_string)  # type: ignore[assignment, arg-type]
 
         validators["parse_list"] = field_validator("*", mode="before")(parse_list)  # type: ignore[assignment, arg-type]
 
+        if text_fields:
+            validators["parse_text"] = field_validator(*text_fields, mode="before")(parse_text)  # type: ignore[assignment, arg-type]
+
         if direct_relation_by_property:
 
             def parse_direct_relation(cls, value: list, info: ValidationInfo) -> dict | list[dict]:
@@ -409,7 +479,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             )
 
         pydantic_cls = create_model(view.external_id, __validators__=validators, **field_definitions)  # type: ignore[arg-type, call-overload]
-        return pydantic_cls, edge_by_property, issues
+        return pydantic_cls, edge_by_type, edge_by_prop_id, issues
 
     def _create_node(
         self,
@@ -430,17 +500,46 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             ],
         )
 
-    def _create_edges(
+    def _create_edge_with_properties(
+        self,
+        identifier: str,
+        properties: dict[str | InstanceType, list[str]],
+        start_node: str,
+        end_node: str,
+        pydantic_cls: type[BaseModel],
+        view_id: dm.ViewId,
+    ) -> dm.EdgeApply:
+        type_ = properties.pop(RDF.type, [None])[0]
+        created = pydantic_cls.model_validate(properties)
+        if type_ is None:
+            raise ValueError(f"Missing type for edge {identifier}")
+
+        return dm.EdgeApply(
+            space=self.instance_space,
+            external_id=identifier,
+            type=dm.DirectRelationReference(view_id.space, view_id.external_id),
+            start_node=dm.DirectRelationReference(self.instance_space, start_node),
+            end_node=dm.DirectRelationReference(self.instance_space, end_node),
+            sources=[
+                dm.NodeOrEdgeData(source=view_id, properties=dict(created.model_dump(exclude_unset=True).items()))
+            ],
+        )
+
+    def _create_edges_without_properties(
         self,
         identifier: str,
         properties: dict[str, list[str]],
         edge_by_type: dict[str, tuple[str, dm.EdgeConnection]],
+        edge_by_prop_id: dict[str, tuple[str, dm.EdgeConnection]],
         tracker: Tracker,
     ) -> Iterable[dm.EdgeApply | NeatIssue]:
         for predicate, values in properties.items():
-            if predicate not in edge_by_type:
+            if predicate in edge_by_type:
+                prop_id, edge = edge_by_type[predicate]
+            elif predicate in edge_by_prop_id:
+                prop_id, edge = edge_by_prop_id[predicate]
+            else:
                 continue
-            prop_id, edge = edge_by_type[predicate]
             if isinstance(edge, SingleEdgeConnection) and len(values) > 1:
                 error = ResourceDuplicatedError(
                     resource_type="edge",

cognite/neat/_graph/queries/_construct.py

@@ -106,7 +106,7 @@ def to_construct_triples(
     non_inherited_starting_rdf_types = []
 
     for transformation in transformations:
-        traversal = cast(RDFPath, transformation.transformation).traversal
+        traversal = cast(RDFPath, transformation.instance_source).traversal
 
         # keeping track of starting rdf types of non-inherited transformations/properties
         if isinstance(traversal, Traversal) and not transformation.inherited: