ycdl/frontends/ycdl_cli.py

import argparse
import itertools
import sys
import traceback

from voussoirkit import betterhelp
from voussoirkit import interactive
from voussoirkit import pipeable
from voussoirkit import vlogging
from voussoirkit import operatornotify

import ycdl

log = vlogging.getLogger(__name__, 'ycdl_cli')

# HELPERS ##########################################################################################

def closest_db():
    return ycdl.ycdldb.YCDLDB.closest_ycdldb()

def get_channels_from_args(args):
    '''
    This function unifies channel IDs that are part of the command's argparser
    and channels that come from --channel_list listargs into a single stream
    of Channel objects.
    '''
    ycdldb = closest_db()
    channels = []

    if args.channel_list_args:
        channels.extend(_channel_list_argparse(args.channel_list_args))

    if args.channel_ids:
        channels.extend(ycdldb.get_channels_by_id(pipeable.input_many(args.channel_ids)))

    return channels

def get_videos_from_args(args):
    '''
    This function unifies video IDs that are part of the command's argparser
    and videos that come from --video_list listargs into a single stream
    of Video objects.
    '''
    ycdldb = closest_db()
    videos = []

    if args.video_list_args:
        videos.extend(_video_list_argparse(args.video_list_args))

    if args.video_ids:
        videos.extend(ycdldb.get_videos_by_id(pipeable.input_many(args.video_ids)))

    return videos

# ARGPARSE #########################################################################################

def add_channel_argparse(args):
    ycdldb = closest_db()
    ycdldb.add_channel(
        channel_id=args.channel_id,
        automark=args.automark,
        download_directory=args.download_directory,
        get_videos=args.get_videos,
        name=args.name,
        queuefile_extension=args.queuefile_extension,
    )

    if args.autoyes or interactive.getpermission('Commit?'):
        ycdldb.commit()

    return 0

def _channel_list_argparse(args):
    ycdldb = closest_db()
    channels = sorted(ycdldb.get_channels(), key=lambda c: c.name.lower())
    yield from channels

def channel_list_argparse(args):
    for channel in _channel_list_argparse(args):
        line = args.format.format(
            automark=channel.automark,
            autorefresh=channel.autorefresh,
            id=channel.id,
            name=channel.name,
            queuefile_extension=channel.queuefile_extension,
            uploads_playlist=channel.uploads_playlist,
        )
        pipeable.stdout(line)

    return 0

def delete_channel_argparse(args):
    ycdldb = closest_db()
    needs_commit = False

    for channel in get_channels_from_args(args):
        channel.delete()
        needs_commit = True

    if args.autoyes or interactive.getpermission('Commit?'):
        ycdldb.commit()

    return 0

def download_video_argparse(args):
    ycdldb = closest_db()
    needs_commit = False

    for video in get_videos_from_args(args):
        queuefile = ycdldb.download_video(
            video,
            download_directory=args.download_directory,
            force=args.force,
            queuefile_extension=args.queuefile_extension,
        )
        if queuefile is not None:
            needs_commit = True

    if not needs_commit:
        return 0

    if args.autoyes or interactive.getpermission('Commit?'):
        ycdldb.commit()

    return 0

def init_argparse(args):
    ycdldb = ycdl.ycdldb.YCDLDB(create=True)
    ycdldb.commit()
    pipeable.stdout(ycdldb.data_directory.absolute_path)
    return 0

def refresh_channels_argparse(args):
    needs_commit = False
    status = 0

    ycdldb = closest_db()
    if args.channels:
        channels = [ycdldb.get_channel(c) for c in args.channels]
        for channel in channels:
            try:
                channel.refresh(force=args.force)
                needs_commit = True
            except Exception as exc:
                log.warning(traceback.format_exc())
                status = 1
    else:
        excs = ycdldb.refresh_all_channels(force=args.force, skip_failures=True)
        needs_commit = True

    if not needs_commit:
        return status

    if args.autoyes or interactive.getpermission('Commit?'):
        ycdldb.commit()

    return status

def _video_list_argparse(args):
    ycdldb = closest_db()
    videos = ycdldb.get_videos(channel_id=args.channel_id, state=args.state, orderby=args.orderby)

    if args.limit is not None:
        videos = itertools.islice(videos, args.limit)

    yield from videos

def video_list_argparse(args):
    for video in _video_list_argparse(args):
        line = args.format.format(
            author_id=video.author_id,
            duration=video.duration,
            id=video.id,
            live_broadcast=video.live_broadcast,
            published=video.published,
            published_string=video.published_string,
            state=video.state,
            title=video.title,
            views=video.views,
        )
        pipeable.stdout(line)

    return 0

