cognite-neat 1.0.10__py3-none-any.whl → 1.0.12__py3-none-any.whl

cognite/neat/_data_model/validation/dms/_limits.py

@@ -5,17 +5,13 @@ from typing import Literal
 from cognite.neat._data_model.models.dms._container import ContainerRequest
 from cognite.neat._data_model.models.dms._data_types import EnumProperty, ListablePropertyTypeDefinition
 from cognite.neat._data_model.models.dms._indexes import BtreeIndex, InvertedIndex
-from cognite.neat._data_model.models.dms._limits import SchemaLimits
 from cognite.neat._data_model.models.dms._view_property import (
     ViewCorePropertyRequest,
 )
 from cognite.neat._data_model.validation.dms._base import (
-    CDFResources,
     DataModelValidator,
-    LocalResources,
 )
 from cognite.neat._issues import ConsistencyError
-from cognite.neat._utils.useful_types import ModusOperandi
 
 BASE_CODE = "NEAT-DMS-LIMITS"
 
@@ -40,29 +36,31 @@ class DataModelViewCountIsOutOfLimits(DataModelValidator):
     code = f"{BASE_CODE}-DATA-MODEL-001"
     issue_type = ConsistencyError
 
-    def __init__(
-        self,
-        local_resources: LocalResources,
-        cdf_resources: CDFResources,
-        limits: SchemaLimits,
-        modus_operandi: ModusOperandi = "additive",
-    ) -> None:
-        super().__init__(local_resources, cdf_resources, modus_operandi)
-        self.limits = limits
-
     def run(self) -> list[ConsistencyError]:
-        if len(self.data_model_view_references) > self.limits.data_models.views:
-            return [
+        errors: list[ConsistencyError] = []
+
+        if self.validation_resources.merged_data_model.views is None:
+            errors.append(
+                ConsistencyError(
+                    message="The data model does not have any views. This means it is not a data model.",
+                    code=self.code,
+                )
+            )
+
+        elif (
+            len(self.validation_resources.merged_data_model.views) > self.validation_resources.limits.data_models.views
+        ):
+            errors.append(
                 ConsistencyError(
                     message=(
-                        f"The data model references {len(self.data_model_view_references)} views, "
+                        f"The data model references {len(self.validation_resources.merged_data_model.views)} views, "
                         "which exceeds the limit of "
-                        f"{self.limits.data_models.views} views per data model."
+                        f"{self.validation_resources.limits.data_models.views} views per data model."
                     ),
                     code=self.code,
                 )
-            ]
-        return []
+            )
+        return errors
 
 
 ### View level limits
@@ -85,38 +83,23 @@ class ViewPropertyCountIsOutOfLimits(DataModelValidator):
     code = f"{BASE_CODE}-VIEW-001"
     issue_type = ConsistencyError
 
-    def __init__(
-        self,
-        local_resources: LocalResources,
-        cdf_resources: CDFResources,
-        limits: SchemaLimits,
-        modus_operandi: ModusOperandi = "additive",
-    ) -> None:
-        super().__init__(local_resources, cdf_resources, modus_operandi)
-        self.limits = limits
-
     def run(self) -> list[ConsistencyError]:
         errors: list[ConsistencyError] = []
-        merged_views = self.merged_views
-
-        for view_ref in self.local_resources.views_by_reference.keys():
-            view = merged_views.get(view_ref)
-            if not view:
-                raise RuntimeError(f"View {view_ref!s} not found in merged views. This is a bug!")
 
-            if view.properties and len(view.properties) > self.limits.views.properties:
+        for view_ref, properties in self.validation_resources.properties_by_view.items():
+            if properties and len(properties) > self.validation_resources.limits.views.properties:
                 errors.append(
                     ConsistencyError(
                         message=(
-                            f"View {view.as_reference()!s} has {len(view.properties)} properties,"
+                            f"View {view_ref!s} has {len(properties)} properties,"
                             " which exceeds the limit of "
-                            f"{self.limits.views.properties} properties per view."
+                            f"{self.validation_resources.limits.views.properties} properties per view."
                         ),
                         code=self.code,
                     )
                 )
 
