divbase-cli 0.1.0.dev2__py3-none-any.whl → 0.1.0.dev3__py3-none-any.whl

divbase_cli/services/s3_files.py

@@ -0,0 +1,355 @@
+"""
+Service layer for DivBase CLI S3 file operations.
+"""
+
+import sys
+from pathlib import Path
+
+import httpx
+import typer
+
+from divbase_cli.cli_exceptions import (
+    FileDoesNotExistInSpecifiedVersionError,
+    FilesAlreadyInProjectError,
+)
+from divbase_cli.services.pre_signed_urls import (
+    DownloadOutcome,
+    FailedUpload,
+    SuccessfulUpload,
+    UploadOutcome,
+    download_multiple_pre_signed_urls,
+    perform_multipart_upload,
+    upload_multiple_singlepart_pre_signed_urls,
+)
+from divbase_cli.services.project_versions import get_version_details_command
+from divbase_cli.user_auth import make_authenticated_request
+from divbase_lib.api_schemas.s3 import (
+    FileChecksumResponse,
+    ListObjectsRequest,
+    ListObjectsResponse,
+    ObjectDetails,
+    ObjectInfoResponse,
+    PreSignedDownloadResponse,
+    PreSignedSinglePartUploadResponse,
+    RestoreObjectsResponse,
+)
+from divbase_lib.divbase_constants import (
+    MAX_S3_API_BATCH_SIZE,
+    QUERY_RESULTS_FILE_PREFIX,
+    S3_MULTIPART_UPLOAD_THRESHOLD,
+)
+from divbase_lib.s3_checksums import (
+    MD5CheckSumFormat,
+    calculate_composite_md5_s3_etag,
+    calculate_md5_checksum,
+    convert_checksum_hex_to_base64,
+)
+
+
+def list_files_command(
+    divbase_base_url: str,
+    project_name: str,
+    prefix_filter: str | None = None,
+    include_results_files: bool = False,
+) -> list[ObjectDetails]:
+    """
+    List all files in a project optionally filtered by a prefix.
+    We page through results if there are more than can be returned in a single API call.
+
+    NOTE: The current implementation is not very efficient as we page through all results before returning any.
+    Keeping simple for now as we don't expect projects to have huge numbers of files.
+    But could be revisted later if performance becomes an issue.
+    """
+    api_route = f"v1/s3/list?project_name={project_name}"
+    initial_request = ListObjectsRequest(
+        prefix=prefix_filter,
+        next_token=None,
+    )
+
+    response = make_authenticated_request(
+        method="POST",
+        divbase_base_url=divbase_base_url,
+        api_route=api_route,
+        json=initial_request.model_dump(),
+    )
+    response_data = ListObjectsResponse(**response.json())
+    all_matches = response_data.objects
+
+    # page through any remaining results
+    while response_data.next_token:
+        next_request = ListObjectsRequest(prefix=prefix_filter, next_token=response_data.next_token)
+        response = make_authenticated_request(
+            method="POST",
+            divbase_base_url=divbase_base_url,
+            api_route=api_route,
+            json=next_request.model_dump(),
+        )
+        next_page_data = ListObjectsResponse(**response.json())
+
+        all_matches.extend(next_page_data.objects)
+        response_data.next_token = next_page_data.next_token
+
+    # To enable us to both search by prefix and optionally hide/include query results files,
+    # we hide DivBase query results/job files now instead of via S3.
+    # so the prefix param can be used for the optional filter the user wants.
+    if not include_results_files:
+        all_matches = [obj for obj in all_matches if not obj.name.startswith(QUERY_RESULTS_FILE_PREFIX)]
+
+    return all_matches
+
+
+def get_file_info_command(divbase_base_url: str, project_name: str, object_name: str) -> ObjectInfoResponse:
+    """Get detailed information about a specific file/object in a project."""
+    response = make_authenticated_request(
+        method="GET",
+        divbase_base_url=divbase_base_url,
+        api_route=f"v1/s3/info?project_name={project_name}&object_name={object_name}",
+    )
+    return ObjectInfoResponse(**response.json())
+
+
+def soft_delete_objects_command(divbase_base_url: str, project_name: str, all_files: list[str]) -> list[str]:
+    """
+    Soft delete objects from the project's bucket.
+    Returns a list of the soft deleted objects
+    """
+    response = make_authenticated_request(
+        method="DELETE",
+        divbase_base_url=divbase_base_url,
+        api_route=f"v1/s3/?project_name={project_name}",
+        json=all_files,
+    )
+    return response.json()
+
+
+def restore_objects_command(divbase_base_url: str, project_name: str, all_files: list[str]) -> RestoreObjectsResponse:
+    """
+    Restore soft_deleted objects in the project's bucket.
+    Returns an object containing a list of the restored objects, and those that were not restored.
+    """
+    response = make_authenticated_request(
+        method="POST",
+        divbase_base_url=divbase_base_url,
+        api_route=f"v1/s3/restore?project_name={project_name}",
+        json=all_files,
+    )
+    return RestoreObjectsResponse(**response.json())
+
+
+def download_files_command(
+    divbase_base_url: str,
+    project_name: str,
+    raw_files_input: list[str],
+    download_dir: Path,
+    verify_checksums: bool,
+    project_version: str | None = None,
+) -> DownloadOutcome:
+    """
+    Download files from the given project's S3 bucket.
+    """
+    if not download_dir.is_dir():
+        raise NotADirectoryError(
+            f"The specified download directory '{download_dir}' is not a directory. Please create it or specify a valid directory before continuing."
+        )
+
+    if project_version is not None:
+        offending_files = [file for file in raw_files_input if ":" in file]
+        if offending_files:
+            print(
+                "[red] ERROR: bad Input: If you provide a global project version (using --project-version) "
+                "you cannot also specify specific versions of individual files to download. \n"
+                "offending files in your input: \n"
+                f"{'\n'.join(offending_files)} \n"
+                "Exiting..."
+            )
+            raise typer.Exit(1)
+
+    if project_version:
+        project_version_details = get_version_details_command(
+            project_name=project_name, divbase_base_url=divbase_base_url, version_name=project_version
+        )
+
+        # check if all files specified exist for download exist at this project version
+        missing_objects = [f for f in raw_files_input if f not in project_version_details.files]
+        if missing_objects:
+            raise FileDoesNotExistInSpecifiedVersionError(
+                project_name=project_name,
+                project_version=project_version,
+                missing_files=missing_objects,
+            )
+        # we validated in CLI command that
+        to_download = {file: project_version_details.files[file] for file in raw_files_input}
+        json_data = [{"name": obj, "version_id": to_download[obj]} for obj in raw_files_input]
+    else:
+        # parse raw file inputs to see if any specific version ids were provided using format:
+        # file_name:version_id (not possible when using project_version)
+        json_data = []
+        for file_input in raw_files_input:
+            if ":" in file_input:
+                name, version_id = file_input.split(sep=":", maxsplit=1)
+                json_data.append({"name": name, "version_id": version_id})
+            else:
+                json_data.append({"name": file_input, "version_id": None})
+
+    successful_downloads, failed_downloads = [], []
+    for i in range(0, len(json_data), MAX_S3_API_BATCH_SIZE):
+        batch_json_data = json_data[i : i + MAX_S3_API_BATCH_SIZE]
+        response = make_authenticated_request(
+            method="POST",
+            divbase_base_url=divbase_base_url,
+            api_route=f"v1/s3/download?project_name={project_name}",
+            json=batch_json_data,
+        )
+        pre_signed_urls = [PreSignedDownloadResponse(**item) for item in response.json()]
+
+        batch_download_success, batch_download_failed = download_multiple_pre_signed_urls(
+            pre_signed_urls=pre_signed_urls,
+            download_dir=download_dir,
+            verify_checksums=verify_checksums,
+        )
+        successful_downloads.extend(batch_download_success)
+        failed_downloads.extend(batch_download_failed)
+
+    return DownloadOutcome(successful=successful_downloads, failed=failed_downloads)
+
+
+def stream_file_command(
+    divbase_base_url: str, project_name: str, file_name: str, version_id: str | None = None
+) -> None:
+    """Stream the contents of a single file in the project's S3 bucket to stdout."""
+    json_data = [{"name": file_name, "version_id": version_id}]
+    response = make_authenticated_request(
+        method="POST",
+        divbase_base_url=divbase_base_url,
+        api_route=f"v1/s3/download?project_name={project_name}",
+        json=json_data,
+    )
+    pre_signed_url = PreSignedDownloadResponse(**response.json()[0]).pre_signed_url
+
+    try:
+        with httpx.stream("GET", pre_signed_url, timeout=None) as response:
+            response.raise_for_status()
+            for chunk in response.iter_bytes():
+                sys.stdout.buffer.write(chunk)
+    except BrokenPipeError:
+        # This happens when the user pipes to a command that closes early
+        # (e.g., `[divbase-cli stream command] | head -n 10`).
+        pass
+
+
+def upload_files_command(
+    project_name: str, divbase_base_url: str, all_files: list[Path], safe_mode: bool
+) -> UploadOutcome:
+    """
+    Upload files to the project's S3 bucket.
+    Returns an UploadOutcome object containing details of which files were successfully uploaded and which failed.
+
+    - Safe mode:
+        1. checks if any of the files that are to be uploaded already exist in the bucket (by comparing checksums)
+        2. Adds checksum to upload request to allow server to verify upload.
+    """
+    if safe_mode:
+        # mapping of file name to hex-encoded checksum
+        file_checksums_hex = compare_local_to_s3_checksums(
+            project_name=project_name,
+            divbase_base_url=divbase_base_url,
+            all_files=all_files,
+        )
+
+    files_below_threshold, files_above_threshold = [], []
+    for file in all_files:
+        if file.stat().st_size <= S3_MULTIPART_UPLOAD_THRESHOLD:
+            files_below_threshold.append(file)
+        else:
+            files_above_threshold.append(file)
+
+    all_successful_uploads: list[SuccessfulUpload] = []
+    all_failed_uploads: list[FailedUpload] = []
+
+    # P1. Process all single-part uploads in batches of max size allowed by divbase server.
+    for i in range(0, len(files_below_threshold), MAX_S3_API_BATCH_SIZE):
+        batch_files = files_below_threshold[i : i + MAX_S3_API_BATCH_SIZE]
+        batch_of_objects_to_upload = []
+        for file in batch_files:
+            upload_object = {
+                "name": file.name,
+                "content_length": file.stat().st_size,
+            }
+            if safe_mode:
+                hex_checksum = file_checksums_hex[file.name]
+                upload_object["md5_hash"] = convert_checksum_hex_to_base64(hex_checksum)
+            batch_of_objects_to_upload.append(upload_object)
+
+        response = make_authenticated_request(
+            method="POST",
+            divbase_base_url=divbase_base_url,
+            api_route=f"v1/s3/upload/single-part?project_name={project_name}",
+            json=batch_of_objects_to_upload,
+        )
+        pre_signed_urls = [PreSignedSinglePartUploadResponse(**item) for item in response.json()]
+        single_part_upload_outcome = upload_multiple_singlepart_pre_signed_urls(
+            pre_signed_urls=pre_signed_urls, all_files=batch_files
+        )
+        all_successful_uploads.extend(single_part_upload_outcome.successful)
+        all_failed_uploads.extend(single_part_upload_outcome.failed)
+
+    # P2. process all multipart uploads.
+    for file_path in files_above_threshold:
+        outcome = perform_multipart_upload(
+            project_name=project_name,
+            divbase_base_url=divbase_base_url,
+            file_path=file_path,
+            safe_mode=safe_mode,
+        )
+
+        if isinstance(outcome, SuccessfulUpload):
+            all_successful_uploads.append(outcome)
+        else:
+            all_failed_uploads.append(outcome)
+
+    return UploadOutcome(successful=all_successful_uploads, failed=all_failed_uploads)
+
+
+def compare_local_to_s3_checksums(project_name: str, divbase_base_url: str, all_files: list[Path]) -> dict[str, str]:
+    """
+    Calculate the checksums of all local files (to be uploaded) and compares them to the checksums of all files in the project's S3 bucket.
+    Raises error if any files already exist in the project's S3 bucket with identical checksums.
+
+    Here, we are catching an attempt to upload an identical file twice.
+    This is only ran if 'safe_mode' is enabled for uploads.
+    We do not catch an attempt to upload an identical object if it has a different name.
+
+    Return a dict of file names with hex-encoded checksums for all files to be uploaded (including those that are not in S3).
+    These checksums are later used when uploading to the server so the server can verify the upload.
+    """
+    already_uploaded_files: dict[Path, str] = {}  # files that already exist in S3 with identical checksum
+    local_checksums: dict[str, str] = {}  # all local files checksums
+
+    # have to batch requests if above max number allowed by divbase server
+    for i in range(0, len(all_files), MAX_S3_API_BATCH_SIZE):
+        batch_files = all_files[i : i + MAX_S3_API_BATCH_SIZE]
+        batch_files_names = [file.name for file in batch_files]
+
+        response = make_authenticated_request(
+            method="POST",
+            divbase_base_url=divbase_base_url,
+            api_route=f"v1/s3/checksums?project_name={project_name}",
+            json=batch_files_names,
+        )
+        server_checksum_responses = [FileChecksumResponse(**item) for item in response.json()]
+        server_checksums = {item.object_name: item.md5_checksum for item in server_checksum_responses}
+
+        for file in batch_files:
+            if file.stat().st_size > S3_MULTIPART_UPLOAD_THRESHOLD:
+                calculated_checksum = calculate_composite_md5_s3_etag(file_path=file)
+            else:
+                calculated_checksum = calculate_md5_checksum(file_path=file, output_format=MD5CheckSumFormat.HEX)
+
+            local_checksums[file.name] = calculated_checksum
+            if server_checksums.get(file.name) and server_checksums[file.name] == calculated_checksum:
+                already_uploaded_files[file] = calculated_checksum
+
+    if already_uploaded_files:
+        raise FilesAlreadyInProjectError(existing_files=already_uploaded_files, project_name=project_name)
+
+    return local_checksums

