Updated multiple Python modules (now in libs and custom_libs directories) and React libraries

.github/files_to_copy

@@ -1,4 +1,5 @@
 bazarr
+custom_libs
 frontend/build
 libs
 bazarr.py

bazarr/app/app.py

@@ -34,6 +34,7 @@ def create_app():
     else:
         app.config["DEBUG"] = False
 
+    from engineio.async_drivers import threading  # noqa W0611  # required to prevent an import exception in engineio
     socketio.init_app(app, path=f'{base_url.rstrip("/")}/api/socket.io', cors_allowed_origins='*',
                       async_mode='threading', allow_upgrades=False, transports='polling', engineio_logger=False)
 

bazarr/app/libs.py

@@ -18,6 +18,7 @@ def clean_libs():
 
 
 def set_libs():
+    sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)), '../custom_libs/'))
     sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)), '../libs/'))
 
 

bazarr/app/logger.py

@@ -59,7 +59,7 @@ class NoExceptionFormatter(logging.Formatter):
 
 class UnwantedWaitressMessageFilter(logging.Filter):
     def filter(self, record):
-        if settings.general.debug is True:
+        if settings.general.debug:
             # no filtering in debug mode
             return True
             

bazarr/app/scheduler.py

@@ -10,9 +10,13 @@ from apscheduler.triggers.date import DateTrigger
 from apscheduler.events import EVENT_JOB_SUBMITTED, EVENT_JOB_EXECUTED, EVENT_JOB_ERROR
 from datetime import datetime, timedelta
 from calendar import day_name
+from math import floor
 from random import randrange
 from tzlocal import get_localzone
-from tzlocal.utils import ZoneInfoNotFoundError
+try:
+    import zoneinfo  # pragma: no cover
+except ImportError:
+    from backports import zoneinfo  # pragma: no cover
 from dateutil import tz
 import logging
 
@@ -60,7 +64,7 @@ class Scheduler:
 
         try:
             self.timezone = get_localzone()
-        except ZoneInfoNotFoundError as e:
+        except zoneinfo.ZoneInfoNotFoundError as e:
             logging.error(f"BAZARR cannot use specified timezone: {e}")
             self.timezone = tz.gettz("UTC")
 
@@ -219,8 +223,9 @@ class Scheduler:
             trigger = CronTrigger(day_of_week=settings.backup.day, hour=settings.backup.hour)
         elif backup == "Manually":
             trigger = CronTrigger(year=in_a_century())
-        self.aps_scheduler.add_job(backup_to_zip, trigger, max_instances=1, coalesce=True, misfire_grace_time=15,
-                                   id='backup', name='Backup Database and Configuration File', replace_existing=True)
+        self.aps_scheduler.add_job(backup_to_zip, trigger,
+                                   max_instances=1, coalesce=True, misfire_grace_time=15, id='backup',
+                                   name='Backup Database and Configuration File', replace_existing=True)
 
     def __sonarr_full_update_task(self):
         if settings.general.use_sonarr:

custom_libs/custom_version.txt

@@ -0,0 +1,19 @@
+# Bazarr dependencies
+subliminal_patch
+subzero
+py-pretty==1  # modified version to support Python 3
+
+# Bazarr modified dependencies
+signalr-client-threads==0.0.12  # Modified to work with Sonarr v3. Not used anymore with v4
+Flask-Compress==1.14  # modified to import brotli only if required
+
+# Required-by: signalr-client-threads
+sseclient==0.0.27  # Modified to work with Sonarr v3
+
+# Required-by: subliminal_patch
+deathbycaptcha  # unknown version, only found on gist
+git+https://github.com/pannal/libfilebot#egg=libfilebot
+git+https://github.com/RobinDavid/pyADS.git@28a2f6dbfb357f85b2c2f49add770b336e88840d#egg=pyads
+py7zr==0.7.0  # modified to prevent importing of modules that can't be vendored
+subscene-api==1.0.0  # modified specificaly for Bazarr
+subliminal==2.1.0  # modified specifically for Bazarr

custom_libs/flask_compress/_version.py

@@ -0,0 +1 @@
+__version__ = "1.14"

custom_libs/flask_compress/flask_compress.py

