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

kleinkram/core.py

@@ -22,6 +22,7 @@ from typing import Optional
 from typing import Sequence
 from uuid import UUID
 
+import httpx
 from rich.console import Console
 from tqdm import tqdm
 
@@ -33,6 +34,7 @@ from kleinkram.api.query import FileQuery
 from kleinkram.api.query import MissionQuery
 from kleinkram.api.query import ProjectQuery
 from kleinkram.api.query import check_mission_query_is_creatable
+from kleinkram.errors import InvalidFileQuery
 from kleinkram.errors import MissionNotFound
 from kleinkram.models import FileState
 from kleinkram.models import FileVerificationStatus
@@ -67,16 +69,17 @@ def download(
         raise ValueError(f"Destination {base_dir.absolute()} is not a directory")
 
     # retrive files and get the destination paths
-    files = list(kleinkram.api.routes.get_files(client, file_query=query))
+    try:
+        files = list(kleinkram.api.routes.get_files(client, file_query=query))
+    except httpx.HTTPStatusError:
+        raise InvalidFileQuery(f"Files not found. Maybe you forgot to specify mission or project flags: {query}")
     paths = file_paths_from_files(files, dest=base_dir, allow_nested=nested)
 
     if verbose:
         table = files_to_table(files, title="downloading files...")
         Console().print(table)
 
-    kleinkram.api.file_transfer.download_files(
-        client, paths, verbose=verbose, overwrite=overwrite
-    )
+    kleinkram.api.file_transfer.download_files(client, paths, verbose=verbose, overwrite=overwrite)
 
 
 def upload(
@@ -107,9 +110,9 @@ def upload(
 
     if create and mission is None:
         # check if project exists and get its id at the same time
-        project_id = kleinkram.api.routes.get_project(
-            client, query=query.project_query
-        ).id
+        project = kleinkram.api.routes.get_project(client, query=query.project_query, exact_match=True)
+        project_id = project.id
+        project_required_tags = project.required_tags
         mission_name = check_mission_query_is_creatable(query)
         kleinkram.api.routes._create_mission(
             client,
@@ -117,15 +120,14 @@ def upload(
             mission_name,
             metadata=metadata or {},
             ignore_missing_tags=ignore_missing_metadata,
+            required_tags=project_required_tags,
         )
         mission = kleinkram.api.routes.get_mission(client, query)
 
     assert mission is not None, "unreachable"
 
     filename_map = get_filename_map(file_paths)
-    kleinkram.api.file_transfer.upload_files(
-        client, filename_map, mission.id, verbose=verbose
-    )
+    kleinkram.api.file_transfer.upload_files(client, filename_map, mission.id, verbose=verbose)
 
 
 def verify(
@@ -153,12 +155,7 @@ def verify(
     # check that the mission exists
     _ = kleinkram.api.routes.get_mission(client, query)
 
-    remote_files = {
-        f.name: f
-        for f in kleinkram.api.routes.get_files(
-            client, file_query=FileQuery(mission_query=query)
-        )
-    }
+    remote_files = {f.name: f for f in kleinkram.api.routes.get_files(client, file_query=FileQuery(mission_query=query))}
     filename_map = get_filename_map(file_paths)
 
     # verify files
@@ -213,9 +210,7 @@ def update_file(*, client: AuthenticatedClient, file_id: UUID) -> None:
     raise NotImplementedError("if you have an idea what this should do, open an issue")
 
 
-def update_mission(
-    *, client: AuthenticatedClient, mission_id: UUID, metadata: Dict[str, str]
-) -> None:
+def update_mission(*, client: AuthenticatedClient, mission_id: UUID, metadata: Dict[str, str]) -> None:
     # TODO: this funciton will do more than just overwirte the metadata in the future
     kleinkram.api.routes._update_mission(client, mission_id, metadata=metadata)
 
@@ -228,9 +223,7 @@ def update_project(
     new_name: Optional[str] = None,
 ) -> None:
     # TODO: this function should do more in the future
-    kleinkram.api.routes._update_project(
-        client, project_id, description=description, new_name=new_name
-    )
+    kleinkram.api.routes._update_project(client, project_id, description=description, new_name=new_name)
 
 
 def delete_files(*, client: AuthenticatedClient, file_ids: Collection[UUID]) -> None:
@@ -247,9 +240,7 @@ def delete_files(*, client: AuthenticatedClient, file_ids: Collection[UUID]) ->
     found_ids = [f.id for f in files]
     for file_id in file_ids:
         if file_id not in found_ids:
-            raise kleinkram.errors.FileNotFound(
-                f"file {file_id} not found, did not delete any files"
-            )
+            raise kleinkram.errors.FileNotFound(f"file {file_id} not found, did not delete any files")
 
     # to prevent catastrophic mistakes from happening *again*
     assert set(file_ids) == set([file.id for file in files]), "unreachable"
@@ -268,11 +259,7 @@ def delete_files(*, client: AuthenticatedClient, file_ids: Collection[UUID]) ->
 def delete_mission(*, client: AuthenticatedClient, mission_id: UUID) -> None:
     mquery = MissionQuery(ids=[mission_id])
     mission = kleinkram.api.routes.get_mission(client, mquery)
-    files = list(
-        kleinkram.api.routes.get_files(
-            client, file_query=FileQuery(mission_query=mquery)
-        )
-    )
+    files = list(kleinkram.api.routes.get_files(client, file_query=FileQuery(mission_query=mquery)))
 
     # delete the files and then the mission
     kleinkram.api.routes._delete_files(client, [f.id for f in files], mission.id)
@@ -281,14 +268,10 @@ def delete_mission(*, client: AuthenticatedClient, mission_id: UUID) -> None:
 
 def delete_project(*, client: AuthenticatedClient, project_id: UUID) -> None:
     pquery = ProjectQuery(ids=[project_id])
-    _ = kleinkram.api.routes.get_project(client, pquery)  # check if project exists
+    _ = kleinkram.api.routes.get_project(client, pquery, exact_match=True)  # check if project exists
 
     # delete all missions and files
-    missions = list(
-        kleinkram.api.routes.get_missions(
-            client, mission_query=MissionQuery(project_query=pquery)
-        )
-    )
+    missions = list(kleinkram.api.routes.get_missions(client, mission_query=MissionQuery(project_query=pquery)))
     for mission in missions:
         delete_mission(client=client, mission_id=mission.id)
 

kleinkram/errors.py

@@ -43,9 +43,18 @@ class FileTypeNotSupported(Exception): ...
 class FileNameNotSupported(Exception): ...
 
 
+class DatatypeNotSupported(Exception): ...
+
+
 class InvalidMissionMetadata(Exception): ...
 
 
+class MissionValidationError(Exception): ...
+
+
+class ProjectValidationError(Exception): ...
+
+
 class NotAuthenticated(Exception):
     def __init__(self) -> None:
         super().__init__(LOGIN_MESSAGE)
@@ -54,3 +63,6 @@ class NotAuthenticated(Exception):
 class UpdateCLIVersion(Exception):
     def __init__(self) -> None:
         super().__init__(UPDATE_MESSAGE)
+
+
+class RunNotFound(Exception): ...

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"
@@ -41,6 +42,7 @@ class Project:
     description: str
     created_at: datetime
     updated_at: datetime
+    required_tags: List[str]
 
 
 @dataclass(frozen=True)
@@ -75,6 +77,53 @@ class File:
     state: FileState = FileState.OK
 
 
+class RunStatus(str, Enum):
+    QUEUED = "Queued"
+    IN_PROGRESS = "In Progress"
+    SUCCESS = "Success"
+    FAILED = "Failed"
+    CANCELLED = "Cancelled"
+
+
+@dataclass(frozen=True)
+class LogEntry:
+    timestamp: datetime
+    level: str
+    message: str
+
+
+@dataclass(frozen=True)
+class Run:
+    uuid: UUID
+    state: str
+    state_cause: str | None
+    artifact_url: str | None
+    created_at: datetime
+    updated_at: datetime | None
+    project_name: str
+    mission_id: UUID
+    mission_name: str
+    template_id: UUID
+    template_name: str
+    logs: List[LogEntry] = field(default_factory=list)
+
+
+@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
+
+
 # this is the file state for the verify command
 class FileVerificationStatus(str, Enum):
     UPLOADED = "uploaded"

kleinkram/printing.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import sys
+import time
 from dataclasses import asdict
 from datetime import datetime
 from pathlib import Path
@@ -13,24 +14,32 @@ from typing import Tuple
 from typing import Union
 
 import dateutil.parser
+import httpx
+import typer
 from rich.console import Console
 from rich.table import Table
 from rich.text import Text
 
+import kleinkram
+from kleinkram.api.client import AuthenticatedClient
 from kleinkram.config import get_shared_state
 from kleinkram.core import FileVerificationStatus
+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 MetadataValueType
 from kleinkram.models import Mission
 from kleinkram.models import Project
+from kleinkram.models import Run
 
 FILE_STATE_COLOR = {
     FileState.OK: "green",
     FileState.CORRUPTED: "red",
     FileState.UPLOADING: "yellow",
     FileState.ERROR: "red",
+    FileState.CONVERTING: "blue",
     FileState.CONVERSION_ERROR: "red",
     FileState.LOST: "bold red",
     FileState.FOUND: "yellow",
@@ -166,9 +175,7 @@ def missions_to_table(missions: Sequence[Mission]) -> Table:
     return table
 
 
-def files_to_table(
-    files: Sequence[File], *, title: str = "files", delimiters: bool = True
-) -> Table:
+def files_to_table(files: Sequence[File], *, title: str = "files", delimiters: bool = True) -> Table:
     table = Table(title=title)
     table.add_column("project")
     table.add_column("mission")
@@ -232,9 +239,7 @@ def file_info_table(file: File) -> Table:
     return table
 
 
-def mission_info_table(
-    mission: Mission, print_metadata: bool = False
-) -> Tuple[Table, ...]:
+def mission_info_table(mission: Mission, print_metadata: bool = True) -> Tuple[Table, ...]:
     table = Table("k", "v", title=f"mission info: {mission.name}", show_header=False)
 
     # TODO: add more fields as we store more information in the Mission object
@@ -251,9 +256,7 @@ def mission_info_table(
         return (table,)
 
     metadata_table = Table("k", "v", title="mission metadata", show_header=False)
-    kv_pairs_sorted = sorted(
-        [(k, v) for k, v in mission.metadata.items()], key=lambda x: x[0]
-    )
+    kv_pairs_sorted = sorted([(k, v) for k, v in mission.metadata.items()], key=lambda x: x[0])
     for k, v in kv_pairs_sorted:
         metadata_table.add_row(k, str(parse_metadata_value(v)))
 
@@ -269,6 +272,7 @@ def project_info_table(project: Project) -> Table:
     table.add_row("description", project.description)
     table.add_row("created", str(project.created_at))
     table.add_row("updated", str(project.updated_at))
+    table.add_row("required tags", ", ".join(project.required_tags))
 
     return table
 
@@ -284,9 +288,7 @@ def file_verification_status_table(
     return table
 
 
-def print_file_verification_status(
-    file_status: Mapping[Path, FileVerificationStatus], *, pprint: bool
-) -> None:
+def print_file_verification_status(file_status: Mapping[Path, FileVerificationStatus], *, pprint: bool) -> None:
     """\
     prints the file verification status to stdout / stderr
     either using pprint or as a list for piping
@@ -296,9 +298,7 @@ def print_file_verification_status(
         Console().print(table)
     else:
         for path, status in file_status.items():
-            stream = (
-                sys.stdout if status == FileVerificationStatus.UPLOADED else sys.stderr
-            )
+            stream = sys.stdout if status == FileVerificationStatus.UPLOADED else sys.stderr
             print(path, file=stream, flush=True)
 
 
@@ -383,3 +383,213 @@ def print_project_info(project: Project, *, pprint: bool) -> None:
         for key in project_dct:
             project_dct[key] = str(project_dct[key])  # TODO: improve this
         print(json.dumps(project_dct))
+
+
+def runs_to_table(runs: Sequence[Run]) -> Table:
+    table = Table(title="action runs")
+    table.add_column("project")
+    table.add_column("mission")
+    table.add_column("template")
+    table.add_column("run id")
+    table.add_column("status")
+    table.add_column("created")
+
+    # order by created_at descending
+    runs_sorted = sorted(runs, key=lambda r: r.created_at, reverse=True)
+
+    max_table_size = get_shared_state().max_table_size
+    for run in runs_sorted[:max_table_size]:
+        table.add_row(
+            run.project_name,
+            run.mission_name,
+            run.template_name,
+            Text(str(run.uuid), style="green"),
+            run.state,
+            str(run.created_at),
+        )
+
+    if len(list(runs)) > max_table_size:
+        _add_placeholder_row(table, skipped=len(runs) - max_table_size)
+    return table
+
+
+def run_info_table(run: Run) -> Table:
+    table = Table("k", "v", title=f"run info: {run.uuid}", show_header=False)
+
+    table.add_row("id", Text(str(run.uuid), style="green"))
+    table.add_row("template", run.template_name)
+    table.add_row("status", run.state)
+    table.add_row("project", run.project_name)
+    table.add_row("mission", run.mission_name)
+    table.add_row("created", str(run.created_at))
+
+    finished = str(run.updated_at) if run.updated_at else "N/A"
+    table.add_row("updated", finished)
+
+    return table
+
+
+def print_runs_table(runs: Sequence[Run], *, pprint: bool) -> None:
+    """
+    Prints the runs to stdout
+    either using pprint or as a list for piping
+    """
+    if pprint:
+        table = runs_to_table(runs)
+        Console().print(table)
+    else:
+        for run in runs:
+            print(run.uuid)
+
+
+def print_run_info(run: Run, *, pprint: bool) -> None:
+    """
+    Prints the run info to stdout
+    either using pprint or as JSON for piping
+    """
+    if pprint:
+        Console().print(run_info_table(run))
+    else:
+        run_dict = asdict(run)
+        for key in run_dict:
+            run_dict[key] = str(run_dict[key])  # simple serialization
+        print(json.dumps(run_dict))
+
+
+LOG_LEVEL_COLORS = {
+    "DEBUG": typer.colors.CYAN,
+    "INFO": typer.colors.GREEN,
+    "WARNING": typer.colors.YELLOW,
+    "ERROR": typer.colors.RED,
+    "CRITICAL": typer.colors.BRIGHT_RED,
+    "STDOUT": typer.colors.BRIGHT_BLACK,
+    "STDERR": typer.colors.RED,
+}
+
+
+def pretty_print_log(entry: LogEntry) -> None:
+    """
+    Prints a single LogEntry object to the console with
+    colors and standardized formatting.
+
+    This version correctly handles carriage returns (from tqdm)
+    and empty lines.
+    """
+    # Clean up the level name, just in case
+    level = entry.level.upper().strip()
+    color = LOG_LEVEL_COLORS.get(level, typer.colors.WHITE)
+    timestamp_str = entry.timestamp.strftime("%Y-%m-%d %H:%M:%S")
+    level_str = f"[{level.ljust(8)}]"
+    message = entry.message.strip()
+
+    if not message:
+        return
+
+    typer.secho(f"[{timestamp_str}] {level_str} ", fg=color, nl=False)
+    typer.echo(message)
+
+
+def print_run_logs(logs: Sequence[LogEntry], *, pprint: bool) -> None:
+    """
+    Prints a sequence of LogEntry objects to the console.
+    (This function is unchanged, as the logic is fully
+    contained in pretty_print_log.)
+    """
+    if not logs:
+        typer.secho("No logs found for this run.", fg=typer.colors.YELLOW)
+        return
+
+    for log_entry in logs:
+        if pprint:
+            pretty_print_log(log_entry)
+        else:
+            typer.echo(f"[{log_entry.timestamp}] {log_entry.message}")
+
+
+def action_templates_to_table(templates: Sequence[ActionTemplate]) -> Table:
+    """Creates a rich Table for a list of ActionTemplates."""
+    table = Table(title="Available Action Templates")
+
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("ID (UUID)", style="magenta")
+    table.add_column("Image Name", style="green")
+    table.add_column("Command", style="cyan")
+
+    for template in templates:
+        uuid_text = Text(str(template.uuid), style="magenta")
+        table.add_row(template.name, uuid_text, template.image_name, template.command)
+
+    return table
+
+
+def print_action_templates_table(templates: Sequence[ActionTemplate], *, pprint: bool) -> None:
+    """
+    Prints the action templates to stdout
+    either using rich or as a simple list of IDs for piping.
+    """
+    if not templates:
+        typer.echo("No action templates found.")
+        return
+
+    if pprint:
+        table = action_templates_to_table(templates)
+        Console().print(table)
+    else:
+        for template in templates:
+            print(template.uuid)
+
+
+def follow_run_logs(client: AuthenticatedClient, run_uuid: str) -> int:
+    """
+    Polls the API for run details and prints new logs as they arrive.
+
+    Returns:
+        An exit code (0 for success, 1 for failure).
+    """
+    typer.echo(f"Following logs for run {run_uuid}...")
+
+    TERMINAL_STATES = {"DONE", "FAILED", "UNPROCESSABLE"}
+    printed_log_count = 0
+    current_run_state = None
+    exit_code = 0  # Assume success
+
+    try:
+        while current_run_state not in TERMINAL_STATES:
+            try:
+                run_details: Run = kleinkram.api.routes.get_run(client, run_uuid)
+                current_run_state = run_details.state.upper()
+
+                # Print only new logs
+                new_logs = run_details.logs[printed_log_count:]
+                if new_logs:
+                    # Always pretty-print when following
+                    print_run_logs(new_logs, pprint=True)
+                    printed_log_count = len(run_details.logs)
+
+                if current_run_state in TERMINAL_STATES:
+                    color = typer.colors.GREEN if run_details.state.upper() == "DONE" else typer.colors.RED
+                    typer.secho(
+                        f"\nRun finished with state: {run_details.state} ({run_details.state_cause})",
+                        fg=color,
+                    )
+                    if run_details.state.upper() != "DONE":
+                        exit_code = 1  # Set failure exit code
+                    break
+
+                time.sleep(2)  # Poll every 2 seconds
+
+            except kleinkram.errors.RunNotFound:
+                time.sleep(1)
+            except httpx.HTTPStatusError as e:
+                typer.secho(f"Error fetching run status: {e}", fg=typer.colors.RED)
+                time.sleep(5)  # Wait longer on API errors
+
+    except KeyboardInterrupt:
+        typer.secho(
+            f"\nStopped following logs. Run {run_uuid} is still processing.",
+            fg=typer.colors.YELLOW,
+        )
+        # Return 0, as the command itself wasn't a failure
+        return 0
+
+    return exit_code

kleinkram/utils.py

@@ -28,15 +28,11 @@ from kleinkram.types import IdLike
 from kleinkram.types import PathLike
 
 INTERNAL_ALLOWED_CHARS = string.ascii_letters + string.digits + "_" + "-"
-SUPPORT_FILE_TYPES = [
-    ".bag",
-    ".mcap",
-]
+SUPPORT_FILE_TYPES = [".bag", ".mcap", ".db3", ".svo2", ".tum", ".yaml", ".yml"]
+EXPERIMENTAL_FILE_TYPES = []
 
 
-def file_paths_from_files(
-    files: Sequence[File], *, dest: Path, allow_nested: bool = False
-) -> Dict[Path, File]:
+def file_paths_from_files(files: Sequence[File], *, dest: Path, allow_nested: bool = False) -> Dict[Path, File]:
     """\
     determines the destinations for a sequence of `File` objects,
     possibly nested by project and mission
@@ -46,10 +42,7 @@ def file_paths_from_files(
     elif not allow_nested:
         return {dest / file.name: file for file in files}
     else:
-        return {
-            dest / file.project_name / file.mission_name / file.name: file
-            for file in files
-        }
+        return {dest / file.project_name / file.mission_name / file.name: file for file in files}
 
 
 def upper_camel_case_to_words(s: str) -> List[str]:
@@ -89,13 +82,10 @@ def check_file_path(file: Path) -> None:
     if not file.exists():
         raise FileNotFoundError(f"{file} does not exist")
     if file.suffix not in SUPPORT_FILE_TYPES:
-        raise FileTypeNotSupported(
-            f"only {', '.join(SUPPORT_FILE_TYPES)} files are supported: {file}"
-        )
+        raise FileTypeNotSupported(f"only {', '.join(SUPPORT_FILE_TYPES)} files are supported: {file}")
     if not check_filename_is_sanatized(file.stem):
         raise FileNameNotSupported(
-            f"only `{''.join(INTERNAL_ALLOWED_CHARS)}` are "
-            f"allowed in filenames and at most 50chars: {file}"
+            f"only `{''.join(INTERNAL_ALLOWED_CHARS)}` are " f"allowed in filenames and at most 50chars: {file}"
         )
 
 
@@ -108,9 +98,7 @@ def format_error(msg: str, exc: Exception, *, verbose: bool = False) -> str:
 
 
 def format_traceback(exc: Exception) -> str:
-    return "".join(
-        traceback.format_exception(type(exc), value=exc, tb=exc.__traceback__)
-    )
+    return "".join(traceback.format_exception(type(exc), value=exc, tb=exc.__traceback__))
 
 
 def styled_string(*objects: Any, **kwargs: Any) -> str:
@@ -150,9 +138,7 @@ def get_filename(path: Path) -> str:
         - the 10 hashed chars are deterministic given the original filename
     """
 
-    stem = "".join(
-        char if char in INTERNAL_ALLOWED_CHARS else "_" for char in path.stem
-    )
+    stem = "".join(char if char in INTERNAL_ALLOWED_CHARS else "_" for char in path.stem)
 
     if len(stem) > 50:
         hash = md5(path.name.encode()).hexdigest()