Beispiel #1
0
def shows(list_type, add_limit=0, add_delay=2.5, sort='votes', genre=None, folder=None, actor=None, no_search=False,
          notifications=False, authenticate_user=None, ignore_blacklist=False, remove_rejected_from_recommended=False):
    from media.sonarr import Sonarr
    from media.trakt import Trakt
    from helpers import misc as misc_helper
    from helpers import sonarr as sonarr_helper
    from helpers import trakt as trakt_helper

    added_shows = 0

    # remove genre from shows blacklisted_genres if supplied
    if genre:
        misc_helper.unblacklist_genres(genre, cfg['filters']['shows']['blacklisted_genres'])

    # replace sonarr root_folder if folder is supplied
    if folder:
        cfg['sonarr']['root_folder'] = folder

    # validate trakt client_id
    trakt = Trakt(cfg)
    sonarr = Sonarr(cfg.sonarr.url, cfg.sonarr.api_key)

    validate_trakt(trakt, notifications)
    validate_pvr(sonarr, 'Sonarr', notifications)

    profile_id = get_profile_id(sonarr, cfg.sonarr.profile)
    profile_tags = get_profile_tags(sonarr)

    pvr_objects_list = get_objects(sonarr, 'Sonarr', notifications)

    # get trakt series list
    if list_type.lower() == 'anticipated':
        trakt_objects_list = trakt.get_anticipated_shows(genres=genre, languages=cfg.filters.shows.allowed_languages)
    elif list_type.lower() == 'trending':
        trakt_objects_list = trakt.get_trending_shows(genres=genre, languages=cfg.filters.shows.allowed_languages)
    elif list_type.lower() == 'popular':
        trakt_objects_list = trakt.get_popular_shows(genres=genre, languages=cfg.filters.shows.allowed_languages)
    elif list_type.lower() == 'person':
        if not actor:
            log.error("You must specify an actor with the --actor / -a parameter when using the person list type!")
            return None
        trakt_objects_list = trakt.get_person_shows(person=actor, genres=genre,
                                                    languages=cfg.filters.shows.allowed_languages)
    elif list_type.lower() == 'recommended':
        trakt_objects_list = trakt.get_recommended_shows(authenticate_user, genres=genre,
                                                         languages=cfg.filters.shows.allowed_languages)
    elif list_type.lower().startswith('played'):
        most_type = misc_helper.substring_after(list_type.lower(), "_")
        trakt_objects_list = trakt.get_most_played_shows(genres=genre, languages=cfg.filters.shows.allowed_languages,
                                                         most_type=most_type if most_type else None)
    elif list_type.lower().startswith('watched'):
        most_type = misc_helper.substring_after(list_type.lower(), "_")
        trakt_objects_list = trakt.get_most_watched_shows(genres=genre, languages=cfg.filters.shows.allowed_languages,
                                                          most_type=most_type if most_type else None)
    elif list_type.lower() == 'watchlist':
        trakt_objects_list = trakt.get_watchlist_shows(authenticate_user)
    else:
        trakt_objects_list = trakt.get_user_list_shows(list_type, authenticate_user)

    if not trakt_objects_list:
        log.error("Aborting due to failure to retrieve Trakt %s shows list", list_type)
        if notifications:
            callback_notify(
                {'event': 'abort', 'type': 'shows', 'list_type': list_type,
                 'reason': 'Failure to retrieve Trakt %s shows list' % list_type})
        return None
    else:
        log.info("Retrieved Trakt %s shows list, shows found: %d", list_type, len(trakt_objects_list))

    # set remove_rejected_recommended to False if this is not the recommended list
    if list_type.lower() != 'recommended':
        remove_rejected_from_recommended = False

    # build filtered series list without series that exist in sonarr
    processed_series_list = sonarr_helper.remove_existing_series(pvr_objects_list, trakt_objects_list,
                                                                 callback_remove_recommended
                                                                 if remove_rejected_from_recommended else None)
    if processed_series_list is None:
        log.error("Aborting due to failure to remove existing Sonarr shows from retrieved Trakt shows list")
        if notifications:
            callback_notify({'event': 'abort', 'type': 'shows', 'list_type': list_type,
                             'reason': 'Failure to remove existing Sonarr shows from retrieved Trakt %s shows list'
                                       % list_type})
        return None
    else:
        log.info("Removed existing Sonarr shows from Trakt shows list, shows left to process: %d",
                 len(processed_series_list))

    # sort filtered series list
    if sort == 'release':
        sorted_series_list = misc_helper.sorted_list(processed_series_list, 'show', 'first_aired')
        log.info("Sorted shows list to process by release date")
    elif sort == 'rating':
        sorted_series_list = misc_helper.sorted_list(processed_series_list, 'show', 'rating')
        log.info("Sorted shows list to process by highest rating")
    else:
        sorted_series_list = misc_helper.sorted_list(processed_series_list, 'show', 'votes')
        log.info("Sorted shows list to process by highest votes")

    # loop series_list
    log.info("Processing list now...")
    for series in sorted_series_list:
        try:
            # check if genre matches genre supplied via argument
            if genre and not misc_helper.allowed_genres(genre, 'show', series):
                log.debug("Skipping: %s because it was not from %s genre(s)", series['show']['title'], genre.lower())
                continue

            # check if series passes out blacklist criteria inspection
            if not trakt_helper.is_show_blacklisted(series, cfg.filters.shows, ignore_blacklist,
                                                    callback_remove_recommended
                                                    if remove_rejected_from_recommended else None):
                log.info("Adding: %s | Genres: %s | Network: %s | Country: %s", series['show']['title'],
                         ', '.join(series['show']['genres']), series['show']['network'],
                         series['show']['country'].upper())

                # determine which tags to use when adding this series
                use_tags = sonarr_helper.series_tag_id_from_network(profile_tags, cfg.sonarr.tags,
                                                                    series['show']['network'])
                # add show to sonarr
                if sonarr.add_series(series['show']['ids']['tvdb'], series['show']['title'],
                                     series['show']['ids']['slug'], profile_id, cfg.sonarr.root_folder, use_tags,
                                     not no_search):
                    log.info("ADDED %s (%d) with tags: %s", series['show']['title'], series['show']['year'],
                             sonarr_helper.readable_tag_from_ids(profile_tags, use_tags))
                    if notifications:
                        callback_notify({'event': 'add_show', 'list_type': list_type, 'show': series['show']})
                    added_shows += 1
                else:
                    log.error("FAILED adding %s (%d) with tags: %s", series['show']['title'], series['show']['year'],
                              sonarr_helper.readable_tag_from_ids(profile_tags, use_tags))

                # stop adding shows, if added_shows >= add_limit
                if add_limit and added_shows >= add_limit:
                    break

                # sleep before adding any more
                time.sleep(add_delay)

        except Exception:
            log.exception("Exception while processing show %s: ", series['show']['title'])

    log.info("Added %d new show(s) to Sonarr", added_shows)

    # send notification
    if notifications and (cfg.notifications.verbose or added_shows > 0):
        notify.send(message="Added %d shows from Trakt's %s list" % (added_shows, list_type))

    return added_shows
