cognite-neat 1.0.24__py3-none-any.whl → 1.0.26__py3-none-any.whl

cognite/neat/_client/init/interactive.py

@@ -0,0 +1,133 @@
+import importlib.util
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+from .env_vars import AVAILABLE_LOGIN_FLOWS, AVAILABLE_PROVIDERS, LoginFlow, Provider, create_env_file_content
+
+
+class InteractiveFlow(ABC):
+    def __init__(self, env_path: Path):
+        self.env_path = env_path
+
+    @abstractmethod
+    def run(self) -> None: ...
+
+    def create_env_file(self, provider: Provider, login_flow: LoginFlow) -> None:
+        env_content = create_env_file_content(provider, login_flow)
+        self.env_path.write_text(env_content, encoding="utf-8", newline="\n")
+
+
+def get_interactive_flow(env_file_path: Path) -> InteractiveFlow:
+    try:
+        importlib.util.find_spec("IPython")
+        importlib.util.find_spec("ipywidgets")
+        if not _is_in_notebook():
+            return NoDependencyFlow(env_file_path)
+        return NotebookFlow(env_file_path)
+    except ImportError:
+        return NoDependencyFlow(env_file_path)
+
+
+def _is_in_notebook() -> bool:
+    try:
+        from IPython import get_ipython
+
+        if "IPKernelApp" not in get_ipython().config:
+            return False
+    except ImportError:
+        return False
+    except AttributeError:
+        return False
+    return True
+
+
+class NoDependencyFlow(InteractiveFlow):
+    def run(self) -> None:
+        if not self.should_create_env_file():
+            return None
+        provider = self.provider()
+        login_flow: LoginFlow
+        if provider != "cdf":
+            login_flow = self.login_flow()
+        else:
+            login_flow = "client_credentials"
+        self.create_env_file(provider, login_flow)
+        print(f"Created environment file at {self.env_path!r}.")
+        return None
+
+    def should_create_env_file(self) -> bool:
+        env_file_name = self.env_path.name
+        answer = input(
+            f"Would you like to create a new {env_file_name!r} file with the required environment variables? [y/N]: "
+        )
+        return answer.strip().lower() == "y"
+
+    @classmethod
+    def provider(cls) -> Provider:
+        index = cls._prompt_choice(AVAILABLE_PROVIDERS, "Select provider:")
+        return AVAILABLE_PROVIDERS[index]
+
+    @classmethod
+    def login_flow(cls) -> LoginFlow:
+        index = cls._prompt_choice(AVAILABLE_LOGIN_FLOWS, "Select login flow:")
+        return AVAILABLE_LOGIN_FLOWS[index]
+
+    @classmethod
+    def _prompt_choice(cls, options: tuple[str, ...], prompt: str) -> int:
+        for i, option in enumerate(options, start=1):
+            print(f"{i}. {option}")
+        question = f"{prompt} [1-{len(options)}]: "
+        while True:
+            answer = input(question)
+            if answer.isdigit():
+                index = int(answer)
+                if 1 <= index <= len(options):
+                    return index - 1
+            print(f"Invalid input. Please enter a number between 1 and {len(options)}.")
+
+
+class NotebookFlow(InteractiveFlow):
+    def __init__(self, env_path: Path):
+        super().__init__(env_path)
+        import ipywidgets as widgets  # type: ignore[import-untyped]
+        from IPython.display import display
+
+        self._widgets = widgets
+        self._display = display
+
+    def run(self) -> None:
+        dropdown_providers = self._widgets.Dropdown(
+            options=list(AVAILABLE_PROVIDERS),
+            value=AVAILABLE_PROVIDERS[0],
+            description="Provider:",
+        )
+        dropdown_login_flows = self._widgets.Dropdown(
+            options=list(AVAILABLE_LOGIN_FLOWS),
+            value=AVAILABLE_LOGIN_FLOWS[0],
+            description="Login Flow:",
+        )
+        confirm_button = self._widgets.Button(description="Create template .env file", button_style="primary")
+        dropdowns = self._widgets.HBox([dropdown_providers, dropdown_login_flows])
+        output = self._widgets.Output()
+        container = self._widgets.VBox([dropdowns, confirm_button, output])
+
+        self._display(container)
+
+        def on_confirm_clicked(b: Any) -> None:
+            with output:
+                provider = dropdown_providers.value
+                login_flow = dropdown_login_flows.value
+                if provider == "cdf" and login_flow != "client_credentials":
+                    print(
+                        "Warning: 'cdf' provider only supports 'client_credentials' login flow. Overriding selection."
+                    )
+                    login_flow = "client_credentials"
+                is_existing = self.env_path.exists()
+                self.create_env_file(provider, login_flow)
+                if is_existing:
+                    print(f"Overwrote existing environment file at {self.env_path!r}.")
+                else:
+                    print(f"Created environment file at {self.env_path!r}.")
+
+        confirm_button.on_click(on_confirm_clicked)

