cognite-neat 1.0.20__py3-none-any.whl → 1.0.21__py3-none-any.whl

cognite/neat/_client/__init__.py

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

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/_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/_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/_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/_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/_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,30 +140,59 @@ 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
+    filter: TableViewFilter | None = None
     in_model: bool | None = Field(None, exclude=True, description="Legacy column")
 
-    @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
-
 
 class DMSContainer(TableObj):
     container: Entity

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/_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/_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/_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/_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/_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

cognite/neat/_utils/auxiliary.py

@@ -1,8 +1,11 @@
+import importlib
 import inspect
 from abc import ABC
+from types import ModuleType
 from typing import TypeVar
 
 from cognite.neat import _version
+from cognite.neat._exceptions import NeatImportError
 
 
 def get_current_neat_version() -> str:
@@ -37,3 +40,10 @@ def get_concrete_subclasses(base_cls: type[T_Cls], exclude_direct_abc_inheritanc
             seen.add(subclass)
             to_check.append(subclass)
     return subclasses
+
+
+def local_import(module: str, extra: str) -> ModuleType:
+    try:
+        return importlib.import_module(module)
+    except ImportError as e:
+        raise NeatImportError(module.split(".")[0], extra) from e

cognite/neat/_utils/repo.py

@@ -0,0 +1,19 @@
+import subprocess
+from pathlib import Path
+
+
+def get_repo_root() -> Path:
+    """Get the root path of the git repository.
+
+    Raises:
+        RuntimeError: If git is not installed or the current directory is not in a git repository
+
+    """
+    try:
+        result = subprocess.run("git rev-parse --show-toplevel".split(), stdout=subprocess.PIPE)
+    except FileNotFoundError as e:
+        raise RuntimeError("Git is not installed or not found in PATH") from e
+    output = result.stdout.decode().strip()
+    if not output:
+        raise RuntimeError("Not in a git repository")
+    return Path(output)

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "1.0.20"
+__version__ = "1.0.21"
 __engine__ = "^2.0.4"

{cognite_neat-1.0.20.dist-info → cognite_neat-1.0.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 1.0.20
+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.20.dist-info → cognite_neat-1.0.21.dist-info}/RECORD

@@ -1,11 +1,15 @@
 cognite/neat/__init__.py,sha256=4RJ6p29cDU_VwQ3sVsgiFdb817BKqKASp-lIgQeD6BI,300
-cognite/neat/_client/__init__.py,sha256=75Bh7eGhaN4sOt3ZcRzHl7pXaheu1z27kmTHeaI05vo,114
+cognite/neat/_client/__init__.py,sha256=DIHMeggZ81rVJwO97E5PVP8AwVAhhLpjBQu7Ns3_xdc,178
 cognite/neat/_client/api.py,sha256=nbxCdWBXcTVM6MrQeT_VpB6ehfoI544JHPFq-ejQKCY,292
 cognite/neat/_client/client.py,sha256=h0HELAHiBFxMNInkDu4AzbgfEIXqeM0BqqnMBmXjgi0,903
 cognite/neat/_client/config.py,sha256=eIIdWaA13yncRP6X7vTYsTpmXmVcmkhZPv5oPnLUEVc,1484
 cognite/neat/_client/containers_api.py,sha256=7bVIlL5PwoAG5Bks1ortW_bCG8iTkFqFVyL05pdJ3Pw,5176
 cognite/neat/_client/data_classes.py,sha256=HYPsrAJGVCUmlWTSIxJgAnIHAOzcyDveMM6Z-cuA92M,1404
 cognite/neat/_client/data_model_api.py,sha256=ogVHOabQ3HTqWaaoiGClmbtYdP-pl6DPN2zmPdH5LWY,4253
+cognite/neat/_client/init/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/_client/init/credentials.py,sha256=95JZFo-LoZO5CAWS18FplrpDvd6TRgG2SvBH0cAEug4,2751
+cognite/neat/_client/init/env_vars.py,sha256=t0zf63TYA3jP_isFiV3rPG81AJ2v_1ULyRthNMKc15Q,4916
+cognite/neat/_client/init/main.py,sha256=q9NA5WCXrtxF2HLAfXOu5UrTH9Ou6qlRoVI9XDtTbZQ,2067
 cognite/neat/_client/spaces_api.py,sha256=xHtSMt_2k2YwZ5_8kH2dfa7fWxQQrky7wra4Ar2jwqs,4111
 cognite/neat/_client/statistics_api.py,sha256=HcYb2nNC9M_iaI1xyjjLn2Cz1tcyu7BJeaqVps79tg4,773
 cognite/neat/_client/views_api.py,sha256=Qzk_wiLtaWszxCQFDBoWCH1yDc4GOEJsVOcL061rcK0,5639
@@ -13,7 +17,7 @@ cognite/neat/_config.py,sha256=ZvCkcaRVAvH4-ClvinoWaLWhRJpRByqdvncGFsf5gLk,9886
 cognite/neat/_data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/_analysis.py,sha256=lPiXF0td4y5TudrR1KPH5OUZ_YNBz8tO6cLg3RnJwEg,22413
 cognite/neat/_data_model/_constants.py,sha256=E2axzdYjsIy7lTHsjW91wsv6r-pUwko8g6K8C_oRnxk,1707
-cognite/neat/_data_model/_identifiers.py,sha256=2l_bCtuE6TVZLCnzV7hhAUTP0kU6ji4QlIK-JhRK1fM,1922
+cognite/neat/_data_model/_identifiers.py,sha256=lDLvMvYDgRNFgk5GmxWzOUunG7M3synAciNjzJI0m_o,1913
 cognite/neat/_data_model/_shared.py,sha256=H0gFqa8tKFNWuvdat5jL6OwySjCw3aQkLPY3wtb9Wrw,1302
 cognite/neat/_data_model/_snapshot.py,sha256=JBaKmL0Tmprz59SZ1JeB49BPMB8Hqa-OAOt0Bai8cw4,6305
 cognite/neat/_data_model/deployer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,20 +34,20 @@ cognite/neat/_data_model/exporters/_base.py,sha256=rG_qAU5i5Hh5hUMep2UmDFFZID4x3
 cognite/neat/_data_model/exporters/_table_exporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/exporters/_table_exporter/exporter.py,sha256=4BPu_Chtjh1EyOaKbThXYohsqllVOkCbSoNekNZuBXc,5159
 cognite/neat/_data_model/exporters/_table_exporter/workbook.py,sha256=1Afk1WqeNe9tiNeSAm0HrF8jTQ1kTbIv1D9hMztKwO8,18482
-cognite/neat/_data_model/exporters/_table_exporter/writer.py,sha256=WAXPXjbIXrKtAKebXQ3npShbgWs_rUwdyQsCsm_jt3I,19374
+cognite/neat/_data_model/exporters/_table_exporter/writer.py,sha256=k1gPrI8OdS75x3ncLn27Z-wnWgkOJ_eiCFnfp-rgdyY,21748
 cognite/neat/_data_model/importers/__init__.py,sha256=dHnKnC_AXk42z6wzEHK15dxIOh8xSEkuUf_AFRZls0E,193
 cognite/neat/_data_model/importers/_api_importer.py,sha256=H8Ow3Tt7utuAuBhC6s7yWvhGqunHAtE0r0XRsVAr6IE,7280
 cognite/neat/_data_model/importers/_base.py,sha256=NRB0FcEBj4GaethU68nRffBfTedBBA866A3zfJNfmiQ,433
 cognite/neat/_data_model/importers/_table_importer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite/neat/_data_model/importers/_table_importer/data_classes.py,sha256=MU3gZg9w3OO0FCJfYdbfa4e8tSNPVhkPOzpJNab4jG4,10762
+cognite/neat/_data_model/importers/_table_importer/data_classes.py,sha256=wnFMrzLRWAsPyMBMZ7W02JLMtjMJRG0VGsXDrj_Ww5Y,11487
 cognite/neat/_data_model/importers/_table_importer/importer.py,sha256=lQ4_Gpv0haEwQEDYZJaxtR9dL6Y0ys9jbjFfWxH6s2o,8870
-cognite/neat/_data_model/importers/_table_importer/reader.py,sha256=I9-zHCpJLo7bj4BabAzSgNBDVUAocdhlvBfy95JkWRw,49451
+cognite/neat/_data_model/importers/_table_importer/reader.py,sha256=5NkUvem9sR3WUM1vtfm6duu76oD3vQ0gi6UuBOcr3bo,50933
 cognite/neat/_data_model/importers/_table_importer/source.py,sha256=h7u5ur5oetmvBs3wgj7Ody5uPF21QwxeAceoIhJ5qzo,3300
 cognite/neat/_data_model/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/models/conceptual/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/models/conceptual/_base.py,sha256=SFkoBJDM51pqew_isHFJoB20OgfofpwVRnTrg-rKkNY,710
 cognite/neat/_data_model/models/conceptual/_concept.py,sha256=0Pk4W2TJ_Y0Z7oPHpzely1kPXrAkmkyqw6a0n3il6LY,2248
-cognite/neat/_data_model/models/conceptual/_data_model.py,sha256=xRnKD1JFXscXAV_joitRdbjh9BTbME6z6IxS3fZNMZM,1696
+cognite/neat/_data_model/models/conceptual/_data_model.py,sha256=zvJZi0OqOFMviwY84Am3Oz_RmF1g3tOzANFHlrldBuU,1673
 cognite/neat/_data_model/models/conceptual/_properties.py,sha256=CpF37vJYBTLT4DH4ZOu2U-JyWtkb_27V8fw52qiaE_k,4007
 cognite/neat/_data_model/models/conceptual/_property.py,sha256=blSZQxX52zaILAtjUkldPzPeysz7wnG-UGSNU5tacI8,4138
 cognite/neat/_data_model/models/dms/__init__.py,sha256=CW5NPMRrMyY4iyZgqYb8eZkRuwbbXUDSVNMWep3zEPI,5326
@@ -58,7 +62,7 @@ cognite/neat/_data_model/models/dms/_indexes.py,sha256=ZtXe8ABuRcsAwRIZ9FCanS3uw
 cognite/neat/_data_model/models/dms/_limits.py,sha256=x_X7T50SkwPNo_aHTGCr35hDXI8FRdZLYIB9HpFqnIk,3520
 cognite/neat/_data_model/models/dms/_references.py,sha256=Mx_nxfvOrvAx7nvebhhbFw6eRm3nHqeFW5P5AqADUlM,3890
 cognite/neat/_data_model/models/dms/_schema.py,sha256=2JFLcm52smzPdtZ69Lf02UbYAD8I_hpRbI7ZAzdxJJs,641
-cognite/neat/_data_model/models/dms/_space.py,sha256=3KvWg0bVuLpgQwhkDbsJ53ZMMmK0cKUgfyDRrSrERko,1904
+cognite/neat/_data_model/models/dms/_space.py,sha256=mj6gID4vcAGsHNtgfXm4_4FMOQbUOkMd3HaYEdy07XM,1895
 cognite/neat/_data_model/models/dms/_types.py,sha256=5-cgC53AG186OZUqkltv7pMjcGNLuH7Etbn8IUcgk1c,447
 cognite/neat/_data_model/models/dms/_view_filter.py,sha256=XxMffUH5kYtcg0xHgyUsY4nueWRoJu2CoJtOU7wbH4Y,11274
 cognite/neat/_data_model/models/dms/_view_property.py,sha256=nJBPmw4KzJOdaQmvRfCE3A4FL-E13OsNUEufI64vLKo,9271
@@ -67,7 +71,7 @@ cognite/neat/_data_model/models/entities/__init__.py,sha256=7dDyES7fYl9LEREal59F
 cognite/neat/_data_model/models/entities/_base.py,sha256=PaNrD29iwxuqTpRWbmESMTxRhhKXmRyDF_cLZEC69dg,3927
 cognite/neat/_data_model/models/entities/_constants.py,sha256=EK9Bus8UgFgxK5cVFMTAqWSl6aWkDe7d59hpUmlHlBs,517
 cognite/neat/_data_model/models/entities/_data_types.py,sha256=DfdEWGek7gODro-_0SiiInhPGwul4zn-ASACQfn8HUY,2838
-cognite/neat/_data_model/models/entities/_identifiers.py,sha256=Ab_cMPbk5b0tKnivkm5pHKLv3cLb5KrwhxDu2elStvQ,1924
+cognite/neat/_data_model/models/entities/_identifiers.py,sha256=a7ojJKY1ErZgUANHscEwkctX4RJ7bWEEWOQt5g5Tsdk,1915
 cognite/neat/_data_model/models/entities/_parser.py,sha256=zef_pSDZYMZrJl4IKreFDR577KutfhtN1xpH3Ayjt2o,7669
 cognite/neat/_data_model/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/validation/dms/__init__.py,sha256=kKD18-Bg_G-w11Cs7Wv_TKV0C_q62Pm2RKLpOz27ar4,2642
@@ -79,7 +83,7 @@ cognite/neat/_data_model/validation/dms/_containers.py,sha256=5Lka1Cg-SaP9Ued0ck
 cognite/neat/_data_model/validation/dms/_limits.py,sha256=U7z8sN-kAyJsF5hYHPNBBg25Fvz1F8njhzYVSQOIiOU,14779
 cognite/neat/_data_model/validation/dms/_orchestrator.py,sha256=qiuUSUmNhekFyBARUUO2yhG-X9AeU_LL49UrJ65JXFA,2964
 cognite/neat/_data_model/validation/dms/_views.py,sha256=Q0x7jdG69-AVc93VrwdZ1_rFHpq-I-OG98puM4lcweE,5068
-cognite/neat/_exceptions.py,sha256=ox-5hXpee4UJlPE7HpuEHV2C96aLbLKo-BhPDoOAzhA,1650
+cognite/neat/_exceptions.py,sha256=mO19TEecZYDNqSvzuc6JmCLFQ70eniT1-Gb0AEbgbzE,2090
 cognite/neat/_issues.py,sha256=wH1mnkrpBsHUkQMGUHFLUIQWQlfJ_qMfdF7q0d9wNhY,1871
 cognite/neat/_session/__init__.py,sha256=owqW5Mml2DSZx1AvPvwNRTBngfhBNrQ6EH-7CKL7Jp0,61
 cognite/neat/_session/_html/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -113,16 +117,17 @@ cognite/neat/_state_machine/_base.py,sha256=-ZpeAhM6l6N6W70dET25tAzOxaaK5aa474ea
 cognite/neat/_state_machine/_states.py,sha256=nmj4SmunpDYcBsNx8A284xnXGS43wuUuWpMMORha2DE,1170
 cognite/neat/_store/__init__.py,sha256=TvM9CcFbtOSrxydPAuJi6Bv_iiGard1Mxfx42ZFoTl0,55
 cognite/neat/_store/_provenance.py,sha256=1zzRDWjR9twZu2jVyIG3UdYdIXtQKJ7uF8a0hV7LEuA,3368
-cognite/neat/_store/_store.py,sha256=PwW4hYQ-ENbCtKpGdGmsJjk0qGU4PPg0LIfhn5nNGSI,9751
+cognite/neat/_store/_store.py,sha256=jtJPBQ8PBG0UlgzSJJpzOIRkC2Np3fHNtV4omRC6H5A,9629
 cognite/neat/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_utils/_reader.py,sha256=9dXrODNNqWU0Gx1zXjRTOiiByFuDZlpQkQEzx3HAxYQ,5390
-cognite/neat/_utils/auxiliary.py,sha256=Cx-LP8dfN782R3iUcm--q26zdzQ0k_RFnVbJ0bwVZMI,1345
+cognite/neat/_utils/auxiliary.py,sha256=YQMpqCxccex_slmLYrR5icVX9aeLbD793ou7IrbNTFs,1654
 cognite/neat/_utils/collection.py,sha256=BIwRrFbUXNPvHhEVujLHgVoDJXzdPEMScrbSBhyCibk,446
 cognite/neat/_utils/http_client/__init__.py,sha256=qaCLLLhi7H3b_cmbknX0S66KILT7JSKX1YSgZjNdd1U,786
 cognite/neat/_utils/http_client/_client.py,sha256=TO9C77LcsqX0R3Fu-mP560nnV6rP5oRXki9kxRYtBlg,9658
 cognite/neat/_utils/http_client/_config.py,sha256=C8IF1JoijmVMjA_FEMgAkiD1buEV1cY5Og3t-Ecyfmk,756
 cognite/neat/_utils/http_client/_data_classes.py,sha256=McyCQZUcwkbOXdBmc99DdNsO6mQz8dNVsepDvXmaINA,10138
 cognite/neat/_utils/http_client/_tracker.py,sha256=EBBnd-JZ7nc_jYNFJokCHN2UZ9sx0McFLZvlceUYYic,1215
+cognite/neat/_utils/repo.py,sha256=nSpT9_XNbbExMip4LyNL0b89aAurHVx003q_Wky-qww,603
 cognite/neat/_utils/text.py,sha256=-ujNaG_hLkdurKsUmZB9ZI_kJkddlCKEf8g-g_XCk10,2010
 cognite/neat/_utils/useful_types.py,sha256=BwTjcWnpxnxN8rWXuYXMgU55O_YjVteMtYK0y25OmH0,1260
 cognite/neat/_utils/validation.py,sha256=U422V0TY5KujFJFyfhRLONVj5A4AcCWgqIKVK6BUm7M,6938
@@ -316,9 +321,9 @@ cognite/neat/_v0/session/_template.py,sha256=BNcvrW5y7LWzRM1XFxZkfR1Nc7e8UgjBClH
 cognite/neat/_v0/session/_to.py,sha256=AnsRSDDdfFyYwSgi0Z-904X7WdLtPfLlR0x1xsu_jAo,19447
 cognite/neat/_v0/session/_wizard.py,sha256=baPJgXAAF3d1bn4nbIzon1gWfJOeS5T43UXRDJEnD3c,1490
 cognite/neat/_v0/session/exceptions.py,sha256=jv52D-SjxGfgqaHR8vnpzo0SOJETIuwbyffSWAxSDJw,3495
-cognite/neat/_version.py,sha256=sA2ZsS8D9yHBhDKFo6czh0Y817b0hccxIxB45Dzk75o,45
+cognite/neat/_version.py,sha256=0Bv-euqjHzX0kdwCv6YRDD5BAUEFBhkf7f6PaEKGdd0,45
 cognite/neat/legacy.py,sha256=eI2ecxOV8ilGHyLZlN54ve_abtoK34oXognkFv3yvF0,219
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_neat-1.0.20.dist-info/WHEEL,sha256=eycQt0QpYmJMLKpE3X9iDk8R04v2ZF0x82ogq-zP6bQ,79
-cognite_neat-1.0.20.dist-info/METADATA,sha256=-nVza3PgQsgHSNGru9JTxml_7T4k4UqxhQo4hrbMMG0,6689
-cognite_neat-1.0.20.dist-info/RECORD,,
+cognite_neat-1.0.21.dist-info/WHEEL,sha256=XjEbIc5-wIORjWaafhI6vBtlxDBp7S9KiujWF1EM7Ak,79
+cognite_neat-1.0.21.dist-info/METADATA,sha256=QpA63SYiPB_pttmYhdDpmx7AbJl98Sd8V-wIbjoWCwI,6689
+cognite_neat-1.0.21.dist-info/RECORD,,

{cognite_neat-1.0.20.dist-info → cognite_neat-1.0.21.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.24
+Generator: uv 0.9.25
 Root-Is-Purelib: true
 Tag: py3-none-any