divbase-cli 0.1.0a1__py3-none-any.whl

divbase_cli/user_auth.py

@@ -0,0 +1,380 @@
+"""
+Manage user authentication with the DivBase server.
+
+This includes login/logout and the getting, storing, using, and refreshing of access + refresh JWTs and Personal Access Tokens (PATs).
+
+User JWTs are stored in the device's OS keyring. They fallback to a local file with 0600 permissions if not possible.
+PATs provided via environment variable
+"""
+
+import contextlib
+import json
+import logging
+import os
+import time
+import warnings
+from dataclasses import dataclass
+from json import JSONDecodeError
+from pathlib import Path
+
+import httpx
+import keyring
+import stamina
+import yaml
+from keyring.errors import KeyringError, NoKeyringError, PasswordDeleteError
+from pydantic import SecretStr
+
+from divbase_cli import __version__ as cli_version
+from divbase_cli.cli_config import cli_settings
+from divbase_cli.cli_exceptions import AuthenticationError, DivBaseAPIConnectionError, DivBaseAPIError
+from divbase_cli.retries import retry_only_on_retryable_divbase_api_errors
+from divbase_cli.user_config import load_user_config
+from divbase_lib.api_schemas.auth import LogoutRequest
+from divbase_lib.divbase_constants import CLI_VERSION_HEADER_KEY
+
+LOGIN_AGAIN_MESSAGE = "Your session has expired. Please log in again with 'divbase-cli auth login [EMAIL]'."
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TokenData:
+    """Class to hold user JWT data"""
+
+    access_token: SecretStr
+    refresh_token: SecretStr
+    access_token_expires_at: int
+    refresh_token_expires_at: int
+
+    def dump_tokens(self, output_path: Path = cli_settings.TOKENS_PATH) -> None:
+        """Dump the user token data to the OS keyring. If fails, fall back to a local file."""
+        token_dict = {
+            "access_token": self.access_token.get_secret_value(),
+            "refresh_token": self.refresh_token.get_secret_value(),
+            "access_token_expires_at": self.access_token_expires_at,
+            "refresh_token_expires_at": self.refresh_token_expires_at,
+        }
+        try:
+            keyring.set_password(
+                service_name=cli_settings.KEYRING_SERVICE,
+                username=cli_settings.KEYRING_USERNAME,
+                password=json.dumps(token_dict),
+            )
+            output_path.unlink(missing_ok=True)
+            logger.debug("JWTs stored in device keyring successfully.")
+            return
+        except KeyringError as e:
+            logger.debug(f"Keyring JWT storage failed with error: {e}\n falling back to file storage.")
+
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        # Create file with 0600 permissions (user read/write only).
+        # Windows doesn't support 0600 permissions, but Windows can use keyring, so should never reach this fallback.
+        # Even if a Windows OS can't use keyring the fallback will still work, the 0600 mode will just be ignored.
+        fd = os.open(path=output_path, flags=os.O_WRONLY | os.O_CREAT | os.O_TRUNC, mode=0o600)
+        with os.fdopen(fd, "w") as file:
+            yaml.safe_dump(token_dict, file, sort_keys=False)
+
+    def is_access_token_expired(self) -> bool:
+        """Check if the access token is expired"""
+        return time.time() >= (self.access_token_expires_at - 5)  # 5 second buffer
+
+    def is_refresh_token_expired(self) -> bool:
+        """Check if the refresh token is expired"""
+        return time.time() >= (self.refresh_token_expires_at - 300)  # 5 minute buffer
+
+
+def _delete_stored_jwts(token_path: Path) -> None:
+    """Attempt to delete user JWTs from both the keyring and the fallback file."""
+    with contextlib.suppress(NoKeyringError, PasswordDeleteError):
+        keyring.delete_password(service_name=cli_settings.KEYRING_SERVICE, username=cli_settings.KEYRING_USERNAME)
+    token_path.unlink(missing_ok=True)
+
+
+def check_existing_session(divbase_url: str, config) -> int | None:
+    """
+    Check if a user is already logged in to DivBase.
+    Used to prevent unnecessary multiple logins.
+
+    Returns the refresh token expiry timestamp if logged in (POSIX time), else None.
+    """
+    if not config.logged_in_url or config.logged_in_url != divbase_url:
+        return None
+
+    token_data = load_user_tokens()
+    if not token_data or token_data.is_refresh_token_expired():
+        return None
+
+    return token_data.refresh_token_expires_at
+
+
+def _handle_divbase_api_error(response: httpx.Response, http_method: str, url: str) -> None:
+    """Handles custom display of a HTTP error response returned by DivBase API."""
+    try:
+        response_body = response.json()
+        error_details = response_body.get("detail", "No error message provided.")
+        error_type = response_body.get("type", "unknown")
+    except (JSONDecodeError, ValueError):
+        # most likely situation for this would be if the reverse proxy returns an error, not the server itself.
+        error_details = response.text
+        error_type = "unexpected_server_error"
+
+    raise DivBaseAPIError(
+        error_details=error_details,
+        status_code=response.status_code,
+        error_type=error_type,
+        http_method=http_method,
+        url=url,
+    ) from None
+
+
+@stamina.retry(on=retry_only_on_retryable_divbase_api_errors, attempts=3)
+def login_to_divbase(email: str, password: SecretStr, divbase_url: str) -> None:
+    """Log in to the DivBase server and return user tokens."""
+    login_url = f"{divbase_url}/v1/auth/login"
+    try:
+        response = httpx.post(
+            url=login_url,
+            data={
+                "grant_type": "password",
+                "username": email,  # OAuth2 uses 'username', not 'email'
+                "password": password.get_secret_value(),
+            },
+            headers={
+                "Content-Type": "application/x-www-form-urlencoded",
+                CLI_VERSION_HEADER_KEY: cli_version,
+            },
+        )
+    except httpx.ConnectError:
+        # We don't raise the full error as it contains the password in the stack trace.
+        # a user could unknowingly dump this into e.g. a bug report/GitHub issue.
+        raise DivBaseAPIConnectionError() from None
+
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError:
+        if response.status_code == 401:
+            error_message = response.json().get("detail", "Invalid email or password.")
+            raise AuthenticationError(error_message) from None
+        _handle_divbase_api_error(response=response, http_method="POST", url=login_url)
+
+    data = response.json()
+    token_data = TokenData(
+        access_token=SecretStr(data["access_token"]),
+        refresh_token=SecretStr(data["refresh_token"]),
+        access_token_expires_at=data["access_token_expires_at"],
+        refresh_token_expires_at=data["refresh_token_expires_at"],
+    )
+    token_data.dump_tokens()
+
+    config = load_user_config()
+    config.set_login_status(url=divbase_url, email=email)
+
+
+def logout_of_divbase(token_path: Path = cli_settings.TOKENS_PATH) -> None:
+    """
+    Log out of the DivBase server.
+    We send the refresh token to DivBase to be revoked server-side.
+    """
+    config = load_user_config()
+
+    # the "if" avoids raising an error on a non logged in user trying to logout
+    if config.logged_in_url:
+        token_data = load_user_tokens(token_path=token_path)
+        if not token_data:
+            _delete_stored_jwts(token_path)
+            config.set_login_status(url=None, email=None)
+            return None
+
+        request_data = LogoutRequest(refresh_token=token_data.refresh_token.get_secret_value())
+        # We don't want logout to fail if server is unreachable or gives an error
+        # JWTs are stateless so local logout is sufficient.
+        try:
+            make_unauthenticated_request(
+                method="POST",
+                divbase_base_url=config.logged_in_url,
+                api_route="v1/auth/logout",
+                json=request_data.model_dump(),
+            )
+        except DivBaseAPIConnectionError as e:
+            warnings.warn(
+                f"Could not connect to DivBase server to log out fully: '{e}'.\n\n"
+                "Continuing local logout.\n"
+                "You do not need to do anything, but if you see this message often, please let us know.",
+                stacklevel=2,
+                category=UserWarning,
+            )
+        except DivBaseAPIError as e:
+            warnings.warn(
+                f"Received an error message from DivBase server when attempting to logout:"
+                f"'{e.error_message=}'. \n\n"
+                "Continuing local logout.\n"
+                "You do not need to do anything. If you see this message a lot, please let us know.",
+                stacklevel=2,
+                category=UserWarning,
+            )
+
+    _delete_stored_jwts(token_path)
+    config.set_login_status(url=None, email=None)
+
+
+def load_user_tokens(token_path: Path = cli_settings.TOKENS_PATH) -> TokenData | None:
+    """
+    Load user tokens from the OS keyring. Fallback for this is a local file with 0600 permissions.
+    Return None if no tokens found or if tokens are malformed/invalid - user logged out.
+    """
+    try:
+        raw = keyring.get_password(service_name=cli_settings.KEYRING_SERVICE, username=cli_settings.KEYRING_USERNAME)
+    except KeyringError as e:
+        raw = None
+        logger.debug(f"Keyring read failed with error: {e}, falling back to file storage.")
+
+    if raw is not None:
+        try:
+            token_dict = json.loads(raw)
+            return TokenData(
+                access_token=SecretStr(token_dict["access_token"]),
+                refresh_token=SecretStr(token_dict["refresh_token"]),
+                access_token_expires_at=token_dict["access_token_expires_at"],
+                refresh_token_expires_at=token_dict["refresh_token_expires_at"],
+            )
+        except (KeyError, json.JSONDecodeError) as e:
+            logger.debug(f"Keyring token data malformed: {e}")
+
+    if not token_path.exists():
+        return None
+
+    with open(token_path, "r") as file:
+        token_dict = yaml.safe_load(file)
+
+    try:
+        token_data = TokenData(
+            access_token=SecretStr(token_dict["access_token"]),
+            refresh_token=SecretStr(token_dict["refresh_token"]),
+            access_token_expires_at=token_dict["access_token_expires_at"],
+            refresh_token_expires_at=token_dict["refresh_token_expires_at"],
+        )
+    except KeyError as e:
+        logger.debug(f"User tokens file at {token_path} appears to be malformed: {e}")
+        return None
+
+    return token_data
+
+
+@stamina.retry(on=retry_only_on_retryable_divbase_api_errors, attempts=3)
+def make_authenticated_request(
+    method: str,
+    divbase_base_url: str,
+    api_route: str,
+    token_path: Path = cli_settings.TOKENS_PATH,
+    **kwargs,
+) -> httpx.Response:
+    """Make an authenticated request to the DivBase server, handles refreshing tokens if needed."""
+    headers = kwargs.get("headers", {})
+    headers[CLI_VERSION_HEADER_KEY] = cli_version
+
+    token_data = load_user_tokens(token_path=token_path)
+    if not token_data:
+        if not cli_settings.DIVBASE_API_PAT:
+            raise AuthenticationError(LOGIN_AGAIN_MESSAGE)
+        logger.info("Using personal access token in request to DivBase API.")
+        headers["Authorization"] = f"Bearer {cli_settings.DIVBASE_API_PAT.get_secret_value()}"
+    else:
+        if token_data.is_access_token_expired():
+            if token_data.is_refresh_token_expired():
+                # Prevents user getting warning about being already logged in when they try to log in again
+                config = load_user_config()
+                config.set_login_status(url=None, email=None)
+                _delete_stored_jwts(token_path)
+                raise AuthenticationError(LOGIN_AGAIN_MESSAGE)
+            else:
+                token_data = _refresh_access_token(token_data=token_data, divbase_base_url=divbase_base_url)
+        headers["Authorization"] = f"Bearer {token_data.access_token.get_secret_value()}"
+
+    kwargs["headers"] = headers
+    url = f"{divbase_base_url}/{api_route.lstrip('/')}"
+
+    try:
+        response = httpx.request(method=method, url=url, **kwargs)
+    except httpx.HTTPError as e:
+        raise DivBaseAPIConnectionError() from e
+
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError:
+        _handle_divbase_api_error(response=response, http_method=method, url=url)
+
+    return response
+
+
+@stamina.retry(on=retry_only_on_retryable_divbase_api_errors, attempts=3)
+def make_unauthenticated_request(
+    method: str,
+    divbase_base_url: str,
+    api_route: str,
+    **kwargs,
+) -> httpx.Response:
+    """
+    Make an unauthenticated request to the DivBase server.
+    Used for those few endpoints that require no authentication, even if the user is logged in.
+    E.g. the announcements endpoint.
+    """
+    url = f"{divbase_base_url}/{api_route.lstrip('/')}"
+
+    headers = kwargs.get("headers", {})
+    headers[CLI_VERSION_HEADER_KEY] = cli_version
+    kwargs["headers"] = headers
+
+    try:
+        response = httpx.request(method=method, url=url, **kwargs)
+    except httpx.HTTPError as e:
+        raise DivBaseAPIConnectionError() from e
+
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError:
+        _handle_divbase_api_error(response=response, http_method=method, url=url)
+
+    return response
+
+
+def _refresh_access_token(token_data: TokenData, divbase_base_url: str) -> TokenData:
+    """
+    Use the refresh token to get a new access token and update the token file.
+
+    Returns the new TokenData object which can be used immediately in a new request.
+    NOTE: We do not need retry logic inside this function as the calling function has it.
+    """
+    refresh_url = f"{divbase_base_url}/v1/auth/refresh"
+    try:
+        response = httpx.post(
+            url=refresh_url,
+            json={"refresh_token": token_data.refresh_token.get_secret_value()},
+            headers={CLI_VERSION_HEADER_KEY: cli_version},
+        )
+    except httpx.HTTPError as e:
+        raise DivBaseAPIConnectionError() from e
+
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError:
+        # Possible if e.g. token revoked on server side.
+        if response.status_code == 401:
+            # Clear logged in status in user config as tokens no longer valid.
+            # Prevents user getting warning about being already logged in when they try to log in again.
+            config = load_user_config()
+            config.set_login_status(url=None, email=None)
+            _delete_stored_jwts(token_path=cli_settings.TOKENS_PATH)
+            raise AuthenticationError(LOGIN_AGAIN_MESSAGE) from None
+
+        _handle_divbase_api_error(response=response, http_method="POST", url=refresh_url)
+
+    data = response.json()
+
+    new_token_data = TokenData(
+        access_token=SecretStr(data["access_token"]),
+        refresh_token=token_data.refresh_token,  # (refresh_token is still a SecretStr)
+        access_token_expires_at=data["expires_at"],
+        refresh_token_expires_at=token_data.refresh_token_expires_at,
+    )
+    new_token_data.dump_tokens()
+    return new_token_data

