Implement episode and season search templates

CHANGELOG.md

@@ -4,6 +4,7 @@
 - Add support for banner and background images to indexer tvmaze ([10234](https://github.com/pymedusa/Medusa/pull/10234))
 - Add option for using ffprobe to validate postprocessed media ([10132](https://github.com/pymedusa/Medusa/pull/10132))
 - Add change indexer page to change the current indexer for shows in bulk ([9862](https://github.com/pymedusa/Medusa/pull/9862))
+- Add search templates feature. ([3732](https://github.com/pymedusa/Medusa/pull/3732))
 
 #### Improvements
 - Add column sorting for the add new show page search results ([10217](https://github.com/pymedusa/Medusa/pull/10217))

medusa/databases/main_db.py

@@ -995,3 +995,37 @@ def execute(self):
             self.addColumn('history', 'part_of_batch', 'INTEGER')
 
         self.inc_minor_version()
+
+
+class AddSearchTemplates(AddHistoryFDHFields):
+    """Create a new table search_templates in main.db."""
+
+    def test(self):
+        """
+        Test if the version is at least 44.19
+        """
+        return self.connection.version >= (44, 19)
+
+    def execute(self):
+        utils.backup_database(self.connection.path, self.connection.version)
+
+        log.info(u'Creating a new table search_templates in the main.db database.')
+
+        self.connection.action(
+            """CREATE TABLE "search_templates" (
+            `search_template_id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+            `template`	TEXT,
+            `title`     TEXT,
+            `indexer`	INTEGER,
+            `series_id`	INTEGER,
+            `season`	INTEGER,
+            `enabled`	INTEGER DEFAULT 1,
+            `default`	INTEGER DEFAULT 1,
+            `season_search` INTEGER DEFAULT 0);"""
+        )
+
+        log.info(u'Adding new templates field in the tv_shows table')
+        if not self.hasColumn('tv_shows', 'templates'):
+            self.addColumn('tv_shows', 'templates', 'NUMERIC', 0)
+
+        self.inc_minor_version()

medusa/name_cache.py

@@ -89,7 +89,6 @@ def build_name_cache(series_obj=None):
     """Build internal name cache.
 
     :param series_obj: Specify series to build name cache for, if None, just do all series
-    :param force: Force the build name cache. Do not depend on the scene_exception_refresh table.
     """
     def _cache_name(cache_series_obj):
         """Build the name cache for a single show."""

medusa/name_parser/parser.py

@@ -279,6 +279,12 @@ def _parse_series(result):
         new_absolute_numbers = []
 
         ex_season = scene_exceptions.get_season_from_name(result.series, result.series_name) or result.season_number
+        if ex_season is None:
+            ex_season = 1
+            log.info(
+                "For the show {name} we could not parse a season number. We did match the title, so we'll asume season 1",
+                {'name': result.series.name}
+            )
 
         for episode_number in result.episode_numbers:
             season = ex_season
@@ -300,6 +306,33 @@ def _parse_series(result):
 
         return new_episode_numbers, new_season_numbers, new_absolute_numbers
 
+    @staticmethod
+    def _parse_special(result):
+        new_episode_numbers = []
+        new_season_numbers = []
+
+        episode_title = result.guess.get('episode_title')
+        if not episode_title:
+            log.info(
+                '{name}: This episode is marked as a special. We could not find an episode title. And we need that to map it to an episode in the library.',
+                {'name': result.series.name}
+            )
+            return new_episode_numbers, new_season_numbers
+
+        # Sanitize the episode title.
+        episode_title = episode_title.lower()
+        if episode_title.startswith('special'):
+            episode_title = episode_title.split('special')[-1].strip()
+
+        all_episodes = result.series.get_all_episodes(season=0)
+        for special_episode in all_episodes:
+            if special_episode.name.lower() == episode_title:
+                new_season_numbers.append(0)
+                new_episode_numbers.append(special_episode.episode)
+                return new_episode_numbers, new_season_numbers
+
+        return [], []
+
     def _parse_string(self, name):
         guess = guessit.guessit(name, dict(show_type=self.show_type))
 
@@ -318,18 +351,22 @@ def _parse_string(self, name):
         new_season_numbers = []
         new_absolute_numbers = []
 
+        # Try to map special episodes without an episode number using the episode title.
+        if result.is_episode_special and not result.episode_numbers:
+            new_episode_numbers, new_season_numbers = self._parse_special(result)
+
         # if we have an air-by-date show and the result is air-by-date,
         # then get the real season/episode numbers
-        if result.series.air_by_date and result.is_air_by_date:
+        elif result.series.air_by_date and result.is_air_by_date:
             new_episode_numbers, new_season_numbers = self._parse_air_by_date(result)
 
         elif result.series.is_anime or result.is_anime:
             new_episode_numbers, new_season_numbers, new_absolute_numbers = self._parse_anime(result)
 
-        elif result.season_number is not None:
+        else:
             new_episode_numbers, new_season_numbers, new_absolute_numbers = self._parse_series(result)
 
-        else:
+        if not new_season_numbers and not new_episode_numbers:
             raise InvalidNameException('The result that was found ({result_name}) is not yet supported by Medusa '
                                        'and will be skipped. Sorry.'.format(result_name=result.original_name))
 
@@ -468,14 +505,15 @@ def to_parse_result(self, name, guess):
                            episode_numbers=helpers.ensure_list(guess.get('episode')),
                            ab_episode_numbers=helpers.ensure_list(guess.get('absolute_episode')),
                            air_date=guess.get('date'), release_group=guess.get('release_group'),
-                           proper_tags=helpers.ensure_list(guess.get('proper_tag')), version=guess.get('version', -1))
+                           proper_tags=helpers.ensure_list(guess.get('proper_tag')), version=guess.get('version', -1),
+                           episode_details=helpers.ensure_list(guess.get('episode_details')))
 
 
 class ParseResult(object):
     """Represent the release information for a given name."""
 
     def __init__(self, guess, series_name=None, season_number=None, episode_numbers=None, ab_episode_numbers=None,
-                 air_date=None, release_group=None, proper_tags=None, version=None, original_name=None):
+                 air_date=None, release_group=None, proper_tags=None, version=None, original_name=None, episode_details=None):
         """Initialize the class.
 
         :param guess:
@@ -498,6 +536,8 @@ def __init__(self, guess, series_name=None, season_number=None, episode_numbers=
         :type version: int
         :param original_name:
         :type original_name: str
+        :param episode_details:
+        :type episode_details: list of str
         """
         self.original_name = original_name
         self.series_name = series_name
@@ -512,6 +552,7 @@ def __init__(self, guess, series_name=None, season_number=None, episode_numbers=
         self.proper_tags = proper_tags
         self.guess = guess
         self.total_time = None
+        self.episode_details = episode_details
 
     def __eq__(self, other):
         """Equal implementation.

medusa/naming.py

@@ -83,11 +83,11 @@ def check_valid_naming(pattern=None, multi=None, anime_type=None):
     if anime_type is None:
         anime_type = app.NAMING_ANIME
 
-    logger.log(u'Checking whether the pattern ' + pattern + ' is valid for a single episode', logger.DEBUG)
+    logger.log(f'Checking whether the pattern {pattern} is valid for a single episode', logger.DEBUG)
     valid = validate_name(pattern, None, anime_type)
 
     if multi is not None:
-        logger.log(u'Checking whether the pattern ' + pattern + ' is valid for a multi episode', logger.DEBUG)
+        logger.log(f'Checking whether the pattern {pattern} is valid for a multi episode', logger.DEBUG)
         valid = valid and validate_name(pattern, multi, anime_type)
 
     return valid
@@ -169,6 +169,7 @@ def validate_name(pattern, multi=None, anime_type=None, file_only=False, abd=Fal
         if parse_result.season_number != ep.season:
             logger.log(u"Season number incorrect in parsed episode, pattern isn't valid", logger.DEBUG)
             return False
+        # If the template is a season search string, we don't need to check for episode.
         if parse_result.episode_numbers != [x.episode for x in [ep] + ep.related_episodes]:
             logger.log(u"Episode numbering incorrect in parsed episode, pattern isn't valid", logger.DEBUG)
             return False

medusa/providers/generic_provider.py

@@ -666,6 +666,21 @@ def _get_episode_search_strings(self, episode, add_string=''):
             'Episode': []
         }
 
+        # If show.use_templates is enabled, where using those instead of creating them here.
+        if episode.series.use_templates:
+            for template in episode.series.search_templates.templates:
+
+                # Only limit to episode search templates. And filter out disabled search templates.
+                if template.season_search or not template.enabled:
+                    continue
+
+                # Make sure we only use a season search template when searched for that season.
+                if episode.scene_season is not None and template.season != -1 and episode.scene_season != template.season:
+                    continue
+
+                search_string['Episode'].append(episode.formatted_search_string(template.template, title=template.title))
+            return [search_string]
+
         all_possible_show_names = episode.series.get_all_possible_names()
         if episode.scene_season is not None:
             all_possible_show_names = all_possible_show_names.union(
@@ -697,6 +712,18 @@ def _get_season_search_strings(self, episode):
             'Season': []
         }
 
+        # If show.use_templates is enabled, where using those instead of creating them here.
+        if episode.series.use_templates:
+            for template in episode.series.search_templates.templates:
+                if not template.season_search or not template.enabled:
+                    continue
+
+                if episode.scene_season and template.season != -1 and episode.scene_season != template.season:
+                    continue
+
+                search_string['Season'].append(episode.formatted_search_string(template.template, title=template.title))
+            return [search_string]
+
         for show_name in episode.series.get_all_possible_names(season=episode.scene_season):
             episode_string = show_name + self.search_separator
 

medusa/queues/show_queue.py

@@ -689,6 +689,10 @@ def message_step(new_step):
             message_step('add scene numbering')
             self.show.add_scene_numbering()
 
+            # Load search templates
+            message_step('generate search templates')
+            self.show.init_search_templates()
+
             if self.show_dir:
                 # If a show dir was passed, this was added as an existing show.
                 # For new shows we should have any files on disk.

medusa/scene_exceptions.py

@@ -169,7 +169,7 @@ def get_season_from_name(series_obj, exception_name):
 
 def get_all_scene_exceptions(series_obj):
     """
-    Get all scene exceptions for a show ID.
+    Get all scene exceptions for a show object using indexer and series_id.
 
     :param series_obj: series object.
     :return: dict of exceptions (e.g. exceptions_cache[season][exception_name])
@@ -239,6 +239,8 @@ def update_scene_exceptions(series_obj, scene_exceptions):
                 [series_obj.indexer, series_obj.series_id, exception['title'], exception['season'], exception['custom']]
             )
 
+    refresh_exceptions_cache(series_obj)
+
 
 def retrieve_exceptions(force=False, exception_type=None):
     """
@@ -283,7 +285,7 @@ def retrieve_exceptions(force=False, exception_type=None):
                 for scene_exception, season in iteritems(exception_dict):
                     if scene_exception not in existing_exceptions:
                         queries.append([
-                            'INSERT OR IGNORE INTO scene_exceptions '
+                            'INSERT OR IGNORE INTO scene_exceptions'
                             '(indexer, series_id, title, season, custom) '
                             'VALUES (?,?,?,?,?)',
                             [indexer, series_id, scene_exception, season, False]

medusa/scene_numbering.py

@@ -358,7 +358,7 @@ def get_indexer_numbering(series_obj, scene_episode, scene_season=None):
     """
     # Try to get a mapping from scene_numbering.
     season, episode = get_custom_numbering_from_scene(series_obj, scene_episode, scene_season)
-    if all((season, episode)):
+    if all((season is not None, episode)):
         return season, episode
 
     if series_obj.is_scene: