cognite-neat 0.123.17__tar.gz → 0.123.19__tar.gz

{cognite_neat-0.123.17 → cognite_neat-0.123.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.17
+Version: 0.123.19
 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.19/cognite/neat/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.123.19"
+__engine__ = "^2.0.4"

{cognite_neat-0.123.17 → cognite_neat-0.123.19}/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-0.123.17 → cognite_neat-0.123.19}/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-0.123.17 → cognite_neat-0.123.19}/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-0.123.17 → cognite_neat-0.123.19}/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-0.123.19/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-0.123.17 → cognite_neat-0.123.19}/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-0.123.17 → cognite_neat-0.123.19}/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-0.123.19/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-0.123.17 → cognite_neat-0.123.19}/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
@@ -13,6 +14,7 @@ from cognite.neat.core._issues.errors._resources import (
 )
 from cognite.neat.core._issues.warnings._models import (
     ConceptOnlyDataModelWarning,
+    ConversionToPhysicalModelImpossibleWarning,
     DanglingPropertyWarning,
     UndefinedConceptWarning,
 )
@@ -20,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
@@ -33,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
@@ -61,9 +62,30 @@ class ConceptualValidation:
 
         self._concept_only_data_model()
         self._regex_compliance_with_physical_data_model()
+        self._physical_data_model_conversion()
 
         return self.issue_list
 
+    def _physical_data_model_conversion(self) -> None:
+        """Check if the conceptual data model has issues that will likely lead
+        to problems when converting to a physical data model."""
+        warning_types_preventing_conversion = [
+            ConceptOnlyDataModelWarning,
+            ResourceRegexViolationWarning,
+            ResourceNotDefinedWarning,
+            UndefinedConceptWarning,
+            DanglingPropertyWarning,
+        ]
+
+        if seen_warnings := frozenset(
+            [
+                warning_type.__name__
+                for warning_type in warning_types_preventing_conversion
+                if self.issue_list.has_warning_type(warning_type)
+            ]
+        ):
+            self.issue_list.append_if_not_exist(ConversionToPhysicalModelImpossibleWarning(issue_types=seen_warnings))
+
     def _concept_only_data_model(self) -> None:
         """Check if the data model only consists of concepts without any properties."""
         if not self._properties:

{cognite_neat-0.123.17 → cognite_neat-0.123.19}/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()