yellowdog-cli 9.1.0__py3-none-any.whl

yellowdog_cli/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "9.1.0"
+__author__ = "YellowDog Limited"
+__email__ = "support@yellowdog.ai"

yellowdog_cli/abort.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+
+"""
+A script to abort Tasks without cancelling their Work Requirements.
+"""
+
+from yellowdog_client.model import (
+    Task,
+    TaskSearch,
+    TaskStatus,
+    WorkRequirementStatus,
+    WorkRequirementSummary,
+)
+
+from yellowdog_cli.utils.entity_utils import (
+    get_filtered_work_requirement_summaries,
+    get_task_group_name,
+)
+from yellowdog_cli.utils.interactive import confirmed, select
+from yellowdog_cli.utils.printing import (
+    print_error,
+    print_info,
+    sorted_objects,
+)
+from yellowdog_cli.utils.wrapper import ARGS_PARSER, CLIENT, CONFIG_COMMON, main_wrapper
+from yellowdog_cli.utils.ydid_utils import YDIDType, get_ydid_type
+
+
+@main_wrapper
+def main():
+
+    if ARGS_PARSER.task_id_list:
+        _abort_tasks_by_name_or_id(ARGS_PARSER.task_id_list)
+        return
+
+    print_info(
+        "Finding active Work Requirements in "
+        f"namespace '{CONFIG_COMMON.namespace}' with tags "
+        f"including '{CONFIG_COMMON.name_tag}'"
+    )
+
+    # Abort Tasks is always interactive
+    ARGS_PARSER.interactive = True
+
+    selected_work_requirement_summaries: list[WorkRequirementSummary] = (
+        get_filtered_work_requirement_summaries(
+            CLIENT,
+            namespace=CONFIG_COMMON.namespace,
+            tag=CONFIG_COMMON.name_tag,
+            exclude_filter=[
+                WorkRequirementStatus.COMPLETED,
+                WorkRequirementStatus.CANCELLED,
+                WorkRequirementStatus.FAILED,
+            ],
+        )
+    )
+
+    if selected_work_requirement_summaries:
+        selected_work_requirement_summaries = select(
+            CLIENT,
+            selected_work_requirement_summaries,
+            single_result=True,
+            override_quiet=True,
+        )
+    else:
+        print_info("No matching Work Requirements found")
+
+    if len(selected_work_requirement_summaries) == 1:
+        abort_tasks_selectively(selected_work_requirement_summaries[0])
+
+
+def abort_tasks_selectively(
+    wr_summary: WorkRequirementSummary,
+) -> None:
+    """
+    Abort selected Tasks in a Work Requirements
+    """
+    print_info(f"Aborting Tasks in Work Requirement '{wr_summary.name}'")
+
+    task_search = TaskSearch(
+        workRequirementId=wr_summary.id,
+        statuses=[TaskStatus.EXECUTING],
+    )
+    tasks: list[Task] = CLIENT.work_client.find_tasks(task_search)
+
+    if tasks:
+        tasks = select(CLIENT, sorted_objects(tasks), override_quiet=True)
+    else:
+        print_info(
+            "No currently executing Tasks in this Work Requirement",
+            override_quiet=True,
+        )
+
+    aborted_tasks = 0
+    if tasks and confirmed(f"Abort {len(tasks)} Task(s)?"):
+        for task in tasks:
+            try:
+                CLIENT.work_client.cancel_task(task, abort=True)
+                print_info(
+                    f"Aborted Task '{task.name}' in Task Group"
+                    f" '{get_task_group_name(CLIENT, wr_summary, task)}' in Work"
+                    f" Requirement '{wr_summary.name}'"
+                )
+                aborted_tasks += 1
+            except Exception as e:
+                print_error(f"Unable to abort Task '{task.name}': {e}")
+
+    if aborted_tasks == 0:
+        print_info("No Tasks Aborted")
+    elif aborted_tasks > 1:
+        print_info(f"Aborted {aborted_tasks} Tasks")
+
+
+def _abort_tasks_by_name_or_id(task_id_list: list[str]):
+    """
+    Abort Tasks by their YDIDs.
+    """
+    aborted_count = 0
+    for task_id in task_id_list:
+        if get_ydid_type(task_id) != YDIDType.TASK:
+            print_error(f"ID '{task_id}' is not a valid Task YDID")
+            continue
+
+        if not confirmed(f"Cancel and abort Task '{task_id}'?"):
+            continue
+
+        try:
+            CLIENT.work_client.cancel_task_by_id(task_id, abort=True)
+            print_info(f"Cancelled and aborted Task '{task_id}'")
+            aborted_count += 1
+        except Exception as e:
+            print_error(f"Unable to cancel and abort Task '{task_id}': {e}")
+
+    if aborted_count > 1:
+        print_info(f"Cancelled and aborted {aborted_count} Tasks")
+    elif aborted_count == 0:
+        print_info("No Tasks cancelled and aborted")
+
+
+# Entry point
+if __name__ == "__main__":
+    main()

