Subliminal update

libs/subliminal/services/__init__.py

@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
+#
+# This file is part of subliminal.
+#
+# subliminal is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# subliminal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with subliminal.  If not, see <http://www.gnu.org/licenses/>.
+from ..exceptions import MissingLanguageError, DownloadFailedError
+import logging
+import os
+import requests
+import threading
+
+
+__all__ = ['ServiceBase', 'ServiceConfig']
+logger = logging.getLogger(__name__)
+
+
+class ServiceBase(object):
+    """Service base class
+
+    :param config: service configuration
+    :type config: :class:`ServiceConfig`
+
+    """
+    #: URL to the service server
+    server_url = ''
+
+    #: User Agent for any HTTP-based requests
+    user_agent = 'subliminal v0.5'
+
+    #: Whether based on an API or not
+    api_based = False
+
+    #: Timeout for web requests
+    timeout = 5
+
+    #: Lock for cache interactions
+    lock = threading.Lock()
+
+    #: Mapping to Service's language codes and subliminal's
+    languages = {}
+
+    #: Whether the mapping is reverted or not
+    reverted_languages = False
+
+    #: Accepted video classes (:class:`~subliminal.videos.Episode`, :class:`~subliminal.videos.Movie`, :class:`~subliminal.videos.UnknownVideo`)
+    videos = []
+
+    #: Whether the video has to exist or not
+    require_video = False
+
+    def __init__(self, config=None):
+        self.config = config or ServiceConfig()
+
+    def __enter__(self):
+        self.init()
+        return self
+
+    def __exit__(self, *args):
+        self.terminate()
+
+    def init(self):
+        """Initialize connection"""
+        logger.debug(u'Initializing %s' % self.__class__.__name__)
+        self.session = requests.session(timeout=10, headers={'User-Agent': self.user_agent})
+
+    def terminate(self):
+        """Terminate connection"""
+        logger.debug(u'Terminating %s' % self.__class__.__name__)
+
+    def query(self, *args):
+        """Make the actual query"""
+        pass
+
+    def list(self, video, languages):
+        """List subtitles"""
+        pass
+
+    def download(self, subtitle):
+        """Download a subtitle"""
+        self.download_file(subtitle.link, subtitle.path)
+
+    @classmethod
+    def available_languages(cls):
+        """Available languages in the Service
+
+        :return: available languages
+        :rtype: set
+
+        """
+        if not cls.reverted_languages:
+            return set(cls.languages.keys())
+        return set(cls.languages.values())
+
+    @classmethod
+    def check_validity(cls, video, languages):
+        """Check for video and languages validity in the Service
+
+        :param video: the video to check
+        :type video: :class:`~subliminal.videos.video`
+        :param set languages: languages to check
+        :rtype: bool
+
+        """
+        languages &= cls.available_languages()
+        if not languages:
+            logger.debug(u'No language available for service %s' % cls.__class__.__name__.lower())
+            return False
+        if not cls.is_valid_video(video):
+            logger.debug(u'%r is not valid for service %s' % (video, cls.__class__.__name__.lower()))
+            return False
+        return True
+
+    @classmethod
+    def is_valid_video(cls, video):
+        """Check if video is valid in the Service
+
+        :param video: the video to check
+        :type video: :class:`~subliminal.videos.Video`
+        :rtype: bool
+
+        """
+        if cls.require_video and not video.exists:
+            return False
+        if not isinstance(video, tuple(cls.videos)):
+            return False
+        return True
+
+    @classmethod
+    def is_valid_language(cls, language):
+        """Check if language is valid in the Service
+
+        :param string language: the language to check
+        :rtype: bool
+
+        """
+        if language in cls.available_languages():
+            return True
+        return False
+
+    @classmethod
+    def get_revert_language(cls, language):
+        """ISO-639-1 language code from service language code
+
+        :param string language: service language code
+        :return: ISO-639-1 language code
+        :rtype: string
+
+        """
+        if not cls.reverted_languages and language in cls.languages.values():
+            return [k for k, v in cls.languages.iteritems() if v == language][0]
+        if cls.reverted_languages and language in cls.languages.keys():
+            return cls.languages[language]
+        raise MissingLanguageError(language)
+
+    @classmethod
+    def get_language(cls, language):
+        """Service language code from ISO-639-1 language code
+
+        :param string language: ISO-639-1 language code
+        :return: service language code
+        :rtype: string
+
+        """
+        if not cls.reverted_languages and language in cls.languages.keys():
+            return cls.languages[language]
+        if cls.reverted_languages and language in cls.languages.values():
+            return [k for k, v in cls.languages.iteritems() if v == language][0]
+        raise MissingLanguageError(language)
+
+    def download_file(self, url, filepath):
+        """Attempt to download a file and remove it in case of failure
+
+        :param string url: URL to download
+        :param string filepath: destination path
+
+        """
+        logger.info(u'Downloading %s' % url)
+        try:
+            r = self.session.get(url, headers={'Referer': url, 'User-Agent': self.user_agent})
+            with open(filepath, 'wb') as f:
+                f.write(r.content)
+        except Exception as e:
+            logger.error(u'Download %s failed: %s' % (url, e))
+            if os.path.exists(filepath):
+                os.remove(filepath)
+            raise DownloadFailedError(str(e))
+        logger.debug(u'Download finished for file %s. Size: %s' % (filepath, os.path.getsize(filepath)))
+
+
+class ServiceConfig(object):
+    """Configuration for any :class:`Service`
+
+    :param bool multi: whether to download one subtitle per language or not
+    :param string cache_dir: cache directory
+
+    """
+    def __init__(self, multi=False, cache_dir=None):
+        self.multi = multi
+        self.cache_dir = cache_dir
+
+    def __repr__(self):
+        return 'ServiceConfig(%r, %s)' % (self.multi, self.cache_dir)

