cognite-neat 1.0.19__tar.gz → 1.0.21__tar.gz

{cognite_neat-1.0.19 → cognite_neat-1.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 1.0.19
+Version: 1.0.21
 Summary: Knowledge graph transformation
 Author: Nikola Vasiljevic, Anders Albert
 Author-email: Nikola Vasiljevic <nikola.vasiljevic@cognite.com>, Anders Albert <anders.albert@cognite.com>

cognite_neat-1.0.21/cognite/neat/_client/__init__.py

@@ -0,0 +1,5 @@
+from .client import NeatClient
+from .config import NeatClientConfig
+from .init.main import get_cognite_client
+
+__all__ = ["NeatClient", "NeatClientConfig", "get_cognite_client"]

cognite_neat-1.0.21/cognite/neat/_client/init/credentials.py

@@ -0,0 +1,70 @@
+from collections.abc import Callable
+
+from cognite.client.credentials import CredentialProvider, OAuthClientCredentials, OAuthInteractive, Token
+
+from cognite.neat._utils.text import humanize_collection
+
+from .env_vars import ClientEnvironmentVariables, LoginFlow
+
+
+def get_credentials(env_vars: ClientEnvironmentVariables) -> CredentialProvider:
+    options: dict[LoginFlow, Callable[[ClientEnvironmentVariables], CredentialProvider]] = {
+        "client_credentials": create_client_credentials,
+        "interactive": create_interactive_credentials,
+        "token": create_token_credentials,
+        "infer": create_infer_credentials,
+    }
+    return options[env_vars.LOGIN_FLOW](env_vars)
+
+
+def create_client_credentials(env_vars: ClientEnvironmentVariables) -> CredentialProvider:
+    missing: list[str] = []
+    if not env_vars.IDP_CLIENT_ID:
+        missing.append("IDP_CLIENT_ID")
+    if not env_vars.IDP_CLIENT_SECRET:
+        missing.append("IDP_CLIENT_SECRET")
+    if env_vars.IDP_CLIENT_ID is None or env_vars.IDP_CLIENT_SECRET is None:
+        raise ValueError(
+            f"The following environment variables must be set for "
+            f"client credentials authentication: {humanize_collection(missing)}"
+        )
+
+    if env_vars.PROVIDER == "cdf":
+        return OAuthClientCredentials(
+            client_id=env_vars.IDP_CLIENT_ID,
+            client_secret=env_vars.IDP_CLIENT_SECRET,
+            token_url=env_vars.idp_token_url,
+            scopes=None,  # type: ignore[arg-type]
+        )
+    return OAuthClientCredentials(
+        client_id=env_vars.IDP_CLIENT_ID,
+        client_secret=env_vars.IDP_CLIENT_SECRET,
+        token_url=env_vars.idp_token_url,
+        audience=env_vars.idp_audience,
+        scopes=env_vars.idp_scopes,
+    )
+
+
+def create_interactive_credentials(env_vars: ClientEnvironmentVariables) -> CredentialProvider:
+    if not env_vars.IDP_CLIENT_ID:
+        raise ValueError("IDP_CLIENT_ID environment variable must be set for interactive authentication.")
+    return OAuthInteractive(
+        client_id=env_vars.IDP_CLIENT_ID,
+        authority_url=env_vars.idp_authority_url,
+        scopes=env_vars.idp_scopes,
+    )
+
+
+def create_token_credentials(env_vars: ClientEnvironmentVariables) -> CredentialProvider:
+    if not env_vars.CDF_TOKEN:
+        raise ValueError("CDF_TOKEN environment variable must be set for token authentication.")
+    return Token(env_vars.CDF_TOKEN)
+
+
+def create_infer_credentials(env_vars: ClientEnvironmentVariables) -> CredentialProvider:
+    if env_vars.IDP_CLIENT_SECRET:
+        return create_client_credentials(env_vars)
+    elif env_vars.CDF_TOKEN:
+        return create_token_credentials(env_vars)
+    else:
+        return create_interactive_credentials(env_vars)

cognite_neat-1.0.21/cognite/neat/_client/init/env_vars.py

@@ -0,0 +1,131 @@
+import sys
+from pathlib import Path
+from typing import Any, Literal, TypeAlias, get_args
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+from cognite.neat._utils.repo import get_repo_root
+from cognite.neat._utils.validation import humanize_validation_error
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+LoginFlow: TypeAlias = Literal["infer", "client_credentials", "interactive", "token"]
+VALID_LOGIN_FLOWS = get_args(LoginFlow)
+Provider: TypeAlias = Literal["entra_id", "auth0", "cdf", "other"]
+
+
+class ClientEnvironmentVariables(BaseModel):
+    """Configuration for environment variables used by the NEAT client."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+    CDF_CLUSTER: str
+    CDF_PROJECT: str
+    PROVIDER: Provider = "entra_id"
+    LOGIN_FLOW: LoginFlow = "infer"
+
+    IDP_CLIENT_ID: str | None = None
+    IDP_CLIENT_SECRET: str | None = None
+    CDF_TOKEN: str | None = None
+
+    IDP_TENANT_ID: str | None = None
+    IDP_TOKEN_URL: str | None = None
+
+    CDF_URL: str | None = None
+    IDP_AUDIENCE: str | None = None
+    IDP_SCOPES: str | None = None
+    IDP_AUTHORITY_URL: str | None = None
+    IDP_DISCOVERY_URL: str | None = None
+    CDF_MAX_WORKERS: int | None = None
+    CDF_CLIENT_TIMEOUT: int | None = None
+    CDF_REDIRECT_PORT: int = 53_000
+
+    @classmethod
+    def create_humanize(cls, values: dict[str, Any]) -> Self:
+        try:
+            return cls.model_validate(values)
+        except ValidationError as e:
+            errors = [humanize_validation_error(error) for error in e.errors()]
+            raise ValueError("Invalid environment variable configuration:\n" + "\n - ".join(errors)) from e
+
+    @property
+    def idp_tenant_id(self) -> str:
+        if self.IDP_TENANT_ID:
+            return self.IDP_TENANT_ID
+        # This line is technically unreachable due to the checks in idp_token_url and idp_authority_url
+        raise RuntimeError("IDP_TENANT_ID is missing")
+
+    @property
+    def idp_token_url(self) -> str:
+        if self.PROVIDER == "cdf":
+            return "https://auth.cognite.com/oauth2/token"
+        if self.IDP_TOKEN_URL:
+            return self.IDP_TOKEN_URL
+        if self.PROVIDER == "entra_id" and self.IDP_TENANT_ID:
+            return f"https://login.microsoftonline.com/{self.IDP_TENANT_ID}/oauth2/v2.0/token"
+        alternative = " or provide IDP_TENANT_ID" if self.PROVIDER == "entra_id" else ""
+        raise ValueError(
+            f"IDP_TOKEN_URL is missing. Please provide it{alternative} in the environment variables.",
+        )
+
+    @property
+    def cdf_url(self) -> str:
+        return self.CDF_URL or f"https://{self.CDF_CLUSTER}.cognitedata.com"
+
+    @property
+    def idp_audience(self) -> str:
+        if self.IDP_AUDIENCE:
+            return self.IDP_AUDIENCE
+        if self.PROVIDER == "auth0":
+            return f"https://{self.CDF_PROJECT}.fusion.cognite.com/{self.CDF_PROJECT}"
+        else:
+            return f"https://{self.CDF_CLUSTER}.cognitedata.com"
+
+    @property
+    def idp_scopes(self) -> list[str]:
+        if self.IDP_SCOPES:
+            return self.IDP_SCOPES.split(",")
+        if self.PROVIDER == "auth0":
+            return ["IDENTITY", "user_impersonation"]
+        return [f"https://{self.CDF_CLUSTER}.cognitedata.com/.default"]
+
+    @property
+    def idp_authority_url(self) -> str:
+        if self.IDP_AUTHORITY_URL:
+            return self.IDP_AUTHORITY_URL
+        if self.PROVIDER == "entra_id" and self.IDP_TENANT_ID:
+            return f"https://login.microsoftonline.com/{self.IDP_TENANT_ID}"
+        alternative = " or provide IDP_TENANT_ID" if self.PROVIDER == "entra_id" else ""
+        raise ValueError(
+            f"IDP_AUTHORITY_URL is missing. Please provide it{alternative} in the environment variables.",
+        )
+
+
+def get_environment_variables(env_file_name: str) -> ClientEnvironmentVariables:
+    to_search: list[tuple[str, Path]] = []
+    try:
+        repo_root = get_repo_root()
+    except RuntimeError:
+        ...
+    else:
+        to_search.append(("repository root", repo_root))
+    to_search.append(("current working directory", Path.cwd()))
+    for location_desc, path in to_search:
+        env_path = path / env_file_name
+        if env_path.is_file():
+            print(f"Found {env_file_name} in {location_desc}.")
+            return _parse_env_file(env_path)
+    raise FileNotFoundError(f"Could not find {env_file_name} in the repository root or current working directory.")
+
+
+def _parse_env_file(env_file_path: Path) -> ClientEnvironmentVariables:
+    content = env_file_path.read_text()
+    variables: dict[str, Any] = {}
+    for line in content.splitlines():
+        if line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.strip().split("=", 1)
+        variables[key] = value
+    return ClientEnvironmentVariables.create_humanize(variables)

cognite_neat-1.0.21/cognite/neat/_client/init/main.py

@@ -0,0 +1,51 @@
+from cognite.client import CogniteClient
+from cognite.client.config import ClientConfig, global_config
+
+from cognite.neat import _version
+
+from .credentials import get_credentials
+from .env_vars import ClientEnvironmentVariables, get_environment_variables
+
+CLIENT_NAME = f"CogniteNeat:{_version.__version__}"
+
+
+def get_cognite_client(env_file_name: str) -> CogniteClient:
+    """Get a CogniteClient using environment variables from a .env file."
+
+    Args:
+        env_file_name: The name of the .env file to look for in the repository root / current working directory. If
+        the file is found, the variables will be loaded from the file. If the file is not found, the user will
+        be prompted to enter the variables and the file will be created.
+
+    Returns:
+        CogniteClient: An instance of CogniteClient configured with the loaded environment variables.
+    """
+    try:
+        return get_cognite_client_internal(env_file_name)
+    except Exception as e:
+        raise RuntimeError(f"Failed to create client ❌: {e!s}") from None
+
+
+def get_cognite_client_internal(env_file_name: str) -> CogniteClient:
+    # This function raises exceptions on failure
+    if not env_file_name.endswith(".env"):
+        raise ValueError(f"env_file_name must end with '.env'. Got: {env_file_name!r}")
+    global_config.disable_pypi_version_check = True
+    global_config.silence_feature_preview_warnings = True
+    env_vars = get_environment_variables(env_file_name)
+    client_config = create_client_config_from_env_vars(env_vars)
+    # Todo validate credentials by making a simple call to CDF
+    #   Offer to store credentials securely if valid
+    #
+    return CogniteClient(client_config)
+
+
+def create_client_config_from_env_vars(env_vars: ClientEnvironmentVariables) -> ClientConfig:
+    return ClientConfig(
+        client_name=CLIENT_NAME,
+        project=env_vars.CDF_PROJECT,
+        credentials=get_credentials(env_vars),
+        max_workers=env_vars.CDF_MAX_WORKERS,
+        timeout=env_vars.CDF_CLIENT_TIMEOUT,
+        base_url=env_vars.cdf_url,
+    )

{cognite_neat-1.0.19 → cognite_neat-1.0.21}/cognite/neat/_data_model/_identifiers.py

@@ -1,6 +1,6 @@
 from pydantic import HttpUrl, RootModel, ValidationError
 
-from cognite.neat._v0.core._utils.auxiliary import local_import
+from cognite.neat._utils.auxiliary import local_import
 
 
 class URI(RootModel[str]):

{cognite_neat-1.0.19 → cognite_neat-1.0.21}/cognite/neat/_data_model/exporters/_table_exporter/writer.py

@@ -3,6 +3,8 @@ from collections import defaultdict
 from dataclasses import dataclass, field
 from typing import Any, Literal
 
+from pydantic import ValidationError
+
 from cognite.neat._data_model._constants import DEFAULT_MAX_LIST_SIZE, DEFAULT_MAX_LIST_SIZE_DIRECT_RELATIONS
 from cognite.neat._data_model.importers._table_importer.data_classes import (
     CREATOR_KEY,
@@ -12,8 +14,11 @@ from cognite.neat._data_model.importers._table_importer.data_classes import (
     DMSNode,
     DMSProperty,
     DMSView,
+    EntityTableFilter,
     MetadataValue,
+    RAWFilterTableFilter,
     TableDMS,
+    TableViewFilter,
 )
 from cognite.neat._data_model.models.dms import (
     ContainerPropertyDefinition,
@@ -23,7 +28,11 @@ from cognite.neat._data_model.models.dms import (
     DataType,
     DirectNodeRelation,
     EnumProperty,
+    EqualsFilterData,
+    Filter,
     FilterAdapter,
+    HasDataFilter,
+    InFilterData,
     ListablePropertyTypeDefinition,
     NodeReference,
     RequestSchema,
@@ -299,13 +308,60 @@ class DMSTableWriter:
                 implements=[self._create_view_entity(parent) for parent in view.implements]
                 if view.implements
                 else None,
-                filter=FilterAdapter.dump_json(view.filter, by_alias=True).decode(encoding="utf-8")
-                if view.filter
-                else None,
+                filter=self.write_view_filter(view.filter),
             )
             for view in views
         ]
 
+    def write_view_filter(self, filter: Filter | None) -> TableViewFilter | None:
+        if filter is None:
+            return None
+        filter_type, entities = self._get_entity_filter(filter)
+        if filter_type is not None and entities:
+            return EntityTableFilter(type=filter_type, entities=entities)
+        else:
+            return RAWFilterTableFilter(filter=FilterAdapter.dump_json(filter, by_alias=True).decode(encoding="utf-8"))
+
+    def _get_entity_filter(self, filter: Filter) -> tuple[Literal["nodeType", "hasData"] | None, list[ParsedEntity]]:
+        """If the filter is an entity-based filter (Equals or In on nodes), return the type and entities.
+        Otherwise, return (None, [])."""
+        if filter is None or len(filter) != 1:
+            return None, []
+        filter_name, body = next(iter(filter.items()))
+        if (
+            isinstance(body, EqualsFilterData)
+            and body.property == ["node", "type"]
+            and isinstance(body.value, dict)
+            and (node_reference := self._try_get_node_reference(body.value))
+        ):
+            return "nodeType", [self._create_node_entity(node_reference)]
+        elif (
+            isinstance(body, InFilterData)
+            and body.property == ["node", "type"]
+            and isinstance(body.values, list)
+            # All values must be node references
+            and len(node_references := [ref for value in body.values if (ref := self._try_get_node_reference(value))])
+            == len(body.values)
+        ):
+            return "nodeType", [self._create_node_entity(node) for node in node_references]
+        elif (
+            isinstance(body, HasDataFilter)
+            and
+            # All data must be container references, a single view reference makes it a raw filter
+            len(container_refs := [item for item in body.data if isinstance(item, ContainerReference)])
+            == len(body.data)
+        ):
+            return "hasData", [self._create_container_entity(item) for item in container_refs]
+        else:
+            return None, []
+
+    @staticmethod
+    def _try_get_node_reference(value: Any) -> NodeReference | None:
+        try:
+            return NodeReference.model_validate(value)
+        except ValidationError:
+            return None
+
     def write_view_properties(self, views: list[ViewRequest], container: ContainerProperties) -> ViewProperties:
         output = ViewProperties()
         for view in views:

{cognite_neat-1.0.19 → cognite_neat-1.0.21}/cognite/neat/_data_model/importers/_table_importer/data_classes.py

@@ -1,4 +1,3 @@
-import json
 from collections.abc import Mapping
 from typing import Annotated, Literal, cast, get_args
 
@@ -18,11 +17,6 @@ from traitlets import Any
 from cognite.neat._data_model.models.entities import ParsedEntity, parse_entities, parse_entity
 from cognite.neat._utils.text import title_case
 from cognite.neat._utils.useful_types import CellValueType
-from cognite.neat._v0.core._data_model.models.entities import (
-    HasDataFilter,
-    NodeTypeFilter,
-    RawFilter,
-)
 
 # This marker is used to identify creator in the description field.
 CREATOR_MARKER = "Creator: "
@@ -146,28 +140,58 @@ class DMSProperty(TableObj):
         return self
 
 
+class EntityTableFilter(BaseModel):
+    """These are special formats that Neat Table format supports for filters."""
+
+    type: Literal["hasData", "nodeType"]
+    entities: EntityList
+
+    def __str__(self) -> str:
+        entities_str = ",".join(str(entity) for entity in self.entities)
+        return f"{self.type}({entities_str})"
+
+
+class RAWFilterTableFilter(BaseModel):
+    """This is a generic filter that holds raw JSON filter."""
+
+    type: Literal["rawFilter"] = "rawFilter"
+    filter: str
+
+    def __str__(self) -> str:
+        return f"rawFilter({self.filter})"
+
+
+def _parse_table_filter(v: str) -> dict[str, str] | EntityTableFilter | RAWFilterTableFilter:
+    if isinstance(v, EntityTableFilter | RAWFilterTableFilter):
+        return v
+    filter_configs = {
+        "hasdata(": ("hasData", "entities"),
+        "nodetype(": ("nodeType", "entities"),
+        "rawfilter(": ("rawFilter", "filter"),
+    }
+    v_lowered = v.casefold()
+    for prefix, (filter_type, field_name) in filter_configs.items():
+        if v_lowered.startswith(prefix) and v_lowered.endswith(")"):
+            return {"type": filter_type, field_name: v[len(prefix) : -1]}
+    # Fallback to raw filter with the whole string
+    return {"type": "rawFilter", "filter": v}
+
+
+TableViewFilter = Annotated[
+    EntityTableFilter | RAWFilterTableFilter,
+    Field(discriminator="type"),
+    BeforeValidator(_parse_table_filter, str),
+    PlainSerializer(func=str),
+]
+
+
 class DMSView(TableObj):
     view: Entity
     name: str | None = None
     description: str | None = None
     implements: EntityList | None = None
-    filter: str | None = None
-
-    @field_validator("filter", mode="after")
-    def _legacy_filter(cls, value: str | None) -> str | None:
-        if value is None:
-            return value
-
-        value_lower = value.lower()
-
-        if value_lower.startswith("hasdata("):
-            return json.dumps(HasDataFilter.load(value).as_dms_filter().dump())
-        elif value_lower.startswith("nodetype("):
-            return json.dumps(NodeTypeFilter.load(value).as_dms_filter().dump())
-        elif value_lower.startswith("rawfilter("):
-            return json.dumps(RawFilter.load(value).as_dms_filter().dump())
-
-        return value
+    filter: TableViewFilter | None = None
+    in_model: bool | None = Field(None, exclude=True, description="Legacy column")
 
 
 class DMSContainer(TableObj):
@@ -231,6 +255,31 @@ class TableDMS(TableObj):
             return {title_case(k): v for k, v in data.items()}
         return data
 
+    @model_validator(mode="after")
+    def _drop_in_model_false_views_definitions(self) -> "TableDMS":
+        """These method is used to drop definition of legacy views which have In Model column set to False
+        We need to drop these views from Views sheet and also drop their properties from Properties sheet.
+        """
+
+        views_to_drop: set[Entity] = set()
+        for view in self.views:
+            if isinstance(view.in_model, bool) and not view.in_model:
+                views_to_drop.add(view.view)
+
+        if not views_to_drop:
+            return self
+
+        print(
+            "You are using legacy `In Model` column which is no longer in use!"
+            f"\nTotal of {len(views_to_drop)} views has `In Model` set to False."
+            f"\nThese views and their property definitions will be dropped from the session!"
+        )
+
+        self.views = [view for view in self.views if view.view not in views_to_drop]
+        self.properties = [prop for prop in self.properties if prop.view not in views_to_drop]
+
+        return self
+
     @classmethod
     def get_sheet_columns(
         cls, sheet_id: str, sheet: FieldInfo | None = None, *, column_type: Literal["all", "required"] = "required"

{cognite_neat-1.0.19 → cognite_neat-1.0.21}/cognite/neat/_data_model/importers/_table_importer/reader.py

@@ -30,7 +30,19 @@ from cognite.neat._issues import ModelSyntaxError
 from cognite.neat._utils.text import humanize_collection
 from cognite.neat._utils.validation import ValidationContext, humanize_validation_error
 
-from .data_classes import CREATOR_KEY, CREATOR_MARKER, DMSContainer, DMSEnum, DMSNode, DMSProperty, DMSView, TableDMS
+from .data_classes import (
+    CREATOR_KEY,
+    CREATOR_MARKER,
+    DMSContainer,
+    DMSEnum,
+    DMSNode,
+    DMSProperty,
+    DMSView,
+    EntityTableFilter,
+    RAWFilterTableFilter,
+    TableDMS,
+    TableViewFilter,
+)
 from .source import TableSource
 
 T_BaseModel = TypeVar("T_BaseModel", bound=BaseModel)
@@ -845,19 +857,6 @@ class DMSTableReader:
         views_requests: list[ViewRequest] = []
         rows_by_seen: dict[ParsedEntity, list[int]] = defaultdict(list)
         for row_no, view in enumerate(views):
-            filter_dict: dict[str, Any] | None = None
-            if view.filter is not None:
-                try:
-                    filter_dict = json.loads(view.filter)
-                except ValueError as e:
-                    self.errors.append(
-                        ModelSyntaxError(
-                            message=(
-                                f"In {self.source.location((self.Sheets.views, row_no, self.ViewColumns.filter))} "
-                                f"must be valid json. Got error {e!s}"
-                            )
-                        )
-                    )
             view_request = self._validate_obj(
                 ViewRequest,
                 dict(
@@ -865,7 +864,7 @@ class DMSTableReader:
                     name=view.name,
                     description=view.description,
                     implements=[self._create_view_ref(impl) for impl in view.implements] if view.implements else None,
-                    filter=filter_dict,
+                    filter=self._create_filter_dict(view.filter, row_no) if view.filter else None,
                     properties=properties.get(view.view, {}),
                 ),
                 (self.Sheets.views, row_no),
@@ -891,6 +890,46 @@ class DMSTableReader:
                 )
         return views_requests, set(rows_by_seen.keys())
 
+    def _create_filter_dict(self, filter: TableViewFilter, row_no: int) -> dict[str, Any] | None:
+        if isinstance(filter, RAWFilterTableFilter):
+            try:
+                return json.loads(filter.filter)
+            except ValueError as e:
+                self.errors.append(
+                    ModelSyntaxError(
+                        message=(
+                            f"In {self.source.location((self.Sheets.views, row_no, self.ViewColumns.filter))} "
+                            f"must be valid json. Got error {e!s}"
+                        )
+                    )
+                )
+            return None
+        elif isinstance(filter, EntityTableFilter):
+            return self._create_entity_filter_dict(filter)
+        else:
+            # This is unreachable due to validation of the TableViewFilter model.
+            raise RuntimeError(f"Unknown filter type {filter.__class__.__name__}")
+
+    def _create_entity_filter_dict(self, filter: EntityTableFilter) -> dict[str, Any]:
+        """Creates the filter dictionary from an EntityTableFilter."""
+        if filter.type == "hasData":
+            return {
+                "hasData": [{**self._create_container_ref(entity), "type": "container"} for entity in filter.entities]
+            }
+        elif filter.type == "nodeType":
+            if len(filter.entities) == 1:
+                return {"equals": {"property": ["node", "type"], "value": self._create_node_ref(filter.entities[0])}}
+            else:
+                return {
+                    "in": {
+                        "property": ["node", "type"],
+                        "values": [self._create_node_ref(entity) for entity in filter.entities],
+                    }
+                }
+        else:
+            # This is unreachable due to validation of the EntityTableFilter model.
+            raise RuntimeError(f"Unknown filter type {filter.__class__.__name__}")
+
     def read_data_model(self, tables: TableDMS, valid_view_entities: set[ParsedEntity]) -> DataModelRequest:
         data: dict[str, Any] = {
             **{meta.key: meta.value for meta in tables.metadata},

{cognite_neat-1.0.19 → cognite_neat-1.0.21}/cognite/neat/_data_model/models/conceptual/_data_model.py

@@ -2,9 +2,9 @@ from collections import Counter
 
 from pydantic import Field, ValidationInfo, field_validator
 
+from cognite.neat._data_model.models.entities import ConceptEntity
 from cognite.neat._data_model.models.entities._constants import PREFIX_PATTERN, SUFFIX_PATTERN, VERSION_PATTERN
 from cognite.neat._utils.text import humanize_collection
-from cognite.neat._v0.core._data_model.models.entities._single_value import ConceptEntity
 
 from ._base import ResourceMetadata
 from ._concept import Concept

{cognite_neat-1.0.19 → cognite_neat-1.0.21}/cognite/neat/_data_model/models/dms/_space.py

@@ -3,7 +3,7 @@ from abc import ABC
 from pydantic import Field, field_validator
 
 from cognite.neat._data_model.models.dms._references import SpaceReference
-from cognite.neat._v0.core._utils.text import humanize_collection
+from cognite.neat._utils.text import humanize_collection
 
 from ._base import APIResource, Resource, WriteableResource
 from ._constants import FORBIDDEN_SPACES, SPACE_FORMAT_PATTERN

{cognite_neat-1.0.19 → cognite_neat-1.0.21}/cognite/neat/_data_model/models/entities/_identifiers.py

@@ -1,6 +1,6 @@
 from pydantic import HttpUrl, RootModel, ValidationError
 
-from cognite.neat._v0.core._utils.auxiliary import local_import
+from cognite.neat._utils.auxiliary import local_import
 
 
 class URI(RootModel[str]):

{cognite_neat-1.0.19 → cognite_neat-1.0.21}/cognite/neat/_exceptions.py

@@ -54,3 +54,15 @@ class UserInputError(NeatException):
 
     def __str__(self) -> str:
         return f"User input error: {self.message}"
+
+
+class NeatImportError(NeatException, ImportError):
+    def __init__(self, module: str, neat_extra: str, functionality: str = "functionality") -> None:
+        message = (
+            f"The {functionality} requires {module}. You can include it in your neat "
+            f'installation with `pip install "cognite-neat[{neat_extra}]"`.'
+        )
+        super().__init__(message)
+
+    def __str__(self) -> str:
+        return self.args[0]

{cognite_neat-1.0.19 → cognite_neat-1.0.21}/cognite/neat/_store/_store.py

@@ -13,7 +13,6 @@ from cognite.neat._data_model.exporters import DMSExporter, DMSFileExporter
 from cognite.neat._data_model.exporters._api_exporter import DMSAPIExporter
 from cognite.neat._data_model.exporters._table_exporter.exporter import DMSTableExporter
 from cognite.neat._data_model.importers import DMSImporter, DMSTableImporter
-from cognite.neat._data_model.importers._api_importer import DMSAPIImporter
 from cognite.neat._data_model.models.dms import RequestSchema as PhysicalDataModel
 from cognite.neat._data_model.models.dms._limits import SchemaLimits
 from cognite.neat._exceptions import DataModelImportException
@@ -108,7 +107,7 @@ class NeatStore:
             raise RuntimeError("No successful physical data model read found in provenance.")
 
         # We do not want to modify the data model for API representations
-        if not (change.agent == DMSAPIImporter.__name__ and isinstance(writer, DMSTableExporter)):
+        if not isinstance(writer, DMSTableExporter):
             return self.physical_data_model[-1]
 
         # This will handle data model that are partially and require to be converted to