cognite-neat 0.123.26__py3-none-any.whl → 1.0.22__py3-none-any.whl

cognite/neat/_utils/useful_types.py

@@ -0,0 +1,37 @@
+from collections.abc import Hashable
+from datetime import date, datetime, time, timedelta
+from typing import Literal, TypeAlias, TypeVar
+
+from pydantic import BaseModel
+from pydantic.alias_generators import to_camel
+
+JsonVal: TypeAlias = None | str | int | float | bool | dict[str, "JsonVal"] | list["JsonVal"]
+PrimaryTypes: TypeAlias = str | int | float | bool
+
+T_ID = TypeVar("T_ID", bound=Hashable)
+# These are the types that openpyxl supports in cells
+CellValueType: TypeAlias = str | int | float | bool | datetime | date | time | timedelta | None
+
+# The format expected for excel sheets representing a data model
+DataModelTableType: TypeAlias = dict[str, list[dict[str, CellValueType]]]
+PrimitiveType: TypeAlias = str | int | float | bool
+
+
+class BaseModelObject(BaseModel, alias_generator=to_camel, extra="ignore"):
+    """Base class for all object. This includes resources and nested objects."""
+
+    ...
+
+
+T_Item = TypeVar("T_Item", bound=BaseModelObject)
+
+
+class ReferenceObject(BaseModelObject, frozen=True, populate_by_name=True):
+    """Base class for all reference objects - these are identifiers."""
+
+    ...
+
+
+T_Reference = TypeVar("T_Reference", bound=ReferenceObject, covariant=True)
+
+ModusOperandi: TypeAlias = Literal["rebuild", "additive"]

cognite/neat/_utils/validation.py