yellowdog_cli/application.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+
+"""
+A script for reporting on the details of the Application being used.
+"""
+
+from typing import cast
+
+from yellowdog_client.model import ApplicationDetails
+
+from yellowdog_cli.utils.entity_utils import (
+    get_all_roles_and_namespaces_for_application,
+    get_application_details,
+    get_application_group_summaries,
+)
+from yellowdog_cli.utils.printing import print_simple
+from yellowdog_cli.utils.wrapper import CLIENT, CONFIG_COMMON, main_wrapper
+
+
+@main_wrapper
+def main():
+
+    application_details: ApplicationDetails = get_application_details(CLIENT)
+
+    print()
+    print_simple(
+        f"  Application name:                  {application_details.name}",
+        override_quiet=True,
+    )
+    print_simple(
+        f"  Application ID:                    {application_details.id}",
+        override_quiet=True,
+    )
+    print_simple(
+        f"  Account name:                      {application_details.accountName}",
+        override_quiet=True,
+    )
+    if "api" in CONFIG_COMMON.url:
+        print_simple(
+            "  Portal URL:                        "
+            f"{CONFIG_COMMON.url.replace('api', 'portal')}"
+            f"/#/signin?account={application_details.accountName}",
+            override_quiet=True,
+        )
+    print_simple(
+        f"  Account ID:                        {application_details.accountId}",
+        override_quiet=True,
+    )
+    features = (
+        ""
+        if application_details.features is None
+        else ", ".join([str(feature) for feature in application_details.features])
+    )
+    print_simple(
+        f"  Account features:                  {features}",
+        override_quiet=True,
+    )
+    all_ns_readable = "Yes" if application_details.allNamespacesReadable else "No"
+    print_simple(
+        f"  All namespaces readable:           {all_ns_readable}",
+        override_quiet=True,
+    )
+    if not application_details.allNamespacesReadable:
+        readable_namespaces = (
+            ""
+            if application_details.readableNamespaces is None
+            else ", ".join(application_details.readableNamespaces)
+        )
+        print_simple(
+            f"  Readable namespaces:               {readable_namespaces}",
+            override_quiet=True,
+        )
+    try:
+        groups = get_application_group_summaries(
+            CLIENT, cast(str, application_details.id)
+        )
+        group_names = ", ".join([cast(str, group.name) for group in groups])
+        print_simple(
+            f"  In group(s):                       {group_names}",
+            override_quiet=True,
+        )
+        for i, (role, namespaces) in enumerate(
+            get_all_roles_and_namespaces_for_application(
+                CLIENT, cast(str, application_details.id)
+            ).items()
+        ):
+            msg = f"{role} [{', '.join(namespaces)}]"
+            if i == 0:
+                print_simple(
+                    f"  With role(s) [in namespace(s)]:    {msg}",
+                    override_quiet=True,
+                )
+            else:
+                print_simple(
+                    f"                                     {msg}",
+                    override_quiet=True,
+                )
+
+    except Exception as e:
+        if "Forbidden" in str(e):
+            print_simple(
+                "  Groups and roles:                  "
+                "Cannot be determined due to application permissions",
+                override_quiet=True,
+            )
+        else:
+            pass
+    print()

