cognite-neat 0.123.18__py3-none-any.whl → 0.123.20__py3-none-any.whl

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.123.18"
+__version__ = "0.123.20"
 __engine__ = "^2.0.4"

cognite/neat/core/_data_model/_shared.py

@@ -5,13 +5,13 @@ from cognite.neat.core._data_model.models import (
     ConceptualDataModel,
     PhysicalDataModel,
 )
+from cognite.neat.core._data_model.models._import_contexts import ImportContext
 from cognite.neat.core._data_model.models.conceptual._unverified import (
     UnverifiedConceptualDataModel,
 )
 from cognite.neat.core._data_model.models.physical._unverified import (
     UnverifiedPhysicalDataModel,
 )
-from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
 
 VerifiedDataModel: TypeAlias = ConceptualDataModel | PhysicalDataModel
 
@@ -32,7 +32,7 @@ class ImportedDataModel(Generic[T_UnverifiedDataModel]):
     """
 
     unverified_data_model: T_UnverifiedDataModel | None
-    context: dict[str, SpreadsheetRead]
+    context: ImportContext | None = None
 
     @classmethod
     def display_type_name(cls) -> str:

cognite/neat/core/_data_model/importers/__init__.py

@@ -1,6 +1,7 @@
 from ._base import BaseImporter
 from ._dict2data_model import DictImporter
 from ._dms2data_model import DMSImporter
+from ._graph2data_model import GraphImporter
 from ._rdf import InferenceImporter, OWLImporter, SubclassInferenceImporter
 from ._spreadsheet2data_model import ExcelImporter
 
@@ -9,13 +10,20 @@ __all__ = [
     "DMSImporter",
     "DictImporter",
     "ExcelImporter",
+    "GraphImporter",
     "InferenceImporter",
     "OWLImporter",
     "SubclassInferenceImporter",
 ]
 
 DataModelImporters = (
-    OWLImporter | DMSImporter | ExcelImporter | DictImporter | InferenceImporter | SubclassInferenceImporter
+    OWLImporter
+    | DMSImporter
+    | ExcelImporter
+    | DictImporter
+    | InferenceImporter
+    | SubclassInferenceImporter
+    | GraphImporter
 )
 
 

cognite/neat/core/_data_model/importers/_dict2data_model.py

@@ -128,4 +128,4 @@ class DictImporter(BaseImporter[T_UnverifiedDataModel]):
         if self._read_issues.has_errors:
             raise MultiValueError(self._read_issues.errors)
 
-        return ImportedDataModel[T_UnverifiedDataModel](data_model, {})
+        return ImportedDataModel[T_UnverifiedDataModel](data_model)

cognite/neat/core/_data_model/importers/_dms2data_model.py

@@ -276,7 +276,7 @@ class DMSImporter(BaseImporter[UnverifiedPhysicalDataModel]):
         self.issue_list.trigger_warnings()
         if self.issue_list.has_errors:
             raise MultiValueError(self.issue_list.errors)
-        return ImportedDataModel(user_data_model, {})
+        return ImportedDataModel(user_data_model, None)
 
     def _create_data_model_components(
         self,

cognite/neat/core/_data_model/importers/_graph2data_model.py

@@ -0,0 +1,299 @@
+import itertools
+import urllib.parse
+import warnings
+from collections import defaultdict
+from collections.abc import Iterable
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import cast
+
+from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
+from rdflib import RDF, RDFS, Namespace, URIRef
+from rdflib import Literal as RdfLiteral
+from rdflib.query import ResultRow
+
+from cognite.neat.core._config import GLOBAL_CONFIG
+from cognite.neat.core._constants import NEAT
+from cognite.neat.core._data_model._shared import ImportedDataModel
+from cognite.neat.core._data_model.models import UnverifiedConceptualDataModel
+from cognite.neat.core._data_model.models._import_contexts import GraphContext
+from cognite.neat.core._data_model.models.conceptual import (
+    UnverifiedConcept,
+    UnverifiedConceptualMetadata,
+    UnverifiedConceptualProperty,
+)
+from cognite.neat.core._data_model.models.entities import UnknownEntity
+from cognite.neat.core._issues.errors import NeatValueError
+from cognite.neat.core._issues.warnings import NeatValueWarning
+from cognite.neat.core._store import NeatInstanceStore
+from cognite.neat.core._utils.collection_ import iterate_progress_bar
+from cognite.neat.core._utils.rdf_ import split_uri
+
+from ._base import BaseImporter
+
+
+# Internal helper class
+@dataclass
+class _ReadProperties:
+    type_uri: URIRef
+    property_uri: URIRef
+    value_type: URIRef
+    parent_uri: URIRef | None
+    max_occurrence: int
+    instance_count: int
+
+
+class GraphImporter(BaseImporter[UnverifiedConceptualDataModel]):
+    """Infers a data model from the triples in a Graph Store.
+    Args:
+        store: The graph store to read from.
+        data_model_id: The data model id to be used for the imported rules.
+    """
+
+    _ORDERED_CONCEPTS_QUERY = """SELECT DISTINCT ?concept (count(?s) as ?instances )
+                           WHERE { ?s a ?concept }
+                           group by ?concept order by DESC(?instances)"""
+
+    _TYPE_PARENT_QUERY = f"""SELECT ?parent ?type
+                            WHERE {{ ?s a ?type .
+                            ?type <{RDFS.subClassOf}> ?parent }}"""
+
+    _PROPERTIES_QUERY = """SELECT DISTINCT ?property ?valueType
+                         WHERE {{
+                            ?s a <{type}> .
+                            ?s ?property ?object .
+                            OPTIONAL {{ ?object a ?objectType }}
+                            BIND(
+                               IF(
+                                    isLiteral(?object), datatype(?object),
+                                    IF(BOUND(?objectType), ?objectType, <{unknown_type}>)
+                                ) AS ?valueType
+                            )
+                        }}"""
+
+    _MAX_OCCURRENCE_QUERY = """SELECT (MAX(?count) AS ?maxCount)
+                            WHERE {{
+                              {{
+                                SELECT ?subject (COUNT(?object) AS ?count)
+                                WHERE {{
+                                  ?subject a <{type}> .
+                                  ?subject <{property}> ?object .
+                                }}
+                                GROUP BY ?subject
+                              }}
+                            }}"""
+
+    def __init__(
+        self,
+        store: NeatInstanceStore,
+        data_model_id: DataModelIdentifier = ("neat_space", "NeatInferredDataModel", "v1"),
+    ) -> None:
+        self.store = store
+        self.data_model_id = DataModelId.load(data_model_id)
+        if self.data_model_id.version is None:
+            raise NeatValueError("Version is required when setting a Data Model ID")
+
+    def to_data_model(self) -> ImportedDataModel[UnverifiedConceptualDataModel]:
+        metadata = self._create_default_metadata()
+        if not self.store.queries.select.has_data():
+            warnings.warn(NeatValueWarning("Cannot infer data model. No data found in the graph."), stacklevel=2)
+            return ImportedDataModel(UnverifiedConceptualDataModel(metadata, [], [], {}), None)
+
+        parent_by_child = self._read_parent_by_child_from_graph()
+        count_by_type = self._read_types_with_counts_from_graph()
+        if not count_by_type:
+            warnings.warn(
+                NeatValueWarning("Cannot infer data model. No RDF.type triples found in the graph."), stacklevel=2
+            )
+            return ImportedDataModel(UnverifiedConceptualDataModel(metadata, [], [], {}), None)
+
+        read_properties = self._read_concept_properties_from_graph(count_by_type, parent_by_child)
+
+        prefixes: dict[str, Namespace] = {}
+        concepts, properties = self._create_concepts_properties(read_properties, prefixes)
+
+        return ImportedDataModel(
+            UnverifiedConceptualDataModel(
+                metadata=metadata,
+                concepts=concepts,
+                properties=properties,
+                prefixes=prefixes,
+            ),
+            context=GraphContext({"inferred_from": count_by_type}),
+        )
+
+    def _read_parent_by_child_from_graph(self) -> dict[URIRef, URIRef]:
+        parent_by_child: dict[URIRef, URIRef] = {}
+        for result_row in self.store.dataset.query(self._TYPE_PARENT_QUERY):
+            parent_uri, child_uri = cast(tuple[URIRef, URIRef], result_row)
+            parent_by_child[child_uri] = parent_uri
+        return parent_by_child
+
+    def _read_types_with_counts_from_graph(self) -> dict[URIRef, int]:
+        count_by_type: dict[URIRef, int] = {}
+        # Reads all types and their instance counts from the graph
+        for result_row in self.store.dataset.query(self._ORDERED_CONCEPTS_QUERY):
+            type_uri, instance_count_literal = cast(tuple[URIRef, RdfLiteral], result_row)
+            count_by_type[type_uri] = instance_count_literal.toPython()
+        return count_by_type
+
+    def _read_concept_properties_from_graph(
+        self, count_by_type: dict[URIRef, int], parent_by_child: dict[URIRef, URIRef]
+    ) -> list[_ReadProperties]:
+        read_properties: list[_ReadProperties] = []
+
+        total_instance_count = sum(count_by_type.values())
+        iterable = count_by_type.items()
+        if GLOBAL_CONFIG.use_iterate_bar_threshold and total_instance_count > GLOBAL_CONFIG.use_iterate_bar_threshold:
+            iterable = iterate_progress_bar(iterable, len(count_by_type), "Inferring types...")  # type: ignore[assignment]
+
+        for type_uri, instance_count in iterable:
+            property_query = self._PROPERTIES_QUERY.format(type=type_uri, unknown_type=NEAT.UnknownType)
+            for result_row in self.store.dataset.query(property_query):
+                property_uri, value_type_uri = cast(tuple[URIRef, URIRef], result_row)
+                if property_uri == RDF.type:
+                    continue
+                occurrence_query = self._MAX_OCCURRENCE_QUERY.format(type=type_uri, property=property_uri)
+                max_occurrence = 1  # default value
+                # We know that the _MAX_OCCURRENCE_QUERY will return a ResultRow
+                occurrence_results = list(cast(ResultRow, self.store.dataset.query(occurrence_query)))
+                if occurrence_results and occurrence_results[0] and occurrence_results[0][0]:
+                    max_occurrence_literal = cast(RdfLiteral, occurrence_results[0][0])
+                    max_occurrence = int(max_occurrence_literal.toPython())
+                read_properties.append(
+                    _ReadProperties(
+                        type_uri=type_uri,
+                        property_uri=property_uri,
+                        parent_uri=parent_by_child.get(type_uri),
+                        value_type=value_type_uri,
+                        max_occurrence=max_occurrence,
+                        instance_count=instance_count,
+                    )
+                )
+        return read_properties
+
+    def _create_concepts_properties(
+        self, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
+    ) -> tuple[list[UnverifiedConcept], list[UnverifiedConceptualProperty]]:
+        concepts: list[UnverifiedConcept] = []
+        properties: list[UnverifiedConceptualProperty] = []
+
+        # Help for IDE
+        type_uri: URIRef
+        parent_uri: URIRef
+        for parent_uri, parent_concepts_properties_iterable in itertools.groupby(
+            sorted(read_properties, key=lambda x: x.parent_uri or NEAT.EmptyType),
+            key=lambda x: x.parent_uri or NEAT.EmptyType,
+        ):
+            parent_str: str | None = None
+            if parent_uri != NEAT.EmptyType:
+                parent_str, parent_cls = self._create_concept(parent_uri, set_instance_source=False, prefixes=prefixes)
+                concepts.append(parent_cls)
+
+            properties_by_concept_by_property = self._get_properties_by_concept_by_property(
+                parent_concepts_properties_iterable
+            )
+            for type_uri, properties_by_property_uri in properties_by_concept_by_property.items():
+                concept_str, concept = self._create_concept(
+                    type_uri, set_instance_source=True, prefixes=prefixes, implements=parent_str
+                )
+                concepts.append(concept)
+                for property_uri, read_properties in properties_by_property_uri.items():
+                    namespace, property_suffix = split_uri(property_uri)
+                    (self._add_uri_namespace_to_prefixes(namespace, prefixes),)
+                    properties.append(
+                        self._create_property(
+                            read_properties, concept_str, property_uri, urllib.parse.unquote(property_suffix), prefixes
+                        )
+                    )
+        return concepts, properties
+
+    @staticmethod
+    def _get_properties_by_concept_by_property(
+        parent_concept_properties_iterable: Iterable[_ReadProperties],
+    ) -> dict[URIRef, dict[URIRef, list[_ReadProperties]]]:
+        properties_by_concept_by_property: dict[URIRef, dict[URIRef, list[_ReadProperties]]] = {}
+        for concept_uri, concept_properties_iterable in itertools.groupby(
+            sorted(parent_concept_properties_iterable, key=lambda x: x.type_uri), key=lambda x: x.type_uri
+        ):
+            properties_by_concept_by_property[concept_uri] = defaultdict(list)
+            for read_prop in concept_properties_iterable:
+                properties_by_concept_by_property[concept_uri][read_prop.property_uri].append(read_prop)
+        return properties_by_concept_by_property
+
+    @classmethod
+    def _create_concept(
+        cls, type_uri: URIRef, set_instance_source: bool, prefixes: dict[str, Namespace], implements: str | None = None
+    ) -> tuple[str, UnverifiedConcept]:
+        namespace, suffix = split_uri(type_uri)
+        cls._add_uri_namespace_to_prefixes(namespace, prefixes)
+        concept_str = urllib.parse.unquote(suffix)
+        return concept_str, UnverifiedConcept(
+            concept=concept_str, implements=implements, instance_source=type_uri if set_instance_source else None
+        )
+
+    def _create_property(
+        self,
+        read_properties: list[_ReadProperties],
+        concept_str: str,
+        property_uri: URIRef,
+        property_id: str,
+        prefixes: dict[str, Namespace],
+    ) -> UnverifiedConceptualProperty:
+        first = read_properties[0]
+        value_type = self._get_value_type(read_properties, prefixes)
+        return UnverifiedConceptualProperty(
+            concept=concept_str,
+            property_=property_id,
+            max_count=first.max_occurrence,
+            value_type=value_type,
+            instance_source=[property_uri],
+        )
+
+    @classmethod
+    def _get_value_type(
+        cls, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
+    ) -> str | UnknownEntity:
+        value_types = {prop.value_type for prop in read_properties}
+        if len(value_types) == 1:
+            uri_ref = value_types.pop()
+            if uri_ref == NEAT.UnknownType:
+                return UnknownEntity()
+            namespace, suffix = split_uri(uri_ref)
+            cls._add_uri_namespace_to_prefixes(namespace, prefixes)
+            return suffix
+        uri_refs: list[str] = []
+        for uri_ref in value_types:
+            if uri_ref == NEAT.UnknownType:
+                return UnknownEntity()
+            namespace, suffix = split_uri(uri_ref)
+            cls._add_uri_namespace_to_prefixes(namespace, prefixes)
+            uri_refs.append(suffix)
+        # Sort the URIs to ensure deterministic output
+        return ", ".join(sorted(uri_refs))
+
+    def _create_default_metadata(self) -> UnverifiedConceptualMetadata:
+        now = datetime.now(timezone.utc)
+        name = self.data_model_id.external_id.replace("_", " ").title()
+        return UnverifiedConceptualMetadata(
+            space=self.data_model_id.space,
+            external_id=self.data_model_id.external_id,
+            # Validated in the constructor
+            version=cast(str, self.data_model_id.version),
+            name=name,
+            creator="NEAT",
+            created=now,
+            updated=now,
+            description="Inferred model from knowledge graph",
+        )
+
+    @classmethod
+    def _add_uri_namespace_to_prefixes(cls, namespace: str, prefixes: dict[str, Namespace]) -> None:
+        """Add URI to prefixes dict if not already present
+
+        Args:
+            URI: URI from which namespace is being extracted
+            prefixes: Dict of prefixes and namespaces
+        """
+        if Namespace(namespace) not in prefixes.values():
+            prefixes[f"prefix_{len(prefixes) + 1}"] = Namespace(namespace)

cognite/neat/core/_data_model/importers/_rdf/_base.py

@@ -130,7 +130,7 @@ class BaseRDFImporter(BaseImporter[UnverifiedConceptualDataModel]):
 
         data_model = UnverifiedConceptualDataModel.load(data_model_dict)
         self.issue_list.trigger_warnings()
-        return ImportedDataModel(data_model, {})
+        return ImportedDataModel(data_model)
 
     def _to_data_model_components(self) -> dict:
         raise NotImplementedError()

cognite/neat/core/_data_model/importers/_spreadsheet2data_model.py

@@ -22,6 +22,7 @@ from cognite.neat.core._data_model.models import (
     RoleTypes,
     SchemaCompleteness,
 )
+from cognite.neat.core._data_model.models._import_contexts import SpreadsheetContext
 from cognite.neat.core._issues import IssueList, MultiValueError
 from cognite.neat.core._issues.errors import (
     FileMissingRequiredFieldError,
@@ -271,7 +272,7 @@ class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
             raise MultiValueError(issue_list.errors)
 
         if user_read is None:
-            return ImportedDataModel(None, {})
+            return ImportedDataModel(None, None)
 
         sheets = user_read.sheets
         original_role = user_read.role
@@ -287,7 +288,7 @@ class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
             except Exception as e:
                 issue_list.append(FileReadError(self.filepath, f"Failed to delete temporary file: {e}"))
 
-        return ImportedDataModel(data_model, read_info_by_sheet)
+        return ImportedDataModel(data_model, SpreadsheetContext(read_info_by_sheet))
 
     @property
     def description(self) -> str:

cognite/neat/core/_data_model/models/_import_contexts.py

@@ -0,0 +1,82 @@
+from collections.abc import Hashable, ItemsView, Iterator, KeysView, Mapping, ValuesView
+from typing import TypeVar
+
+from rdflib import URIRef
+
+from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
+
+T_Key = TypeVar("T_Key", bound=Hashable)
+T_Value = TypeVar("T_Value")
+
+
+class ImportContext(dict, Mapping[T_Key, T_Value]):
+    def __init__(self, data: Mapping[T_Key, T_Value] | None = None) -> None:
+        super().__init__(data or {})
+
+    # The below methods are included to make better type hints in the IDE
+    def __getitem__(self, k: T_Key) -> T_Value:
+        return super().__getitem__(k)
+
+    def __setitem__(self, k: T_Key, v: T_Value) -> None:
+        super().__setitem__(k, v)
+
+    def __delitem__(self, k: T_Key) -> None:
+        super().__delitem__(k)
+
+    def __iter__(self) -> Iterator[T_Key]:
+        return super().__iter__()
+
+    def keys(self) -> KeysView[T_Key]:  # type: ignore[override]
+        return super().keys()
+
+    def values(self) -> ValuesView[T_Value]:  # type: ignore[override]
+        return super().values()
+
+    def items(self) -> ItemsView[T_Key, T_Value]:  # type: ignore[override]
+        return super().items()
+
+    def get(self, __key: T_Key, __default: T_Value | None = None) -> T_Value:  # type: ignore[override]
+        return super().get(__key, __default)
+
+    def pop(self, __key: T_Key, __default: T_Value | None = None) -> T_Value:  # type: ignore[override]
+        return super().pop(__key, __default)
+
+    def popitem(self) -> tuple[T_Key, T_Value]:
+        return super().popitem()
+
+
+class SpreadsheetContext(ImportContext[str, SpreadsheetRead]):
+    def __init__(self, data: dict[str, SpreadsheetRead] | None = None) -> None:
+        """Initialize the SpreadsheetContext with a dictionary of SpreadsheetRead objects.
+
+        Args:
+            data (dict[str, SpreadsheetRead]): A dictionary where keys are sheet names and values are
+                SpreadsheetRead objects containing the read data.
+        """
+        super().__init__(data or {})
+        for k, v in self.items():
+            if not isinstance(k, str):
+                raise TypeError(f"Expected string key, got {type(k).__name__}")
+            if not isinstance(v, SpreadsheetRead):
+                raise TypeError(f"Expected SpreadsheetRead for key '{k}', got {type(v).__name__}")
+
+
+class GraphContext(ImportContext[str, Mapping[URIRef, int]]):
+    def __init__(self, data: dict[str, Mapping[URIRef, int]] | None = None) -> None:
+        """Initialize the GraphContext with a dictionary of mappings from URIRef to int.
+
+        Args:
+            data (dict[str, Mapping[URIRef, int]]): A dictionary where keys are graph names and values are
+                mappings of URIRef to integer identifiers.
+        """
+        super().__init__(data or {})
+        for k, v in self.items():
+            if not isinstance(k, str):
+                raise TypeError(f"Expected string key, got {type(k).__name__}")
+            if not isinstance(v, Mapping):
+                raise TypeError(f"Expected Mapping[URIRef, int] for key '{k}', got {type(v).__name__}")
+            for uri, value in v.items():
+                if not isinstance(uri, URIRef):
+                    raise TypeError(f"Expected URIRef key in mapping for '{k}', got {type(uri).__name__}")
+                if not isinstance(value, int):
+                    raise TypeError(f"Expected int value in mapping for '{k}', got {type(value).__name__}")

cognite/neat/core/_data_model/models/conceptual/_validation.py

@@ -3,6 +3,7 @@ from collections import Counter, defaultdict
 
 from cognite.neat.core._constants import get_base_concepts
 from cognite.neat.core._data_model._constants import PATTERNS, EntityTypes
+from cognite.neat.core._data_model.models._import_contexts import ImportContext, SpreadsheetContext
 from cognite.neat.core._data_model.models.entities import ConceptEntity, UnknownEntity
 from cognite.neat.core._data_model.models.entities._multi_value import MultiValueTypeInfo
 from cognite.neat.core._issues import IssueList
@@ -21,7 +22,6 @@ from cognite.neat.core._issues.warnings._resources import (
     ResourceNotDefinedWarning,
     ResourceRegexViolationWarning,
 )
-from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
 from cognite.neat.core._utils.text import humanize_collection
 
 from ._verified import ConceptualDataModel
@@ -34,14 +34,14 @@ class ConceptualValidation:
     def __init__(
         self,
         data_model: ConceptualDataModel,
-        read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None,
+        context: ImportContext | None = None,
     ):
         # import here to avoid circular import issues
         from cognite.neat.core._data_model.analysis._base import DataModelAnalysis
 
         self.data_model = data_model
         self.analysis = DataModelAnalysis(self.data_model)
-        self._read_info_by_spreadsheet = read_info_by_spreadsheet or {}
+        self._read_info_by_spreadsheet = context if isinstance(context, SpreadsheetContext) else SpreadsheetContext({})
         self._metadata = data_model.metadata
         self._properties = data_model.properties
         self._concepts = data_model.concepts

cognite/neat/core/_data_model/models/physical/_validation.py

@@ -21,7 +21,9 @@ from cognite.neat.core._constants import (
     COGNITE_SPACES,
     DMS_CONTAINER_PROPERTY_SIZE_LIMIT,
     DMS_VIEW_CONTAINER_SIZE_LIMIT,
+    get_base_concepts,
 )
+from cognite.neat.core._data_model.models._import_contexts import ImportContext, SpreadsheetContext
 from cognite.neat.core._data_model.models.data_types import DataType
 from cognite.neat.core._data_model.models.entities import ContainerEntity, RawFilter
 from cognite.neat.core._data_model.models.entities._single_value import (
@@ -47,12 +49,12 @@ from cognite.neat.core._issues.warnings import (
     UndefinedViewWarning,
     user_modeling,
 )
+from cognite.neat.core._issues.warnings._models import ViewWithoutPropertiesWarning
 from cognite.neat.core._issues.warnings.user_modeling import (
     ContainerPropertyLimitWarning,
     DirectRelationMissingSourceWarning,
     NotNeatSupportedFilterWarning,
 )
-from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
 from cognite.neat.core._utils.text import humanize_collection
 
 from ._verified import PhysicalDataModel, PhysicalProperty
@@ -81,15 +83,23 @@ class PhysicalValidation:
         self,
         data_model: PhysicalDataModel,
         client: NeatClient | None = None,
-        read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None,
+        context: ImportContext | None = None,
     ) -> None:
+        # import here to avoid circular import issues
+        from cognite.neat.core._data_model.analysis._base import DataModelAnalysis
+
         self._data_model = data_model
         self._client = client
         self._metadata = data_model.metadata
         self._properties = data_model.properties
         self._containers = data_model.containers
         self._views = data_model.views
-        self._read_info_by_spreadsheet = read_info_by_spreadsheet or {}
+        self._read_info_by_spreadsheet = context if isinstance(context, SpreadsheetContext) else SpreadsheetContext()
+
+        self.analysis = DataModelAnalysis(physical=self._data_model)
+        self._cdf_concepts = {
+            ViewEntity.load(concept_as_string) for concept_as_string in get_base_concepts(base_model="CogniteCore")
+        }
 
     def imported_views_and_containers_ids(
         self, include_views_with_no_properties: bool = True
@@ -170,6 +180,9 @@ class PhysicalValidation:
         # Validated for duplicated resource
         issue_list.extend(self._duplicated_resources())
 
+        # Validate if views are defined (i.e. have at least one property defined, or inherited)
+        issue_list.extend(self._views_without_properties_exist())
+
         # Neat DMS classes Validation
         # These are errors that can only happen due to the format of the Neat DMS classes
         issue_list.extend(self._validate_raw_filter())
@@ -192,6 +205,23 @@ class PhysicalValidation:
         issue_list.extend(self._same_space_views_and_data_model())
         return issue_list
 
+    def _views_without_properties_exist(self) -> IssueList:
+        """Check if there are views that do not have any properties defined directly or inherited."""
+        issue_list = IssueList()
+        views = {view.view for view in self._views}
+        ancestors_by_view = self.analysis.implements_by_view(include_ancestors=True, include_different_space=True)
+        views_with_properties = self.analysis.defined_views().union(self._cdf_concepts)
+
+        if candidate_views := views.difference(views_with_properties):
+            for view in candidate_views:
+                # Here we check if at least one of the ancestors of the view has properties
+                if (ancestors := ancestors_by_view.get(view)) and ancestors.intersection(views_with_properties):
+                    continue
+
+                issue_list.append_if_not_exist(ViewWithoutPropertiesWarning(view_id=view.as_id()))
+
+        return issue_list
+
     def _same_space_views_and_data_model(self) -> IssueList:
         issue_list = IssueList()
 

cognite/neat/core/_data_model/transformers/_converters.py

@@ -31,6 +31,7 @@ from cognite.neat.core._constants import (
 )
 from cognite.neat.core._data_model._constants import PATTERNS, get_reserved_words
 from cognite.neat.core._data_model._shared import (
+    ImportContext,
     ImportedDataModel,
     ImportedUnverifiedDataModel,
     VerifiedDataModel,
@@ -93,7 +94,6 @@ from cognite.neat.core._issues.warnings._models import (
     SolutionModelBuildOnTopOfCDMWarning,
 )
 from cognite.neat.core._utils.rdf_ import get_inheritance_path
-from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
 from cognite.neat.core._utils.text import (
     NamingStandardization,
     humanize_collection,
@@ -2412,13 +2412,13 @@ class AddCogniteProperties(
                 concepts=new_classes,
                 prefixes=input_.prefixes,
             ),
-            context={},
+            context=None,
         )
 
     @staticmethod
     def _get_properties_by_concepts(
         properties: list[UnverifiedConceptualProperty],
-        read_context: dict[str, SpreadsheetRead],
+        read_context: ImportContext | None,
         default_space: str,
     ) -> dict[ConceptEntity, dict[str, UnverifiedConceptualProperty]]:
         issues = IssueList()
@@ -2438,7 +2438,7 @@ class AddCogniteProperties(
     @staticmethod
     def _get_dependencies_by_concepts(
         concepts: list[UnverifiedConcept],
-        read_context: dict[str, SpreadsheetRead],
+        read_context: ImportContext | None,
         default_space: str,
     ) -> dict[ConceptEntity, set[ConceptEntity]]:
         dependencies_by_concepts: dict[ConceptEntity, set[ConceptEntity]] = {}

cognite/neat/core/_issues/_contextmanagers.py

@@ -1,14 +1,16 @@
 import warnings
 from collections.abc import Iterator
 from contextlib import contextmanager
+from typing import TYPE_CHECKING
 
 from pydantic import ValidationError
 
-from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
-
 from ._base import IssueList, MultiValueError, NeatError
 from ._factory import from_pydantic_errors, from_warning
 
+if TYPE_CHECKING:
+    from cognite.neat.core._data_model.models._import_contexts import ImportContext
+
 
 @contextmanager
 def catch_warnings() -> Iterator[IssueList]:
@@ -26,12 +28,12 @@ def catch_warnings() -> Iterator[IssueList]:
 
 
 @contextmanager
-def catch_issues(read_info_by_sheet: dict[str, SpreadsheetRead] | None = None) -> Iterator[IssueList]:
+def catch_issues(context: "ImportContext | None" = None) -> Iterator[IssueList]:
     """This is an internal help function to handle issues and warnings.
 
     Args:
-        read_info_by_sheet (dict[str, SpreadsheetRead]): The read information by sheet. This is used to adjust
-            the row numbers in the errors/warnings.
+        context (ImportContext): The read context. This is used to adjust
+            the row numbers in the errors/warnings if the data is read from a spreadsheet.
 
     Returns:
         IssueList: The list of issues.
@@ -41,7 +43,7 @@ def catch_issues(read_info_by_sheet: dict[str, SpreadsheetRead] | None = None) -
         try:
             yield issues
         except ValidationError as e:
-            issues.extend(from_pydantic_errors(e.errors(), read_info_by_sheet))
+            issues.extend(from_pydantic_errors(e.errors(), context))
         except NeatError as single:
             issues.append(single)
         except MultiValueError as multi:

cognite/neat/core/_issues/_factory.py

@@ -1,18 +1,21 @@
-from typing import cast
+from typing import TYPE_CHECKING, cast
 from warnings import WarningMessage
 
 from pydantic_core import ErrorDetails
 
 from cognite.neat.core._issues._base import NeatError, NeatWarning
-from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
 
 from .errors import NeatValueError, SpreadsheetError
 
+if TYPE_CHECKING:
+    from cognite.neat.core._data_model.models._import_contexts import ImportContext, SpreadsheetContext
 
