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

cognite/neat/_rules/transformers/_mapping.py

@@ -1,18 +1,17 @@
 import warnings
 from abc import ABC
 from collections import defaultdict
-from functools import cached_property
 from typing import Any, ClassVar, Literal
 
 from cognite.client import data_modeling as dm
 
 from cognite.neat._client import NeatClient
 from cognite.neat._issues.errors import CDFMissingClientError, NeatValueError, ResourceNotFoundError
-from cognite.neat._issues.warnings import NeatValueWarning, PropertyOverwritingWarning
+from cognite.neat._issues.warnings import PropertyOverwritingWarning
 from cognite.neat._rules.models import DMSRules, SheetList
 from cognite.neat._rules.models.data_types import Enum
-from cognite.neat._rules.models.dms import DMSEnum, DMSProperty, DMSView
-from cognite.neat._rules.models.entities import ContainerEntity, ViewEntity
+from cognite.neat._rules.models.dms import DMSContainer, DMSEnum, DMSProperty
+from cognite.neat._rules.models.entities import ClassEntity, ContainerEntity, ViewEntity
 
 from ._base import RulesTransformer
 
@@ -104,11 +103,12 @@ class MapOneToOne(MapOntoTransformers):
 class RuleMapper(RulesTransformer[DMSRules, DMSRules]):
     """Maps properties and classes using the given mapping.
 
-    **Note**: This transformer mutates the input rules.
-
     Args:
-        mapping: The mapping to use.
-
+        mapping: The mapping to use represented as a DMSRules object.
+        data_type_conflict: How to handle data type conflicts. The default is "overwrite".
+            A data type conflicts occurs when the data type of a property in the mapping is different from the
+            data type of the property in the input rules. If "overwrite" the data type in the input rules is overwritten
+            with the data type in the mapping.
     """
 
     _mapping_fields: ClassVar[frozenset[str]] = frozenset(
@@ -119,67 +119,83 @@ class RuleMapper(RulesTransformer[DMSRules, DMSRules]):
         self.mapping = mapping
         self.data_type_conflict = data_type_conflict
 
-    @cached_property
-    def _view_by_entity_id(self) -> dict[str, DMSView]:
-        return {view.view.external_id: view for view in self.mapping.views}
-
-    @cached_property
-    def _property_by_view_property(self) -> dict[tuple[str, str], DMSProperty]:
-        return {(prop.view.external_id, prop.view_property): prop for prop in self.mapping.properties}
-
     def transform(self, rules: DMSRules) -> DMSRules:
         if self.data_type_conflict != "overwrite":
             raise NeatValueError(f"Invalid data_type_conflict: {self.data_type_conflict}")
         input_rules = rules
         new_rules = input_rules.model_copy(deep=True)
 
-        for view in new_rules.views:
-            if mapping_view := self._view_by_entity_id.get(view.view.external_id):
-                view.implements = mapping_view.implements
+        views_by_external_id = {view.view.external_id: view for view in new_rules.views}
+        new_views: set[ViewEntity] = set()
+        for mapping_view in self.mapping.views:
+            if existing_view := views_by_external_id.get(mapping_view.view.external_id):
+                existing_view.implements = mapping_view.implements
+            else:
+                # We need to add all the views in the mapping that are not in the input rules.
+                # This is to ensure that all ValueTypes are present in the resulting rules.
+                # For example, if a property is a direct relation to an Equipment view, we need to add
+                # the Equipment view to the rules.
+                new_rules.views.append(mapping_view)
+                new_views.add(mapping_view.view)
 
-        for prop in new_rules.properties:
-            key = (prop.view.external_id, prop.view_property)
-            if key not in self._property_by_view_property:
-                continue
-            mapping_prop = self._property_by_view_property[key]
-            to_overwrite, conflicts = self._find_overwrites(prop, mapping_prop)
-            if conflicts and self.data_type_conflict == "overwrite":
-                warnings.warn(
-                    PropertyOverwritingWarning(prop.view.as_id(), "view", prop.view_property, tuple(conflicts)),
-                    stacklevel=2,
-                )
-            elif conflicts:
-                raise NeatValueError(f"Conflicting properties for {prop.view}.{prop.view_property}: {conflicts}")
-            for field_name, value in to_overwrite.items():
-                setattr(prop, field_name, value)
-            prop.container = mapping_prop.container
-            prop.container_property = mapping_prop.container_property
-
-        # Add missing views used as value types
-        existing_views = {view.view for view in new_rules.views}
-        new_value_types = {
-            prop.value_type
-            for prop in new_rules.properties
-            if isinstance(prop.value_type, ViewEntity) and prop.value_type not in existing_views
+        properties_by_view_property = {
+            (prop.view.external_id, prop.view_property): prop for prop in new_rules.properties
         }
-        for new_value_type in new_value_types:
-            if mapping_view := self._view_by_entity_id.get(new_value_type.external_id):
-                new_rules.views.append(mapping_view)
+        existing_enum_collections = {item.collection for item in new_rules.enum or []}
+        mapping_enums_by_collection: dict[ClassEntity, list[DMSEnum]] = defaultdict(list)
+        for item in self.mapping.enum or []:
+            mapping_enums_by_collection[item.collection].append(item)
+        existing_containers = {container.container for container in new_rules.containers or []}
+        mapping_containers_by_id = {container.container: container for container in self.mapping.containers or []}
+        for mapping_prop in self.mapping.properties:
+            if existing_prop := properties_by_view_property.get(
+                (mapping_prop.view.external_id, mapping_prop.view_property)
+            ):
+                to_overwrite, conflicts = self._find_overwrites(existing_prop, mapping_prop)
+                if conflicts and self.data_type_conflict == "overwrite":
+                    warnings.warn(
+                        PropertyOverwritingWarning(
+                            existing_prop.view.as_id(), "view", existing_prop.view_property, tuple(conflicts)
+                        ),
+                        stacklevel=2,
+                    )
+                elif conflicts:
+                    raise NeatValueError(
+                        f"Conflicting properties for {existing_prop.view}.{existing_prop.view_property}: {conflicts}"
+                    )
+
+                for field_name, value in to_overwrite.items():
+                    setattr(existing_prop, field_name, value)
+                existing_prop.container = mapping_prop.container
+                existing_prop.container_property = mapping_prop.container_property
+            elif isinstance(mapping_prop.value_type, ViewEntity):
+                # All connections must be included in the rules. This is to update the
+                # ValueTypes of the implemented views.
+                new_rules.properties.append(mapping_prop)
+            elif mapping_prop.view in new_views:
+                # All properties of new views are included. Main motivation is GUIDs properties
+                new_rules.properties.append(mapping_prop)
             else:
-                warnings.warn(NeatValueWarning(f"View {new_value_type} not found in mapping"), stacklevel=2)
+                # Skipping mapped properties that are not in the input rules.
+                continue
 
-        # Add missing enums
-        existing_enum_collections = {item.collection for item in new_rules.enum or []}
-        new_enums = {
-            prop.value_type.collection
-            for prop in new_rules.properties
-            if isinstance(prop.value_type, Enum) and prop.value_type.collection not in existing_enum_collections
-        }
-        if new_enums:
-            new_rules.enum = new_rules.enum or SheetList[DMSEnum]([])
-            for item in self.mapping.enum or []:
-                if item.collection in new_enums:
-                    new_rules.enum.append(item)
+            if (
+                isinstance(mapping_prop.value_type, Enum)
+                and mapping_prop.value_type.collection not in existing_enum_collections
+            ):
+                if not new_rules.enum:
+                    new_rules.enum = SheetList[DMSEnum]([])
+                new_rules.enum.extend(mapping_enums_by_collection[mapping_prop.value_type.collection])
+
+            if (
+                mapping_prop.container
+                and mapping_prop.container not in existing_containers
+                and (new_container := mapping_containers_by_id.get(mapping_prop.container))
+            ):
+                # Mapping can include new containers for GUID properties
+                if not new_rules.containers:
+                    new_rules.containers = SheetList[DMSContainer]([])
+                new_rules.containers.append(new_container)
 
         return new_rules
 

cognite/neat/_rules/transformers/_verification.py

@@ -1,7 +1,7 @@
 from abc import ABC
 
 from cognite.neat._client import NeatClient
-from cognite.neat._issues import IssueList, MultiValueError, NeatError, NeatWarning, catch_issues
+from cognite.neat._issues import MultiValueError, catch_issues
 from cognite.neat._issues.errors import NeatTypeError, NeatValueError
 from cognite.neat._rules._shared import (
     ReadRules,
@@ -39,8 +39,7 @@ class VerificationTransformer(RulesTransformer[T_ReadInputRules, T_VerifiedRules
         verified_rules: T_VerifiedRules | None = None
         # We need to catch issues as we use the error args to provide extra context for the errors/warnings
         # For example, which row in the spreadsheet the error occurred o
-        issues = IssueList()
-        with catch_issues(issues, NeatError, NeatWarning, error_args) as _:
+        with catch_issues(error_args=error_args) as issues:
             rules_cls = self._get_rules_cls(rules)
             dumped = in_.dump()
             verified_rules = rules_cls.model_validate(dumped)  # type: ignore[assignment]

cognite/neat/_session/_inspect.py

@@ -59,7 +59,9 @@ class InspectAPI:
             neat.inspect.properties
             ```
         """
-        return self._state.rule_store.last_verified_rule.properties.to_pandas()
+        df = self._state.rule_store.last_verified_rule.properties.to_pandas()
+        df.drop(columns=["neatId"], errors="ignore", inplace=True)
+        return df
 
 
 @session_class_wrapper

cognite/neat/_session/_prepare.py

@@ -8,8 +8,10 @@ from cognite.neat._client import NeatClient
 from cognite.neat._constants import (
     get_default_prefixes_and_namespaces,
 )
+from cognite.neat._graph import extractors
 from cognite.neat._graph.transformers import (
     AttachPropertyFromTargetToSource,
+    ConnectionToLiteral,
     ConvertLiteral,
     LiteralToEntity,
     PruneDeadEndEdges,
@@ -20,14 +22,20 @@ from cognite.neat._graph.transformers import (
 )
 from cognite.neat._graph.transformers._rdfpath import MakeConnectionOnExactMatch
 from cognite.neat._issues import IssueList
+from cognite.neat._issues.errors import NeatValueError
+from cognite.neat._rules.models.dms import DMSValidation
 from cognite.neat._rules.transformers import (
     AddClassImplements,
     IncludeReferenced,
     PrefixEntities,
     ReduceCogniteModel,
+    RulesTransformer,
     ToCompliantEntities,
-    ToExtension,
+    ToDataProductModel,
+    ToEnterpriseModel,
+    ToSolutionModel,
 )
+from cognite.neat._utils.text import humanize_collection
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, session_class_wrapper
@@ -195,9 +203,11 @@ class InstancePrepareAPI:
             neat.prepare.instances.make_connection_on_exact_match(source, target, connection)
             ```
         """
-
-        subject_type, subject_predicate = self._get_type_and_property_uris(*source)
-        object_type, object_predicate = self._get_type_and_property_uris(*target)
+        try:
+            subject_type, subject_predicate = self._get_type_and_property_uris(*source)
+            object_type, object_predicate = self._get_type_and_property_uris(*target)
+        except NeatValueError as e:
+            raise NeatSessionError(f"Cannot make connection: {e}") from None
 
         transformer = MakeConnectionOnExactMatch(
             subject_type,
@@ -215,17 +225,19 @@ class InstancePrepareAPI:
         property_uri = self._state.instances.store.queries.property_uri(property_)
 
         if not type_uri:
-            raise NeatSessionError(f"Type {type_} does not exist in the graph.")
+            raise NeatValueError(f"Type {type_} does not exist in the graph.")
         elif len(type_uri) > 1:
-            raise NeatSessionError(f"{type_} has multiple ids found in the graph: {','.join(type_uri)}.")
+            raise NeatValueError(f"{type_} has multiple ids found in the graph: {humanize_collection(type_uri)}.")
 
         if not property_uri:
-            raise NeatSessionError(f"Property {property_} does not exist in the graph.")
+            raise NeatValueError(f"Property {property_} does not exist in the graph.")
         elif len(type_uri) > 1:
-            raise NeatSessionError(f"{property_} has multiple ids found in the graph: {','.join(property_uri)}.")
+            raise NeatValueError(
+                f"{property_} has multiple ids found in the graph: {humanize_collection(property_uri)}."
+            )
 
         if not self._state.instances.store.queries.type_with_property(type_uri[0], property_uri[0]):
-            raise NeatSessionError(f"Property {property_} is not defined for type {type_}. Cannot make connection")
+            raise NeatValueError(f"Property {property_} is not defined for type {type_}.")
         return type_uri[0], property_uri[0]
 
     def relationships_as_edges(self, min_relationship_types: int = 1, limit_per_type: int | None = None) -> None:
@@ -269,7 +281,10 @@ class InstancePrepareAPI:
             ```
 
         """
-        subject_type, subject_predicate = self._get_type_and_property_uris(*source)
+        try:
+            subject_type, subject_predicate = self._get_type_and_property_uris(*source)
+        except NeatValueError as e:
+            raise NeatSessionError(f"Cannot convert data type: {e}") from None
 
         transformer = ConvertLiteral(subject_type, subject_predicate, convert)
         self._state.instances.store.transform(transformer)
@@ -294,13 +309,81 @@ class InstancePrepareAPI:
         """
         subject_type: URIRef | None = None
         if source[0] is not None:
-            subject_type, subject_predicate = self._get_type_and_property_uris(*source)  # type: ignore[arg-type, assignment]
+            try:
+                subject_type, subject_predicate = self._get_type_and_property_uris(*source)  # type: ignore[arg-type, assignment]
+            except NeatValueError as e:
+                raise NeatSessionError(f"Cannot convert to type: {e}") from None
         else:
             subject_predicate = self._state.instances.store.queries.property_uri(source[1])[0]
 
         transformer = LiteralToEntity(subject_type, subject_predicate, type, new_property)
         self._state.instances.store.transform(transformer)
 
+    def connection_to_data_type(self, source: tuple[str | None, str]) -> None:
+        """Converts a connection to a data type.
+
+        Args:
+            source: The source of the conversion. A tuple of (type, property)
+                    where property is the property that should be converted.
+                    You can pass (None, property) to covert all properties with the given name.
+
+        Example:
+
+            Convert all properties 'labels' from a connection to a string:
+
+            ```python
+            neat.prepare.instances.connection_to_data_type(
+                (None, "labels")
+            )
+            ```
+
+        """
+        subject_type: URIRef | None = None
+        if source[0] is not None:
+            try:
+                subject_type, subject_predicate = self._get_type_and_property_uris(*source)  # type: ignore[arg-type, assignment]
+            except NeatValueError as e:
+                raise NeatSessionError(f"Cannot convert to data type: {e}") from None
+        else:
+            subject_predicate = self._state.instances.store.queries.property_uri(source[1])[0]
+        transformer = ConnectionToLiteral(subject_type, subject_predicate)
+        self._state.instances.store.transform(transformer)
+
+    def classic_to_core(self) -> None:
+        """Prepares extracted CDF classic graph for the Core Data model.
+
+        !!! note "This method bundles several graph transformers which"
+            - Convert relationships to edges
+            - Convert TimeSeries.type from bool to enum
+            - Convert all properties 'source' to a connection to SourceSystem
+            - Convert all properties 'labels' from a connection to a string
+
+        Example:
+            Apply classic to core transformations:
+            ```python
+            neat.prepare.instances.classic_to_core()
+            ```
+        """
+        self.relationships_as_edges()
+        self.convert_data_type(
+            ("TimeSeries", "isString"), convert=lambda is_string: "string" if is_string else "numeric"
+        )
+        self.property_to_type((None, "source"), "SourceSystem", "name")
+        for type_ in [
+            extractors.EventsExtractor._default_rdf_type,
+            extractors.AssetsExtractor._default_rdf_type,
+            extractors.FilesExtractor._default_rdf_type,
+        ]:
+            try:
+                subject_type, subject_predicate = self._get_type_and_property_uris(type_, "labels")
+            except NeatValueError:
+                # If the type_.labels does not exist, continue. This is not an error, it just means that the
+                # Labels is not used in the graph for that type.
+                continue
+            else:
+                transformer = ConnectionToLiteral(subject_type, subject_predicate)
+                self._state.instances.store.transform(transformer)
+
 
 @session_class_wrapper
 class DataModelPrepareAPI:
@@ -357,10 +440,9 @@ class DataModelPrepareAPI:
 
         """
         return self._state.rule_transform(
-            ToExtension(
+            ToEnterpriseModel(
                 new_model_id=data_model_id,
                 org_name=org_name,
-                type_="enterprise",
                 dummy_property=dummy_property,
                 move_connections=move_connections,
             )
@@ -394,10 +476,9 @@ class DataModelPrepareAPI:
 
         """
         return self._state.rule_transform(
-            ToExtension(
+            ToSolutionModel(
                 new_model_id=data_model_id,
                 org_name=org_name,
-                type_="solution",
                 mode=mode,
                 dummy_property=dummy_property,
             )
@@ -416,25 +497,32 @@ class DataModelPrepareAPI:
 
         Args:
             data_model_id: The data product data model id that is being created.
-            org_name: Organization name to use for the views in the new data model.
+            org_name: Organization name used as prefix if the model is building on top of a Cognite Data Model.
             include: The views to include in the data product data model. Can be either "same-space" or "all".
-                If you set same-space, only the views in the same space as the data model will be included.
+                If you set same-space, only the properties of the views in the same space as the data model
+                will be included.
         """
-        if self._client is None:
+
+        view_ids, container_ids = DMSValidation(
+            self._state.rule_store.last_verified_dms_rules
+        ).imported_views_and_containers_ids()
+        transformers: list[RulesTransformer] = []
+        if (view_ids or container_ids) and self._client is None:
             raise NeatSessionError(
                 "No client provided. You are referencing unknown views and containers in your data model, "
                 "NEAT needs a client to lookup the definitions. "
                 "Please set the client in the session, NeatSession(client=client)."
             )
-        transformers = [
-            IncludeReferenced(self._client, include_properties=True),
-            ToExtension(
+        elif (view_ids or container_ids) and self._client:
+            transformers.append(IncludeReferenced(self._client, include_properties=True))
+
+        transformers.append(
+            ToDataProductModel(
                 new_model_id=data_model_id,
                 org_name=org_name,
-                type_="data_product",
                 include=include,
-            ),
-        ]
+            )
+        )
 
         self._state.rule_transform(*transformers)
 

cognite/neat/_session/_read.py

@@ -1,18 +1,16 @@
-import tempfile
-from pathlib import Path
 from typing import Any, Literal, cast
 
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 
 from cognite.neat._client import NeatClient
-from cognite.neat._constants import COGNITE_SPACES
 from cognite.neat._graph import examples as instances_examples
 from cognite.neat._graph import extractors
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import NeatValueError
+from cognite.neat._issues.warnings import MissingCogniteClientWarning
 from cognite.neat._rules import catalog, importers
 from cognite.neat._rules.importers import BaseImporter
-from cognite.neat._utils.reader import GitHubReader, HttpFileReader, NeatReader, PathReader
+from cognite.neat._utils.reader import NeatReader
 
 from ._state import SessionState
 from ._wizard import NeatObjectType, RDFFileType, XMLFileType, object_wizard, rdf_dm_wizard, xml_format_wizard
@@ -167,9 +165,8 @@ class ExcelReadAPI(BaseReadAPI):
             io: file path to the Excel sheet
         """
         reader = NeatReader.create(io)
-        if not isinstance(reader, PathReader):
-            raise NeatValueError("Only file paths are supported for Excel files")
-        return self._state.rule_import(importers.ExcelImporter(reader.path))
+        path = reader.materialize_path()
+        return self._state.rule_import(importers.ExcelImporter(path))
 
 
 @session_class_wrapper
@@ -185,46 +182,32 @@ class ExcelExampleAPI(BaseReadAPI):
 
 @session_class_wrapper
 class YamlReadAPI(BaseReadAPI):
-    """Reads a yaml with either neat rules, or several toolkit yaml files to import Data Model(s) into NeatSession.
-
-    Args:
-        io: file path to the Yaml file in the case of "neat" yaml, or path to a zip folder or directory with several
-        Yaml files in the case of "toolkit".
+    def __call__(self, io: Any, format: Literal["neat", "toolkit"] = "neat") -> IssueList:
+        """Reads a yaml with either neat rules, or several toolkit yaml files to import Data Model(s) into NeatSession.
 
-    Example:
-        ```python
-        neat.read.yaml("path_to_toolkit_yamls")
-        ```
-    """
+        Args:
+            io: File path to the Yaml file in the case of "neat" yaml, or path to a zip folder or directory with several
+                Yaml files in the case of "toolkit".
+            format: The format of the yaml file(s). Can be either "neat" or "toolkit".
 
-    def __call__(self, io: Any, format: Literal["neat", "toolkit"] = "neat") -> IssueList:
+        Example:
+            ```python
+            neat.read.yaml("path_to_toolkit_yamls")
+            ```
+        """
         reader = NeatReader.create(io)
-        if not isinstance(reader, PathReader):
-            raise NeatValueError("Only file paths are supported for YAML files")
+        path = reader.materialize_path()
         importer: BaseImporter
         if format == "neat":
-            importer = importers.YAMLImporter.from_file(reader.path, source_name=f"{reader!s}")
+            importer = importers.YAMLImporter.from_file(path, source_name=f"{reader!s}")
         elif format == "toolkit":
-            if reader.path.is_file():
-                dms_importer = importers.DMSImporter.from_zip_file(reader.path)
-            elif reader.path.is_dir():
-                dms_importer = importers.DMSImporter.from_directory(reader.path)
-            else:
-                raise NeatValueError(f"Unsupported YAML format: {format}")
-
-            ref_containers = dms_importer.root_schema.referenced_container()
-            if system_container_ids := [
-                container_id for container_id in ref_containers if container_id.space in COGNITE_SPACES
-            ]:
-                if self._client is None:
-                    raise NeatSessionError(
-                        "No client provided. You are referencing Cognite containers in your data model, "
-                        "NEAT needs a client to lookup the container definitions. "
-                        "Please set the client in the session, NeatSession(client=client)."
-                    )
-                system_containers = self._client.loaders.containers.retrieve(system_container_ids)
-                dms_importer.update_referenced_containers(system_containers)
-
+            dms_importer = importers.DMSImporter.from_path(path, self._client)
+            if dms_importer.issue_list.has_warning_type(MissingCogniteClientWarning):
+                raise NeatSessionError(
+                    "No client provided. You are referencing Cognite containers in your data model, "
+                    "NEAT needs a client to lookup the container definitions. "
+                    "Please set the client in the session, NeatSession(client=client)."
+                )
             importer = dms_importer
         else:
             raise NeatValueError(f"Unsupported YAML format: {format}")
@@ -251,17 +234,9 @@ class CSVReadAPI(BaseReadAPI):
     """
 
     def __call__(self, io: Any, type: str, primary_key: str) -> None:
-        reader = NeatReader.create(io)
-        if isinstance(reader, HttpFileReader):
-            path = Path(tempfile.gettempdir()).resolve() / reader.name
-            path.write_text(reader.read_text(), encoding="utf-8", newline="\n")
-        elif isinstance(reader, PathReader):
-            path = reader.path
-        else:
-            raise NeatValueError("Only file paths are supported for CSV files")
         engine = import_engine()
         engine.set.format = "csv"
-        engine.set.file = path
+        engine.set.file = NeatReader.create(io).materialize_path()
         engine.set.type = type
         engine.set.primary_key = primary_key
         extractor = engine.create_extractor()
@@ -283,14 +258,7 @@ class XMLReadAPI(BaseReadAPI):
         io: Any,
         format: XMLFileType | None = None,
     ) -> None:
-        reader = NeatReader.create(io)
-        if isinstance(reader, GitHubReader):
-            path = Path(tempfile.gettempdir()).resolve() / reader.name
-            path.write_text(reader.read_text())
-        elif isinstance(reader, PathReader):
-            path = reader.path
-        else:
-            raise NeatValueError("Only file paths are supported for XML files")
+        path = NeatReader.create(io).materialize_path()
         if format is None:
             format = xml_format_wizard()
 
@@ -303,7 +271,7 @@ class XMLReadAPI(BaseReadAPI):
         else:
             raise NeatValueError("Only support XML files of DEXPI format at the moment.")
 
-    def dexpi(self, path):
+    def dexpi(self, io: Any) -> None:
         """Reads a DEXPI file into the NeatSession.
 
         Args:
@@ -314,13 +282,14 @@ class XMLReadAPI(BaseReadAPI):
             neat.read.xml.dexpi("url_or_path_to_dexpi_file")
             ```
         """
+        path = NeatReader.create(io).materialize_path()
         engine = import_engine()
         engine.set.format = "dexpi"
         engine.set.file = path
         extractor = engine.create_extractor()
         self._state.instances.store.write(extractor)
 
-    def aml(self, path):
+    def aml(self, io: Any):
         """Reads an AML file into NeatSession.
 
         Args:
@@ -331,6 +300,7 @@ class XMLReadAPI(BaseReadAPI):
             neat.read.xml.aml("url_or_path_to_aml_file")
             ```
         """
+        path = NeatReader.create(io).materialize_path()
         engine = import_engine()
         engine.set.format = "aml"
         engine.set.file = path
@@ -362,9 +332,7 @@ class RDFReadAPI(BaseReadAPI):
             ```
         """
         reader = NeatReader.create(io)
-        if not isinstance(reader, PathReader):
-            raise NeatValueError("Only file paths are supported for RDF files")
-        importer = importers.OWLImporter.from_file(reader.path, source_name=f"file {reader!s}")
+        importer = importers.OWLImporter.from_file(reader.materialize_path(), source_name=f"file {reader!s}")
         return self._state.rule_import(importer)
 
     def imf(self, io: Any) -> IssueList:
@@ -379,9 +347,7 @@ class RDFReadAPI(BaseReadAPI):
             ```
         """
         reader = NeatReader.create(io)
-        if not isinstance(reader, PathReader):
-            raise NeatValueError("Only file paths are supported for RDF files")
-        importer = importers.IMFImporter.from_file(reader.path, source_name=f"file {reader!s}")
+        importer = importers.IMFImporter.from_file(reader.materialize_path(), source_name=f"file {reader!s}")
         return self._state.rule_import(importer)
 
     def __call__(
@@ -408,10 +374,7 @@ class RDFReadAPI(BaseReadAPI):
 
         elif type == "instances":
             reader = NeatReader.create(io)
-            if not isinstance(reader, PathReader):
-                raise NeatValueError("Only file paths are supported for RDF files")
-
-            self._state.instances.store.write(extractors.RdfFileExtractor(reader.path))
+            self._state.instances.store.write(extractors.RdfFileExtractor(reader.materialize_path()))
             return IssueList()
         else:
             raise NeatSessionError(f"Expected data model or instances, got {type}")

cognite/neat/_session/_state.py

@@ -4,7 +4,7 @@ from typing import Literal, cast
 from cognite.neat._issues import IssueList
 from cognite.neat._rules.importers import BaseImporter, InferenceImporter
 from cognite.neat._rules.models import DMSRules, InformationRules
-from cognite.neat._rules.transformers import RulesTransformer, ToExtension
+from cognite.neat._rules.transformers import RulesTransformer, ToExtensionModel
 from cognite.neat._store import NeatGraphStore, NeatRulesStore
 from cognite.neat._store._rules_store import ModelEntity
 from cognite.neat._utils.rdf_ import uri_display_name
@@ -36,7 +36,7 @@ class SessionState:
                 f"Moving back {len(pruned)} {step_str} to the last {location}."
             )
         if (
-            any(isinstance(t, ToExtension) for t in transformer)
+            any(isinstance(t, ToExtensionModel) for t in transformer)
             and isinstance(self.rule_store.provenance[-1].target_entity, ModelEntity)
             and isinstance(self.rule_store.provenance[-1].target_entity.result, DMSRules | InformationRules)
         ):