DOCSTRING = '''
YCDL CLI
========

{add_channel}

{channel_list}

{delete_channel}

{download_video}

{init}

{refresh_channels}

{video_list}

TO SEE DETAILS ON EACH COMMAND, RUN
> ycdl_cli.py <command> --help
'''

SUB_DOCSTRINGS = dict(
add_channel='''
add_channel:
    Add a channel to the database.

    > ycdl_cli.py add_channel channel_id <flags>

    flags:
    --automark X:
        Set the channel's automark to this value, which should be 'pending',
        'downloaded', or 'ignored'.

    --download_directory X:
        Set the channel's download directory to this path, which must
        be a directory.

    --name X:
        Override the channel's own name with a name of your choosing.

    --no_videos:
        By default, the channel's videos will be fetched right away.
        Add this argument if you don't want to do that yet.

    --queuefile_extension X:
        Set the queuefile extension for all videos downloaded from this channel.

    Examples:
    > ycdl_cli.py add_channel UCFhXFikryT4aFcLkLw2LBLA
''',

channel_list='''
channel_list:
    Print all channels in the database.

    Note: If you want to use this in a command pipeline, please specify
    --format instead of relying on the default.

    > ycdl_cli.py channel_list <flags>

    flags:
    --format X:
        A string like "{id}: {name}" to format the attributes of the channel.
        The available attributes are id, name, automark, autorefresh,
        uploads_playlist, queuefile_extension.

        If you are using --channel_list as listargs for another command, then
        this argument is not relevant.

    > ycdl_cli.py channel_list

    Examples:
    > ycdl_cli.py channel_list
    > ycdl_cli.py channel_list --format "{id} automark={automark}"
''',

delete_channel='''
delete_channel:
    Delete a channel and all its videos from the database.

    You can pass multiple channel IDs.
    Uses pipeable to support !c clipboard, !i stdin.

    > ycdl_cli.py delete_channel channel_id [channel_id channel_id...]
    > ycdl_cli.py delete_channel --channel_list listargs

    Examples:
    # Delete one channel
    > ycdl_cli.py delete_channel UCOYBuFGi8T3NM5fNAptCLCw

    # Delete many channels
    > ycdl_cli.py delete_channel UCOYBuFGi8T3NM5fNAptCLCw UCmu9PVIZBk-ZCi-Sk2F2utA

    # Delete all channels in the database
    > ycdl_cli.py delete_channel --channel-list

    See ycdl_cli.py channel_list --help for help with listargs.
''',

download_video='''
download_video:
    Create the queuefiles for one or more videos.

    They will be placed in the channel's download_directory if it has one, or
    else the download_directory in the ycdl.json config file. The video will
    have its state set to "downloaded".

    Uses pipeable to support !c clipboard, !i stdin.

    > ycdl_cli.py download_video video_id [video_id video_id...] <flags>
    > ycdl_cli.py download_video <flags> --video_list listargs

    flags:
    --download_directory X:
        By default, the queuefile will be placed in the channel's
        download_directory if it has one, or the download_directory in the
        ycdl.json config file. You can pass this argument to override both
        of those.

    --force:
        By default, a video that is already marked as downloaded will not be
        downloaded again. You can add this to make the queuefiles for those
        videos anyway.

    --queuefile_extension X:
        By default, the queuefile extension is taken from the channel or the
        config file. You can pass this argument to override both of those.

    Examples:
    # Download one video
    > ycdl_cli.py download_video thOifuHs6eY

    # Force download many videos
    > ycdl_cli.py download_video yJ-oASr_djo vHuFizITMdA --force

    # Download all videos from this channel
    > ycdl_cli.py download_video --video_list --channel UCvBv3PCvD9v-IKKTkd94XPg

    # Force re-download all videos that have already been downloaded
    > ycdl_cli.py download_video --force --video_list --state downloaded

    See ycdl_cli.py video_list --help for help with listargs.
''',

init='''
init:
    Create a new YCDL database in the current directory.

    > ycdl_cli.py init
''',

refresh_channels='''
refresh_channels:
    Refresh some or all channels in the database.

    New videos will have their state marked with the channel's automark value,
    and queuefiles will be created for channels with automark=downloaded.

    > ycdl_cli.py refresh_channels <flags>

    flags:
    --channels X Y Z:
        Any number of channel IDs.
        If omitted, all channels will be refreshed.

    --force:
        If omitted, only new videos are found.
        If included, channels are refreshed completely. This may be slow and
        cost a lot of API calls.

    Examples:
    > ycdl_cli.py refresh_channels --force
    > ycdl_cli.py refresh_channels --channels UC1_uAIS3r8Vu6JjXWvastJg
''',

video_list='''
video_list:
    Print videos in the database.

    Note: If you want to use this in a command pipeline, please specify
    --format instead of relying on the default.

    > ycdl_cli.py video_list <flags>

    flags:
    --channel X:
        A channel ID to list videos from.

    --format X:
        A string like "{published_string}:{id} {title}" to format the
        attributes of the video. The available attributes are author_id,
        duration, id, live_broadcast, published, published_string, state,
        title, views.

    --limit X:
        Only show up to X results.

    --orderby X:
        Order the results by published, views, duration, or random.

    --state X:
        Only show videos with this state.

    Examples:
    > ycdl_cli.py video_list --state pending --limit 100
    > ycdl_cli.py video_list --channel UCzIiTeduaanyEboRfwJJznA --orderby views
''',
)

