red_ops_better

#!/usr/bin/env python3

import configparser
import argparse
import pickle
import os
import shutil
import sys
import tempfile
import traceback
from urllib.parse import urlparse, parse_qsl
from multiprocessing import cpu_count
from getpass import getpass
import tagged
import transcode
import RedOpsAPI

import re
import logging
import base64
import json
from os.path import exists


if sys.version_info < (3, 6, 0):
    raise Exception("Requires Python 3.6.0 or newer")

def create_description(torrent, flac_dir, format, permalink):
    # Create an example command to document the transcode process.
    cmds = transcode.transcode_commands(format,
                                        transcode.needs_resampling(flac_dir),
                                        transcode.resample_rate(flac_dir),
            'input.flac', 'output' + transcode.encoders[format]['ext'])

    description = [
        'Transcode process:',
        '',
        '[code]{0}[/code]'.format(' | '.join(cmds)),
        '',
        'Created using [url=https://github.com/kpdean/RED_OPS_Better]REDBetter (Chachhing fork)[/url]'
        ''
        ]
    return description

def formats_needed(group, torrent, supported_formats):
    same_group = lambda t: t['media'] == torrent['media'] and\
                           t['remasterYear'] == torrent['remasterYear'] and\
                           t['remasterTitle'] == torrent['remasterTitle'] and\
                           t['remasterRecordLabel'] == torrent['remasterRecordLabel'] and\
                           t['remasterCatalogueNumber'] == torrent['remasterCatalogueNumber']

    others = filter(same_group, group['torrents'])
    current_formats = set((t['format'], t['encoding']) for t in others)
    missing_formats = [format for format, details in [(f, RedOpsAPI.formats[f]) for f in supported_formats]\
                           if (details['format'], details['encoding']) not in current_formats]
    allowed_formats = RedOpsAPI.allowed_transcodes(torrent)
    return [format for format in missing_formats if format in allowed_formats]

