kleinkram 0.48.0.dev20250723090520__py3-none-any.whl → 0.58.0.dev20260110152317__py3-none-any.whl

kleinkram/api/client.py

@@ -39,15 +39,11 @@ ListData = Sequence[Data]
 QueryParams = Mapping[str, Union[Data, NestedData, ListData]]
 
 
-def _convert_nested_data_query_params_values(
-    key: str, values: NestedData
-) -> List[Tuple[str, Data]]:
+def _convert_nested_data_query_params_values(key: str, values: NestedData) -> List[Tuple[str, Data]]:
     return [(f"{key}[{k}]", v) for k, v in values.items()]
 
 
-def _convert_list_data_query_params_values(
-    key: str, values: ListData
-) -> List[Tuple[str, Data]]:
+def _convert_list_data_query_params_values(key: str, values: ListData) -> List[Tuple[str, Data]]:
     return [(key, value) for value in values]
 
 
@@ -71,9 +67,7 @@ class AuthenticatedClient(httpx.Client):
     _config: Config
     _config_lock: Lock
 
-    def __init__(
-        self, config_path: Path = CONFIG_PATH, *args: Any, **kwargs: Any
-    ) -> None:
+    def __init__(self, config_path: Path = CONFIG_PATH, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
         self._config = get_config(path=config_path)
@@ -116,9 +110,7 @@ class AuthenticatedClient(httpx.Client):
 
         self.cookies.set(COOKIE_AUTH_TOKEN, new_access_token)
 
-    def _send_request_with_kleinkram_headers(
-        self, *args: Any, **kwargs: Any
-    ) -> httpx.Response:
+    def _send_request_with_kleinkram_headers(self, *args: Any, **kwargs: Any) -> httpx.Response:
         # add the cli version to the headers
         headers = kwargs.get("headers") or {}
         headers.setdefault(CLI_VERSION_HEADER, __version__)
@@ -150,9 +142,7 @@ class AuthenticatedClient(httpx.Client):
         logger.info(f"requesting {method} {full_url}")
 
         httpx_params = _convert_query_params_to_httpx_format(params or {})
-        response = self._send_request_with_kleinkram_headers(
-            method, full_url, params=httpx_params, *args, **kwargs
-        )
+        response = self._send_request_with_kleinkram_headers(method, full_url, params=httpx_params, *args, **kwargs)
 
         logger.info(f"got response {response}")
 
@@ -170,9 +160,7 @@ class AuthenticatedClient(httpx.Client):
                 raise NotAuthenticated
 
             logger.info(f"retrying request {method} {full_url}")
-            response = self._send_request_with_kleinkram_headers(
-                method, full_url, params=httpx_params, *args, **kwargs
-            )
+            response = self._send_request_with_kleinkram_headers(method, full_url, params=httpx_params, *args, **kwargs)
             logger.info(f"got response {response}")
             return response
         else:

kleinkram/api/deser.py

@@ -4,6 +4,7 @@ from datetime import datetime
 from enum import Enum
 from typing import Any
 from typing import Dict
+from typing import List
 from typing import Literal
 from typing import NewType
 from typing import Tuple
@@ -12,10 +13,14 @@ from uuid import UUID
 import dateutil.parser
 
 from kleinkram.errors import ParsingError
+from kleinkram.models import ActionTemplate
 from kleinkram.models import File
 from kleinkram.models import FileState
+from kleinkram.models import LogEntry
+from kleinkram.models import MetadataValue
 from kleinkram.models import Mission
 from kleinkram.models import Project
+from kleinkram.models import Run
 
 __all__ = [
     "_parse_project",
@@ -27,6 +32,7 @@ __all__ = [
 ProjectObject = NewType("ProjectObject", Dict[str, Any])
 MissionObject = NewType("MissionObject", Dict[str, Any])
 FileObject = NewType("FileObject", Dict[str, Any])
+RunObject = NewType("RunObject", Dict[str, Any])
 
 MISSION = "mission"
 PROJECT = "project"
@@ -51,6 +57,9 @@ class MissionObjectKeys(str, Enum):
     DESCRIPTION = "description"
     CREATED_AT = "createdAt"
     UPDATED_AT = "updatedAt"
+    TAGS = "tags"
+    FILESIZE = "size"
+    FILECOUNT = "filesCount"
 
 
 class ProjectObjectKeys(str, Enum):
@@ -59,6 +68,40 @@ class ProjectObjectKeys(str, Enum):
     DESCRIPTION = "description"
     CREATED_AT = "createdAt"
     UPDATED_AT = "updatedAt"
+    REQUIRED_TAGS = "requiredTags"
+
+
+class RunObjectKeys(str, Enum):
+    UUID = "uuid"
+    STATE = "state"
+    STATE_CAUSE = "stateCause"
+    CREATED_AT = "createdAt"
+    MISSION = "mission"
+    TEMPLATE = "template"
+    UPDATED_AT = "updatedAt"
+    LOGS = "logs"
+    ARTIFACT_URL = "artifactUrl"
+
+
+class TemplateObjectKeys(str, Enum):
+    UUID = "uuid"
+    NAME = "name"
+    ACCESS_RIGHTS = "accessRights"
+    COMMAND = "command"
+    CPU_CORES = "cpuCores"
+    CPU_MEMORY_GB = "cpuMemory"
+    ENTRYPOINT = "entrypoint"
+    GPU_MEMORY_GB = "gpuMemory"
+    IMAGE_NAME = "imageName"
+    MAX_RUNTIME_MINUTES = "maxRuntime"
+    CREATED_AT = "createdAt"
+    VERSION = "version"
+
+
+class LogEntryObjectKeys(str, Enum):
+    TIMESTAMP = "timestamp"
+    LEVEL = "type"
+    MESSAGE = "message"
 
 
 def _get_nested_info(data, key: Literal["mission", "project"]) -> Tuple[UUID, str]:
@@ -83,6 +126,21 @@ def _parse_file_state(state: str) -> FileState:
         raise ParsingError(f"error parsing file state: {state}") from e
 
 
+def _parse_metadata(tags: List[Dict]) -> Dict[str, MetadataValue]:
+    result = {}
+    try:
+        for tag in tags:
+            entry = {tag.get("name"): MetadataValue(tag.get("valueAsString"), tag.get("datatype"))}
+            result.update(entry)
+        return result
+    except ValueError as e:
+        raise ParsingError(f"error parsing metadata: {e}") from e
+
+
+def _parse_required_tags(tags: List[Dict]) -> list[str]:
+    return list(_parse_metadata(tags).keys())
+
+
 def _parse_project(project_object: ProjectObject) -> Project:
     try:
         id_ = UUID(project_object[ProjectObjectKeys.UUID], version=4)
@@ -90,6 +148,7 @@ def _parse_project(project_object: ProjectObject) -> Project:
         description = project_object[ProjectObjectKeys.DESCRIPTION]
         created_at = _parse_datetime(project_object[ProjectObjectKeys.CREATED_AT])
         updated_at = _parse_datetime(project_object[ProjectObjectKeys.UPDATED_AT])
+        required_tags = _parse_required_tags(project_object[ProjectObjectKeys.REQUIRED_TAGS])
     except Exception as e:
         raise ParsingError(f"error parsing project: {project_object}") from e
     return Project(
@@ -98,6 +157,7 @@ def _parse_project(project_object: ProjectObject) -> Project:
         description=description,
         created_at=created_at,
         updated_at=updated_at,
+        required_tags=required_tags,
     )
 
 
@@ -107,7 +167,9 @@ def _parse_mission(mission: MissionObject) -> Mission:
         name = mission[MissionObjectKeys.NAME]
         created_at = _parse_datetime(mission[MissionObjectKeys.CREATED_AT])
         updated_at = _parse_datetime(mission[MissionObjectKeys.UPDATED_AT])
-        metadata = {}  # TODO: this crap is really bad to parse
+        metadata = _parse_metadata(mission[MissionObjectKeys.TAGS])
+        file_count = mission[MissionObjectKeys.FILECOUNT]
+        filesize = mission[MissionObjectKeys.FILESIZE]
 
         project_id, project_name = _get_nested_info(mission, PROJECT)
 
@@ -119,6 +181,8 @@ def _parse_mission(mission: MissionObject) -> Mission:
             metadata=metadata,
             project_id=project_id,
             project_name=project_name,
+            number_of_files=file_count,
+            size=filesize,
         )
     except Exception as e:
         raise ParsingError(f"error parsing mission: {mission}") from e
@@ -160,3 +224,90 @@ def _parse_file(file: FileObject) -> File:
     except Exception as e:
         raise ParsingError(f"error parsing file: {file}") from e
     return parsed
+
+
+def _parse_action_template(run_object: RunObject) -> ActionTemplate:
+    try:
+        uuid_ = UUID(run_object[TemplateObjectKeys.UUID], version=4)
+        access_rights = run_object[TemplateObjectKeys.ACCESS_RIGHTS]
+        command = run_object[TemplateObjectKeys.COMMAND]
+        cpu_cores = run_object[TemplateObjectKeys.CPU_CORES]
+        cpu_memory_gb = run_object[TemplateObjectKeys.CPU_MEMORY_GB]
+        entrypoint = run_object[TemplateObjectKeys.ENTRYPOINT]
+        gpu_memory_gb = run_object[TemplateObjectKeys.GPU_MEMORY_GB]
+        image_name = run_object[TemplateObjectKeys.IMAGE_NAME]
+        max_runtime_minutes = run_object[TemplateObjectKeys.MAX_RUNTIME_MINUTES]
+        created_at = _parse_datetime(run_object[TemplateObjectKeys.CREATED_AT])
+        name = run_object[TemplateObjectKeys.NAME]
+        version = run_object[TemplateObjectKeys.VERSION]
+
+    except Exception as e:
+        raise ParsingError(f"error parsing action template: {run_object}") from e
+
+    return ActionTemplate(
+        uuid=uuid_,
+        access_rights=access_rights,
+        command=command,
+        cpu_cores=cpu_cores,
+        cpu_memory_gb=cpu_memory_gb,
+        entrypoint=entrypoint,
+        gpu_memory_gb=gpu_memory_gb,
+        image_name=image_name,
+        max_runtime_minutes=max_runtime_minutes,
+        created_at=created_at,
+        name=name,
+        version=version,
+    )
+
+
+def _parse_run(run_object: RunObject) -> Run:
+    try:
+        uuid_ = UUID(run_object[RunObjectKeys.UUID], version=4)
+        state = run_object[RunObjectKeys.STATE]
+        state_cause = run_object[RunObjectKeys.STATE_CAUSE]
+        artifact_url = run_object.get(RunObjectKeys.ARTIFACT_URL)
+        created_at = _parse_datetime(run_object[RunObjectKeys.CREATED_AT])
+        updated_at = (
+            _parse_datetime(run_object[RunObjectKeys.UPDATED_AT]) if run_object.get(RunObjectKeys.UPDATED_AT) else None
+        )
+
+        mission_dict = run_object[RunObjectKeys.MISSION]
+        mission_id = UUID(mission_dict[MissionObjectKeys.UUID], version=4)
+        mission_name = mission_dict[MissionObjectKeys.NAME]
+
+        project_dict = mission_dict[PROJECT]
+        project_name = project_dict[ProjectObjectKeys.NAME]
+
+        template_dict = run_object[RunObjectKeys.TEMPLATE]
+        template_id = UUID(template_dict[TemplateObjectKeys.UUID], version=4)
+        template_name = template_dict[TemplateObjectKeys.NAME]
+        logs = []
+        for log_entry in run_object.get(RunObjectKeys.LOGS, []):
+            log_timestamp = _parse_datetime(log_entry[LogEntryObjectKeys.TIMESTAMP])
+            log_level = log_entry[LogEntryObjectKeys.LEVEL]
+            log_message = log_entry[LogEntryObjectKeys.MESSAGE]
+            logs.append(
+                LogEntry(
+                    timestamp=log_timestamp,
+                    level=log_level,
+                    message=log_message,
+                )
+            )
+
+    except Exception as e:
+        raise ParsingError(f"error parsing run: {run_object}") from e
+
+    return Run(
+        uuid=uuid_,
+        state=state,
+        state_cause=state_cause,
+        artifact_url=artifact_url,
+        created_at=created_at,
+        updated_at=updated_at,
+        mission_id=mission_id,
+        mission_name=mission_name,
+        project_name=project_name,
+        template_id=template_id,
+        template_name=template_name,
+        logs=logs,
+    )

kleinkram/api/file_transfer.py

@@ -7,7 +7,8 @@ from concurrent.futures import ThreadPoolExecutor
 from concurrent.futures import as_completed
 from enum import Enum
 from pathlib import Path
-from time import monotonic, sleep
+from time import monotonic
+from time import sleep
 from typing import Dict
 from typing import NamedTuple
 from typing import Optional
@@ -34,7 +35,7 @@ from kleinkram.utils import styled_string
 logger = logging.getLogger(__name__)
 
 UPLOAD_CREDS = "/files/temporaryAccess"
-UPLOAD_CONFIRM = "/queue/confirmUpload"
+UPLOAD_CONFIRM = "/files/upload/confirm"
 UPLOAD_CANCEL = "/files/cancelUpload"
 
 DOWNLOAD_CHUNK_SIZE = 1024 * 1024 * 16
@@ -56,20 +57,17 @@ class UploadCredentials(NamedTuple):
     bucket: str
 
 
-def _confirm_file_upload(
-    client: AuthenticatedClient, file_id: UUID, file_hash: str
-) -> None:
+def _confirm_file_upload(client: AuthenticatedClient, file_id: UUID, file_hash: str) -> None:
     data = {
         "uuid": str(file_id),
         "md5": file_hash,
+        "source": "CLI",
     }
     resp = client.post(UPLOAD_CONFIRM, json=data)
     resp.raise_for_status()
 
 
-def _cancel_file_upload(
-    client: AuthenticatedClient, file_id: UUID, mission_id: UUID
-) -> None:
+def _cancel_file_upload(client: AuthenticatedClient, file_id: UUID, mission_id: UUID) -> None:
     data = {
         "uuids": [str(file_id)],
         "missionUuid": str(mission_id),
@@ -96,9 +94,16 @@ def _get_upload_creditials(
     dct = {
         "filenames": [internal_filename],
         "missionUUID": str(mission_id),
+        "source": "CLI",
     }
-    resp = client.post(UPLOAD_CREDS, json=dct)
-    resp.raise_for_status()
+    try:
+        resp = client.post(UPLOAD_CREDS, json=dct)
+        resp.raise_for_status()
+    except httpx.HTTPStatusError as e:
+        # 409 Conflict means file already exists
+        if e.response.status_code == 409:
+            return None
+        raise
 
     data = resp.json()["data"][0]
 
@@ -156,9 +161,7 @@ class UploadState(Enum):
     CANCELED = 3
 
 
-def _get_upload_credentials_with_retry(
-    client, pbar, filename, mission_id, max_attempts=5
-):
+def _get_upload_credentials_with_retry(client, pbar, filename, mission_id, max_attempts=5):
     """
     Retrieves upload credentials with retry logic.
 
@@ -173,9 +176,7 @@ def _get_upload_credentials_with_retry(
     """
     attempt = 0
     while attempt < max_attempts:
-        creds = _get_upload_creditials(
-            client, internal_filename=filename, mission_id=mission_id
-        )
+        creds = _get_upload_creditials(client, internal_filename=filename, mission_id=mission_id)
         if creds is not None:
             return creds
 
@@ -230,9 +231,7 @@ def upload_file(
                 try:
                     _cancel_file_upload(client, creds.file_id, mission_id)
                 except Exception as cancel_e:
-                    logger.error(
-                        f"Failed to cancel upload for {creds.file_id}: {cancel_e}"
-                    )
+                    logger.error(f"Failed to cancel upload for {creds.file_id}: {cancel_e}")
 
                 if attempt < 2:  # Retry if not the last attempt
                     pbar.update(0)
@@ -251,22 +250,19 @@ def _get_file_download(client: AuthenticatedClient, id: UUID) -> str:
     """\
     get the download url for a file by file id
     """
-    resp = client.get(DOWNLOAD_URL, params={"uuid": str(id), "expires": True})
+    resp = client.get(DOWNLOAD_URL, params={"uuid": str(id), "expires": True, "preview_only": False})
 
     if 400 <= resp.status_code < 500:
         raise AccessDenied(
-            f"Failed to download file: {resp.json()['message']}"
-            f" Status Code: {resp.status_code}",
+            f"Failed to download file: {resp.json()['message']}" f" Status Code: {resp.status_code}",
         )
 
     resp.raise_for_status()
 
-    return resp.text
+    return resp.json()["url"]
 
 
-def _url_download(
-    url: str, *, path: Path, size: int, overwrite: bool = False, verbose: bool = False
-) -> None:
+def _url_download(url: str, *, path: Path, size: int, overwrite: bool = False, verbose: bool = False) -> None:
     if path.exists():
         if overwrite:
             path.unlink()
@@ -282,18 +278,11 @@ def _url_download(
     while downloaded < size:
         try:
             headers = {"Range": f"bytes={downloaded}-"}
-            with httpx.stream(
-                "GET", url, headers=headers, timeout=S3_READ_TIMEOUT
-            ) as response:
+            with httpx.stream("GET", url, headers=headers, timeout=S3_READ_TIMEOUT) as response:
                 # Accept both 206 Partial Content and 200 OK if starting from 0
-                if not (
-                    response.status_code == 206
-                    or (downloaded == 0 and response.status_code == 200)
-                ):
+                if not (response.status_code == 206 or (downloaded == 0 and response.status_code == 200)):
                     response.raise_for_status()
-                    raise RuntimeError(
-                        f"Expected 206 Partial Content, got {response.status_code}"
-                    )
+                    raise RuntimeError(f"Expected 206 Partial Content, got {response.status_code}")
 
                 mode = "ab" if downloaded > 0 else "wb"
                 with open(path, mode) as f:
@@ -306,9 +295,7 @@ def _url_download(
                         leave=False,
                         disable=not verbose,
                     ) as pbar:
-                        for chunk in response.iter_bytes(
-                            chunk_size=DOWNLOAD_CHUNK_SIZE
-                        ):
+                        for chunk in response.iter_bytes(chunk_size=DOWNLOAD_CHUNK_SIZE):
                             attempt = 0  # reset attempt counter on successful download of non-empty chunk
                             if not chunk:
                                 break
@@ -320,13 +307,9 @@ def _url_download(
             logger.info(f"Error: {e}, retrying...")
             attempt += 1
             if attempt > MAX_RETRIES:
-                raise RuntimeError(
-                    f"Download failed after {MAX_RETRIES} retries due to {e}"
-                ) from e
+                raise RuntimeError(f"Download failed after {MAX_RETRIES} retries due to {e}") from e
             if verbose:
-                print(
-                    f"{e} on attempt {attempt}/{MAX_RETRIES}, retrying after backoff..."
-                )
+                print(f"{e} on attempt {attempt}/{MAX_RETRIES}, retrying after backoff...")
             sleep(RETRY_BACKOFF_BASE**attempt)
 
 
@@ -366,17 +349,13 @@ def download_file(
                 return DownloadState.SKIPPED_OK, 0
 
             elif verbose:
-                tqdm.write(
-                    styled_string(f"overwriting {path}, hash mismatch", style="yellow")
-                )
+                tqdm.write(styled_string(f"overwriting {path}, hash mismatch", style="yellow"))
 
         elif not overwrite and file.size is not None:
             return DownloadState.SKIPPED_FILE_SIZE_MISMATCH, 0
 
         elif verbose:
-            tqdm.write(
-                styled_string(f"overwriting {path}, file size mismatch", style="yellow")
-            )
+            tqdm.write(styled_string(f"overwriting {path}, file size mismatch", style="yellow"))
 
     # request a download url
     download_url = _get_file_download(client, file.id)
@@ -406,6 +385,10 @@ def download_file(
 
     observed_hash = b64_md5(path)
     if file.hash is not None and observed_hash != file.hash:
+        print(
+            f"HASH MISMATCH: {path} expected={file.hash} observed={observed_hash}",
+            file=sys.stderr,
+        )
         # Download completed but hash failed
         return (
             DownloadState.DOWNLOADED_INVALID_HASH,
@@ -422,9 +405,7 @@ UPLOAD_STATE_COLOR = {
 }
 
 
-def _upload_handler(
-    future: Future[Tuple[UploadState, int]], path: Path, *, verbose: bool = False
-) -> int:
+def _upload_handler(future: Future[Tuple[UploadState, int]], path: Path, *, verbose: bool = False) -> int:
     """Returns bytes uploaded successfully."""
     state = UploadState.CANCELED  # Default to canceled if exception occurs
     size_bytes = 0
@@ -433,7 +414,7 @@ def _upload_handler(
     except Exception as e:
         logger.error(format_traceback(e))
         if verbose:
-            tqdm.write(format_error(f"error uploading", e, verbose=verbose))
+            tqdm.write(format_error("error uploading", e, verbose=verbose))
         else:
             print(f"ERROR: {path.absolute()}: {e}", file=sys.stderr)
         return 0  # Return 0 bytes on error
@@ -503,11 +484,7 @@ def _download_handler(
     elif state not in (DownloadState.DOWNLOADED_OK, DownloadState.SKIPPED_OK):
         print(f"SKIP/FAIL: {path.absolute()} ({state.name})", file=sys.stderr)
 
-    return (
-        size_bytes
-        if state in (DownloadState.DOWNLOADED_OK, DownloadState.SKIPPED_OK)
-        else 0
-    )
+    return size_bytes if state in (DownloadState.DOWNLOADED_OK, DownloadState.SKIPPED_OK) else 0
 
 
 def upload_files(
@@ -524,7 +501,7 @@ def upload_files(
         unit="files",
         desc="Uploading files",
         disable=not verbose,
-        leave=False,
+        leave=True,
     ) as pbar:
         start = monotonic()
         futures: Dict[Future[Tuple[UploadState, int]], Path] = {}
@@ -534,9 +511,7 @@ def upload_files(
         with ThreadPoolExecutor(max_workers=n_workers) as executor:
             for name, path in files.items():
                 if not path.is_file():
-                    console.print(
-                        f"[yellow]Skipping non-existent file: {path}[/yellow]"
-                    )
+                    console.print(f"[yellow]Skipping non-existent file: {path}[/yellow]")
                     pbar.update()
                     continue
 
@@ -556,10 +531,7 @@ def upload_files(
                 if future.exception():
                     failed_files += 1
 
-                if (
-                    future.exception() is None
-                    and future.result()[0] == UploadState.EXISTS
-                ):
+                if future.exception() is None and future.result()[0] == UploadState.EXISTS:
                     skipped_files += 1
 
                 path = futures[future]
@@ -567,24 +539,25 @@ def upload_files(
                 total_uploaded_bytes += uploaded_bytes
                 pbar.update()
 
-        end = monotonic()
-        elapsed_time = end - start
+    end = monotonic()
+    elapsed_time = end - start
 
-        avg_speed_bps = total_uploaded_bytes / elapsed_time if elapsed_time > 0 else 0
+    avg_speed_bps = total_uploaded_bytes / elapsed_time if elapsed_time > 0 else 0
 
+    if verbose:
+        console.print()
         console.print(f"Upload took {elapsed_time:.2f} seconds")
         console.print(f"Total uploaded: {format_bytes(total_uploaded_bytes)}")
         console.print(f"Average speed: {format_bytes(avg_speed_bps, speed=True)}")
 
         if failed_files > 0:
             console.print(
-                f"\nUploaded {len(files) - failed_files - skipped_files} files, {skipped_files} skipped, {failed_files} uploads failed",
+                f"\nUploaded {len(files) - failed_files - skipped_files} files, "
+                f"{skipped_files} skipped, {failed_files} uploads failed",
                 style="red",
             )
         else:
-            console.print(
-                f"\nUploaded {len(files) - skipped_files} files, {skipped_files} skipped"
-            )
+            console.print(f"\nUploaded {len(files) - skipped_files} files, {skipped_files} skipped")
 
 
 def download_files(
@@ -601,7 +574,7 @@ def download_files(
         unit="files",
         desc="Downloading files",
         disable=not verbose,
-        leave=False,
+        leave=True,
     ) as pbar:
 
         start = monotonic()
@@ -621,18 +594,15 @@ def download_files(
             total_downloaded_bytes = 0
             for future in as_completed(futures):
                 file, path = futures[future]
-                downloaded_bytes = _download_handler(
-                    future, file, path, verbose=verbose
-                )
+                downloaded_bytes = _download_handler(future, file, path, verbose=verbose)
                 total_downloaded_bytes += downloaded_bytes
                 pbar.update()
 
-        end = monotonic()
-        elapsed_time = end - start
-        avg_speed_bps = total_downloaded_bytes / elapsed_time if elapsed_time > 0 else 0
+    end = monotonic()
+    elapsed_time = end - start
+    avg_speed_bps = total_downloaded_bytes / elapsed_time if elapsed_time > 0 else 0
 
-        console.print(f"Download took {elapsed_time:.2f} seconds")
-        console.print(
-            f"Total downloaded/verified: {format_bytes(total_downloaded_bytes)}"
-        )
-        console.print(f"Average speed: {format_bytes(avg_speed_bps, speed=True)}")
+    console.print()
+    console.print(f"Download took {elapsed_time:.2f} seconds")
+    console.print(f"Total downloaded/verified: {format_bytes(total_downloaded_bytes)}")
+    console.print(f"Average speed: {format_bytes(avg_speed_bps, speed=True)}")

kleinkram/api/pagination.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from enum import Enum
 from typing import Any
 from typing import Dict
 from typing import Generator
@@ -17,6 +16,7 @@ DataPage = Dict[str, Any]
 PAGE_SIZE = 128
 SKIP = "skip"
 TAKE = "take"
+EXACT_MATCH = "exactMatch"
 
 
 def paginated_request(
@@ -25,6 +25,7 @@ def paginated_request(
     params: Optional[Mapping[str, Any]] = None,
     max_entries: Optional[int] = None,
     page_size: int = PAGE_SIZE,
+    exact_match: bool = False,
 ) -> Generator[DataPage, None, None]:
     total_entries_count = 0
 
@@ -32,10 +33,18 @@ def paginated_request(
 
     params[TAKE] = page_size
     params[SKIP] = 0
+    if exact_match:
+        params[EXACT_MATCH] = str(exact_match).lower()  # pass string rather than bool
 
     while True:
         resp = client.get(endpoint, params=params)
-        resp.raise_for_status()  # TODO: this is fine for now
+
+        # explicitly handle 404 if json contains message
+        if resp.status_code == 404 and "message" in resp.json():
+            raise ValueError(resp.json()["message"])
+
+        # raise for other errors
+        resp.raise_for_status()
 
         paged_data = resp.json()
         data_page = cast(List[DataPage], paged_data["data"])