cognite-neat 0.123.2__py3-none-any.whl → 0.127.30__py3-none-any.whl

cognite/neat/{core → v0/core}/_client/_api/data_modeling_loaders.py

@@ -1,8 +1,11 @@
+import itertools
+import re
 import warnings
 from abc import ABC, abstractmethod
+from collections import defaultdict
 from collections.abc import Callable, Collection, Iterable, Sequence
 from dataclasses import dataclass, field
-from graphlib import TopologicalSorter
+from graphlib import CycleError, TopologicalSorter
 from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, TypeVar, cast, overload
 
 from cognite.client.data_classes import filters
@@ -52,13 +55,14 @@ from cognite.client.data_classes.data_modeling.views import (
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite.neat.core._client.data_classes.data_modeling import Component
-from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._issues.warnings import CDFMaxIterationsWarning
-from cognite.neat.core._shared import T_ID
+from cognite.neat.v0.core._client.data_classes.data_modeling import Component
+from cognite.neat.v0.core._client.data_classes.schema import DMSSchema
+from cognite.neat.v0.core._issues.warnings import CDFMaxIterationsWarning
+from cognite.neat.v0.core._shared import T_ID
+from cognite.neat.v0.core._utils.tarjan import tarjan
 
 if TYPE_CHECKING:
-    from cognite.neat.core._client._api_client import NeatClient
+    from cognite.neat.v0.core._client._api_client import NeatClient
 
 T_WritableCogniteResourceList = TypeVar("T_WritableCogniteResourceList", bound=WriteableCogniteResourceList)
 
@@ -235,7 +239,7 @@ class ResourceLoader(
         try:
             return self._update(items)
         except CogniteAPIError as e:
-            failed_ids = {self.get_id(failed) for failed in e.failed + e.unknown}
+            failed_ids = {self.get_id(failed) for failed in itertools.chain(e.failed, e.unknown)}
             success_ids = [self.get_id(success) for success in e.successful]
             success_ = self.retrieve(success_ids)
             if success is None:
@@ -620,6 +624,81 @@ class ViewLoader(DataModelingLoader[ViewId, ViewApply, View, ViewApplyList, View
     def _create(self, items: Sequence[ViewApply]) -> ViewList:
         return self._client.data_modeling.views.apply(items)
 
+    def create(self, items: Sequence[ViewApply]) -> ViewList:
+        try:
+            return self._create(items)
+        except CogniteAPIError as e1:
+            if self._is_auto_retryable(e1):
+                # Fallback to creating one by one if the error is auto-retryable.
+                return self._fallback_one_by_one(self._create, items)
+            elif self._is_false_not_exists(e1, {item.as_id() for item in items}):
+                return self._try_to_recover_coupled(items, e1)
+            raise
+
+    def _try_to_recover_coupled(self, items: Sequence[ViewApply], original_error: CogniteAPIError) -> ViewList:
+        """The /models/views endpoint can give faulty 400 about missing views that are part of the request.
+
+        This method tries to recover from such errors by identifying the strongly connected components in the graph
+        defined by the implements and through properties of the views. We then create the components in topological
+        order.
+
+        Args:
+            items: The items that failed to create.
+            original_error: The original error that was raised. If the problem is not recoverable, this error is raised.
+
+        Returns:
+            The views that were created.
+
+        """
+        views_by_id = {self.get_id(item): item for item in items}
+        parents_by_child: dict[ViewId, set[ViewId]] = {
+            view_id: {parent for parent in view.implements or [] if parent in views_by_id}
+            for view_id, view in views_by_id.items()
+        }
+        # Check for cycles in the implements graph
+        try:
+            TopologicalSorter(parents_by_child).static_order()
+        except CycleError as e:
+            raise CycleError(f"Failed to deploy views. This likely due to a cycle in implements. {e.args[1]}") from None
+
+        dependencies_by_id: dict[ViewId, set[ViewId]] = defaultdict(set)
+        for view_id, view in views_by_id.items():
+            dependencies_by_id[view_id].update([parent for parent in view.implements or [] if parent in views_by_id])
+            for properties in (view.properties or {}).values():
+                if isinstance(properties, ReverseDirectRelationApply):
+                    if isinstance(properties.through.source, ViewId) and properties.through.source in views_by_id:
+                        dependencies_by_id[view_id].add(properties.through.source)
+
+        created = ViewList([])
+        for strongly_connected in tarjan(dependencies_by_id):
+            to_create = [views_by_id[view_id] for view_id in strongly_connected]
+            try:
+                created_set = self._client.data_modeling.views.apply(to_create)
+            except CogniteAPIError:
+                self._client.data_modeling.views.delete(created.as_ids())
+                raise original_error from None
+            created.extend(created_set)
+        return created
+
+    @staticmethod
+    def _is_auto_retryable(e: CogniteAPIError) -> bool:
+        return isinstance(e.extra, dict) and "isAutoRetryable" in e.extra and e.extra["isAutoRetryable"]
+
+    @staticmethod
+    def _is_false_not_exists(e: CogniteAPIError, request_views: set[ViewId]) -> bool:
+        """This is a bug in the API where it returns a 400 status complaining that a views does not exist,
+        even though they are part of the request. This bug is reported to Cognite. The workaround is to do a
+        topological sort of the strongly connected views and retry the request.
+        """
+        if "not exist" not in e.message and 400 <= e.code < 500:
+            return False
+        results = re.findall(r"'([a-zA-Z0-9_-]+):([a-zA-Z0-9_]+)/([.a-zA-Z0-9_-]+)'", e.message)
+        if not results:
+            # No view references in the message
+            return False
+        error_message_views = {ViewId(*result) for result in results}
+        return error_message_views.issubset(request_views)
+
     @overload
     def retrieve(
         self,

cognite/neat/{core → v0/core}/_client/_api/neat_instances.py

@@ -7,13 +7,13 @@ from cognite.client.data_classes.filters import Filter
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite.neat.core._constants import DMS_INSTANCE_LIMIT_MARGIN
-from cognite.neat.core._issues import NeatIssue
-from cognite.neat.core._issues.errors import WillExceedLimitError
-from cognite.neat.core._issues.warnings import NeatValueWarning
+from cognite.neat.v0.core._constants import DMS_INSTANCE_LIMIT_MARGIN
+from cognite.neat.v0.core._issues import NeatIssue
+from cognite.neat.v0.core._issues.errors import WillExceedLimitError
+from cognite.neat.v0.core._issues.warnings import NeatValueWarning
 
 if TYPE_CHECKING:
-    from cognite.neat.core._client._api_client import NeatClient
+    from cognite.neat.v0.core._client._api_client import NeatClient
 
 
 class NeatInstancesAPI:

cognite/neat/{core → v0/core}/_client/_api/schema.py

@@ -5,17 +5,17 @@ from typing import TYPE_CHECKING
 
 from cognite.client import data_modeling as dm
 
-from cognite.neat.core._client.data_classes.data_modeling import (
+from cognite.neat.v0.core._client.data_classes.data_modeling import (
     ContainerApplyDict,
     SpaceApplyDict,
     ViewApplyDict,
 )
-from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._constants import is_hierarchy_property
-from cognite.neat.core._issues.errors import NeatValueError
+from cognite.neat.v0.core._client.data_classes.schema import DMSSchema
+from cognite.neat.v0.core._constants import is_hierarchy_property
+from cognite.neat.v0.core._issues.errors import NeatValueError
 
 if TYPE_CHECKING:
-    from cognite.neat.core._client._api_client import NeatClient
+    from cognite.neat.v0.core._client._api_client import NeatClient
 
 
 class SchemaAPI:

cognite/neat/{core → v0/core}/_client/_api/statistics.py

@@ -7,7 +7,7 @@ from cognite.client.config import ClientConfig
 from cognite.client.data_classes.data_modeling.ids import _load_space_identifier
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite.neat.core._client.data_classes.statistics import (
+from cognite.neat.v0.core._client.data_classes.statistics import (
     ProjectStatsAndLimits,
     SpaceInstanceCounts,
     SpaceInstanceCountsList,
@@ -34,7 +34,7 @@ class StatisticsAPI(APIClient):
         Examples:
             Fetch project statistics (and limits) and check the current number of data models vs.
             and how many more can be created:
-                >>> from cognite.neat.core._client import NeatClient
+                >>> from cognite.neat.v0.core._client import NeatClient
                 >>> client = NeatClient()
                 >>> stats = client.instance_statistics.project()
                 >>> num_dm = stats.data_models.current
@@ -64,7 +64,7 @@ class StatisticsAPI(APIClient):
 
         Examples:
             Fetch statistics for a single space:
-                >>> from cognite.neat.core._client import NeatClient
+                >>> from cognite.neat.v0.core._client import NeatClient
                 >>> client = NeatClient()
                 >>> res = client.instance_statistics.list("my-space")
             Fetch statistics for multiple spaces:

cognite/neat/{core → v0/core}/_client/_api_client.py

@@ -1,6 +1,6 @@
 from cognite.client import ClientConfig, CogniteClient
 
-from cognite.neat.core._utils.auth import _CLIENT_NAME
+from cognite.neat.v0.core._utils.auth import _CLIENT_NAME
 
 from ._api.data_modeling_loaders import DataModelLoaderAPI
 from ._api.neat_instances import NeatInstancesAPI

cognite/neat/{core → v0/core}/_client/data_classes/schema.py

@@ -20,21 +20,21 @@ from cognite.client.data_classes.data_modeling.views import (
     ViewPropertyApply,
 )
 
-from cognite.neat.core._client.data_classes.data_modeling import (
+from cognite.neat.v0.core._client.data_classes.data_modeling import (
     CogniteResourceDict,
     ContainerApplyDict,
     NodeApplyDict,
     SpaceApplyDict,
     ViewApplyDict,
 )
-from cognite.neat.core._issues.errors import (
+from cognite.neat.v0.core._issues.errors import (
     NeatYamlError,
 )
-from cognite.neat.core._issues.warnings import (
+from cognite.neat.v0.core._issues.warnings import (
     FileTypeUnexpectedWarning,
     ResourcesDuplicatedWarning,
 )
-from cognite.neat.core._utils.text import to_camel_case
+from cognite.neat.v0.core._utils.text import to_camel_case
 
 if sys.version_info >= (3, 11):
     from typing import Self

cognite/neat/{core → v0/core}/_client/testing.py

@@ -5,7 +5,7 @@ from unittest.mock import MagicMock
 
 from cognite.client.testing import CogniteClientMock
 
-from cognite.neat.core._client._api_client import NeatClient
+from cognite.neat.v0.core._client._api_client import NeatClient
 
 from ._api.data_modeling_loaders import DataModelLoaderAPI
 from ._api.neat_instances import NeatInstancesAPI

cognite/neat/{core → v0/core}/_constants.py

@@ -11,7 +11,7 @@ from rdflib.namespace import DefinedNamespace
 from cognite import neat
 
 if TYPE_CHECKING:
-    from cognite.neat.core._data_model.models.physical import PhysicalProperty
+    from cognite.neat.v0.core._data_model.models.physical import PhysicalProperty
 
 
 def _is_in_notebook() -> bool:
@@ -204,7 +204,7 @@ BASE_MODEL = Literal["CogniteCore"]
 
 def get_asset_read_only_properties_with_connection() -> "list[PhysicalProperty]":
     """Gets the asset read-only properties with connection, i.e. Root and Path."""
-    from cognite.neat.core._data_model.models.physical import PhysicalProperty
+    from cognite.neat.v0.core._data_model.models.physical import PhysicalProperty
 
     return [PhysicalProperty.model_validate(item) for item in (_ASSET_ROOT_PROPERTY, _ASSET_PATH_PROPERTY)]
 
@@ -219,7 +219,7 @@ def get_base_concepts(
         total_concepts: The number of concepts to get. If None, all concepts are returned.
     """
     # Local import to avoid circular dependency issues
-    from cognite.neat.core._issues.errors._general import NeatValueError
+    from cognite.neat.v0.core._issues.errors._general import NeatValueError
 
     if base_model == "CogniteCore":
         return [f"cdf_cdm:{concept}(version=v1)" for concept in COGNITE_CONCEPTS][:total_concepts]
@@ -250,6 +250,11 @@ def is_hierarchy_property(container: dm.ContainerId, property_: str) -> bool:
     )
 
 
+def cognite_prefixes() -> dict[str, Namespace]:
+    """Returns the Cognite prefixes and namespaces."""
+    return {space: Namespace(CDF_NAMESPACE[space] + "/") for space in COGNITE_SPACES}
+
+
 DMS_RESERVED_PROPERTIES = frozenset(
     {
         "createdTime",
@@ -269,3 +274,5 @@ DMS_RESERVED_PROPERTIES = frozenset(
         "endNode",
     }
 )
+
+NAMED_GRAPH_NAMESPACE = Namespace("http://thisisneat.io/namedgraph/")

cognite/neat/{core → v0/core}/_data_model/_constants.py

@@ -43,6 +43,11 @@ class EntityTypes(StrEnum):
     prefix = "prefix"
     space = "space"
     container_index = "container_index"
+    container_constraint = "container_constraint"
+    concept_restriction = "conceptRestriction"
+    value_constraint = "valueConstraint"
+    cardinality_constraint = "cardinalityConstraint"
+    named_individual = "named_individual"
 
 
 def get_reserved_words(
@@ -111,12 +116,8 @@ PHYSICAL_PROPERTY_ID_COMPLIANCE_REGEX = (
     rf"(?!^({'|'.join(get_reserved_words('property'))})$)"
     r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
 )
-CONCEPT_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words('concept'))})$)"
-    r"(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
-)
+CONCEPT_ID_COMPLIANCE_REGEX = r"^[a-zA-Z0-9._~?@!$&'*+,;=%-]+$"
 
-INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX = r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
 
 
@@ -128,6 +129,8 @@ SPLIT_ON_EQUAL_PATTERN = re.compile(r"=(?![^(]*\))")
 # Very special Edge Entity parsing
 SPLIT_ON_EDGE_ENTITY_ARGS_PATTERN = re.compile(r"(\btype\b|\bproperties\b|\bdirection\b)\s*=\s*([^,]+)")
 
+CONSTRAINT_ID_MAX_LENGTH = 43
+
 
 class _Patterns:
     @cached_property
@@ -156,7 +159,7 @@ class _Patterns:
 
     @cached_property
     def conceptual_property_id_compliance(self) -> re.Pattern[str]:
-        return re.compile(INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX)
+        return re.compile(CONCEPT_ID_COMPLIANCE_REGEX)
 
     @cached_property
     def version_compliance(self) -> re.Pattern[str]:

cognite/neat/{core → v0/core}/_data_model/_shared.py

@@ -1,17 +1,17 @@
 from dataclasses import dataclass
 from typing import Generic, TypeAlias, TypeVar
 
-from cognite.neat.core._data_model.models import (
+from cognite.neat.v0.core._data_model.models import (
     ConceptualDataModel,
     PhysicalDataModel,
 )
-from cognite.neat.core._data_model.models.conceptual._unverified import (
+from cognite.neat.v0.core._data_model.models._import_contexts import ImportContext
+from cognite.neat.v0.core._data_model.models.conceptual._unverified import (
     UnverifiedConceptualDataModel,
 )
-from cognite.neat.core._data_model.models.physical._unverified import (
+from cognite.neat.v0.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 → v0/core}/_data_model/analysis/_base.py

@@ -11,23 +11,23 @@ import pandas as pd
 from cognite.client import data_modeling as dm
 from rdflib import URIRef
 
-from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
-from cognite.neat.core._data_model.models.conceptual import (
+from cognite.neat.v0.core._data_model.models import ConceptualDataModel, PhysicalDataModel
+from cognite.neat.v0.core._data_model.models.conceptual import (
     Concept,
     ConceptualProperty,
 )
-from cognite.neat.core._data_model.models.entities import (
+from cognite.neat.v0.core._data_model.models.entities import (
     ConceptEntity,
     MultiValueTypeInfo,
     ViewEntity,
 )
-from cognite.neat.core._data_model.models.entities._single_value import (
+from cognite.neat.v0.core._data_model.models.entities._single_value import (
     UnknownEntity,
 )
-from cognite.neat.core._data_model.models.physical import PhysicalProperty
-from cognite.neat.core._data_model.models.physical._verified import PhysicalView
-from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._issues.warnings import NeatValueWarning
+from cognite.neat.v0.core._data_model.models.physical import PhysicalProperty
+from cognite.neat.v0.core._data_model.models.physical._verified import PhysicalView
+from cognite.neat.v0.core._issues.errors import NeatValueError
+from cognite.neat.v0.core._issues.warnings import NeatValueWarning
 
 T_Hashable = TypeVar("T_Hashable", bound=Hashable)
 
@@ -348,6 +348,10 @@ class DataModelAnalysis:
         properties_by_view = self.properties_by_view(include_ancestors)
         return {prop.view for prop in itertools.chain.from_iterable(properties_by_view.values())}
 
+    def concepts(self) -> set[ConceptEntity]:
+        """Returns all concepts defined Concepts in the data model."""
+        return {concept.concept for concept in self.conceptual.concepts}
+
     def defined_concepts(
         self,
         include_ancestors: bool = False,

cognite/neat/{core → v0/core}/_data_model/exporters/__init__.py

@@ -2,7 +2,7 @@ from ._base import BaseExporter, CDFExporter
 from ._data_model2dms import DMSExporter
 from ._data_model2excel import ExcelExporter
 from ._data_model2instance_template import InstanceTemplateExporter
-from ._data_model2ontology import GraphExporter, OWLExporter, SemanticDataModelExporter, SHACLExporter
+from ._data_model2semantic_model import GraphExporter, OWLExporter, SHACLExporter
 from ._data_model2yaml import YAMLExporter
 
 __all__ = [
@@ -14,7 +14,6 @@ __all__ = [
     "InstanceTemplateExporter",
     "OWLExporter",
     "SHACLExporter",
-    "SemanticDataModelExporter",
     "YAMLExporter",
 ]
 

cognite/neat/{core → v0/core}/_data_model/exporters/_base.py

@@ -5,14 +5,14 @@ from pathlib import Path
 from types import UnionType
 from typing import TYPE_CHECKING, Generic, TypeVar, Union, get_args, get_origin
 
-from cognite.neat.core._client import NeatClient
-from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._data_model._shared import T_VerifiedDataModel
-from cognite.neat.core._utils.auxiliary import class_html_doc
-from cognite.neat.core._utils.upload import UploadResult, UploadResultList
+from cognite.neat.v0.core._client import NeatClient
+from cognite.neat.v0.core._constants import DEFAULT_NAMESPACE
+from cognite.neat.v0.core._data_model._shared import T_VerifiedDataModel
+from cognite.neat.v0.core._utils.auxiliary import class_html_doc
+from cognite.neat.v0.core._utils.upload import UploadResult, UploadResultList
 
 if TYPE_CHECKING:
-    from cognite.neat.core._store._provenance import Agent as ProvenanceAgent
+    from cognite.neat.v0.core._store._provenance import Agent as ProvenanceAgent
 
 T_Export = TypeVar("T_Export")
 
@@ -36,7 +36,7 @@ class BaseExporter(ABC, Generic[T_VerifiedDataModel, T_Export]):
     @property
     def agent(self) -> "ProvenanceAgent":
         """Provenance agent for the importer."""
-        from cognite.neat.core._store._provenance import Agent as ProvenanceAgent
+        from cognite.neat.v0.core._store._provenance import Agent as ProvenanceAgent
 
         return ProvenanceAgent(id_=DEFAULT_NAMESPACE[f"agent/{type(self).__name__}"])
 

cognite/neat/{core → v0/core}/_data_model/exporters/_data_model2dms.py

@@ -18,24 +18,24 @@ from cognite.client.data_classes.data_modeling import (
 )
 from cognite.client.exceptions import CogniteAPIError
 
-from cognite.neat.core._client import DataModelingLoader, NeatClient
-from cognite.neat.core._client._api.data_modeling_loaders import (
+from cognite.neat.v0.core._client import DataModelingLoader, NeatClient
+from cognite.neat.v0.core._client._api.data_modeling_loaders import (
     MultiCogniteAPIError,
     T_WritableCogniteResourceList,
 )
-from cognite.neat.core._client.data_classes.data_modeling import (
+from cognite.neat.v0.core._client.data_classes.data_modeling import (
     Component,
     ViewApplyDict,
 )
-from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._data_model.models.physical import PhysicalDataModel
-from cognite.neat.core._issues import IssueList
-from cognite.neat.core._issues.warnings import (
+from cognite.neat.v0.core._client.data_classes.schema import DMSSchema
+from cognite.neat.v0.core._data_model.models.physical import PhysicalDataModel
+from cognite.neat.v0.core._issues import IssueList
+from cognite.neat.v0.core._issues.warnings import (
     PrincipleOneModelOneSpaceWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat.core._shared import T_ID
-from cognite.neat.core._utils.upload import UploadResult
+from cognite.neat.v0.core._shared import T_ID
+from cognite.neat.v0.core._utils.upload import UploadResult
 
 from ._base import CDFExporter
 

cognite/neat/{core → v0/core}/_data_model/exporters/_data_model2excel.py

@@ -14,25 +14,25 @@ from openpyxl.worksheet.datavalidation import DataValidation
 from openpyxl.worksheet.worksheet import Worksheet
 from rdflib import Namespace
 
-from cognite.neat.core._constants import BASE_MODEL, get_base_concepts
-from cognite.neat.core._data_model._constants import get_internal_properties
-from cognite.neat.core._data_model._shared import VerifiedDataModel
-from cognite.neat.core._data_model.models import (
+from cognite.neat.v0.core._constants import BASE_MODEL, get_base_concepts
+from cognite.neat.v0.core._data_model._constants import get_internal_properties
+from cognite.neat.v0.core._data_model._shared import VerifiedDataModel
+from cognite.neat.v0.core._data_model.models import (
     SheetRow,
 )
-from cognite.neat.core._data_model.models._base_verified import (
+from cognite.neat.v0.core._data_model.models._base_verified import (
     BaseVerifiedMetadata,
     RoleTypes,
 )
-from cognite.neat.core._data_model.models.conceptual._verified import (
+from cognite.neat.v0.core._data_model.models.conceptual._verified import (
     ConceptualDataModel,
 )
-from cognite.neat.core._data_model.models.data_types import (
+from cognite.neat.v0.core._data_model.models.data_types import (
     _DATA_TYPE_BY_DMS_TYPE,
 )
-from cognite.neat.core._data_model.models.physical._verified import PhysicalDataModel
-from cognite.neat.core._utils.spreadsheet import (
-    find_column_with_value,
+from cognite.neat.v0.core._data_model.models.physical._verified import PhysicalDataModel
+from cognite.neat.v0.core._utils.spreadsheet import (
+    find_column_and_row_with_value,
     generate_data_validation,
 )
 
@@ -217,7 +217,7 @@ class ExcelExporter(BaseExporter[VerifiedDataModel, Workbook]):
                 continue
             ws = workbook[sheet]
             for col in get_internal_properties():
-                column_letter = find_column_with_value(ws, col)
+                column_letter = find_column_and_row_with_value(ws, col)[0]
                 if column_letter:
                     ws.column_dimensions[column_letter].hidden = True
 
@@ -344,7 +344,7 @@ class ExcelExporter(BaseExporter[VerifiedDataModel, Workbook]):
         for value_type_counter, value_type in enumerate(_DATA_TYPE_BY_DMS_TYPE.values()):
             value_type_as_str = value_type.dms._type.casefold() if role == RoleTypes.dms else value_type.xsd
             # skip types which require special handling or are surpassed by CDM
-            if value_type_as_str in ["enum", "timeseries", "sequence", "file", "json"]:
+            if value_type_as_str in ["enum", "timeseries", "sequence", "file"]:
                 continue
             workbook[self._helper_sheet_name].cell(
                 row=value_type_counter + 1,
@@ -451,7 +451,7 @@ class ExcelExporter(BaseExporter[VerifiedDataModel, Workbook]):
         workbook[sheet_name].add_data_validation(data_validators[data_validator_name])
 
         # APPLY VALIDATOR TO SPECIFIC COLUMN
-        if column_letter := find_column_with_value(workbook[sheet_name], column_name):
+        if column_letter := find_column_and_row_with_value(workbook[sheet_name], column_name)[0]:
             data_validators[data_validator_name].add(f"{column_letter}{3}:{column_letter}{3 + total_rows}")
 
     def _create_sheet_with_header(

cognite/neat/{core → v0/core}/_data_model/exporters/_data_model2instance_template.py

@@ -8,12 +8,12 @@ from openpyxl.styles import Alignment, Border, Font, NamedStyle, PatternFill, Si
 from openpyxl.utils import get_column_letter
 from openpyxl.worksheet.datavalidation import DataValidation
 
-from cognite.neat.core._data_model._constants import EntityTypes
-from cognite.neat.core._data_model.analysis import DataModelAnalysis
-from cognite.neat.core._data_model.models.conceptual._verified import (
+from cognite.neat.v0.core._data_model._constants import EntityTypes
+from cognite.neat.v0.core._data_model.analysis import DataModelAnalysis
+from cognite.neat.v0.core._data_model.models.conceptual._verified import (
     ConceptualDataModel,
 )
-from cognite.neat.core._data_model.models.entities._single_value import ConceptEntity
+from cognite.neat.v0.core._data_model.models.entities._single_value import ConceptEntity
 
 from ._base import BaseExporter