def main():
    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, prog='red_ops_better')
    parser.add_argument('release_urls', nargs='*', help='the URL where the release is located')
    parser.add_argument('-s', '--single', action='store_true', help='only add one format per release (useful for getting unique groups)')
    parser.add_argument('-j', '--threads', type=int, help='number of threads to use when transcoding',
            default=max(cpu_count() - 1, 1))
    parser.add_argument('--config', help='the location of the configuration file', \
            default=os.path.expanduser(os.getcwd()+'/config'))
    parser.add_argument('--cache', help='the location of the cache', \
            default=os.path.expanduser(os.getcwd()+'/cache'))
    parser.add_argument('-U', '--no-upload', action='store_true', help='don\'t upload new torrents (in case you want to do it manually)')
    parser.add_argument('-E', '--no-24bit-edit', action='store_true', help='don\'t try to edit 24-bit torrents mistakenly labeled as 16-bit')
    parser.add_argument('-S', '--skip', action='store_true', help="treats a torrent as already processed")
    parser.add_argument('-t', '--totp', help="time based one time password for 2FA", default=None)
    parser.add_argument('-T', '--tracker', help="pick your tracker for transcoding (choose from RED or OPS)", default='RED')

    args = parser.parse_args()

    config = configparser.ConfigParser(interpolation=None)
    open(args.config)
    config.read(args.config)
    dictConfig = config._sections
    file_response = (dict(dictConfig))

    TrackerArgs = args.tracker.upper()
    if TrackerArgs == 'RED':
        config_dict = file_response['RED']
        trackerLogingto = 'Redacted'
    elif TrackerArgs == 'OPS':
        config_dict = file_response['OPS']
        trackerLogingto = 'Orpheus Network'
    elif TrackerArgs == 'DIC':
        config_dict = file_response['DIC']
        trackerLogingto = 'Dolphin Is Coming'
    else:
        print("Tracker argument must be (RED or OPS or DIC).")
        sys.exit(2)

    username = config_dict['username']
    password = config_dict['password']
    api_key = config_dict['api_key']
    try:
        session_cookie = os.path.expanduser(config_dict['session_cookie'])
    except configparser.NoOptionError:
        session_cookie = None

    do_24_bit = config_dict['24bit_behaviour']
    data_dir = [os.path.expanduser(d) for d in config_dict['data_dir'].split(';')]
    try:
        output_dir = os.path.expanduser(config_dict['output_dir'])
    except configparser.NoOptionError:
        output_dir = None
    if not output_dir:
        output_dir = data_dir[0]
    torrent_dir = os.path.expanduser(config_dict['torrent_dir'])
    supported_formats = [format.strip().upper() for format in config_dict['formats'].split(',')]

    try:
        media_config = config_dict['media']
        if not media_config:
            supported_media = RedOpsAPI.lossless_media
        else:
            supported_media = set([medium.strip().lower() for medium in media_config.split(',')])
            if not supported_media.issubset(set(RedOpsAPI.lossless_media)):
                print('Unsupported media type "{0}", edit your configuration'.format((supported_media - RedOpsAPI.lossless_media).pop()))
                print("Supported types are: {0}".format(', '.join(RedOpsAPI.lossless_media)))
                sys.exit(2)
    except configparser.NoOptionError:
        supported_media = RedOpsAPI.lossless_media

    tracker = config_dict['tracker']
    endpoint = config_dict['api']
    source = config_dict['source']
    piece_length = config_dict['piece_length']

    upload_torrent = not args.no_upload

    print("Logging in to " + trackerLogingto + "....")
    api = RedOpsAPI.RED_OPS_API(username, password, session_cookie, endpoint, args.totp, api_key)

    try:
        seen = pickle.load(open(args.cache, 'rb'))
    except:
        seen = set()
        pickle.dump(seen, open(args.cache, 'wb'))

    if args.skip:
        skip = [int(query['torrentid']) for query in\
                [dict(parse_qsl(urlparse(url).query)) for url in args.release_urls]]
        for id in skip:
            print("Skipping torrent {0}".format(str(id)))
            seen.add(str(id))
        pickle.dump(seen, open(args.cache, 'wb'))
        return

    print("Searching for transcode candidates...")
    if args.release_urls:
        if len(args.release_urls) == 1 and os.path.isfile(args.release_urls[0]):
            print("You supplied a url list, ignoring your configuration's media types.")
            with open(args.release_urls[0]) as f:
                candidates = [(int(query['id']), int(query['torrentid'])) for query in\
                        [dict(parse_qsl(urlparse(url).query)) for url in f]]
        else:
            print("You supplied one or more release URLs, ignoring your configuration's media types.")
            candidates = [(int(query['id']), int(query['torrentid'])) for query in\
                    [dict(parse_qsl(urlparse(url).query)) for url in args.release_urls]]
    else:
        candidates = api.snatched()

    for groupid, torrentid in candidates:
        group = api.request('torrentgroup', id=groupid)
        if group != None:
            torrent = [t for t in group['torrents'] if t['id'] == torrentid][0]

            artist = "";
            if len(group['group']['musicInfo']['artists']) > 2:
                artist = "Various Artists"
            elif not group['group']['musicInfo']['artists'] and len(group['group']['musicInfo']['composers']) > 2:
                artist = "Various Artists"
            elif len(group['group']['musicInfo']['artists']) == 2:
                artist = group['group']['musicInfo']['artists'][0]['name'] + " & " + group['group']['musicInfo']['artists'][1]['name']
            elif not group['group']['musicInfo']['artists'] and len(group['group']['musicInfo']['composers']) == 2:
                artist = group['group']['musicInfo']['composers'][0]['name'] + " & " + group['group']['musicInfo']['composers'][1]['name']
            elif not group['group']['musicInfo']['artists'] and len(group['group']['musicInfo']['composers']):
                artist = group['group']['musicInfo']['composers'][0]['name']
            else:
                artist = group['group']['musicInfo']['artists'][0]['name']

            year = str(torrent['remasterYear'])
            if year == "0":
                year = str(group['group']['year'])
            media = str(torrent['media'])

            releaseartist = "Release artist(s): {0}" .format(artist)
            releasename   = "Release name     : {0}" .format(RedOpsAPI.unescape(group['group']['name']))
            releaseyear   = "Release year     : {0}" .format(year)
            releasemedia  = "Release Media    : {0}" .format(media)
            releaseurl    = "Release URL      : {0}" .format(api.release_url(group, torrent))

            print(("\n" + releaseartist + "\n" + releasename + "\n" + releaseyear + "\n" + releasemedia + "\n" + releaseurl + "\n" ))

        if not torrent['filePath']:
            for d in data_dir:
                flac_file = os.path.join(d, RedOpsAPI.unescape(torrent['fileList']).split('{{{')[0])
                if not os.path.exists(flac_file):
                    continue
                flac_dir = os.path.join(d, "{0} ({1}) [FLAC]".format(
                    RedOpsAPI.unescape(group['group']['name']), group['group']['year']))
                if not os.path.exists(flac_dir):
                    os.makedirs(flac_dir)
                shutil.copy(flac_file, flac_dir)
                break

            if not os.path.exists(flac_file):
                continue
        else:
            for d in data_dir:
                flac_dir = os.path.join(d, RedOpsAPI.unescape(torrent['filePath']))
                if os.path.exists(flac_dir):
                    break

        if int(do_24_bit):
            try:
                if transcode.is_24bit(flac_dir) and torrent['encoding'] != '24bit Lossless':
                    # A lot of people are uploading FLACs from Bandcamp without realizing
                    # that they're actually 24 bit files (usually 24/44.1). Since we know for
                    # sure whether the files are 24 bit, we might as well correct the listing
                    # on the site (and get an extra upload in the process).
                    if args.no_24bit_edit:
                        print("Release is actually 24-bit lossless, skipping.")
                        continue
                    if int(do_24_bit) == 1:
                        confirmation = raw_input("Mark release as 24bit lossless? y/n: ")
                        if confirmation != 'y':
                            continue
                    print("Marking release as 24bit lossless.")
                    api.set_24bit(torrent)
                    group = api.request('torrentgroup', id=groupid)
                    torrent = [t for t in group['torrents'] if t['id'] == torrentid][0]
            except Exception as e:
                print("Error: can't edit 24-bit torrent - skipping: {0}".format(e))
                continue

        if transcode.is_multichannel(flac_dir):
            print("This is a multichannel release, which is unsupported - skipping")
            continue

        needed = formats_needed(group, torrent, supported_formats)
        print("Formats needed: {0}".format(', '.join(needed)))

        if needed:
            # Before proceeding, do the basic tag checks on the source
            # files to ensure any uploads won't be reported, but punt
            # on the tracknumber formatting; problems with tracknumber
            # may be fixable when the tags are copied.
            broken_tags = False
            for flac_file in transcode.locate(flac_dir, transcode.ext_matcher('.flac')):
                (ok, msg) = tagged.check_tags(flac_file, check_tracknumber_format=False)
                if not ok:
                    print("A FLAC file in this release has unacceptable tags - skipping: {0}".format(msg))
                    print("You might be able to trump it.")
                    broken_tags = True
                    break
            if broken_tags:
                continue

            while os.path.exists(flac_dir) == False:
                print("Path not found: {0}".format(flac_dir))
                alternative_file_path_exists = ""
                while (alternative_file_path_exists.lower() != "y") and (alternative_file_path_exists.lower() != "n"):
                    alternative_file_path_exists = input("Do you wish to provide an alternative file path? (y/n): ")

                if alternative_file_path_exists.lower() == "y":
                    flac_dir = input("Alternative file path: ")
                else:
                    break

            for format in needed:
                if os.path.exists(flac_dir):
                    print("Adding format {0}...".format(format), end=" ")
                    tmpdir = tempfile.mkdtemp()
                    AlbumName = RedOpsAPI.unescape(group['group']['name'])
                    try:
                        local_output_dir = config_dict['output_dir_{}'.format(format).lower()]
                    except:
                        local_output_dir = output_dir
                    try:
                        local_torrent_dir = config_dict['torrent_dir_{}'.format(format).lower()]
                    except:
                        local_torrent_dir = torrent_dir
                    try:
                        if len(torrent['remasterTitle']) >= 1:
                            basename = artist + " - " + AlbumName + " (" + torrent['remasterTitle'] + ") " + "[" + year + "] (" + torrent['media'] + " - "
                        else:
                            basename = artist + " - " + AlbumName + " [" + year + "] (" + torrent['media'] + " - "

                        transcode_dir = transcode.transcode_release(flac_dir, local_output_dir, basename, format, max_threads=args.threads)
                        if transcode_dir == False:
                            print("Skipping - some file(s) in this release were incorrectly marked as 24bit.")
                            break

                        new_torrent = transcode.make_torrent(transcode_dir, tmpdir, tracker, api.passkey, piece_length, source)
                        if upload_torrent:
                            permalink = api.permalink(torrent)
                            description = create_description(torrent, flac_dir, format, permalink)
                            api.upload(group, torrent, new_torrent, format, description)
                        shutil.copy(new_torrent, local_torrent_dir)
                        print("done!")
                        if args.single: break
                    except Exception as e:
                        print("Error adding format {0}: {1}".format(format, e))
                        traceback.print_exc()
                    finally:
                        shutil.rmtree(tmpdir)
                else:
                    print("Path not found - skipping: {0}".format(flac_dir))
                    break

        seen.add(str(torrentid))
        pickle.dump(seen, open(args.cache, 'wb'))

if __name__ == "__main__":
    authFile = "config"
    main()