cognite-neat 0.84.0__py3-none-any.whl → 0.85.0__py3-none-any.whl

cognite/neat/rules/exporters/_base.py

@@ -7,6 +7,7 @@ from cognite.client import CogniteClient
 
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.models import DMSRules, InformationRules, RoleTypes
+from cognite.neat.utils.auxiliary import class_html_doc
 from cognite.neat.utils.upload import UploadResult, UploadResultList
 
 T_Export = TypeVar("T_Export")
@@ -34,6 +35,10 @@ class BaseExporter(ABC, Generic[T_Export]):
         else:
             raise NotImplementedError(f"Role {output_role} is not supported for {type(rules).__name__} rules")
 
+    @classmethod
+    def _repr_html_(cls) -> str:
+        return class_html_doc(cls, include_factory_methods=False)
+
 
 class CDFExporter(BaseExporter[T_Export]):
     @abstractmethod

cognite/neat/rules/exporters/_rules2dms.py

@@ -39,7 +39,7 @@ Component: TypeAlias = Literal["all", "spaces", "data_models", "views", "contain
 
 
 class DMSExporter(CDFExporter[DMSSchema]):
-    """Class for exporting rules object to CDF Data Model Storage (DMS).
+    """Export rules to Cognite Data Fusion's Data Model Storage (DMS) service.
 
     Args:
         export_components (frozenset[Literal["all", "spaces", "data_models", "views", "containers"]], optional):

cognite/neat/rules/exporters/_rules2ontology.py

@@ -39,16 +39,22 @@ class GraphExporter(BaseExporter[Graph], ABC):
 
 
 class OWLExporter(GraphExporter):
+    """Exports rules to an OWL ontology."""
+
     def export(self, rules: Rules) -> Graph:
         return Ontology.from_rules(rules).as_owl()
 
 
 class SHACLExporter(GraphExporter):
+    """Exports rules to a SHACL graph."""
+
     def export(self, rules: Rules) -> Graph:
         return Ontology.from_rules(rules).as_shacl()
 
 
 class SemanticDataModelExporter(GraphExporter):
+    """Exports rules to a semantic data model."""
+
     def export(self, rules: Rules) -> Graph:
         return Ontology.from_rules(rules).as_semantic_data_model()
 

cognite/neat/rules/importers/__init__.py

@@ -16,3 +16,23 @@ __all__ = [
     "YAMLImporter",
     "InferenceImporter",
 ]
+
+
+def _repr_html_() -> str:
+    import pandas as pd
+
+    table = pd.DataFrame(  # type: ignore[operator]
+        [
+            {
+                "Importer": name,
+                "Description": globals()[name].__doc__.strip().split("\n")[0] if globals()[name].__doc__ else "Missing",
+            }
+            for name in __all__
+            if name != "BaseImporter"
+        ]
+    )._repr_html_()
+
+    return (
+        "<strong>Importer</strong> An importer reads data/schema/data model from a source"
+        f" and converts it into Neat's representation of a data model called <em>Rules</em>.<br />{table}"
+    )

cognite/neat/rules/importers/_base.py

@@ -11,7 +11,8 @@ from rdflib import Namespace
 
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.issues.base import IssueList, NeatValidationError, ValidationWarning
-from cognite.neat.rules.models import DMSRules, InformationRules, RoleTypes
+from cognite.neat.rules.models import AssetRules, DMSRules, InformationRules, RoleTypes
+from cognite.neat.utils.auxiliary import class_html_doc
 
 
 class BaseImporter(ABC):
@@ -48,9 +49,9 @@ class BaseImporter(ABC):
 
         if rules.metadata.role is role or role is None:
             output = rules
-        elif isinstance(rules, DMSRules) and role is RoleTypes.information_architect:
+        elif isinstance(rules, DMSRules) or isinstance(rules, AssetRules) and role is RoleTypes.information_architect:
             output = rules.as_information_architect_rules()
-        elif isinstance(rules, InformationRules) and role is RoleTypes.dms_architect:
+        elif isinstance(rules, InformationRules) or isinstance(rules, AssetRules) and role is RoleTypes.dms_architect:
             output = rules.as_dms_architect_rules()
         else:
             raise NotImplementedError(f"Role {role} is not supported for {type(rules).__name__} rules")
@@ -79,6 +80,10 @@ class BaseImporter(ABC):
             "description": f"Imported using {type(self).__name__}",
         }
 
+    @classmethod
+    def _repr_html_(cls) -> str:
+        return class_html_doc(cls)
+
 
 class _FutureResult:
     def __init__(self) -> None:

cognite/neat/rules/importers/_dms2rules.py

@@ -46,6 +46,16 @@ from cognite.neat.rules.models.entities import (
 
 
 class DMSImporter(BaseImporter):
+    """Imports a Data Model from Cognite Data Fusion.
+
+    Args:
+        schema: The schema containing the data model.
+        read_issues: A list of issues that occurred during the import.
+        metadata: Metadata for the data model.
+        ref_metadata: Metadata for the reference data model.
+
+    """
+
     def __init__(
         self,
         schema: DMSSchema,

cognite/neat/rules/importers/_dtdl2rules/dtdl_importer.py

@@ -18,7 +18,7 @@ from cognite.neat.utils.text import to_pascal
 
 
 class DTDLImporter(BaseImporter):
-    """Importer for DTDL (Digital Twin Definition Language).
+    """Importer from Azure Digital Twin - DTDL (Digital Twin Definition Language).
 
     This importer supports DTDL v2.0 and v3.0.
 

cognite/neat/rules/importers/_inference2rules.py

@@ -33,7 +33,11 @@ INSTANCE_PROPERTIES_DEFINITION = """SELECT ?property (count(?property) as ?occur
 
 
 class InferenceImporter(BaseImporter):
-    """Rules inference through analysis of knowledge graph provided in various formats.
+    """Infers rules from a triple store.
+
+    Rules inference through analysis of knowledge graph provided in various formats.
+    Use the factory methods to create an triples store from sources such as
+    RDF files, JSON files, YAML files, XML files, or directly from a graph store.
 
     Args:
         issue_list: Issue list to store issues

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -205,6 +205,12 @@ class SpreadsheetReader:
 
 
 class ExcelImporter(BaseImporter):
+    """Import rules from an Excel file.
+
+    Args:
+        filepath (Path): The path to the Excel file.
+    """
+
     def __init__(self, filepath: Path):
         self.filepath = filepath
 
@@ -286,6 +292,17 @@ class ExcelImporter(BaseImporter):
 
 
 class GoogleSheetImporter(BaseImporter):
+    """Import rules from a Google Sheet.
+
+    .. warning::
+
+        This importer is experimental and may not work as expected.
+
+    Args:
+        sheet_id (str): The Google Sheet ID.
+        skiprows (int): The number of rows to skip when reading the Google Sheet.
+    """
+
     def __init__(self, sheet_id: str, skiprows: int = 1):
         self.sheet_id = sheet_id
         self.skiprows = skiprows

cognite/neat/rules/models/_rdfpath.py

@@ -6,7 +6,7 @@ from collections import Counter
 from functools import total_ordering
 from typing import ClassVar, Literal
 
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, field_validator, model_serializer
 
 from cognite.neat.rules import exceptions
 
@@ -82,6 +82,7 @@ TABLE_REGEX_COMPILED = re.compile(
 
 StepDirection = Literal["source", "target", "origin"]
 _direction_by_symbol: dict[str, StepDirection] = {"->": "target", "<-": "source"}
+_symbol_by_direction: dict[StepDirection, str] = {"source": "<-", "target": "->"}
 
 Undefined = type(object())
 Unknown = type(object())
@@ -196,10 +197,29 @@ class Step(BaseModel):
         msg += " ->prefix:suffix, <-prefix:suffix, ->prefix:suffix(prefix:suffix) or <-prefix:suffix(prefix:suffix)"
         raise ValueError(msg)
 
+    def __str__(self) -> str:
+        if self.property:
+            return f"{self.class_}({self.property})"
+        else:
+            return f"{_symbol_by_direction[self.direction]}{self.class_}"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
 
 class Traversal(BaseModel):
     class_: Entity
 
+    def __str__(self) -> str:
+        return f"{self.class_}"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    @model_serializer(when_used="unless-none", return_type=str)
+    def as_str(self) -> str:
+        return str(self)
+
 
 class SingleProperty(Traversal):
     property: Entity
@@ -208,6 +228,9 @@ class SingleProperty(Traversal):
     def from_string(cls, class_: str, property_: str) -> Self:
         return cls(class_=Entity.from_string(class_), property=Entity.from_string(property_))
 
+    def __str__(self) -> str:
+        return f"{self.class_}({self.property})"
+
 
 class AllReferences(Traversal):
     @classmethod
@@ -220,6 +243,9 @@ class AllProperties(Traversal):
     def from_string(cls, class_: str) -> Self:
         return cls(class_=Entity.from_string(class_))
 
+    def __str__(self) -> str:
+        return f"{self.class_}(*)"
+
 
 class Origin(BaseModel):
     class_: Entity
@@ -245,6 +271,9 @@ class Hop(Traversal):
             ),
         )
 
+    def __str__(self) -> str:
+        return f"{self.class_}{''.join([str(step) for step in self.traversal])}"
+
 
 class TableLookup(BaseModel):
     name: str
@@ -261,7 +290,17 @@ class Query(BaseModel):
 
 
 class RDFPath(Rule):
-    traversal: Traversal | Query
+    traversal: SingleProperty | AllProperties | AllReferences | Hop
+
+    def __str__(self) -> str:
+        return f"{self.traversal}"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    @model_serializer(when_used="unless-none", return_type=str)
+    def as_str(self) -> str:
+        return str(self)
 
 
 class RawLookup(RDFPath):

cognite/neat/rules/models/asset/_rules.py

@@ -148,9 +148,12 @@ class AssetRules(BaseRules):
     def as_domain_rules(self) -> DomainRules:
         from ._converter import _AssetRulesConverter
 
-        return _AssetRulesConverter(cast(InformationRules, self)).as_domain_rules()
+        return _AssetRulesConverter(self.as_information_architect_rules()).as_domain_rules()
 
     def as_dms_architect_rules(self) -> "DMSRules":
         from ._converter import _AssetRulesConverter
 
-        return _AssetRulesConverter(cast(InformationRules, self)).as_dms_architect_rules()
+        return _AssetRulesConverter(self.as_information_architect_rules()).as_dms_architect_rules()
+
+    def as_information_architect_rules(self) -> InformationRules:
+        return InformationRules.model_validate(self.model_dump())

cognite/neat/rules/models/information/_converter.py

@@ -16,11 +16,15 @@ from cognite.neat.rules.models._constants import DMS_CONTAINER_SIZE_LIMIT
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.domain import DomainRules
 from cognite.neat.rules.models.entities import (
+    AssetEntity,
+    AssetFields,
     ClassEntity,
     ContainerEntity,
     DMSUnknownEntity,
+    EntityTypes,
     MultiValueTypeInfo,
     ReferenceEntity,
+    RelationshipEntity,
     UnknownEntity,
     ViewEntity,
     ViewPropertyEntity,
@@ -29,6 +33,7 @@ from cognite.neat.rules.models.entities import (
 from ._rules import InformationClass, InformationMetadata, InformationProperty, InformationRules
 
 if TYPE_CHECKING:
+    from cognite.neat.rules.models.asset._rules import AssetRules
     from cognite.neat.rules.models.dms._rules import DMSMetadata, DMSProperty, DMSRules
 
 
@@ -52,6 +57,28 @@ class _InformationRulesConverter:
     def as_domain_rules(self) -> DomainRules:
         raise NotImplementedError("DomainRules not implemented yet")
 
+    def as_asset_architect_rules(self) -> "AssetRules":
+        from cognite.neat.rules.models.asset._rules import AssetClass, AssetMetadata, AssetProperty, AssetRules
+
+        classes: SheetList[AssetClass] = SheetList[AssetClass](
+            data=[AssetClass(**class_.model_dump()) for class_ in self.rules.classes]
+        )
+        properties: SheetList[AssetProperty] = SheetList[AssetProperty]()
+        for prop_ in self.rules.properties:
+            if prop_.type_ == EntityTypes.data_property:
+                properties.append(
+                    AssetProperty(**prop_.model_dump(), implementation=[AssetEntity(property=AssetFields.metadata)])
+                )
+            elif prop_.type_ == EntityTypes.object_property:
+                properties.append(AssetProperty(**prop_.model_dump(), implementation=[RelationshipEntity()]))
+
+        return AssetRules(
+            metadata=AssetMetadata(**self.rules.metadata.model_dump()),
+            properties=properties,
+            classes=classes,
+            prefixes=self.rules.prefixes,
+        )
+
     def as_dms_architect_rules(self) -> "DMSRules":
         from cognite.neat.rules.models.dms._rules import (
             DMSContainer,

cognite/neat/rules/models/information/_rules.py

@@ -49,7 +49,7 @@ from cognite.neat.rules.models.entities import (
 )
 
 if TYPE_CHECKING:
-    from cognite.neat.rules.models.dms._rules import DMSRules
+    from cognite.neat.rules.models import AssetRules, DMSRules
 
 
 if sys.version_info >= (3, 11):
@@ -341,6 +341,11 @@ class InformationRules(BaseRules):
 
         return _InformationRulesConverter(self).as_domain_rules()
 
+    def as_asset_architect_rules(self) -> "AssetRules":
+        from ._converter import _InformationRulesConverter
+
+        return _InformationRulesConverter(self).as_asset_architect_rules()
+
     def as_dms_architect_rules(self) -> "DMSRules":
         from ._converter import _InformationRulesConverter
 

cognite/neat/utils/auth.py

@@ -0,0 +1,298 @@
+import os
+import subprocess
+from contextlib import suppress
+from dataclasses import dataclass, fields
+from pathlib import Path
+from typing import Literal, TypeAlias, get_args
+
+from cognite.client import CogniteClient
+from cognite.client.credentials import CredentialProvider, OAuthClientCredentials, OAuthInteractive, Token
+
+from cognite.neat import _version
+from cognite.neat.utils.auxiliary import local_import
+
+__all__ = ["get_cognite_client"]
+
+_LOGIN_FLOW: TypeAlias = Literal["infer", "client_credentials", "interactive", "token"]
+_VALID_LOGIN_FLOWS = get_args(_LOGIN_FLOW)
+_CLIENT_NAME = f"CogniteNeat:{_version.__version__}"
+
+
+def get_cognite_client() -> CogniteClient:
+    with suppress(KeyError):
+        variables = _EnvironmentVariables.create_from_environ()
+        return variables.get_client()
+
+    repo_root = _repo_root()
+    if repo_root:
+        with suppress(KeyError, FileNotFoundError, TypeError):
+            variables = _from_dotenv(repo_root / ".env")
+            client = variables.get_client()
+            print("Found .env file in repository root. Loaded variables from .env file.")
+            return client
+    variables = _prompt_user()
+    if repo_root and _env_in_gitignore(repo_root):
+        local_import("rich", "jupyter")
+        from rich.prompt import Prompt
+
+        env_file = repo_root / ".env"
+        answer = Prompt.ask(
+            "Do you store the variables in an .env file in the repository root for easy reuse?", choices=["y", "n"]
+        )
+        if env_file.exists():
+            answer = Prompt.ask(f"{env_file} already exists. Overwrite?", choices=["y", "n"])
+        if answer == "y":
+            env_file.write_text(variables.create_env_file())
+            print("Created .env file in repository root.")
+
+    return variables.get_client()
+
+
+@dataclass
+class _EnvironmentVariables:
+    CDF_CLUSTER: str
+    CDF_PROJECT: str
+    LOGIN_FLOW: _LOGIN_FLOW = "infer"
+    IDP_CLIENT_ID: str | None = None
+    IDP_CLIENT_SECRET: str | None = None
+    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
+
+    def __post_init__(self):
+        if self.LOGIN_FLOW.lower() not in _VALID_LOGIN_FLOWS:
+            raise ValueError(f"LOGIN_FLOW must be one of {_VALID_LOGIN_FLOWS}")
+
+    @property
+    def cdf_url(self) -> str:
+        return self.CDF_URL or f"https://{self.CDF_CLUSTER}.cognitedata.com"
+
+    @property
+    def idp_token_url(self) -> str:
+        if self.IDP_TOKEN_URL:
+            return self.IDP_TOKEN_URL
+        if not self.IDP_TENANT_ID:
+            raise KeyError("IDP_TENANT_ID or IDP_TOKEN_URL must be set in the environment.")
+        return f"https://login.microsoftonline.com/{self.IDP_TENANT_ID}/oauth2/v2.0/token"
+
+    @property
+    def idp_audience(self) -> str:
+        return self.IDP_AUDIENCE or f"https://{self.CDF_CLUSTER}.cognitedata.com"
+
+    @property
+    def idp_scopes(self) -> list[str]:
+        if self.IDP_SCOPES:
+            return self.IDP_SCOPES.split()
+        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 not self.IDP_TENANT_ID:
+            raise KeyError("IDP_TENANT_ID or IDP_AUTHORITY_URL must be set in the environment.")
+        return f"https://login.microsoftonline.com/{self.IDP_TENANT_ID}"
+
+    @classmethod
+    def create_from_environ(cls) -> "_EnvironmentVariables":
+        if "CDF_CLUSTER" not in os.environ or "CDF_PROJECT" not in os.environ:
+            raise KeyError("CDF_CLUSTER and CDF_PROJECT must be set in the environment.", "CDF_CLUSTER", "CDF_PROJECT")
+
+        return cls(
+            CDF_CLUSTER=os.environ["CDF_CLUSTER"],
+            CDF_PROJECT=os.environ["CDF_PROJECT"],
+            LOGIN_FLOW=os.environ.get("LOGIN_FLOW", "infer"),  # type: ignore[arg-type]
+            IDP_CLIENT_ID=os.environ.get("IDP_CLIENT_ID"),
+            IDP_CLIENT_SECRET=os.environ.get("IDP_CLIENT_SECRET"),
+            TOKEN=os.environ.get("TOKEN"),
+            CDF_URL=os.environ.get("CDF_URL"),
+            IDP_TOKEN_URL=os.environ.get("IDP_TOKEN_URL"),
+            IDP_TENANT_ID=os.environ.get("IDP_TENANT_ID"),
+            IDP_AUDIENCE=os.environ.get("IDP_AUDIENCE"),
+            IDP_SCOPES=os.environ.get("IDP_SCOPES"),
+            IDP_AUTHORITY_URL=os.environ.get("IDP_AUTHORITY_URL"),
+        )
+
+    def get_credentials(self) -> CredentialProvider:
+        method_by_flow = {
+            "client_credentials": self.get_oauth_client_credentials,
+            "interactive": self.get_oauth_interactive,
+            "token": self.get_token,
+        }
+        if self.LOGIN_FLOW in method_by_flow:
+            return method_by_flow[self.LOGIN_FLOW]()
+        key_options: list[tuple[str, ...]] = []
+        for method in method_by_flow.values():
+            try:
+                return method()
+            except KeyError as e:
+                key_options += e.args[1:]
+        raise KeyError(
+            f"LOGIN_FLOW={self.LOGIN_FLOW} requires one of the following environment set variables to be set.",
+            *key_options,
+        )
+
+    def get_oauth_client_credentials(self) -> OAuthClientCredentials:
+        if not self.IDP_CLIENT_ID or not self.IDP_CLIENT_SECRET:
+            raise KeyError(
+                "IDP_CLIENT_ID and IDP_CLIENT_SECRET must be set in the environment.",
+                "IDP_CLIENT_ID",
+                "IDP_CLIENT_SECRET",
+            )
+        return OAuthClientCredentials(
+            client_id=self.IDP_CLIENT_ID,
+            client_secret=self.IDP_CLIENT_SECRET,
+            token_url=self.idp_token_url,
+            audience=self.idp_audience,
+            scopes=self.idp_scopes,
+        )
+
+    def get_oauth_interactive(self) -> OAuthInteractive:
+        if not self.IDP_CLIENT_ID:
+            raise KeyError("IDP_CLIENT_ID must be set in the environment.", "IDP_CLIENT_ID")
+        return OAuthInteractive(
+            client_id=self.IDP_CLIENT_ID,
+            authority_url=self.idp_authority_url,
+            redirect_port=53_000,
+            scopes=self.idp_scopes,
+        )
+
+    def get_token(self) -> Token:
+        if not self.TOKEN:
+            raise KeyError("TOKEN must be set in the environment", "TOKEN")
+        return Token(self.TOKEN)
+
+    def get_client(self) -> CogniteClient:
+        return CogniteClient.default(
+            self.CDF_PROJECT, self.CDF_CLUSTER, credentials=self.get_credentials(), client_name=_CLIENT_NAME
+        )
+
+    def create_env_file(self) -> str:
+        lines: list[str] = []
+        first_optional = True
+        for field in fields(self):
+            is_optional = hasattr(self, field.name.lower())
+            if is_optional and first_optional:
+                lines.append(
+                    "# The below variables are the defaults, they are automatically " "constructed unless they are set."
+                )
+                first_optional = False
+            name = field.name.lower() if is_optional else field.name
+            value = getattr(self, name)
+            if value is not None:
+                if isinstance(value, list):
+                    value = " ".join(value)
+                lines.append(f"{field.name}={value}")
+        return "\n".join(lines)
+
+
+def _from_dotenv(evn_file: Path) -> _EnvironmentVariables:
+    if not evn_file.exists():
+        raise FileNotFoundError(f"{evn_file} does not exist.")
+    content = evn_file.read_text()
+    valid_variables = {f.name for f in fields(_EnvironmentVariables)}
+    variables: dict[str, str] = {}
+    for line in content.splitlines():
+        if line.startswith("#") or not line:
+            continue
+        key, value = line.split("=", 1)
+        if key in valid_variables:
+            variables[key] = value
+    return _EnvironmentVariables(**variables)  # type: ignore[arg-type]
+
+
+def _prompt_user() -> _EnvironmentVariables:
+    local_import("rich", "jupyter")
+    from rich.prompt import Prompt
+
+    try:
+        variables = _EnvironmentVariables.create_from_environ()
+        continue_ = Prompt.ask(
+            f"Use environment variables for CDF Cluster '{variables.CDF_CLUSTER}' "
+            f"and Project '{variables.CDF_PROJECT}'? [y/n]",
+            choices=["y", "n"],
+            default="y",
+        )
+        if continue_ == "n":
+            variables = _prompt_cluster_and_project()
+    except KeyError:
+        variables = _prompt_cluster_and_project()
+
+    login_flow = Prompt.ask("Login flow", choices=[f for f in _VALID_LOGIN_FLOWS if f != "infer"])
+    variables.LOGIN_FLOW = login_flow  # type: ignore[assignment]
+    if login_flow == "token":
+        token = Prompt.ask("Enter token")
+        variables.TOKEN = token
+        return variables
+
+    variables.IDP_CLIENT_ID = Prompt.ask("Enter IDP Client ID")
+    if login_flow == "client_credentials":
+        variables.IDP_CLIENT_SECRET = Prompt.ask("Enter IDP Client Secret", password=True)
+        tenant_id = Prompt.ask("Enter IDP_TENANT_ID (leave empty to enter IDP_TOKEN_URL instead)")
+        if tenant_id:
+            variables.IDP_TENANT_ID = tenant_id
+        else:
+            token_url = Prompt.ask("Enter IDP_TOKEN_URL")
+            variables.IDP_TOKEN_URL = token_url
+        optional = ["IDP_AUDIENCE", "IDP_SCOPES"]
+    else:
+        optional = ["IDP_TENANT_ID", "IDP_SCOPES"]
+
+    defaults = "".join(f"\n - {name}: {getattr(variables, name.lower())}" for name in optional)
+    use_defaults = Prompt.ask(
+        f"Use default values for the following variables?{defaults}", choices=["y", "n"], default="y"
+    )
+    if use_defaults:
+        return variables
+    for name in optional:
+        value = Prompt.ask(f"Enter {name}")
+        setattr(variables, name, value)
+    return variables
+
+
+def _prompt_cluster_and_project() -> _EnvironmentVariables:
+    from rich.prompt import Prompt
+
+    cluster = Prompt.ask("Enter CDF Cluster (example 'greenfield', 'bluefield', 'westeurope-1)")
+    project = Prompt.ask("Enter CDF Project")
+    return _EnvironmentVariables(cluster, project)
+
+
+def _is_notebook() -> bool:
+    try:
+        shell = get_ipython().__class__.__name__  # type: ignore[name-defined]
+        if shell == "ZMQInteractiveShell":
+            return True  # Jupyter notebook or qtconsole
+        elif shell == "TerminalInteractiveShell":
+            return False  # Terminal running IPython
+        else:
+            return False  # Other type (?)
+    except NameError:
+        return False  # Probably standard Python interpreter
+
+
+def _repo_root() -> Path | None:
+    with suppress(Exception):
+        result = subprocess.run("git rev-parse --show-toplevel".split(), stdout=subprocess.PIPE)
+        return Path(result.stdout.decode().strip())
+    return None
+
+
+def _env_in_gitignore(repo_root: Path) -> bool:
+    ignore_file = repo_root / ".gitignore"
+    if not ignore_file.exists():
+        return False
+    else:
+        ignored = {line.strip() for line in ignore_file.read_text().splitlines()}
+        return ".env" in ignored or "*.env" in ignored
+
+
+if __name__ == "__main__":
+    c = _prompt_user().get_client()
+    print(c.iam.token.inspect())