cognite-neat 1.0.9__tar.gz → 1.0.28__tar.gz

{cognite_neat-1.0.9 → cognite_neat-1.0.28}/PKG-INFO

@@ -1,26 +1,30 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 1.0.9
+Version: 1.0.28
 Summary: Knowledge graph transformation
 Author: Nikola Vasiljevic, Anders Albert
 Author-email: Nikola Vasiljevic <nikola.vasiljevic@cognite.com>, Anders Albert <anders.albert@cognite.com>
 License-Expression: Apache-2.0
-Requires-Dist: pandas>=1.5.3,<3.0.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Customer Service
+Classifier: Topic :: Database
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
 Requires-Dist: cognite-sdk>=7.83.0,<8.0.0
-Requires-Dist: rdflib>=7.0.0,<8.0.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: pydantic>=2.0.0,<3.0.0
 Requires-Dist: pyyaml>=6.0.1,<7.0.0
-Requires-Dist: requests>=2.28.1,<3.0.0
 Requires-Dist: urllib3>=1.26.15,<3.0.0
 Requires-Dist: openpyxl>=3.0.10,<4.0.0
 Requires-Dist: networkx>=3.4.2,<4.0.0
 Requires-Dist: mixpanel>=4.10.1,<5.0.0
-Requires-Dist: packaging>=22.0
-Requires-Dist: jsonpath-python>=1.0.6,<2.0.0
-Requires-Dist: elementpath>=4.0.0,<5.0.0
-Requires-Dist: pyvis>=0.3.2,<1.0.0
-Requires-Dist: rich[jupyter]>=13.7.1,<14.0.0
 Requires-Dist: exceptiongroup>=1.1.3,<2.0.0 ; python_full_version < '3.11'
 Requires-Dist: backports-strenum>=1.2,<2.0.0 ; python_full_version < '3.11'
 Requires-Dist: typing-extensions>=4.8.0,<5.0.0 ; python_full_version < '3.11'
@@ -39,16 +43,25 @@ Requires-Dist: mkdocs-autorefs>=0.5.0,<1.0.0 ; extra == 'docs'
 Requires-Dist: gspread>=5.0.0,<6.0.0 ; extra == 'google'
 Requires-Dist: google-api-python-client>=2.70.0,<3.0.0 ; extra == 'google'
 Requires-Dist: google-auth-oauthlib>=1.0.0,<2.0.0 ; extra == 'google'
+Requires-Dist: rdflib>=7.0.0,<8.0.0 ; extra == 'legacy'
+Requires-Dist: pandas>=1.5.3,<3.0.0 ; extra == 'legacy'
+Requires-Dist: requests>=2.28.1,<3.0.0 ; extra == 'legacy'
+Requires-Dist: packaging>=22.0 ; extra == 'legacy'
+Requires-Dist: jsonpath-python>=1.0.6,<2.0.0 ; extra == 'legacy'
+Requires-Dist: elementpath>=4.0.0,<5.0.0 ; extra == 'legacy'
+Requires-Dist: pyvis>=0.3.2,<1.0.0 ; extra == 'legacy'
+Requires-Dist: rich[jupyter]>=13.7.1,<14.0.0 ; extra == 'legacy'
 Requires-Dist: lxml>=5.3.0,<6.0.0 ; extra == 'lxml'
 Requires-Dist: oxrdflib>=0.4.0,<0.5.0 ; extra == 'oxi'
 Requires-Dist: pyoxigraph>=0.4.3,<0.5.0 ; extra == 'oxi'
 Requires-Python: >=3.10
-Project-URL: Changelog, https://github.com/cognitedata/neat/releases
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
-Project-URL: GitHub, https://github.com/cognitedata/neat
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/
+Project-URL: GitHub, https://github.com/cognitedata/neat
+Project-URL: Changelog, https://github.com/cognitedata/neat/releases
 Provides-Extra: docs
 Provides-Extra: google
