cognite-neat 1.0.23__py3-none-any.whl → 1.0.25__py3-none-any.whl

cognite/neat/__init__.py

@@ -1,4 +1,4 @@
-from cognite.neat._v0.core._utils.auth import get_cognite_client
+from cognite.neat._client.init.main import get_cognite_client
 
 from ._config import NeatConfig, get_neat_config_from_file
 from ._session import NeatSession

cognite/neat/_client/init/credentials.py

@@ -12,7 +12,6 @@ def get_credentials(env_vars: 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)
 
@@ -59,12 +58,3 @@ def create_token_credentials(env_vars: ClientEnvironmentVariables) -> Credential
     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

@@ -4,7 +4,6 @@ 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):
@@ -12,9 +11,10 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
-LoginFlow: TypeAlias = Literal["infer", "client_credentials", "interactive", "token"]
-VALID_LOGIN_FLOWS = get_args(LoginFlow)
+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):
@@ -24,7 +24,7 @@ class ClientEnvironmentVariables(BaseModel):
     CDF_CLUSTER: str
     CDF_PROJECT: str
     PROVIDER: Provider = "entra_id"
-    LOGIN_FLOW: LoginFlow = "infer"
+    LOGIN_FLOW: LoginFlow = "client_credentials"
 
     IDP_CLIENT_ID: str | None = None
     IDP_CLIENT_SECRET: str | None = None
@@ -103,24 +103,7 @@ class ClientEnvironmentVariables(BaseModel):
         )
 
 
-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:
+def parse_env_file(env_file_path: Path) -> ClientEnvironmentVariables:
     content = env_file_path.read_text()
     variables: dict[str, Any] = {}
     for line in content.splitlines():
@@ -129,3 +112,32 @@ def _parse_env_file(env_file_path: Path) -> ClientEnvironmentVariables:
         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)

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/_data_model/exporters/_api_exporter.py

@@ -1,9 +1,16 @@
+import warnings
+import zipfile
+from collections.abc import Iterator
 from pathlib import Path
 
 import yaml
+from pydantic import BaseModel
 
 from cognite.neat._data_model.exporters._base import DMSExporter, DMSFileExporter
 from cognite.neat._data_model.models.dms import RequestSchema
+from cognite.neat._data_model.models.dms._container import ContainerRequest
+from cognite.neat._data_model.models.dms._references import NodeReference
+from cognite.neat._data_model.models.dms._views import ViewRequest
 
 
 class DMSAPIExporter(DMSExporter[RequestSchema]):
@@ -16,12 +23,90 @@ class DMSAPIExporter(DMSExporter[RequestSchema]):
 
 class DMSAPIYAMLExporter(DMSAPIExporter, DMSFileExporter[RequestSchema]):
     def export_to_file(self, data_model: RequestSchema, file_path: Path) -> None:
