From 2244b5bc23ff3da798096ad8b2ae5ff21a8647db Mon Sep 17 00:00:00 2001
From: Dario <dariovizz@hotmail.it>
Date: Fri, 13 Jul 2018 13:42:42 +0200
Subject: [PATCH 01/11] Rename Season search mode to Backlog search mode

---
 themes-default/slim/views/config_providers.mako | 8 ++++----
 themes/dark/templates/config_providers.mako     | 8 ++++----
 themes/light/templates/config_providers.mako    | 8 ++++----
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/themes-default/slim/views/config_providers.mako b/themes-default/slim/views/config_providers.mako
index f31ab7a4df..b8ac7896ad 100644
--- a/themes-default/slim/views/config_providers.mako
+++ b/themes-default/slim/views/config_providers.mako
@@ -1128,9 +1128,9 @@ const startVue = () => {
                         % if hasattr(cur_nzb_provider, 'search_mode'):
                         <div class="field-pair">
                             <label>
-                                <span class="component-title">Season search mode</span>
+                                <span class="component-title">Backlog search mode</span>
                                 <span class="component-desc">
-                                    <p>when searching for complete seasons you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
+                                    <p>when searching with backlog you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
                                 </span>
                             </label>
                             <label>
@@ -1438,9 +1438,9 @@ const startVue = () => {
                         % if hasattr(cur_torrent_provider, 'search_mode'):
                         <div class="field-pair">
                             <label>
-                                <span class="component-title">Season search mode</span>
+                                <span class="component-title">Backlog search mode</span>
                                 <span class="component-desc">
-                                    <p>when searching for complete seasons you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
+                                    <p>when searching with backlog you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
                                 </span>
                             </label>
                             <label>
diff --git a/themes/dark/templates/config_providers.mako b/themes/dark/templates/config_providers.mako
index f31ab7a4df..b8ac7896ad 100644
--- a/themes/dark/templates/config_providers.mako
+++ b/themes/dark/templates/config_providers.mako
@@ -1128,9 +1128,9 @@ const startVue = () => {
                         % if hasattr(cur_nzb_provider, 'search_mode'):
                         <div class="field-pair">
                             <label>
-                                <span class="component-title">Season search mode</span>
+                                <span class="component-title">Backlog search mode</span>
                                 <span class="component-desc">
-                                    <p>when searching for complete seasons you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
+                                    <p>when searching with backlog you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
                                 </span>
                             </label>
                             <label>
@@ -1438,9 +1438,9 @@ const startVue = () => {
                         % if hasattr(cur_torrent_provider, 'search_mode'):
                         <div class="field-pair">
                             <label>
-                                <span class="component-title">Season search mode</span>
+                                <span class="component-title">Backlog search mode</span>
                                 <span class="component-desc">
-                                    <p>when searching for complete seasons you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
+                                    <p>when searching with backlog you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
                                 </span>
                             </label>
                             <label>
diff --git a/themes/light/templates/config_providers.mako b/themes/light/templates/config_providers.mako
index f31ab7a4df..b8ac7896ad 100644
--- a/themes/light/templates/config_providers.mako
+++ b/themes/light/templates/config_providers.mako
@@ -1128,9 +1128,9 @@ const startVue = () => {
                         % if hasattr(cur_nzb_provider, 'search_mode'):
                         <div class="field-pair">
                             <label>
-                                <span class="component-title">Season search mode</span>
+                                <span class="component-title">Backlog search mode</span>
                                 <span class="component-desc">
-                                    <p>when searching for complete seasons you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
+                                    <p>when searching with backlog you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
                                 </span>
                             </label>
                             <label>
@@ -1438,9 +1438,9 @@ const startVue = () => {
                         % if hasattr(cur_torrent_provider, 'search_mode'):
                         <div class="field-pair">
                             <label>
-                                <span class="component-title">Season search mode</span>
+                                <span class="component-title">Backlog search mode</span>
                                 <span class="component-desc">
-                                    <p>when searching for complete seasons you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
+                                    <p>when searching with backlog you can choose to have it look for season packs only, or choose to have it build a complete season from just single episodes.</p>
                                 </span>
                             </label>
                             <label>

From fe095c553daf14d8bad575e25a1175b915b05296 Mon Sep 17 00:00:00 2001
From: Dario <dariovizz@hotmail.it>
Date: Sun, 15 Jul 2018 02:01:05 +0200
Subject: [PATCH 02/11] Improve multi-episode and season snatches. Fixes #229

---
 medusa/classes.py                    |  7 +++--
 medusa/providers/generic_provider.py |  8 +++---
 medusa/search/core.py                | 42 ++++++----------------------
 3 files changed, 18 insertions(+), 39 deletions(-)

diff --git a/medusa/classes.py b/medusa/classes.py
index c4407c7b93..8637084838 100644
--- a/medusa/classes.py
+++ b/medusa/classes.py
@@ -211,8 +211,11 @@ def add_result_to_cache(self, cache):
 
     def create_episode_object(self):
         """Use this result to create an episode segment out of it."""
-        if self.actual_season and self.actual_episodes and self.series:
-            self.episodes = [self.series.get_episode(self.actual_season, ep) for ep in self.actual_episodes]
+        if self.actual_season and self.series:
+            if self.actual_episodes:
+                self.episodes = [self.series.get_episode(self.actual_season, ep) for ep in self.actual_episodes]
+            else:
+                self.episodes = self.series.get_all_episodes(self.actual_season)
         return self.episodes
 
     def finish_search_result(self, provider):
diff --git a/medusa/providers/generic_provider.py b/medusa/providers/generic_provider.py
index 19cb612cc5..5979499463 100644
--- a/medusa/providers/generic_provider.py
+++ b/medusa/providers/generic_provider.py
@@ -458,15 +458,15 @@ def find_search_results(self, series, episodes, search_mode, forced_search=False
 
             log.debug('Found result {0} at {1}', search_result.name, search_result.url)
 
-            episode_object = search_result.create_episode_object()
+            search_result.create_episode_object()
             # result = self.get_result(episode_object, search_result)
             search_result.finish_search_result(self)
 
-            if not episode_object:
+            if not search_result.actual_episodes:
                 episode_number = SEASON_RESULT
                 log.debug('Found season pack result {0} at {1}', search_result.name, search_result.url)
-            elif len(episode_object) == 1:
-                episode_number = episode_object[0].episode
+            elif len(search_result.actual_episodes) == 1:
+                episode_number = search_result.actual_episode
                 log.debug('Found single episode result {0} at {1}', search_result.name, search_result.url)
             else:
                 episode_number = MULTI_EP_RESULT
diff --git a/medusa/search/core.py b/medusa/search/core.py
index 5f7919ee6d..550a9475e9 100644
--- a/medusa/search/core.py
+++ b/medusa/search/core.py
@@ -805,41 +805,20 @@ def collect_multi_candidates(candidates, series_obj, episodes, down_cur_quality)
     if not wanted_candidates:
         return multi_candidates, single_candidates
 
-    searched_seasons = {str(x.season) for x in episodes}
-    main_db_con = db.DBConnection()
-    selection = main_db_con.select(
-        'SELECT episode '
-        'FROM tv_episodes '
-        'WHERE indexer = ?'
-        ' AND showid = ?'
-        ' AND ( season IN ( {0} ) )'.format(','.join(searched_seasons)),
-        [series_obj.indexer, series_obj.series_id]
-    )
-    all_eps = [int(x[b'episode']) for x in selection]
-    log.debug(u'Episodes list: {0}', all_eps)
-
     for candidate in wanted_candidates:
-        season_quality = candidate.quality
-
         all_wanted = True
         any_wanted = False
-        for cur_ep_num in all_eps:
-            for season in {x.season for x in episodes}:
-                if not series_obj.want_episode(season, cur_ep_num, season_quality,
-                                               down_cur_quality):
-                    all_wanted = False
-                else:
-                    any_wanted = True
+        for ep_obj in candidate.episodes:
+            if not series_obj.want_episode(ep_obj.season, ep_obj.episode,
+                                           candidate.quality, down_cur_quality):
+                all_wanted = False
+            else:
+                any_wanted = True
 
         if all_wanted:
             log.info(u'All episodes in this season are needed, adding {0} {1}',
                      candidate.provider.provider_type,
                      candidate.name)
-            ep_objs = []
-            for cur_ep_num in all_eps:
-                for season in {x.season for x in episodes}:
-                    ep_objs.append(series_obj.get_episode(season, cur_ep_num))
-            candidate.episodes = ep_objs
 
             # Skip the result if search delay is enabled for the provider
             if not delay_search(candidate):
@@ -871,12 +850,9 @@ def collect_multi_candidates(candidates, series_obj, episodes, down_cur_quality)
             else:
                 log.info(u'Adding multi-episode result for full-season torrent.'
                          u' Undesired episodes can be skipped in the torrent client if desired!')
-                ep_objs = []
-                for cur_ep_num in all_eps:
-                    for season in {x.season for x in episodes}:
-                        ep_objs.append(series_obj.get_episode(season, cur_ep_num))
-                candidate.episodes = ep_objs
-                multi_candidates.append(candidate)
+                # Skip the result if search delay is enabled for the provider
+                if not delay_search(candidate):
+                    multi_candidates.append(candidate)
 
     return multi_candidates, single_candidates
 

From 6b21f58ebb4f40ce02cdb0d2a0b876455766f43c Mon Sep 17 00:00:00 2001
From: Dario <dariovizz@hotmail.it>
Date: Sun, 15 Jul 2018 02:19:29 +0200
Subject: [PATCH 03/11] Remove unused import

---
 medusa/search/core.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/medusa/search/core.py b/medusa/search/core.py
index 550a9475e9..ffae1b1b65 100644
--- a/medusa/search/core.py
+++ b/medusa/search/core.py
@@ -11,7 +11,6 @@
 import os
 import threading
 import time
-from builtins import str
 
 from medusa import (
     app,

From 2567c84b1ca38ed38d82a58bad6f60a38a1cde4c Mon Sep 17 00:00:00 2001
From: Dario <dariovizz@hotmail.it>
Date: Tue, 17 Jul 2018 17:58:49 +0200
Subject: [PATCH 04/11] Add support for multi-episodes cache results, remove
 naive quality comparisions

---
 medusa/providers/generic_provider.py | 32 +++++------
 medusa/search/core.py                | 84 +++++++++++++++++-----------
 medusa/tv/cache.py                   | 82 ++++++++++++++-------------
 3 files changed, 109 insertions(+), 89 deletions(-)

diff --git a/medusa/providers/generic_provider.py b/medusa/providers/generic_provider.py
index 5979499463..6bde258e9b 100644
--- a/medusa/providers/generic_provider.py
+++ b/medusa/providers/generic_provider.py
@@ -247,21 +247,24 @@ def find_search_results(self, series, episodes, search_mode, forced_search=False
 
         results = {}
         items_list = []
+        season_search = (
+            len(episodes) > 1 or manual_search_type == 'season'
+        ) and search_mode == 'sponly'
 
         for episode in episodes:
             if not manual_search:
-                cache_result = self.cache.search_cache(episode, forced_search=forced_search,
-                                                       down_cur_quality=download_current_quality)
+                cache_result = self.cache.find_needed_episodes(
+                    episode, forced_search=forced_search, down_cur_quality=download_current_quality
+                )
                 if cache_result:
-                    if episode.episode not in results:
-                        results[episode.episode] = cache_result
-                    else:
-                        results[episode.episode].extend(cache_result)
-
+                    for episode_no in cache_result:
+                        if episode_no not in results:
+                            results[episode_no] = cache_result[episode_no]
+                        else:
+                            results[episode_no] += cache_result[episode_no]
                     continue
 
             search_strings = []
-            season_search = (len(episodes) > 1 or manual_search_type == 'season') and search_mode == 'sponly'
             if season_search:
                 search_strings = self._get_season_search_strings(episode)
             elif search_mode == 'eponly':
@@ -273,13 +276,11 @@ def find_search_results(self, series, episodes, search_mode, forced_search=False
                     search_string, ep_obj=episode, manual_search=manual_search
                 )
 
-            # In season search, we can't loop in episodes lists as we only need one episode to get the season string
+            # In season search, we can't loop in episodes lists as we
+            # only need one episode to get the season string
             if search_mode == 'sponly':
                 break
 
-        if len(results) == len(episodes):
-            return results
-
         # Remove duplicate items
         unique_items = self.remove_duplicate_mappings(items_list)
         log.debug('Found {0} unique items', len(unique_items))
@@ -303,8 +304,6 @@ def find_search_results(self, series, episodes, search_mode, forced_search=False
         # unpack all of the quality lists into a single sorted list
         items_list = list(sorted_items)
 
-        cl = []
-
         # Move through each item and parse it into a quality
         search_results = []
         for item in items_list:
@@ -443,6 +442,7 @@ def find_search_results(self, series, episodes, search_mode, forced_search=False
                             search_result.actual_season = int(sql_results[0][b'season'])
                             search_result.actual_episodes = [int(sql_results[0][b'episode'])]
 
+        cl = []
         # Iterate again over the search results, and see if there is anything we want.
         for search_result in search_results:
 
@@ -521,10 +521,6 @@ def make_id(name):
 
         return re.sub(r'[^\w\d_]', '_', str(name).strip().lower())
 
-    def search_rss(self, episodes):
-        """Find cached needed episodes."""
-        return self.cache.find_needed_episodes(episodes)
-
     def seed_ratio(self):
         """Return ratio."""
         return ''
diff --git a/medusa/search/core.py b/medusa/search/core.py
index ffae1b1b65..ccbc113754 100644
--- a/medusa/search/core.py
+++ b/medusa/search/core.py
@@ -475,28 +475,32 @@ def wanted_episodes(series_obj, from_date):
                     u'reason': should_search_reason,
                 }
             )
+
         ep_obj = series_obj.get_episode(episode[b'season'], episode[b'episode'])
-        ep_obj.wanted_quality = [i for i in all_qualities if i > cur_quality]
+        ep_obj.wanted_quality = [
+            quality
+            for quality in all_qualities
+            if Quality.is_higher_quality(
+                cur_quality, quality, allowed_qualities, preferred_qualities
+            )
+        ]
         wanted.append(ep_obj)
 
     return wanted
 
 
 def search_for_needed_episodes(force=False):
-    """
-    Check providers for details on wanted episodes.
-
-    :return: episodes we have a search hit for
-    """
-    found_results = {}
-
+    """Check providers for details on wanted episodes."""
     show_list = app.showList
     from_date = datetime.date.fromordinal(1)
     episodes = []
 
     for cur_show in show_list:
         if cur_show.paused:
-            log.debug(u'Not checking for needed episodes of {0} because the show is paused', cur_show.name)
+            log.debug(
+                u'Not checking for needed episodes of {0} because the show is paused',
+                cur_show.name,
+            )
             continue
         episodes.extend(wanted_episodes(cur_show, from_date))
 
@@ -504,58 +508,74 @@ def search_for_needed_episodes(force=False):
         # nothing wanted so early out, ie: avoid whatever arbitrarily
         # complex thing a provider cache update entails, for example,
         # reading rss feeds
-        return list(itervalues(found_results))
-
-    original_thread_name = threading.currentThread().name
+        return []
 
     providers = enabled_providers(u'daily')
-
     if not providers:
-        log.warning(u'No NZB/Torrent providers found or enabled in the application config for daily searches.'
-                    u' Please check your settings')
-        return list(itervalues(found_results))
+        log.warning(
+            u'No NZB/Torrent providers found or enabled in the application config for daily searches.'
+            u' Please check your settings'
+        )
+        return []
 
+    original_thread_name = threading.currentThread().name
     log.info(u'Using daily search providers')
+
     for cur_provider in providers:
-        threading.currentThread().name = u'{thread} :: [{provider}]'.format(thread=original_thread_name,
-                                                                            provider=cur_provider.name)
+        threading.currentThread().name = u'{thread} :: [{provider}]'.format(
+            thread=original_thread_name, provider=cur_provider.name
+        )
         cur_provider.cache.update_cache()
 
+    single_results = {}
+    multi_results = []
     for cur_provider in providers:
-        threading.currentThread().name = u'{thread} :: [{provider}]'.format(thread=original_thread_name,
-                                                                            provider=cur_provider.name)
+        threading.currentThread().name = u'{thread} :: [{provider}]'.format(
+            thread=original_thread_name, provider=cur_provider.name
+        )
         try:
-            cur_found_results = cur_provider.search_rss(episodes)
+            found_results = cur_provider.cache.find_needed_episodes(episodes)
         except AuthException as error:
             log.error(u'Authentication error: {0}', ex(error))
             continue
 
         # pick a single result for each episode, respecting existing results
-        for cur_ep in cur_found_results:
-            if not cur_ep.series or cur_ep.series.paused:
-                log.debug(u'Skipping {0} because the show is paused ', cur_ep.pretty_name())
+        for episode_no, results in iteritems(found_results):
+            if results[0].series.paused:
+                log.debug(u'Skipping {0} because the show is paused.', results[0].series.name)
                 continue
 
             # if all results were rejected move on to the next episode
-            wanted_results = filter_results(cur_found_results[cur_ep])
+            wanted_results = filter_results(results)
             if not wanted_results:
-                log.debug(u'All found results for {0} were rejected.', cur_ep.pretty_name())
+                log.debug(u'All found results for {0} were rejected.', results[0].series.name)
                 continue
 
             best_result = pick_result(wanted_results)
-            # if it's already in the list (from another provider) and the newly found quality is no better then skip it
-            if cur_ep in found_results and best_result.quality <= found_results[cur_ep].quality:
-                continue
-
             # Skip the result if search delay is enabled for the provider.
             if delay_search(best_result):
                 continue
 
-            found_results[cur_ep] = best_result
+            if episode_no in (SEASON_RESULT, MULTI_EP_RESULT):
+                multi_results.append(best_result)
+            else:
+                # if it's already in the list (from another provider) and
+                # the newly found quality is no better then skip it
+                if episode_no in single_results:
+                    allowed_qualities, preferred_qualities = results[0].series.current_qualities
+                    if not Quality.is_higher_quality(
+                        single_results[episode_no].quality,
+                        best_result.quality,
+                        allowed_qualities,
+                        preferred_qualities
+                    ):
+                        continue
+
+                single_results[episode_no] = best_result
 
     threading.currentThread().name = original_thread_name
 
-    return list(itervalues(found_results))
+    return combine_results(multi_results, list(itervalues(single_results)))
 
 
 def delay_search(best_result):
diff --git a/medusa/tv/cache.py b/medusa/tv/cache.py
index 1ba7fb576c..94b5a4f992 100644
--- a/medusa/tv/cache.py
+++ b/medusa/tv/cache.py
@@ -15,6 +15,10 @@
     app,
     db,
 )
+from medusa.common import (
+    MULTI_EP_RESULT,
+    SEASON_RESULT,
+)
 from medusa.helper.common import episode_num
 from medusa.helper.exceptions import AuthException
 from medusa.logger.adapters.style import BraceAdapter
@@ -413,7 +417,7 @@ def add_cache_entry(self, name, url, seeders, leechers, size, pubdate, parsed_re
             proper_tags = '|'.join(parse_result.proper_tags)
 
             if not self.item_in_cache(url):
-                log.debug('Added RSS item: {0} to cache: {1} with url {2}', name, self.provider_id, url)
+                log.debug('Added item: {0} to cache: {1} with url {2}', name, self.provider_id, url)
                 return [
                     b'INSERT INTO [{name}] '
                     b'   (name, season, episodes, indexerid, url, time, quality, '
@@ -427,7 +431,7 @@ def add_cache_entry(self, name, url, seeders, leechers, size, pubdate, parsed_re
                      seeders, leechers, size, pubdate, proper_tags, cur_timestamp, parse_result.series.indexer]
                 ]
             else:
-                log.debug('Updating RSS item: {0} to cache: {1}', name, self.provider_id)
+                log.debug('Updating item: {0} to cache: {1}', name, self.provider_id)
                 return [
                     b'UPDATE [{name}] '
                     b'SET name=?, season=?, episodes=?, indexer=?, indexerid=?, '
@@ -441,13 +445,6 @@ def add_cache_entry(self, name, url, seeders, leechers, size, pubdate, parsed_re
                      seeders, leechers, size, pubdate, proper_tags, url]
                 ]
 
-    def search_cache(self, episode, forced_search=False,
-                     down_cur_quality=False):
-        """Search cache for needed episodes."""
-        needed_eps = self.find_needed_episodes(episode, forced_search,
-                                               down_cur_quality)
-        return needed_eps[episode] if episode in needed_eps else []
-
     def item_in_cache(self, url):
         """Check if the url is already available for the specific provider."""
         cache_db_con = self._get_db()
@@ -475,7 +472,7 @@ def find_needed_episodes(self, episode, forced_search=False,
                 b'      season = ? AND'
                 b'      episodes LIKE ?'.format(name=self.provider_id),
                 [episode.series.indexer, episode.series.series_id, episode.season,
-                 b'%|{0}|%'.format(episode.episode)]
+                 '%|{0}|%'.format(episode.episode)]
             )
         else:
             for ep_obj in episode:
@@ -491,7 +488,7 @@ def find_needed_episodes(self, episode, forced_search=False,
                                             for x in ep_obj.wanted_quality))
                     ),
                     [ep_obj.series.indexer, ep_obj.series.series_id, ep_obj.season,
-                     b'%|{0}|%'.format(ep_obj.episode)]]
+                     '%|{0}|%'.format(ep_obj.episode)]]
                 )
 
             if results:
@@ -532,35 +529,44 @@ def find_needed_episodes(self, episode, forced_search=False,
                 log.debug('{0} is not an anime, skipping', series_obj.name)
                 continue
 
-            # get season and ep data (ignoring multi-eps for now)
-            search_result.season = int(cur_result[b'season'])
-            if search_result.season == -1:
-                continue
-
-            cur_ep = cur_result[b'episodes'].split('|')[1]
-            if not cur_ep:
-                continue
-
-            cur_ep = int(cur_ep)
-
+            # build a result object
             search_result.quality = int(cur_result[b'quality'])
             search_result.release_group = cur_result[b'release_group']
             search_result.version = cur_result[b'version']
+            search_result.name = cur_result[b'name']
+            search_result.url = cur_result[b'url']
+            search_result.season = int(cur_result[b'season'])
+            search_result.actual_season = search_result.season
 
-            # if the show says we want that episode then add it to the list
-            if not series_obj.want_episode(search_result.season, cur_ep, search_result.quality,
-                                           forced_search, down_cur_quality):
-                log.debug('Ignoring {0}', cur_result[b'name'])
+            sql_episodes = cur_result[b'episodes'].strip('|')
+            # Season result
+            if not sql_episodes:
+                ep_objs = self.series.get_all_episodes(search_result.season)
+                actual_episodes = [ep.episode for ep in ep_objs]
+                episode_number = SEASON_RESULT
+            # Multi or single episode result
+            else:
+                actual_episodes = [int(ep) for ep in sql_episodes.split('|')]
+                ep_objs = [series_obj.get_episode(search_result.season, ep) for ep in actual_episodes]
+                if len(actual_episodes) == 1:
+                    episode_number = actual_episodes[0]
+                else:
+                    episode_number = MULTI_EP_RESULT
+
+            all_wanted = True
+            for cur_ep in actual_episodes:
+                # if the show says we want that episode then add it to the list
+                if not series_obj.want_episode(search_result.season, cur_ep, search_result.quality,
+                                               forced_search, down_cur_quality):
+                    log.debug('Ignoring {0} because one or more episodes are unwanted', cur_result[b'name'])
+                    all_wanted = False
+                    break
+
+            if not all_wanted:
                 continue
 
-            search_result.episodes = [series_obj.get_episode(search_result.season, cur_ep)]
-
-            search_result.actual_episodes = [search_result.episodes[0].episode]
-            search_result.actual_season = search_result.season
-
-            # build a result object
-            search_result.name = cur_result[b'name']
-            search_result.url = cur_result[b'url']
+            search_result.episodes = ep_objs
+            search_result.actual_episodes = actual_episodes
 
             log.debug(
                 '{id}: Using cached results from {provider} for series {show_name!r} episode {ep}', {
@@ -582,15 +588,13 @@ def find_needed_episodes(self, episode, forced_search=False,
 
             # FIXME: Should be changed to search_result.search_type
             search_result.forced_search = forced_search
-
             search_result.download_current_quality = down_cur_quality
 
-            episode_object = search_result.episodes[0]
             # add it to the list
-            if episode_object not in needed_eps:
-                needed_eps[episode_object] = [search_result]
+            if episode_number not in needed_eps:
+                needed_eps[episode_number] = [search_result]
             else:
-                needed_eps[episode_object].append(search_result)
+                needed_eps[episode_number].append(search_result)
 
         # datetime stamp this search so cache gets cleared
         self.searched = time()

From 82e81f93d761791415f28f836c71a59a9dcdaeff Mon Sep 17 00:00:00 2001
From: Dario <dariovizz@hotmail.it>
Date: Tue, 17 Jul 2018 21:01:44 +0200
Subject: [PATCH 05/11] Add TODO

---
 medusa/tv/cache.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/medusa/tv/cache.py b/medusa/tv/cache.py
index 94b5a4f992..c63e56121c 100644
--- a/medusa/tv/cache.py
+++ b/medusa/tv/cache.py
@@ -539,6 +539,7 @@ def find_needed_episodes(self, episode, forced_search=False,
             search_result.actual_season = search_result.season
 
             sql_episodes = cur_result[b'episodes'].strip('|')
+            # TODO: Add support for season results
             # Season result
             if not sql_episodes:
                 ep_objs = self.series.get_all_episodes(search_result.season)

From 474beb6644bebdb973eb99c77ed6db45f9d8006e Mon Sep 17 00:00:00 2001
From: Dario <medariox@users.noreply.github.com>
Date: Wed, 18 Jul 2018 14:53:10 +0200
Subject: [PATCH 06/11] Better formatting

---
 medusa/search/core.py | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/medusa/search/core.py b/medusa/search/core.py
index ccbc113754..b8376c613d 100644
--- a/medusa/search/core.py
+++ b/medusa/search/core.py
@@ -563,12 +563,9 @@ def search_for_needed_episodes(force=False):
                 # the newly found quality is no better then skip it
                 if episode_no in single_results:
                     allowed_qualities, preferred_qualities = results[0].series.current_qualities
-                    if not Quality.is_higher_quality(
-                        single_results[episode_no].quality,
-                        best_result.quality,
-                        allowed_qualities,
-                        preferred_qualities
-                    ):
+                    if not Quality.is_higher_quality(single_results[episode_no].quality,
+                                                     best_result.quality, allowed_qualities,
+                                                     preferred_qualities):
                         continue
 
                 single_results[episode_no] = best_result

From 42c748d05343c88cf4f6ea2c1abd05da64840efb Mon Sep 17 00:00:00 2001
From: Dario <dariovizz@hotmail.it>
Date: Thu, 19 Jul 2018 17:01:20 +0200
Subject: [PATCH 07/11] Remove support to download seasons for multi-episodes
 (torrents only)

---
 medusa/search/core.py | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/medusa/search/core.py b/medusa/search/core.py
index b8376c613d..46f973bb6d 100644
--- a/medusa/search/core.py
+++ b/medusa/search/core.py
@@ -861,15 +861,6 @@ def collect_multi_candidates(candidates, series_obj, episodes, down_cur_quality)
                     elif len(cur_result.episodes) > 1:
                         multi_candidates.append(cur_result)
 
-            # If this is a torrent all we can do is get the entire torrent,
-            # user will have to select which eps not do download in his torrent client
-            else:
-                log.info(u'Adding multi-episode result for full-season torrent.'
-                         u' Undesired episodes can be skipped in the torrent client if desired!')
-                # Skip the result if search delay is enabled for the provider
-                if not delay_search(candidate):
-                    multi_candidates.append(candidate)
-
     return multi_candidates, single_candidates
 
 

From 042f687d9f55fb75fdac438da634ce52d93dbd2e Mon Sep 17 00:00:00 2001
From: Dario <medariox@users.noreply.github.com>
Date: Wed, 25 Jul 2018 00:05:42 +0200
Subject: [PATCH 08/11] Use plural for better representation

---
 medusa/providers/generic_provider.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/medusa/providers/generic_provider.py b/medusa/providers/generic_provider.py
index 6bde258e9b..5de8df2b90 100644
--- a/medusa/providers/generic_provider.py
+++ b/medusa/providers/generic_provider.py
@@ -253,15 +253,15 @@ def find_search_results(self, series, episodes, search_mode, forced_search=False
 
         for episode in episodes:
             if not manual_search:
-                cache_result = self.cache.find_needed_episodes(
+                cache_results = self.cache.find_needed_episodes(
                     episode, forced_search=forced_search, down_cur_quality=download_current_quality
                 )
-                if cache_result:
-                    for episode_no in cache_result:
+                if cache_results:
+                    for episode_no in cache_results:
                         if episode_no not in results:
-                            results[episode_no] = cache_result[episode_no]
+                            results[episode_no] = cache_results[episode_no]
                         else:
-                            results[episode_no] += cache_result[episode_no]
+                            results[episode_no] += cache_results[episode_no]
                     continue
 
             search_strings = []

From b79097e4323ff6872f346db23c88dc3aa6022e88 Mon Sep 17 00:00:00 2001
From: Dario <dariovizz@hotmail.it>
Date: Sun, 29 Jul 2018 19:57:17 +0200
Subject: [PATCH 09/11] Review

---
 medusa/providers/generic_provider.py |  4 +---
 medusa/search/core.py                | 22 +++++++++++-----------
 2 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/medusa/providers/generic_provider.py b/medusa/providers/generic_provider.py
index 5de8df2b90..35b98af22e 100644
--- a/medusa/providers/generic_provider.py
+++ b/medusa/providers/generic_provider.py
@@ -247,9 +247,7 @@ def find_search_results(self, series, episodes, search_mode, forced_search=False
 
         results = {}
         items_list = []
-        season_search = (
-            len(episodes) > 1 or manual_search_type == 'season'
-        ) and search_mode == 'sponly'
+        season_search = (len(episodes) > 1 or manual_search_type == 'season') and search_mode == 'sponly'
 
         for episode in episodes:
             if not manual_search:
diff --git a/medusa/search/core.py b/medusa/search/core.py
index 46f973bb6d..a2280f733d 100644
--- a/medusa/search/core.py
+++ b/medusa/search/core.py
@@ -490,7 +490,11 @@ def wanted_episodes(series_obj, from_date):
 
 
 def search_for_needed_episodes(force=False):
-    """Check providers for details on wanted episodes."""
+    """Search providers for needed episodes.
+
+    :param force: run the search even if no episodes are needed
+    :return: list of found episodes
+    """
     show_list = app.showList
     from_date = datetime.date.fromordinal(1)
     episodes = []
@@ -822,16 +826,12 @@ def collect_multi_candidates(candidates, series_obj, episodes, down_cur_quality)
         return multi_candidates, single_candidates
 
     for candidate in wanted_candidates:
-        all_wanted = True
-        any_wanted = False
-        for ep_obj in candidate.episodes:
-            if not series_obj.want_episode(ep_obj.season, ep_obj.episode,
-                                           candidate.quality, down_cur_quality):
-                all_wanted = False
-            else:
-                any_wanted = True
+        wanted_episodes = (
+            series_obj.want_episode(ep_obj.season, ep_obj.episode, candidate.quality, down_cur_quality)
+            for ep_obj in candidate.episodes
+        )
 
-        if all_wanted:
+        if all(wanted_episodes):
             log.info(u'All episodes in this season are needed, adding {0} {1}',
                      candidate.provider.provider_type,
                      candidate.name)
@@ -840,7 +840,7 @@ def collect_multi_candidates(candidates, series_obj, episodes, down_cur_quality)
             if not delay_search(candidate):
                 multi_candidates.append(candidate)
 
-        elif not any_wanted:
+        elif not any(wanted_episodes):
             log.debug(u'No episodes in this season are needed at this quality, ignoring {0} {1}',
                       candidate.provider.provider_type,
                       candidate.name)

From e1c220cbdd627b8614d8afba62773ca6c65a186e Mon Sep 17 00:00:00 2001
From: Dario <medariox@users.noreply.github.com>
Date: Sun, 29 Jul 2018 20:27:43 +0200
Subject: [PATCH 10/11] Update CHANGELOG.md

---
 CHANGELOG.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 99894aa1bc..84a28c1bd8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,15 @@
 
 -----
 
+## 0.2.9 (2018-08-10)
+
+#### Fixes
+- Fixed error when changing episode status from episode status management ([#4783](https://github.com/pymedusa/Medusa/pull/4783))
+- Fixed multi-episode snatches not being marked as snatched in history ([#229](https://github.com/pymedusa/Medusa/issues/229))
+- Fixed whole seasons being downloaded as multi-episode replacement ([#4750](https://github.com/pymedusa/Medusa/issues/4750))
+
+-----
+
 ## 0.2.8 (2018-07-28)
 
 #### Fixes

From 43a1dda63298aff737d01495ecddc74c6bd5e4da Mon Sep 17 00:00:00 2001
From: P0psicles <rogier@headshots.nl>
Date: Wed, 1 Aug 2018 11:43:49 +0200
Subject: [PATCH 11/11] Moved v0.2.9 changelog items to 'Unreleased'

---
 CHANGELOG.md | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3d00a0c0ff..31d8786448 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,21 +1,16 @@
 ## Unreleased
 
-#### Fixes
-
 #### New Features
 
 #### Improvements
 - Converted /config/postProcessing to a Vue component ([#4259](https://github.com/pymedusa/Medusa/pull/4259))
 
------
-
-## 0.2.9 (2018-08-10)
-
 #### Fixes
 - Fixed error when changing episode status from episode status management ([#4783](https://github.com/pymedusa/Medusa/pull/4783))
 - Fixed multi-episode snatches not being marked as snatched in history ([#229](https://github.com/pymedusa/Medusa/issues/229))
 - Fixed whole seasons being downloaded as multi-episode replacement ([#4750](https://github.com/pymedusa/Medusa/issues/4750))
 
+
 -----
 
 ## 0.2.8 (2018-07-28)