yellowdog_cli/boost.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+
+"""
+A script to boost allowances.
+"""
+
+from yellowdog_cli.utils.interactive import confirmed
+from yellowdog_cli.utils.printing import print_error, print_info
+from yellowdog_cli.utils.wrapper import ARGS_PARSER, CLIENT, main_wrapper
+from yellowdog_cli.utils.ydid_utils import YDIDType, get_ydid_type
+
+
+@main_wrapper
+def main():
+
+    count = 0
+    for allowance in ARGS_PARSER.allowance_list:
+        if get_ydid_type(allowance) != YDIDType.ALLOWANCE:
+            print_error(f"Not a valid Allowance ID: '{allowance}'")
+            continue
+        if not confirmed(
+            f"Boost Allowance {allowance} by {ARGS_PARSER.boost_hours} hours?"
+        ):
+            continue
+        try:
+            CLIENT.allowances_client.boost_allowance_by_id(
+                allowance, ARGS_PARSER.boost_hours
+            )
+            print_info(
+                f"Boosted Allowance {allowance} by {ARGS_PARSER.boost_hours} hours"
+            )
+            count += 1
+        except Exception as e:
+            print_error(f"Unable to boost Allowance {allowance}: {e}")
+
+    if count > 1:
+        print_info(f"Boosted {count} allowances by {ARGS_PARSER.boost_hours} hours")
+
+
+# Standalone entry point
+if __name__ == "__main__":
+    main()