-def from_pydantic_errors(
-    errors: list[ErrorDetails], read_info_by_sheet: dict[str, SpreadsheetRead] | None = None
-) -> list[NeatError]:
-    read_info_by_sheet = read_info_by_sheet or {}
+
+def from_pydantic_errors(errors: list[ErrorDetails], context: "ImportContext | None" = None) -> list[NeatError]:
+    # To avoid circular import, we import SpreadsheetContext here.
+    from cognite.neat.core._data_model.models._import_contexts import SpreadsheetContext
+
+    read_info_by_sheet = context if isinstance(context, SpreadsheetContext) else SpreadsheetContext({})
     return [
         _from_pydantic_error(error, read_info_by_sheet)
         for error in errors
@@ -29,7 +32,7 @@ def from_warning(warning: WarningMessage) -> NeatWarning | None:
     return None
 
 
-def _from_pydantic_error(error: ErrorDetails, read_info_by_sheet: dict[str, SpreadsheetRead]) -> NeatError:
+def _from_pydantic_error(error: ErrorDetails, read_info_by_sheet: "SpreadsheetContext") -> NeatError:
     neat_error = _create_neat_value_error(error)
     location = error["loc"]
 

cognite/neat/core/_issues/warnings/_models.py

@@ -92,6 +92,15 @@ class NotSupportedHasDataFilterLimitWarning(CDFNotSupportedWarning):
     limit: int = DMS_VIEW_CONTAINER_SIZE_LIMIT
 
 
+@dataclass(unsafe_hash=True)
+class ViewWithoutPropertiesWarning(UserModelingWarning):
+    """View {view_id} has neither explicit properties nor implements views that have properties."""
+
+    fix = "Define properties for view or inherit properties by implementing view(s) that has properties."
+
+    view_id: ViewId
+
+
 @dataclass(unsafe_hash=True)
 class UndefinedConceptWarning(UserModelingWarning):
     """Concept {concept_id} has no explicit properties neither implements concepts that have properties."""

cognite/neat/core/_store/_instance.py

@@ -347,7 +347,7 @@ class NeatInstanceStore:
             )
             return issue_list
         _start = datetime.now(timezone.utc)
