cognite-neat 0.100.1__py3-none-any.whl → 0.102.0__py3-none-any.whl

cognite/neat/_rules/importers/_dms2rules.py

@@ -1,4 +1,4 @@
-from collections import Counter
+from collections import Counter, defaultdict
 from collections.abc import Collection, Iterable, Sequence
 from datetime import datetime, timezone
 from pathlib import Path
@@ -222,12 +222,18 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         schema: DMSSchema,
         metadata: DMSInputMetadata | None = None,
     ) -> DMSInputRules:
+        enum_by_container_property = self._create_enum_collections(schema.containers.values())
+        enum_collection_by_container_property = {
+            key: enum_list[0].collection for key, enum_list in enum_by_container_property.items() if enum_list
+        }
+
         properties: list[DMSInputProperty] = []
         for view_id, view in schema.views.items():
             view_entity = ViewEntity.from_id(view_id)
-            class_entity = view_entity.as_class()
             for prop_id, prop in (view.properties or {}).items():
-                dms_property = self._create_dms_property(prop_id, prop, view_entity, class_entity)
+                dms_property = self._create_dms_property(
+                    prop_id, prop, view_entity, enum_collection_by_container_property
+                )
                 if dms_property is not None:
                     properties.append(dms_property)
 
@@ -237,8 +243,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
 
         metadata = metadata or DMSInputMetadata.from_data_model(data_model)
 
-        enum = self._create_enum_collections(schema.containers.values())
-
         return DMSInputRules(
             metadata=metadata,
             properties=properties,
@@ -248,7 +252,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                 for view_id, view in schema.views.items()
             ],
             nodes=[DMSInputNode.from_node_type(node_type) for node_type in schema.node_types.values()],
-            enum=enum,
+            enum=[enum for enum_list in enum_by_container_property.values() for enum in enum_list] or None,
         )
 
     @classmethod
@@ -267,7 +271,11 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         )
 
     def _create_dms_property(
-        self, prop_id: str, prop: ViewPropertyApply, view_entity: ViewEntity, class_entity: ClassEntity
+        self,
+        prop_id: str,
+        prop: ViewPropertyApply,
+        view_entity: ViewEntity,
+        enum_collection_by_container_property: dict[tuple[dm.ContainerId, str], str],
     ) -> DMSInputProperty | None:
         if isinstance(prop, dm.MappedPropertyApply) and prop.container not in self._all_containers_by_id:
             self.issue_list.append(
@@ -300,7 +308,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             )
             return None
 
-        value_type = self._get_value_type(prop, view_entity, prop_id)
+        value_type = self._get_value_type(prop, view_entity, prop_id, enum_collection_by_container_property)
         if value_type is None:
             return None
 
