'Accept or Reject episode or season pack from available releases, or postpone choosing.
:param task: Current Task
:param series_entries: dict mapping Episodes or Seasons to entries for that episode or season_pack
:param config: Series configuration'

def process_series(self, task, series_entries, config):

    accepted_seasons = []
    for (entity, entries) in sorted(series_entries.items(), key=(lambda e: (e[0].is_season, (e[0].season or (-1)))), reverse=True):
        if (not entries):
            continue
        reason = None
        entries.sort(key=(lambda e: (e[u'quality'], e[u'series_parser'].episodes, e[u'series_parser'].proper_count)), reverse=True)
        log.debug(u'start    with    entities:    %s', [e[u'title'] for e in entries])
        season_packs = self.season_pack_opts(config.get(u'season_packs', False))
        if (entity.is_season and (not season_packs)):
            for entry in entries:
                entry.reject(u'season    pack    support    is    turned    off')
            continue
        if ((not entity.is_season) and season_packs and season_packs[u'reject_eps']):
            for entry in entries:
                entry.reject(u'season    pack    only    mode')
            continue
        ep_threshold = (season_packs[u'threshold'] if season_packs else 0)
        if (entity.season in accepted_seasons):
            for entry in entries:
                entry.reject((u'already    accepted    season    pack    for    season    `%s`    in    this    task' % entity.season))
            continue
        if entity.series.begin:
            if (entity < entity.series.begin):
                for entry in entries:
                    entry.reject((u'Entity    `%s`    is    before    begin    value    of    `%s`' % (entity.identifier, entity.series.begin.identifier)))
                continue
        if ((not config.get(u'specials', True)) and (entity.identified_by == u'special')):
            log.debug(u'Skipping    special    episode    as    support    is    turned    off.')
            continue
        log.debug(u'current    entities:    %s', [e[u'title'] for e in entries])
        if (u'quality' in config):
            entries = self.process_quality(config, entries)
            if (not entries):
                continue
            reason = u'matches    quality'
        downloaded = entity.downloaded_releases
        downloaded_qualities = [rls.quality for rls in downloaded]
        log.debug(((u'-' * 20) + u'    process_propers    -->'))
        entries = self.process_propers(config, entity, entries)
        if (not entries):
            continue
        for entry in reversed(entries):
            if (entry[u'quality'] in downloaded_qualities):
                entry.reject(u'quality    already    downloaded')
                entries.remove(entry)
        if (not entries):
            continue
        if downloaded:
            if config.get(u'upgrade'):
                for entry in reversed(entries):
                    if (entry[u'quality'] < max(downloaded_qualities)):
                        entry.reject(u'worse    quality    than    already    downloaded.')
                        entries.remove(entry)
            if (not entries):
                continue
            if ((u'target' in config) and config.get(u'upgrade')):
                self.process_timeframe_target(config, entries, downloaded)
                continue
            if (u'qualities' in config):
                log.debug(((u'-' * 20) + u'    process_qualities    -->'))
                self.process_qualities(config, entries, downloaded)
                continue
            elif config.get(u'upgrade'):
                entries[0].accept(u'is    an    upgrade    to    existing    quality')
                continue
            for entry in entries:
                entry.reject(u'entity    has    already    been    downloaded')
            continue
        best = entries[0]
        log.debug(u'continuing    w.    entities:    %s', [e[u'title'] for e in entries])
        log.debug(u'best    entity    is:    `%s`', best[u'title'])
        if (entity.identified_by in [u'ep', u'sequence']):
            if (task.options.disable_tracking or (not config.get(u'tracking', True))):
                log.debug(u'episode    tracking    disabled')
            else:
                log.debug(((u'-' * 20) + u'    tracking    -->'))
                backfill = (config.get(u'tracking') == u'backfill')
                if self.process_entity_tracking(entity, entries, grace=(len(series_entries) + 2), backfill=backfill, threshold=ep_threshold):
                    continue
        if ((u'target' in config) or (u'qualities' in config)):
            if (u'target' in config):
                if self.process_timeframe_target(config, entries, downloaded):
                    continue
            elif (u'qualities' in config):
                if self.process_qualities(config, entries, downloaded):
                    continue
            if (u'timeframe' in config):
                if self.process_timeframe(task, config, entity, entries):
                    continue
                reason = u'Timeframe    expired,    choosing    best    available'
            else:
                continue
        reason = (reason or u'choosing    best    available    quality')
        best.accept(reason)
        if entity.is_season:
            log.debug(u'adding    season    number    `%s`    to    accepted    seasons    for    this    task', entity.season)
            accepted_seasons.append(entity.season)