divbase_cli/user_config.py

@@ -0,0 +1,177 @@
+"""
+Handles the user's configuration file for the divbase-cli package.
+The user configuration is stored in a local file.
+
+The path to the config file is determined by `cli_settings.CONFIG_PATH` and
+is stored in a platform-specific user configuration directory (for example,
+under the user application data directory on Linux, macOS, or Windows).
+"""
+
+import logging
+import warnings
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from divbase_cli.cli_config import cli_settings
+from divbase_cli.cli_exceptions import ProjectNotInConfigError
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ProjectConfig:
+    """Config of a single project."""
+
+    name: str
+    divbase_url: str
+
+
+@dataclass
+class UserConfig:
+    """Overall user configuration"""
+
+    config_path: Path
+    logged_in_url: str | None = None  # URL of the divbase server the user is currently logged in to, if any.
+    logged_in_email: str | None = None  # Email the user is currently logged in with, if any.
+    projects: list[ProjectConfig] = field(default_factory=list)
+    default_project: str | None = None
+    # default_download_dir is a string (rather than Path) for easier loading/saving.
+    default_download_dir: str | None = None
+
+    @property
+    def all_project_names(self) -> list[str]:
+        """List of all project names in the user's config"""
+        return [project.name for project in self.projects]
+
+    def dump_config(self) -> None:
+        """
+        Dump the user configuration to the specified output path
+        Don't include the config_path in the dumped file.
+        """
+        config_dict = {
+            "logged_in_url": self.logged_in_url,
+            "logged_in_email": self.logged_in_email,
+            "projects": [project.__dict__ for project in self.projects],
+            "default_project": self.default_project,
+            "default_download_dir": self.default_download_dir,
+        }
+
+        with open(self.config_path, "w") as file:
+            yaml.safe_dump(config_dict, file, sort_keys=False)
+
+    def add_project(self, name: str, divbase_url: str, is_default: bool) -> ProjectConfig:
+        """
+        Add a new project to the user configuration file.
+        If the configuration file does not exist, it will be created.
+        """
+        new_project = ProjectConfig(name=name, divbase_url=divbase_url)
+
+        if new_project.name in self.all_project_names:
+            warnings.warn(
+                f"""The project: '{new_project.name}' already existed in your configuration file. It will be replaced with your new params""",
+                stacklevel=2,
+            )
+
+            self.projects = [project for project in self.projects if project.name != new_project.name]
+
+        self.projects.append(new_project)
+
+        if is_default:
+            self.default_project = new_project.name
+
+        self.dump_config()
+        return new_project
+
+    def set_default_project(self, name: str) -> str:
+        """
+        Set the default project in the user configuration file.
+        """
+        if name not in self.all_project_names:
+            raise ValueError(
+                f"The project name specified: '{name}', was not found in your config file, please add it first."
+            )
+        self.default_project = name
+        self.dump_config()
+        return self.default_project
+
+    def remove_project(self, name: str) -> str | None:
+        """
+        Remove a project from the user configuration file.
+        Returns the project name if it was removed successfully, otherwise None.
+        """
+        if name not in self.all_project_names:
+            return
+
+        self.projects = [project for project in self.projects if project.name != name]
+
+        if self.default_project == name:
+            self.default_project = None
+
+        self.dump_config()
+
+        return name
+
+    def set_default_download_dir(self, download_dir: str) -> str:
+        """
+        Set the default download directory in the user configuration file.
+        """
+        self.default_download_dir = download_dir
+        self.dump_config()
+        return self.default_download_dir
+
+    def project_info(self, name: str) -> ProjectConfig:
+        """
+        Get the project configuration given the project name.
+        """
+        for project in self.projects:
+            if project.name == name:
+                return project
+        raise ProjectNotInConfigError(config_path=self.config_path, project_name=name)
+
+    def set_login_status(self, url: str | None, email: str | None) -> None:
+        """
+        Used during login/logout to track state (Dumps config after updating)
+        Sets the following fields:
+        1. URL of the DivBase server the user is currently logged in to.
+        2. Email of the user currently logged in.
+        """
+        self.logged_in_url = url
+        self.logged_in_email = email
+        self.dump_config()
+
+
+def load_user_config() -> UserConfig:
+    """Helper function to load the user config file"""
+    try:
+        with open(cli_settings.CONFIG_PATH, "r") as file:
+            config_contents = yaml.safe_load(file)
+    except FileNotFoundError:
+        logger.debug(f"No existing config file found at {cli_settings.CONFIG_PATH}, creating a new one.")
+        create_user_config(config_path=cli_settings.CONFIG_PATH)
+        with open(cli_settings.CONFIG_PATH, "r") as file:
+            config_contents = yaml.safe_load(file)
+
+    projects = [ProjectConfig(**project) for project in config_contents.get("projects", [])]
+
+    return UserConfig(
+        config_path=cli_settings.CONFIG_PATH,
+        logged_in_url=config_contents.get("logged_in_url"),
+        logged_in_email=config_contents.get("logged_in_email"),
+        projects=projects,
+        default_project=config_contents.get("default_project"),
+        default_download_dir=config_contents.get("default_download_dir"),
+    )
+
+
+def create_user_config(config_path: Path) -> None:
+    """Create a user configuration file at the specified path."""
+    if config_path.exists():
+        raise FileExistsError(
+            f"Config file already exists at {config_path}. Stopping to avoid overwriting existing config."
+        )
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    user_config = UserConfig(config_path=config_path, projects=[])
+    user_config.dump_config()