@@ -347,7 +355,11 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             return None
 
     def _get_value_type(
-        self, prop: ViewPropertyApply, view_entity: ViewEntity, prop_id
+        self,
+        prop: ViewPropertyApply,
+        view_entity: ViewEntity,
+        prop_id: str,
+        enum_collection_by_container_property: dict[tuple[dm.ContainerId, str], str],
     ) -> DataType | ViewEntity | DMSUnknownEntity | None:
         if isinstance(
             prop,
@@ -367,7 +379,16 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             elif isinstance(container_prop.type, PropertyTypeWithUnit) and container_prop.type.unit:
                 return DataType.load(f"{container_prop.type._type}(unit={container_prop.type.unit.external_id})")
             elif isinstance(container_prop.type, DMSEnum):
-                return Enum(collection=ClassEntity(suffix=prop_id), unknownValue=container_prop.type.unknown_value)
+                collection = enum_collection_by_container_property.get(
+                    (prop.container, prop.container_property_identifier)
+                )
+                if collection is None:
+                    # This should never happen
+                    raise ValueError(
+                        f"BUG in Neat: Enum for {prop.container}.{prop.container_property_identifier} not found."
+                    )
+
+                return Enum(collection=ClassEntity(suffix=collection), unknownValue=container_prop.type.unknown_value)
             else:
                 return DataType.load(container_prop.type._type)
         else:
@@ -477,15 +498,26 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         return candidates[0]
 
     @staticmethod
-    def _create_enum_collections(containers: Collection[dm.ContainerApply]) -> list[DMSInputEnum] | None:
-        enum_collections: list[DMSInputEnum] = []
+    def _create_enum_collections(
+        containers: Collection[dm.ContainerApply],
+    ) -> dict[tuple[dm.ContainerId, str], list[DMSInputEnum]]:
+        enum_by_container_property: dict[tuple[dm.ContainerId, str], list[DMSInputEnum]] = defaultdict(list)
+
+        is_external_id_unique = len({container.external_id for container in containers}) == len(containers)
+
         for container in containers:
+            container_id = container.as_id()
             for prop_id, prop in container.properties.items():
-                if isinstance(prop.type, DMSEnum):
-                    for identifier, value in prop.type.values.items():
-                        enum_collections.append(
-                            DMSInputEnum(
-                                collection=prop_id, value=identifier, name=value.name, description=value.description
-                            )
+                if not isinstance(prop.type, DMSEnum):
+                    continue
+                if is_external_id_unique:
+                    collection = f"{container.external_id}.{prop_id}"
+                else:
+                    collection = f"{container.space}:{container.external_id}.{prop_id}"
+                for identifier, value in prop.type.values.items():
+                    enum_by_container_property[(container_id, prop_id)].append(
+                        DMSInputEnum(
+                            collection=collection, value=identifier, name=value.name, description=value.description
                         )
-        return enum_collections
+                    )
+        return enum_by_container_property

cognite/neat/_rules/importers/_rdf/_base.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from cognite.client import data_modeling as dm
 from rdflib import Graph, Namespace, URIRef
 
-from cognite.neat._constants import get_default_prefixes
+from cognite.neat._constants import get_default_prefixes_and_namespaces
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import FileReadError
 from cognite.neat._issues.errors._general import NeatValueError
@@ -97,7 +97,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
             issue_list.append(FileReadError(filepath, str(e)))
 
         # bind key namespaces
-        for prefix, namespace in get_default_prefixes().items():
+        for prefix, namespace in get_default_prefixes_and_namespaces().items():
             graph.bind(prefix, namespace)
 
         return cls(

cognite/neat/_rules/models/_base_rules.py

@@ -147,11 +147,13 @@ class BaseMetadata(SchemaModel):
     Metadata model for data model
     """
 
-    role: ClassVar[RoleTypes]
-    aspect: ClassVar[DataModelAspect]
-    space: SpaceType = Field(alias="prefix")
-    external_id: DataModelExternalIdType = Field(alias="externalId")
-    version: VersionType
+    role: ClassVar[RoleTypes] = Field(description="Role of the person creating the data model")
+    aspect: ClassVar[DataModelAspect] = Field(description="Aspect of the data model")
+    space: SpaceType = Field(alias="prefix", description="The space where the data model is defined")
+    external_id: DataModelExternalIdType = Field(
+        alias="externalId", description="External identifier for the data model"
+    )
+    version: VersionType = Field(description="Version of the data model")
 
     name: str | None = Field(
         None,
@@ -160,21 +162,23 @@ class BaseMetadata(SchemaModel):
         max_length=255,
     )
 
-    description: str | None = Field(None, min_length=1, max_length=1024)
+    description: str | None = Field(
+        None, min_length=1, max_length=1024, description="Short description of the data model"
+    )
 
     creator: StrListType = Field(
         description=(
-            "List of contributors to the data model creation, "
+            "List of contributors (comma seperated) to the data model creation, "
             "typically information architects are considered as contributors."
         ),
     )
 
     created: datetime = Field(
-        description=("Date of the data model creation"),
+        description="Date of the data model creation",
     )
 
     updated: datetime = Field(
-        description=("Date of the data model update"),
+        description="Date of the data model update",
     )
 
     @field_validator("*", mode="before")

cognite/neat/_rules/models/dms/_rules.py

@@ -94,20 +94,60 @@ def _metadata(context: Any) -> DMSMetadata | None:
 
 
 class DMSProperty(SheetRow):
-    view: ViewEntityType = Field(alias="View")
-    view_property: DmsPropertyType = Field(alias="View Property")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
-    connection: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None = Field(None, alias="Connection")
-    value_type: DataType | 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")
-    container: ContainerEntityType | None = Field(None, alias="Container")
-    container_property: DmsPropertyType | None = Field(None, alias="Container Property")
-    index: StrListType | None = Field(None, alias="Index")
-    constraint: StrListType | None = Field(None, alias="Constraint")
+    view: ViewEntityType = Field(alias="View", description="The property identifier.")
+    view_property: DmsPropertyType = Field(alias="View Property", description="The ViewId this property belongs to")
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the property")
+    description: str | None = Field(alias="Description", default=None, description="Short description of the property")
+    connection: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None = Field(
+        None,
+        alias="Connection",
+        description="nly applies to connection between views. "
+        "It specify how the connection should be implemented in CDF.",
+    )
+    value_type: DataType | ViewEntity | DMSUnknownEntity = Field(
+        alias="Value Type",
+        description="Value type that the property can hold. "
+        "It takes either subset of CDF primitive types or a View id",
+    )
+    nullable: bool | None = Field(
+        default=None,
+        alias="Nullable",
+        description="Used to indicate whether the property is required or not. Only applies to primitive type.",
+    )
+    immutable: bool | None = Field(
+        default=None,
+        alias="Immutable",
+        description="sed to indicate whether the property is can only be set once. Only applies to primitive type.",
+    )
+    is_list: bool | None = Field(
+        default=None,
+        alias="Is List",
+        description="Used to indicate whether the property holds single or multiple values (list). "
+        "Only applies to primitive types.",
+    )
+    default: str | int | dict | None = Field(
+        None, alias="Default", description="Specifies default value for the property."
+    )
+    container: ContainerEntityType | None = Field(
+        None,
+        alias="Container",
+        description="Specifies container where the property is stored. Only applies to primitive type.",
+    )
+    container_property: DmsPropertyType | None = Field(
+        None,
+        alias="Container Property",
+        description="Specifies property in the container where the property is stored. Only applies to primitive type.",
+    )
+    index: StrListType | None = Field(
+        None,
+        alias="Index",
+        description="The names of the indexes (comma separated) that should be created for the property.",
+    )
+    constraint: StrListType | None = Field(
+        None,
+        alias="Constraint",
+        description="The names of the uniquness (comma separated) that should be created for the property.",
+    )
     logical: URIRefType | None = Field(
         None,
         alias="Logical",
@@ -192,11 +232,21 @@ class DMSProperty(SheetRow):
 
 
 class DMSContainer(SheetRow):
-    container: ContainerEntityType = Field(alias="Container")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
-    constraint: ContainerEntityList | None = Field(None, alias="Constraint")
-    used_for: Literal["node", "edge", "all"] | None = Field("all", alias="Used For")
+    container: ContainerEntityType = Field(
+        alias="Container", description="Container id, strongly advised to PascalCase usage."
+    )
+    name: str | None = Field(
+        alias="Name", default=None, description="Human readable name of the container being defined."
+    )
+    description: str | None = Field(
+        alias="Description", default=None, description="Short description of the node being defined."
+    )
+    constraint: ContainerEntityList | None = Field(
+        None, alias="Constraint", description="List of required (comma separated) constraints for the container"
+    )
+    used_for: Literal["node", "edge", "all"] | None = Field(
+        "all", alias="Used For", description=" Whether the container is used for nodes, edges or all."
+    )
 
     def _identifier(self) -> tuple[Hashable, ...]:
         return (self.container,)
@@ -240,12 +290,22 @@ class DMSContainer(SheetRow):
 
 
 class DMSView(SheetRow):
-    view: ViewEntityType = Field(alias="View")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
-    implements: ViewEntityList | None = Field(None, alias="Implements")
-    filter_: HasDataFilter | NodeTypeFilter | RawFilter | None = Field(None, alias="Filter")
-    in_model: bool = Field(True, alias="In Model")
+    view: ViewEntityType = Field(alias="View", description="View id, strongly advised to PascalCase usage.")
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the view being defined.")
+    description: str | None = Field(
+        alias="Description", default=None, description="Short description of the view being defined "
+    )
+    implements: ViewEntityList | None = Field(
+        None,
+        alias="Implements",
+        description="List of parent view ids (comma separated) which the view being defined implements.",
+    )
+    filter_: HasDataFilter | NodeTypeFilter | RawFilter | None = Field(
+        None, alias="Filter", description="Explicitly define the filter for the view."
+    )
+    in_model: bool = Field(
+        True, alias="In Model", description="Indicates whether the view being defined is a part of the data model."
+    )
     logical: URIRefType | None = Field(
         None,
         alias="Logical",
@@ -292,10 +352,14 @@ class DMSView(SheetRow):
 
 
 class DMSNode(SheetRow):
-    node: DMSNodeEntity = Field(alias="Node")
-    usage: Literal["type", "collection"] = Field(alias="Usage")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
+    node: DMSNodeEntity = Field(alias="Node", description="The type definition of the node.")
+    usage: Literal["type", "collection"] = Field(
+        alias="Usage", description="What the usage of the node is in the data model."
+    )
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the node being defined.")
+    description: str | None = Field(
+        alias="Description", default=None, description="Short description of the node being defined."
+    )
 
     def _identifier(self) -> tuple[Hashable, ...]:
         return (self.node,)
@@ -316,10 +380,10 @@ class DMSNode(SheetRow):
 
 
 class DMSEnum(SheetRow):
-    collection: ClassEntityType = Field(alias="Collection")
-    value: str = Field(alias="Value")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
+    collection: ClassEntityType = Field(alias="Collection", description="The collection this enum belongs to.")
+    value: str = Field(alias="Value", description="The value of the enum.")
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the enum.")
+    description: str | None = Field(alias="Description", default=None, description="Short description of the enum.")
 
     def _identifier(self) -> tuple[Hashable, ...]:
         return self.collection, self.value
@@ -332,12 +396,20 @@ class DMSEnum(SheetRow):
 
 
 class DMSRules(BaseRules):
-    metadata: DMSMetadata = Field(alias="Metadata")
-    properties: SheetList[DMSProperty] = Field(alias="Properties")
-    views: SheetList[DMSView] = Field(alias="Views")
-    containers: SheetList[DMSContainer] | None = Field(None, alias="Containers")
-    enum: SheetList[DMSEnum] | None = Field(None, alias="Enum")
-    nodes: SheetList[DMSNode] | None = Field(None, alias="Nodes")
+    metadata: DMSMetadata = Field(alias="Metadata", description="Contains information about the data model.")
+    properties: SheetList[DMSProperty] = Field(
+        alias="Properties", description="Contains the properties of the data model."
+    )
+    views: SheetList[DMSView] = Field(alias="Views", description="Contains the views of the data model.")
+    containers: SheetList[DMSContainer] | None = Field(
+        None,
+        alias="Containers",
+        description="Contains the definition containers that are the physical storage of the data model.",
+    )
+    enum: SheetList[DMSEnum] | None = Field(None, alias="Enum", description="Contains the definition of enum values.")
+    nodes: SheetList[DMSNode] | None = Field(
+        None, alias="Nodes", description="Contains the definition of the node types."
+    )
 
     @field_validator("views")
     def matching_version_and_space(cls, value: SheetList[DMSView], info: ValidationInfo) -> SheetList[DMSView]:

cognite/neat/_rules/models/information/_rules.py

@@ -7,7 +7,7 @@ from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo
 from rdflib import Namespace, URIRef
 
-from cognite.neat._constants import get_default_prefixes
+from cognite.neat._constants import get_default_prefixes_and_namespaces
 from cognite.neat._issues.errors import NeatValueError, PropertyDefinitionError
 from cognite.neat._rules._constants import EntityTypes
 from cognite.neat._rules.models._base_rules import (
@@ -68,10 +68,16 @@ class InformationClass(SheetRow):
         implements: Which classes the current class implements.
     """
 
-    class_: ClassEntityType = Field(alias="Class")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
-    implements: ClassEntityList | None = Field(alias="Implements", default=None)
+    class_: ClassEntityType = Field(
+        alias="Class", description="Class id being defined, use strongly advise `PascalCase` usage."
+    )
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the class.")
+    description: str | None = Field(alias="Description", default=None, description="Short description of the class.")
+    implements: ClassEntityList | None = Field(
+        alias="Implements",
+        default=None,
+        description="List of classes (comma separated) that the current class implements (parents).",
+    )
 
     physical: URIRefType | None = Field(
         None,
@@ -119,17 +125,40 @@ class InformationProperty(SheetRow):
               knowledge graph. Defaults to None (no transformation)
     """
 
-    class_: ClassEntityType = Field(alias="Class")
-    property_: InformationPropertyType = Field(alias="Property")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
+    class_: ClassEntityType = Field(
+        alias="Class", description="Class id that the property is defined for, strongly advise `PascalCase` usage."
+    )
+    property_: InformationPropertyType = Field(
+        alias="Property", description="Property id, strongly advised to `camelCase` usage."
+    )
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the property.")
+    description: str | None = Field(alias="Description", default=None, description="Short description of the property.")
     value_type: DataType | ClassEntityType | MultiValueTypeType | UnknownEntity = Field(
-        alias="Value Type", union_mode="left_to_right"
+        alias="Value Type",
+        union_mode="left_to_right",
+        description="Value type that the property can hold. It takes either subset of XSD type or a class defined.",
+    )
+    min_count: int | None = Field(
+        alias="Min Count",
+        default=None,
+        description="Minimum number of values that the property can hold. "
+        "If no value is provided, the default value is  `0`, "
+        "which means that the property is optional.",
+    )
+    max_count: int | float | None = Field(
+        alias="Max Count",
+        default=None,
+        description="Maximum number of values that the property can hold. "
+        "If no value is provided, the default value is  `inf`, "
+        "which means that the property can hold any number of values (listable).",
+    )
+    default: Any | None = Field(alias="Default", default=None, description="Default value of the property.")
+    transformation: RDFPath | None = Field(
+        alias="Transformation",
+        default=None,
+        description="The rule that is used to populate the data model. "
+        "The rule is provided in a RDFPath query syntax which is converted to downstream solution query (e.g. SPARQL).",
     )
-    min_count: int | None = Field(alias="Min Count", default=None)
-    max_count: int | float | None = Field(alias="Max Count", default=None)
-    default: Any | None = Field(alias="Default", default=None)
-    transformation: RDFPath | None = Field(alias="Transformation", default=None)
     inherited: bool = Field(
         default=False,
         exclude=True,
@@ -221,17 +250,21 @@ class InformationProperty(SheetRow):
 
 
 class InformationRules(BaseRules):
-    metadata: InformationMetadata = Field(alias="Metadata")
-    properties: SheetList[InformationProperty] = Field(alias="Properties")
-    classes: SheetList[InformationClass] = Field(alias="Classes")
-    prefixes: dict[str, Namespace] = Field(default_factory=get_default_prefixes, alias="Prefixes")
+    metadata: InformationMetadata = Field(alias="Metadata", description="Metadata for the logical data model")
+    properties: SheetList[InformationProperty] = Field(alias="Properties", description="List of properties")
+    classes: SheetList[InformationClass] = Field(alias="Classes", description="List of classes")
+    prefixes: dict[str, Namespace] = Field(
+        alias="Prefixes",
+        default_factory=get_default_prefixes_and_namespaces,
+        description="the definition of the prefixes that are used in the semantic data model",
+    )
 
     @field_validator("prefixes", mode="before")
     def parse_str(cls, values: Any) -> Any:
         if isinstance(values, dict):
             return {key: Namespace(value) if isinstance(value, str) else value for key, value in values.items()}
         elif values is None:
-            values = get_default_prefixes()
+            values = get_default_prefixes_and_namespaces()
         return values
 
     def as_dms_rules(self) -> "DMSRules":

cognite/neat/_session/_base.py

@@ -38,6 +38,24 @@ from .exceptions import NeatSessionError, session_class_wrapper
 
 @session_class_wrapper
 class NeatSession:
+    """Creates a new NeatSession.
+
+    This is the main entry point for using Neat. It provides access to the different APIs that can be used to read,
+    write, and manipulate data and data models.
+
+    Args:
+        client: The CogniteClient to use for reading and writing data.
+        storage: The storage type to use for storing data and data models. Can be either "memory" or "oxigraph".
+            In "memory" mode works well for small data sets and when only working with data models. It is works
+            well for all notebook environments. In "oxigraph" mode, the data is stored in an Oxigraph database. This
+            is more performant for larger data sets and when working with data. Note that this option requires
+            additional dependencies to be installed and is not available in CDF Notebooks.
+        verbose: Whether to print information about the operations being performed.
+        load_engine: Whether to load the Neat Engine. Can be "newest", "cache", or "skip". "newest" will always
+            check for the newest version of the engine. "cache" will load the engine if it has been downloaded before.
+            "skip" will not load the engine.
+    """
+
     def __init__(
         self,
         client: CogniteClient | None = None,

cognite/neat/_session/_prepare.py

@@ -7,8 +7,18 @@ from cognite.client.data_classes.data_modeling import DataModelIdentifier
 from rdflib import URIRef
 
 from cognite.neat._client import NeatClient
-from cognite.neat._constants import DEFAULT_NAMESPACE
-from cognite.neat._graph.transformers import RelationshipAsEdgeTransformer
+from cognite.neat._constants import (
+    DEFAULT_NAMESPACE,
+    get_default_prefixes_and_namespaces,
+)
+from cognite.neat._graph.transformers import (
+    AttachPropertyFromTargetToSource,
+    PruneDeadEndEdges,
+    PruneInstancesOfUnknownType,
+    PruneTypes,
+    RelationshipAsEdgeTransformer,
+    Transformers,
+)
 from cognite.neat._graph.transformers._rdfpath import MakeConnectionOnExactMatch
 from cognite.neat._rules._shared import InputRules, ReadRules
 from cognite.neat._rules.importers import DMSImporter
@@ -50,6 +60,79 @@ class InstancePrepareAPI:
         self._state = state
         self._verbose = verbose
 
+    def dexpi(self) -> None:
+        """Prepares extracted DEXPI graph for further usage in CDF
+
+        This method bundles several graph transformers which:
+        - attach values of generic attributes to nodes
+        - create associations between nodes
+        - remove unused generic attributes
+        - remove associations between nodes that do not exist in the extracted graph
+        - remove edges to nodes that do not exist in the extracted graph
+
+        and therefore safeguard CDF from a bad graph
+        """
+
+        DEXPI = get_default_prefixes_and_namespaces()["dexpi"]
+
+        transformers = [
+            # Remove any instance which type is unknown
+            PruneInstancesOfUnknownType(),
+            # Directly connect generic attributes
+            AttachPropertyFromTargetToSource(
+                target_property=DEXPI.Value,
+                target_property_holding_new_property=DEXPI.Name,
+                target_node_type=DEXPI.GenericAttribute,
+                delete_target_node=True,
+            ),
+            # Directly connect associations
+            AttachPropertyFromTargetToSource(
+                target_property=DEXPI.ItemID,
+                target_property_holding_new_property=DEXPI.Type,
+                target_node_type=DEXPI.Association,
+                delete_target_node=True,
+            ),
+            # Remove unused generic attributes and associations
+            PruneTypes([DEXPI.GenericAttribute, DEXPI.Association]),
+            # Remove edges to nodes that do not exist in the extracted graph
+            PruneDeadEndEdges(),
+        ]
+
+        for transformer in transformers:
+            self._state.instances.store.transform(cast(Transformers, transformer))
+
+    def aml(self) -> None:
+        """Prepares extracted AutomationML graph for further usage in CDF
+
+        This method bundles several graph transformers which:
+        - attach values of attributes to nodes
+        - remove unused attributes
+        - remove edges to nodes that do not exist in the extracted graph
+
+        and therefore safeguard CDF from a bad graph
+        """
+
+        AML = get_default_prefixes_and_namespaces()["aml"]
+
+        transformers = [
+            # Remove any instance which type is unknown
+            PruneInstancesOfUnknownType(),
+            # Directly connect generic attributes
+            AttachPropertyFromTargetToSource(
+                target_property=AML.Value,
+                target_property_holding_new_property=AML.Name,
+                target_node_type=AML.Attribute,
+                delete_target_node=True,
+            ),
+            # Prune unused attributes
+            PruneTypes([AML.Attribute]),
+            # # Remove edges to nodes that do not exist in the extracted graph
+            PruneDeadEndEdges(),
+        ]
+
+        for transformer in transformers:
+            self._state.instances.store.transform(cast(Transformers, transformer))
+
     def make_connection_on_exact_match(
         self,
         source: tuple[str, str],

cognite/neat/_session/_read.py

@@ -17,7 +17,7 @@ from cognite.neat._rules.importers import BaseImporter
 from cognite.neat._store._provenance import Activity as ProvenanceActivity
 from cognite.neat._store._provenance import Change
 from cognite.neat._store._provenance import Entity as ProvenanceEntity
-from cognite.neat._utils.reader import GitHubReader, NeatReader, PathReader
+from cognite.neat._utils.reader import GitHubReader, HttpFileReader, NeatReader, PathReader
 
 from ._state import SessionState
 from ._wizard import NeatObjectType, RDFFileType, XMLFileType, object_wizard, rdf_dm_wizard, xml_format_wizard
@@ -244,9 +244,9 @@ class YamlReadAPI(BaseReadAPI):
 class CSVReadAPI(BaseReadAPI):
     def __call__(self, io: Any, type: str, primary_key: str) -> None:
         reader = NeatReader.create(io)
-        if isinstance(reader, GitHubReader):
+        if isinstance(reader, HttpFileReader):
             path = Path(tempfile.gettempdir()).resolve() / reader.name
-            path.write_text(reader.read_text())
+            path.write_text(reader.read_text(), encoding="utf-8", newline="\n")
         elif isinstance(reader, PathReader):
             path = reader.path
         else:

cognite/neat/_session/_to.py

@@ -150,7 +150,7 @@ class CDFToAPI:
         - "skip": If any component already exists, it will be skipped.
         - "update": If any component already exists, it will be updated.
         - "force": If any component already exists, and the update fails, it will be deleted and recreated.
-        - "recreate": All components will be deleted and recreated.
+        - "recreate": All components will be deleted and recreated. The exception is spaces, which will be updated.
 
         """