libs/subliminal/services/bierdopje.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
+#
+# This file is part of subliminal.
+#
+# subliminal is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# subliminal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with subliminal.  If not, see <http://www.gnu.org/licenses/>.
+from . import ServiceBase
+from ..exceptions import ServiceError
+from ..subtitles import get_subtitle_path, ResultSubtitle
+from ..videos import Episode
+from ..utils import to_unicode
+import BeautifulSoup
+import logging
+import os.path
+import urllib
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+
+logger = logging.getLogger(__name__)
+
+
+class BierDopje(ServiceBase):
+    server_url = 'http://api.bierdopje.com/A2B638AC5D804C2E/'
+    api_based = True
+    languages = {'en': 'en', 'nl': 'nl'}
+    reverted_languages = False
+    videos = [Episode]
+    require_video = False
+
+    def __init__(self, config=None):
+        super(BierDopje, self).__init__(config)
+        self.showids = {}
+        if self.config and self.config.cache_dir:
+            self.init_cache()
+
+    def init_cache(self):
+        logger.debug(u'Initializing cache...')
+        if not self.config or not self.config.cache_dir:
+            raise ServiceError('Cache directory is required')
+        self.showids_cache = os.path.join(self.config.cache_dir, 'bierdopje_showids.cache')
+        if not os.path.exists(self.showids_cache):
+            self.save_cache()
+
+    def save_cache(self):
+        logger.debug(u'Saving showids to cache...')
+        with self.lock:
+            with open(self.showids_cache, 'w') as f:
+                pickle.dump(self.showids, f)
+
+    def load_cache(self):
+        logger.debug(u'Loading showids from cache...')
+        with self.lock:
+            with open(self.showids_cache, 'r') as f:
+                self.showids = pickle.load(f)
+
+    def query(self, season, episode, languages, filepath, tvdbid=None, series=None):
+        self.load_cache()
+        if series:
+            if series.lower() in self.showids:  # from cache
+                request_id = self.showids[series.lower()]
+                logger.debug(u'Retreived showid %d for %s from cache' % (request_id, series))
+            else:  # query to get showid
+                logger.debug(u'Getting showid from show name %s...' % series)
+                r = self.session.get('%sGetShowByName/%s' % (self.server_url, urllib.quote(series.lower())))
+                if r.status_code != 200:
+                    logger.error(u'Request %s returned status code %d' % (r.url, r.status_code))
+                    return []
+                soup = BeautifulSoup.BeautifulStoneSoup(r.content)
+                if soup.status.contents[0] == 'false':
+                    logger.debug(u'Could not find show %s' % series)
+                    return []
+                request_id = int(soup.showid.contents[0])
+                self.showids[series.lower()] = request_id
+                self.save_cache()
+            request_source = 'showid'
+            request_is_tvdbid = 'false'
+        elif tvdbid:
+            request_id = tvdbid
+            request_source = 'tvdbid'
+            request_is_tvdbid = 'true'
+        else:
+            raise ServiceError('One or more parameter missing')
+        subtitles = []
+        for language in languages:
+            logger.debug(u'Getting subtitles for %s %d season %d episode %d with language %s' % (request_source, request_id, season, episode, language))
+            r = self.session.get('%sGetAllSubsFor/%s/%s/%s/%s/%s' % (self.server_url, request_id, season, episode, language, request_is_tvdbid))
+            if r.status_code != 200:
+                logger.error(u'Request %s returned status code %d' % (r.url, r.status_code))
+                return []
+            soup = BeautifulSoup.BeautifulStoneSoup(r.content)
+            if soup.status.contents[0] == 'false':
+                logger.debug(u'Could not find subtitles for %s %d season %d episode %d with language %s' % (request_source, request_id, season, episode, language))
+                continue
+            path = get_subtitle_path(filepath, language, self.config.multi)
+            for result in soup.results('result'):
+                subtitle = ResultSubtitle(path, language, service=self.__class__.__name__.lower(), link=result.downloadlink.contents[0],
+                                          release=to_unicode(result.filename.contents[0]))
+                subtitles.append(subtitle)
+        return subtitles
+
+    def list(self, video, languages):
+        if not self.check_validity(video, languages):
+            return []
+        results = self.query(video.season, video.episode, languages, video.path or video.release, video.tvdbid, video.series)
+        return results
+
+
+Service = BierDopje