Beispiel #2
0
def shows(list_type,
          add_limit=0,
          add_delay=2.5,
          genre=None,
          no_search=False,
          notifications=False):
    added_shows = 0

    # validate trakt api_key
    trakt = Trakt(cfg.trakt.api_key)
    if not trakt.validate_api_key():
        log.error("Aborting due to failure to validate Trakt API Key")
        if notifications:
            callback_notify({
                'event': 'abort',
                'type': 'shows',
                'list_type': list_type,
                'reason': 'Failure to validate Trakt API Key'
            })
        return None
    else:
        log.info("Validated Trakt API Key")

    # validate sonarr url & api_key
    sonarr = Sonarr(cfg.sonarr.url, cfg.sonarr.api_key)
    if not sonarr.validate_api_key():
        log.error("Aborting due to failure to validate Sonarr URL / API Key")
        if notifications:
            callback_notify({
                'event':
                'abort',
                'type':
                'shows',
                'list_type':
                list_type,
                'reason':
                'Failure to validate Sonarr URL / API Key'
            })
        return None
    else:
        log.info("Validated Sonarr URL & API Key")

    # retrieve profile id for requested profile
    profile_id = sonarr.get_profile_id(cfg.sonarr.profile)
    if not profile_id or not profile_id > 0:
        log.error("Aborting due to failure to retrieve Profile ID for: %s",
                  cfg.sonarr.profile)
        if notifications:
            callback_notify({
                'event':
                'abort',
                'type':
                'shows',
                'list_type':
                list_type,
                'reason':
                'Failure to retrieve Sonarr Profile ID of %s' %
                cfg.sonarr.profile
            })
        return None
    else:
        log.info("Retrieved Profile ID for %s: %d", cfg.sonarr.profile,
                 profile_id)

    # retrieve profile tags
    profile_tags = sonarr.get_tags()
    if profile_tags is None:
        log.error("Aborting due to failure to retrieve Tag ID's")
        if notifications:
            callback_notify({
                'event': 'abort',
                'type': 'shows',
                'list_type': list_type,
                'reason': "Failure to retrieve Sonarr Tag ID's"
            })
        return None
    else:
        log.info("Retrieved %d Tag ID's", len(profile_tags))

    # get sonarr series list
    sonarr_series_list = sonarr.get_series()
    if not sonarr_series_list:
        log.error("Aborting due to failure to retrieve Sonarr shows list")
        if notifications:
            callback_notify({
                'event': 'abort',
                'type': 'shows',
                'list_type': list_type,
                'reason': 'Failure to retrieve Sonarr shows list'
            })
        return None
    else:
        log.info("Retrieved Sonarr shows list, shows found: %d",
                 len(sonarr_series_list))

    # get trakt series list
    trakt_series_list = None
    if list_type.lower() == 'anticipated':
        trakt_series_list = trakt.get_anticipated_shows()
    elif list_type.lower() == 'trending':
        trakt_series_list = trakt.get_trending_shows()
    elif list_type.lower() == 'popular':
        trakt_series_list = trakt.get_popular_shows()
    else:
        log.error("Aborting due to unknown Trakt list type")
        if notifications:
            callback_notify({
                'event': 'abort',
                'type': 'shows',
                'list_type': list_type,
                'reason': 'Failure to determine Trakt list type'
            })
        return None
    if not trakt_series_list:
        log.error("Aborting due to failure to retrieve Trakt %s shows list",
                  list_type)
        if notifications:
            callback_notify({
                'event':
                'abort',
                'type':
                'shows',
                'list_type':
                list_type,
                'reason':
                'Failure to retrieve Trakt %s shows list' % list_type
            })
        return None
    else:
        log.info("Retrieved Trakt %s shows list, shows found: %d", list_type,
                 len(trakt_series_list))

    # build filtered series list without series that exist in sonarr
    processed_series_list = helpers.sonarr_remove_existing_series(
        sonarr_series_list, trakt_series_list)
    if processed_series_list is None:
        log.error(
            "Aborting due to failure to remove existing Sonarr shows from retrieved Trakt shows list"
        )
        if notifications:
            callback_notify({
                'event':
                'abort',
                'type':
                'shows',
                'list_type':
                list_type,
                'reason':
                'Failure to remove existing Sonarr shows from retrieved Trakt %s shows list'
                % list_type
            })
        return None
    else:
        log.info(
            "Removed existing Sonarr shows from Trakt shows list, shows left to process: %d",
            len(processed_series_list))

    # sort filtered series list by highest votes
    sorted_series_list = sorted(processed_series_list,
                                key=lambda k: k['show']['votes'],
                                reverse=True)
    log.info("Sorted shows list to process by highest votes")

    # loop series_list
    log.info("Processing list now...")
    for series in sorted_series_list:
        try:
            # check if genre matches genre supplied via argument
            if genre and genre.lower() not in series['show']['genres']:
                log.debug("Skipping: %s because it was not from %s genre",
                          series['show']['title'], genre.lower())
                continue

            # check if series passes out blacklist criteria inspection
            if not helpers.trakt_is_show_blacklisted(series,
                                                     cfg.filters.shows):
                log.info("Adding: %s | Genres: %s | Network: %s | Country: %s",
                         series['show']['title'],
                         ', '.join(series['show']['genres']),
                         series['show']['network'],
                         series['show']['country'].upper())

                # determine which tags to use when adding this series
                use_tags = helpers.sonarr_series_tag_id_from_network(
                    profile_tags, cfg.sonarr.tags, series['show']['network'])
                # add show to sonarr
                if sonarr.add_series(series['show']['ids']['tvdb'],
                                     series['show']['title'],
                                     series['show']['ids']['slug'], profile_id,
                                     cfg.sonarr.root_folder, use_tags,
                                     not no_search):
                    log.info(
                        "ADDED %s (%d) with tags: %s", series['show']['title'],
                        series['show']['year'],
                        helpers.sonarr_readable_tag_from_ids(
                            profile_tags, use_tags))
                    if notifications:
                        callback_notify({
                            'event': 'add_show',
                            'list_type': list_type,
                            'show': series['show']
                        })
                    added_shows += 1
                else:
                    log.error(
                        "FAILED adding %s (%d) with tags: %s",
                        series['show']['title'], series['show']['year'],
                        helpers.sonarr_readable_tag_from_ids(
                            profile_tags, use_tags))

                # stop adding shows, if added_shows >= add_limit
                if add_limit and added_shows >= add_limit:
                    break

                # sleep before adding any more
                time.sleep(add_delay)

        except Exception:
            log.exception("Exception while processing show %s: ",
                          series['show']['title'])

    log.info("Added %d new show(s) to Sonarr", added_shows)

    # send notification
    if notifications:
        notify.send(message="Added %d shows from Trakt's %s list" %
                    (added_shows, list_type))

    return added_shows