cognite-neat 1.0.20__tar.gz → 1.0.22__tar.gz

{cognite_neat-1.0.20 → cognite_neat-1.0.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 1.0.20
+Version: 1.0.22
 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.22/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.22/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.22/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.22/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.20 → cognite_neat-1.0.22}/cognite/neat/_data_model/_analysis.py

@@ -23,7 +23,7 @@ from cognite.neat._data_model.models.dms._view_property import (
     ViewRequestProperty,
 )
 from cognite.neat._data_model.models.dms._views import ViewRequest
-from cognite.neat._utils.useful_types import ModusOperandi
+from cognite.neat._utils.useful_types import ModusOperandi, T_Reference
 
 # Type aliases for better readability
 ViewsByReference: TypeAlias = dict[ViewReference, ViewRequest]
@@ -458,9 +458,42 @@ class ValidationResources:
         view_sets = [self.views_by_container.get(c, set()) for c in containers]
         return set.intersection(*view_sets)
 
-    # =========================================================================
-    # Methods used for requires constraint validation
-    # =========================================================================
+    @cached_property
+    def implements_graph(self) -> nx.DiGraph:
+        """Build a weighted directed graph of view implements.
+
+        Nodes are ViewReferences, edges represent implements.
+        An edge A → B means view A implements view B. Order of views in implements is used to set weight of an edge.
+
+        Includes views from both merged schema and CDF
+        """
+        graph: nx.DiGraph = nx.DiGraph()
+
+        for view_ref in self.cdf.views:
+            graph.add_node(view_ref)
+        for view_ref in self.merged.views:
+            graph.add_node(view_ref)
+
+        # Add edges for implements
+        for view_ref in graph.nodes():
+            view = self.select_view(view_ref)
+            if not view or not view.implements:
+                continue
+
+            # Adding weight to preserve order of implements
+            for i, implement in enumerate(view.implements):
+                graph.add_edge(view_ref, implement, weight=i + 1)
+
+        return graph
+
+    @cached_property
+    def implements_cycles(self) -> list[list[ViewReference]]:
+        """Find all cycles in the implements graph.
+        Returns:
+            List of lists, where each list contains the ordered Views involved in forming the implements cycle.
+        """
+
+        return self.graph_cycles(self.implements_graph)
 
     @cached_property
     def requires_constraint_graph(self) -> nx.DiGraph:
@@ -524,15 +557,15 @@ class ValidationResources:
         return False
 
     @cached_property
-    def requires_constraint_cycles(self) -> list[set[ContainerReference]]:
-        """Find all cycles in the requires constraint graph using Tarjan's algorithm.
-
-        Uses strongly connected components (SCC) to identify cycles efficiently.
-        An SCC with more than one node indicates a cycle.
-
+    def requires_constraint_cycles(self) -> list[list[ContainerReference]]:
+        """Find all cycles in the requires constraint graph.
         Returns:
-            List of sets, where each set contains the containers involved in a cycle.
+            List of lists, where each list contains the ordered containers involved in forming the requires cycle.
         """
-        sccs = nx.strongly_connected_components(self.requires_constraint_graph)
-        # Only SCCs with more than one node represent cycles
-        return [scc for scc in sccs if len(scc) > 1]
+
+        return self.graph_cycles(self.requires_constraint_graph)
+
+    @staticmethod
+    def graph_cycles(graph: nx.DiGraph) -> list[list[T_Reference]]:
+        """Returns cycles in the graph otherwise empty list"""
+        return [candidate for candidate in nx.simple_cycles(graph) if len(candidate) > 1]

{cognite_neat-1.0.20 → cognite_neat-1.0.22}/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.20 → cognite_neat-1.0.22}/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.20 → cognite_neat-1.0.22}/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-1.0.20 → cognite_neat-1.0.22}/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.20 → cognite_neat-1.0.22}/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.20 → cognite_neat-1.0.22}/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.20 → cognite_neat-1.0.22}/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]):