kleinkram 0.53.0__tar.gz → 0.56.0.dev20251201085236__tar.gz

{kleinkram-0.53.0 → kleinkram-0.56.0.dev20251201085236}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kleinkram
-Version: 0.53.0
+Version: 0.56.0.dev20251201085236
 Summary: give me your bags
 Author: Cyrill Püntener, Dominique Garmier, Johann Schwabe
 Author-email: pucyril@ethz.ch, dgarmier@ethz.ch, jschwab@ethz.ch
@@ -23,6 +23,7 @@ Requires-Dist: rich
 Requires-Dist: tqdm
 Requires-Dist: typer
 Requires-Dist: click
+Requires-Dist: requests
 
 # Kleinkram: CLI
 
@@ -118,7 +119,7 @@ pytest
 ```
 For the latter you need to have an instance of the backend running locally.
 See instructions in the root of the repository for this.
-On top of that these tests require particular files to be present in the `cli/data/testing` directory.
-To see the exact files that are required, see `cli/testing/backend_fixtures.py`.
+On top of that these tests require particular files to be present in the `cli/tests/data` directory.
+These files are automatically generated by the `cli/tests/generate_test_data.py` script.
 
 You also need to make sure to be logged in with the cli with `klein login`.

{kleinkram-0.53.0 → kleinkram-0.56.0.dev20251201085236}/README.md

@@ -92,7 +92,7 @@ pytest
 ```
 For the latter you need to have an instance of the backend running locally.
 See instructions in the root of the repository for this.
-On top of that these tests require particular files to be present in the `cli/data/testing` directory.
-To see the exact files that are required, see `cli/testing/backend_fixtures.py`.
+On top of that these tests require particular files to be present in the `cli/tests/data` directory.
+These files are automatically generated by the `cli/tests/generate_test_data.py` script.
 
 You also need to make sure to be logged in with the cli with `klein login`.

{kleinkram-0.53.0 → kleinkram-0.56.0.dev20251201085236}/kleinkram/api/deser.py

@@ -71,30 +71,13 @@ class ProjectObjectKeys(str, Enum):
 class RunObjectKeys(str, Enum):
     UUID = "uuid"
     STATE = "state"
+    STATE_CAUSE = "stateCause"
     CREATED_AT = "createdAt"
     MISSION = "mission"
     TEMPLATE = "template"
     UPDATED_AT = "updatedAt"
     LOGS = "logs"
-
-
-"""
-@dataclass(frozen=True)
-class ActionTemplate:
-    uuid: UUID
-    access_rights: int
-    command: str
-    cpu_cores: int
-    cpu_memory_gb: int
-    entrypoint: str
-    gpu_memory_gb: int
-    image_name: str
-    max_runtime_minutes: int
-    created_at: datetime
-    name: str
-    version: str
-
-"""
+    ARTIFACT_URL = "artifactUrl"
 
 
 class TemplateObjectKeys(str, Enum):
@@ -303,6 +286,8 @@ 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])
@@ -339,6 +324,8 @@ def _parse_run(run_object: RunObject) -> Run:
     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,

{kleinkram-0.53.0 → kleinkram-0.56.0.dev20251201085236}/kleinkram/api/file_transfer.py