-        with catch_issues({}) as transform_issues:
+        with catch_issues() as transform_issues:
             transformer.transform(self.graph(named_graph))
         issue_list.extend(transform_issues)
         self.provenance.append(

cognite/neat/core/_utils/auxiliary.py

@@ -11,7 +11,7 @@ from typing import Any
 
 from cognite.client.exceptions import CogniteDuplicatedError, CogniteReadTimeout
 
-from cognite.neat.core._issues.errors import NeatImportError
+from cognite.neat.core._issues.errors._general import NeatImportError
 
 
 def local_import(module: str, extra: str) -> ModuleType:

cognite/neat/session/_base.py

@@ -33,6 +33,7 @@ from ._mapping import MappingAPI
 from ._plugin import PluginAPI
 from ._prepare import PrepareAPI
 from ._read import ReadAPI
+from ._session._data_model import DataModelAPI
 from ._set import SetAPI
 from ._show import ShowAPI
 from ._state import SessionState
@@ -115,6 +116,9 @@ class NeatSession:
         if load_engine != "skip" and (engine_version := load_neat_engine(client, load_engine)):
             print(f"Neat Engine {engine_version} loaded.")
 
+        # new API for data model operations
+        self.data_model = DataModelAPI(self._state)
+
     def _select_most_performant_store(self) -> Literal["memory", "oxigraph"]:
         """Select the most performant store based on the current environment."""
 

cognite/neat/session/_session/_data_model.py

@@ -0,0 +1,154 @@
+from typing import Any, Literal
+from zipfile import Path
+
+from cognite.neat.core._data_model import importers
+from cognite.neat.core._data_model.importers._base import BaseImporter
+from cognite.neat.core._issues._base import IssueList
+from cognite.neat.core._issues.errors._general import NeatValueError
+from cognite.neat.core._issues.warnings._general import MissingCogniteClientWarning
+from cognite.neat.core._utils.reader._base import NeatReader
+from cognite.neat.plugins._manager import get_plugin_manager
+from cognite.neat.plugins.data_model.importers._base import DataModelImporterPlugin
+from cognite.neat.session._state import SessionState
+from cognite.neat.session.exceptions import NeatSessionError, session_class_wrapper
+
+
+@session_class_wrapper
+class DataModelAPI:
+    """API for managing data models in NEAT session."""
+
+    def __init__(self, state: SessionState) -> None:
+        self._state = state
+        self.read = ReadAPI(state)
+
+
+@session_class_wrapper
+class ReadAPI:
+    def __init__(self, state: SessionState) -> None:
+        self._state = state
+
+    def __call__(self, name: str, io: str | Path, **kwargs: Any) -> IssueList:
+        """Provides access to the external plugins for data model importing.
+
+        Args:
+            name (str): The name of format (e.g. Excel) plugin is handling.
+            io (str | Path | None): The input/output interface for the plugin.
+            **kwargs (Any): Additional keyword arguments for the plugin.
+
+        !!! note "kwargs"
+            Users must consult the documentation of the plugin to understand
+            what keyword arguments are supported.
+        """
+
+        # These are internal readers that are not plugins
+        if name.strip().lower() == "excel":
+            return self.excel(io, **kwargs)
+        elif name.strip().lower() == "ontology":
+            return self.ontology(io)
+        elif name.strip().lower() == "yaml":
+            return self.yaml(io, **kwargs)
+        else:
+            return self._plugin(name, io, **kwargs)
+
+    def _plugin(self, name: str, io: str | Path, **kwargs: Any) -> IssueList:
+        """Provides access to the external plugins for data model importing.
+
+        Args:
+            name (str): The name of format (e.g. Excel) plugin is handling.
+            io (str | Path | None): The input/output interface for the plugin.
+            **kwargs (Any): Additional keyword arguments for the plugin.
+
+        !!! note "kwargs"
+            Users must consult the documentation of the plugin to understand
+            what keyword arguments are supported.
+        """
+
+        # Some plugins may not support the io argument
+        reader = NeatReader.create(io)
+        path = reader.materialize_path()
+
+        self._state._raise_exception_if_condition_not_met(
+            "Data Model Read",
+            empty_data_model_store_required=True,
+        )
+
+        plugin_manager = get_plugin_manager()
+        plugin = plugin_manager.get(name, DataModelImporterPlugin)
+
+        print(
+            f"You are using an external plugin {plugin.__name__}, which is not developed by the NEAT team."
+            "\nUse it at your own risk."
+        )
+
+        return self._state.data_model_import(plugin().configure(io=path, **kwargs))
+
+    def excel(self, io: str | Path, *, enable_manual_edit: bool = False) -> IssueList:
+        """Reads a Neat Excel Data Model to the data model store.
+        The data model spreadsheets may contain conceptual or physical data model definitions.
+
+            Args:
+                io: file path to the Excel sheet
+                enable_manual_edit: If True, the user will be able to re-import data model
+                    which where edit outside of NeatSession
+        """
+        reader = NeatReader.create(io)
+        path = reader.materialize_path()
+
+        self._state._raise_exception_if_condition_not_met(
+            "Read Excel Data Model",
+            empty_data_model_store_required=not enable_manual_edit,
+        )
+
+        return self._state.data_model_import(importers.ExcelImporter(path), enable_manual_edit)
+
+    def ontology(self, io: str | Path) -> IssueList:
+        """Reads an OWL ontology source into NeatSession.
+
+        Args:
+            io: file path or url to the OWL file
+        """
+
+        self._state._raise_exception_if_condition_not_met(
+            "Read Ontology",
+            empty_data_model_store_required=True,
+        )
+
+        reader = NeatReader.create(io)
+        importer = importers.OWLImporter.from_file(reader.materialize_path(), source_name=f"file {reader!s}")
+        return self._state.data_model_import(importer)
+
+    def yaml(self, io: str | Path, *, format: Literal["neat", "toolkit"] = "neat") -> IssueList:
+        """Reads a yaml with either neat data mode, 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".
+            format: The format of the yaml file(s). Can be either "neat" or "toolkit".
+
+        Example:
+            ```python
+            neat.read.yaml("path_to_toolkit_yamls")
+            ```
+        """
+        self._state._raise_exception_if_condition_not_met(
+            "Read YAML data model",
+            empty_data_model_store_required=True,
+        )
+        reader = NeatReader.create(io)
+        path = reader.materialize_path()
+        importer: BaseImporter
+        if format == "neat":
+            importer = importers.DictImporter.from_yaml_file(path, source_name=f"{reader!s}")
+        elif format == "toolkit":
+            dms_importer = importers.DMSImporter.from_path(path, self._state.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}")
+        return self._state.data_model_import(importer)

{cognite_neat-0.123.18.dist-info → cognite_neat-0.123.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.18
+Version: 0.123.20
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/

{cognite_neat-0.123.18.dist-info → cognite_neat-0.123.20.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=12StS1dzH9_MElqxGvLWrNsxCJl9Hv8A2a9D0E5OD_U,193
-cognite/neat/_version.py,sha256=fuTI2lcJbM6-5HASu5MdGJw07hZcivY-3tNoqelvUs0,47
+cognite/neat/_version.py,sha256=tUfZIhsXsTuZtKqqfKwmQe_3linzeB0aoFlEj2fZHAQ,47
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/_config.py,sha256=WT1BS8uADcFvGoUYOOfwFOVq_VBl472TisdoA3wLick,280
@@ -20,7 +20,7 @@ cognite/neat/core/_client/data_classes/schema.py,sha256=SpkBGbC2SUJG38Ixf1vYJINI
 cognite/neat/core/_client/data_classes/statistics.py,sha256=GU-u41cOTig0Y5pYhW5KqzCsuAUIX9tOmdizMEveYuw,4487
 cognite/neat/core/_data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/_data_model/_constants.py,sha256=ssiOprhd4bamglQnLTNjmqYn9mCBW-VOUbn08qDBbsM,5857
-cognite/neat/core/_data_model/_shared.py,sha256=gLEEMofI9prZLRNjHpwQe0uX9WoKd5qUt5pT1i_KAYo,2072
+cognite/neat/core/_data_model/_shared.py,sha256=at3-TT6pkdwtsjuz94P1lj1W7dO6_Sb3nQ3JSDBNLCY,2088
 cognite/neat/core/_data_model/analysis/__init__.py,sha256=v3hSfz7AEEqcmdjL71I09tP8Hl-gPZYOiDYMp_CW4vg,70
 cognite/neat/core/_data_model/analysis/_base.py,sha256=VT1orVf0xSSZrKnJoc-cJR1F1mtMn9Ybjk7UDO71aFA,24448
 cognite/neat/core/_data_model/catalog/__init__.py,sha256=zWG1-GONe8m05lV3gLAK_Xp7EJvcy6qLLl2B-RHHBjw,260
@@ -34,25 +34,27 @@ cognite/neat/core/_data_model/exporters/_data_model2excel.py,sha256=88ReyrsRqoIR
 cognite/neat/core/_data_model/exporters/_data_model2instance_template.py,sha256=9k8A70b1paeOHjvJRtbl6Xror1GD8AIMdo3cCx5aejE,6103
 cognite/neat/core/_data_model/exporters/_data_model2ontology.py,sha256=sZRxvbnv2reav3xUUZl6NIX-KqngoKr4qLmzTUvkhYk,22615
 cognite/neat/core/_data_model/exporters/_data_model2yaml.py,sha256=1dlb-v4sV8BArnX_6J4wpjQT7r-FinFAvoPDoMNkHYw,3284
-cognite/neat/core/_data_model/importers/__init__.py,sha256=5KqFRDz69FlXRcmqu7ejQl3YVXrpLXx-Q-HpwAeDbfA,1184
+cognite/neat/core/_data_model/importers/__init__.py,sha256=jkDKSGv5VdJgl44lmn7VQtD6-rqo09VFOr-tTB5Lfyc,1290
 cognite/neat/core/_data_model/importers/_base.py,sha256=pKe2OK86Wdj6CTj5bUgjY33ejZhRfD2eJbjcCapHD58,2013
 cognite/neat/core/_data_model/importers/_base_file_reader.py,sha256=m7CwMujEybYMfHWbTQOb7wBvLl2X1TmROkPelJMSaDA,1621
-cognite/neat/core/_data_model/importers/_dict2data_model.py,sha256=-1zmo8JkxJ9qiWuC7sUH7oSlpnPPKTMxZtm4WrRPO5A,4709
-cognite/neat/core/_data_model/importers/_dms2data_model.py,sha256=1luEyqEu51rNcFcEh-MjTnUY_5mnQU0761MDVHOuteo,29132
-cognite/neat/core/_data_model/importers/_spreadsheet2data_model.py,sha256=2QqrxQ9AI3LT9toH_gryIR52UecMsR-v44ljXedDCp4,11972
+cognite/neat/core/_data_model/importers/_dict2data_model.py,sha256=GEAD0Gs69rH-i-TjHV3Px-7Wo1Z7PfUqESsZt_58xUU,4705
+cognite/neat/core/_data_model/importers/_dms2data_model.py,sha256=X2iQ2VQvrruj1lEFVYN3Hl7J1R7NK3WT6FyXyl-ruyE,29134
+cognite/neat/core/_data_model/importers/_graph2data_model.py,sha256=yWi6Vlrc8rrcFM8hxHOVesr9D3etwJ0rbL6TJULrW9U,13684
+cognite/neat/core/_data_model/importers/_spreadsheet2data_model.py,sha256=wPb1ie_nmWNuHO0X6NW53pvqUDYGvNkHLvT8_UKFJIw,12079
 cognite/neat/core/_data_model/importers/_rdf/__init__.py,sha256=1yOjV2PKCxwH7uCTXVZhSdxtn5etmFX40cksvwtKcZ8,199
-cognite/neat/core/_data_model/importers/_rdf/_base.py,sha256=FKceKumKmhEGpMZvo1BwEewnUvfAsTF3Ax9fo1nxsGE,6020
+cognite/neat/core/_data_model/importers/_rdf/_base.py,sha256=XTdKqN4nf0d2Vvk56LShrDoyCQCg9MXvKwxXT0uMnGg,6016
 cognite/neat/core/_data_model/importers/_rdf/_inference2rdata_model.py,sha256=PCgM9-qGSLlupN7tYCFLHjivgICtMiahNry1ub8JCYk,28934
 cognite/neat/core/_data_model/importers/_rdf/_owl2data_model.py,sha256=l_89N1LewZVjSttcJkFAJj63JW8wI-THKJYjAxcNiDg,3093
 cognite/neat/core/_data_model/importers/_rdf/_shared.py,sha256=qibq94dFoy_g1ED5nIFYwHC_LYI4jI67HFVcMy7abrM,6665
 cognite/neat/core/_data_model/models/__init__.py,sha256=hmF7MDR1XmpLxYdMkOEuPuHUqOQKE4AgsuUqdc-ySSQ,1249
 cognite/neat/core/_data_model/models/_base_unverified.py,sha256=1Wfbp-tJaEF6hd1bFdp2FhTgPkInf-1ZokuEoVJRPxQ,6842
 cognite/neat/core/_data_model/models/_base_verified.py,sha256=nzPrlj7ZvYull_Fdh2zeDXz98hux-eQOdTGy9jhUtYA,15127
+cognite/neat/core/_data_model/models/_import_contexts.py,sha256=LAQbgwTbyIAY3at2hk6OksfK_CKavBwgwPcRFcszJcc,3436
 cognite/neat/core/_data_model/models/_types.py,sha256=70E8fiLdZkVF2sDUGPuDhzXNA5niVECkVDI7YN0NF60,5488
 cognite/neat/core/_data_model/models/data_types.py,sha256=uQ_u9KxCetLjxo-VtFzOXSxQuuf97Kg-9lfTTGzY6hc,10150
 cognite/neat/core/_data_model/models/conceptual/__init__.py,sha256=9A6myEV8s0-LqdXejaljqPj8S0pIpUL75rNdRDZzyR8,585
 cognite/neat/core/_data_model/models/conceptual/_unverified.py,sha256=VswgnTSjSCRzBX3z5HvintBGaWBPexxIs-7z7S4J57c,6298
-cognite/neat/core/_data_model/models/conceptual/_validation.py,sha256=u-BngcU1Bfe846CxJM-z_uu7En1bLJd7NBzeKOmS9RA,13806
+cognite/neat/core/_data_model/models/conceptual/_validation.py,sha256=CF1jYALTCQFAr5KUwplAzOLdxJGknIeJo-HpxVZsgMY,13859
 cognite/neat/core/_data_model/models/conceptual/_verified.py,sha256=BUB4Ur4kpBoWiwTf57tjxJ2l0tDTSbY7zGrg1g0yVNQ,13716
 cognite/neat/core/_data_model/models/entities/__init__.py,sha256=UsW-_6fwd-TW0WcnShPKf40h75l1elVn80VurUwRAic,1567
 cognite/neat/core/_data_model/models/entities/_constants.py,sha256=GXRzVfArwxF3C67VCkzy0JWTZRkRJUYXBQaaecrqcWc,351
@@ -67,11 +69,11 @@ cognite/neat/core/_data_model/models/mapping/_classic2core.yaml,sha256=ei-nuivNW
 cognite/neat/core/_data_model/models/physical/__init__.py,sha256=ONE_xLw1cxfw88rICG_RtbjCYUZm8yS2kBQ4Di3EGnA,987
 cognite/neat/core/_data_model/models/physical/_exporter.py,sha256=DPOytV-sIzpGJtfDEfi7G4RWnSCVNRLWe1KzY26ewmc,30083
 cognite/neat/core/_data_model/models/physical/_unverified.py,sha256=VyI-JULAu6kHJygUclDPH1JYjhf_XcO58tI9BkXORC0,18430
-cognite/neat/core/_data_model/models/physical/_validation.py,sha256=icgNNmvc60lIxI91NGGL5Bs7rR9evNtEubYYMMeKBVg,39529
+cognite/neat/core/_data_model/models/physical/_validation.py,sha256=AuBAecOTAVRbGh9VXZ6W91HsU7-B75ko7oaxlX4Mmqw,41140
 cognite/neat/core/_data_model/models/physical/_verified.py,sha256=4_7XUj6-x74DhL8qe-duXhlNnq6ANmShB7UpICjbQW4,26783
 cognite/neat/core/_data_model/transformers/__init__.py,sha256=N6yRBplAkrwwxoTAre_1BE_fdSZL5jihr7xTQjW3KnM,1876
 cognite/neat/core/_data_model/transformers/_base.py,sha256=7adUBJgDkXgRq_h7l1q2VsLQo3lE7-xmzmHdcF4QHq8,3133
-cognite/neat/core/_data_model/transformers/_converters.py,sha256=OazYC7DgAXXEvxdiaPfJSe2ZNkYn2mRqWhtvtvWK59g,111575
+cognite/neat/core/_data_model/transformers/_converters.py,sha256=Nyq2Iy2BYV0QMwpqLtdwHqpftl9sF1KvX5YVkIMPguc,111519
 cognite/neat/core/_data_model/transformers/_mapping.py,sha256=GwmTRnhiUPIG37CgUSIbjT7ZpWOwdWuBZ_HAIIBiKYY,19024
 cognite/neat/core/_data_model/transformers/_union_conceptual.py,sha256=sg-VGjrK7PwZS1U18ov-8Or00uR3pFLOaPOYT1edD8Q,8852
 cognite/neat/core/_data_model/transformers/_verification.py,sha256=yyPK6irhMGjVtwKxRIElSsPLUvLLVfk1lBAGny6jN5w,5193
@@ -120,8 +122,8 @@ cognite/neat/core/_instances/transformers/_rdfpath.py,sha256=4PIVpjlng59oTjoToS6
 cognite/neat/core/_instances/transformers/_value_type.py,sha256=-d18yefiGrx8CaVNLgJe0dF0zsMxtCQxlD2q2ZFGJ8U,15820
 cognite/neat/core/_issues/__init__.py,sha256=NQ-PN3fqp-hBPlpG2AZEND4cDn3_3UXAPfhLNtF5mtc,457
 cognite/neat/core/_issues/_base.py,sha256=LZhTF_QOQvCxFrGUnWmF9gQnuyr7nM3MqXf_r8KG7GY,12003
-cognite/neat/core/_issues/_contextmanagers.py,sha256=5-QXVmfplt4S_k2csrQ2xuezOOuE5_FxSA9GVGVG1s4,1582
-cognite/neat/core/_issues/_factory.py,sha256=ifEzHZcvPyO0ZGJo8T8CE20F5L4yRzrrGPxl9d87oIs,2829
+cognite/neat/core/_issues/_contextmanagers.py,sha256=EiLW9h60ZJ80GAsbEGvwf9LoID1ZPAUh-7KNn6i9cGk,1621
+cognite/neat/core/_issues/_factory.py,sha256=mcBaIF1H5SPkw9X80VsTgL1SHlZN6P2kXE75k3Y1WN8,3079
 cognite/neat/core/_issues/formatters.py,sha256=k2h_6wHW0ve52gXeuRoEcGwrxqqSe5sYFa_HycPiqW8,3323
 cognite/neat/core/_issues/errors/__init__.py,sha256=YkJeNnB1FDhYYTUbsb6iIm2rzI7usDYdjQDb4qrfFR4,2492
 cognite/neat/core/_issues/errors/_external.py,sha256=AaKwO5-AvX01d7Hd83vqYl1qNmMtgsmShmvyH8ioZAM,2354
@@ -132,18 +134,18 @@ cognite/neat/core/_issues/errors/_wrapper.py,sha256=clhuSwUuHy-FQXQopFIQRY8c_NZM
 cognite/neat/core/_issues/warnings/__init__.py,sha256=3MQS_elyRD3SG3iEWMWLRJDabth7upT3oX4WD0xxOh4,3263
 cognite/neat/core/_issues/warnings/_external.py,sha256=w-1R7ea6DXTIWqwlwMMjY0YxKDMSJ8gKAbp_nIIM1AI,1324
 cognite/neat/core/_issues/warnings/_general.py,sha256=_6dAFaMz-LIv7GsBBIBq2d-kmbuxVXKvU4jZeb7tjAo,972
-cognite/neat/core/_issues/warnings/_models.py,sha256=zTQuj2eAQOaX4CO8NljhX50Y8i9FUy3nc3x4l42YHmM,5479
+cognite/neat/core/_issues/warnings/_models.py,sha256=3AGdCteVRq7iK4TcGUYy7RxLIKGgc32NyigG8G489jA,5795
 cognite/neat/core/_issues/warnings/_properties.py,sha256=I3vqc1aL-ce_FRQNgQQy34RW7kQxcjbwhZIIVtGVmg8,3807
 cognite/neat/core/_issues/warnings/_resources.py,sha256=_iPRq0pRMmRu3LFjqZTaG3OqOzw4f8-Vc9G4Im__FHc,3578
 cognite/neat/core/_issues/warnings/user_modeling.py,sha256=Qn_S8TLw7MMYQaJcZBScJA48kz_PrTWz0NaepSR70Fk,4144
 cognite/neat/core/_store/__init__.py,sha256=wpsF8xjIQ5V21NOh45XQV813n_EzgyPOt0VVinYjnDI,140
 cognite/neat/core/_store/_data_model.py,sha256=6Eg_QH1ZlS4AO3c0_Ye8M-Y4_Ycf3mQPJBKyardGu9w,19646
-cognite/neat/core/_store/_instance.py,sha256=QFrhOyaVA-mOtRaKZDE0aYyEJlSYx1jImKC8iE3b75E,17406
+cognite/neat/core/_store/_instance.py,sha256=FzNtu_G9_VavrZLIhUZUqBGUs5Mknbbfi1hC0qFs5yQ,17404
 cognite/neat/core/_store/_provenance.py,sha256=aMEsq27dZ4NZ6XEC8hA0fIDF13i1ZP3QwnclLCRaNk4,7326
 cognite/neat/core/_store/exceptions.py,sha256=jcd1Gv65mfTdC4cipFAMWUNghEmdLS_lwPH1FB_ebxI,1656
 cognite/neat/core/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/_utils/auth.py,sha256=tP_diUZdtacUkM8TLlbSOyHlNcq9VGh-4o_7myWRU_o,14763
-cognite/neat/core/_utils/auxiliary.py,sha256=0A5dE0oLahErqAClF3OjRge_RFqnq3GBK6L3t-GpmuM,6850
+cognite/neat/core/_utils/auxiliary.py,sha256=nQAvIysrtigDTefuxTRGFiNUUBYy-iSDJPhvw-6RB50,6859
 cognite/neat/core/_utils/collection_.py,sha256=zVrSmm4045pjw6Pt6y4VPTIJ4dXdMJPyOV70LdFyDBM,2376
 cognite/neat/core/_utils/graph_transformations_report.py,sha256=ORVH7lw357TPOq4elU5lH46Qx6GCLVrSj-1nX6Ggk1U,1235
 cognite/neat/core/_utils/io_.py,sha256=D2Mg8sOxfBoDg3fC0jBzaxO3vkXmr0QvZSgYIv6xRkM,386
@@ -163,7 +165,7 @@ cognite/neat/plugins/data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 cognite/neat/plugins/data_model/importers/__init__.py,sha256=d4UJNCFR1DXPY7lv5LdCW2hiStEhvXiu2g_bRSIp1y0,89
 cognite/neat/plugins/data_model/importers/_base.py,sha256=M9zXp7tEu1SfJZRAJAtLmqpssdFcoi2X-5e25q_n_h8,1034
 cognite/neat/session/__init__.py,sha256=fxQ5URVlUnmEGYyB8Baw7IDq-uYacqkigbc4b-Pr9Fw,58
-cognite/neat/session/_base.py,sha256=6P63Kq4JJSi3S1CpcVLiG-dfKsN9Ml3o5GqZXjcLVvo,12937
+cognite/neat/session/_base.py,sha256=yxAItY6663wcmlrwxmzWkJorrrrm9oahpYOP-5RGwvQ,13081
 cognite/neat/session/_collector.py,sha256=-icWXOT9YBjAOVZfpPtBx-D39kpRP2RaQKdPtcr7Xm8,4233
 cognite/neat/session/_drop.py,sha256=ipD8RS_ZebPNpeIkhC7yqSSeo7e57TXMRxrh5_6IRik,4239
 cognite/neat/session/_experimental.py,sha256=0peZPZ9JpmzQE05wHbng2tWmPPLLTAVfWZEEUhdnI6o,1274
@@ -182,12 +184,14 @@ cognite/neat/session/_template.py,sha256=NCgrrwLT98DpLYoo3Wybr_OUXrEXpsJZjrJ83Kq
 cognite/neat/session/_to.py,sha256=_R-UB3iEIQoa12kTD7tuSrRDdbySQXQg_mzbn5t-7bg,19399
 cognite/neat/session/_wizard.py,sha256=hARNNzD5Zfkk_V147rIjOLVvrFaqzXGXWhZuH1NJG3M,1486
 cognite/neat/session/exceptions.py,sha256=z5jxwfVTXDCCFZKTTYVIaksNKqb9CMa2tyIZgyNL3Us,3475
+cognite/neat/session/_session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/session/_session/_data_model.py,sha256=id2chqUIA8tkxc9tTT7RiGWs-GzHC4LnzNkq-mfBIW4,6347
 cognite/neat/session/_state/README.md,sha256=o6N7EL98lgyWffw8IoEUf2KG5uSKveD5__TW45YzVjA,902
 cognite/neat/session/engine/__init__.py,sha256=D3MxUorEs6-NtgoICqtZ8PISQrjrr4dvca6n48bu_bI,120
 cognite/neat/session/engine/_import.py,sha256=1QxA2_EK613lXYAHKQbZyw2yjo5P9XuiX4Z6_6-WMNQ,169
 cognite/neat/session/engine/_interface.py,sha256=3W-cYr493c_mW3P5O6MKN1xEQg3cA7NHR_ev3zdF9Vk,533
 cognite/neat/session/engine/_load.py,sha256=g52uYakQM03VqHt_RDHtpHso1-mFFifH5M4T2ScuH8A,5198
-cognite_neat-0.123.18.dist-info/METADATA,sha256=q22nT23r2NuAAxf3lXnDcYch4KrhEl7ZPVptlcYiGm0,9172
-cognite_neat-0.123.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_neat-0.123.18.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.123.18.dist-info/RECORD,,
+cognite_neat-0.123.20.dist-info/METADATA,sha256=O8qdN1hncWgpZrnj6h4aeeoZlbtTG2Loe7qTGpHUuzA,9172
+cognite_neat-0.123.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.123.20.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.123.20.dist-info/RECORD,,