+Provides-Extra: legacy
 Provides-Extra: lxml
 Provides-Extra: oxi
 Description-Content-Type: text/markdown

cognite_neat-1.0.28/cognite/neat/__init__.py

@@ -0,0 +1,7 @@
+from cognite.neat._client.init.main import get_cognite_client
+
+from ._config import NeatConfig, get_neat_config_from_file
+from ._session import NeatSession
+from ._version import __version__
+
+__all__ = ["NeatConfig", "NeatSession", "__version__", "get_cognite_client", "get_neat_config_from_file"]

cognite_neat-1.0.28/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.28/cognite/neat/_client/api.py

@@ -0,0 +1,178 @@
+from abc import ABC, abstractmethod
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from typing import Any, Generic, Literal, TypeAlias, TypeVar
+
+from pydantic import BaseModel, JsonValue, TypeAdapter
+
+from cognite.neat._client.config import NeatClientConfig
+from cognite.neat._data_model.models.dms._base import T_Resource, T_Response
+from cognite.neat._utils.collection import chunker_sequence
+from cognite.neat._utils.http_client import HTTPClient, ParametersRequest, SimpleBodyRequest, SuccessResponse
+from cognite.neat._utils.useful_types import T_Reference
+
+from .data_classes import PagedResponse
+
+_T_BaseModel = TypeVar("_T_BaseModel", bound=BaseModel)
+
+
+@dataclass(frozen=True)
+class Endpoint:
+    method: Literal["GET", "POST"]
+    path: str
+    item_limit: int
+
+
+APIMethod: TypeAlias = Literal["apply", "retrieve", "delete", "list"]
+
+
+class NeatAPI(Generic[T_Reference, T_Resource, T_Response], ABC):
+    def __init__(
+        self, neat_config: NeatClientConfig, http_client: HTTPClient, endpoint_map: dict[APIMethod, Endpoint]
+    ) -> None:
+        self._config = neat_config
+        self._http_client = http_client
+        self._method_endpoint_map = endpoint_map
+
+    @abstractmethod
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[T_Response]:
+        """Parse a single item response."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _validate_id_response(self, response: SuccessResponse) -> list[T_Reference]:
+        """Parse a single item response."""
+        raise NotImplementedError()
+
+    def _make_url(self, path: str = "") -> str:
+        """Create the full URL for this resource endpoint."""
+        return self._config.create_api_url(path)
+
+    def _request_item_response(
+        self,
+        items: Sequence[BaseModel],
+        method: APIMethod,
+        extra_body: dict[str, Any] | None = None,
+    ) -> list[T_Response]:
+        response_items: list[T_Response] = []
+        for response in self._chunk_requests(items, method, extra_body):
+            response_items.extend(self._validate_page_response(response).items)
+        return response_items
+
+    def _request_id_response(
+        self,
+        items: Sequence[BaseModel],
+        method: APIMethod,
+        extra_body: dict[str, Any] | None = None,
+    ) -> list[T_Reference]:
+        response_items: list[T_Reference] = []
+        for response in self._chunk_requests(items, method, extra_body):
+            response_items.extend(self._validate_id_response(response))
+        return response_items
+
+    def _chunk_requests(
+        self,
+        items: Sequence[_T_BaseModel],
+        method: APIMethod,
+        extra_body: dict[str, Any] | None = None,
+    ) -> Iterable[SuccessResponse]:
+        """Send requests in chunks and yield responses.
+
+        Args:
+            items: The items to process.
+            method: The API method to use. This is used ot look the up the endpoint.
+            extra_body: Optional extra body content to include in the request.
+
+        Yields:
+            The successful responses from the API.
+        """
+        # Filter out None
+        endpoint = self._method_endpoint_map[method]
+
+        for chunk in chunker_sequence(items, endpoint.item_limit):
+            request = SimpleBodyRequest(
+                endpoint_url=self._make_url(endpoint.path),
+                method=endpoint.method,
+                body=TypeAdapter(dict[str, JsonValue]).dump_json(
+                    {
+                        "items": [item.model_dump(by_alias=True) for item in chunk],
+                        **(extra_body or {}),
+                    },
+                ),
+            )
+            response = self._http_client.request_with_retries(request)
+            response.raise_for_status()
+            yield response.success_response
+
+    @classmethod
+    def _filter_out_none_values(cls, params: dict[str, Any] | None) -> dict[str, Any] | None:
+        request_params: dict[str, Any] | None = None
+        if params:
+            request_params = {k: v for k, v in params.items() if v is not None}
+        return request_params
+
+    def _paginate(
+        self,
+        limit: int,
+        cursor: str | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> PagedResponse[T_Response]:
+        """Fetch a single page of resources.
+
+        Args:
+            params: Query parameters for the request. Supported parameters depend on
+                the resource type but typically include:
+                - cursor: Cursor for pagination
+                - limit: Maximum number of items (defaults to list limit)
+                - space: Filter by space
+                - includeGlobal: Whether to include global resources
+            limit: Maximum number of items to return in the page.
+            cursor: Cursor for pagination.
+
+        Returns:
+            A Page containing the items and the cursor for the next page.
+        """
+        endpoint = self._method_endpoint_map["list"]
+        if not (0 < limit <= endpoint.item_limit):
+            raise ValueError(f"Limit must be between 1 and {endpoint.item_limit}, got {limit}.")
+        if endpoint.method != "GET":
+            raise NotImplementedError(f"Pagination not implemented for method {endpoint.method}.")
+        request_params = self._filter_out_none_values(params) or {}
+        request_params["limit"] = limit
+        if cursor is not None:
+            request_params["cursor"] = cursor
+        request = ParametersRequest(
+            endpoint_url=self._make_url(endpoint.path),
+            method=endpoint.method,
+            parameters=request_params,
+        )
+        result = self._http_client.request_with_retries(request)
+        result.raise_for_status()
+        return self._validate_page_response(result.success_response)
+
+    def _iterate(
+        self,
+        limit: int | None = None,
+        cursor: str | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> Iterable[list[T_Response]]:
+        """Iterate over all resources, handling pagination automatically."""
+        next_cursor = cursor
+        total = 0
+        endpoint = self._method_endpoint_map["list"]
+        while True:
+            page_limit = endpoint.item_limit if limit is None else min(limit - total, endpoint.item_limit)
+            page = self._paginate(limit=page_limit, cursor=next_cursor, params=params)
+            yield page.items
+            total += len(page.items)
+            if page.next_cursor is None or (limit is not None and total >= limit):
+                break
+            next_cursor = page.next_cursor
+
+    def _list(
+        self,
+        limit: int | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> list[T_Response]:
+        """List all resources, handling pagination automatically."""
+        return [item for batch in self._iterate(limit=limit, params=params) for item in batch]

cognite_neat-1.0.28/cognite/neat/_client/containers_api.py

@@ -0,0 +1,77 @@
+from collections.abc import Sequence
+
+from cognite.neat._data_model.models.dms import ContainerReference, ContainerRequest, ContainerResponse
+from cognite.neat._utils.http_client import HTTPClient, SuccessResponse
+
+from .api import Endpoint, NeatAPI
+from .config import NeatClientConfig
+from .data_classes import PagedResponse
+from .filters import ContainerFilter
+
+
+class ContainersAPI(NeatAPI):
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        super().__init__(
+            neat_config,
+            http_client,
+            endpoint_map={
+                "apply": Endpoint("POST", "models/containers", item_limit=100),
+                "retrieve": Endpoint("POST", "models/containers/byids", item_limit=100),
+                "delete": Endpoint("POST", "models/containers/delete", item_limit=100),
+                "list": Endpoint("GET", "models/containers", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[ContainerResponse]:
+        return PagedResponse[ContainerResponse].model_validate_json(response.body)
+
+    def _validate_id_response(self, response: SuccessResponse) -> list[ContainerReference]:
+        return PagedResponse[ContainerReference].model_validate_json(response.body).items
+
+    def apply(self, items: Sequence[ContainerRequest]) -> list[ContainerResponse]:
+        """Apply (create or update) containers in CDF.
+
+        Args:
+            items: List of ContainerRequest objects to apply.
+        Returns:
+            List of ContainerResponse objects.
+        """
+        return self._request_item_response(items, "apply")
+
+    def retrieve(self, items: list[ContainerReference]) -> list[ContainerResponse]:
+        """Retrieve containers by their identifiers.
+
+        Args:
+            items: List of (space, external_id) tuples identifying the containers to retrieve.
+
+        Returns:
+            List of ContainerResponse objects.
+        """
+        return self._request_item_response(items, "retrieve")
+
+    def delete(self, items: list[ContainerReference]) -> list[ContainerReference]:
+        """Delete containers by their identifiers.
+
+        Args:
+            items: List of ContainerReference objects identifying the containers to delete.
+
+        Returns:
+            List of ContainerReference objects representing the deleted containers.
+        """
+        return self._request_id_response(items, "delete")
+
+    def list(
+        self, space: str | None = None, include_global: bool = False, limit: int | None = 10
+    ) -> list[ContainerResponse]:
+        """List containers in CDF Project.
+
+        Args:
+            space: If specified, only containers in this space are returned.
+            include_global: If True, include global containers.
+            limit: Maximum number of containers to return. If None, return all containers.
+
+        Returns:
+            List of ContainerResponse objects.
+        """
+        filter = ContainerFilter(space=space, include_global=include_global)
+        return self._list(limit=limit, params=filter.dump())

cognite_neat-1.0.28/cognite/neat/_client/data_model_api.py

@@ -0,0 +1,87 @@
+from collections.abc import Sequence
+
+from cognite.neat._data_model.models.dms import DataModelReference, DataModelRequest, DataModelResponse
+from cognite.neat._utils.http_client import HTTPClient, SuccessResponse
+
+from .api import Endpoint, NeatAPI
+from .config import NeatClientConfig
+from .data_classes import PagedResponse
+from .filters import DataModelFilter
+
+
+class DataModelsAPI(NeatAPI):
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        super().__init__(
+            neat_config,
+            http_client,
+            endpoint_map={
+                "apply": Endpoint("POST", "/models/datamodels", item_limit=100),
+                "retrieve": Endpoint("POST", "/models/datamodels/byids", item_limit=100),
+                "delete": Endpoint("POST", "/models/datamodels/delete", item_limit=100),
+                "list": Endpoint("GET", "/models/datamodels", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[DataModelResponse]:
+        return PagedResponse[DataModelResponse].model_validate_json(response.body)
+
+    def _validate_id_response(self, response: SuccessResponse) -> list[DataModelReference]:
+        return PagedResponse[DataModelReference].model_validate_json(response.body).items
+
+    def apply(self, data_models: Sequence[DataModelRequest]) -> list[DataModelResponse]:
+        """Apply (create or update) data models in CDF.
+
+        Args:
+            data_models: List of DataModelRequest objects to apply.
+        Returns:
+            List of DataModelResponse objects.
+        """
+        return self._request_item_response(data_models, "apply")
+
+    def retrieve(self, items: list[DataModelReference]) -> list[DataModelResponse]:
+        """Retrieve data models by their identifiers.
+
+        Args:
+            items: List of data models references identifying the data models to retrieve.
+        Returns:
+            List of DataModelResponse objects.
+        """
+        return self._request_item_response(items, "retrieve")
+
+    def delete(self, items: list[DataModelReference]) -> list[DataModelReference]:
+        """Delete data models by their identifiers.
+
+        Args:
+            items: List of data model references identifying the data models to delete.
+        Returns:
+            List of DataModelReference objects representing the deleted data models.
+        """
+        return self._request_id_response(items, "delete")
+
+    def list(
+        self,
+        space: str | None = None,
+        all_versions: bool = False,
+        inline_views: bool = False,
+        include_global: bool = False,
+        limit: int | None = 10,
+    ) -> list[DataModelResponse]:
+        """List data models in CDF Project.
+
+        Args:
+            space: If specified, only data models in this space are returned.
+            all_versions: If True, return all versions. If False, only return the latest version.
+            inline_views: If True, include views inline in the response.
+            include_global: If True, include global data models.
+            limit: Maximum number of data models to return. If None, return all data models.
+
+        Returns:
+            List of DataModelResponse objects.
+        """
+        filter = DataModelFilter(
+            space=space,
+            all_versions=all_versions,
+            inline_views=inline_views,
+            include_global=include_global,
+        )
+        return self._list(limit=limit, params=filter.dump())

cognite_neat-1.0.28/cognite/neat/_client/filters.py

@@ -0,0 +1,40 @@
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class BaseModelRequest(BaseModel):
+    """Base class for all object. This includes resources and nested objects."""
+
+
+class Filter(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, extra="ignore", populate_by_name=True)
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        """Dump the object to a dictionary.
+
+        Args:
+            camel_case (bool): Whether to use camelCase for the keys. Default is True.
+
+        """
+        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=True)
+
+
+class DataModelingFilter(Filter):
+    space: str | None = None
+    include_global: bool | None = None
+
+
+class ContainerFilter(DataModelingFilter):
+    used_for: Literal["node", "edge", "record", "all"] | None = None
+
+
+class ViewFilter(DataModelingFilter):
+    include_inherited_properties: bool | None = None
+    all_versions: bool | None = None
+
+
+class DataModelFilter(DataModelingFilter):
+    inline_views: bool | None = None
+    all_versions: bool | None = None

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

@@ -0,0 +1,60 @@
+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,
+    }
+    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)

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

@@ -0,0 +1,143 @@
+import sys
+from pathlib import Path
+from typing import Any, Literal, TypeAlias, get_args
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+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["client_credentials", "interactive", "token"]
+AVAILABLE_LOGIN_FLOWS: tuple[LoginFlow, ...] = get_args(LoginFlow)
+Provider: TypeAlias = Literal["entra_id", "auth0", "cdf", "other"]
+AVAILABLE_PROVIDERS: tuple[Provider, ...] = get_args(Provider)
+
+
+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 = "client_credentials"
+
+    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 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)
+
+
+def create_env_file_content(provider: Provider, login_flow: LoginFlow) -> str:
+    lines = [
+        "# Cognite NEAT Client Environment Variables",
+        "CDF_CLUSTER=<your-cdf-cluster>",
+        "CDF_PROJECT=<your-cdf-project>",
+        "",
+    ]
+    if login_flow != "token":
+        lines.append(f"PROVIDER={provider}")
+    lines.append(f"LOGIN_FLOW={login_flow}")
+    lines.append("")
+    if login_flow in ("client_credentials", "interactive"):
+        lines.append("IDP_CLIENT_ID=<your-idp-client-id>")
+        if login_flow == "client_credentials":
+            lines.append("IDP_CLIENT_SECRET=<your-idp-client-secret>")
+        if provider == "entra_id":
+            lines.append("IDP_TENANT_ID=<your-idp-tenant-id>")
+        if provider not in ("cdf", "entra_id"):
+            lines.append("IDP_TOKEN_URL=<your-idp-token-url>")
+        if provider == "other":
+            lines.append("IDP_AUDIENCE=<your-idp-audience>")
+            lines.append("IDP_SCOPES=<your-idp-scopes-comma-separated>")
+            lines.append("IDP_AUTHORITY_URL=<your-idp-authority-url>")
+    elif login_flow == "token":
+        lines.append("CDF_TOKEN=<your-cdf-token>")
+
+    return "\n".join(lines)