libs/subliminal/services/opensubtitles.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
+#
+# This file is part of subliminal.
+#
+# subliminal is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# subliminal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with subliminal.  If not, see <http://www.gnu.org/licenses/>.
+from . import ServiceBase
+from ..exceptions import ServiceError, DownloadFailedError
+from ..subtitles import get_subtitle_path, ResultSubtitle
+from ..videos import Episode, Movie
+from ..utils import to_unicode
+import gzip
+import logging
+import os.path
+import xmlrpclib
+
+
+logger = logging.getLogger(__name__)
+
+
+class OpenSubtitles(ServiceBase):
+    server_url = 'http://api.opensubtitles.org/xml-rpc'
+    api_based = True
+    languages = {'aa': 'aar', 'ab': 'abk', 'af': 'afr', 'ak': 'aka', 'sq': 'alb', 'am': 'amh', 'ar': 'ara',
+                 'an': 'arg', 'hy': 'arm', 'as': 'asm', 'av': 'ava', 'ae': 'ave', 'ay': 'aym', 'az': 'aze',
+                 'ba': 'bak', 'bm': 'bam', 'eu': 'baq', 'be': 'bel', 'bn': 'ben', 'bh': 'bih', 'bi': 'bis',
+                 'bs': 'bos', 'br': 'bre', 'bg': 'bul', 'my': 'bur', 'ca': 'cat', 'ch': 'cha', 'ce': 'che',
+                 'zh': 'chi', 'cu': 'chu', 'cv': 'chv', 'kw': 'cor', 'co': 'cos', 'cr': 'cre', 'cs': 'cze',
+                 'da': 'dan', 'dv': 'div', 'nl': 'dut', 'dz': 'dzo', 'en': 'eng', 'eo': 'epo', 'et': 'est',
+                 'ee': 'ewe', 'fo': 'fao', 'fj': 'fij', 'fi': 'fin', 'fr': 'fre', 'fy': 'fry', 'ff': 'ful',
+                 'ka': 'geo', 'de': 'ger', 'gd': 'gla', 'ga': 'gle', 'gl': 'glg', 'gv': 'glv', 'el': 'ell',
+                 'gn': 'grn', 'gu': 'guj', 'ht': 'hat', 'ha': 'hau', 'he': 'heb', 'hz': 'her', 'hi': 'hin',
+                 'ho': 'hmo', 'hr': 'hrv', 'hu': 'hun', 'ig': 'ibo', 'is': 'ice', 'io': 'ido', 'ii': 'iii',
+                 'iu': 'iku', 'ie': 'ile', 'ia': 'ina', 'id': 'ind', 'ik': 'ipk', 'it': 'ita', 'jv': 'jav',
+                 'ja': 'jpn', 'kl': 'kal', 'kn': 'kan', 'ks': 'kas', 'kr': 'kau', 'kk': 'kaz', 'km': 'khm',
+                 'ki': 'kik', 'rw': 'kin', 'ky': 'kir', 'kv': 'kom', 'kg': 'kon', 'ko': 'kor', 'kj': 'kua',
+                 'ku': 'kur', 'lo': 'lao', 'la': 'lat', 'lv': 'lav', 'li': 'lim', 'ln': 'lin', 'lt': 'lit',
+                 'lb': 'ltz', 'lu': 'lub', 'lg': 'lug', 'mk': 'mac', 'mh': 'mah', 'ml': 'mal', 'mi': 'mao',
+                 'mr': 'mar', 'ms': 'may', 'mg': 'mlg', 'mt': 'mlt', 'mo': 'mol', 'mn': 'mon', 'na': 'nau',
+                 'nv': 'nav', 'nr': 'nbl', 'nd': 'nde', 'ng': 'ndo', 'ne': 'nep', 'nn': 'nno', 'nb': 'nob',
+                 'no': 'nor', 'ny': 'nya', 'oc': 'oci', 'oj': 'oji', 'or': 'ori', 'om': 'orm', 'os': 'oss',
+                 'pa': 'pan', 'fa': 'per', 'pi': 'pli', 'pl': 'pol', 'pt': 'por', 'ps': 'pus', 'qu': 'que',
+                 'rm': 'roh', 'rn': 'run', 'ru': 'rus', 'sg': 'sag', 'sa': 'san', 'sr': 'scc', 'si': 'sin',
+                 'sk': 'slo', 'sl': 'slv', 'se': 'sme', 'sm': 'smo', 'sn': 'sna', 'sd': 'snd', 'so': 'som',
+                 'st': 'sot', 'es': 'spa', 'sc': 'srd', 'ss': 'ssw', 'su': 'sun', 'sw': 'swa', 'sv': 'swe',
+                 'ty': 'tah', 'ta': 'tam', 'tt': 'tat', 'te': 'tel', 'tg': 'tgk', 'tl': 'tgl', 'th': 'tha',
+                 'bo': 'tib', 'ti': 'tir', 'to': 'ton', 'tn': 'tsn', 'ts': 'tso', 'tk': 'tuk', 'tr': 'tur',
+                 'tw': 'twi', 'ug': 'uig', 'uk': 'ukr', 'ur': 'urd', 'uz': 'uzb', 've': 'ven', 'vi': 'vie',
+                 'vo': 'vol', 'cy': 'wel', 'wa': 'wln', 'wo': 'wol', 'xh': 'xho', 'yi': 'yid', 'yo': 'yor',
+                 'za': 'zha', 'zu': 'zul', 'ro': 'rum', 'po': 'pob', 'un': 'unk', 'ay': 'ass'}
+    reverted_languages = False
+    videos = [Episode, Movie]
+    require_video = False
+    confidence_order = ['moviehash', 'imdbid', 'fulltext']
+
+    def __init__(self, config=None):
+        super(OpenSubtitles, self).__init__(config)
+        self.server = xmlrpclib.ServerProxy(self.server_url)
+        self.token = None
+
+    def init(self):
+        super(OpenSubtitles, self).init()
+        result = self.server.LogIn('', '', 'eng', self.user_agent)
+        if result['status'] != '200 OK':
+            raise ServiceError('Login failed')
+        self.token = result['token']
+
+    def terminate(self):
+        super(OpenSubtitles, self).terminate()
+        if self.token:
+            self.server.LogOut(self.token)
+
+    def query(self, filepath, languages, moviehash=None, size=None, imdbid=None, query=None):
+        searches = []
+        if moviehash and size:
+            searches.append({'moviehash': moviehash, 'moviebytesize': size})
+        if imdbid:
+            searches.append({'imdbid': imdbid})
+        if query:
+            searches.append({'query': query})
+        if not searches:
+            raise ServiceError('One or more parameter missing')
+        for search in searches:
+            search['sublanguageid'] = ','.join([self.get_language(l) for l in languages])
+        logger.debug(u'Getting subtitles %r with token %s' % (searches, self.token))
+        results = self.server.SearchSubtitles(self.token, searches)
+        if not results['data']:
+            logger.debug(u'Could not find subtitles for %r with token %s' % (searches, self.token))
+            return []
+        subtitles = []
+        for result in results['data']:
+            language = self.get_revert_language(result['SubLanguageID'])
+            path = get_subtitle_path(filepath, language, self.config.multi)
+            confidence = 1 - float(self.confidence_order.index(result['MatchedBy'])) / float(len(self.confidence_order))
+            subtitle = ResultSubtitle(path, language, service=self.__class__.__name__.lower(), link=result['SubDownloadLink'],
+                                      release=to_unicode(result['SubFileName']), confidence=confidence)
+            subtitles.append(subtitle)
+        return subtitles
+
+    def list(self, video, languages):
+        if not self.check_validity(video, languages):
+            return []
+        results = []
+        if video.exists:
+            results = self.query(video.path or video.release, languages, moviehash=video.hashes['OpenSubtitles'], size=str(video.size))
+        elif video.imdbid:
+            results = self.query(video.path or video.release, languages, imdbid=video.imdbid)
+        elif isinstance(video, Episode):
+            results = self.query(video.path or video.release, languages, query=video.series)
+        elif isinstance(video, Movie):
+            results = self.query(video.path or video.release, languages, query=video.title)
+        return results
+
+    def download(self, subtitle):
+        #TODO: Use OpenSubtitles DownloadSubtitles method
+        try:
+            self.download_file(subtitle.link, subtitle.path + '.gz')
+            with open(subtitle.path, 'wb') as dump:
+                gz = gzip.open(subtitle.path + '.gz')
+                dump.write(gz.read())
+                gz.close()
+        except Exception as e:
+            if os.path.exists(subtitle.path):
+                os.remove(subtitle.path)
+            raise DownloadFailedError(str(e))
+        finally:
+            if os.path.exists(subtitle.path + '.gz'):
+                os.remove(subtitle.path + '.gz')
+        return subtitle
+
+
+Service = OpenSubtitles