DOCSTRING = betterhelp.add_previews(DOCSTRING, SUB_DOCSTRINGS)

@operatornotify.main_decorator(subject='ycdl_cli')
@vlogging.main_decorator
def main(argv):
    parser = argparse.ArgumentParser(description=__doc__)
    subparsers = parser.add_subparsers()

    primary_args = []
    video_list_args = []
    channel_list_args = []
    mode = primary_args
    for arg in argv:
        if 0:
            pass
        elif arg in {'--channel_list', '--channel-list'}:
            mode = channel_list_args
        elif arg in {'--video_list', '--video-list'}:
            mode = video_list_args
        else:
            mode.append(arg)

    p_add_channel = subparsers.add_parser('add_channel', aliases=['add-channel'])
    p_add_channel.add_argument('channel_id')
    p_add_channel.add_argument('--automark', default='pending')
    p_add_channel.add_argument('--download_directory', '--download-directory', default=None)
    p_add_channel.add_argument('--name', default=None)
    p_add_channel.add_argument('--no_videos', '--no-videos', dest='get_videos', action='store_false')
    p_add_channel.add_argument('--queuefile_extension', '--queuefile-extension', default=None)
    p_add_channel.add_argument('--yes', dest='autoyes', action='store_true')
    p_add_channel.set_defaults(func=add_channel_argparse)

    p_channel_list = subparsers.add_parser('channel_list', aliases=['channel-list'])
    p_channel_list.add_argument('--format', default='{id}:{name}')
    p_channel_list.set_defaults(func=channel_list_argparse)

    p_delete_channel = subparsers.add_parser('delete_channel', aliases=['delete-channel'])
    p_delete_channel.add_argument('channel_ids', nargs='*')
    p_delete_channel.add_argument('--yes', dest='autoyes', action='store_true')
    p_delete_channel.set_defaults(func=delete_channel_argparse)

    p_download_video = subparsers.add_parser('download_video', aliases=['download-video'])
    p_download_video.add_argument('video_ids', nargs='*')
    p_download_video.add_argument('--download_directory', '--download-directory', default=None)
    p_download_video.add_argument('--force', action='store_true')
    p_download_video.add_argument('--queuefile_extension', '--queuefile-extension', default=None)
    p_download_video.add_argument('--yes', dest='autoyes', action='store_true')
    p_download_video.set_defaults(func=download_video_argparse)

    p_init = subparsers.add_parser('init')
    p_init.set_defaults(func=init_argparse)

    p_refresh_channels = subparsers.add_parser('refresh_channels', aliases=['refresh-channels'])
    p_refresh_channels.add_argument('--channels', nargs='*')
    p_refresh_channels.add_argument('--force', action='store_true')
    p_refresh_channels.add_argument('--yes', dest='autoyes', action='store_true')
    p_refresh_channels.set_defaults(func=refresh_channels_argparse)

    p_video_list = subparsers.add_parser('video_list', aliases=['video-list'])
    p_video_list.add_argument('--channel', dest='channel_id', default=None)
    p_video_list.add_argument('--format', default='{published_string}:{id}:{title}')
    p_video_list.add_argument('--limit', type=int, default=None)
    p_video_list.add_argument('--orderby', default=None)
    p_video_list.add_argument('--state', default=None)
    p_video_list.set_defaults(func=video_list_argparse)

    ##

    def postprocessor(args):
        args.video_list_args = p_video_list.parse_args(video_list_args)
        args.channel_list_args = p_channel_list.parse_args(channel_list_args)
        return args

    try:
        return betterhelp.subparser_main(
            primary_args,
            parser,
            main_docstring=DOCSTRING,
            sub_docstrings=SUB_DOCSTRINGS,
            args_postprocessor=postprocessor,
        )
    except ycdl.exceptions.NoClosestYCDLDB as exc:
        pipeable.stderr(exc.error_message)
        pipeable.stderr('Try `ycdl_cli.py init` to create the database.')
        return 1

if __name__ == '__main__':
    raise SystemExit(main(sys.argv[1:]))