divbase_cli/utils.py

@@ -0,0 +1,28 @@
+"""Collection of utility functions for divbase-cli package that haven't found a better home"""
+
+import csv
+import sys
+
+from rich.table import Table
+
+
+def print_rich_table_as_tsv(table: Table) -> None:
+    """
+    Helper function to print a rich Table as a TSV file to standard output.
+
+    This is useful for CLI commands that want to offer both rich table output
+    for human users as well as TSV output for programmatic parsing.
+
+    NOTE: This function expects all table rows to be of same length (you can have None values in cells).
+    """
+    writer = csv.writer(sys.stdout, delimiter="\t")
+
+    headers = [str(col.header) for col in table.columns]
+    writer.writerow(headers)
+
+    columns_data = [col._cells for col in table.columns]
+
+    num_rows = min(len(col) for col in columns_data)
+    for row_index in range(num_rows):
+        row = [str(columns_data[col_index][row_index]) for col_index in range(len(columns_data))]
+        writer.writerow(row)

divbase_cli-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: divbase-cli
+Version: 0.1.0a1
+Summary: Command Line Interface for Divbase
+Project-URL: Homepage, https://divbase.scilifelab-2-prod.sys.kth.se
+Project-URL: Documentation, https://scilifelabdatacentre.github.io/divbase
+Project-URL: Repository, https://github.com/ScilifelabDataCentre/divbase
+Project-URL: Issues, https://github.com/ScilifelabDataCentre/divbase/issues
+Author-email: SciLifeLab Data Centre <datacentre@scilifelab.se>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Requires-Dist: divbase-lib==0.1.0a1
+Requires-Dist: keyring>=25.7.0
+Requires-Dist: typer==0.24.1
+Description-Content-Type: text/markdown
+
+# divbase-cli
+
+Command Line Interface for Divbase. 
+
+## Installation
+
+```bash
+pipx install divbase-cli
+```
+
+## Usage
+
+```bash
+divbase --help # can also run divbase-cli --help
+```
+
+## Development
+
+This package is developed in the [DivBase repository](https://github.com/ScilifelabDataCentre/divbase) by Scilifelab Data Centre.

divbase_cli-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,28 @@
+divbase_cli/__init__.py,sha256=lmvUfjeqbjbsnD2PLlUjZbqEGZrq6yUD6t2LZsM61ak,24
+divbase_cli/cli_config.py,sha256=-B6sOFq2fCQzGG9FGkOntEpeacy5XzG-9LrBRyzXEtQ,2532
+divbase_cli/cli_exceptions.py,sha256=MeSignmkzTidzlhRDdbUBHkbxD6qOWUYtTRUOfDVz0w,6501
+divbase_cli/config_resolver.py,sha256=2P-1OyyRUg3jWxi2rl_sRnW0DXU1WFXofNRFCU01G_w,3286
+divbase_cli/display_task_history.py,sha256=_DlxOwVRU0hSn1w8yz4xMeFYzSVeATJ6me7_DLwBYe4,8254
+divbase_cli/divbase_cli.py,sha256=JrUvPB925gJHroNXez4uSNehKHKfDCGMLzpyipHkGKY,2358
+divbase_cli/retries.py,sha256=UFv4CHudC1Sb0kRe2HuuCidoCNA9TSXB-mOdrt4uDew,1298
+divbase_cli/user_auth.py,sha256=jdz8ZKrmEVBx-7fJdE9DFIolCRI5WZobsXJ_qYpgXAY,15149
+divbase_cli/user_config.py,sha256=oROFuNZN5MoC01070ufZbVh8lwavFN2bTj6u4oy7MYE,6350
+divbase_cli/utils.py,sha256=-D2x3uIiVDcO3YABrrHhWUszEFzc1kQIeXN69EUWS78,962
+divbase_cli/cli_commands/__init__.py,sha256=K_2r8V1QGpEmxDcD2QOyWlXR4HPoc16yytmZwGkIyLw,166
+divbase_cli/cli_commands/auth_cli.py,sha256=XDp5sRFovrzTLMpFVnsfmtCgZghZrchr_GhY08W6Rd8,3114
+divbase_cli/cli_commands/dimensions_cli.py,sha256=rYhxiviIdU-tfw_Gr8Ly_7pCPbBFaGZ9F8E02Tc_mF4,18913
+divbase_cli/cli_commands/file_cli.py,sha256=gGjeHfa6G9h1T9AwOWgasVdhflZXOeuCOte76HujUAo,25755
+divbase_cli/cli_commands/query_cli.py,sha256=1r3m9g450x1nhR7B9EiBVcmzyi_vJywZ5cDo7qX3U2E,11910
+divbase_cli/cli_commands/shared_args_options.py,sha256=BGOo1tPjrCM3XOB5v3wAeRZJ8d8NvCPruqa_ZVReLPE,585
+divbase_cli/cli_commands/task_history_cli.py,sha256=ePbgRZ3fmQLycyMjAe6X-ZuqsQDsn9y1EgOKdiT1Uj0,4558
+divbase_cli/cli_commands/user_config_cli.py,sha256=WB1iPPuecEdYmUBxnMQYTT1E3LC5FzU62LF4WUp-lJE,5396
+divbase_cli/cli_commands/version_cli.py,sha256=oC3NWjTrkq_axwXKrwlnmfXL0fkMPDGWCZ0ryaJ9Dy0,8818
+divbase_cli/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+divbase_cli/services/announcements.py,sha256=EYXoHaAcZmzNm3ezgLVi81DQFn3qecZVlIuNHvpQq_c,1531
+divbase_cli/services/pre_signed_urls.py,sha256=Tg6d1z01Sk5Id03_AL6e3k-u4gYWdd-ipQwyzaU65Ro,17437
+divbase_cli/services/project_versions.py,sha256=LwDjJCKPGJl1fAv5GSQ7aTOrEfrpzn3IVLwR-b10C9k,3628
+divbase_cli/services/s3_files.py,sha256=0t76BfBX0VKGzn7pQNJAu-S55MWqykJp1X7RSw9phmM,17921
+divbase_cli-0.1.0a1.dist-info/METADATA,sha256=ULzFB-uWahbhyvcb9AgrHgVnrRc2HtA2H3cryDqnze0,1395
+divbase_cli-0.1.0a1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+divbase_cli-0.1.0a1.dist-info/entry_points.txt,sha256=U4l9q6SebrFeGx3m8qA5bM_-Y-5KpTPUdFHhFoVUSU8,61
+divbase_cli-0.1.0a1.dist-info/RECORD,,

divbase_cli-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

divbase_cli-0.1.0a1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+divbase-cli = divbase_cli.divbase_cli:main