Implement episode and season search templates

medusa/cache.py

@@ -42,6 +42,7 @@ def release_write_lock(self):
 cache = make_region()
 memory_cache = make_region()
 recommended_series_cache = make_region()
+anidb_cache = make_region()
 
 
 def configure(cache_dir):
@@ -70,6 +71,12 @@ def configure(cache_dir):
                                        arguments={'filename': os.path.join(cache_dir, 'recommended.dbm'),
                                                   'lock_factory': MutexLock})
 
+    # anidb (adba) series cache
+    anidb_cache.configure('dogpile.cache.dbm',
+                    expiration_time=timedelta(days=3),
+                    arguments={'filename': os.path.join(cache_dir, 'anidb.dbm'),
+                               'lock_factory': MutexLock})
+
 
 def fallback():
     """Memory only configuration. Used for test purposes."""

medusa/databases/cache_db.py

@@ -156,3 +156,13 @@ def execute(self):
 
         # clean up null values from the scene_exceptions_table
         self.connection.action("DELETE FROM scene_exceptions WHERE indexer = '' or indexer is null;")
+
+
+class RemoveSceneExceptionsTable(AddIndexerIds):
+    """The scene_exceptions table has been moved to main.db"""
+    def test(self):
+        """Test if the table history already has the indexer_id."""
+        return not self.hasTable("db_version")
+
+    def execute(self):
+        self.connection.action('DROP TABLE IF EXISTS scene_exceptions;')

medusa/databases/main_db.py

@@ -366,7 +366,13 @@ def execute(self):
         log.info(u'Converting column indexer and default_ep_status field types to numeric')
         self.connection.action("DROP TABLE IF EXISTS tmp_tv_shows")
         self.connection.action("ALTER TABLE tv_shows RENAME TO tmp_tv_shows")
-        self.connection.action("CREATE TABLE tv_shows (show_id INTEGER PRIMARY KEY, indexer_id NUMERIC, indexer NUMERIC, show_name TEXT, location TEXT, network TEXT, genre TEXT, classification TEXT, runtime NUMERIC, quality NUMERIC, airs TEXT, status TEXT, flatten_folders NUMERIC, paused NUMERIC, startyear NUMERIC, air_by_date NUMERIC, lang TEXT, subtitles NUMERIC, notify_list TEXT, imdb_id TEXT, last_update_indexer NUMERIC, dvdorder NUMERIC, archive_firstmatch NUMERIC, rls_require_words TEXT, rls_ignore_words TEXT, sports NUMERIC, anime NUMERIC, scene NUMERIC, default_ep_status NUMERIC)")
+        self.connection.action("CREATE TABLE tv_shows (show_id INTEGER PRIMARY KEY, indexer_id NUMERIC, indexer NUMERIC, "
+                               "show_name TEXT, location TEXT, network TEXT, genre TEXT, classification TEXT, "
+                               "runtime NUMERIC, quality NUMERIC, airs TEXT, status TEXT, flatten_folders NUMERIC, "
+                               "paused NUMERIC, startyear NUMERIC, air_by_date NUMERIC, lang TEXT, subtitles NUMERIC, "
+                               "notify_list TEXT, imdb_id TEXT, last_update_indexer NUMERIC, dvdorder NUMERIC, "
+                               "archive_firstmatch NUMERIC, rls_require_words TEXT, rls_ignore_words TEXT, "
+                               "sports NUMERIC, anime NUMERIC, scene NUMERIC, default_ep_status NUMERIC)")
         self.connection.action("INSERT INTO tv_shows SELECT * FROM tmp_tv_shows")
         self.connection.action("DROP TABLE tmp_tv_shows")
 
@@ -706,3 +712,26 @@ def create_series_dict():
         # Flag the image migration.
         from medusa import app
         app.MIGRATE_IMAGES = True
+
+
+class AddSearchTemplates(AddIndexerIds):
+    """Adds column size to history table."""
+
+    def test(self):
+        """
+        Test if the version is at least 44.10
+        """
+        return self.connection.version >= (44, 10)
+
+    def execute(self):
+        backupDatabase(self.connection.version)
+
+        log.info(u"Creating a new table scene_exceptions in the main.db database.")
+
+        self.connection.action(
+            'CREATE TABLE scene_exceptions '
+            '(exception_id INTEGER PRIMARY KEY, indexer INTEGER, series_id INTEGER, show_name TEXT, '
+            'season NUMERIC DEFAULT -1, custom NUMERIC DEFAULT 0, episode_search_template TEXT, season_search_template TEXT);'
+        )
+
+        self.inc_minor_version()

medusa/helper/exceptions.py

@@ -130,3 +130,11 @@ class ShowNotFoundException(ApplicationException):
     """
     The show wasn't found on the Indexer
     """
+
+
+class AnidbAdbaConnectionException(Exception):
+    """
+    Connection exceptions raised while trying to communicate with the Anidb UDP api.
+
+    More info on the api: https://wiki.anidb.net/w/API.
+    """

medusa/helpers/__init__.py

@@ -35,8 +35,6 @@
 except ImportError:
     pass
 
-import adba
-
 from cachecontrol import CacheControlAdapter
 from cachecontrol.cache import DictCache
 
@@ -1032,11 +1030,10 @@ def get_show(name, try_indexers=False):
 
         # try scene exceptions
         if not series:
-            series_from_name = scene_exceptions.get_scene_exceptions_by_name(series_name)[0]
-            series_id = series_from_name[0]
-            indexer_id = series_from_name[2]
-            if series_id:
-                series = Show.find_by_id(app.showList, indexer_id, series_id)
+            found_exceptions = list(scene_exceptions.get_scene_exceptions_by_name(series_name))
+            if found_exceptions:
+                # Only use the first exception.
+                series = Show.find_by_id(app.showList, found_exceptions[0].indexer, found_exceptions[0].series_id)
 
         if not series:
             match_name_only = (s.name for s in app.showList if text_type(s.imdb_year) in s.name and
@@ -1110,39 +1107,6 @@ def validate_show(show, season=None, episode=None):
         pass
 
 
-def set_up_anidb_connection():
-    """Connect to anidb."""
-    if not app.USE_ANIDB:
-        log.debug(u'Usage of anidb disabled. Skipping')
-        return False
-
-    if not app.ANIDB_USERNAME and not app.ANIDB_PASSWORD:
-        log.debug(u'anidb username and/or password are not set.'
-                  u' Aborting anidb lookup.')
-        return False
-
-    if not app.ADBA_CONNECTION:
-        def anidb_logger(msg):
-            return log.debug(u'anidb: {0}', msg)
-
-        try:
-            app.ADBA_CONNECTION = adba.Connection(keepAlive=True, log=anidb_logger)
-        except Exception as error:
-            log.warning(u'anidb exception msg: {0!r}', error)
-            return False
-
-    try:
-        if not app.ADBA_CONNECTION.authed():
-            app.ADBA_CONNECTION.auth(app.ANIDB_USERNAME, app.ANIDB_PASSWORD)
-        else:
-            return True
-    except Exception as error:
-        log.warning(u'anidb exception msg: {0!r}', error)
-        return False
-
-    return app.ADBA_CONNECTION.authed()
-
-
 def backup_config_zip(file_list, archive, arcname=None):
     """Store the config file as a ZIP.
 

medusa/helpers/anidb.py

@@ -0,0 +1,59 @@
+"""Helper for anidb communications."""
+
+import adba
+import logging
+from medusa import app
+from medusa.cache import anidb_cache
+from medusa.logger.adapters.style import BraceAdapter
+from medusa.helper.exceptions import AnidbAdbaConnectionException
+
+log = BraceAdapter(logging.getLogger(__name__))
+log.logger.addHandler(logging.NullHandler())
+
+
+def set_up_anidb_connection():
+    """Connect to anidb."""
+    if not app.USE_ANIDB:
+        log.debug(u'Usage of anidb disabled. Skipping')
+        return False
+
+    if not app.ANIDB_USERNAME and not app.ANIDB_PASSWORD:
+        log.debug(u'anidb username and/or password are not set.'
+                  u' Aborting anidb lookup.')
+        return False
+
+    if not app.ADBA_CONNECTION:
+        def anidb_logger(msg):
+            return log.debug(u'anidb: {0}', msg)
+
+        try:
+            app.ADBA_CONNECTION = adba.Connection(keepAlive=True, log=anidb_logger)
+        except Exception as error:
+            log.warning(u'anidb exception msg: {0!r}', error)
+            return False
+
+    try:
+        if not app.ADBA_CONNECTION.authed():
+            app.ADBA_CONNECTION.auth(app.ANIDB_USERNAME, app.ANIDB_PASSWORD)
+        else:
+            return True
+    except Exception as error:
+        log.warning(u'anidb exception msg: {0!r}', error)
+        return False
+
+    return app.ADBA_CONNECTION.authed()
+
+
+@anidb_cache.cache_on_arguments()
+def get_release_groups_for_anime(series_name):
+    """Get release groups for an anidb anime."""
+    groups = []
+    if set_up_anidb_connection():
+        try:
+            anime = adba.Anime(app.ADBA_CONNECTION, name=series_name)
+            groups = anime.get_groups()
+        except Exception as error:
+            log.warning(u'Unable to retrieve Fansub Groups from AniDB. Error: {error}', {'error': error.message})
+            raise AnidbAdbaConnectionException(error)
+
+    return groups

medusa/indexers/indexer_config.py

@@ -3,6 +3,7 @@
 """Indexer config module."""
 from __future__ import unicode_literals
 
+from six import text_type
 from medusa.app import BASE_PYMEDUSA_URL
 from medusa.indexers.tmdb.tmdb import Tmdb
 from medusa.indexers.tvdbv2.tvdbv2_api import TVDBv2
@@ -114,3 +115,43 @@
         'identifier': 'tmdb',  # Also used as key for the custom scenename exceptions. (_get_custom_exceptions())
     }
 }
+
+
+def create_config_json(indexer):
+    """Create a json (pickable) conpatible dict, for using as an apiv2 resource."""
+    return {
+        'enabled': indexer['enabled'],
+        'id': indexer['id'],
+        'name': indexer['name'],
+        'module': text_type(indexer['module']),
+        'apiParams': {
+            'language': indexer['api_params']['language'],
+            'useZip': indexer['api_params']['use_zip'],
+            'session': '',
+        },
+        'xemOrigin': indexer.get('xem_origin'),
+        'icon': indexer.get('icon'),
+        'scene_loc': indexer.get('scene_loc'),
+        'baseUrl': indexer.get('base_url'),
+        'showUrl': indexer.get('show_url'),
+        'mappedTo': indexer.get('mapped_to'),  # The attribute to which other indexers can map there thetvdb id to
+        'identifier': indexer.get('identifier'),  # Also used as key for the custom scenename exceptions. (_get_custom_exceptions())
+        'validLanguages': initConfig['valid_languages'],
+        'langabbvToId': initConfig['langabbv_to_id'],
+    }
+
+
+def get_indexer_config():
+    indexers = {
+        indexerConfig[indexer]['identifier']: create_config_json(indexerConfig[indexer]) for indexer in indexerConfig.keys()
+    }
+
+    main = {
+        'validLanguages': initConfig['valid_languages'],
+        'langabbvToId': initConfig['langabbv_to_id'],
+        'externalMappings': EXTERNAL_MAPPINGS,
+        'traktIndexers': TRAKT_INDEXERS,
+        'statusMap': STATUS_MAP
+    }
+
+    return {'indexers': indexers, 'main': main}

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."""
@@ -98,7 +97,7 @@ def _cache_name(cache_series_obj):
         series_identifier = (cache_series_obj.indexer, cache_series_obj.series_id)
         scene_exceptions = exceptions_cache[series_identifier].copy()
         names = {
-            full_sanitize_scene_name(name): series_identifier
+            full_sanitize_scene_name(name.series_name): series_identifier
             for season_exceptions in itervalues(scene_exceptions)
             for name in season_exceptions
         }

medusa/name_parser/guessit_parser.py

@@ -92,19 +92,19 @@ def get_expected_titles(show_list):
     """
     expected_titles = []
     for show in show_list:
-        names = {show.name}.union(show.exceptions)
-        for name in names:
-            if name.isdigit():
+        exceptions = {show.name}.union({exception.series_name for exception in show.exceptions})
+        for exception in exceptions:
+            if exception.isdigit():
                 # do not add numbers to expected titles.
                 continue
 
-            match = series_re.match(name)
+            match = series_re.match(exception)
             if not match:
                 continue
 
             series, year, _ = match.groups()
             if year and not valid_year(int(year)):
-                series = name
+                series = exception
 
             if not any([char.isdigit() for char in series]):
                 continue

medusa/name_parser/parser.py

@@ -186,7 +186,9 @@ def _parse_anime(result):
         # "diamond is unbreakable" exception back to season 4 of it's "master" table. This will be used later
         # to translate it to an absolute number, which in turn can be translated to an indexer SxEx.
         # For example Diamond is unbreakable - 26 -> Season 4 -> Absolute number 100 -> tvdb S03E26
-        scene_season = scene_exceptions.get_scene_exceptions_by_name(result.series_name)[0][1]
+        found_exceptions = list(scene_exceptions.get_scene_exceptions_by_name(result.series_name))
+        if found_exceptions:
+            scene_season = found_exceptions[0].season
 
         if result.ab_episode_numbers:
             for absolute_episode in result.ab_episode_numbers:

medusa/providers/generic_provider.py

@@ -632,6 +632,8 @@ def _get_episode_search_strings(self, episode, add_string=''):
         if not episode:
             return []
 
+        from medusa.scene_exceptions import get_scene_exceptions_by_name, get_all_scene_exceptions, get_scene_exceptions
+
         search_string = {
             'Episode': []
         }
@@ -677,6 +679,17 @@ def _get_episode_search_strings(self, episode, add_string=''):
             if episode_string_fallback:
                 search_string['Episode'].append(episode_string_fallback.strip())
 
+            exceptions = get_scene_exceptions_by_name(show_name)
+
+            for exception in exceptions:
+                if exception.episode_search_template:
+                    anime_type = app.NAMING_ANIME
+                    if not self.series.is_anime:
+                        anime_type = 3
+                    search_string['Episode'].append(
+                        episode.formatted_search_string(exception.episode_search_template, anime_type=anime_type)
+                    )
+
         return [search_string]
 
     def _get_tvdb_id(self):