libs/subliminal/services/subswiki.py

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
+#
+# This file is part of subliminal.
+#
+# subliminal is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# subliminal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with subliminal.  If not, see <http://www.gnu.org/licenses/>.
+from . import ServiceBase
+from ..exceptions import ServiceError
+from ..subtitles import get_subtitle_path, ResultSubtitle
+from ..videos import Episode, Movie
+from subliminal.utils import get_keywords, split_keyword
+import BeautifulSoup
+import logging
+import re
+import urllib
+
+
+logger = logging.getLogger(__name__)
+
+
+class SubsWiki(ServiceBase):
+    server_url = 'http://www.subswiki.com'
+    api_based = False
+    languages = {u'English (US)': 'en', u'English (UK)': 'en', u'English': 'en', u'French': 'fr', u'Brazilian': 'po',
+                 u'Portuguese': 'pt', u'Español (Latinoamérica)': 'es', u'Español (España)': 'es', u'Español': 'es',
+                 u'Italian': 'it', u'Català': 'ca'}
+    reverted_languages = True
+    videos = [Episode, Movie]
+    require_video = False
+    release_pattern = re.compile('\nVersion (.+), ([0-9]+).([0-9])+ MBs')
+
+    def list(self, video, languages):
+        if not self.check_validity(video, languages):
+            return []
+        results = []
+        if isinstance(video, Episode):
+            results = self.query(video.path or video.release, languages, get_keywords(video.guess), series=video.series, season=video.season, episode=video.episode)
+        elif isinstance(video, Movie) and video.year:
+            results = self.query(video.path or video.release, languages, get_keywords(video.guess), movie=video.title, year=video.year)
+        return results
+
+    def query(self, filepath, languages, keywords=None, series=None, season=None, episode=None, movie=None, year=None):
+        if series and season and episode:
+            request_series = series.lower().replace(' ', '_')
+            if isinstance(request_series, unicode):
+                request_series = request_series.encode('utf-8')
+            logger.debug(u'Getting subtitles for %s season %d episode %d with languages %r' % (series, season, episode, languages))
+            r = self.session.get('%s/serie/%s/%s/%s/' % (self.server_url, urllib.quote(request_series), season, episode))
+            if r.status_code == 404:
+                logger.debug(u'Could not find subtitles for %s season %d episode %d with languages %r' % (series, season, episode, languages))
+                return []
+        elif movie and year:
+            request_movie = movie.title().replace(' ', '_')
+            if isinstance(request_movie, unicode):
+                request_movie = request_movie.encode('utf-8')
+            logger.debug(u'Getting subtitles for %s (%d) with languages %r' % (movie, year, languages))
+            r = self.session.get('%s/film/%s_(%d)' % (self.server_url, urllib.quote(request_movie), year))
+            if r.status_code == 404:
+                logger.debug(u'Could not find subtitles for %s (%d) with languages %r' % (movie, year, languages))
+                return []
+        else:
+            raise ServiceError('One or more parameter missing')
+        if r.status_code != 200:
+            logger.error(u'Request %s returned status code %d' % (r.url, r.status_code))
+            return []
+        soup = BeautifulSoup.BeautifulSoup(r.content)
+        subtitles = []
+        for sub in soup('td', {'class': 'NewsTitle'}):
+            sub_keywords = split_keyword(self.release_pattern.search(sub.contents[1]).group(1).lower())
+            if not keywords & sub_keywords:
+                logger.debug(u'None of subtitle keywords %r in %r' % (sub_keywords, keywords))
+                continue
+            for html_language in sub.parent.parent.findAll('td', {'class': 'language'}):
+                language = self.get_revert_language(html_language.string.strip())
+                if not language in languages:
+                    logger.debug(u'Language %r not in wanted languages %r' % (language, languages))
+                    continue
+                html_status = html_language.findNextSibling('td')
+                status = html_status.find('strong').string.strip()
+                if status != 'Completed':
+                    logger.debug(u'Wrong subtitle status %s' % status)
+                    continue
+                path = get_subtitle_path(filepath, language, self.config.multi)
+                subtitle = ResultSubtitle(path, language, service=self.__class__.__name__.lower(), link='%s%s' % (self.server_url, html_status.findNext('td').find('a')['href']))
+                subtitles.append(subtitle)
+        return subtitles
+
+Service = SubsWiki