@@ -62,6 +62,7 @@ def _confirm_file_upload(
     data = {
         "uuid": str(file_id),
         "md5": file_hash,
+        "source": "CLI",
     }
     resp = client.post(UPLOAD_CONFIRM, json=data)
     resp.raise_for_status()
@@ -96,6 +97,7 @@ 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()
@@ -251,7 +253,9 @@ 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(
@@ -406,6 +410,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,

{kleinkram-0.53.0 → kleinkram-0.56.0.dev20251201085236}/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
@@ -34,11 +33,18 @@ def paginated_request(
 
     params[TAKE] = page_size
     params[SKIP] = 0
-    params[EXACT_MATCH] = str(exact_match).lower()  # pass string rather than bool
+    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"])

{kleinkram-0.53.0 → kleinkram-0.56.0.dev20251201085236}/kleinkram/api/routes.py

@@ -185,7 +185,7 @@ def get_projects(
     yield from map(lambda p: _parse_project(ProjectObject(p)), response_stream)
 
 
-LIST_ACTIONS_ENDPOINT = "/action/listActions"
+LIST_ACTIONS_ENDPOINT = "/actions"
 
 
 def get_runs(
@@ -201,7 +201,7 @@ def get_run(
     client: AuthenticatedClient,
     run_id: str,
 ) -> Run:
-    resp = client.get(f"{ACTION_ENDPOINT}/details", params={"uuid": run_id})
+    resp = client.get(f"{ACTION_ENDPOINT}s/{run_id}")
     if resp.status_code == 404:
         raise kleinkram.errors.RunNotFound(f"Run not found: {run_id}")
     resp.raise_for_status()
@@ -211,7 +211,7 @@ def get_run(
 def get_action_templates(
     client: AuthenticatedClient,
 ) -> Generator[ActionTemplate, None, None]:
-    response_stream = paginated_request(client, "/action/listTemplates")
+    response_stream = paginated_request(client, "/templates")
     yield from map(lambda p: _parse_action_template(RunObject(p)), response_stream)
 
 
@@ -247,7 +247,7 @@ def submit_action(
     }
 
     typer.echo("Submitting action...")
-    resp = client.post(f"{ACTION_ENDPOINT}/submit", json=submit_payload)
+    resp = client.post(f"{ACTION_ENDPOINT}s", json=submit_payload)
     resp.raise_for_status()  # Raises on 4xx/5xx responses
 
     response_data = resp.json()

kleinkram-0.56.0.dev20251201085236/kleinkram/auth.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import urllib.parse
+import webbrowser
+from getpass import getpass
+from http.server import BaseHTTPRequestHandler
+from http.server import HTTPServer
+from typing import Optional
+
+from kleinkram.config import CONFIG_PATH
+from kleinkram.config import Credentials
+from kleinkram.config import get_config
+from kleinkram.config import save_config
+
+CLI_CALLBACK_ENDPOINT = "/cli/callback"
+OAUTH_SLUG = "/auth/"
+
+
+def _has_browser() -> bool:
+    try:
+        webbrowser.get()
+        return True
+    except webbrowser.Error:
+        return False
+
+
+def _headless_auth(*, url: str) -> None:
+
+    print(f"please open the following URL manually to authenticate: {url}")
+    print("enter the authentication token provided after logging in:")
+    auth_token = getpass("authentication token: ")
+    refresh_token = getpass("refresh token: ")
+
+    if auth_token and refresh_token:
+        config = get_config()
+        config.credentials = Credentials(
+            auth_token=auth_token, refresh_token=refresh_token
+        )
+        save_config(config)
+        print(f"Authentication complete. Tokens saved to {CONFIG_PATH}.")
+    else:
+        raise ValueError("Please provided tokens.")
+
+
+class OAuthCallbackHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        if self.path.startswith(CLI_CALLBACK_ENDPOINT):
+            query = urllib.parse.urlparse(self.path).query
+            params = urllib.parse.parse_qs(query)
+
+            try:
+                creds = Credentials(
+                    auth_token=params.get("authtoken")[0],  # type: ignore
+                    refresh_token=params.get("refreshtoken")[0],  # type: ignore
+                )
+                config = get_config()
+                config.credentials = creds
+                save_config(config)
+            except Exception:
+                raise RuntimeError("Failed to fetch authentication tokens.")
+
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"Authentication successful. You can close this window.")
+        else:
+            raise RuntimeError("Invalid path")
+
+    def log_message(self, *args, **kwargs):
+        _ = args, kwargs
+        pass  # suppress logging
+
+
+def _browser_auth(*, url: str) -> None:
+    webbrowser.open(url)
+
+    server = HTTPServer(("", 8000), OAuthCallbackHandler)
+    server.handle_request()
+
+    print(f"Authentication complete. Tokens saved to {CONFIG_PATH}.")
+
+
+def _direct_oauth_auth(*, endpoint: str, provider: str, user: str) -> None:
+    """
+    Directly authenticate with fake OAuth by programmatically following the OAuth flow.
+    This bypasses the browser entirely for automated testing.
+    """
+    import requests
+
+    print(f"Authenticating as user {user} with {provider}...")
+
+    try:
+        # Step 1: Get the authorization code from fake OAuth
+        # The fake OAuth server will auto-redirect when user parameter is provided
+        fake_oauth_url = f"http://localhost:8004/oauth/authorize"
+        callback_url = f"{endpoint}/auth/{provider}/callback"
+
+        params = {
+            "client_id": "some-random-string-it-does-not-matter",
+            "redirect_uri": callback_url,
+            "response_type": "code",
+            "state": "cli-direct",
+            "user": user,
+        }
+
+        # Make request to fake OAuth - it will redirect with the auth code
+        response = requests.get(fake_oauth_url, params=params, allow_redirects=False)
+
+        if response.status_code not in [301, 302, 303, 307, 308]:
+            raise RuntimeError(
+                f"Expected redirect from OAuth provider, got {response.status_code}"
+            )
+
+        # Extract the redirect location
+        location = response.headers.get("Location")
+        if not location:
+            raise RuntimeError("No redirect location from OAuth provider")
+
+        # Parse the callback URL to extract the auth code
+        parsed = urllib.parse.urlparse(location)
+        query_params = urllib.parse.parse_qs(parsed.query)
+
+        if "code" not in query_params:
+            raise RuntimeError(f"No authorization code in redirect: {location}")
+
+        auth_code = query_params["code"][0]
+        state = query_params.get("state", [None])[0]
+
+        print(f"Received authorization code, exchanging for tokens...")
+
+        # Step 2: Exchange the code for tokens by calling the backend callback
+        # Use a session to preserve cookies
+        session = requests.Session()
+        callback_params = {"code": auth_code}
+        if state:
+            callback_params["state"] = state
+
+        callback_response = session.get(
+            callback_url, params=callback_params, allow_redirects=False
+        )
+
+        # The backend should set cookies and redirect
+        if callback_response.status_code not in [301, 302, 303, 307, 308]:
+            raise RuntimeError(
+                f"Expected redirect from callback, got {callback_response.status_code}"
+            )
+
+        # Extract tokens from cookies
+        auth_token = session.cookies.get("authtoken")
+        refresh_token = session.cookies.get("refreshtoken")
+
+        if not auth_token or not refresh_token:
+            raise RuntimeError("Failed to get tokens from callback response")
+
+        # Save tokens
+        config = get_config()
+        config.credentials = Credentials(
+            auth_token=auth_token, refresh_token=refresh_token
+        )
+        save_config(config)
+        print(f"Authentication complete. Tokens saved to {CONFIG_PATH}.")
+
+    except requests.RequestException as e:
+        raise RuntimeError(f"OAuth flow failed: {e}")
+
+
+def login_flow(
+    *,
+    oAuthProvider: str,
+    key: Optional[str] = None,
+    headless: bool = False,
+    user: Optional[str] = None,
+) -> None:
+    config = get_config()
+    # use cli key login
+    if key is not None:
+        config.credentials = Credentials(api_key=key)
+        save_config(config)
+        return
+
+    # If user parameter is provided with fake-oauth, use direct OAuth flow
+    if user is not None and oAuthProvider == "fake-oauth":
+        _direct_oauth_auth(
+            endpoint=config.endpoint.api, provider=oAuthProvider, user=user
+        )
+        return
+
+    # Build OAuth URL with state parameter
+    oauth_url = f"{config.endpoint.api}{OAUTH_SLUG}{oAuthProvider}?state=cli"
+
+    # Add user parameter if provided (for fake-oauth auto-login)
+    if user is not None:
+        oauth_url += f"&user={user}"
+
+    is_port_available = True
+    try:
+        server = HTTPServer(("", 8000), OAuthCallbackHandler)
+        server.server_close()
+    except OSError:
+        is_port_available = False
+
+    if not is_port_available:
+        print(
+            "Warning: Port 8000 is not available. Falling back to headless authentication.\n\n"
+        )
+
+    if not headless and _has_browser() and is_port_available:
+        _browser_auth(url=oauth_url)
+    else:
+        _headless_auth(url=f"{oauth_url}-no-redirect")

kleinkram-0.56.0.dev20251201085236/kleinkram/cli/_run.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import tarfile
+import os
+import re
+import sys
+import time
+from typing import Optional, List
+
+import requests
+import typer
+
+import kleinkram.api.routes
+from kleinkram.api.client import AuthenticatedClient
+from kleinkram.api.query import RunQuery
+from kleinkram.config import get_shared_state
+from kleinkram.models import Run, LogEntry
+from kleinkram.printing import print_runs_table, print_run_info, print_run_logs
+from kleinkram.utils import split_args
+
+HELP = """\
+Manage and inspect action runs.
+
+You can list action runs, get detailed information about specific runs, stream their logs,
+cancel runs in progress, and retry failed runs.
+"""
+
+run_typer = typer.Typer(
+    no_args_is_help=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help=HELP,
+)
+
+LIST_HELP = "List action runs. Optionally filter by mission or project."
+INFO_HELP = "Get detailed information about a specific action run."
+LOGS_HELP = "Stream the logs for a specific action run."
+CANCEL_HELP = "Cancel an action run that is in progress."
+RETRY_HELP = "Retry a failed action run."
+DOWNLOAD_HELP = "Download artifacts for a specific action run."
+
+
+@run_typer.command(help=LIST_HELP, name="list")
+def list_runs(
+    mission: Optional[str] = typer.Option(
+        None, "--mission", "-m", help="Mission ID or name to filter by."
+    ),
+    project: Optional[str] = typer.Option(
+        None, "--project", "-p", help="Project ID or name to filter by."
+    ),
+) -> None:
+    """
+    List action runs.
+    """
+    client = AuthenticatedClient()
+
+    mission_ids, mission_patterns = split_args([mission] if mission else [])
+    project_ids, project_patterns = split_args([project] if project else [])
+
+    query = RunQuery(
+        mission_ids=mission_ids,
+        mission_patterns=mission_patterns,
+        project_ids=project_ids,
+        project_patterns=project_patterns,
+    )
+
+    runs = list(kleinkram.api.routes.get_runs(client, query=query))
+    print_runs_table(runs, pprint=get_shared_state().verbose)
+
+
+@run_typer.command(name="info", help=INFO_HELP)
+def get_info(
+    run_id: str = typer.Argument(..., help="The ID of the run to get information for.")
+) -> None:
+    """
+    Get detailed information for a single run.
+    """
+    client = AuthenticatedClient()
+    run: Run = kleinkram.api.routes.get_run(client, run_id=run_id)
+    print_run_info(run, pprint=get_shared_state().verbose)
+
+
+@run_typer.command(help=LOGS_HELP)
+def logs(
+    run_id: str = typer.Argument(..., help="The ID of the run to fetch logs for."),
+    follow: bool = typer.Option(
+        False, "--follow", "-f", help="Follow the log output in real-time."
+    ),
+) -> None:
+    """
+    Fetch and display logs for a specific run.
+    """
+    client = AuthenticatedClient()
+
+    if follow:
+        typer.echo(f"Watching logs for run {run_id}. Press Ctrl+C to stop.")
+        try:
+
+            # TODO: fine for now, but ideally we would have a streaming endpoint
+            # currently there is no following, thus we just poll every 2 seconds
+            # from the get_run endpoint
+            last_log_index = 0
+            while True:
+                run: Run = kleinkram.api.routes.get_run(client, run_id=run_id)
+                log_entries: List[LogEntry] = run.logs
+                new_log_entries = log_entries[last_log_index:]
+                if new_log_entries:
+                    print_run_logs(new_log_entries, pprint=get_shared_state().verbose)
+                    last_log_index += len(new_log_entries)
+
+                time.sleep(2)
+
+        except KeyboardInterrupt:
+            typer.echo("Stopped following logs.")
+            sys.exit(0)
+    else:
+        log_entries = kleinkram.api.routes.get_run(client, run_id=run_id).logs
+        print_run_logs(log_entries, pprint=get_shared_state().verbose)
+
+
+def _get_filename_from_cd(cd: str) -> Optional[str]:
+    """Extract filename from Content-Disposition header."""
+    if not cd:
+        return None
+    fname = re.findall("filename=(.+)", cd)
+    if len(fname) == 0:
+        return None
+    return fname[0].strip().strip('"')
+
+
+@run_typer.command(name="download", help=DOWNLOAD_HELP)
+def download_artifacts(
+    run_id: str = typer.Argument(
+        ..., help="The ID of the run to download artifacts for."
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Path or filename to save the artifacts to."
+    ),
+    extract: bool = typer.Option(
+        False,
+        "--extract",
+        "-x",
+        help="Automatically extract the archive after downloading.",
+    ),
+) -> None:
+    """
+    Download the artifacts (.tar.gz) for a finished run.
+    """
+    client = AuthenticatedClient()
+
+    # Fetch Run Details
+    try:
+        run: Run = kleinkram.api.routes.get_run(client, run_id=run_id)
+    except Exception as e:
+        typer.secho(f"Failed to fetch run details: {e}", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+    if not run.artifact_url:
+        typer.secho(
+            f"No artifacts found for run {run_id}. The run might not be finished or artifacts expired.",
+            fg=typer.colors.YELLOW,
+        )
+        raise typer.Exit(1)
+
+    typer.echo(f"Downloading artifacts for run {run_id}...")
+
+    # Stream Download
+    try:
+        with requests.get(run.artifact_url, stream=True) as r:
+            r.raise_for_status()
+
+            # Determine Filename
+            filename = output
+            if not filename:
+                filename = _get_filename_from_cd(r.headers.get("content-disposition"))
+
+            if not filename:
+                filename = f"{run_id}.tar.gz"
+
+            # If output is a directory, join with filename
+            if output and os.path.isdir(output):
+                filename = os.path.join(
+                    output,
+                    _get_filename_from_cd(r.headers.get("content-disposition"))
+                    or f"{run_id}.tar.gz",
+                )
+
+            total_length = int(r.headers.get("content-length", 0))
+
+            # Write to file with Progress Bar
+            with open(filename, "wb") as f:
+                with typer.progressbar(
+                    length=total_length, label=f"Saving to {filename}"
+                ) as progress:
+                    for chunk in r.iter_content(chunk_size=8192):
+                        if chunk:
+                            f.write(chunk)
+                            progress.update(len(chunk))
+
+            typer.secho(
+                f"\nSuccessfully downloaded to {filename}", fg=typer.colors.GREEN
+            )
+
+            # Extraction Logic
+            if extract:
+                try:
+                    # Determine extraction directory (based on filename without extension)
+                    # e.g., "downloads/my-run.tar" -> "downloads/my-run"
+                    base_name = os.path.basename(filename)
+                    folder_name = base_name.split(".")[0]
+
+                    # Get the parent directory of the downloaded file
+                    parent_dir = os.path.dirname(os.path.abspath(filename))
+                    extract_path = os.path.join(parent_dir, folder_name)
+
+                    typer.echo(f"Extracting to: {extract_path}...")
+
+                    with tarfile.open(filename, "r:gz") as tar:
+
+                        # Safety check: filter_data prevents extraction outside target dir (CVE-2007-4559)
+                        # Available in Python 3.12+, for older python use generic extractall
+                        if hasattr(tarfile, "data_filter"):
+                            tar.extractall(path=extract_path, filter="data")
+                        else:
+                            tar.extractall(path=extract_path)
+
+                    typer.secho(f"Successfully extracted.", fg=typer.colors.GREEN)
+
+                except tarfile.TarError as e:
+                    typer.secho(f"Failed to extract archive: {e}", fg=typer.colors.RED)
+
+    except requests.exceptions.RequestException as e:
+        typer.secho(f"Error downloading file: {e}", fg=typer.colors.RED)
+        raise typer.Exit(1)

{kleinkram-0.53.0 → kleinkram-0.56.0.dev20251201085236}/kleinkram/cli/app.py

@@ -141,6 +141,12 @@ def login(
     ),
     key: Optional[str] = typer.Option(None, help="CLI key"),
     headless: bool = typer.Option(False),
+    user: Optional[str] = typer.Option(
+        None,
+        "--user",
+        "-u",
+        help="Auto-select user ID for fake-oauth (e.g., 1, 2, 3). Only works with fake-oauth provider.",
+    ),
 ) -> None:
 
     # logic to resolve the "auto" default
@@ -157,7 +163,13 @@ def login(
             f"Unsupported OAuth provider '{oAuthProvider}'. Supported providers: google, github, fake-oauth."
         )
 
-    login_flow(oAuthProvider=oAuthProvider, key=key, headless=headless)
+    # validate that user parameter is only used with fake-oauth
+    if user is not None and oAuthProvider != "fake-oauth":
+        raise typer.BadParameter(
+            "--user parameter can only be used with fake-oauth provider"
+        )
+
+    login_flow(oAuthProvider=oAuthProvider, key=key, headless=headless, user=user)
 
 
 @app.command(rich_help_panel=CommandTypes.AUTH)

{kleinkram-0.53.0 → kleinkram-0.56.0.dev20251201085236}/kleinkram/models.py

@@ -29,6 +29,7 @@ class FileState(str, Enum):
     CORRUPTED = "CORRUPTED"
     UPLOADING = "UPLOADING"
     ERROR = "ERROR"
+    CONVERTING = "CONVERTING"
     CONVERSION_ERROR = "CONVERSION_ERROR"
     LOST = "LOST"
     FOUND = "FOUND"
@@ -95,6 +96,8 @@ class LogEntry:
 class Run:
     uuid: UUID
     state: str
+    state_cause: str | None
+    artifact_url: str | None
     created_at: datetime
     updated_at: datetime | None
     project_name: str