-        """Export the data model to a YAML file in API format."""
-        if file_path.suffix.lower() not in {".yaml", ".yml"}:
-            raise ValueError("The file path must have a .yaml or .yml extension.")
+        """Export the data model to a YAML files or zip file in API format.
 
-        api_format = data_model.model_dump(mode="json", by_alias=True)
-        file_path.write_text(yaml.safe_dump(api_format, sort_keys=False), encoding=self.ENCODING, newline=self.NEW_LINE)
+        Args:
+            data_model: Request schema
+            file_path: The directory or zip file to save the schema to.
+
+        """
+
+        if file_path.is_dir():
+            self._export_to_directory(data_model, file_path)
+        else:
+            self._export_to_zip_file(data_model, file_path)
+
+    def _export_to_directory(self, data_model: RequestSchema, directory: Path) -> None:
+        """Save the schema to a directory as YAML files. This is compatible with the Cognite-Toolkit convention.
+
+        Args:
+            data_model: Request schema
+            directory: The directory to save the schema to.
+        """
+
+        subdir = directory / "data_models"
+        subdir.mkdir(parents=True, exist_ok=True)
+
+        for file_path, yaml_content in self._generate_yaml_entries(data_model):
+            full_path = subdir / file_path
+            # Create parent directories if needed (e.g., for views/, containers/, nodes/)
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+            full_path.write_text(
+                yaml_content,
+                encoding=self.ENCODING,
+                newline=self.NEW_LINE,
+            )
+
+    def _export_to_zip_file(self, data_model: RequestSchema, zip_file: Path) -> None:
+        """Save the schema as a zip file containing a directory as YAML files.
+        This is compatible with the Cognite-Toolkit convention.
+
+        Args:
+            data_model: Request schema
+            zip_file: The zip file path to save the schema to.
+        """
+        if zip_file.suffix not in {".zip"}:
+            warnings.warn("File extension is not .zip, adding it to the file name", stacklevel=2)
+            zip_file = zip_file.with_suffix(".zip")
+
+        with zipfile.ZipFile(zip_file, "w") as zip_ref:
+            for file_path, yaml_content in self._generate_yaml_entries(data_model):
+                zip_ref.writestr(f"data_models/{file_path}", yaml_content)
+
+    def _generate_yaml_entries(self, data_model: RequestSchema) -> Iterator[tuple[str, str]]:
+        """Generate file paths and YAML content for all data model components.
+
+        This helper method eliminates duplication by centralizing the logic for
+        iterating through spaces, views, containers, and node types.
+
+        Args:
+            data_model: Request schema
+
+        Yields:
+            Tuples of (file_path, yaml_content) for each component.
+            File paths are relative to the data_models directory.
+        """
+
+        def _dump(item: BaseModel) -> str:
+            return yaml.safe_dump(item.model_dump(mode="json", by_alias=True), sort_keys=False)
+
+        # Export spaces
+        for space in data_model.spaces:
+            yield f"{space.space}.space.yaml", _dump(space)
+
+        # Export data model
+        yield f"{data_model.data_model.external_id}.datamodel.yaml", _dump(data_model.data_model)
+
+        component_configs: list[tuple[str, list[ViewRequest] | list[ContainerRequest] | list[NodeReference]]] = [
+            ("views", data_model.views),
+            ("containers", data_model.containers),
+            ("nodes", data_model.node_types),
+        ]
+
+        for dir_prefix, components in component_configs:
+            file_suffix = dir_prefix.removesuffix("s")
+            for component in components:
+                yield f"{dir_prefix}/{component.external_id}.{file_suffix}.yaml", _dump(component)
 
 
 class DMSAPIJSONExporter(DMSAPIExporter, DMSFileExporter[RequestSchema]):

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/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.23"
+__version__ = "1.0.25"
 __engine__ = "^2.0.4"

{cognite_neat-1.0.23.dist-info → cognite_neat-1.0.25.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-cognite/neat/__init__.py,sha256=4RJ6p29cDU_VwQ3sVsgiFdb817BKqKASp-lIgQeD6BI,300
+cognite/neat/__init__.py,sha256=YU2PPtzByiyLcUeWePkckaL9v-ZxoR6OF6wiq-2XVwM,297
 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
@@ -7,9 +7,10 @@ cognite/neat/_client/containers_api.py,sha256=7bVIlL5PwoAG5Bks1ortW_bCG8iTkFqFVy
 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/init/credentials.py,sha256=8PCKk-rc3rxG3l9vNiY3DklIziJgJpBr9nleozS7BZw,2385
+cognite/neat/_client/init/env_vars.py,sha256=9nOEVABp4rI2TtFHCMItLouQ5MXFL0zzL4PTclT9m-c,5469
+cognite/neat/_client/init/interactive.py,sha256=YVnsvRblQJPojf24dA050gVlrrqADK8afSQ6hkXn7Cs,4801
+cognite/neat/_client/init/main.py,sha256=D-9bsor07T84iFnTZLnhIFA1Xey9zsooHaDhXVeNdos,2508
 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
@@ -29,7 +30,7 @@ cognite/neat/_data_model/deployer/_differ_view.py,sha256=g1xHwsoxFUaTOTtQa19nntK
 cognite/neat/_data_model/deployer/data_classes.py,sha256=cq86u7wuKCcvH-A_cGI_gWzlQCTIG6mrXG2MahdiGco,27299
 cognite/neat/_data_model/deployer/deployer.py,sha256=lEdTh4jOwTxLkSEx-SlcnXUZyPZCUtIzop1zhAe2s44,19681
 cognite/neat/_data_model/exporters/__init__.py,sha256=AskjmB_0Vqib4kN84bWt8-M8nO42QypFf-l-E8oA5W8,482
-cognite/neat/_data_model/exporters/_api_exporter.py,sha256=G9cqezy_SH8VdhW4o862qBHh_QcbzfP6O1Yyjvdpeog,1579
+cognite/neat/_data_model/exporters/_api_exporter.py,sha256=nBDHx9dGbaje0T4IEQv0Kulk2Yu7FkPXgXK_MgLbE50,4948
 cognite/neat/_data_model/exporters/_base.py,sha256=rG_qAU5i5Hh5hUMep2UmDFFZID4x3LEenL6Z5C6N8GQ,646
 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
@@ -106,7 +107,7 @@ cognite/neat/_session/_result/_deployment/_physical/_changes.py,sha256=CmFWxAMtV
 cognite/neat/_session/_result/_deployment/_physical/_statistics.py,sha256=aOXZTSOGmVggERB4mKaqQEUx40vrxiN9ZkwjKU1555A,6324
 cognite/neat/_session/_result/_deployment/_physical/serializer.py,sha256=BbCUb7_C75enMimGgTPg-ZW1QGcRhPDf5dNwpWdM790,1272
 cognite/neat/_session/_result/_result.py,sha256=OnjIJQSnIzYr-IE50rq7z3CVO0LpVE8tAaZN7XPjlKw,1188
-cognite/neat/_session/_session.py,sha256=5wgXxcgsoQ3YaI8vDbMSJ3ZJu_O0El4z5fk3ZjH0-5I,3304
+cognite/neat/_session/_session.py,sha256=SsPEYupMiW7zRFruTjC1Ga9yvvs5gkygdpI_tVyh1rA,3729
 cognite/neat/_session/_usage_analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_session/_usage_analytics/_collector.py,sha256=8yVfzt8KFfZ-ldkVjDWazuQbs45Q3r6vWKcZEwU8i18,4734
 cognite/neat/_session/_usage_analytics/_constants.py,sha256=-tVdYrCTMKfuMlbO7AlzC29Nug41ug6uuX9DFuihpJg,561
@@ -127,7 +128,7 @@ cognite/neat/_utils/http_client/_client.py,sha256=TO9C77LcsqX0R3Fu-mP560nnV6rP5o
 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/repo.py,sha256=Ex_lW7qd4fi0YLaOJaLRwSyrN46kfMXbxecVE4mSs2I,598
 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
@@ -321,9 +322,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=rj_LKbqpGZavJZekkd20Oo3-5Wi6i3pBDjeRkCt22zY,45
+cognite/neat/_version.py,sha256=kEQ71HVQEACqgtyau8hgTcILi0EwbWj3B7RI2KWSEHg,45
 cognite/neat/legacy.py,sha256=eI2ecxOV8ilGHyLZlN54ve_abtoK34oXognkFv3yvF0,219
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_neat-1.0.23.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
-cognite_neat-1.0.23.dist-info/METADATA,sha256=hByYgnOhvq27boiIAHGRyCwddaWgqPxcP_jX8TytSMs,6689
-cognite_neat-1.0.23.dist-info/RECORD,,
+cognite_neat-1.0.25.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+cognite_neat-1.0.25.dist-info/METADATA,sha256=Puzp0pIIcNYZAvb2M1YswRXTzr6pvtqk4cfBT-oeKBg,6689
+cognite_neat-1.0.25.dist-info/RECORD,,