libs/subliminal/services/subtitulos.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
+#
+# This file is part of subliminal.
+#
+# subliminal is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# subliminal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with subliminal.  If not, see <http://www.gnu.org/licenses/>.
+from . import ServiceBase
+from ..subtitles import get_subtitle_path, ResultSubtitle
+from ..videos import Episode
+from subliminal.utils import get_keywords, split_keyword
+import BeautifulSoup
+import logging
+import re
+import unicodedata
+import urllib
+
+
+logger = logging.getLogger(__name__)
+
+
+class Subtitulos(ServiceBase):
+    server_url = 'http://www.subtitulos.es'
+    api_based = False
+    languages = {u'English (US)': 'en', u'English (UK)': 'en', u'English': 'en', u'French': 'fr', u'Brazilian': 'po',
+                 u'Portuguese': 'pt', u'Español (Latinoamérica)': 'es', u'Español (España)': 'es', u'Español': 'es',
+                 u'Italian': 'it', u'Català': 'ca'}
+    reverted_languages = True
+    videos = [Episode]
+    require_video = False
+    release_pattern = re.compile('Versi&oacute;n (.+) ([0-9]+).([0-9])+ megabytes')
+
+    def list(self, video, languages):
+        if not self.check_validity(video, languages):
+            return []
+        results = self.query(video.path or video.release, languages, get_keywords(video.guess), video.series, video.season, video.episode)
+        return results
+
+    def query(self, filepath, languages, keywords, series, season, episode):
+        request_series = series.lower().replace(' ', '_')
+        if isinstance(request_series, unicode):
+            request_series = unicodedata.normalize('NFKD', request_series).encode('ascii', 'ignore')
+        logger.debug(u'Getting subtitles for %s season %d episode %d with languages %r' % (series, season, episode, languages))
+        r = self.session.get('%s/%s/%sx%.2d' % (self.server_url, urllib.quote(request_series), season, episode))
+        if r.status_code == 404:
+            logger.debug(u'Could not find subtitles for %s season %d episode %d with languages %r' % (series, season, episode, languages))
+            return []
+        if r.status_code != 200:
+            logger.error(u'Request %s returned status code %d' % (r.url, r.status_code))
+            return []
+        soup = BeautifulSoup.BeautifulSoup(r.content)
+        subtitles = []
+        for sub in soup('div', {'id': 'version'}):
+            sub_keywords = split_keyword(self.release_pattern.search(sub.find('p', {'class': 'title-sub'}).contents[1]).group(1).lower())
+            if not keywords & sub_keywords:
+                logger.debug(u'None of subtitle keywords %r in %r' % (sub_keywords, keywords))
+                continue
+            for html_language in sub.findAllNext('ul', {'class': 'sslist'}):
+                language = self.get_revert_language(html_language.findNext('li', {'class': 'li-idioma'}).find('strong').contents[0].string.strip())
+                if not language in languages:
+                    logger.debug(u'Language %r not in wanted languages %r' % (language, languages))
+                    continue
+                html_status = html_language.findNext('li', {'class': 'li-estado green'})
+                status = html_status.contents[0].string.strip()
+                if status != 'Completado':
+                    logger.debug(u'Wrong subtitle status %s' % status)
+                    continue
+                path = get_subtitle_path(filepath, language, self.config.multi)
+                subtitle = ResultSubtitle(path, language, service=self.__class__.__name__.lower(), link=html_status.findNext('span', {'class': 'descargar green'}).find('a')['href'], keywords=sub_keywords)
+                subtitles.append(subtitle)
+        return subtitles
+
+Service = Subtitulos