-            elif not view.properties:
+            elif not properties:
                 errors.append(
                     ConsistencyError(
                         message=(
@@ -149,41 +132,26 @@ class ViewContainerCountIsOutOfLimits(DataModelValidator):
     code = f"{BASE_CODE}-VIEW-002"
     issue_type = ConsistencyError
 
-    def __init__(
-        self,
-        local_resources: LocalResources,
-        cdf_resources: CDFResources,
-        limits: SchemaLimits,
-        modus_operandi: ModusOperandi = "additive",
-    ) -> None:
-        super().__init__(local_resources, cdf_resources, modus_operandi)
-        self.limits = limits
-
     def run(self) -> list[ConsistencyError]:
         errors: list[ConsistencyError] = []
-        merged_views = self.merged_views
 
         # Single loop over all views
-        for view_ref in self.local_resources.views_by_reference.keys():
-            view = merged_views.get(view_ref)
-            if not view:
-                raise RuntimeError(f"View {view_ref!s} not found in merged views. This is a bug!")
-
-            if view.properties:
+        for view_ref, properties in self.validation_resources.properties_by_view.items():
+            if properties:
                 count = len(
                     {
                         prop.container
-                        for prop in view.properties.values()
+                        for prop in properties.values()
                         if (isinstance(prop, ViewCorePropertyRequest) and prop.container)
                     }
                 )
-                if count > self.limits.views.containers:
+                if count > self.validation_resources.limits.views.containers:
                     errors.append(
                         ConsistencyError(
                             message=(
                                 f"View {view_ref!s} references "
                                 f"{count} containers, which exceeds the limit of "
-                                f"{self.limits.views.containers} containers per view."
+                                f"{self.validation_resources.limits.views.containers} containers per view."
                             ),
                             code=self.code,
                         )
@@ -209,33 +177,18 @@ class ViewImplementsCountIsOutOfLimits(DataModelValidator):
     code = f"{BASE_CODE}-VIEW-003"
     issue_type = ConsistencyError
 
-    def __init__(
-        self,
-        local_resources: LocalResources,
-        cdf_resources: CDFResources,
-        limits: SchemaLimits,
-        modus_operandi: ModusOperandi = "additive",
-    ) -> None:
-        super().__init__(local_resources, cdf_resources, modus_operandi)
-        self.limits = limits
-
     def run(self) -> list[ConsistencyError]:
         errors: list[ConsistencyError] = []
-        merged_views = self.merged_views
 
         # Single loop over all views
-        for view_ref in self.local_resources.views_by_reference.keys():
-            view = merged_views.get(view_ref)
-            if not view:
-                raise RuntimeError(f"View {view_ref!s} not found in merged views. This is a bug!")
-
-            if view.implements and len(view.implements) > self.limits.views.implements:
+        for view_ref, ancestors in self.validation_resources.ancestors_by_view.items():
+            if ancestors and len(ancestors) > self.validation_resources.limits.views.implements:
                 errors.append(
                     ConsistencyError(
                         message=(
-                            f"View {view_ref!s} implements {len(view.implements)} views,"
+                            f"View {view_ref!s} implements {len(ancestors)} views,"
                             " which exceeds the limit of"
-                            f" {self.limits.views.implements} implemented views per view."
+                            f" {self.validation_resources.limits.views.implements} implemented views per view."
                         ),
                         code=self.code,
                     )
@@ -264,33 +217,20 @@ class ContainerPropertyCountIsOutOfLimits(DataModelValidator):
     code = f"{BASE_CODE}-CONTAINER-001"
     issue_type = ConsistencyError
 
-    def __init__(
-        self,
-        local_resources: LocalResources,
-        cdf_resources: CDFResources,
-        limits: SchemaLimits,
-        modus_operandi: ModusOperandi = "additive",
-    ) -> None:
-        super().__init__(local_resources, cdf_resources, modus_operandi)
-        self.limits = limits
-
     def run(self) -> list[ConsistencyError]:
         errors: list[ConsistencyError] = []
-        merged_containers = self.merged_containers
-
         # Single loop over all containers
-        for container_ref in self.local_resources.containers_by_reference.keys():
-            container = merged_containers.get(container_ref)
-            if not container:
-                raise RuntimeError(f"Container {container_ref!s} not found in merged containers. This is a bug!")
-
-            if container.properties and len(container.properties) > self.limits.containers.properties():
+        for container_ref, container in self.validation_resources.merged.containers.items():
+            if (
+                container.properties
+                and len(container.properties) > self.validation_resources.limits.containers.properties()
+            ):
                 errors.append(
                     ConsistencyError(
                         message=(
-                            f"Container {container.as_reference()!s} has {len(container.properties)} properties, "
+                            f"Container {container_ref!s} has {len(container.properties)} properties, "
                             "which exceeds the limit of "
-                            f"{self.limits.containers.properties()} properties per container."
+                            f"{self.validation_resources.limits.containers.properties()} properties per container."
                         ),
                         fix="Define at least one property for container",
                         code=self.code,
@@ -299,7 +239,7 @@ class ContainerPropertyCountIsOutOfLimits(DataModelValidator):
             elif not container.properties:
                 errors.append(
                     ConsistencyError(
-                        message=(f"Container {container.as_reference()!s} does not have any properties defined."),
+                        message=(f"Container {container_ref!s} does not have any properties defined."),
                         fix="Define at least one property for container",
                         code=self.code,
                     )
@@ -333,26 +273,11 @@ class ContainerPropertyListSizeIsOutOfLimits(DataModelValidator):
     code = f"{BASE_CODE}-CONTAINER-002"
     issue_type = ConsistencyError
 
-    def __init__(
-        self,
-        local_resources: LocalResources,
-        cdf_resources: CDFResources,
-        limits: SchemaLimits,
-        modus_operandi: ModusOperandi = "additive",
-    ) -> None:
-        super().__init__(local_resources, cdf_resources, modus_operandi)
-        self.limits = limits
-
     def run(self) -> list[ConsistencyError]:
         errors: list[ConsistencyError] = []
-        merged_containers = self.merged_containers
 
         # Single loop over all containers
-        for container_ref in self.local_resources.containers_by_reference.keys():
-            container = merged_containers.get(container_ref)
-            if not container:
-                raise RuntimeError(f"Container {container_ref!s} not found in merged containers. This is a bug!")
-
+        for container_ref, container in self.validation_resources.merged.containers.items():
             properties_by_index_type = self.container_property_by_index_type(container)
 
             for property_id, property_ in container.properties.items():
@@ -367,13 +292,13 @@ class ContainerPropertyListSizeIsOutOfLimits(DataModelValidator):
                     continue
 
                 has_btree_index = property_id in properties_by_index_type[BtreeIndex.model_fields["index_type"].default]
-                limit = self.limits.containers.properties.listable(type_, has_btree_index)
+                limit = self.validation_resources.limits.containers.properties.listable(type_, has_btree_index)
 
                 if type_.max_list_size > limit:
                     errors.append(
                         ConsistencyError(
                             message=(
-                                f"Container {container.as_reference()!s} has property {property_id} with list size "
+                                f"Container {container_ref!s} has property {property_id} with list size "
                                 f"{type_.max_list_size}, which exceeds the limit of {limit} "
                                 f"for data type {type_.__class__.__name__}."
                             ),

cognite/neat/_data_model/validation/dms/_orchestrator.py

@@ -1,56 +1,15 @@
 from collections.abc import Callable
-from itertools import chain
+from datetime import datetime, timezone
 
-from cognite.neat._client import NeatClient
-from cognite.neat._data_model._analysis import DataModelAnalysis
+from cognite.neat._data_model._analysis import ValidationResources
 from cognite.neat._data_model._shared import OnSuccessIssuesChecker
-from cognite.neat._data_model.models.dms._container import ContainerRequest
+from cognite.neat._data_model._snapshot import SchemaSnapshot
 from cognite.neat._data_model.models.dms._limits import SchemaLimits
-from cognite.neat._data_model.models.dms._references import ContainerReference, DataModelReference, ViewReference
 from cognite.neat._data_model.models.dms._schema import RequestSchema
-from cognite.neat._data_model.models.dms._view_property import ViewCorePropertyRequest
-from cognite.neat._data_model.models.dms._views import ViewRequest
-from cognite.neat._data_model.validation.dms._limits import (
-    ContainerPropertyCountIsOutOfLimits,
-    ContainerPropertyListSizeIsOutOfLimits,
-    DataModelViewCountIsOutOfLimits,
-    ViewContainerCountIsOutOfLimits,
-    ViewImplementsCountIsOutOfLimits,
-    ViewPropertyCountIsOutOfLimits,
-)
+from cognite.neat._utils.auxiliary import get_concrete_subclasses
 from cognite.neat._utils.useful_types import ModusOperandi
 
-from ._ai_readiness import (
-    DataModelMissingDescription,
-    DataModelMissingName,
-    EnumerationMissingDescription,
-    EnumerationMissingName,
-    ViewMissingDescription,
-    ViewMissingName,
-    ViewPropertyMissingDescription,
-    ViewPropertyMissingName,
-)
-from ._base import CDFResources, DataModelValidator, LocalResources
-from ._connections import (
-    ConnectionValueTypeUndefined,
-    ConnectionValueTypeUnexisting,
-    ReverseConnectionContainerMissing,
-    ReverseConnectionContainerPropertyMissing,
-    ReverseConnectionContainerPropertyWrongType,
-    ReverseConnectionPointsToAncestor,
-    ReverseConnectionSourcePropertyMissing,
-    ReverseConnectionSourcePropertyWrongType,
-    ReverseConnectionSourceViewMissing,
-    ReverseConnectionTargetMismatch,
-    ReverseConnectionTargetMissing,
-)
-from ._consistency import ViewSpaceVersionInconsistentWithDataModel
-from ._containers import (
-    ExternalContainerDoesNotExist,
-    ExternalContainerPropertyDoesNotExist,
-    RequiredContainerDoesNotExist,
-)
-from ._views import ImplementedViewNotExisting, ViewToContainerMappingNotPossible
+from ._base import DataModelValidator
 
 
 class DmsDataModelValidation(OnSuccessIssuesChecker):
@@ -58,104 +17,26 @@ class DmsDataModelValidation(OnSuccessIssuesChecker):
 
     def __init__(
         self,
-        client: NeatClient | None = None,
+        cdf_snapshot: SchemaSnapshot,
+        limits: SchemaLimits,
         modus_operandi: ModusOperandi = "additive",
         can_run_validator: Callable[[str, type], bool] | None = None,
     ) -> None:
         super().__init__()
-        self._client = client
-        self._can_run_validator = can_run_validator or (lambda code, issue_type: True)  # type: ignore
+        self._cdf_snapshot = cdf_snapshot
+        self._limits = limits
         self._modus_operandi = modus_operandi
+        self._can_run_validator = can_run_validator or (lambda code, issue_type: True)  # type: ignore
         self._has_run = False
 
-    def _gather_resources(self, data_model: RequestSchema) -> tuple[LocalResources, CDFResources, SchemaLimits]:
-        """Gather local and CDF resources needed for validation."""
-
-        analysis = DataModelAnalysis(data_model)
-
-        local_views_by_reference = analysis.view_by_reference(include_inherited_properties=True)
-        local_ancestors_by_view_reference = analysis.ancestors_by_view(list(local_views_by_reference.values()))
-        local_reverse_to_direct_mapping = analysis.reverse_to_direct_mapping
-        local_containers_by_reference = analysis.container_by_reference
-        local_data_model_views = set(data_model.data_model.views) if data_model.data_model.views else set()
-
-        local_resources = LocalResources(
-            data_model_description=data_model.data_model.description,
-            data_model_name=data_model.data_model.name,
-            data_model_reference=data_model.data_model.as_reference(),
-            views_by_reference=local_views_by_reference,
-            properties_by_view=analysis.properties_by_view,
-            ancestors_by_view_reference=local_ancestors_by_view_reference,
-            reverse_to_direct_mapping=local_reverse_to_direct_mapping,
-            containers_by_reference=local_containers_by_reference,
-            connection_end_node_types=analysis.connection_end_node_types,
-            data_model_views=local_data_model_views,
-        )
-
-        cdf_views_by_reference = self._cdf_view_by_reference(
-            list(analysis.referenced_views(include_connection_end_node_types=True)),
-            include_inherited_properties=True,
-        )
-        cdf_ancestors_by_view_reference = analysis.ancestors_by_view(list(cdf_views_by_reference.values()))
-        cdf_containers_by_reference = self._cdf_container_by_reference(
-            list(self._referenced_containers(local_views_by_reference, cdf_views_by_reference))
-        )
-        cdf_data_model_views = self._cdf_data_model_views(data_model.data_model.as_reference())
-
-        cdf_resources = CDFResources(
-            views_by_reference=cdf_views_by_reference,
-            ancestors_by_view_reference=cdf_ancestors_by_view_reference,
-            containers_by_reference=cdf_containers_by_reference,
-            data_model_views=cdf_data_model_views,
-        )
-
-        return local_resources, cdf_resources, self._cdf_limits()
-
-    def run(self, data_model: RequestSchema) -> None:
+    def run(self, request_schema: RequestSchema) -> None:
         """Run quality assessment on the DMS data model."""
 
-        # Helper wrangled data model components
-        local_resources, cdf_resources, cdf_limits = self._gather_resources(data_model)
+        validation_resources = self._gather_validation_resources(request_schema)
 
         # Initialize all validators
         validators: list[DataModelValidator] = [
-            # Limits
-            DataModelViewCountIsOutOfLimits(local_resources, cdf_resources, cdf_limits, self._modus_operandi),
-            ViewPropertyCountIsOutOfLimits(local_resources, cdf_resources, cdf_limits, self._modus_operandi),
-            ViewImplementsCountIsOutOfLimits(local_resources, cdf_resources, cdf_limits, self._modus_operandi),
-            ViewContainerCountIsOutOfLimits(local_resources, cdf_resources, cdf_limits, self._modus_operandi),
-            ContainerPropertyCountIsOutOfLimits(local_resources, cdf_resources, cdf_limits, self._modus_operandi),
-            ContainerPropertyListSizeIsOutOfLimits(local_resources, cdf_resources, cdf_limits, self._modus_operandi),
-            # Views
-            ViewToContainerMappingNotPossible(local_resources, cdf_resources, self._modus_operandi),
-            ImplementedViewNotExisting(local_resources, cdf_resources, self._modus_operandi),
-            # Containers
-            ExternalContainerDoesNotExist(local_resources, cdf_resources, self._modus_operandi),
-            ExternalContainerPropertyDoesNotExist(local_resources, cdf_resources, self._modus_operandi),
-            RequiredContainerDoesNotExist(local_resources, cdf_resources, self._modus_operandi),
-            # Consistency
-            ViewSpaceVersionInconsistentWithDataModel(local_resources, cdf_resources, self._modus_operandi),
-            # Connections
-            ConnectionValueTypeUnexisting(local_resources, cdf_resources, self._modus_operandi),
-            ConnectionValueTypeUndefined(local_resources, cdf_resources, self._modus_operandi),
-            ReverseConnectionContainerMissing(local_resources, cdf_resources, self._modus_operandi),
-            ReverseConnectionContainerPropertyMissing(local_resources, cdf_resources, self._modus_operandi),
-            ReverseConnectionContainerPropertyWrongType(local_resources, cdf_resources, self._modus_operandi),
-            ReverseConnectionSourceViewMissing(local_resources, cdf_resources, self._modus_operandi),
-            ReverseConnectionSourcePropertyMissing(local_resources, cdf_resources, self._modus_operandi),
-            ReverseConnectionSourcePropertyWrongType(local_resources, cdf_resources, self._modus_operandi),
-            ReverseConnectionPointsToAncestor(local_resources, cdf_resources, self._modus_operandi),
-            ReverseConnectionTargetMismatch(local_resources, cdf_resources, self._modus_operandi),
-            ReverseConnectionTargetMissing(local_resources, cdf_resources, self._modus_operandi),
-            # AI Readiness
-            DataModelMissingName(local_resources, cdf_resources, self._modus_operandi),
-            DataModelMissingDescription(local_resources, cdf_resources, self._modus_operandi),
-            ViewMissingName(local_resources, cdf_resources, self._modus_operandi),
-            ViewMissingDescription(local_resources, cdf_resources, self._modus_operandi),
-            ViewPropertyMissingName(local_resources, cdf_resources, self._modus_operandi),
-            ViewPropertyMissingDescription(local_resources, cdf_resources, self._modus_operandi),
-            EnumerationMissingName(local_resources, cdf_resources, self._modus_operandi),
-            EnumerationMissingDescription(local_resources, cdf_resources, self._modus_operandi),
+            validator(validation_resources) for validator in get_concrete_subclasses(DataModelValidator)
         ]
 
         # Run validators
@@ -165,58 +46,21 @@ class DmsDataModelValidation(OnSuccessIssuesChecker):
 
         self._has_run = True
 
-    def _cdf_data_model_views(self, data_model_ref: DataModelReference) -> set[ViewReference]:
-        """Get all data model views in CDF."""
-
-        if not self._client:
-            return set()
-
-        data_model = self._client.data_models.retrieve([data_model_ref])
-
-        return set(data_model[0].views) if data_model and data_model[0].views else set()
-
-    def _cdf_view_by_reference(
-        self, views: list[ViewReference], include_inherited_properties: bool = True
-    ) -> dict[ViewReference, ViewRequest]:
-        """Fetch view definition from CDF."""
-
-        if not self._client:
-            return {}
-        return {
-            response.as_reference(): response.as_request()
-            for response in self._client.views.retrieve(
-                views, include_inherited_properties=include_inherited_properties
-            )
-        }
-
-    def _cdf_container_by_reference(
-        self, containers: list[ContainerReference]
-    ) -> dict[ContainerReference, ContainerRequest]:
-        """Fetch container definition from CDF."""
-
-        if not self._client:
-            return {}
-        return {
-            response.as_reference(): response.as_request() for response in self._client.containers.retrieve(containers)
-        }
-
-    def _cdf_limits(self) -> SchemaLimits:
-        """Fetch DMS statistics from CDF."""
-
-        if not self._client:
-            return SchemaLimits()
-        return SchemaLimits.from_api_response(self._client.statistics.project())
+    def _gather_validation_resources(self, request_schema: RequestSchema) -> ValidationResources:
+        # we do not want to modify the original request schema during validation
+        copy = request_schema.model_copy(deep=True)
+        local = SchemaSnapshot(
+            data_model={request_schema.data_model.as_reference(): copy.data_model},
+            views={view.as_reference(): view for view in copy.views},
+            containers={container.as_reference(): container for container in copy.containers},
+            spaces={space.as_reference(): space for space in copy.spaces},
+            node_types={node_type: node_type for node_type in copy.node_types},
+            timestamp=datetime.now(timezone.utc),
+        )
 
-    def _referenced_containers(
-        self,
-        local_views_by_reference: dict[ViewReference, ViewRequest],
-        cdf_views_by_reference: dict[ViewReference, ViewRequest],
-    ) -> set[ContainerReference]:
-        """Get all referenced containers in the physical data model both local and in CDF."""
-        return {
-            property_.container
-            for view in chain(local_views_by_reference.values(), cdf_views_by_reference.values())
-            if view.properties
-            for property_ in view.properties.values()
-            if isinstance(property_, ViewCorePropertyRequest)
-        }
+        return ValidationResources(
+            cdf=self._cdf_snapshot,
+            local=local,
+            limits=self._limits,
+            modus_operandi=self._modus_operandi,
+        )

cognite/neat/_data_model/validation/dms/_views.py

@@ -29,7 +29,21 @@ class ViewToContainerMappingNotPossible(DataModelValidator):
     def run(self) -> list[ConsistencyError]:
         errors: list[ConsistencyError] = []
 
-        for view_ref, view in self.local_resources.views_by_reference.items():
+        if not self.validation_resources.merged_data_model.views:
+            return errors
+
+        for view_ref in self.validation_resources.merged_data_model.views:
+            view = self.validation_resources.select_view(view_ref)
+
+            if not view:
+                raise RuntimeError(
+                    f"ViewToContainerMappingNotPossible.run: View {view_ref!s} "
+                    "not found in local resources. This is a bug in NEAT."
+                )
+
+            if view.properties is None:
+                continue
+
             for property_ref, property_ in view.properties.items():
                 if not isinstance(property_, ViewCorePropertyRequest):
                     continue
@@ -37,7 +51,7 @@ class ViewToContainerMappingNotPossible(DataModelValidator):
                 container_ref = property_.container
                 container_property = property_.container_property_identifier
 
-                container = self._select_container_with_property(container_ref, container_property)
+                container = self.validation_resources.select_container(container_ref, container_property)
 
                 if not container:
                     errors.append(
@@ -87,11 +101,22 @@ class ImplementedViewNotExisting(DataModelValidator):
     def run(self) -> list[ConsistencyError]:
         errors: list[ConsistencyError] = []
 
-        for view_ref, view in self.local_resources.views_by_reference.items():
+        if not self.validation_resources.merged_data_model.views:
+            return errors
+
+        for view_ref in self.validation_resources.merged_data_model.views:
+            view = self.validation_resources.select_view(view_ref)
+
+            if not view:
+                raise RuntimeError(
+                    f"ImplementedViewNotExisting.run: View {view_ref!s} "
+                    "not found in local resources. This is a bug in NEAT."
+                )
+
             if view.implements is None:
                 continue
             for implement in view.implements:
-                if implement not in self.merged_views:
+                if self.validation_resources.select_view(implement) is None:
                     errors.append(
                         ConsistencyError(
                             message=f"View {view_ref!s} implements {implement!s} which is not defined.",