yellowdog_cli/cancel.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+
+"""
+A script to cancel Work Requirements and optionally abort Tasks.
+"""
+
+from typing import cast
+
+from yellowdog_client.model import (
+    WorkRequirement,
+    WorkRequirementStatus,
+    WorkRequirementSummary,
+)
+
+from yellowdog_cli.utils.entity_utils import (
+    get_filtered_work_requirement_summaries,
+    get_work_requirement_summary_by_name_or_id,
+)
+from yellowdog_cli.utils.follow_utils import follow_ids
+from yellowdog_cli.utils.interactive import confirmed, select
+from yellowdog_cli.utils.misc_utils import link_entity
+from yellowdog_cli.utils.printing import print_error, print_info, print_warning
+from yellowdog_cli.utils.wrapper import ARGS_PARSER, CLIENT, CONFIG_COMMON, main_wrapper
+from yellowdog_cli.utils.ydid_utils import YDIDType, get_ydid_type
+
+
+@main_wrapper
+def main():
+    if ARGS_PARSER.work_requirement_names:
+        _cancel_work_requirements_by_name_or_id(ARGS_PARSER.work_requirement_names)
+        return
+
+    print_info(
+        "Cancelling Work Requirements in namespace "
+        f"'{CONFIG_COMMON.namespace}' with tags "
+        f"including '{CONFIG_COMMON.name_tag}'"
+    )
+
+    selected_work_requirement_summaries: list[WorkRequirementSummary] = (
+        get_filtered_work_requirement_summaries(
+            client=CLIENT,
+            namespace=CONFIG_COMMON.namespace,
+            tag=CONFIG_COMMON.name_tag,
+            exclude_filter=[
+                WorkRequirementStatus.COMPLETED,
+                WorkRequirementStatus.CANCELLED,
+                WorkRequirementStatus.FAILED,
+            ],
+        )
+    )
+
+    cancelled_count = 0
+    cancelling_count = 0
+    work_requirement_ids: list[str] = []
+
+    if selected_work_requirement_summaries:
+        selected_work_requirement_summaries = select(
+            CLIENT, selected_work_requirement_summaries
+        )
+
+    if selected_work_requirement_summaries and confirmed(
+        f"Cancel {len(selected_work_requirement_summaries)} "
+        f"Work Requirement(s)"
+        f"{'' if not ARGS_PARSER.abort else ' and abort all allocated tasks'}?"
+    ):
+        for work_summary in selected_work_requirement_summaries:
+            if work_summary.status != WorkRequirementStatus.CANCELLING:
+                try:
+                    CLIENT.work_client.cancel_work_requirement_by_id(
+                        work_summary.id, ARGS_PARSER.abort
+                    )
+                    work_requirement: WorkRequirement = (
+                        CLIENT.work_client.get_work_requirement_by_id(work_summary.id)
+                    )
+                    cancelled_count += 1
+                    print_info(
+                        f"Cancelled {link_entity(CONFIG_COMMON.url, work_requirement)} "
+                        f"('{work_summary.name}')"
+                        f"{'' if not ARGS_PARSER.abort else ' and aborted all allocated tasks'}"
+                    )
+
+                except Exception as e:
+                    print_error(
+                        f"Failed to cancel Work Requirement '{work_summary.name}': {e}"
+                    )
+
+            elif work_summary.status == WorkRequirementStatus.CANCELLING:
+                print_info(
+                    f"Work Requirement '{work_summary.name}' is already cancelling"
+                )
+                cancelling_count += 1
+            work_requirement_ids.append(work_summary.id)
+
+        if cancelled_count > 1:
+            print_info(f"Cancelled {cancelled_count} Work Requirement(s)")
+        elif cancelled_count == 0 and cancelling_count == 0:
+            print_info("No Work Requirements to cancel")
+
+        if ARGS_PARSER.follow:
+            follow_ids(work_requirement_ids)
+
+    else:
+        print_info("No Work Requirements to cancel")
+
+
+def _cancel_work_requirements_by_name_or_id(names_or_ids: list[str]):
+    """
+    Cancel Work Requirements by their names or IDs.
+    """
+    work_requirement_summaries: list[WorkRequirementSummary] = []
+
+    for name_or_id in names_or_ids:
+
+        # Handle a task ID
+        if get_ydid_type(name_or_id) == YDIDType.TASK:
+            if not confirmed(
+                f"Cancel {'' if not ARGS_PARSER.abort else 'and abort '}"
+                f"Task '{name_or_id}'?"
+            ):
+                continue
+            try:
+                CLIENT.work_client.cancel_task_by_id(name_or_id, ARGS_PARSER.abort)
+            except Exception as e:
+                print_error(f"Failed to cancel Task '{name_or_id}': {e}")
+            continue
+
+        work_requirement_summary = get_work_requirement_summary_by_name_or_id(
+            CLIENT,
+            name_or_id,
+            namespace=CONFIG_COMMON.namespace,
+        )
+        if work_requirement_summary is None:
+            print_error(f"Work Requirement '{name_or_id}' not found")
+            continue
+
+        if work_requirement_summary.status not in [
+            WorkRequirementStatus.RUNNING,
+            WorkRequirementStatus.HELD,
+            WorkRequirementStatus.FINISHING,
+        ]:
+            print_warning(
+                f"Work Requirement '{name_or_id}' is not in a valid state"
+                f" ('{work_requirement_summary.status}') for cancellation"
+            )
+            continue
+
+        work_requirement_summaries.append(work_requirement_summary)
+        fq_name = (
+            f"{work_requirement_summary.namespace}/{work_requirement_summary.name}"
+        )
+        if work_requirement_summary.status == WorkRequirementStatus.CANCELLING:
+            print_info(
+                f"Work Requirement '{fq_name}' ({work_requirement_summary.id}) "
+                "is already cancelling"
+            )
+        else:
+            if not confirmed(
+                f"Cancel Work Requirement '{fq_name}' ({work_requirement_summary.id})"
+                f"{'' if not ARGS_PARSER.abort else ' and abort all allocated tasks'}?"
+            ):
+                continue
+            try:
+                CLIENT.work_client.cancel_work_requirement_by_id(
+                    work_requirement_summary.id, ARGS_PARSER.abort
+                )
+                print_info(
+                    f"Cancelled Work Requirement '{fq_name}' ({work_requirement_summary.id})"
+                    f"{'' if not ARGS_PARSER.abort else ' and aborted all allocated tasks'}"
+                )
+            except Exception as e:
+                print_error(
+                    f"Failed to cancel Work Requirement '{fq_name}' "
+                    f"({work_requirement_summary.id}): {e}"
+                )
+
+    if ARGS_PARSER.follow:
+        follow_ids([cast(str, wrs.id) for wrs in work_requirement_summaries])
+
+
+# Entry point
+if __name__ == "__main__":
+    main()