libs/subliminal/services/thesubdb.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
+#
+# This file is part of subliminal.
+#
+# subliminal is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# subliminal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with subliminal.  If not, see <http://www.gnu.org/licenses/>.
+from . import ServiceBase
+from ..subtitles import get_subtitle_path, ResultSubtitle
+from ..videos import Episode, Movie, UnknownVideo
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class TheSubDB(ServiceBase):
+    server_url = 'http://api.thesubdb.com/'  # for testing purpose, use http://sandbox.thesubdb.com/ instead
+    user_agent = 'SubDB/1.0 (subliminal/0.5; https://github.com/Diaoul/subliminal)'  # defined by the API
+    api_based = True
+    languages = {'af': 'af', 'cs': 'cs', 'da': 'da', 'de': 'de', 'en': 'en', 'es': 'es', 'fi': 'fi',
+                 'fr': 'fr', 'hu': 'hu', 'id': 'id', 'it': 'it', 'la': 'la', 'nl': 'nl', 'no': 'no',
+                 'oc': 'oc', 'pl': 'pl', 'pt': 'pt', 'ro': 'ro', 'ru': 'ru', 'sl': 'sl', 'sr': 'sr',
+                 'sv': 'sv', 'tr': 'tr'}  # list available with the API at http://sandbox.thesubdb.com/?action=languages
+    reverted_languages = False
+    videos = [Movie, Episode, UnknownVideo]
+    require_video = True
+
+    def list(self, video, languages):
+        if not self.check_validity(video, languages):
+            return []
+        results = self.query(video.path, video.hashes['TheSubDB'], languages)
+        return results
+
+    def query(self, filepath, moviehash, languages):
+        r = self.session.get(self.server_url, params={'action': 'search', 'hash': moviehash})
+        if r.status_code == 404:
+            logger.debug(u'Could not find subtitles for hash %s' % moviehash)
+            return []
+        if r.status_code != 200:
+            logger.error(u'Request %s returned status code %d' % (r.url, r.status_code))
+            return []
+        available_languages = set([self.get_revert_language(l) for l in r.content.split(',')])
+        languages &= available_languages
+        if not languages:
+            logger.debug(u'Could not find subtitles for hash %s with languages %r (only %r available)' % (moviehash, languages, available_languages))
+            return []
+        subtitles = []
+        for language in languages:
+            path = get_subtitle_path(filepath, language, self.config.multi)
+            subtitle = ResultSubtitle(path, language, service=self.__class__.__name__.lower(), link='%s?action=download&hash=%s&language=%s' % (self.server_url, moviehash, self.get_language(language)))
+            subtitles.append(subtitle)
+        return subtitles
+
+Service = TheSubDB