divbase_cli/user_auth.py

@@ -10,11 +10,13 @@ from dataclasses import dataclass
 from pathlib import Path
 
 import httpx
+import stamina
 import yaml
 from pydantic import SecretStr
 
 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
 
@@ -76,7 +78,8 @@ def check_existing_session(divbase_url: str, config) -> int | None:
     return token_data.refresh_token_expires_at
 
 
-def login_to_divbase(email: str, password: SecretStr, divbase_url: str, config_path: Path) -> 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.
     """
@@ -110,18 +113,16 @@ def login_to_divbase(email: str, password: SecretStr, divbase_url: str, config_p
     )
     token_data.dump_tokens()
 
-    config = load_user_config(config_path)
+    config = load_user_config()
     config.set_login_status(url=divbase_url, email=email)
 
 
-def logout_of_divbase(
-    token_path: Path = cli_settings.TOKENS_PATH, config_path: Path = cli_settings.CONFIG_PATH
-) -> None:
+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(config_path)
+    config = load_user_config()
 
     # the "if" avoids raising an error on a non logged in user trying to logout
     if config.logged_in_url:
@@ -182,6 +183,7 @@ def load_user_tokens(token_path: Path = cli_settings.TOKENS_PATH) -> TokenData:
     )
 
 
+@stamina.retry(on=retry_only_on_retryable_divbase_api_errors, attempts=3)
 def make_authenticated_request(
     method: str,
     divbase_base_url: str,
@@ -235,13 +237,15 @@ def _refresh_access_token(token_data: TokenData, divbase_base_url: str) -> Token
     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.
     """
