adalab-cli 3.0.0__tar.gz → 3.2.0__tar.gz

{adalab_cli-3.0.0 → adalab_cli-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: adalab-cli
-Version: 3.0.0
+Version: 3.2.0
 Summary: The CLI app to interact with AdaLab.
 Home-page: https://adamatics.com
 Author: Adamatics ApS
@@ -16,8 +16,9 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Dist: adalib (>=5.0.0)
+Requires-Dist: adalib (>=7.2.0)
 Requires-Dist: adalib-auth (>=1.2.2)
+Requires-Dist: ascii-magic (>=2.3.0)
 Requires-Dist: loguru (>=0.7.2)
 Requires-Dist: prompt-toolkit (>=3.0.47)
 Requires-Dist: sh (>=2.0.6)

{adalab_cli-3.0.0 → adalab_cli-3.2.0}/adalab_cli/cli/app.py

@@ -28,13 +28,15 @@ from .gallery_commands import gallery_app
 from .interactive import interactive_mode
 from .logger import Logger
 from .login_commands import load_config
+from .logs_commands import logs_app
+from .pictures_commands import pictures_app
 from .schedule_commands import schedules_app
 from .user_commands import user_app
 
 app = typer.Typer(no_args_is_help=False)
 
 
-@app.callback("adalab", invoke_without_command=True, no_args_is_help=True)
+@app.callback(invoke_without_command=True, no_args_is_help=True)
 def main(
     token: str = typer.Option(None, help="User token for authentication"),
     adalab_url: str = typer.Option(None, help="URL of the AdaLab server"),
@@ -189,3 +191,17 @@ app.add_typer(
     help="Commands for interacting with schedules.",
     no_args_is_help=True,
 )
+
+app.add_typer(
+    logs_app,
+    name="logs",
+    help="Commands for fetching AdaLab logs.",
+    no_args_is_help=True,
+)
+
+app.add_typer(
+    pictures_app,
+    name="pictures",
+    help="Commands for handling pictures in AdaLab.",
+    no_args_is_help=True,
+)

adalab_cli-3.2.0/adalab_cli/cli/completion_tree.py

@@ -0,0 +1,143 @@
+"""Map of the CLI commands and subcommands for the CLI completion tree."""
+
+completion_tree = {
+    "cards": {
+        "toggle-review": {"help": None, "exit": None},
+        "expose-card": {"help": None, "exit": None},
+        "get-card": {"help": None, "--incl-content": None, "exit": None},
+        "hide-card": {"help": None, "exit": None},
+        "list-cards": {
+            "all": {
+                "--search-phrase": None,
+                "--group-category": None,
+                "--only-hidden": None,
+                "--only-exposed": None,
+                "help": None,
+                "exit": None,
+            },
+            "notebook": {
+                "--search-phrase": None,
+                "--group-category": None,
+                "--only-hidden": None,
+                "--only-exposed": None,
+                "help": None,
+                "exit": None,
+            },
+            "voila": {
+                "--search-phrase": None,
+                "--group-category": None,
+                "--only-hidden": None,
+                "--only-exposed": None,
+                "help": None,
+                "exit": None,
+            },
+            "url": {
+                "--search-phrase": None,
+                "--group-category": None,
+                "--url-subtype": None,
+                "--only-hidden": None,
+                "--only-exposed": None,
+                "help": None,
+                "exit": None,
+            },
+            "group": {
+                "--search-phrase": None,
+                "--group-category": None,
+                "--only-hidden": None,
+                "--only-exposed": None,
+                "help": None,
+                "exit": None,
+            },
+            "help": None,
+            "exit": None,
+        },
+        "help": None,
+        "exit": None,
+    },
+    "databases": {
+        "list-databases": {"--no-pretty": None, "help": None},
+        "list-datasets": {"--no-pretty": None, "--return-sql": None, "help": None},
+        "list-tables": {"--no-pretty": None, "help": None},
+        "view-dataset": {"--head": None, "--no-pretty": None, "help": None},
+        "help": None,
+        "exit": None,
+    },
+    "logs": {
+        "app": {
+            "--container": None,
+            "--container-index": None,
+            "--from": None,
+            "--source": None,
+            "--to": None,
+            "help": None,
+            "exit": None,
+        },
+        "build": {"--source": None, "help": None},
+        "lab": {"--from": None, "--source": None, "--to": None, "help": None},
+        "publish": {"--source": None, "help": None},
+        "run": {"help": None},
+        "help": None,
+        "exit": None,
+    },
+    "schedules": {
+        "list-schedules": {
+            "--only-active": None,
+            "--search-phrase": None,
+            "help": None,
+            "exit": None,
+        },
+        "get-schedule": {"--incl-content": None, "help": None},
+        "create-schedule": {
+            "--schedule": None,
+            "--pool": None,
+            "--active": None,
+            "--concurrent": None,
+            "--cleanup": None,
+            "--timeout": None,
+            "help": None,
+            "exit": None,
+        },
+        "delete-run": {"help": None, "exit": None},
+        "delete-schedule": {"help": None, "exit": None},
+        "start-run": {
+            "--cleanup": None,
+            "--pool": None,
+            "--timeout": None,
+            "help": None,
+            "exit": None,
+        },
+        "stop-run": {"help": None, "exit": None},
+        "update-schedule": {
+            "--schedule": None,
+            "--pool": None,
+            "--active": None,
+            "--concurrent": None,
+            "--cleanup": None,
+            "--timeout": None,
+            "help": None,
+            "exit": None,
+        },
+        "help": None,
+        "exit": None,
+    },
+    "user": {
+        "whoami": {
+            "--full-information": None,
+            "--with-notifications": None,
+            "help": None,
+            "exit": None,
+        },
+        "help": None,
+        "exit": None,
+    },
+    "pictures": {
+        "show": {"help": None, "exit": None},
+        "download": {"--output-path": None, "help": None, "exit": None},
+        "create": {"--path": None, "--url": None, "help": None, "exit": None},
+        "help": None,
+        "exit": None,
+    },
+    "version": None,
+    "help": None,
+    "exit": None,
+}

{adalab_cli-3.0.0 → adalab_cli-3.2.0}/adalab_cli/cli/databases_commands.py

@@ -204,7 +204,7 @@ def list_tables(
     utils.print_dataframe(dataframe=tables, pretty=pretty, title=f"Tables in database {db_index}")
 
 
-@db_app.callback("callback", invoke_without_command=True)
+@db_app.callback(invoke_without_command=True)
 def main(
     interactive: bool = typer.Option(
         False, "-i", "--interactive", help="Activate interactive mode"

{adalab_cli-3.0.0 → adalab_cli-3.2.0}/adalab_cli/cli/gallery_commands.py

@@ -38,26 +38,65 @@ def gallery_list_cards(
         typer.Argument(
             help="The type of cards to list. " "Choose from [all, notebook, voila, url, group].",
         ),
-    ]
+    ] = "all",
+    head: Annotated[int | None, typer.Option(help="Number of cards to display.")] = None,
+    url_subtype: Annotated[
+        str,
+        typer.Option(
+            help="The URL subtype to filter by.",
+        ),
+    ] = "all",
+    search_phrase: Annotated[str, typer.Option(help="Search phrase to filter cards by.")] = None,
+    group_category: Annotated[str, typer.Option(help="Group category to filter by.")] = None,
+    only_hidden: Annotated[bool, typer.Option(help="Show only hidden cards.")] = False,
+    only_exposed: Annotated[bool, typer.Option(help="Show only exposed cards.")] = False,
 ):
     """
-    Prints all cards from the Gallery with the type CARD_TYPE.
+    Prints all cards from the Gallery with the type CARD_TYPE. Optionally filter by URL_SUBTYPE
+    for URL cards.
     """
     try:
         with Progress(
             SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True
         ) as progress:
             progress.add_task(description="Fetching data...", total=None)
-            cards = get_cards(card_type=card_type)
+            cards = get_cards(
+                card_type=card_type,
+                url_subtype=url_subtype,
+                head=head,
+                search_phrase=search_phrase,
+                group_category=group_category,
+                only_hidden=only_hidden,
+                only_exposed=only_exposed,
+            )
     except Exception as e:
         logger.error(f"Error: {str(e)}")
         sys.exit()
 
     rich_print(f"Card type: {card_type} ({len(cards)})")
 
-    table = Table("Card id", "Card type", "Card name", "Card author", title="Cards")
+    cols = (
+        [("Card id", 0), ("Card type", 1)]
+        + ([("URL type", 2)] if card_type == "url" else [])
+        + [("Reviewed", 3), ("Exposed", 4), ("Card name", 5)]
+        + ([("Cards in Group", 6)] if card_type == "group" else [])
+        + [("Card author", 7)]
+    )
+    table = Table(
+        *[x[0] for x in cols],
+        title="Cards",
+    )
     for card in cards:
-        table.add_row(str(card[0]), card[1], card[2], card[3])
+        table.add_row(
+            *[
+                (
+                    str(card[ind])
+                    if _cname not in ["Reviewed", "Exposed"]
+                    else ("✅" if card[ind] else "❌")
+                )
+                for _cname, ind in cols
+            ]
+        )
     console = Console()
     console.print(table)
 
@@ -70,6 +109,9 @@ def gallery_get_card(
             help="The ID of the card you want to retrieve.",
         ),
     ],
+    incl_content: Annotated[
+        bool, typer.Option(help="Include card content in the output.")
+    ] = False,
 ):
     """
     Gets the contents of a card identified by CARD_ID.
@@ -81,12 +123,22 @@ def gallery_get_card(
             transient=True,
         ) as progress:
             progress.add_task(description="Fetching data...", total=None)
-            card = get_card_contents(card_id=card_id)
+            card = get_card_contents(card_id=card_id, incl_content=incl_content)
     except Exception:
         rich_print(f"Card {card_id} [bold red]failed[/bold red] to retrieve.")
         sys.exit(1)
 
-    rich_print(card)
+    console = Console()
+
+    table = Table(title="Card Details")
+    table.add_column("Property", style="cyan", no_wrap=True)
+    table.add_column("Value", style="magenta")
+    for key, value in card.items():
+        if isinstance(value, bool):
+            value = "✅" if value else "❌"
+        table.add_row(key, str(value) if value != [] else "[dim]Empty List[/dim]")
+
+    console.print(table)
 
 
 @gallery_app.command("expose-card", no_args_is_help=True)
@@ -149,7 +201,7 @@ def gallery_toggle_card_review(
     rich_print(f"Card {card_id} review status [bold green]updated[/bold green] successfully.")
 
 
-@gallery_app.callback("callback", invoke_without_command=True)
+@gallery_app.callback(invoke_without_command=True)
 def main(
     interactive: bool = typer.Option(
         False, "-i", "--interactive", help="Activate interactive mode"

adalab_cli-3.2.0/adalab_cli/cli/logs_commands.py

@@ -0,0 +1,337 @@
+"""Logs command group for the adalib CLI.
+
+This submodule encompasses commands related to AdaLab logs
+in the adalib CLI. It uses Typer for command line interface implementation,
+allowing the user to retrieve different types of logs.
+
+Functions:
+
+"""
+
+import sys
+
+import typer
+from adalib.apps import get_app, get_app_logs
+from adalib.harbor import get_publish_logs
+from adalib.lab import get_build_logs, get_lab_logs
+from adalib.schedules import get_run_logs
+from loguru import logger
+from prompt_toolkit.completion import NestedCompleter
+from rich import print as rich_print
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+from typing_extensions import Annotated
+
+from .completion_tree import completion_tree
+from .factory import check_authentication
+from .interactive import interactive_mode
+
+logs_app = typer.Typer()
+
+
+@logs_app.command("app", no_args_is_help=True)
+def logs_get_app_logs(
+    app_id: Annotated[
+        str,
+        typer.Argument(
+            help="The ID of the app to fetch logs for.",
+        ),
+    ],
+    container: Annotated[
+        str,
+        typer.Option(
+            "-c",
+            "--container",
+            help="The name of the container whose logs to fetch.",
+        ),
+    ] = "",
+    container_idx: Annotated[
+        int,
+        typer.Option(
+            "-i",
+            "--container-index",
+            help="The index of the container whose logs to fetch.",
+        ),
+    ] = 0,
+    from_date: Annotated[
+        str,
+        typer.Option(
+            "-f",
+            "--from",
+            help="The start date for the logs, in ISO format (YYYY-MM-DDTHH:mm:ss+HH:mm).",
+        ),
+    ] = "",
+    source: Annotated[
+        str,
+        typer.Option(
+            "-s",
+            "--source",
+            help="The source of the logs. One of 'container' or 'system'.",
+        ),
+    ] = "container",
+    to_date: Annotated[
+        str,
+        typer.Option(
+            "-t",
+            "--to",
+            help="The end date for the logs, in ISO format (YYYY-MM-DDTHH:mm:ss+HH:mm).",
+        ),
+    ] = "",
+):
+    """
+    Fetches logs for the app with the given ID.
+    """
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(description="Fetching data...", total=None)
+            tmp = get_app(app_id)
+            app_name = tmp["name"]
+            logs = get_app_logs(
+                app_id,
+                container=container,
+                container_idx=container_idx,
+                from_date=from_date,
+                source=source,
+                to_date=to_date,
+            )
+    except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        sys.exit()
+
+    rich_print(f"{source.capitalize()} logs for app: {app_name} ({len(logs)})")
+
+    table = Table("Timestamp", "Log message", title="Logs")
+    for log in logs:
+        table.add_row(log["time"], log["message"])
+
+    console = Console()
+    console.print(table)
+
+
+@logs_app.command("build", no_args_is_help=True)
+def logs_get_build_logs(
+    build_id: Annotated[
+        int,
+        typer.Argument(
+            help="The ID of the build process to fetch logs for.",
+        ),
+    ],
+    source: Annotated[
+        str,
+        typer.Option(
+            "-s",
+            "--source",
+            help="The source of the logs. One of 'build' or 'system'.",
+        ),
+    ] = "build",
+):
+    """
+    Fetches logs for the build with the given ID.
+    """
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(description="Fetching data...", total=None)
+            logs = get_build_logs(
+                build_id=build_id,
+                source=source,
+            )
+    except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        sys.exit()
+
+    rich_print(f"{source.capitalize()} logs for build process: {build_id} ({len(logs)})")
+
+    if len(logs[0].keys()) == 2:
+        table = Table("Timestamp", "Log message", title="Logs")
+        for log in logs:
+            table.add_row(log["time"], log["message"])
+    else:
+        table = Table("Timestamp", "Input", "Output", title="Logs")
+        for log in logs:
+            table.add_row(log["time"], log["input"], log["output"])
+
+    console = Console()
+    console.print(table)
+
+
+@logs_app.command("lab", no_args_is_help=True)
+def logs_get_lab_logs(
+    from_date: Annotated[
+        str,
+        typer.Option(
+            "-f",
+            "--from",
+            help="The start date for the logs, in ISO format (YYYY-MM-DDTHH:mm:ss+HH:mm).",
+        ),
+    ] = "",
+    source: Annotated[
+        str,
+        typer.Option(
+            "-s",
+            "--source",
+            help="The source of the logs. One of 'user' or 'system'.",
+        ),
+    ] = "user",
+    to_date: Annotated[
+        str,
+        typer.Option(
+            "-t",
+            "--to",
+            help="The end date for the logs, in ISO format (YYYY-MM-DDTHH:mm:ss+HH:mm).",
+        ),
+    ] = "",
+):
+    """
+    Fetches logs for the user's Lab instance.
+    """
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(description="Fetching data...", total=None)
+            logs = get_lab_logs(
+                from_date=from_date,
+                source=source,
+                to_date=to_date,
+            )
+    except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        sys.exit()
+
+    rich_print(f"{source.capitalize()} Lab logs ({len(logs)})")
+
+    table = Table("Timestamp", "Log message", title="Logs")
+    for log in logs:
+        table.add_row(log["time"], log["message"])
+
+    console = Console()
+    console.print(table)
+
+
+@logs_app.command("publish", no_args_is_help=True)
+def logs_get_publish_logs(
+    metadata_id: Annotated[
+        int,
+        typer.Argument(
+            help="The ID of the publish process to fetch logs for.",
+        ),
+    ],
+    source: Annotated[
+        str,
+        typer.Option(
+            "-s",
+            "--source",
+            help="The source of the logs. One of 'publish' or 'system'.",
+        ),
+    ] = "publish",
+):
+    """
+    Fetches logs for the publish process with the given ID.
+    """
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(description="Fetching data...", total=None)
+            logs = get_publish_logs(
+                metadata_id=metadata_id,
+                source=source,
+            )
+    except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        sys.exit()
+
+    rich_print(
+        f"{source.capitalize()} logs for publish process of metadata {metadata_id} ({len(logs)})"
+    )
+
+    if len(logs[0].keys()) == 2:
+        table = Table("Timestamp", "Log message", title="Logs")
+        for log in logs:
+            table.add_row(log["time"], log["message"])
+    else:
+        table = Table("Timestamp", "Input", "Output", title="Logs")
+        for log in logs:
+            table.add_row(log["time"], log["input"], log["output"])
+
+    console = Console()
+    console.print(table)
+
+
+@logs_app.command("run", no_args_is_help=True)
+def logs_get_run_logs(
+    schedule_id: Annotated[
+        int,
+        typer.Argument(
+            help="The ID of the schedule to fetch logs for.",
+        ),
+    ],
+    run_id: Annotated[
+        int,
+        typer.Argument(
+            help="The ID of the run instance to fetch logs for.",
+        ),
+    ],
+):
+    """
+    Fetches logs for the schedule run instance with the given ID.
+    """
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(description="Fetching data...", total=None)
+            logs = get_run_logs(
+                schedule_id=schedule_id,
+                run_id=run_id,
+            )
+    except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        sys.exit()
+
+    rich_print(f"Logs for run process {run_id} of schedule {schedule_id} ({len(logs)})")
+
+    table = Table("Timestamp", "Source", "Input", "Output", "Cell number", title="Logs")
+    for log in logs:
+        table.add_row(
+            log["timestamp"],
+            log["log_type"],
+            log["input"] or "",
+            log["output"] or "",
+            str(log["cell_number"]) or "",
+        )
+
+    console = Console()
+    console.print(table)
+
+
+@logs_app.callback(invoke_without_command=True)
+def main(
+    interactive: bool = typer.Option(
+        False, "-i", "--interactive", help="Activate interactive mode"
+    )
+):
+    if interactive:
+        interactive_mode(
+            this_app=logs_app,
+            title="logs",
+            color="maroon",
+            completion=NestedCompleter.from_nested_dict(completion_tree["logs"]),
+        )
+    else:
+        check_authentication()

adalab_cli-3.2.0/adalab_cli/cli/pictures_commands.py

@@ -0,0 +1,85 @@
+"""Pictures-related commands"""
+
+import sys
+from io import BytesIO
+from typing import Annotated
+
+import typer
+from adalib.adaboard import request_adaboard
+from adalib.pictures import get_picture, post_picture, post_picture_url
+from ascii_magic import AsciiArt
+from prompt_toolkit.completion import NestedCompleter
+from rich import print as rich_print
+
+from .completion_tree import completion_tree
+from .factory import check_authentication
+from .interactive import interactive_mode
+
+pictures_app = typer.Typer()
+
+
+@pictures_app.command("show", no_args_is_help=True)
+def show_picture(picture_id: Annotated[int, typer.Argument(help="The ID of the picture to show")]):
+    """Show the specific picture as an ASCII art"""
+    try:
+        data = BytesIO(request_adaboard(f"image/{picture_id}").content)
+        AsciiArt.from_image(data).to_terminal()
+    except Exception:
+        rich_print(f"Could not show the picture with ID: {picture_id}")
+        sys.exit(1)
+
+
+@pictures_app.command("download", no_args_is_help=True)
+def download_picture(
+    picture_id: Annotated[int, typer.Argument(help="The ID of the picture to download")],
+    output_path: Annotated[
+        str | None, typer.Option(help="The path to save the picture to")
+    ] = None,
+):
+    """Download the specific picture into a file."""
+    if output_path is None:
+        output_path = f"picture_{picture_id}"
+    try:
+        get_picture(picture_id=picture_id, output_file_path=output_path)
+    except Exception:
+        rich_print(f"Could not download the picture with ID: {picture_id}")
+        sys.exit(1)
+
+
+@pictures_app.command("create", no_args_is_help=True)
+def create_new_picture(
+    path: Annotated[str | None, typer.Option(help="The path to the picture file")] = None,
+    url: Annotated[str | None, typer.Option(help="The URL of the picture")] = None,
+):
+    """Create a new picture from a file or URL."""
+    if (path is not None and url is not None) or (path is None and url is None):
+        rich_print("Please provide either a path or a URL to create a picture.")
+        sys.exit(1)
+
+    try:
+        if path is not None:
+            picture_id = post_picture(input_file_path=path)
+        else:
+            picture_id = post_picture_url(picture_url=url)
+
+        rich_print(f"Picture created with ID: {picture_id}")
+    except Exception:
+        rich_print("Could not create the picture.")
+        sys.exit(1)
+
+
+@pictures_app.callback(invoke_without_command=True)
+def main(
+    interactive: bool = typer.Option(
+        False, "-i", "--interactive", help="Activate interactive mode"
+    )
+):
+    if interactive:
+        interactive_mode(
+            this_app=pictures_app,
+            title="pictures",
+            color="maroon",
+            completion=NestedCompleter.from_nested_dict(completion_tree["pictures"]),
+        )
+    else:
+        check_authentication()

{adalab_cli-3.0.0 → adalab_cli-3.2.0}/adalab_cli/cli/schedule_commands.py

@@ -10,10 +10,11 @@ Functions:
 
 """
 
+import base64
 import sys
 
 import typer
-from adalib.adaboard import get_user
+from adalib.adaboard import get_all_pages, get_user, request_adaboard
 from adalib.schedules import (
     create_schedule,
     delete_run,
@@ -24,6 +25,7 @@ from adalib.schedules import (
 )
 from prompt_toolkit.completion import NestedCompleter
 from rich import print as rich_print
+from rich.table import Table
 from typing_extensions import Annotated
 
 from .completion_tree import completion_tree
@@ -33,6 +35,93 @@ from .interactive import interactive_mode
 schedules_app = typer.Typer()
 
 
+@schedules_app.command("list-schedules", no_args_is_help=False)
+def list_all_schedules(
+    only_active: Annotated[bool, typer.Option(help="Include only active schedules")] = False,
+    search_phrase: Annotated[str, typer.Option(help="Search phrase to filter schedules")] = None,
+):
+    """Lists all available schedules."""
+    params = dict()
+    if only_active:
+        params = {"only_active": True}
+
+    if search_phrase is not None:
+        params["search"] = search_phrase
+
+    try:
+        res = get_all_pages("schedules/v2", params=params)
+    except Exception:
+        rich_print("Failed to list schedules.")
+        sys.exit(1)
+
+    cols = ["ID", "Name", "Owner", "Cron", "Pool", "Active", "Last Run", "Next Run"]
+    table = Table(
+        *[x for x in cols],
+        title="Schedules",
+    )
+    for row in res:
+        table.add_row(
+            str(row["schedule_id"]),
+            row["name"],
+            row["owner"]["name"],
+            row["cron"],
+            row["pool"],
+            "✅" if row["active"] else "❌",
+            row["last_scheduled_ts"] or "N/A",
+            row["next_scheduled_ts"] or "N/A",
+        )
+    rich_print(table)
+
+
+@schedules_app.command("get-schedule", no_args_is_help=True)
+def get_single_schedule(
+    schedule_id: Annotated[int, typer.Argument(help="ID of the schedule.")],
+    incl_content: Annotated[bool, typer.Option(help="Include the schedule content.")] = False,
+):
+    """Retrieves the details of a single schedule."""
+    params = {"with_content": incl_content}
+    try:
+        res = request_adaboard(f"schedules/v2/{schedule_id}", params=params).json()
+    except Exception:
+        rich_print(f"Failed to get schedule {schedule_id}.")
+        sys.exit(1)
+
+    if res["content"]:
+        for _content in res["content"]:
+            _content["content"] = base64.b64decode(_content["content"]).decode("utf-8")
+
+    schedule = {
+        "ID": schedule_id,
+        "Name": res["name"],
+        "Owner": res["owner"]["name"],
+        "Runner": res["runner"]["name"],
+        "Timeout": res["timeout"],
+        "Pool": res["pool"],
+        "Active": "✅" if res["active"] else "❌",
+        "Timezone": res["timezone"],
+        "Cron": res["cron"],
+        "Last Run": res["last_scheduled_ts"] or "N/A",
+        "Next Run": res["next_scheduled_ts"] or "N/A",
+        "Concurrent": "✅" if res["concurrent"] else "❌",
+        "Cleanup": "✅" if res["cleanup"] else "❌",
+        "Contents": res["content"],
+        "Inputs": res["run_config"]["inputs"],
+        "Pre-run script": res["run_config"]["scripts"]["pre_run_script"] or "N/A",
+        "Post-run script": res["run_config"]["scripts"]["post_run_script"] or "N/A",
+        "Kernel ID": res["kernel_metadata_id"],
+    }
+
+    table = Table(title="Schedule Details")
+    table.add_column("Property", style="cyan", no_wrap=True)
+    table.add_column("Value", style="magenta")
+    for key, value in schedule.items():
+        if isinstance(value, bool):
+            value = "✅" if value else "❌"
+        table.add_row(key, str(value) if value != [] else "[dim]Empty List[/dim]")
+
+    rich_print(table)
+
+
 @schedules_app.command("start-run", no_args_is_help=True)
 def notebooks_start_run(
     schedule_id: Annotated[int, typer.Argument(help="ID of the schedule to start run.")]
@@ -172,7 +261,7 @@ def notebooks_delete_schedule(
         sys.exit(1)
 
 
-@schedules_app.callback("interactive", invoke_without_command=True)
+@schedules_app.callback(invoke_without_command=True)
 def main(
     interactive: bool = typer.Option(
         False, "-i", "--interactive", help="Activate interactive mode"

{adalab_cli-3.0.0 → adalab_cli-3.2.0}/adalab_cli/cli/user_commands.py

@@ -58,7 +58,7 @@ def user_who_am_i_in_adalab(
     console.print(table)
 
 
-@user_app.callback("interactive", invoke_without_command=True)
+@user_app.callback(invoke_without_command=True)
 def main(
     interactive: bool = typer.Option(
         False, "-i", "--interactive", help="Activate interactive mode"

{adalab_cli-3.0.0 → adalab_cli-3.2.0}/pyproject.toml

@@ -1,8 +1,8 @@
 [project]
 name = "adalab-cli"
-version = "3.0.0"
+version = "3.2.0"
 description = "The CLI app to interact with AdaLab."
-keywords = [ "cli",]
+keywords = ["cli"]
 
 [[project.authors]]
 name = "Adamatics ApS"
@@ -10,35 +10,34 @@ email = "info@adamatics.com"
 
 [tool.poetry]
 name = "adalab-cli"
-version = "3.0.0"
+version = "3.2.0"
 description = "The CLI app to interact with AdaLab."
 authors = ["Adamatics ApS <info@adamatics.com>"]
 readme = "README.md"
 homepage = "https://adamatics.com"
 repository = "https://gitlab.com/adamatics/python/adalab-cli"
 classifiers = [
-  "Development Status :: 4 - Beta",
-  "Intended Audience :: Developers",
-  "Operating System :: OS Independent",
-  "Programming Language :: Python",
-  "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.10",
-  "Topic :: Software Development :: Libraries :: Python Modules",
-  "Typing :: Typed",
-]
-packages = [
-    { include = "adalab_cli" }
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
 ]
+packages = [{ include = "adalab_cli" }]
 
 [tool.poetry.dependencies]
 python = "^3.10.0"
 tabulate = ">=0.9.0"
 typer = ">=0.9.0"
 sh = ">=2.0.6"
-adalib = {version = ">=5.0.0", source = "adalib-dev"}
-adalib-auth = {version = ">=1.2.2", source = "adalib-dev"}
+adalib = { version = ">=7.2.0", source = "adalib-dev" }
+adalib-auth = { version = ">=1.2.2", source = "adalib-dev" }
 loguru = ">=0.7.2"
 prompt-toolkit = ">=3.0.47"
+ascii-magic = ">=2.3.0"
 
 [tool.poetry.group.dev.dependencies]
 black = "^23.9.1"
@@ -87,8 +86,8 @@ line-length = 99
 [tool.flake8]
 ignore = ["E203", "E266", "E501", "W503"]
 max-complexity = 18
-select = ["B","C","E","F","W","T4"]
-exclude = [".git",".venv",".tox"]
+select = ["B", "C", "E", "F", "W", "T4"]
+exclude = [".git", ".venv", ".tox"]
 max-line-length = 99
 
 [tool.pytest]
@@ -104,10 +103,7 @@ addopts = """\
 
 [tool.coverage.report]
 fail_under = 100
-exclude_lines = [
-    'if TYPE_CHECKING:',
-    'pragma: no cover'
-]
+exclude_lines = ['if TYPE_CHECKING:', 'pragma: no cover']
 
 [tool.mypy]
 disallow_any_unimported = true

adalab_cli-3.0.0/adalab_cli/cli/completion_tree.py

@@ -1,67 +0,0 @@
-"""Map of the CLI commands and subcommands for the CLI completion tree."""
-
-completion_tree = {
-    "cards": {
-        "approve-card": {"--help": None},
-        "expose-card": {"--help": None},
-        "get-card": {"--help": None},
-        "hide-card": {"--help": None},
-        "list-cards": {
-            "all": None,
-            "notebook": None,
-            "voila": None,
-            "url": None,
-            "group": None,
-            "--help": None,
-        },
-        "help": None,
-        "exit": None,
-    },
-    "databases": {
-        "list-databases": {"--no-pretty": None, "--help": None},
-        "list-datasets": {"--no-pretty": None, "--return-sql": None, "--help": None},
-        "list-tables": {"--no-pretty": None, "--help": None},
-        "view-dataset": {"--head": None, "--no-pretty": None, "--help": None},
-        "help": None,
-        "exit": None,
-    },
-    "schedules": {
-        "create-schedule": {
-            "--schedule": None,
-            "--pool": None,
-            "--active": None,
-            "--concurrent": None,
-            "--cleanup": None,
-            "--timeout": None,
-            "--help": None,
-        },
-        "delete-run": {"--help": None},
-        "delete-schedule": {"--help": None},
-        "start-run": {
-            "--cleanup": None,
-            "--pool": None,
-            "--timeout": None,
-            "--help": None,
-        },
-        "stop-run": {"--help": None},
-        "update-schedule": {
-            "--schedule": None,
-            "--pool": None,
-            "--active": None,
-            "--concurrent": None,
-            "--cleanup": None,
-            "--timeout": None,
-            "--help": None,
-        },
-        "help": None,
-        "exit": None,
-    },
-    "user": {
-        "whoami": {"--full-information": None, "--with-notifications": None, "--help": None},
-        "help": None,
-        "exit": None,
-    },
-    "version": None,
-    "help": None,
-    "exit": None,
-}