@@ -63,9 +63,14 @@ class Compress(object):
 
     def init_app(self, app):
         defaults = [
-            ('COMPRESS_MIMETYPES', ['text/html', 'text/css', 'text/xml',
-                                    'application/json',
-                                    'application/javascript']),
+            ('COMPRESS_MIMETYPES', [
+                'application/javascript',  # Obsolete (RFC 9239)
+                'application/json',
+                'text/css',
+                'text/html',
+                'text/javascript',
+                'text/xml',
+            ]),
             ('COMPRESS_LEVEL', 6),
             ('COMPRESS_BR_LEVEL', 4),
             ('COMPRESS_BR_MODE', 0),

custom_libs/subliminal/converters/legendastv.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+from babelfish import LanguageReverseConverter
+
+from ..exceptions import ConfigurationError
+
+
+class LegendasTVConverter(LanguageReverseConverter):
+    def __init__(self):
+        self.from_legendastv = {1: ('por', 'BR'), 2: ('eng',), 3: ('spa',), 4: ('fra',), 5: ('deu',), 6: ('jpn',),
+                                7: ('dan',), 8: ('nor',), 9: ('swe',), 10: ('por',), 11: ('ara',), 12: ('ces',),
+                                13: ('zho',), 14: ('kor',), 15: ('bul',), 16: ('ita',), 17: ('pol',)}
+        self.to_legendastv = {v: k for k, v in self.from_legendastv.items()}
+        self.codes = set(self.from_legendastv.keys())
+
+    def convert(self, alpha3, country=None, script=None):
+        if (alpha3, country) in self.to_legendastv:
+            return self.to_legendastv[(alpha3, country)]
+        if (alpha3,) in self.to_legendastv:
+            return self.to_legendastv[(alpha3,)]
+
+        raise ConfigurationError('Unsupported language code for legendastv: %s, %s, %s' % (alpha3, country, script))
+
+    def reverse(self, legendastv):
+        if legendastv in self.from_legendastv:
+            return self.from_legendastv[legendastv]
+
+        raise ConfigurationError('Unsupported language number for legendastv: %s' % legendastv)

custom_libs/subliminal/matches.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+from rebulk.loose import ensure_list
+
+from .score import get_equivalent_release_groups, score_keys
+from .video import Episode, Movie
+from .utils import sanitize, sanitize_release_group
+
+
+def series_matches(video, title=None, **kwargs):
+    """Whether the `video` matches the series title.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param str title: the series name.
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    if isinstance(video, Episode):
+        return video.series and sanitize(title) in (
+            sanitize(name) for name in [video.series] + video.alternative_series
+        )
+
+
+def title_matches(video, title=None, episode_title=None, **kwargs):
+    """Whether the movie matches the movie `title` or the series matches the `episode_title`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param str title: the movie title.
+    :param str episode_title: the series episode title.
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    if isinstance(video, Episode):
+        return video.title and sanitize(episode_title) == sanitize(video.title)
+    if isinstance(video, Movie):
+        return video.title and sanitize(title) == sanitize(video.title)
+
+
+def season_matches(video, season=None, **kwargs):
+    """Whether the episode matches the `season`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param int season: the episode season.
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    if isinstance(video, Episode):
+        return video.season and season == video.season
+
+
+def episode_matches(video, episode=None, **kwargs):
+    """Whether the episode matches the `episode`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param episode: the episode season.
+    :type: list of int or int
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    if isinstance(video, Episode):
+        return video.episodes and ensure_list(episode) == video.episodes
+
+
+def year_matches(video, year=None, partial=False, **kwargs):
+    """Whether the video matches the `year`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param int year: the video year.
+    :param bool partial: whether or not the guess is partial.
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    if video.year and year == video.year:
+        return True
+    if isinstance(video, Episode):
+        # count "no year" as an information
+        return not partial and video.original_series and not year
+
+
+def country_matches(video, country=None, partial=False, **kwargs):
+    """Whether the video matches the `country`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param country: the video country.
+    :type country: :class:`~babelfish.country.Country`
+    :param bool partial: whether or not the guess is partial.
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    if video.country and country == video.country:
+        return True
+
+    if isinstance(video, Episode):
+        # count "no country" as an information
+        return not partial and video.original_series and not country
+
+    if isinstance(video, Movie):
+        # count "no country" as an information
+        return not video.country and not country
+
+
+def release_group_matches(video, release_group=None, **kwargs):
+    """Whether the video matches the `release_group`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param str release_group: the video release group.
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    return (video.release_group and release_group and
+            any(r in sanitize_release_group(release_group)
+                for r in get_equivalent_release_groups(sanitize_release_group(video.release_group))))
+
+
+def streaming_service_matches(video, streaming_service=None, **kwargs):
+    """Whether the video matches the `streaming_service`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param str streaming_service: the video streaming service
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    return video.streaming_service and streaming_service == video.streaming_service
+
+
+def resolution_matches(video, screen_size=None, **kwargs):
+    """Whether the video matches the `resolution`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param str screen_size: the video resolution
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    return video.resolution and screen_size == video.resolution
+
+
+def source_matches(video, source=None, **kwargs):
+    """Whether the video matches the `source`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param str source: the video source
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    return video.source and source == video.source
+
+
+def video_codec_matches(video, video_codec=None, **kwargs):
+    """Whether the video matches the `video_codec`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param str video_codec: the video codec
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    return video.video_codec and video_codec == video.video_codec
+
+
+def audio_codec_matches(video, audio_codec=None, **kwargs):
+    """Whether the video matches the `audio_codec`.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param str audio_codec: the video audio codec
+    :return: whether there's a match
+    :rtype: bool
+
+    """
+    return video.audio_codec and audio_codec == video.audio_codec
+
+
+#: Available matches functions
+matches_manager = {
+    'series': series_matches,
+    'title': title_matches,
+    'season': season_matches,
+    'episode': episode_matches,
+    'year': year_matches,
+    'country': country_matches,
+    'release_group': release_group_matches,
+    'streaming_service': streaming_service_matches,
+    'resolution': resolution_matches,
+    'source': source_matches,
+    'video_codec': video_codec_matches,
+    'audio_codec': audio_codec_matches
+}
+
+
+def guess_matches(video, guess, partial=False):
+    """Get matches between a `video` and a `guess`.
+
+    If a guess is `partial`, the absence information won't be counted as a match.
+
+    :param video: the video.
+    :type video: :class:`~subliminal.video.Video`
+    :param guess: the guess.
+    :type guess: dict
+    :param bool partial: whether or not the guess is partial.
+    :return: matches between the `video` and the `guess`.
+    :rtype: set
+
+    """
+    matches = set()
+    for key in score_keys:
+        if key in matches_manager and matches_manager[key](video, partial=partial, **guess):
+            matches.add(key)
+
+    return matches

custom_libs/subliminal/providers/argenteam.py

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+import io
+import json
+import logging
+from zipfile import ZipFile
+
+from babelfish import Language
+from guessit import guessit
+from requests import Session
+from six.moves import urllib
+
+from . import Provider
+from ..cache import EPISODE_EXPIRATION_TIME, region
+from ..exceptions import ProviderError
+from ..matches import guess_matches
+from ..subtitle import Subtitle, fix_line_ending
+from ..video import Episode
+
+logger = logging.getLogger(__name__)
+
+
+class ArgenteamSubtitle(Subtitle):
+    provider_name = 'argenteam'
+
+    def __init__(self, language, download_link, series, season, episode, release, version):
+        super(ArgenteamSubtitle, self).__init__(language, download_link)
+        self.download_link = download_link
+        self.series = series
+        self.season = season
+        self.episode = episode
+        self.release = release
+        self.version = version
+
+    @property
+    def id(self):
+        return self.download_link
+
+    @property
+    def info(self):
+        return urllib.parse.unquote(self.download_link.rsplit('/')[-1])
+
+    def get_matches(self, video):
+        matches = guess_matches(video, {
+            'title': self.series,
+            'season': self.season,
+            'episode': self.episode,
+            'release_group': self.version
+        })
+
+        # resolution
+        if video.resolution and self.version and video.resolution in self.version.lower():
+            matches.add('resolution')
+
+        matches |= guess_matches(video, guessit(self.version, {'type': 'episode'}), partial=True)
+        return matches
+
+
+class ArgenteamProvider(Provider):
+    provider_name = 'argenteam'
+    language = Language.fromalpha2('es')
+    languages = {language}
+    video_types = (Episode,)
+    server_url = "http://argenteam.net/api/v1/"
+    subtitle_class = ArgenteamSubtitle
+
+    def __init__(self):
+        self.session = None
+
+    def initialize(self):
+        self.session = Session()
+        self.session.headers['User-Agent'] = self.user_agent
+
+    def terminate(self):
+        self.session.close()
+
+    @region.cache_on_arguments(expiration_time=EPISODE_EXPIRATION_TIME, should_cache_fn=lambda value: value)
+    def search_episode_id(self, series, season, episode):
+        """Search the episode id from the `series`, `season` and `episode`.
+
+        :param str series: series of the episode.
+        :param int season: season of the episode.
+        :param int episode: episode number.
+        :return: the episode id, if any.
+        :rtype: int or None
+
+        """
+        # make the search
+        query = '%s S%#02dE%#02d' % (series, season, episode)
+        logger.info('Searching episode id for %r', query)
+        r = self.session.get(self.server_url + 'search', params={'q': query}, timeout=10)
+        r.raise_for_status()
+        results = json.loads(r.text)
+        if results['total'] == 1:
+            return results['results'][0]['id']
+
+        logger.error('No episode id found for %r', series)
+
+    def query(self, series, season, episode):
+        episode_id = self.search_episode_id(series, season, episode)
+        if episode_id is None:
+            return []
+
+        response = self.session.get(self.server_url + 'episode', params={'id': episode_id}, timeout=10)
+        response.raise_for_status()
+        content = json.loads(response.text)
+        subtitles = []
+        for r in content['releases']:
+            for s in r['subtitles']:
+                subtitle = self.subtitle_class(self.language, s['uri'], series, season, episode, r['team'], r['tags'])
+                logger.debug('Found subtitle %r', subtitle)
+                subtitles.append(subtitle)
+
+        return subtitles
+
+    def list_subtitles(self, video, languages):
+        titles = [video.series] + video.alternative_series
+        for title in titles:
+            subs = self.query(title, video.season, video.episode)
+            if subs:
+                return subs
+
+        return []
+
+    def download_subtitle(self, subtitle):
+        # download as a zip
+        logger.info('Downloading subtitle %r', subtitle)
+        r = self.session.get(subtitle.download_link, timeout=10)
+        r.raise_for_status()
+
+        # open the zip
+        with ZipFile(io.BytesIO(r.content)) as zf:
+            if len(zf.namelist()) > 1:
+                raise ProviderError('More than one file to unzip')
+
+            subtitle.content = fix_line_ending(zf.read(zf.namelist()[0]))

custom_libs/subliminal/providers/legendastv.py

@@ -0,0 +1,514 @@
+# -*- coding: utf-8 -*-
+import io
+import json
+import logging
+import os
+import re
+
+from babelfish import Language, language_converters
+from datetime import datetime, timedelta
+from dogpile.cache.api import NO_VALUE
+from guessit import guessit
+import pytz
+import rarfile
+from rarfile import RarFile, is_rarfile
+from rebulk.loose import ensure_list
+from requests import Session
+from zipfile import ZipFile, is_zipfile
+
+from . import ParserBeautifulSoup, Provider
+from ..cache import SHOW_EXPIRATION_TIME, region
+from ..exceptions import AuthenticationError, ConfigurationError, ProviderError, ServiceUnavailable
+from ..matches import guess_matches
+from ..subtitle import SUBTITLE_EXTENSIONS, Subtitle, fix_line_ending
+from ..utils import sanitize
+from ..video import Episode, Movie
+
+logger = logging.getLogger(__name__)
+
+language_converters.register('legendastv = subliminal.converters.legendastv:LegendasTVConverter')
+
+# Configure :mod:`rarfile` to use the same path separator as :mod:`zipfile`
+rarfile.PATH_SEP = '/'
+
+#: Conversion map for types
+type_map = {'M': 'movie', 'S': 'episode', 'C': 'episode'}
+
+#: BR title season parsing regex
+season_re = re.compile(r' - (?P<season>\d+)(\xaa|a|st|nd|rd|th) (temporada|season)', re.IGNORECASE)
+
+#: Downloads parsing regex
+downloads_re = re.compile(r'(?P<downloads>\d+) downloads')
+
+#: Rating parsing regex
+rating_re = re.compile(r'nota (?P<rating>\d+)')
+
+#: Timestamp parsing regex
+timestamp_re = re.compile(r'(?P<day>\d+)/(?P<month>\d+)/(?P<year>\d+) - (?P<hour>\d+):(?P<minute>\d+)')
+
+#: Title with year/country regex
+title_re = re.compile(r'^(?P<series>.*?)(?: \((?:(?P<year>\d{4})|(?P<country>[A-Z]{2}))\))?$')
+
+#: Cache key for releases
+releases_key = __name__ + ':releases|{archive_id}|{archive_name}'
+
+
+class LegendasTVArchive(object):
+    """LegendasTV Archive.
+
+    :param str id: identifier.
+    :param str name: name.
+    :param bool pack: contains subtitles for multiple episodes.
+    :param bool pack: featured.
+    :param str link: link.
+    :param int downloads: download count.
+    :param int rating: rating (0-10).
+    :param timestamp: timestamp.
+    :type timestamp: datetime.datetime
+    """
+
+    def __init__(self, id, name, pack, featured, link, downloads=0, rating=0, timestamp=None):
+        #: Identifier
+        self.id = id
+
+        #: Name
+        self.name = name
+
+        #: Pack
+        self.pack = pack
+
+        #: Featured
+        self.featured = featured
+
+        #: Link
+        self.link = link
+
+        #: Download count
+        self.downloads = downloads
+
+        #: Rating (0-10)
+        self.rating = rating
+
+        #: Timestamp
+        self.timestamp = timestamp
+
+        #: Compressed content as :class:`rarfile.RarFile` or :class:`zipfile.ZipFile`
+        self.content = None
+
+    def __repr__(self):
+        return '<%s [%s] %r>' % (self.__class__.__name__, self.id, self.name)
+
+
+class LegendasTVSubtitle(Subtitle):
+    """LegendasTV Subtitle."""
+
+    provider_name = 'legendastv'
+
+    def __init__(self, language, type, title, year, imdb_id, season, archive, name):
+        super(LegendasTVSubtitle, self).__init__(language, page_link=archive.link)
+        self.type = type
+        self.title = title
+        self.year = year
+        self.imdb_id = imdb_id
+        self.season = season
+        self.archive = archive
+        self.name = name
+
+    @property
+    def id(self):
+        return '%s-%s' % (self.archive.id, self.name.lower())
+
+    @property
+    def info(self):
+        return self.name
+
+    def get_matches(self, video, hearing_impaired=False):
+        matches = guess_matches(video, {
+            'title': self.title,
+            'year': self.year
+        })
+
+        # episode
+        if isinstance(video, Episode) and self.type == 'episode':
+            # imdb_id
+            if video.series_imdb_id and self.imdb_id == video.series_imdb_id:
+                matches.add('series_imdb_id')
+
+        # movie
+        elif isinstance(video, Movie) and self.type == 'movie':
+            # imdb_id
+            if video.imdb_id and self.imdb_id == video.imdb_id:
+                matches.add('imdb_id')
+
+        # name
+        matches |= guess_matches(video, guessit(self.name, {'type': self.type}))
+
+        return matches
+
+
+class LegendasTVProvider(Provider):
+    """LegendasTV Provider.
+
+    :param str username: username.
+    :param str password: password.
+    """
+
+    languages = {Language.fromlegendastv(l) for l in language_converters['legendastv'].codes}
+    server_url = 'http://legendas.tv/'
+    subtitle_class = LegendasTVSubtitle
+
+    def __init__(self, username=None, password=None):
+
+        # Provider needs UNRAR installed. If not available raise ConfigurationError
+        try:
+            rarfile.custom_check([rarfile.UNRAR_TOOL], True)
+        except rarfile.RarExecError:
+            raise ConfigurationError('UNRAR tool not available')
+
+        if any((username, password)) and not all((username, password)):
+            raise ConfigurationError('Username and password must be specified')
+
+        self.username = username
+        self.password = password
+        self.logged_in = False
+        self.session = None
+
+    def initialize(self):
+        self.session = Session()
+        self.session.headers['User-Agent'] = self.user_agent
+
+        # login
+        if self.username and self.password:
+            logger.info('Logging in')
+            data = {'_method': 'POST', 'data[User][username]': self.username, 'data[User][password]': self.password}
+            r = self.session.post(self.server_url + 'login', data, allow_redirects=False, timeout=10)
+            raise_for_status(r)
+
+            soup = ParserBeautifulSoup(r.content, ['html.parser'])
+            if soup.find('div', {'class': 'alert-error'}, string=re.compile(u'Usuário ou senha inválidos')):
+                raise AuthenticationError(self.username)
+
+            logger.debug('Logged in')
+            self.logged_in = True
+
+    def terminate(self):
+        # logout
+        if self.logged_in:
+            logger.info('Logging out')
+            r = self.session.get(self.server_url + 'users/logout', allow_redirects=False, timeout=10)
+            raise_for_status(r)
+            logger.debug('Logged out')
+            self.logged_in = False
+
+        self.session.close()
+
+    @staticmethod
+    def is_valid_title(title, title_id, sanitized_title, season, year):
+        """Check if is a valid title."""
+        sanitized_result = sanitize(title['title'])
+        if sanitized_result != sanitized_title:
+            logger.debug("Mismatched title, discarding title %d (%s)",
+                         title_id, sanitized_result)
+            return
+
+        # episode type
+        if season:
+            # discard mismatches on type
+            if title['type'] != 'episode':
+                logger.debug("Mismatched 'episode' type, discarding title %d (%s)", title_id, sanitized_result)
+                return
+
+            # discard mismatches on season
+            if 'season' not in title or title['season'] != season:
+                logger.debug('Mismatched season %s, discarding title %d (%s)',
+                             title.get('season'), title_id, sanitized_result)
+                return
+        # movie type
+        else:
+            # discard mismatches on type
+            if title['type'] != 'movie':
+                logger.debug("Mismatched 'movie' type, discarding title %d (%s)", title_id, sanitized_result)
+                return
+
+            # discard mismatches on year
+            if year is not None and 'year' in title and title['year'] != year:
+                logger.debug("Mismatched movie year, discarding title %d (%s)", title_id, sanitized_result)
+                return
+        return True
+
+    @region.cache_on_arguments(expiration_time=SHOW_EXPIRATION_TIME, should_cache_fn=lambda value: value)
+    def search_titles(self, title, season, title_year):
+        """Search for titles matching the `title`.
+
+        For episodes, each season has it own title
+        :param str title: the title to search for.
+        :param int season: season of the title
+        :param int title_year: year of the title
+        :return: found titles.
+        :rtype: dict
+        """
+        titles = {}
+        sanitized_titles = [sanitize(title)]
+        ignore_characters = {'\'', '.'}
+        if any(c in title for c in ignore_characters):
+            sanitized_titles.append(sanitize(title, ignore_characters=ignore_characters))
+
+        for sanitized_title in sanitized_titles:
+            # make the query
+            if season:
+                logger.info('Searching episode title %r for season %r', sanitized_title, season)
+            else:
+                logger.info('Searching movie title %r', sanitized_title)
+
+            r = self.session.get(self.server_url + 'legenda/sugestao/{}'.format(sanitized_title), timeout=10)
+            raise_for_status(r)
+            results = json.loads(r.text)
+
+            # loop over results
+            for result in results:
+                source = result['_source']
+
+                # extract id
+                title_id = int(source['id_filme'])
+
+                # extract type
+                title = {'type': type_map[source['tipo']]}
+
+                # extract title, year and country
+                name, year, country = title_re.match(source['dsc_nome']).groups()
+                title['title'] = name
+
+                # extract imdb_id
+                if source['id_imdb'] != '0':
+                    if not source['id_imdb'].startswith('tt'):
+                        title['imdb_id'] = 'tt' + source['id_imdb'].zfill(7)
+                    else:
+                        title['imdb_id'] = source['id_imdb']
+
+                # extract season
+                if title['type'] == 'episode':
+                    if source['temporada'] and source['temporada'].isdigit():
+                        title['season'] = int(source['temporada'])
+                    else:
+                        match = season_re.search(source['dsc_nome_br'])
+                        if match:
+                            title['season'] = int(match.group('season'))
+                        else:
+                            logger.debug('No season detected for title %d (%s)', title_id, name)
+
+                # extract year
+                if year:
+                    title['year'] = int(year)
+                elif source['dsc_data_lancamento'] and source['dsc_data_lancamento'].isdigit():
+                    # year is based on season air date hence the adjustment
+                    title['year'] = int(source['dsc_data_lancamento']) - title.get('season', 1) + 1
+
+                # add title only if is valid
+                # Check against title without ignored chars
+                if self.is_valid_title(title, title_id, sanitized_titles[0], season, title_year):
+                    titles[title_id] = title
+
+            logger.debug('Found %d titles', len(titles))
+
+        return titles
+
+    @region.cache_on_arguments(expiration_time=timedelta(minutes=15).total_seconds())
+    def get_archives(self, title_id, language_code, title_type, season, episodes):
+        """Get the archive list from a given `title_id`, `language_code`, `title_type`, `season` and `episode`.
+
+        :param int title_id: title id.
+        :param int language_code: language code.
+        :param str title_type: episode or movie
+        :param int season: season
+        :param list episodes: episodes
+        :return: the archives.
+        :rtype: list of :class:`LegendasTVArchive`
+
+        """
+        archives = []
+        page = 0
+        while True:
+            # get the archive page
+            url = self.server_url + 'legenda/busca/-/{language}/-/{page}/{title}'.format(
+                language=language_code, page=page, title=title_id)
+            r = self.session.get(url)
+            raise_for_status(r)
+
+            # parse the results
+            soup = ParserBeautifulSoup(r.content, ['lxml', 'html.parser'])
+            for archive_soup in soup.select('div.list_element > article > div > div.f_left'):
+                # create archive
+                archive = LegendasTVArchive(archive_soup.a['href'].split('/')[2],
+                                            archive_soup.a.text,
+                                            'pack' in archive_soup.parent['class'],
+                                            'destaque' in archive_soup.parent['class'],
+                                            self.server_url + archive_soup.a['href'][1:])
+                # clean name of path separators and pack flags
+                clean_name = archive.name.replace('/', '-')
+                if archive.pack and clean_name.startswith('(p)'):
+                    clean_name = clean_name[3:]
+
+                # guess from name
+                guess = guessit(clean_name, {'type': title_type})
+
+                # episode
+                if season and episodes:
+                    # discard mismatches on episode in non-pack archives
+
+                    # Guessit may return int for single episode or list for multi-episode
+                    # Check if archive name has multiple episodes releases on it
+                    if not archive.pack and 'episode' in guess:
+                        wanted_episode = set(episodes)
+                        archive_episode = set(ensure_list(guess['episode']))
+
+                        if not wanted_episode.intersection(archive_episode):
+                            logger.debug('Mismatched episode %s, discarding archive: %s', guess['episode'], clean_name)
+                            continue
+
+                # extract text containing downloads, rating and timestamp
+                data_text = archive_soup.find('p', class_='data').text
+
+                # match downloads
+                archive.downloads = int(downloads_re.search(data_text).group('downloads'))
+
+                # match rating
+                match = rating_re.search(data_text)
+                if match:
+                    archive.rating = int(match.group('rating'))
+
+                # match timestamp and validate it
+                time_data = {k: int(v) for k, v in timestamp_re.search(data_text).groupdict().items()}
+                archive.timestamp = pytz.timezone('America/Sao_Paulo').localize(datetime(**time_data))
+                if archive.timestamp > datetime.utcnow().replace(tzinfo=pytz.utc):
+                    raise ProviderError('Archive timestamp is in the future')
+
+                # add archive
+                logger.info('Found archive for title %d and language %d at page %s: %s',
+                            title_id, language_code, page, archive)
+                archives.append(archive)
+
+            # stop on last page
+            if soup.find('a', attrs={'class': 'load_more'}, string='carregar mais') is None:
+                break
+
+            # increment page count
+            page += 1
+
+        logger.debug('Found %d archives', len(archives))
+
+        return archives
+
+    def download_archive(self, archive):
+        """Download an archive's :attr:`~LegendasTVArchive.content`.
+
+        :param archive: the archive to download :attr:`~LegendasTVArchive.content` of.
+        :type archive: :class:`LegendasTVArchive`
+
+        """
+        logger.info('Downloading archive %s', archive.id)
+        r = self.session.get(self.server_url + 'downloadarquivo/{}'.format(archive.id))
+        raise_for_status(r)
+
+        # open the archive
+        archive_stream = io.BytesIO(r.content)
+        if is_rarfile(archive_stream):
+            logger.debug('Identified rar archive')
+            archive.content = RarFile(archive_stream)
+        elif is_zipfile(archive_stream):
+            logger.debug('Identified zip archive')
+            archive.content = ZipFile(archive_stream)
+        else:
+            raise ValueError('Not a valid archive')
+
+    def query(self, language, title, season=None, episodes=None, year=None):
+        # search for titles
+        titles = self.search_titles(title, season, year)
+
+        subtitles = []
+        # iterate over titles
+        for title_id, t in titles.items():
+
+            logger.info('Getting archives for title %d and language %d', title_id, language.legendastv)
+            archives = self.get_archives(title_id, language.legendastv, t['type'], season, episodes or [])
+            if not archives:
+                logger.info('No archives found for title %d and language %d', title_id, language.legendastv)
+
+            # iterate over title's archives
+            for a in archives:
+
+                # compute an expiration time based on the archive timestamp
+                expiration_time = (datetime.utcnow().replace(tzinfo=pytz.utc) - a.timestamp).total_seconds()
+
+                # attempt to get the releases from the cache
+                cache_key = releases_key.format(archive_id=a.id, archive_name=a.name)
+                releases = region.get(cache_key, expiration_time=expiration_time)
+
+                # the releases are not in cache or cache is expired
+                if releases == NO_VALUE:
+                    logger.info('Releases not found in cache')
+
+                    # download archive
+                    self.download_archive(a)
+
+                    # extract the releases
+                    releases = []
+                    for name in a.content.namelist():
+                        # discard the legendastv file
+                        if name.startswith('Legendas.tv'):
+                            continue
+
+                        # discard hidden files
+                        if os.path.split(name)[-1].startswith('.'):
+                            continue
+
+                        # discard non-subtitle files
+                        if not name.lower().endswith(SUBTITLE_EXTENSIONS):
+                            continue
+
+                        releases.append(name)
+
+                    # cache the releases
+                    region.set(cache_key, releases)
+
+                # iterate over releases
+                for r in releases:
+                    subtitle = self.subtitle_class(language, t['type'], t['title'], t.get('year'), t.get('imdb_id'),
+                                                   t.get('season'), a, r)
+                    logger.debug('Found subtitle %r', subtitle)
+                    subtitles.append(subtitle)
+
+        return subtitles
+
+    def list_subtitles(self, video, languages):
+        season = None
+        episodes = []
+        if isinstance(video, Episode):
+            titles = [video.series] + video.alternative_series
+            season = video.season
+            episodes = video.episodes
+        else:
+            titles = [video.title] + video.alternative_titles
+
+        for title in titles:
+            subtitles = [s for l in languages for s in
+                         self.query(l, title, season=season, episodes=episodes, year=video.year)]
+            if subtitles:
+                return subtitles
+
+        return []
+
+    def download_subtitle(self, subtitle):
+        # download archive in case we previously hit the releases cache and didn't download it
+        if subtitle.archive.content is None:
+            self.download_archive(subtitle.archive)
+
+        # extract subtitle's content
+        subtitle.content = fix_line_ending(subtitle.archive.content.read(subtitle.name))
+
+
+def raise_for_status(r):
+    # When site is under maintaince and http status code 200.
+    if 'Em breve estaremos de volta' in r.text:
+        raise ServiceUnavailable
+    else:
+        r.raise_for_status()

custom_libs/subliminal/refiners/hash.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+import logging
+
+from ..extensions import provider_manager, default_providers
+from ..utils import hash_napiprojekt, hash_opensubtitles, hash_shooter, hash_thesubdb
+
+logger = logging.getLogger(__name__)
+
+hash_functions = {
+    'napiprojekt': hash_napiprojekt,
+    'opensubtitles': hash_opensubtitles,
+    'opensubtitlesvip': hash_opensubtitles,
+    'shooter': hash_shooter,
+    'thesubdb': hash_thesubdb
+}
+
+
+def refine(video, providers=None, languages=None, **kwargs):
+    """Refine a video computing required hashes for the given providers.
+
+    The following :class:`~subliminal.video.Video` attribute can be found:
+
+      * :attr:`~subliminal.video.Video.hashes`
+
+    """
+    if video.size <= 10485760:
+        logger.warning('Size is lower than 10MB: hashes not computed')
+        return
+
+    logger.debug('Computing hashes for %r', video.name)
+    for name in providers or default_providers:
+        provider = provider_manager[name].plugin
+        if name not in hash_functions:
+            continue
+
+        if not provider.check_types(video):
+            continue
+
+        if languages and not provider.check_languages(languages):
+            continue
+
+        video.hashes[name] = hash_functions[name](video.name)
+
+    logger.debug('Computed hashes %r', video.hashes)