Add Cinemast provider

HISTORY.rst

@@ -16,7 +16,7 @@ Changelog
 ^^^^^
 **release date:** 2016-09-03
 
-* Fix subscenter
+* Add Cinemast provider
 
 
 2.0.3

docs/api/providers.rst

@@ -7,6 +7,11 @@ Addic7ed
 .. automodule:: subliminal.providers.addic7ed
    :private-members:
 
+Cinemast
+----------
+.. automodule:: subliminal.providers.cinemast
+   :private-members:
+
 LegendasTv
 ----------
 .. automodule:: subliminal.providers.legendastv

docs/user/how_it_works.rst

@@ -7,6 +7,7 @@ Subliminal uses multiple providers to give users a vast choice and have a better
 subtitles. Current supported providers are:
 
 * Addic7ed
+* Cinemast
 * LegendasTV
 * NapiProjekt
 * OpenSubtitles

setup.py

@@ -69,6 +69,7 @@ def find_version(*file_paths):
       entry_points={
           'subliminal.providers': [
               'addic7ed = subliminal.providers.addic7ed:Addic7edProvider',
+              'cinemast = subliminal.providers.cinemast:CinemastProvider',
               'legendastv = subliminal.providers.legendastv:LegendasTVProvider',
               'opensubtitles = subliminal.providers.opensubtitles:OpenSubtitlesProvider',
               'podnapisi = subliminal.providers.podnapisi:PodnapisiProvider',

subliminal/cli.py

@@ -216,6 +216,7 @@ def convert(self, value, param, ctx):
 @click.group(context_settings={'max_content_width': 100}, epilog='Suggestions and bug reports are greatly appreciated: '
              'https://github.com/Diaoul/subliminal/')
 @click.option('--addic7ed', type=click.STRING, nargs=2, metavar='USERNAME PASSWORD', help='Addic7ed configuration.')
+@click.option('--cinemast', type=click.STRING, nargs=2, metavar='USERNAME PASSWORD', help='Cinemast configuration.')
 @click.option('--legendastv', type=click.STRING, nargs=2, metavar='USERNAME PASSWORD', help='LegendasTV configuration.')
 @click.option('--opensubtitles', type=click.STRING, nargs=2, metavar='USERNAME PASSWORD',
               help='OpenSubtitles configuration.')
@@ -224,7 +225,7 @@ def convert(self, value, param, ctx):
 @click.option('--debug', is_flag=True, help='Print useful information for debugging subliminal and for reporting bugs.')
 @click.version_option(__version__)
 @click.pass_context
-def subliminal(ctx, addic7ed, legendastv, opensubtitles, cache_dir, debug):
+def subliminal(ctx, addic7ed, cinemast, legendastv, opensubtitles, cache_dir, debug):
     """Subtitles, faster than your thoughts."""
     # create cache directory
     try:
@@ -248,6 +249,8 @@ def subliminal(ctx, addic7ed, legendastv, opensubtitles, cache_dir, debug):
     ctx.obj = {'provider_configs': {}}
     if addic7ed:
         ctx.obj['provider_configs']['addic7ed'] = {'username': addic7ed[0], 'password': addic7ed[1]}
+    if cinemast:
+        ctx.obj['provider_configs']['cinemast'] = {'username': cinemast[0], 'password': cinemast[1]}
     if legendastv:
         ctx.obj['provider_configs']['legendastv'] = {'username': legendastv[0], 'password': legendastv[1]}
     if opensubtitles:

subliminal/extensions.py

@@ -89,6 +89,7 @@ def unregister(self, entry_point):
 #: Provider manager
 provider_manager = RegistrableExtensionManager('subliminal.providers', [
     'addic7ed = subliminal.providers.addic7ed:Addic7edProvider',
+    'cinemast = subliminal.providers.cinemast:CinemastProvider',
     'legendastv = subliminal.providers.legendastv:LegendasTVProvider',
     'opensubtitles = subliminal.providers.opensubtitles:OpenSubtitlesProvider',
     'podnapisi = subliminal.providers.podnapisi:PodnapisiProvider',

subliminal/providers/cinemast.py

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+import bisect
+import io
+import logging
+import zipfile
+
+from babelfish import Language
+from guessit import guessit
+from requests import Session
+
+from . import Provider
+from .. import __short_version__
+from ..exceptions import AuthenticationError, ConfigurationError, ProviderError
+from ..subtitle import Subtitle, fix_line_ending, guess_matches
+from ..utils import sanitize
+from ..video import Episode, Movie
+
+logger = logging.getLogger(__name__)
+
+
+class CinemastSubtitle(Subtitle):
+    """Cinemast Subtitle."""
+    provider_name = 'cinemast'
+
+    def __init__(self, language, page_link, series, season, episode, title, subtitle_id, subtitle_key,
+                 releases):
+        super(CinemastSubtitle, self).__init__(language, page_link=page_link)
+        self.series = series
+        self.season = season
+        self.episode = episode
+        self.title = title
+        self.subtitle_id = subtitle_id
+        self.subtitle_key = subtitle_key
+        self.downloaded = 0
+        self.releases = releases
+
+    @property
+    def id(self):
+        return str(self.subtitle_id)
+
+    def get_matches(self, video):
+        matches = set()
+
+        # episode
+        if isinstance(video, Episode):
+            # series
+            if video.series and (sanitize(self.title) in (
+                    sanitize(name) for name in [video.series] + video.alternative_series)):
+                matches.add('series')
+            # season
+            if video.season and self.season == video.season:
+                matches.add('season')
+            # episode
+            if video.episode and self.episode == video.episode:
+                matches.add('episode')
+            # guess
+            for release in self.releases:
+                matches |= guess_matches(video, guessit(release, {'type': 'episode'}))
+        # movie
+        elif isinstance(video, Movie):
+            # guess
+            for release in self.releases:
+                matches |= guess_matches(video, guessit(release, {'type': 'movie'}))
+
+            # title
+            if video.title and (sanitize(self.title) in (
+                    sanitize(name) for name in [video.title] + video.alternative_titles)):
+                matches.add('title')
+
+        return matches
+
+
+class CinemastProvider(Provider):
+    """Cinemast Provider."""
+    languages = {Language.fromalpha2(l) for l in ['he']}
+    server_url = 'http://www.cinemast.org/he/cinemast/api/'
+    subtitle_class = CinemastSubtitle
+
+    default_username = '[email protected]'
+    default_password = 'subliminal'
+
+    def __init__(self, username=None, password=None):
+        if any((username, password)) and not all((username, password)):
+            raise ConfigurationError('Username and password must be specified')
+
+        self.session = None
+        self.username = username or self.default_username
+        self.password = password or self.default_password
+        self.user_id = None
+        self.token = None
+        self.session = None
+
+    def initialize(self):
+        self.session = Session()
+        self.session.headers['User-Agent'] = 'Subliminal/{}'.format(__short_version__)
+
+        # login
+        if self.username and self.password:
+            logger.debug('Logging in')
+            url = self.server_url + 'login/'
+
+            # actual login
+            data = {'username': self.username, 'password': self.password}
+            r = self.session.post(url, data=data, allow_redirects=False, timeout=10)
+
+            if r.status_code != 200:
+                raise AuthenticationError(self.username)
+
+            try:
+                result = r.json()
+                if 'token' not in result:
+                    raise AuthenticationError(self.username)
+
+                logger.info('Logged in')
+                self.user_id = r.json().get('user')
+                self.token = r.json().get('token')
+            except ValueError:
+                raise AuthenticationError(self.username)
+
+    def terminate(self):
+        # logout
+        if self.token or self.user_id:
+            logger.info('Logged out')
+            self.token = None
+            self.user_id = None
+
+        self.session.close()
+
+    def query(self, title, season=None, episode=None, year=None):
+        query = {
+            'q': title,
+            'user': self.user_id,
+            'token': self.token
+        }
+
+        # episode
+        if season and episode:
+            query['type'] = 'series'
+            query['season'] = season
+            query['episode'] = episode
+        else:
+            query['type'] = 'movies'
+            if year:
+                query['year_start'] = year - 1
+                query['year_end'] = year
+
+        # get the list of subtitles
+        logger.debug('Getting the list of subtitles')
+        url = self.server_url + 'search/'
+        r = self.session.post(url, data=query)
+        r.raise_for_status()
+
+        try:
+            results = r.json()
+        except ValueError:
+            return {}
+
+        # loop over results
+        subtitles = {}
+        for group_data in results.get('data', []):
+            # create page link
+            slug_name = group_data.get('name_en').lower().replace(' ', '-').replace('\'', '').replace('"', '')
+            if query['type'] == 'series':
+                page_link = self.server_url + 'subtitle/series/{}/{}/{}/'.format(slug_name, season, episode)
+            else:
+                page_link = self.server_url + 'subtitle/movie/{}/'.format(slug_name)
+
+            # go over each language
+            for language_code, subtitles_data in group_data.get('subtitles', {}).items():
+                for subtitle_item in subtitles_data:
+                    # read the item
+                    language = Language.fromalpha2(language_code)
+                    subtitle_id = subtitle_item['id']
+                    subtitle_key = subtitle_item['key']
+                    release = subtitle_item['version']
+
+                    # add the release and increment downloaded count if we already have the subtitle
+                    if subtitle_id in subtitles:
+                        logger.debug('Found additional release %r for subtitle %r', release, subtitle_id)
+                        bisect.insort_left(subtitles[subtitle_id].releases, release)  # deterministic order
+                        subtitles[subtitle_id].downloaded += 1
+                        continue
+
+                    # otherwise create it
+                    subtitle = self.subtitle_class(language, page_link, title, season, episode, title, subtitle_id,
+                                                   subtitle_key, [release])
+                    logger.debug('Found subtitle %r', subtitle)
+                    subtitles[subtitle_id] = subtitle
+
+        return subtitles.values()
+
+    def list_subtitles(self, video, languages):
+        season = episode = None
+
+        if isinstance(video, Episode):
+            titles = [video.series] + video.alternative_series
+            season = video.season
+            episode = video.episode
+        else:
+            titles = [video.title] + video.alternative_titles
+
+        for title in titles:
+            subtitles = [s for s in self.query(title, season, episode) if s.language in languages]
+            if subtitles:
+                return subtitles
+
+        return []
+
+    def download_subtitle(self, subtitle):
+        # download
+        url = self.server_url + 'subtitle/download/{}/'.format(subtitle.language.alpha2)
+        params = {
+            'v': subtitle.releases[0],
+            'key': subtitle.subtitle_key,
+            'sub_id': subtitle.subtitle_id
+        }
+        data = {
+            'user': self.user_id,
+            'token': self.token
+        }
+        r = self.session.post(url, data=data, params=params, timeout=10)
+        r.raise_for_status()
+
+        # open the zip
+        with zipfile.ZipFile(io.BytesIO(r.content)) as zf:
+            # remove some filenames from the namelist
+            namelist = [n for n in zf.namelist() if not n.endswith('.txt')]
+            if len(namelist) > 1:
+                raise ProviderError('More than one file to unzip')
+
+            subtitle.content = fix_line_ending(zf.read(namelist[0]))