cli

@main_cli.group(help="Run command line arguments of AYON addons")
@click.pass_context
def addon(ctx):
    """Addon specific commands created dynamically.

    These commands are generated dynamically by currently loaded addons.
    """
    pass

@main_cli.command()
def browser():
    """Show Browser tool."""
    from ayon_core.tools.loader.ui import LoaderWindow
    from ayon_core.tools.utils import get_ayon_qt_app

    app = get_ayon_qt_app()
    browser_window = LoaderWindow()
    browser_window.setWindowTitle("AYON Browser")
    browser_window.show()
    app.exec_()

@main_cli.command()
@click.argument("output_path")
@click.option("--project", help="Define project context")
@click.option(
    "--folder", help="Define folder in project (project must be set)")
@click.option(
    "--strict",
    is_flag=True,
    help="Full context must be set otherwise dialog can't be closed."
)
def contextselection(
    output_path,
    project,
    folder,
    strict
):
    """Show Qt dialog to select context.

    Context is project name, folder path and task name. The result is stored
    into json file which path is passed in first argument.
    """
    from ayon_core.tools.context_dialog import main

    main(output_path, project, folder, strict)

@main_cli.command()
@click.option(
    "--project",
    type=str,
    help="Project name",
    required=True)
def create_project_structure(
    project,
):
    """Create project folder structure as defined in setting
    `ayon+settings://core/project_folder_structure`

    Args:
        project (str): The name of the project for which you
            want to create its additional folder structure.

    """

    from ayon_core.pipeline.project_folders import create_project_folders

    print(f">>> Creating project folder structure for project '{project}'.")
    create_project_folders(project)

@main_cli.command()
@click.option(
    "--project",
    type=str,
    help="Project name",
    required=True)
@click.option(
    "--event_id",
    type=str,
    help="Id of the event carrying the version ids",
    default=None)
@click.option(
    "--version_ids",
    type=str,
    help="Comma separated version ids",
    default=None)
def deliver(
    project, event_id, version_ids
):
    """Launch delivery action for selected versions.

    The version ids can be passed either directly via '--version_ids' (legacy)
    or via an event using '--event_id'. Exactly one of the two must be
    provided.

    Args:
        project (str): The name of the project.
        event_id (str): Id of the event carrying the version ids.
        version_ids (str): Comma separated version ids.

    """

    print(f">>> Launching browser for Delivery action '{project}'.")

    log = Logger.get_logger("delivery")

    try:
        from ayon_core.tools.delivery.delivery import DeliveryOptionsDialog
        # must be here because no module qargparse
        from ayon_core.tools.utils.lib import get_qt_app

        _app = get_qt_app()
        list_entity_label = None
        if event_id:
            event = ayon_api.get_event(event_id)

            # either version_ids or list_id can be in payload
            version_ids = event["payload"].get("version_ids")
            list_id = event["payload"].get("list_id")
            if not version_ids and not list_id:
                raise ValueError("No version_ids or list_id in payload.")
            if list_id:
                list_entity = ayon_api.get_entity_list_rest(project, list_id)
                if not list_entity:
                    raise ValueError(
                        f"Entity list '{list_id}' was not found.")
                list_entity_label = list_entity["label"]
                # get all version entities belonging to the list
                version_ids = [
                    version["entityId"] for version in list_entity["items"]]
        elif version_ids:
            version_ids = version_ids.split(",")
        else:
            raise ValueError("Missing option '--version_ids' or '--event_id'")

        dialog = DeliveryOptionsDialog(
            project, version_ids, list_entity_label=list_entity_label, log=log
        )
        dialog.exec_()
    except Exception:
        log.warning("Failed to deliver versions.", exc_info=True)

@main_cli.command()
def interactive():
    """Interactive (Python like) console.

    Helpful command not only for development to directly work with python
    interpreter.

    Warning:
        Executable 'ayon.exe' on Windows won't work.
    """
    version = os.environ["AYON_VERSION"]
    banner = (
        f"AYON launcher {version}\nPython {sys.version} on {sys.platform}"
    )
    code.interact(banner)

@click.group(invoke_without_command=True)
@click.pass_context
@click.option(
    "--use-staging",
    is_flag=True,
    expose_value=False,
    help="use staging variants")
@click.option(
    "--debug",
    is_flag=True,
    expose_value=False,
    help="Enable debug")
@click.option(
    "--project",
    help="Project name")
@click.option(
    "--verbose",
    expose_value=False,
    help="Change AYON log level (debug - critical or 0-50)")
@click.option(
    "--use-dev",
    is_flag=True,
    expose_value=False,
    help="use dev bundle")
@click.option(
    "--ayon-login",
    is_flag=True,
    expose_value=False,
    help="Show login dialog (change server or user)")
def main_cli(ctx, *_args, **_kwargs):
    """AYON is main command serving as entry point to pipeline system.

    It wraps different commands together.
    """
    if ctx.invoked_subcommand is None:
        # Print help if headless mode is used
        if os.getenv("AYON_HEADLESS_MODE") == "1":
            print(ctx.get_help())
            sys.exit(0)
        else:
            ctx.params.pop("project")
            ctx.forward(tray)

@main_cli.command()
@click.pass_context
@click.argument("path", required=True)
@click.option("-t", "--targets", help="Targets", default=None,
              multiple=True)
def publish(ctx, path, targets):
    """Start CLI publishing.

    Publish collects json from path provided as an argument.

    """
    from ayon_core.pipeline.publish import main_cli_publish

    main_cli_publish(path, targets, ctx.obj["addons_manager"])

@main_cli.command(
    context_settings=dict(
        ignore_unknown_options=True,
        allow_extra_args=True))
@click.argument("script", required=True, type=click.Path(exists=True))
def run(script):
    """Run python script in AYON context."""
    import runpy

    if not script:
        print("Error: missing path to script file.")
        return

    # Remove first argument if it is the same as AYON executable
    # - Forward compatibility with future AYON versions.
    # - Current AYON launcher keeps the arguments with first argument but
    #     future versions might remove it.
    first_arg = sys.argv[0]
    if is_running_from_build():
        comp_path = os.getenv("AYON_EXECUTABLE")
    else:
        comp_path = os.path.join(os.environ["AYON_ROOT"], "start.py")
    # Compare paths and remove first argument if it is the same as AYON
    if Path(first_arg).resolve() == Path(comp_path).resolve():
        sys.argv.pop(0)

    # Remove 'run' command from sys.argv
    sys.argv.remove("run")

    args_string = " ".join(sys.argv[1:])
    print(f"... running: {script} {args_string}")
    runpy.run_path(script, run_name="__main__")

@main_cli.command()
@click.option(
    "--force",
    is_flag=True,
    help="Force to start tray and close any existing one.")
def tray(force):
    """Launch AYON tray.

    Default action of AYON command is to launch tray widget to control basic
    aspects of AYON. See documentation for more information.
    """
    from ayon_core.tools.tray import main

    main(force)

@main_cli.command()
@click.option("--build", help="Print only build version",
              is_flag=True, default=False)
def version(build):
    """Print AYON launcher version.

    Deprecated:
        This function has questionable usage.
    """
    print(os.environ["AYON_VERSION"])