Implement episode and season search templates

medusa/databases/main_db.py

@@ -995,3 +995,36 @@ 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 == 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
@@ -326,10 +332,10 @@ def _parse_string(self, name):
         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))
 

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,18 @@ 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:
+                if 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['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 +709,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,7 @@ 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 +284,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]