cognite/neat/_client/init/main.py

@@ -1,15 +1,19 @@
+from pathlib import Path
+
 from cognite.client import CogniteClient
 from cognite.client.config import ClientConfig, global_config
 
 from cognite.neat import _version
+from cognite.neat._utils.repo import get_repo_root
 
 from .credentials import get_credentials
-from .env_vars import ClientEnvironmentVariables, get_environment_variables
+from .env_vars import ClientEnvironmentVariables, parse_env_file
+from .interactive import get_interactive_flow
 
 CLIENT_NAME = f"CogniteNeat:{_version.__version__}"
 
 
-def get_cognite_client(env_file_name: str) -> CogniteClient:
+def get_cognite_client(env_file_name: str) -> CogniteClient | None:
     """Get a CogniteClient using environment variables from a .env file."
 
     Args:
@@ -20,24 +24,30 @@ def get_cognite_client(env_file_name: str) -> CogniteClient:
     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)
+
+    repo_root = get_repo_root()
+    if repo_root and (env_path := repo_root / env_file_name).exists():
+        print(f"Found {env_file_name} in repository root.")
+    elif (env_path := Path.cwd() / env_file_name).exists():
+        print(f"Found {env_file_name} in current working directory.")
+
+    if env_path.exists():
+        env_vars = parse_env_file(env_path)
+        client_config = create_client_config_from_env_vars(env_vars)
+        return CogniteClient(client_config)
+    print(f"Failed to find {env_file_name} in repository root or current working directory.")
+
+    env_folder = repo_root if repo_root is not None else Path.cwd()
+    new_env_path = env_folder / env_file_name
+    flow = get_interactive_flow(new_env_path)
+    flow.run()
+    print("Could not create CogniteClient because no environment file was found.")
+    return None
 
 
 def create_client_config_from_env_vars(env_vars: ClientEnvironmentVariables) -> ClientConfig:

cognite/neat/_client/spaces_api.py

@@ -1,18 +1,37 @@
 from __future__ import annotations
 
-from cognite.neat._data_model.models.dms import DataModelBody, SpaceRequest, SpaceResponse
+from collections.abc import Sequence
+
+from cognite.neat._data_model.models.dms import SpaceRequest, SpaceResponse
 from cognite.neat._data_model.models.dms._references import SpaceReference
-from cognite.neat._utils.http_client import ItemIDBody, ItemsRequest, ParametersRequest
-from cognite.neat._utils.useful_types import PrimitiveType
+from cognite.neat._utils.http_client import HTTPClient, SuccessResponse
 
-from .api import NeatAPI
+from .api import Endpoint, NeatAPI
+from .config import NeatClientConfig
 from .data_classes import PagedResponse
+from .filters import DataModelingFilter
 
 
 class SpacesAPI(NeatAPI):
-    ENDPOINT = "/models/spaces"
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        super().__init__(
+            neat_config,
+            http_client,
+            endpoint_map={
+                "apply": Endpoint("POST", "/models/spaces", item_limit=100),
+                "retrieve": Endpoint("POST", "/models/spaces/byids", item_limit=100),
+                "delete": Endpoint("POST", "/models/spaces/delete", item_limit=100),
+                "list": Endpoint("GET", "/models/spaces", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[SpaceResponse]:
+        return PagedResponse[SpaceResponse].model_validate_json(response.body)
+
+    def _validate_id_response(self, response: SuccessResponse) -> list[SpaceReference]:
+        return PagedResponse[SpaceReference].model_validate_json(response.body).items
 
-    def apply(self, spaces: list[SpaceRequest]) -> list[SpaceResponse]:
+    def apply(self, spaces: Sequence[SpaceRequest]) -> list[SpaceResponse]:
         """Apply (create or update) spaces in CDF.
 
         Args:
@@ -20,20 +39,7 @@ class SpacesAPI(NeatAPI):
         Returns:
             List of SpaceResponse objects.
         """
-        if not spaces:
-            return []
-        if len(spaces) > 100:
-            raise ValueError("Cannot apply more than 100 spaces at once.")
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="POST",
-                body=DataModelBody(items=spaces),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[SpaceResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(spaces, "apply")
 
     def retrieve(self, spaces: list[SpaceReference]) -> list[SpaceResponse]:
         """Retrieve spaces by their identifiers.
@@ -44,21 +50,7 @@ class SpacesAPI(NeatAPI):
         Returns:
             List of SpaceResponse objects.
         """
-        if not spaces:
-            return []
-        if len(spaces) > 1000:
-            raise ValueError("Cannot retrieve more than 1000 spaces at once.")
-
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/byids"),
-                method="POST",
-                body=ItemIDBody(items=spaces),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[SpaceResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(spaces, "retrieve")
 
     def delete(self, spaces: list[SpaceReference]) -> list[SpaceReference]:
         """Delete spaces by their identifiers.
@@ -68,48 +60,21 @@ class SpacesAPI(NeatAPI):
         Returns:
             List of SpaceReference objects representing the deleted spaces.
         """
-        if not spaces:
-            return []
-        if len(spaces) > 100:
-            raise ValueError("Cannot delete more than 100 spaces at once.")
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
-                method="POST",
-                body=ItemIDBody(items=spaces),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[SpaceReference].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_id_response(spaces, "delete")
 
     def list(
         self,
         include_global: bool = False,
-        limit: int = 10,
+        limit: int | None = 10,
     ) -> list[SpaceResponse]:
         """List spaces in CDF Project.
 
         Args:
             include_global: If True, include global spaces.
-            limit: Maximum number of spaces to return. Max is 1000.
+            limit: Maximum number of spaces to return. If None, return all spaces.
 
         Returns:
             List of SpaceResponse objects.
         """
-        if limit > 1000:
-            raise ValueError("Pagination is not (yet) supported for listing spaces. The maximum limit is 1000.")
-        parameters: dict[str, PrimitiveType] = {
-            "includeGlobal": include_global,
-            "limit": limit,
-        }
-        result = self._http_client.request_with_retries(
-            ParametersRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="GET",
-                parameters=parameters,
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[SpaceResponse].model_validate_json(result.success_response.body)
-        return result.items
+        filter = DataModelingFilter(include_global=include_global)
+        return self._list(limit=limit, params=filter.dump())

cognite/neat/_client/statistics_api.py

@@ -1,9 +1,14 @@
-from cognite.neat._client.api import NeatAPI
-from cognite.neat._client.data_classes import StatisticsResponse
-from cognite.neat._utils.http_client import ParametersRequest
+from cognite.neat._utils.http_client import HTTPClient, ParametersRequest
 
+from .config import NeatClientConfig
+from .data_classes import StatisticsResponse
+
+
+class StatisticsAPI:
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        self._config = neat_config
+        self._http_client = http_client
 
-class StatisticsAPI(NeatAPI):
     def project(self) -> StatisticsResponse:
         """Retrieve project-wide usage data and limits.
 

cognite/neat/_client/views_api.py

@@ -2,46 +2,45 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 
-from cognite.neat._data_model.models.dms import DataModelBody, ViewReference, ViewRequest, ViewResponse
-from cognite.neat._utils.collection import chunker_sequence
-from cognite.neat._utils.http_client import ItemIDBody, ItemsRequest, ParametersRequest
-from cognite.neat._utils.useful_types import PrimitiveType
+from cognite.neat._data_model.models.dms import ViewReference, ViewRequest, ViewResponse
+from cognite.neat._utils.http_client import HTTPClient, SuccessResponse
 
-from .api import NeatAPI
+from .api import Endpoint, NeatAPI
+from .config import NeatClientConfig
 from .data_classes import PagedResponse
+from .filters import ViewFilter
 
 
 class ViewsAPI(NeatAPI):
-    ENDPOINT = "/models/views"
-    LIST_REQUEST_LIMIT = 1000
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        super().__init__(
+            neat_config,
+            http_client,
+            endpoint_map={
+                "apply": Endpoint("POST", "/models/views", item_limit=100),
+                "retrieve": Endpoint("POST", "/models/views/byids", item_limit=100),
+                "delete": Endpoint("POST", "/models/views/delete", item_limit=100),
+                "list": Endpoint("GET", "/models/views", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[ViewResponse]:
+        return PagedResponse[ViewResponse].model_validate_json(response.body)
+
+    def _validate_id_response(self, response: SuccessResponse) -> list[ViewReference]:
+        return PagedResponse[ViewReference].model_validate_json(response.body).items
 
     def apply(self, items: Sequence[ViewRequest]) -> list[ViewResponse]:
         """Create or update views in CDF Project.
+
         Args:
             items: List of ViewRequest objects to create or update.
         Returns:
             List of ViewResponse objects.
         """
-        if not items:
-            return []
-        if len(items) > 100:
-            raise ValueError("Cannot apply more than 100 views at once.")
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="POST",
-                body=DataModelBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[ViewResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(items, "apply")
 
-    def retrieve(
-        self,
-        items: list[ViewReference],
-        include_inherited_properties: bool = True,
-    ) -> list[ViewResponse]:
+    def retrieve(self, items: list[ViewReference], include_inherited_properties: bool = True) -> list[ViewResponse]:
         """Retrieve views by their identifiers.
 
         Args:
@@ -51,42 +50,20 @@ class ViewsAPI(NeatAPI):
         Returns:
             List of ViewResponse objects.
         """
-        results: list[ViewResponse] = []
-        for chunk in chunker_sequence(items, 100):
-            batch = self._http_client.request_with_retries(
-                ItemsRequest(
-                    endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/byids"),
-                    method="POST",
-                    body=ItemIDBody(items=chunk),
-                    parameters={"includeInheritedProperties": include_inherited_properties},
-                )
-            )
-            batch.raise_for_status()
-            result = PagedResponse[ViewResponse].model_validate_json(batch.success_response.body)
-            results.extend(result.items)
-        return results
+        return self._request_item_response(
+            items, "retrieve", extra_body={"includeInheritedProperties": include_inherited_properties}
+        )
 
     def delete(self, items: list[ViewReference]) -> list[ViewReference]:
         """Delete views by their identifiers.
 
         Args:
             items: List of (space, external_id, version) tuples identifying the views to delete.
+
+        Returns:
+            List of ViewReference objects representing the deleted views.
         """
-        if not items:
-            return []
-        if len(items) > 100:
-            raise ValueError("Cannot delete more than 100 views at once.")
-
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
-                method="POST",
-                body=ItemIDBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[ViewReference].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_id_response(items, "delete")
 
     def list(
         self,
@@ -108,37 +85,10 @@ class ViewsAPI(NeatAPI):
         Returns:
             List of ViewResponse objects.
         """
-        if limit is not None and limit < 0:
-            raise ValueError("Limit must be non-negative.")
-        elif limit is not None and limit == 0:
-            return []
-        parameters: dict[str, PrimitiveType] = {
-            "allVersions": all_versions,
-            "includeInheritedProperties": include_inherited_properties,
-            "includeGlobal": include_global,
-        }
-        if space is not None:
-            parameters["space"] = space
-        cursor: str | None = None
-        view_responses: list[ViewResponse] = []
-        while True:
-            if cursor is not None:
-                parameters["cursor"] = cursor
-            if limit is None:
-                parameters["limit"] = self.LIST_REQUEST_LIMIT
-            else:
-                parameters["limit"] = min(self.LIST_REQUEST_LIMIT, limit - len(view_responses))
-            result = self._http_client.request_with_retries(
-                ParametersRequest(
-                    endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                    method="GET",
-                    parameters=parameters,
-                )
-            )
-            result.raise_for_status()
-            result = PagedResponse[ViewResponse].model_validate_json(result.success_response.body)
-            view_responses.extend(result.items)
-            cursor = result.next_cursor
-            if cursor is None or (limit is not None and len(view_responses) >= limit):
-                break
-        return view_responses
+        filter = ViewFilter(
+            space=space,
+            all_versions=all_versions,
+            include_inherited_properties=include_inherited_properties,
+            include_global=include_global,
+        )
+        return self._list(limit=limit, params=filter.dump())

cognite/neat/_data_model/models/dms/_base.py

@@ -22,6 +22,9 @@ class WriteableResource(Resource, Generic[T_Resource], ABC):
         raise NotImplementedError()
 
 
+T_Response = TypeVar("T_Response", bound=WriteableResource)
+
+
 class APIResource(Generic[T_Reference], ABC):
     """Base class for all API data modeling resources."""
 

cognite/neat/_session/_session.py

@@ -15,11 +15,19 @@ from ._physical import PhysicalDataModel
 from ._result import Result
 
 
+def _is_in_browser() -> bool:
+    try:
+        from pyodide.ffi import IN_BROWSER  # type: ignore [import-not-found]
+    except ModuleNotFoundError:
+        return False
+    return IN_BROWSER
+
+
 class NeatSession:
     """A session is an interface for neat operations."""
 
     def __init__(
-        self, client: CogniteClient | ClientConfig, config: PredefinedProfile | NeatConfig = "legacy-additive"
+        self, client: CogniteClient | ClientConfig | None, config: PredefinedProfile | NeatConfig = "legacy-additive"
     ) -> None:
         """Initialize a Neat session.
 
@@ -30,6 +38,10 @@ class NeatSession:
                 Defaults to "legacy-additive". This means Neat will perform additive modeling
                 and apply only validations that were part of the legacy Neat version.
         """
+        if client is None and _is_in_browser():
+            client = CogniteClient()
+        elif client is None:
+            raise ValueError("A CogniteClient or ClientConfig must be provided to initialize a NeatSession.")
         self._config = NeatConfig.create_predefined(config) if isinstance(config, str) else config
 
         # Use configuration for physical data model

cognite/neat/_utils/http_client/_client.py

@@ -167,7 +167,9 @@ class HTTPClient:
         if isinstance(item, BodyRequest):
             data = item.data()
             if not global_config.disable_gzip:
-                data = gzip.compress(data.encode("utf-8"))
+                if isinstance(data, str):
+                    data = data.encode("utf-8")
+                data = gzip.compress(data)
         return self.session.request(
             method=item.method,
             url=item.endpoint_url,

cognite/neat/_utils/http_client/_data_classes.py

@@ -118,14 +118,14 @@ class BodyRequest(ParametersRequest, ABC):
     """Base class for HTTP request messages with a body"""
 
     @abstractmethod
-    def data(self) -> str:
+    def data(self) -> str | bytes:
         raise NotImplementedError()
 
 
 class SimpleBodyRequest(BodyRequest):
-    body: str
+    body: str | bytes
 
-    def data(self) -> str:
+    def data(self) -> str | bytes:
         return self.body
 
 

cognite/neat/_utils/repo.py

@@ -2,7 +2,7 @@ import subprocess
 from pathlib import Path
 
 
-def get_repo_root() -> Path:
+def get_repo_root() -> Path | None:
     """Get the root path of the git repository.
 
     Raises:
@@ -11,9 +11,11 @@ def get_repo_root() -> Path:
     """
     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
+    except FileNotFoundError:
+        # Git is not installed or not found in PATH
+        return None
     output = result.stdout.decode().strip()
     if not output:
-        raise RuntimeError("Not in a git repository")
+        # Not in a git repository
+        return None
     return Path(output)

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "1.0.24"
+__version__ = "1.0.26"
 __engine__ = "^2.0.4"

{cognite_neat-1.0.24.dist-info → cognite_neat-1.0.26.dist-info}/METADATA

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