yellowdog_cli/cloudwizard.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+
+"""
+Cloud Wizard: cloud provider and YellowDog account setup.
+"""
+
+from yellowdog_cli.utils.check_imports import check_cloudwizard_imports
+from yellowdog_cli.utils.cloudwizard_aws import AWSConfig
+from yellowdog_cli.utils.cloudwizard_azure import AzureConfig
+from yellowdog_cli.utils.cloudwizard_gcp import GCPConfig
+from yellowdog_cli.utils.printing import print_error, print_info, print_warning
+from yellowdog_cli.utils.wrapper import ARGS_PARSER, CLIENT, main_wrapper
+
+
+@main_wrapper
+def main():
+    """
+    Main dispatcher for Cloud Wizard setup and teardown
+    """
+
+    check_cloudwizard_imports()
+
+    if ARGS_PARSER.cloud_provider.lower() in ["aws", "amazon"]:
+        print_info("YellowDog automated cloud provider setup/teardown for 'AWS'")
+        cloud_provider_config = AWSConfig(
+            client=CLIENT,
+            region_name=ARGS_PARSER.region_name,
+            show_secrets=ARGS_PARSER.show_secrets,
+            instance_type=ARGS_PARSER.instance_type,
+        )
+
+    elif ARGS_PARSER.cloud_provider.lower() in ["gcp", "gce", "google"]:
+        print_info("YellowDog automated cloud provider setup/teardown for 'GCP'")
+        if ARGS_PARSER.credentials_file is None:
+            print_error(
+                "Credentials file ('--credentials-file') must be supplied for GCP"
+            )
+            return
+        cloud_provider_config = GCPConfig(
+            service_account_file=ARGS_PARSER.credentials_file,
+            client=CLIENT,
+            instance_type=ARGS_PARSER.instance_type,
+        )
+
+    elif ARGS_PARSER.cloud_provider.lower() in ["azure", "microsoft"]:
+        print_info("YellowDog automated cloud provider setup/teardown for 'Azure'")
+        cloud_provider_config = AzureConfig(
+            client=CLIENT,
+            instance_type=ARGS_PARSER.instance_type,
+        )
+
+    elif ARGS_PARSER.cloud_provider.lower() in [
+        "oci",
+        "oracle",
+        "alibaba",
+    ]:
+        print_warning(
+            f"Cloud provider '{ARGS_PARSER.cloud_provider}' is not yet supported by"
+            " Cloud Wizard"
+        )
+        return
+
+    else:
+        print_error(f"Unknown cloud provider '{ARGS_PARSER.cloud_provider}'")
+        return
+
+    if ARGS_PARSER.operation == "setup":
+        cloud_provider_config.setup()
+
+    elif ARGS_PARSER.operation == "teardown":
+        cloud_provider_config.teardown()
+
+    elif ARGS_PARSER.operation in ["add-ssh", "remove-ssh"]:
+        cloud_provider_config.set_ssh_ingress_rule(
+            ARGS_PARSER.operation, ARGS_PARSER.region_name
+        )
+
+
+if __name__ == "__main__":
+    """
+    Standalone entry point
+    """
+    main()