-    response = httpx.post(
-        f"{divbase_base_url}/v1/auth/refresh",
-        json={
-            "refresh_token": token_data.refresh_token.get_secret_value(),
-        },
-    )
+    try:
+        response = httpx.post(
+            url=f"{divbase_base_url}/v1/auth/refresh",
+            json={"refresh_token": token_data.refresh_token.get_secret_value()},
+        )
+    except httpx.HTTPError as e:
+        raise DivBaseAPIConnectionError() from e
 
     # Possible if e.g. token revoked on server side.
     if response.status_code == 401:
@@ -251,7 +255,16 @@ def _refresh_access_token(token_data: TokenData, divbase_base_url: str) -> Token
         config.set_login_status(url=None, email=None)
         raise AuthenticationError(LOGIN_AGAIN_MESSAGE)
 
-    response.raise_for_status()
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError as e:
+        raise DivBaseAPIError(
+            error_details=response.json().get("detail", "No error details provided"),
+            status_code=response.status_code,
+            error_type=response.json().get("type", "unknown"),
+            http_method="POST",
+            url=f"{divbase_base_url}/v1/auth/refresh",
+        ) from e
     data = response.json()
 
     new_token_data = TokenData(

divbase_cli/user_config.py

@@ -1,9 +1,13 @@
 """
 Handles the user's configuration file for the divbase-cli package.
-User configuration is stored in a local file.
-By default the config will be stored at: "~/.config/divbase/config.yaml"
+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
@@ -11,7 +15,9 @@ from pathlib import Path
 import yaml
 
 from divbase_cli.cli_config import cli_settings
-from divbase_cli.cli_exceptions import ConfigFileNotFoundError, ProjectNotInConfigError
+from divbase_cli.cli_exceptions import ProjectNotInConfigError
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -136,18 +142,21 @@ class UserConfig:
         self.dump_config()
 
 
-def load_user_config(config_path: Path = cli_settings.CONFIG_PATH) -> UserConfig:
+def load_user_config() -> UserConfig:
     """Helper function to load the user config file"""
     try:
-        with open(config_path, "r") as file:
+        with open(cli_settings.CONFIG_PATH, "r") as file:
             config_contents = yaml.safe_load(file)
     except FileNotFoundError:
-        raise ConfigFileNotFoundError from None
+        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=config_path,
+        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,
@@ -159,8 +168,10 @@ def load_user_config(config_path: Path = cli_settings.CONFIG_PATH) -> UserConfig
 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}.")
-    config_path.parent.mkdir(parents=False, exist_ok=True)
+        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,47 @@
+"""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 format_file_size(size_bytes: int | float | None) -> str:
+    """
+    Converts a file size in bytes to a human-readable format.
+
+    Uses powers of 1000 so KB, MB, GB, TB and not 1024 KiB, MiB, GiB, TiB.
+    """
+    if size_bytes is None:
+        return "N/A"
+    if size_bytes == 0:
+        return "0 B"
+    power = 1000
+    n = 0
+    power_labels = {0: "", 1: "K", 2: "M", 3: "G", 4: "T"}
+    while size_bytes >= power and n < len(power_labels) - 1:
+        size_bytes /= power
+        n += 1
+    return f"{size_bytes:.2f} {power_labels[n]}B"
+
+
+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.0.dev2.dist-info → divbase_cli-0.1.0.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: divbase-cli
-Version: 0.1.0.dev2
+Version: 0.1.0.dev3
 Summary: Command Line Interface for Divbase
 Project-URL: Homepage, https://divbase.scilifelab.se
 Project-URL: Documentation, https://scilifelabdatacentre.github.io/divbase
@@ -18,8 +18,9 @@ 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.0.dev2
-Requires-Dist: httpx<2,>=0.28.1
+Requires-Dist: divbase-lib==0.1.0.dev3
+Requires-Dist: httpx<1,>=0.28.1
+Requires-Dist: stamina>=25.2.0
 Requires-Dist: typer<1,>=0.21.1
 Description-Content-Type: text/markdown
 

divbase_cli-0.1.0.dev3.dist-info/RECORD

@@ -0,0 +1,27 @@
+divbase_cli/__init__.py,sha256=jQHG8OW4TlfIzPKW4IrX9q58EfEf9pDfm2YgO0ydKaA,27
+divbase_cli/cli_config.py,sha256=0h40kFmWK03-Gi7qU9S_GtpGT5XpsZVHSxLH127Elkk,1810
+divbase_cli/cli_exceptions.py,sha256=MeSignmkzTidzlhRDdbUBHkbxD6qOWUYtTRUOfDVz0w,6501
+divbase_cli/config_resolver.py,sha256=olnt5U4HtlYKcTS4zGDV1KyIgLcrOxyY4q87T7lx65U,3004
+divbase_cli/display_task_history.py,sha256=k9V4YeWsqv6HTZn2Ns6sl4vngiWANFiPPj7E5kE0_K4,7628
+divbase_cli/divbase_cli.py,sha256=JrUvPB925gJHroNXez4uSNehKHKfDCGMLzpyipHkGKY,2358
+divbase_cli/retries.py,sha256=UFv4CHudC1Sb0kRe2HuuCidoCNA9TSXB-mOdrt4uDew,1298
+divbase_cli/user_auth.py,sha256=0CbwED1xL7TgVdA58_x6Vq4Tpvaq8PwE3Pw5LwrVy6I,10308
+divbase_cli/user_config.py,sha256=oROFuNZN5MoC01070ufZbVh8lwavFN2bTj6u4oy7MYE,6350
+divbase_cli/utils.py,sha256=H31UK32jeg21wJlKpFsPry6D1XJlpzOuDgOZIDanKsI,1512
+divbase_cli/cli_commands/__init__.py,sha256=K_2r8V1QGpEmxDcD2QOyWlXR4HPoc16yytmZwGkIyLw,166
+divbase_cli/cli_commands/auth_cli.py,sha256=IbuQGFvljvn8uezGFu8q0H9v62IKKzFsdpTwmehoriU,2871
+divbase_cli/cli_commands/dimensions_cli.py,sha256=zSWTupp0fx-AGSobKlkSpNNGlv-o62EAe8yarVbmF0k,4875
+divbase_cli/cli_commands/file_cli.py,sha256=6DIPilDtEQBYIoVy6wkjWOgSDh12cuqHqL5duHtVB7U,18772
+divbase_cli/cli_commands/query_cli.py,sha256=Hty7BzrBTV0e8P0OCenlxJm-S7EO9LOscjFhOETjPvw,5551
+divbase_cli/cli_commands/shared_args_options.py,sha256=NNFUp0wRPMUpdtmvgmF_e3loKWbUlSL5uuPCSpJMylk,548
+divbase_cli/cli_commands/task_history_cli.py,sha256=fBKyPzzsOBDf9DC-Uice00wy_q-QqMid0pBXcErrO7A,4453
+divbase_cli/cli_commands/user_config_cli.py,sha256=WB1iPPuecEdYmUBxnMQYTT1E3LC5FzU62LF4WUp-lJE,5396
+divbase_cli/cli_commands/version_cli.py,sha256=UKT-t2MvFwFNRPgSldxTsFvwPiS8EM5vSerXRCmibsw,6073
+divbase_cli/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+divbase_cli/services/pre_signed_urls.py,sha256=7evDg2aeWN609VJnlcGCqZdk7M2yg_6VKUsCYIAt0ME,16479
+divbase_cli/services/project_versions.py,sha256=RzuexQ7UmcoeZTnV7LSU9AehHnDpVVqxKJ5G8t_njBM,2865
+divbase_cli/services/s3_files.py,sha256=lURk4m7MyPBzDz0puQO72i8djC25WmIWzVf1oY9nJwA,14470
+divbase_cli-0.1.0.dev3.dist-info/METADATA,sha256=whCWvjLzGCtDuTPOqE2pIsMyo9LCXPGcEWT8LZO8VYk,1421
+divbase_cli-0.1.0.dev3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+divbase_cli-0.1.0.dev3.dist-info/entry_points.txt,sha256=vaRJvvGmfesTaMMCCy3kcBhYzf51wZoEPuLqas5LDMg,100
+divbase_cli-0.1.0.dev3.dist-info/RECORD,,