@@ -0,0 +1,154 @@
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass, field
+from typing import Literal
+
+from pydantic_core import ErrorDetails
+
+
+def as_json_path(loc: tuple[str | int, ...]) -> str:
+    """Converts a location tuple to a JSON path.
+
+    Args:
+        loc: The location tuple to convert.
+
+    Returns:
+        A JSON path string.
+    """
+    if not loc:
+        return ""
+    # +1 to convert from 0-based to 1-based indexing
+    prefix = ""
+    if isinstance(loc[0], int):
+        prefix = "item"
+
+    suffix = ".".join([str(x) if isinstance(x, str) else f"[{x + 1}]" for x in loc]).replace(".[", "[")
+    return f"{prefix}{suffix}"
+
+
+@dataclass
+class ValidationContext:
+    """
+    Context for validation errors providing configuration for error message formatting.
+
+    This class configures how validation errors are reported, including location formatting,
+    field naming conventions, and how to present missing required fields.
+
+    Attributes:
+        parent_loc: Optional location tuple to prepend to each error location.
+            This is useful when the error is for a nested model and you want to include the location
+            of the parent model.
+        humanize_location: A function that converts a location tuple to a human-readable string.
+            The default is `as_json_path`, which converts the location to a JSON path.
+            This can for example be replaced when the location comes from an Excel table.
+        field_name: The name use for "field" in error messages. Default is "field". This can be changed to
+            "column" or "value" to better fit the context.
+        field_renaming: Optional mapping of field names to source names.
+            This is useful when the field names in the model are different from the names in the source.
+            For example, if the model field is "asset_id" but the source column is "Asset ID",
+            you can provide a mapping {"asset_id": "Asset ID"} to have the error messages use the source names.
+        missing_required_descriptor: How to describe missing required fields. Default is "missing".
+            Other option is "empty" which can be more suitable for table data.
+    """
+
+    parent_loc: tuple[int | str, ...] = field(default_factory=tuple)
+    humanize_location: Callable[[tuple[int | str, ...]], str] = as_json_path
+    field_name: Literal["field", "column", "value"] = "field"
+    field_renaming: Mapping[str, str] = field(default_factory=dict)
+    missing_required_descriptor: Literal["empty", "missing"] = "missing"
+
+
+def humanize_validation_error(
+    error: ErrorDetails,
+    context: ValidationContext | None = None,
+) -> str:
+    """Converts a pydantic ErrorDetails object to a human-readable format.
+    This overwrites the default error messages from Pydantic to be better suited for NEAT users.
+    Args:
+        error: The ErrorDetails object to convert.
+        context: The context for humanizing the error.
+    Returns:
+        A human-readable error message.
+    """
+
+    context = context or ValidationContext()
+
+    loc = (*context.parent_loc, *error["loc"])
+    type_ = error["type"]
+
+    if type_ == "missing":
+        msg = f"Missing required {context.field_name}: {loc[-1]!r}"
+    elif type_ == "extra_forbidden":
+        msg = f"Unused {context.field_name}: {loc[-1]!r}"
+    elif type_ == "value_error":
+        msg = str(error["ctx"]["error"])
+    elif type_ == "literal_error":
+        msg = f"{error['msg']}. Got {error['input']!r}."
+    elif type_ == "string_type":
+        msg = f"{error['msg']}. Got {error['input']!r} of type {type(error['input']).__name__}. "
+    elif type_ == "model_type":
+        model_name = error["ctx"].get("class_name", "unknown")
+        msg = (
+            f"Input must be an object of type {model_name}. Got {error['input']!r} of "
+            f"type {type(error['input']).__name__}."
+        )
+    elif type_ == "union_tag_invalid":
+        msg = error["msg"].replace(", 'direct'", "").replace("found using 'type' ", "").replace("tag", "value")
+    elif type_ == "string_pattern_mismatch":
+        msg = f"string '{error['input']}' does not match the required pattern: '{error['ctx']['pattern']}'."
+
+    elif type_.endswith("_type"):
+        msg = f"{error['msg']}. Got {error['input']!r} of type {type(error['input']).__name__}."
+    else:
+        # Default to the Pydantic error message
+        msg = error["msg"]
+
+    if type_.endswith("dict_type") and len(loc) > 1:
+        # If this is a dict_type error for a JSON field, the location will be:
+        #  dict[str,json-or-python[json=any,python=tagged-union[list[...],dict[str,...],str,bool,int,float,none]]]
+        #  This is hard to read, so we simplify it to just the field name.
+        loc = tuple(["dict" if isinstance(x, str) and "json-or-python" in x else x for x in loc])
+
+    error_suffix = f"{msg[:1].casefold()}{msg[1:]}"
+
+    if len(loc) >= 3 and context.field_name == "column" and loc[-3:] == ("type", "enum", "values"):
+        # Special handling for enum errors in table columns
+        msg = _enum_message(type_, loc, context)
+    elif len(loc) > 1 and type_ in {"extra_forbidden", "missing"}:
+        if context.missing_required_descriptor == "empty" and type_ == "missing":
+            # This is a table so we modify the error message.
+            msg = (
+                f"In {context.humanize_location(loc[:-1])} the {context.field_name}"
+                f" {context.field_renaming.get(str(loc[-1]), loc[-1])!r} "
+                "cannot be empty."
+            )
+        else:
+            # We skip the last element as this is in the message already
+            msg = f"In {context.humanize_location(loc[:-1])} {error_suffix.replace('field', context.field_name)}"
+    elif len(loc) > 1:
+        if context.parent_loc == ("Metadata",) and len(loc) == 2:
+            msg = f"In table '{loc[0]}' '{loc[1]}' {error_suffix}"
+        else:
+            msg = f"In {context.humanize_location(loc)} {error_suffix}"
+    elif len(loc) == 1 and isinstance(loc[0], str) and type_ not in {"extra_forbidden", "missing"}:
+        msg = f"In {context.field_name} {loc[0]!r}, {error_suffix}"
+
+    msg = msg.strip()
+    if not msg.endswith("."):
+        msg += "."
+    return msg
+
+
+def _enum_message(type_: str, loc: tuple[int | str, ...], context: ValidationContext) -> str:
+    """Special handling of enum errors in table columns."""
+
+    if loc[-1] != "values":
+        raise RuntimeError("This is a neat bug, report to the team.")
+    if type_ == "missing":
+        return (
+            f"In {context.humanize_location(loc[:-1])} definition should include "
+            "a reference to a collection in the 'Enum' sheet (e.g., collection='MyEnumCollection')."
+        )
+    elif type_ == "too_short":
+        return f"In {context.humanize_location(loc[:-1])} collection is not defined in the 'Enum' sheet"
+    else:
+        raise RuntimeError("This is a neat bug, report to the team.")

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

@@ -1,3 +1,4 @@
+import itertools
 import re
 import warnings
 from abc import ABC, abstractmethod
@@ -54,14 +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.core._utils.tarjan import tarjan
+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)
 
@@ -238,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:

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]
@@ -274,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(
@@ -124,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

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

@@ -1,15 +1,15 @@
 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._import_contexts import ImportContext
-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,
 )
 

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)
 

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
 
@@ -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