Subliminal update
This commit is contained in:
Ruud
+24
-13
@@ -1,23 +1,34 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
|
||||
#
|
||||
# Subliminal - Subtitles, faster than your thoughts
|
||||
# Copyright (c) 2011 Antoine Bertin <diaoulael@gmail.com>
|
||||
# This file is part of subliminal.
|
||||
#
|
||||
# This file is part of Subliminal.
|
||||
#
|
||||
# Subliminal is free software; you can redistribute it and/or modify it under
|
||||
# the terms of the Lesser GNU General Public License as published by
|
||||
# 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,
|
||||
# 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
|
||||
# Lesser GNU General Public License for more details.
|
||||
# GNU Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the Lesser GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
__all__ = ['Subliminal']
|
||||
# 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 .api import list_subtitles, download_subtitles
|
||||
from .async import Pool
|
||||
from .core import (SERVICES, LANGUAGE_INDEX, SERVICE_INDEX, SERVICE_CONFIDENCE,
|
||||
MATCHING_CONFIDENCE)
|
||||
from .infos import __version__
|
||||
import logging
|
||||
try:
|
||||
from logging import NullHandler
|
||||
except ImportError:
|
||||
class NullHandler(logging.Handler):
|
||||
def emit(self, record):
|
||||
pass
|
||||
|
||||
from core import Subliminal
|
||||
|
||||
__all__ = ['SERVICES', 'LANGUAGE_INDEX', 'SERVICE_INDEX', 'SERVICE_CONFIDENCE',
|
||||
'MATCHING_CONFIDENCE', 'list_subtitles', 'download_subtitles', 'Pool']
|
||||
logging.getLogger(__name__).addHandler(NullHandler())
|
||||
|
||||
Executable
+100
@@ -0,0 +1,100 @@
|
||||
# -*- 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 .core import (SERVICES, LANGUAGE_INDEX, SERVICE_INDEX, SERVICE_CONFIDENCE,
|
||||
MATCHING_CONFIDENCE, create_list_tasks, consume_task, create_download_tasks,
|
||||
group_by_video, key_subtitles)
|
||||
from .languages import list_languages
|
||||
import logging
|
||||
|
||||
|
||||
__all__ = ['list_subtitles', 'download_subtitles']
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def list_subtitles(paths, languages=None, services=None, force=True, multi=False, cache_dir=None, max_depth=3):
|
||||
"""List subtitles in given paths according to the criteria
|
||||
|
||||
:param paths: path(s) to video file or folder
|
||||
:type paths: string or list
|
||||
:param list languages: languages to search for, in preferred order
|
||||
:param list services: services to use for the search, in preferred order
|
||||
:param bool force: force searching for subtitles even if some are detected
|
||||
:param bool multi: search multiple languages for the same video
|
||||
:param string cache_dir: path to the cache directory to use
|
||||
:param int max_depth: maximum depth for scanning entries
|
||||
:return: found subtitles
|
||||
:rtype: dict of :class:`~subliminal.videos.Video` => [:class:`~subliminal.subtitles.ResultSubtitle`]
|
||||
|
||||
"""
|
||||
services = services or SERVICES
|
||||
languages = set(languages or list_languages(1))
|
||||
if isinstance(paths, basestring):
|
||||
paths = [paths]
|
||||
if any([not isinstance(p, unicode) for p in paths]):
|
||||
logger.warning(u'Not all entries are unicode')
|
||||
results = []
|
||||
service_instances = {}
|
||||
tasks = create_list_tasks(paths, languages, services, force, multi, cache_dir, max_depth)
|
||||
for task in tasks:
|
||||
try:
|
||||
result = consume_task(task, service_instances)
|
||||
results.append((task.video, result))
|
||||
except:
|
||||
logger.error(u'Error consuming task %r' % task, exc_info=True)
|
||||
for service_instance in service_instances.itervalues():
|
||||
service_instance.terminate()
|
||||
return group_by_video(results)
|
||||
|
||||
|
||||
def download_subtitles(paths, languages=None, services=None, force=True, multi=False, cache_dir=None, max_depth=3, order=None):
|
||||
"""Download subtitles in given paths according to the criteria
|
||||
|
||||
:param paths: path(s) to video file or folder
|
||||
:type paths: string or list
|
||||
:param list languages: languages to search for, in preferred order
|
||||
:param list services: services to use for the search, in preferred order
|
||||
:param bool force: force searching for subtitles even if some are detected
|
||||
:param bool multi: search multiple languages for the same video
|
||||
:param string cache_dir: path to the cache directory to use
|
||||
:param int max_depth: maximum depth for scanning entries
|
||||
:param order: preferred order for subtitles sorting
|
||||
:type list: list of :data:`~subliminal.core.LANGUAGE_INDEX`, :data:`~subliminal.core.SERVICE_INDEX`, :data:`~subliminal.core.SERVICE_CONFIDENCE`, :data:`~subliminal.core.MATCHING_CONFIDENCE`
|
||||
:return: found subtitles
|
||||
:rtype: list of (:class:`~subliminal.videos.Video`, [:class:`~subliminal.subtitles.ResultSubtitle`])
|
||||
|
||||
"""
|
||||
services = services or SERVICES
|
||||
languages = languages or list_languages(1)
|
||||
if isinstance(paths, basestring):
|
||||
paths = [paths]
|
||||
order = order or [LANGUAGE_INDEX, SERVICE_INDEX, SERVICE_CONFIDENCE, MATCHING_CONFIDENCE]
|
||||
subtitles_by_video = list_subtitles(paths, set(languages), services, force, multi, cache_dir, max_depth)
|
||||
for video, subtitles in subtitles_by_video.iteritems():
|
||||
subtitles.sort(key=lambda s: key_subtitles(s, video, languages, services, order), reverse=True)
|
||||
results = []
|
||||
service_instances = {}
|
||||
tasks = create_download_tasks(subtitles_by_video, multi)
|
||||
for task in tasks:
|
||||
try:
|
||||
result = consume_task(task, service_instances)
|
||||
results.append(result)
|
||||
except:
|
||||
logger.error(u'Error consuming task %r' % task, exc_info=True)
|
||||
for service_instance in service_instances.itervalues():
|
||||
service_instance.terminate()
|
||||
return results
|
||||
Executable
+141
@@ -0,0 +1,141 @@
|
||||
# -*- 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 .core import (consume_task, LANGUAGE_INDEX, SERVICE_INDEX,
|
||||
SERVICE_CONFIDENCE, MATCHING_CONFIDENCE, SERVICES, create_list_tasks,
|
||||
create_download_tasks, group_by_video, key_subtitles)
|
||||
from .languages import list_languages
|
||||
from .tasks import StopTask
|
||||
import Queue
|
||||
import logging
|
||||
import threading
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class Worker(threading.Thread):
|
||||
"""Consume tasks and put the result in the queue"""
|
||||
def __init__(self, tasks, results):
|
||||
super(Worker, self).__init__()
|
||||
self.tasks = tasks
|
||||
self.results = results
|
||||
self.services = {}
|
||||
|
||||
def run(self):
|
||||
while 1:
|
||||
result = []
|
||||
try:
|
||||
task = self.tasks.get(block=True)
|
||||
if isinstance(task, StopTask):
|
||||
break
|
||||
result = consume_task(task, self.services)
|
||||
self.results.put((task.video, result))
|
||||
except:
|
||||
logger.error(u'Exception raised in worker %s' % self.name, exc_info=True)
|
||||
finally:
|
||||
self.tasks.task_done()
|
||||
self.terminate()
|
||||
logger.debug(u'Thread %s terminated' % self.name)
|
||||
|
||||
def terminate(self):
|
||||
"""Terminate instantiated services"""
|
||||
for service_name, service in self.services.iteritems():
|
||||
try:
|
||||
service.terminate()
|
||||
except:
|
||||
logger.error(u'Exception raised when terminating service %s' % service_name, exc_info=True)
|
||||
|
||||
|
||||
class Pool(object):
|
||||
"""Pool of workers"""
|
||||
def __init__(self, size):
|
||||
self.tasks = Queue.Queue()
|
||||
self.results = Queue.Queue()
|
||||
self.workers = []
|
||||
for _ in range(size):
|
||||
self.workers.append(Worker(self.tasks, self.results))
|
||||
|
||||
def __enter__(self):
|
||||
self.start()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.stop()
|
||||
self.join()
|
||||
|
||||
def start(self):
|
||||
"""Start workers"""
|
||||
for worker in self.workers:
|
||||
worker.start()
|
||||
|
||||
def stop(self):
|
||||
"""Stop workers"""
|
||||
for _ in self.workers:
|
||||
self.tasks.put(StopTask())
|
||||
|
||||
def join(self):
|
||||
"""Join the task queue"""
|
||||
self.tasks.join()
|
||||
|
||||
def collect(self):
|
||||
"""Collect available results
|
||||
|
||||
:return: results of tasks
|
||||
:rtype: list of :class:`~subliminal.tasks.Task`
|
||||
|
||||
"""
|
||||
results = []
|
||||
while 1:
|
||||
try:
|
||||
result = self.results.get(block=False)
|
||||
results.append(result)
|
||||
except Queue.Empty:
|
||||
break
|
||||
return results
|
||||
|
||||
def list_subtitles(self, paths, languages=None, services=None, force=True, multi=False, cache_dir=None, max_depth=3):
|
||||
"""See :meth:`subliminal.list_subtitles`"""
|
||||
services = services or SERVICES
|
||||
languages = set(languages or list_languages(1))
|
||||
if isinstance(paths, basestring):
|
||||
paths = [paths]
|
||||
if any([not isinstance(p, unicode) for p in paths]):
|
||||
logger.warning(u'Not all entries are unicode')
|
||||
tasks = create_list_tasks(paths, languages, services, force, multi, cache_dir, max_depth)
|
||||
for task in tasks:
|
||||
self.tasks.put(task)
|
||||
self.join()
|
||||
results = self.collect()
|
||||
return group_by_video(results)
|
||||
|
||||
def download_subtitles(self, paths, languages=None, services=None, cache_dir=None, max_depth=3, force=True, multi=False, order=None):
|
||||
"""See :meth:`subliminal.download_subtitles`"""
|
||||
services = services or SERVICES
|
||||
languages = languages or list_languages(1)
|
||||
if isinstance(paths, basestring):
|
||||
paths = [paths]
|
||||
order = order or [LANGUAGE_INDEX, SERVICE_INDEX, SERVICE_CONFIDENCE, MATCHING_CONFIDENCE]
|
||||
subtitles_by_video = self.list_subtitles(paths, set(languages), services, force, multi, cache_dir, max_depth)
|
||||
for video, subtitles in subtitles_by_video.iteritems():
|
||||
subtitles.sort(key=lambda s: key_subtitles(s, video, languages, services, order), reverse=True)
|
||||
tasks = create_download_tasks(subtitles_by_video, multi)
|
||||
for task in tasks:
|
||||
self.tasks.put(task)
|
||||
self.join()
|
||||
results = self.collect()
|
||||
return results
|
||||
+187
-313
@@ -1,346 +1,173 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
|
||||
#
|
||||
# Subliminal - Subtitles, faster than your thoughts
|
||||
# Copyright (c) 2011 Antoine Bertin <diaoulael@gmail.com>
|
||||
# This file is part of subliminal.
|
||||
#
|
||||
# This file is part of Subliminal.
|
||||
#
|
||||
# Subliminal is free software; you can redistribute it and/or modify it under
|
||||
# the terms of the Lesser GNU General Public License as published by
|
||||
# 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,
|
||||
# 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
|
||||
# Lesser GNU General Public License for more details.
|
||||
# GNU Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the Lesser GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
__all__ = ['PLUGINS', 'API_PLUGINS', 'IDLE', 'RUNNING', 'PAUSED', 'Subliminal', 'PluginWorker', 'matching_confidence',
|
||||
'LANGUAGE_INDEX', 'PLUGIN_INDEX', 'PLUGIN_CONFIDENCE', 'MATCHING_CONFIDENCE']
|
||||
|
||||
|
||||
# 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 DownloadFailedError
|
||||
from .services import ServiceConfig
|
||||
from .tasks import DownloadTask, ListTask
|
||||
from .utils import get_keywords
|
||||
from .videos import Episode, Movie, scan
|
||||
from collections import defaultdict
|
||||
from exceptions import InvalidLanguageError, PluginError, BadStateError, \
|
||||
WrongTaskError, DownloadFailedError
|
||||
from itertools import groupby
|
||||
from languages import list_languages
|
||||
from utils import NullHandler
|
||||
from tasks import Task, DownloadTask, ListTask, StopTask
|
||||
import Queue
|
||||
import guessit
|
||||
import logging
|
||||
import os
|
||||
import plugins
|
||||
import subtitles
|
||||
import threading
|
||||
import utils
|
||||
import videos
|
||||
|
||||
# init logger
|
||||
logger = logging.getLogger('subliminal')
|
||||
logger.addHandler(NullHandler())
|
||||
|
||||
# const
|
||||
PLUGINS = ['OpenSubtitles', 'BierDopje', 'TheSubDB', 'SubsWiki', 'Subtitulos']
|
||||
API_PLUGINS = filter(lambda p: getattr(plugins, p).api_based, PLUGINS)
|
||||
IDLE, RUNNING, PAUSED = range(3)
|
||||
LANGUAGE_INDEX, PLUGIN_INDEX, PLUGIN_CONFIDENCE, MATCHING_CONFIDENCE = range(4)
|
||||
|
||||
|
||||
class Subliminal(object):
|
||||
"""Main Subliminal class"""
|
||||
__all__ = ['SERVICES', 'LANGUAGE_INDEX', 'SERVICE_INDEX', 'SERVICE_CONFIDENCE', 'MATCHING_CONFIDENCE',
|
||||
'create_list_tasks', 'create_download_tasks', 'consume_task', 'matching_confidence',
|
||||
'key_subtitles', 'group_by_video']
|
||||
logger = logging.getLogger(__name__)
|
||||
SERVICES = ['opensubtitles', 'bierdopje', 'subswiki', 'subtitulos', 'thesubdb']
|
||||
LANGUAGE_INDEX, SERVICE_INDEX, SERVICE_CONFIDENCE, MATCHING_CONFIDENCE = range(4)
|
||||
|
||||
def __init__(self, cache_dir=None, workers=None, multi=False, force=False,
|
||||
max_depth=None, filemode=None, sort_order=None, plugins=None, languages=None):
|
||||
self.multi = multi
|
||||
self.sort_order = sort_order or [LANGUAGE_INDEX, PLUGIN_INDEX, PLUGIN_CONFIDENCE, MATCHING_CONFIDENCE]
|
||||
self.force = force
|
||||
self.max_depth = max_depth or 3
|
||||
self.taskQueue = Queue.PriorityQueue()
|
||||
self.listResultQueue = Queue.Queue()
|
||||
self.downloadResultQueue = Queue.Queue()
|
||||
self.languages = languages or []
|
||||
self.plugins = plugins or API_PLUGINS
|
||||
self._workers = workers or 4
|
||||
self.filemode = filemode
|
||||
self.state = IDLE
|
||||
self.cache_dir = cache_dir
|
||||
try:
|
||||
if cache_dir and not os.path.isdir(cache_dir):
|
||||
os.makedirs(cache_dir)
|
||||
logger.debug(u'Creating cache directory: %r' % cache_dir)
|
||||
except:
|
||||
self.cache_dir = None
|
||||
logger.error(u'Failed to use the cache directory, continue without it')
|
||||
|
||||
def __enter__(self):
|
||||
self.startWorkers()
|
||||
return self
|
||||
def create_list_tasks(paths, languages, services, force, multi, cache_dir, max_depth):
|
||||
"""Create a list of :class:`~subliminal.tasks.ListTask` from one or more paths using the given criteria
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.stopWorkers(0)
|
||||
:param paths: path(s) to video file or folder
|
||||
:type paths: string or list
|
||||
:param set languages: languages to search for
|
||||
:param list services: services to use for the search
|
||||
:param bool force: force searching for subtitles even if some are detected
|
||||
:param bool multi: search multiple languages for the same video
|
||||
:param string cache_dir: path to the cache directory to use
|
||||
:param int max_depth: maximum depth for scanning entries
|
||||
:return: the created tasks
|
||||
:rtype: list of :class:`~subliminal.tasks.ListTask`
|
||||
|
||||
@property
|
||||
def workers(self):
|
||||
return self._workers
|
||||
|
||||
@workers.setter
|
||||
def workers(self, value):
|
||||
if self.state == RUNNING:
|
||||
raise BadStateError(self.state, IDLE)
|
||||
self._workers = value
|
||||
|
||||
@property
|
||||
def languages(self):
|
||||
"""Getter for languages"""
|
||||
return self._languages
|
||||
|
||||
@languages.setter
|
||||
def languages(self, languages):
|
||||
"""Setter for languages"""
|
||||
logger.debug(u'Setting languages to %r' % languages)
|
||||
self._languages = []
|
||||
for l in languages:
|
||||
if l not in list_languages(1):
|
||||
raise InvalidLanguageError(l)
|
||||
if not l in self._languages:
|
||||
self._languages.append(l)
|
||||
|
||||
@property
|
||||
def plugins(self):
|
||||
"""Getter for plugins"""
|
||||
return self._plugins
|
||||
|
||||
@plugins.setter
|
||||
def plugins(self, plugins):
|
||||
"""Setter for plugins"""
|
||||
logger.debug(u'Setting plugins to %r' % plugins)
|
||||
self._plugins = []
|
||||
for p in plugins:
|
||||
if p not in PLUGINS:
|
||||
raise PluginError(p)
|
||||
if not p in self._plugins:
|
||||
self._plugins.append(p)
|
||||
|
||||
def listSubtitles(self, entries, auto=False):
|
||||
"""
|
||||
Search subtitles within the plugins and return all found subtitles in a list of Subtitle object.
|
||||
|
||||
Attributes:
|
||||
entries -- filepath or folderpath of video file or a list of that
|
||||
auto -- automaticaly manage workers (default to False)"""
|
||||
if auto:
|
||||
if self.state != IDLE:
|
||||
raise BadStateError(self.state, IDLE)
|
||||
self.startWorkers()
|
||||
if isinstance(entries, basestring):
|
||||
entries = [entries]
|
||||
config = utils.PluginConfig(self.multi, self.cache_dir, self.filemode)
|
||||
scan_result = []
|
||||
for e in entries:
|
||||
if not isinstance(e, unicode):
|
||||
logger.warning(u'Entry %r is not unicode' % e)
|
||||
scan_result.extend(videos.scan(e))
|
||||
task_count = 0
|
||||
for video, subtitles in scan_result:
|
||||
languages = set([s.language for s in subtitles if s.language])
|
||||
wanted_languages = set(self._languages)
|
||||
"""
|
||||
scan_result = []
|
||||
for p in paths:
|
||||
scan_result.extend(scan(p, max_depth))
|
||||
logger.debug(u'Found %d videos in %r with maximum depth %d' % (len(scan_result), paths, max_depth))
|
||||
tasks = []
|
||||
config = ServiceConfig(multi, cache_dir)
|
||||
for video, detected_subtitles in scan_result:
|
||||
detected_languages = set([s.language for s in detected_subtitles])
|
||||
wanted_languages = languages.copy()
|
||||
if not force and multi:
|
||||
wanted_languages -= detected_languages
|
||||
if not wanted_languages:
|
||||
wanted_languages = list_languages(1)
|
||||
if not self.force and self.multi:
|
||||
wanted_languages = set(wanted_languages) - languages
|
||||
if not wanted_languages:
|
||||
logger.debug(u'No need to list multi subtitles %r for %r because %r subtitles detected' % (self._languages, video.path, languages))
|
||||
continue
|
||||
if not self.force and not self.multi and None in [s.language for s in subtitles]:
|
||||
logger.debug(u'No need to list single subtitles %r for %r because one detected' % (self._languages, video.path))
|
||||
logger.debug(u'No need to list multi subtitles %r for %r because %r detected' % (languages, video, detected_languages))
|
||||
continue
|
||||
logger.debug(u'Listing subtitles %r for %r with %r' % (wanted_languages, video.path, self._plugins))
|
||||
for plugin_name in self._plugins:
|
||||
plugin = getattr(plugins, plugin_name)
|
||||
to_list_languages = wanted_languages & plugin.availableLanguages()
|
||||
if not to_list_languages:
|
||||
logger.debug(u'Skipping %r: none of wanted languages %r available in %r for plugin %s' % (video.path, wanted_languages, plugin.availableLanguages(), plugin_name))
|
||||
continue
|
||||
if not plugin.isValidVideo(video):
|
||||
logger.debug(u'Skipping %r: video %r is not part of supported videos %r for plugin %s' % (video.path, video, plugin.videos, plugin_name))
|
||||
continue
|
||||
self.taskQueue.put((5, ListTask(video, to_list_languages, plugin_name, config)))
|
||||
task_count += 1
|
||||
subtitles = []
|
||||
for _ in range(task_count):
|
||||
subtitles.extend(self.listResultQueue.get())
|
||||
if auto:
|
||||
self.stopWorkers()
|
||||
return subtitles
|
||||
|
||||
def downloadSubtitles(self, entries, auto=False):
|
||||
"""
|
||||
Download subtitles using the plugins preferences and languages. Also use internal algorithm to find
|
||||
the best match inside a plugin.
|
||||
|
||||
Attributes:
|
||||
entries -- filepath or folderpath of video file or a list of that
|
||||
auto -- automaticaly manage workers (default to False)"""
|
||||
if auto:
|
||||
if self.state != IDLE:
|
||||
raise BadStateError(self.state, IDLE)
|
||||
self.startWorkers()
|
||||
by_video = self.groupByVideo(self.listSubtitles(entries, False))
|
||||
# Define an order with LANGUAGE_INDEX first for multi sorting
|
||||
order = self.sort_order
|
||||
if self.multi:
|
||||
order.insert(0, LANGUAGE_INDEX)
|
||||
task_count = 0
|
||||
for video, subtitles in by_video.iteritems():
|
||||
ordered_subtitles = sorted(subtitles, key=lambda s: self.keySubtitles(s, video, order), reverse=True)
|
||||
if not self.multi:
|
||||
self.taskQueue.put((5, DownloadTask(video, list(ordered_subtitles))))
|
||||
task_count += 1
|
||||
if not force and not multi and None in detected_languages:
|
||||
logger.debug(u'No need to list single subtitles %r for %r because one detected' % (languages, video))
|
||||
continue
|
||||
logger.debug(u'Listing subtitles %r for %r with services %r' % (wanted_languages, video, services))
|
||||
for service_name in services:
|
||||
mod = __import__('services.' + service_name, globals=globals(), locals=locals(), fromlist=['Service'], level=-1)
|
||||
service = mod.Service
|
||||
service_languages = wanted_languages & service.available_languages()
|
||||
if not service_languages:
|
||||
logger.debug(u'Skipping %r: none of wanted languages %r available for service %s' % (video, wanted_languages, service_name))
|
||||
continue
|
||||
for _, by_language in groupby(ordered_subtitles, lambda s: s.language):
|
||||
self.taskQueue.put((5, DownloadTask(video, list(by_language))))
|
||||
task_count += 1
|
||||
downloaded = []
|
||||
for _ in range(task_count):
|
||||
downloaded.extend(self.downloadResultQueue.get())
|
||||
if auto:
|
||||
self.stopWorkers()
|
||||
return downloaded
|
||||
|
||||
def keySubtitles(self, subtitle, video, order):
|
||||
"""Create a key to sort subtitle using preferences"""
|
||||
key = ''
|
||||
for sort_item in order:
|
||||
if sort_item == LANGUAGE_INDEX:
|
||||
key += '{0:03d}'.format(len(self._languages) - self._languages.index(subtitle.language) - 1)
|
||||
elif sort_item == PLUGIN_INDEX:
|
||||
key += '{0:02d}'.format(len(self._plugins) - self._plugins.index(subtitle.plugin) - 1)
|
||||
elif sort_item == PLUGIN_CONFIDENCE:
|
||||
key += '{0:04d}'.format(int(subtitle.confidence * 1000))
|
||||
elif sort_item == MATCHING_CONFIDENCE:
|
||||
confidence = 0
|
||||
if subtitle.release:
|
||||
confidence = matching_confidence(video, subtitle)
|
||||
key += '{0:04d}'.format(int(confidence * 1000))
|
||||
return int(key)
|
||||
|
||||
def groupByVideo(self, list_result):
|
||||
'''Because list outputs a list of tuples from different plugins, we need to put them back
|
||||
together under a single video key'''
|
||||
result = defaultdict(list)
|
||||
for video, subtitles in list_result:
|
||||
result[video] += subtitles
|
||||
return result
|
||||
|
||||
def startWorkers(self):
|
||||
"""Create a pool of workers and start them"""
|
||||
if self.state == RUNNING:
|
||||
raise BadStateError(self.state, IDLE)
|
||||
self.pool = []
|
||||
for _ in range(self._workers):
|
||||
worker = PluginWorker(self.taskQueue, self.listResultQueue, self.downloadResultQueue)
|
||||
worker.start()
|
||||
self.pool.append(worker)
|
||||
logger.debug(u'Worker %s added to the pool' % worker.name)
|
||||
self.state = RUNNING
|
||||
|
||||
def stopWorkers(self, priority=10):
|
||||
"""Stop workers using a lowest priority stop signal and wait for them to terminate properly"""
|
||||
for _ in range(self._workers):
|
||||
self.taskQueue.put((priority, StopTask()))
|
||||
for worker in self.pool:
|
||||
worker.join()
|
||||
self.state = IDLE
|
||||
if not self.taskQueue.empty():
|
||||
self.state = PAUSED
|
||||
|
||||
def pauseWorkers(self):
|
||||
"""Pause workers using a highest priority stop signal and wait for them to terminate properly"""
|
||||
self.stopWorkers(0)
|
||||
|
||||
def addTask(self, task):
|
||||
"""Add a task with default priority"""
|
||||
if not isinstance(task, Task) or isinstance(task, StopTask):
|
||||
raise WrongTaskError()
|
||||
self.taskQueue.put((5, task))
|
||||
if not service.is_valid_video(video):
|
||||
logger.debug(u'Skipping %r: not part of supported videos %r for service %s' % (video, service.videos, service_name))
|
||||
continue
|
||||
task = ListTask(video, service_languages, service_name, config)
|
||||
logger.debug(u'Created task %r' % task)
|
||||
tasks.append(task)
|
||||
return tasks
|
||||
|
||||
|
||||
class PluginWorker(threading.Thread):
|
||||
"""Threaded plugin worker"""
|
||||
def __init__(self, taskQueue, listResultQueue, downloadResultQueue):
|
||||
threading.Thread.__init__(self)
|
||||
self.taskQueue = taskQueue
|
||||
self.listResultQueue = listResultQueue
|
||||
self.downloadResultQueue = downloadResultQueue
|
||||
self.logger = logging.getLogger('subliminal.worker')
|
||||
self.plugins = {}
|
||||
def create_download_tasks(subtitles_by_video, multi):
|
||||
"""Create a list of :class:`~subliminal.tasks.DownloadTask` from a list results grouped by video
|
||||
|
||||
def run(self):
|
||||
while True:
|
||||
task = self.taskQueue.get()[1]
|
||||
if isinstance(task, StopTask):
|
||||
self.logger.debug(u'Poison pill received in thread %s' % self.name)
|
||||
self.taskQueue.task_done()
|
||||
:param subtitles_by_video: :class:`~subliminal.tasks.ListTask` results grouped by video and sorted
|
||||
:type subtitles_by_video: dict of :class:`~subliminal.videos.Video` => [:class:`~subliminal.subtitles.Subtitle`]
|
||||
:param order: preferred order for subtitles sorting
|
||||
:type list: list of :data:`LANGUAGE_INDEX`, :data:`SERVICE_INDEX`, :data:`SERVICE_CONFIDENCE`, :data:`MATCHING_CONFIDENCE`
|
||||
:param bool multi: download multiple languages for the same video
|
||||
:return: the created tasks
|
||||
:rtype: list of :class:`~subliminal.tasks.DownloadTask`
|
||||
|
||||
"""
|
||||
tasks = []
|
||||
for video, subtitles in subtitles_by_video.iteritems():
|
||||
if not subtitles:
|
||||
continue
|
||||
if not multi:
|
||||
task = DownloadTask(video, list(subtitles))
|
||||
logger.debug(u'Created task %r' % task)
|
||||
tasks.append(task)
|
||||
continue
|
||||
for _, by_language in groupby(subtitles, lambda s: s.language):
|
||||
task = DownloadTask(video, list(by_language))
|
||||
logger.debug(u'Created task %r' % task)
|
||||
tasks.append(task)
|
||||
return tasks
|
||||
|
||||
|
||||
def consume_task(task, services=None):
|
||||
"""Consume a task. If the ``services`` parameter is given, the function will attempt
|
||||
to get the service from it. In case the service is not in ``services``, it will be initialized
|
||||
and put in ``services``
|
||||
|
||||
:param task: task to consume
|
||||
:type task: :class:`~subliminal.tasks.ListTask` or :class:`~subliminal.tasks.DownloadTask`
|
||||
:param dict services: mapping between the service name and an instance of this service
|
||||
:return: the result of the task
|
||||
:rtype: list of :class:`~subliminal.subtitles.ResultSubtitle` or :class:`~subliminal.subtitles.Subtitle`
|
||||
|
||||
"""
|
||||
if services is None:
|
||||
services = {}
|
||||
logger.info(u'Consuming %r' % task)
|
||||
result = None
|
||||
if isinstance(task, ListTask):
|
||||
if task.service not in services:
|
||||
mod = __import__('services.' + task.service, globals=globals(), locals=locals(), fromlist=['Service'], level=-1)
|
||||
services[task.service] = mod.Service(task.config)
|
||||
services[task.service].init()
|
||||
subtitles = services[task.service].list(task.video, task.languages)
|
||||
result = subtitles
|
||||
elif isinstance(task, DownloadTask):
|
||||
for subtitle in task.subtitles:
|
||||
if subtitle.service not in services:
|
||||
mod = __import__('services.' + subtitle.service, globals=globals(), locals=locals(), fromlist=['Service'], level=-1)
|
||||
services[subtitle.service] = mod.Service()
|
||||
services[subtitle.service].init()
|
||||
try:
|
||||
services[subtitle.service].download(subtitle)
|
||||
result = subtitle
|
||||
break
|
||||
result = []
|
||||
try:
|
||||
if isinstance(task, ListTask):
|
||||
if task.plugin not in self.plugins: # init the plugin
|
||||
self.plugins[task.plugin] = getattr(plugins, task.plugin)()
|
||||
self.plugins[task.plugin].init()
|
||||
# Retrieve the plugin list subtitles and return [(video, [subtitle])]
|
||||
plugin = self.plugins[task.plugin]
|
||||
plugin.config = task.config
|
||||
subtitles = plugin.list(task.video, task.languages)
|
||||
result = [(task.video, subtitles)]
|
||||
elif isinstance(task, DownloadTask):
|
||||
# Attempt to download one subtitle from the given list
|
||||
for subtitle in task.subtitles:
|
||||
if subtitle.plugin not in self.plugins: # init the plugin
|
||||
self.plugins[subtitle.plugin] = getattr(plugins, subtitle.plugin)()
|
||||
self.plugins[subtitle.plugin].init()
|
||||
plugin = self.plugins[subtitle.plugin]
|
||||
try:
|
||||
result = [plugin.download(subtitle)]
|
||||
break
|
||||
except DownloadFailedError: # try the next one
|
||||
self.logger.warning(u'Could not download subtitle %r, trying next' % subtitle)
|
||||
continue
|
||||
if not result:
|
||||
self.logger.error(u'No subtitles could be downloaded for video %r' % task.video.path or task.video.release)
|
||||
except:
|
||||
self.logger.error(u'Exception raised in worker %s' % self.name, exc_info=True)
|
||||
finally:
|
||||
# Put the result in the correct queue
|
||||
if isinstance(task, ListTask):
|
||||
self.listResultQueue.put(result)
|
||||
elif isinstance(task, DownloadTask):
|
||||
self.downloadResultQueue.put(result)
|
||||
self.taskQueue.task_done()
|
||||
self.terminate()
|
||||
self.logger.debug(u'Thread %s terminated' % self.name)
|
||||
|
||||
def terminate(self):
|
||||
"""Terminate instanciated plugins"""
|
||||
for plugin_name, plugin in self.plugins.iteritems():
|
||||
try:
|
||||
plugin.terminate()
|
||||
except:
|
||||
self.logger.error(u'Exception raised when terminating plugin %s' % plugin_name, exc_info=True)
|
||||
except DownloadFailedError:
|
||||
logger.warning(u'Could not download subtitle %r, trying next' % subtitle)
|
||||
continue
|
||||
if result is None:
|
||||
logger.error(u'No subtitles could be downloaded for video %r' % task.video)
|
||||
return result
|
||||
|
||||
|
||||
def matching_confidence(video, subtitle):
|
||||
'''Compute the confidence that the subtitle matches the video.
|
||||
Returns a float between 0 and 1. 1 being the perfect match.'''
|
||||
"""Compute the probability (confidence) that the subtitle matches the video
|
||||
|
||||
:param video: video to match
|
||||
:type video: :class:`~subliminal.videos.Video`
|
||||
:param subtitle: subtitle to match
|
||||
:type subtitle: :class:`~subliminal.subtitles.Subtitle`
|
||||
:return: the matching probability
|
||||
:rtype: float
|
||||
|
||||
"""
|
||||
guess = guessit.guess_file_info(subtitle.release, 'autodetect')
|
||||
video_keywords = utils.get_keywords(video.guess)
|
||||
subtitle_keywords = utils.get_keywords(guess) | subtitle.keywords
|
||||
video_keywords = get_keywords(video.guess)
|
||||
subtitle_keywords = get_keywords(guess) | subtitle.keywords
|
||||
replacement = {'keywords': len(video_keywords & subtitle_keywords)}
|
||||
if isinstance(video, videos.Episode):
|
||||
if isinstance(video, Episode):
|
||||
replacement.update({'series': 0, 'season': 0, 'episode': 0})
|
||||
matching_format = '{series:b}{season:b}{episode:b}{keywords:03b}'
|
||||
best = matching_format.format(series=1, season=1, episode=1, keywords=len(video_keywords))
|
||||
@@ -351,7 +178,7 @@ def matching_confidence(video, subtitle):
|
||||
replacement['season'] = 1
|
||||
if 'episodeNumber' in guess and guess['episodeNumber'] == video.episode:
|
||||
replacement['episode'] = 1
|
||||
elif isinstance(video, videos.Movie):
|
||||
elif isinstance(video, Movie):
|
||||
replacement.update({'title': 0, 'year': 0})
|
||||
matching_format = '{title:b}{year:b}{keywords:03b}'
|
||||
best = matching_format.format(title=1, year=1, keywords=len(video_keywords))
|
||||
@@ -364,3 +191,50 @@ def matching_confidence(video, subtitle):
|
||||
return 0
|
||||
confidence = float(int(matching_format.format(**replacement), 2)) / float(int(best, 2))
|
||||
return confidence
|
||||
|
||||
|
||||
def key_subtitles(subtitle, video, languages, services, order):
|
||||
"""Create a key to sort subtitle using the given order
|
||||
|
||||
:param subtitle: subtitle to sort
|
||||
:type subtitle: :class:`~subliminal.subtitles.ResultSubtitle`
|
||||
:param video: video to match
|
||||
:type video: :class:`~subliminal.videos.Video`
|
||||
:param list languages: languages in preferred order
|
||||
:param list services: services in preferred order
|
||||
:param order: preferred order for subtitles sorting
|
||||
:type list: list of :data:`LANGUAGE_INDEX`, :data:`SERVICE_INDEX`, :data:`SERVICE_CONFIDENCE`, :data:`MATCHING_CONFIDENCE`
|
||||
:return: a key ready to use for subtitles sorting
|
||||
:rtype: int
|
||||
|
||||
"""
|
||||
key = ''
|
||||
for sort_item in order:
|
||||
if sort_item == LANGUAGE_INDEX:
|
||||
key += '{0:03d}'.format(len(languages) - languages.index(subtitle.language) - 1)
|
||||
elif sort_item == SERVICE_INDEX:
|
||||
key += '{0:02d}'.format(len(services) - services.index(subtitle.service) - 1)
|
||||
elif sort_item == SERVICE_CONFIDENCE:
|
||||
key += '{0:04d}'.format(int(subtitle.confidence * 1000))
|
||||
elif sort_item == MATCHING_CONFIDENCE:
|
||||
confidence = 0
|
||||
if subtitle.release:
|
||||
confidence = matching_confidence(video, subtitle)
|
||||
key += '{0:04d}'.format(int(confidence * 1000))
|
||||
return int(key)
|
||||
|
||||
|
||||
def group_by_video(list_results):
|
||||
"""Group the results of :class:`ListTasks <subliminal.tasks.ListTask>` into a
|
||||
dictionary of :class:`~subliminal.videos.Video` => :class:`~subliminal.subtitles.Subtitle`
|
||||
|
||||
:param list_results:
|
||||
:type list_results: list of result of :class:`~subliminal.tasks.ListTask`
|
||||
:return: subtitles grouped by videos
|
||||
:rtype: dict of :class:`~subliminal.videos.Video` => [:class:`~subliminal.subtitles.Subtitle`]
|
||||
|
||||
"""
|
||||
result = defaultdict(list)
|
||||
for video, subtitles in list_results:
|
||||
result[video] += subtitles
|
||||
return result
|
||||
|
||||
@@ -1,23 +1,20 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
|
||||
#
|
||||
# Subliminal - Subtitles, faster than your thoughts
|
||||
# Copyright (c) 2011 Antoine Bertin <diaoulael@gmail.com>
|
||||
# This file is part of subliminal.
|
||||
#
|
||||
# This file is part of Subliminal.
|
||||
#
|
||||
# Subliminal is free software; you can redistribute it and/or modify it under
|
||||
# the terms of the Lesser GNU General Public License as published by
|
||||
# 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,
|
||||
# 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
|
||||
# Lesser GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the Lesser GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
# 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/>.
|
||||
|
||||
|
||||
class Error(Exception):
|
||||
@@ -25,21 +22,6 @@ class Error(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class BadStateError(Error):
|
||||
"""Exception raised when an invalid action is asked
|
||||
|
||||
Attributes:
|
||||
current -- current state of Subliminal instance
|
||||
expected -- expected state of Subliminal instance
|
||||
"""
|
||||
def __init__(self, current, expected):
|
||||
self.current = current
|
||||
self.expected = expected
|
||||
|
||||
def __str__(self):
|
||||
return 'Expected state %d but current state is %d' % (self.expected, self.current)
|
||||
|
||||
|
||||
class InvalidLanguageError(Error):
|
||||
"""Exception raised when invalid language is submitted
|
||||
|
||||
@@ -66,21 +48,21 @@ class MissingLanguageError(Error):
|
||||
return self.language
|
||||
|
||||
|
||||
class InvalidPluginError(Error):
|
||||
""""Exception raised when invalid plugin is submitted
|
||||
class InvalidServiceError(Error):
|
||||
"""Exception raised when invalid service is submitted
|
||||
|
||||
:param string service: service that causes the error
|
||||
|
||||
Attributes:
|
||||
plugin -- plugin that cause the error
|
||||
"""
|
||||
def __init__(self, plugin):
|
||||
self.plugin = plugin
|
||||
def __init__(self, service):
|
||||
self.service = service
|
||||
|
||||
def __str__(self):
|
||||
return self.plugin
|
||||
return self.service
|
||||
|
||||
|
||||
class PluginError(Error):
|
||||
""""Exception raised by plugins"""
|
||||
class ServiceError(Error):
|
||||
""""Exception raised by services"""
|
||||
pass
|
||||
|
||||
|
||||
@@ -90,7 +72,7 @@ class WrongTaskError(Error):
|
||||
|
||||
|
||||
class DownloadFailedError(Error):
|
||||
""""Exception raised when a download task has failed in plugin"""
|
||||
""""Exception raised when a download task has failed in service"""
|
||||
pass
|
||||
|
||||
|
||||
|
||||
@@ -1,26 +1,18 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
|
||||
#
|
||||
# Subliminal - Subtitles, faster than your thoughts
|
||||
# Copyright (c) 2011 Antoine Bertin <diaoulael@gmail.com>
|
||||
# This file is part of subliminal.
|
||||
#
|
||||
# This file is part of Subliminal.
|
||||
#
|
||||
# Subliminal is free software; you can redistribute it and/or modify it under
|
||||
# the terms of the Lesser GNU General Public License as published by
|
||||
# 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,
|
||||
# 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
|
||||
# Lesser GNU General Public License for more details.
|
||||
# GNU Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the Lesser GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
__title__ = 'subliminal'
|
||||
__description__ = 'Subtitles, faster than your thoughts'
|
||||
__version__ = '0.5'
|
||||
__author__ = 'Antoine Bertin'
|
||||
__license__ = 'LGPLv3'
|
||||
__copyright__ = 'Copyright 2010-2011 Antoine Bertin'
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with subliminal. If not, see <http://www.gnu.org/licenses/>.
|
||||
__version__ = '0.5.1'
|
||||
|
||||
@@ -1,29 +1,34 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
|
||||
#
|
||||
# Subliminal - Subtitles, faster than your thoughts
|
||||
# Copyright (c) 2011 Antoine Bertin <diaoulael@gmail.com>
|
||||
# This file is part of subliminal.
|
||||
#
|
||||
# This file is part of Subliminal.
|
||||
#
|
||||
# Subliminal is free software; you can redistribute it and/or modify it under
|
||||
# the terms of the Lesser GNU General Public License as published by
|
||||
# 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,
|
||||
# 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
|
||||
# Lesser GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the Lesser GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
# 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/>.
|
||||
__all__ = ['convert_language', 'list_languages', 'LANGUAGES']
|
||||
|
||||
|
||||
def convert_language(language, to_iso, from_iso=None):
|
||||
# if no from_iso is given, try to guess it
|
||||
if from_iso == None:
|
||||
"""Convert a language into another format
|
||||
|
||||
:param string language: language
|
||||
:param int to_iso: convert language to ISO-639-x
|
||||
:param int from_iso: convert language from ISO-639-x
|
||||
:return: converted language
|
||||
:rtype: string
|
||||
|
||||
"""
|
||||
if from_iso == None: # if no from_iso is given, try to guess it
|
||||
if language.startswith(language[:1].upper()):
|
||||
from_iso = 0
|
||||
elif len(language) == 2:
|
||||
@@ -43,10 +48,17 @@ def convert_language(language, to_iso, from_iso=None):
|
||||
|
||||
|
||||
def list_languages(iso):
|
||||
"""List languages in the given ISO-639-x format
|
||||
|
||||
:param int iso: ISO-639-x format to list
|
||||
:return: languages in the requested format
|
||||
:rtype: list
|
||||
|
||||
"""
|
||||
return [l[iso] for l in LANGUAGES if l[iso]]
|
||||
|
||||
# ISO-639-2 languages list from http://www.loc.gov/standards/iso639-2/ISO-639-2_utf-8.txt
|
||||
# + ('Brazilian', 'po', 'pob')
|
||||
#: ISO-639-2 languages list from http://www.loc.gov/standards/iso639-2/ISO-639-2_utf-8.txt
|
||||
#: + ('Brazilian', 'po', 'pob')
|
||||
LANGUAGES = [('Afar', 'aa', 'aar'),
|
||||
('Abkhazian', 'ab', 'abk'),
|
||||
('Achinese', '', 'ace'),
|
||||
|
||||
@@ -1,890 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Subliminal - Subtitles, faster than your thoughts
|
||||
# Copyright (c) 2011 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 Lesser GNU 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
|
||||
# Lesser GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the Lesser GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
__all__ = ['PluginBase', 'OpenSubtitles', 'BierDopje', 'TheSubDB', 'SubsWiki', 'Subtitulos']
|
||||
|
||||
|
||||
from exceptions import DownloadFailedError, MissingLanguageError, PluginError
|
||||
from utils import get_keywords, PluginConfig, split_keyword
|
||||
from videos import Episode, Movie, UnknownVideo
|
||||
from subtitles import ResultSubtitle, get_subtitle_path
|
||||
import BeautifulSoup
|
||||
import abc
|
||||
import gzip
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import requests
|
||||
import suds.client
|
||||
import threading
|
||||
import unicodedata
|
||||
import urllib
|
||||
import xmlrpclib
|
||||
try:
|
||||
import cPickle as pickle
|
||||
except ImportError:
|
||||
import pickle
|
||||
|
||||
|
||||
#TODO: use ISO-639-2 in plugins instead of ISO-639-1
|
||||
class PluginBase(object):
|
||||
__metaclass__ = abc.ABCMeta
|
||||
site_url = ''
|
||||
site_name = ''
|
||||
server_url = ''
|
||||
user_agent = 'Subliminal v0.5'
|
||||
api_based = False
|
||||
timeout = 5
|
||||
lock = threading.Lock()
|
||||
languages = {}
|
||||
reverted_languages = False
|
||||
videos = []
|
||||
require_video = False
|
||||
shared_support = False
|
||||
|
||||
@abc.abstractmethod
|
||||
def __init__(self, config=None):
|
||||
self.config = config or PluginConfig()
|
||||
self.logger = logging.getLogger('subliminal.%s' % self.__class__.__name__)
|
||||
|
||||
@abc.abstractmethod
|
||||
def init(self):
|
||||
"""Initiate connection"""
|
||||
self.session = requests.session(timeout=10, headers={'User-Agent': self.user_agent})
|
||||
|
||||
@abc.abstractmethod
|
||||
def terminate(self):
|
||||
"""Terminate connection"""
|
||||
|
||||
@abc.abstractmethod
|
||||
def query(self, *args):
|
||||
"""Make the actual query"""
|
||||
|
||||
@abc.abstractmethod
|
||||
def list(self, video, languages):
|
||||
"""List subtitles"""
|
||||
|
||||
@abc.abstractmethod
|
||||
def download(self, subtitle):
|
||||
"""Download a subtitle"""
|
||||
|
||||
@classmethod
|
||||
def availableLanguages(cls):
|
||||
if not cls.reverted_languages:
|
||||
return set(cls.languages.keys())
|
||||
if cls.reverted_languages:
|
||||
return set(cls.languages.values())
|
||||
|
||||
@classmethod
|
||||
def isValidVideo(cls, video):
|
||||
if cls.require_video and not video.exists:
|
||||
return False
|
||||
if not isinstance(video, tuple(cls.videos)):
|
||||
return False
|
||||
return True
|
||||
|
||||
@classmethod
|
||||
def isValidLanguage(cls, language):
|
||||
if language in cls.availableLanguages():
|
||||
return True
|
||||
return False
|
||||
|
||||
@classmethod
|
||||
def getRevertLanguage(cls, language):
|
||||
"""ISO-639-1 language code from plugin language code"""
|
||||
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 getLanguage(cls, language):
|
||||
"""Plugin language code from ISO-639-1 language code"""
|
||||
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 adjustPermissions(self, filepath):
|
||||
if self.config.filemode != None:
|
||||
os.chmod(filepath, self.config.filemode)
|
||||
|
||||
def downloadFile(self, url, filepath):
|
||||
"""Download a subtitle file"""
|
||||
self.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:
|
||||
self.logger.error(u'Download %s failed: %s' % (url, e))
|
||||
if os.path.exists(filepath):
|
||||
os.remove(filepath)
|
||||
raise DownloadFailedError(str(e))
|
||||
self.logger.debug(u'Download finished for file %s. Size: %s' % (filepath, os.path.getsize(filepath)))
|
||||
|
||||
|
||||
class OpenSubtitles(PluginBase):
|
||||
site_url = 'http://www.opensubtitles.org'
|
||||
site_name = 'OpenSubtitles'
|
||||
server_url = 'http://api.opensubtitles.org/xml-rpc'
|
||||
user_agent = 'Subliminal v0.5'
|
||||
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 __enter__(self):
|
||||
self.init()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.terminate()
|
||||
|
||||
def init(self):
|
||||
self.logger.debug(u'Initializing')
|
||||
super(OpenSubtitles, self).init()
|
||||
result = self.server.LogIn('', '', 'eng', self.user_agent)
|
||||
if result['status'] != '200 OK':
|
||||
raise PluginError('Login failed')
|
||||
self.token = result['token']
|
||||
|
||||
def terminate(self):
|
||||
self.logger.debug(u'Terminating')
|
||||
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 PluginError('One or more parameter missing')
|
||||
for search in searches:
|
||||
search['sublanguageid'] = ','.join([self.getLanguage(l) for l in languages])
|
||||
self.logger.debug(u'Getting subtitles %r with token %s' % (searches, self.token))
|
||||
results = self.server.SearchSubtitles(self.token, searches)
|
||||
if not results['data']:
|
||||
self.logger.debug(u'Could not find subtitles for %r with token %s' % (searches, self.token))
|
||||
return []
|
||||
subtitles = []
|
||||
for result in results['data']:
|
||||
language = self.getRevertLanguage(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, self.__class__.__name__, result['SubDownloadLink'], result['SubFileName'], confidence)
|
||||
subtitles.append(subtitle)
|
||||
return subtitles
|
||||
|
||||
def list(self, video, languages):
|
||||
languages = languages & self.availableLanguages()
|
||||
if not languages:
|
||||
self.logger.debug(u'No language available')
|
||||
return []
|
||||
if not self.isValidVideo(video):
|
||||
self.logger.debug(u'Not a valid video')
|
||||
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.downloadFile(subtitle.link, subtitle.path + '.gz')
|
||||
with open(subtitle.path, 'wb') as dump:
|
||||
gz = gzip.open(subtitle.path + '.gz')
|
||||
dump.write(gz.read())
|
||||
gz.close()
|
||||
self.adjustPermissions(subtitle.path)
|
||||
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
|
||||
|
||||
|
||||
class BierDopje(PluginBase):
|
||||
site_url = 'http://bierdopje.com'
|
||||
site_name = 'BierDopje'
|
||||
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.initCache()
|
||||
|
||||
def __enter__(self):
|
||||
self.init()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.terminate()
|
||||
|
||||
def init(self):
|
||||
self.logger.debug(u'Initializing')
|
||||
super(BierDopje, self).init()
|
||||
|
||||
def terminate(self):
|
||||
self.logger.debug(u'Terminating')
|
||||
|
||||
def initCache(self):
|
||||
self.logger.debug(u'Initializing cache...')
|
||||
if not self.config or not self.config.cache_dir:
|
||||
raise PluginError('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.saveToCache()
|
||||
|
||||
def saveToCache(self):
|
||||
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 loadFromCache(self):
|
||||
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.initCache()
|
||||
self.loadFromCache()
|
||||
if series:
|
||||
if series.lower() in self.showids: # from cache
|
||||
request_id = self.showids[series.lower()]
|
||||
self.logger.debug(u'Retreived showid %d for %s from cache' % (request_id, series))
|
||||
else: # query to get showid
|
||||
self.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:
|
||||
self.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':
|
||||
self.logger.debug(u'Could not find show %s' % series)
|
||||
return []
|
||||
request_id = int(soup.showid.contents[0])
|
||||
self.showids[series.lower()] = request_id
|
||||
self.saveToCache()
|
||||
request_source = 'showid'
|
||||
request_is_tvdbid = 'false'
|
||||
elif tvdbid:
|
||||
request_id = tvdbid
|
||||
request_source = 'tvdbid'
|
||||
request_is_tvdbid = 'true'
|
||||
else:
|
||||
raise PluginError('One or more parameter missing')
|
||||
subtitles = []
|
||||
for language in languages:
|
||||
self.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:
|
||||
self.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':
|
||||
self.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, self.__class__.__name__, result.downloadlink.contents[0], result.filename.contents[0])
|
||||
subtitles.append(subtitle)
|
||||
return subtitles
|
||||
|
||||
def list(self, video, languages):
|
||||
languages = languages & self.availableLanguages()
|
||||
if not languages:
|
||||
self.logger.debug(u'No language available')
|
||||
return []
|
||||
if not self.isValidVideo(video):
|
||||
self.logger.debug(u'Not a valid video')
|
||||
return []
|
||||
results = self.query(video.season, video.episode, languages, video.path or video.release, video.tvdbid, video.series)
|
||||
return results
|
||||
|
||||
def download(self, subtitle):
|
||||
self.downloadFile(subtitle.link, subtitle.path)
|
||||
return subtitle
|
||||
|
||||
|
||||
class TheSubDB(PluginBase):
|
||||
site_url = 'http://thesubdb.com'
|
||||
site_name = 'SubDB'
|
||||
server_url = 'http://api.thesubdb.com/' # for testing purpose, use http://sandbox.thesubdb.com/ instead
|
||||
api_based = True
|
||||
user_agent = 'SubDB/1.0 (Subliminal/0.5; https://github.com/Diaoul/subliminal)' # defined by the API
|
||||
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 __init__(self, config=None):
|
||||
super(TheSubDB, self).__init__(config)
|
||||
|
||||
def __enter__(self):
|
||||
self.init()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.terminate()
|
||||
|
||||
def init(self):
|
||||
self.logger.debug(u'Initializing')
|
||||
super(TheSubDB, self).init()
|
||||
|
||||
def terminate(self):
|
||||
self.logger.debug(u'Terminating')
|
||||
|
||||
def list(self, video, languages):
|
||||
languages = languages & self.availableLanguages()
|
||||
if not languages:
|
||||
self.logger.debug(u'No language available')
|
||||
return []
|
||||
if not self.isValidVideo(video):
|
||||
self.logger.debug(u'Not a valid video')
|
||||
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:
|
||||
self.logger.debug(u'Could not find subtitles for hash %s' % moviehash)
|
||||
return []
|
||||
if r.status_code != 200:
|
||||
self.logger.error(u'Request %s returned status code %d' % (r.url, r.status_code))
|
||||
return []
|
||||
available_languages = set([self.getRevertLanguage(l) for l in r.content.split(',')])
|
||||
filtered_languages = languages & available_languages
|
||||
if not filtered_languages:
|
||||
self.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 filtered_languages:
|
||||
path = get_subtitle_path(filepath, language, self.config.multi)
|
||||
subtitle = ResultSubtitle(path, language, self.__class__.__name__, '%s?action=download&hash=%s&language=%s' % (self.server_url, moviehash, self.getLanguage(language)))
|
||||
subtitles.append(subtitle)
|
||||
return subtitles
|
||||
|
||||
def download(self, subtitle):
|
||||
self.downloadFile(subtitle.link, subtitle.path)
|
||||
return subtitle
|
||||
|
||||
|
||||
class SubsWiki(PluginBase):
|
||||
site_url = 'http://www.subswiki.com'
|
||||
site_name = 'SubsWiki'
|
||||
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 __init__(self, config=None):
|
||||
super(SubsWiki, self).__init__(config)
|
||||
|
||||
def __enter__(self):
|
||||
self.init()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.terminate()
|
||||
|
||||
def init(self):
|
||||
self.logger.debug(u'Initializing')
|
||||
super(SubsWiki, self).init()
|
||||
|
||||
def terminate(self):
|
||||
self.logger.debug(u'Terminating')
|
||||
|
||||
def list(self, video, languages):
|
||||
languages = languages & self.availableLanguages()
|
||||
if not languages:
|
||||
self.logger.debug(u'No language available')
|
||||
return []
|
||||
if not self.isValidVideo(video):
|
||||
self.logger.debug(u'Not a valid video')
|
||||
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')
|
||||
self.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:
|
||||
self.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')
|
||||
self.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:
|
||||
self.logger.debug(u'Could not find subtitles for %s (%d) with languages %r' % (movie, year, languages))
|
||||
return []
|
||||
else:
|
||||
raise PluginError('One or more parameter missing')
|
||||
if r.status_code != 200:
|
||||
self.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:
|
||||
self.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.getRevertLanguage(html_language.string.strip())
|
||||
if not language in languages:
|
||||
self.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':
|
||||
self.logger.debug(u'Wrong subtitle status %s' % status)
|
||||
continue
|
||||
path = get_subtitle_path(filepath, language, self.config.multi)
|
||||
subtitle = ResultSubtitle(path, language, self.__class__.__name__, '%s%s' % (self.server_url, html_status.findNext('td').find('a')['href']))
|
||||
subtitles.append(subtitle)
|
||||
return subtitles
|
||||
|
||||
def download(self, subtitle):
|
||||
self.downloadFile(subtitle.link, subtitle.path)
|
||||
return subtitle
|
||||
|
||||
|
||||
class Subtitulos(PluginBase):
|
||||
site_url = 'http://www.subtitulos.es/'
|
||||
site_name = 'Subtitulos'
|
||||
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ón (.+) ([0-9]+).([0-9])+ megabytes')
|
||||
|
||||
def __init__(self, config=None):
|
||||
super(Subtitulos, self).__init__(config)
|
||||
|
||||
def __enter__(self):
|
||||
self.init()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.terminate()
|
||||
|
||||
def init(self):
|
||||
self.logger.debug(u'Initializing')
|
||||
super(Subtitulos, self).init()
|
||||
|
||||
def terminate(self):
|
||||
self.logger.debug(u'Terminating')
|
||||
|
||||
def list(self, video, languages):
|
||||
languages = languages & self.availableLanguages()
|
||||
if not languages:
|
||||
self.logger.debug(u'No language available')
|
||||
return []
|
||||
if not self.isValidVideo(video):
|
||||
self.logger.debug(u'Not a valid video')
|
||||
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')
|
||||
self.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:
|
||||
self.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:
|
||||
self.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:
|
||||
self.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.getRevertLanguage(html_language.findNext('li', {'class': 'li-idioma'}).find('strong').contents[0].string.strip())
|
||||
if not language in languages:
|
||||
self.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':
|
||||
self.logger.debug(u'Wrong subtitle status %s' % status)
|
||||
continue
|
||||
path = get_subtitle_path(filepath, language, self.config.multi)
|
||||
subtitle = ResultSubtitle(path, language, self.__class__.__name__, html_status.findNext('span', {'class': 'descargar green'}).find('a')['href'], keywords=sub_keywords)
|
||||
subtitles.append(subtitle)
|
||||
return subtitles
|
||||
|
||||
def download(self, subtitle):
|
||||
self.downloadFile(subtitle.link, subtitle.path)
|
||||
return subtitle
|
||||
|
||||
|
||||
class GetSubtitle(PluginBase):
|
||||
site_url = 'http://www.subtitles.com.br/'
|
||||
site_name = 'GetSubtitle'
|
||||
server_url = 'http://api.getsubtitle.com/server.php?wsdl'
|
||||
api_based = True
|
||||
languages = {'sq': 'ALB', 'ar': 'ARA', 'hy': 'ARM', 'bs': 'BOS', 'bg': 'BUL', 'ca': 'CAT', 'zh': 'CHI', 'hr': 'HRV',
|
||||
'cs': 'CZE', 'da': 'DAN', 'nl': 'NLD', 'en': 'ENG', 'eo': 'ESP', 'et': 'EST', 'fi': 'FIN', 'fr': 'FRA',
|
||||
'gl': 'GLG', 'ka': 'GEO', 'de': 'DEU', 'el': 'GRC', 'he': 'ISR', 'hi': 'HIN', 'hu': 'HUN', 'is': 'ISL',
|
||||
'id': 'IND', 'it': 'ITA', 'ja': 'JPN', 'kk': 'KAZ', 'ko': 'KOR', 'lv': 'LVA', 'lt': 'LIT', 'lb': 'LTZ',
|
||||
'mk': 'MKD', 'ms': 'MAY', 'no': 'NOR', 'oc': 'OCC', 'pl': 'POL', 'pt': 'POR', 'ro': 'RUM', 'ru': 'RUS',
|
||||
'sr': 'ZAF', 'sk': 'SLK', 'sl': 'SLV', 'es': 'SPA', 'sv': 'SWE', 'th': 'THA', 'tr': 'TUR', 'uk': 'UKR',
|
||||
'ur': 'URD', 'vi': 'VTN'}
|
||||
reverted_languages = False
|
||||
videos = [Movie]
|
||||
require_video = False
|
||||
max_results = 100
|
||||
|
||||
def __init__(self, config=None):
|
||||
super(GetSubtitle, self).__init__(config)
|
||||
|
||||
def __enter__(self):
|
||||
self.init()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
pass
|
||||
|
||||
def init(self):
|
||||
self.logger.debug(u'Initializing')
|
||||
self.server = suds.client.Client(self.server_url)
|
||||
|
||||
def terminate(self):
|
||||
self.logger.debug(u'Terminating')
|
||||
|
||||
def query(self, *args):
|
||||
#TODO
|
||||
pass
|
||||
|
||||
def list(self, video, languages):
|
||||
languages = languages & self.availableLanguages()
|
||||
if not languages:
|
||||
self.logger.debug(u'No language available')
|
||||
return []
|
||||
if not self.isValidVideo(video):
|
||||
self.logger.debug(u'Not a valid video')
|
||||
return []
|
||||
#TODO
|
||||
|
||||
def download(self, subtitle):
|
||||
#TODO
|
||||
pass
|
||||
|
||||
|
||||
'''
|
||||
class Addic7ed(PluginBase.PluginBase):
|
||||
site_url = 'http://www.addic7ed.com'
|
||||
site_name = 'Addic7ed'
|
||||
server_url = 'http://www.addic7ed.com'
|
||||
api_based = False
|
||||
_plugin_languages = {u'English': 'en',
|
||||
u'English (US)': 'en',
|
||||
u'English (UK)': 'en',
|
||||
u'Italian': 'it',
|
||||
u'Portuguese': 'pt',
|
||||
u'Portuguese (Brazilian)': 'po',
|
||||
u'Romanian': 'ro',
|
||||
u'Español (Latinoamérica)': 'es',
|
||||
u'Español (España)': 'es',
|
||||
u'Spanish (Latin America)': 'es',
|
||||
u'Español': 'es',
|
||||
u'Spanish': 'es',
|
||||
u'Spanish (Spain)': 'es',
|
||||
u'French': 'fr',
|
||||
u'Greek': 'el',
|
||||
u'Arabic': 'ar',
|
||||
u'German': 'de',
|
||||
u'Croatian': 'hr',
|
||||
u'Indonesian': 'id',
|
||||
u'Hebrew': 'he',
|
||||
u'Russian': 'ru',
|
||||
u'Turkish': 'tr',
|
||||
u'Swedish': 'se',
|
||||
u'Czech': 'cs',
|
||||
u'Dutch': 'nl',
|
||||
u'Hungarian': 'hu',
|
||||
u'Norwegian': 'no',
|
||||
u'Polish': 'pl',
|
||||
u'Persian': 'fa'}
|
||||
|
||||
def __init__(self, config_dict=None):
|
||||
super(Addic7ed, self).__init__(self._plugin_languages, config_dict, isRevert=True)
|
||||
#http://www.addic7ed.com/serie/Smallville/9/11/Absolute_Justice
|
||||
self.release_pattern = re.compile(' \nVersion (.+), ([0-9]+).([0-9])+ MBs')
|
||||
|
||||
def list(self, filepath, languages):
|
||||
if not self.checkLanguages(languages):
|
||||
return []
|
||||
guess = guessit.guess_file_info(filepath, 'autodetect')
|
||||
if guess['type'] != 'episode':
|
||||
self.logger.debug(u'Not an episode')
|
||||
return []
|
||||
# add multiple things to the release group set
|
||||
release_group = set()
|
||||
if 'releaseGroup' in guess:
|
||||
release_group.add(guess['releaseGroup'].lower())
|
||||
else:
|
||||
if 'title' in guess:
|
||||
release_group.add(guess['title'].lower())
|
||||
if 'screenSize' in guess:
|
||||
release_group.add(guess['screenSize'].lower())
|
||||
if 'series' not in guess or len(release_group) == 0:
|
||||
self.logger.debug(u'Not enough information to proceed')
|
||||
return []
|
||||
self.release_group = release_group # used to sort results
|
||||
return self.query(guess['series'], guess['season'], guess['episodeNumber'], release_group, filepath, languages)
|
||||
|
||||
def query(self, name, season, episode, release_group, filepath, languages=None):
|
||||
searchname = name.lower().replace(' ', '_')
|
||||
if isinstance(searchname, unicode):
|
||||
searchname = searchname.encode('utf-8')
|
||||
searchurl = '%s/serie/%s/%s/%s/%s' % (self.server_url, urllib2.quote(searchname), season, episode, urllib2.quote(searchname))
|
||||
self.logger.debug(u'Searching in %s' % searchurl)
|
||||
try:
|
||||
req = urllib2.Request(searchurl, headers={'User-Agent': self.user_agent})
|
||||
page = urllib2.urlopen(req, timeout=self.timeout)
|
||||
except urllib2.HTTPError as inst:
|
||||
self.logger.info(u'Error: %s - %s' % (searchurl, inst))
|
||||
return []
|
||||
except urllib2.URLError as inst:
|
||||
self.logger.info(u'TimeOut: %s' % inst)
|
||||
return []
|
||||
soup = BeautifulSoup(page.read())
|
||||
sublinks = []
|
||||
for html_sub in soup('td', {'class': 'NewsTitle', 'colspan': '3'}):
|
||||
if not self.release_pattern.match(str(html_sub.contents[1])): # On not needed soup td result
|
||||
continue
|
||||
sub_teams = self.listTeams([self.release_pattern.match(str(html_sub.contents[1])).groups()[0].lower()], ['.', '_', ' ', '/', '-'])
|
||||
if not release_group.intersection(sub_teams): # On wrong team
|
||||
continue
|
||||
html_language = html_sub.findNext('td', {'class': 'language'})
|
||||
sub_language = self.getRevertLanguage(html_language.contents[0].strip().replace(' ', ''))
|
||||
if languages and not sub_language in languages: # On wrong language
|
||||
continue
|
||||
html_status = html_language.findNextSibling('td')
|
||||
sub_status = html_status.find('b').string.strip()
|
||||
if not sub_status == 'Completed': # On not completed subtitles
|
||||
continue
|
||||
sub_link = self.server_url + html_status.findNextSibling('td', {'colspan': '3'}).find('a')['href']
|
||||
self.logger.debug(u'Found a match with teams: %s' % sub_teams)
|
||||
result = Subtitle(filepath, self.getSubtitlePath(filepath, sub_language), self.__class__.__name__, sub_language, sub_link, keywords=sub_teams)
|
||||
sublinks.append(result)
|
||||
sublinks.sort(self._cmpReleaseGroup)
|
||||
return sublinks
|
||||
|
||||
def download(self, subtitle):
|
||||
self.downloadFile(subtitle.link, subtitle.path)
|
||||
return subtitle
|
||||
|
||||
|
||||
class Podnapisi(PluginBase.PluginBase):
|
||||
site_url = "http://www.podnapisi.net"
|
||||
site_name = "Podnapisi"
|
||||
server_url = 'http://ssp.podnapisi.net:8000'
|
||||
api_based = True
|
||||
_plugin_languages = {"sl": "1",
|
||||
"en": "2",
|
||||
"no": "3",
|
||||
"ko": "4",
|
||||
"de": "5",
|
||||
"is": "6",
|
||||
"cs": "7",
|
||||
"fr": "8",
|
||||
"it": "9",
|
||||
"bs": "10",
|
||||
"ja": "11",
|
||||
"ar": "12",
|
||||
"ro": "13",
|
||||
"es-ar": "14",
|
||||
"hu": "15",
|
||||
"el": "16",
|
||||
"zh": "17",
|
||||
"lt": "19",
|
||||
"et": "20",
|
||||
"lv": "21",
|
||||
"he": "22",
|
||||
"nl": "23",
|
||||
"da": "24",
|
||||
"se": "25",
|
||||
"pl": "26",
|
||||
"ru": "27",
|
||||
"es": "28",
|
||||
"sq": "29",
|
||||
"tr": "30",
|
||||
"fi": "31",
|
||||
"pt": "32",
|
||||
"bg": "33",
|
||||
"mk": "35",
|
||||
"sk": "37",
|
||||
"hr": "38",
|
||||
"zh": "40",
|
||||
"hi": "42",
|
||||
"th": "44",
|
||||
"uk": "46",
|
||||
"sr": "47",
|
||||
"po": "48",
|
||||
"ga": "49",
|
||||
"be": "50",
|
||||
"vi": "51",
|
||||
"fa": "52",
|
||||
"ca": "53",
|
||||
"id": "54"}
|
||||
|
||||
def __init__(self, config_dict=None):
|
||||
super(Podnapisi, self).__init__(self._plugin_languages, config_dict)
|
||||
# Podnapisi uses two reference for latin serbian and cyrillic serbian (36 and 47)
|
||||
# add the 36 manually as cyrillic seems to be more used
|
||||
self.revertPluginLanguages["36"] = "sr"
|
||||
|
||||
def list(self, filenames, languages):
|
||||
"""Main method to call when you want to list subtitles"""
|
||||
filepath = filenames[0]
|
||||
if not os.path.isfile(filepath):
|
||||
return []
|
||||
return self.query(self.hashFile(filepath), languages)
|
||||
|
||||
def download(self, subtitle):
|
||||
return []
|
||||
|
||||
def query(self, moviehash, languages=None):
|
||||
"""Makes a query on podnapisi and returns info (link, lang) about found subtitles"""
|
||||
# login
|
||||
self.server = xmlrpclib.ServerProxy(self.server_url)
|
||||
try:
|
||||
log_result = self.server.initiate(self.user_agent)
|
||||
self.logger.debug(u"Result: %s" % log_result)
|
||||
token = log_result["session"]
|
||||
nonce = log_result["nonce"]
|
||||
except Exception:
|
||||
self.logger.error(u"Cannot login" % log_result)
|
||||
return []
|
||||
username = 'getmesubs'
|
||||
password = '99D31$$'
|
||||
hash = md5()
|
||||
hash.update(password)
|
||||
password = hash.hexdigest()
|
||||
hash = sha256()
|
||||
hash.update(password)
|
||||
hash.update(nonce)
|
||||
password = hash.hexdigest()
|
||||
self.server.authenticate(token, username, password)
|
||||
self.logger.debug(u'Authenticated')
|
||||
#if languages:
|
||||
# self.logger.debug([self.getLanguage(l) for l in languages])
|
||||
# self.server.setFilters(token, [self.getLanguage(l) for l in languages])
|
||||
# self.logger.debug('Filers set for languages %s' % languages)
|
||||
self.logger.debug(u"Starting search with token %s and hashs %s" % (token, [moviehash]))
|
||||
results = self.server.search(token, [moviehash])
|
||||
return results
|
||||
subs = []
|
||||
for sub in results['results']:
|
||||
subs.append(sub)
|
||||
self.server.terminate(token)
|
||||
return subs
|
||||
'''
|
||||
Executable
+214
@@ -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)
|
||||
Executable
+122
@@ -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
|
||||
Executable
+143
@@ -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
|
||||
Executable
+99
@@ -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
|
||||
Executable
+83
@@ -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ó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
|
||||
Executable
+65
@@ -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
|
||||
@@ -1,50 +1,73 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
|
||||
#
|
||||
# Subliminal - Subtitles, faster than your thoughts
|
||||
# Copyright (c) 2011 Antoine Bertin <diaoulael@gmail.com>
|
||||
# This file is part of subliminal.
|
||||
#
|
||||
# This file is part of Subliminal.
|
||||
#
|
||||
# Subliminal is free software; you can redistribute it and/or modify it under
|
||||
# the terms of the Lesser GNU General Public License as published by
|
||||
# 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,
|
||||
# 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
|
||||
# Lesser GNU General Public License for more details.
|
||||
# GNU Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the Lesser GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
__all__ = ['Subtitle', 'EmbeddedSubtitle', 'ExternalSubtitle', 'ResultSubtitle', 'get_subtitle_path']
|
||||
|
||||
|
||||
from languages import list_languages, convert_language
|
||||
import abc
|
||||
# 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 .languages import list_languages, convert_language
|
||||
import os.path
|
||||
|
||||
|
||||
__all__ = ['Subtitle', 'EmbeddedSubtitle', 'ExternalSubtitle', 'ResultSubtitle', 'get_subtitle_path']
|
||||
|
||||
|
||||
#: Subtitles extensions
|
||||
EXTENSIONS = ['.srt', '.sub', '.txt']
|
||||
|
||||
|
||||
class Subtitle(object):
|
||||
__metaclass__ = abc.ABCMeta
|
||||
"""Base class for subtitles"""
|
||||
"""Base class for subtitles
|
||||
|
||||
:param string path: path to the subtitle
|
||||
:param string language: language of the subtitle (second element of :class:`~subliminal.languages.LANGUAGES`)
|
||||
|
||||
"""
|
||||
def __init__(self, path, language):
|
||||
self.path = path
|
||||
self.language = language
|
||||
|
||||
@property
|
||||
def exists(self):
|
||||
"""Whether the subtitle exists or not"""
|
||||
if self.path:
|
||||
return os.path.exists(self.path)
|
||||
return False
|
||||
|
||||
|
||||
class EmbeddedSubtitle(Subtitle):
|
||||
"""Subtitle embedded in a container
|
||||
|
||||
:param string path: path to the subtitle
|
||||
:param string language: language of the subtitle (second element of :class:`~subliminal.languages.LANGUAGES`)
|
||||
:param int track_id: id of the subtitle track in the container
|
||||
|
||||
"""
|
||||
def __init__(self, path, language, track_id):
|
||||
super(EmbeddedSubtitle, self).__init__(path, language)
|
||||
self.track_id = track_id
|
||||
|
||||
@classmethod
|
||||
def fromPath(cls, path):
|
||||
def from_enzyme(cls, path, subtitle):
|
||||
language = convert_language(subtitle.language, 1, 2)
|
||||
return cls(path, language, subtitle.trackno)
|
||||
|
||||
|
||||
class ExternalSubtitle(Subtitle):
|
||||
"""Subtitle in a file next to the video file"""
|
||||
@classmethod
|
||||
def from_path(cls, path):
|
||||
"""Create an :class:`ExternalSubtitle` from path"""
|
||||
extension = ''
|
||||
for e in EXTENSIONS:
|
||||
if path.endswith(e):
|
||||
@@ -58,25 +81,21 @@ class Subtitle(object):
|
||||
return cls(path, language)
|
||||
|
||||
|
||||
class EmbeddedSubtitle(Subtitle):
|
||||
def __init__(self, path, language, track_id):
|
||||
super(EmbeddedSubtitle, self).__init__(path, language)
|
||||
self.track_id = track_id
|
||||
|
||||
@classmethod
|
||||
def fromEnzyme(cls, path, subtitle):
|
||||
language = convert_language(subtitle.language, 1, 2)
|
||||
return cls(path, language, subtitle.trackno)
|
||||
|
||||
|
||||
class ExternalSubtitle(Subtitle):
|
||||
pass
|
||||
|
||||
|
||||
class ResultSubtitle(ExternalSubtitle):
|
||||
def __init__(self, path, language, plugin, link, release=None, confidence=1, keywords=set()):
|
||||
"""Subtitle found using :mod:`~subliminal.services`
|
||||
|
||||
:param string path: path to the subtitle
|
||||
:param string language: language of the subtitle (second element of :class:`~subliminal.languages.LANGUAGES`)
|
||||
:param string service: name of the service
|
||||
:param string link: download link for the subtitle
|
||||
:param string release: release name of the video
|
||||
:param float confidence: confidence that the subtitle matches the video according to the service
|
||||
:param set keywords: keywords that describe the subtitle
|
||||
|
||||
"""
|
||||
def __init__(self, path, language, service, link, release=None, confidence=1, keywords=set()):
|
||||
super(ResultSubtitle, self).__init__(path, language)
|
||||
self.plugin = plugin
|
||||
self.service = service
|
||||
self.link = link
|
||||
self.release = release
|
||||
self.confidence = confidence
|
||||
@@ -84,19 +103,20 @@ class ResultSubtitle(ExternalSubtitle):
|
||||
|
||||
@property
|
||||
def single(self):
|
||||
"""Whether this is a single subtitle or not. A single subtitle does not have
|
||||
a language indicator in its file name
|
||||
|
||||
:rtype: bool
|
||||
|
||||
"""
|
||||
extension = os.path.splitext(self.path)[0]
|
||||
language = os.path.splitext(self.path[:len(self.path) - len(extension)])[1][1:]
|
||||
if not language in list_languages(1):
|
||||
return True
|
||||
return False
|
||||
|
||||
def convert(self):
|
||||
converted = {'path': self.path, 'plugin': self.plugin, 'language': self.language, 'link': self.link, 'release': self.release,
|
||||
'confidence': self.confidence, 'keywords': self.keywords}
|
||||
return converted
|
||||
|
||||
def __str__(self):
|
||||
return repr(self.convert())
|
||||
def __repr__(self):
|
||||
return 'ResultSubtitle(%s, %s, %.2f, %s)' % (self.language, self.service, self.confidence, self.release)
|
||||
|
||||
|
||||
def get_subtitle_path(video_path, language, multi):
|
||||
|
||||
+35
-16
@@ -1,23 +1,20 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
|
||||
#
|
||||
# Subliminal - Subtitles, faster than your thoughts
|
||||
# Copyright (c) 2011 Antoine Bertin <diaoulael@gmail.com>
|
||||
# This file is part of subliminal.
|
||||
#
|
||||
# This file is part of Subliminal.
|
||||
#
|
||||
# Subliminal is free software; you can redistribute it and/or modify it under
|
||||
# the terms of the Lesser GNU General Public License as published by
|
||||
# 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,
|
||||
# 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
|
||||
# Lesser GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the Lesser GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
# 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/>.
|
||||
__all__ = ['Task', 'ListTask', 'DownloadTask', 'StopTask']
|
||||
|
||||
|
||||
@@ -27,21 +24,43 @@ class Task(object):
|
||||
|
||||
|
||||
class ListTask(Task):
|
||||
"""List task to list subtitles"""
|
||||
def __init__(self, video, languages, plugin, config):
|
||||
"""List task used by the worker to search for subtitles
|
||||
|
||||
:param video: video to search subtitles for
|
||||
:type video: :class:`~subliminal.videos.Video`
|
||||
:param list languages: languages to search for
|
||||
:param string service: name of the service to use
|
||||
:param config: configuration for the service
|
||||
:type config: :class:`~subliminal.services.ServiceConfig`
|
||||
|
||||
"""
|
||||
def __init__(self, video, languages, service, config):
|
||||
self.video = video
|
||||
self.plugin = plugin
|
||||
self.service = service
|
||||
self.languages = languages
|
||||
self.config = config
|
||||
|
||||
def __repr__(self):
|
||||
return 'ListTask(%r, %r, %s, %r)' % (self.video, self.languages, self.service, self.config)
|
||||
|
||||
|
||||
class DownloadTask(Task):
|
||||
"""Download task to download subtitles"""
|
||||
"""Download task used by the worker to download subtitles
|
||||
|
||||
:param video: video to download subtitles for
|
||||
:type video: :class:`~subliminal.videos.Video`
|
||||
:param subtitles: subtitles to download in order of preference
|
||||
:type subtitles: list of :class:`~subliminal.subtitles.Subtitle`
|
||||
|
||||
"""
|
||||
def __init__(self, video, subtitles):
|
||||
self.video = video
|
||||
self.subtitles = subtitles
|
||||
|
||||
def __repr__(self):
|
||||
return 'DownloadTask(%r, %r)' % (self.video, self.subtitles)
|
||||
|
||||
|
||||
class StopTask(Task):
|
||||
"""Stop task to stop workers"""
|
||||
"""Stop task that will stop the worker"""
|
||||
pass
|
||||
|
||||
+39
-26
@@ -1,44 +1,35 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
|
||||
#
|
||||
# Subliminal - Subtitles, faster than your thoughts
|
||||
# Copyright (c) 2011 Antoine Bertin <diaoulael@gmail.com>
|
||||
# This file is part of subliminal.
|
||||
#
|
||||
# This file is part of Subliminal.
|
||||
#
|
||||
# Subliminal is free software; you can redistribute it and/or modify it under
|
||||
# the terms of the Lesser GNU General Public License as published by
|
||||
# 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,
|
||||
# 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
|
||||
# Lesser GNU General Public License for more details.
|
||||
# GNU Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the Lesser GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
__all__ = ['PluginConfig', 'get_keywords', 'split_keyword', 'NullHandler']
|
||||
|
||||
|
||||
import logging
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with subliminal. If not, see <http://www.gnu.org/licenses/>.
|
||||
import re
|
||||
try:
|
||||
from logging import NullHandler
|
||||
except ImportError:
|
||||
class NullHandler(logging.Handler):
|
||||
def emit(self, record):
|
||||
pass
|
||||
|
||||
|
||||
class PluginConfig(object):
|
||||
def __init__(self, multi=None, cache_dir=None, filemode=None):
|
||||
self.multi = multi
|
||||
self.cache_dir = cache_dir
|
||||
self.filemode = filemode
|
||||
__all__ = ['get_keywords', 'split_keyword', 'to_unicode']
|
||||
|
||||
|
||||
def get_keywords(guess):
|
||||
"""Retrieve keywords from guessed informations
|
||||
|
||||
:param guess: guessed informations
|
||||
:type guess: :class:`guessit.guess.Guess`
|
||||
:return: lower case alphanumeric keywords
|
||||
:rtype: set
|
||||
|
||||
"""
|
||||
keywords = set()
|
||||
for k in ['releaseGroup', 'screenSize', 'videoCodec', 'format']:
|
||||
if k in guess:
|
||||
@@ -47,5 +38,27 @@ def get_keywords(guess):
|
||||
|
||||
|
||||
def split_keyword(keyword):
|
||||
"""Split a keyword in multiple ones on any non-alphanumeric character
|
||||
|
||||
:param string keyword: keyword
|
||||
:return: keywords
|
||||
:rtype: set
|
||||
|
||||
"""
|
||||
split = set(re.findall(r'\w+', keyword))
|
||||
return split
|
||||
|
||||
|
||||
def to_unicode(data):
|
||||
"""Convert a basestring to unicode
|
||||
|
||||
:param basestring data: data to decode
|
||||
:return: data as unicode
|
||||
:rtype: unicode
|
||||
|
||||
"""
|
||||
if not isinstance(data, basestring):
|
||||
raise ValueError('Basestring expected')
|
||||
if isinstance(data, unicode):
|
||||
return data
|
||||
return unicode(data, 'utf-8', 'replace')
|
||||
|
||||
+190
-135
@@ -1,57 +1,73 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
|
||||
#
|
||||
# Subliminal - Subtitles, faster than your thoughts
|
||||
# Copyright (c) 2011 Antoine Bertin <diaoulael@gmail.com>
|
||||
# This file is part of subliminal.
|
||||
#
|
||||
# This file is part of Subliminal.
|
||||
#
|
||||
# Subliminal is free software; you can redistribute it and/or modify it under
|
||||
# the terms of the Lesser GNU General Public License as published by
|
||||
# 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,
|
||||
# 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
|
||||
# Lesser GNU General Public License for more details.
|
||||
# GNU Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the Lesser GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
__all__ = ['EXTENSIONS', 'MIMETYPES', 'Video', 'Episode', 'Movie', 'UnknownVideo', 'scan']
|
||||
|
||||
|
||||
from languages import list_languages
|
||||
import abc
|
||||
# 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 subtitles
|
||||
from .languages import list_languages
|
||||
import enzyme
|
||||
import guessit
|
||||
import hashlib
|
||||
import logging
|
||||
import mimetypes
|
||||
import os
|
||||
import struct
|
||||
import subprocess
|
||||
import subtitles
|
||||
|
||||
|
||||
EXTENSIONS = ['.avi', '.mkv', '.mpg', '.mp4', '.m4v', '.mov', '.ogm', '.ogv', '.wmv', '.divx', '.asf']
|
||||
MIMETYPES = ['video/mpeg', 'video/mp4', 'video/quicktime', 'video/x-ms-wmv', 'video/x-msvideo', 'video/x-flv', 'video/x-matroska', 'video/x-matroska-3d']
|
||||
__all__ = ['EXTENSIONS', 'MIMETYPES', 'Video', 'Episode', 'Movie', 'UnknownVideo',
|
||||
'scan', 'hash_opensubtitles', 'hash_thesubdb']
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
#: Video extensions
|
||||
EXTENSIONS = ['.avi', '.mkv', '.mpg', '.mp4', '.m4v', '.mov', '.ogm', '.ogv', '.wmv',
|
||||
'.divx', '.asf']
|
||||
|
||||
#: Video mimetypes
|
||||
MIMETYPES = ['video/mpeg', 'video/mp4', 'video/quicktime', 'video/x-ms-wmv', 'video/x-msvideo',
|
||||
'video/x-flv', 'video/x-matroska', 'video/x-matroska-3d']
|
||||
|
||||
|
||||
class Video(object):
|
||||
__metaclass__ = abc.ABCMeta
|
||||
"""Base class for videos"""
|
||||
def __init__(self, release, guess, imdbid=None):
|
||||
self.release = release
|
||||
"""Base class for videos
|
||||
|
||||
:param string path: path
|
||||
:param guess: guessed informations
|
||||
:type guess: :class:`~guessit.guess.Guess`
|
||||
:param string imdbid: imdbid
|
||||
|
||||
"""
|
||||
def __init__(self, path, guess, imdbid=None):
|
||||
self.release = path
|
||||
self.guess = guess
|
||||
self.imdbid = imdbid
|
||||
self._path = None
|
||||
self.hashes = {}
|
||||
if os.path.exists(release):
|
||||
self.path = release
|
||||
if os.path.exists(path):
|
||||
self._path = path
|
||||
self.size = os.path.getsize(self._path)
|
||||
self._compute_hashes()
|
||||
|
||||
@classmethod
|
||||
def fromPath(cls, path):
|
||||
"""Create a Video object guessing all informations from the given release/path"""
|
||||
def from_path(cls, path):
|
||||
"""Create a :class:`Video` subclass guessing all informations from the given path
|
||||
|
||||
:param string path: path
|
||||
:return: video object
|
||||
:rtype: :class:`Episode` or :class:`Movie` or :class:`UnknownVideo`
|
||||
|
||||
"""
|
||||
guess = guessit.guess_file_info(path, 'autodetect')
|
||||
result = None
|
||||
if guess['type'] == 'episode' and 'series' in guess and 'season' in guess and 'episodeNumber' in guess:
|
||||
@@ -72,12 +88,14 @@ class Video(object):
|
||||
|
||||
@property
|
||||
def exists(self):
|
||||
"""Whether the video exists or not"""
|
||||
if self._path:
|
||||
return os.path.exists(self._path)
|
||||
return False
|
||||
|
||||
@property
|
||||
def path(self):
|
||||
"""Path to the video"""
|
||||
return self._path
|
||||
|
||||
@path.setter
|
||||
@@ -86,21 +104,137 @@ class Video(object):
|
||||
raise ValueError('Path does not exists')
|
||||
self._path = value
|
||||
self.size = os.path.getsize(self._path)
|
||||
self._computeHashes()
|
||||
self._compute_hashes()
|
||||
|
||||
def _computeHashes(self):
|
||||
self.hashes['OpenSubtitles'] = self._computeHashOpenSubtitles()
|
||||
self.hashes['TheSubDB'] = self._computeHashTheSubDB()
|
||||
def _compute_hashes(self):
|
||||
"""Compute different hashes"""
|
||||
self.hashes['OpenSubtitles'] = hash_opensubtitles(self.path)
|
||||
self.hashes['TheSubDB'] = hash_thesubdb(self.path)
|
||||
|
||||
def _computeHashOpenSubtitles(self):
|
||||
"""Hash a file like OpenSubtitles"""
|
||||
longlongformat = 'q' # long long
|
||||
bytesize = struct.calcsize(longlongformat)
|
||||
f = open(self.path, 'rb')
|
||||
filesize = os.path.getsize(self.path)
|
||||
def scan(self):
|
||||
"""Scan and return associated subtitles
|
||||
|
||||
:return: associated subtitles
|
||||
:rtype: list of :class:`~subliminal.subtitles.Subtitle`
|
||||
|
||||
"""
|
||||
if not self.exists:
|
||||
return []
|
||||
basepath = os.path.splitext(self.path)[0]
|
||||
results = []
|
||||
video_infos = None
|
||||
try:
|
||||
video_infos = enzyme.parse(self.path)
|
||||
logger.debug(u'Succeeded parsing %s with enzyme: %r' % (self.path, video_infos))
|
||||
except:
|
||||
logger.debug(u'Failed parsing %s with enzyme' % self.path)
|
||||
if isinstance(video_infos, enzyme.core.AVContainer):
|
||||
results.extend([subtitles.EmbeddedSubtitle.from_enzyme(self.path, s) for s in video_infos.subtitles])
|
||||
for l in list_languages(1):
|
||||
for e in subtitles.EXTENSIONS:
|
||||
single_path = basepath + '%s' % e
|
||||
if os.path.exists(single_path):
|
||||
results.append(subtitles.ExternalSubtitle(single_path, None))
|
||||
multi_path = basepath + '.%s%s' % (l, e)
|
||||
if os.path.exists(multi_path):
|
||||
results.append(subtitles.ExternalSubtitle(multi_path, l))
|
||||
return results
|
||||
|
||||
def __repr__(self):
|
||||
return '%s(%r)' % (self.__class__.__name__, self.release)
|
||||
|
||||
|
||||
class Episode(Video):
|
||||
"""Episode :class:`Video`
|
||||
|
||||
:param string path: path
|
||||
:param string series: series
|
||||
:param int season: season number
|
||||
:param int episode: episode number
|
||||
:param string title: title
|
||||
:param guess: guessed informations
|
||||
:type guess: :class:`~guessit.guess.Guess`
|
||||
:param string tvdbid: tvdbid
|
||||
:param string imdbid: imdbid
|
||||
|
||||
"""
|
||||
def __init__(self, path, series, season, episode, title=None, guess=None, tvdbid=None, imdbid=None):
|
||||
super(Episode, self).__init__(path, guess, imdbid)
|
||||
self.series = series
|
||||
self.title = title
|
||||
self.season = season
|
||||
self.episode = episode
|
||||
self.tvdbid = tvdbid
|
||||
|
||||
|
||||
class Movie(Video):
|
||||
"""Movie :class:`Video`
|
||||
|
||||
:param string path: path
|
||||
:param string title: title
|
||||
:param int year: year
|
||||
:param guess: guessed informations
|
||||
:type guess: :class:`~guessit.guess.Guess`
|
||||
:param string imdbid: imdbid
|
||||
|
||||
"""
|
||||
def __init__(self, path, title, year=None, guess=None, imdbid=None):
|
||||
super(Movie, self).__init__(path, guess, imdbid)
|
||||
self.title = title
|
||||
self.year = year
|
||||
|
||||
|
||||
class UnknownVideo(Video):
|
||||
"""Unknown video"""
|
||||
pass
|
||||
|
||||
|
||||
def scan(entry, max_depth=3, depth=0):
|
||||
"""Scan a path for videos and subtitles
|
||||
|
||||
:param string entry: path
|
||||
:param int max_depth: maximum folder depth
|
||||
:param int depth: starting depth
|
||||
:return: found videos and subtitles
|
||||
:rtype: list of (:class:`Video`, [:class:`~subliminal.subtitles.Subtitle`])
|
||||
|
||||
"""
|
||||
if depth > max_depth and max_depth != 0: # we do not want to search the whole file system except if max_depth = 0
|
||||
return []
|
||||
if depth == 0:
|
||||
entry = os.path.abspath(entry)
|
||||
if os.path.isdir(entry): # a dir? recurse
|
||||
logger.debug(u'Scanning directory %s with depth %d/%d' % (entry, depth, max_depth))
|
||||
result = []
|
||||
for e in os.listdir(entry):
|
||||
result.extend(scan(os.path.join(entry, e), max_depth, depth + 1))
|
||||
return result
|
||||
if os.path.isfile(entry) or depth == 0:
|
||||
logger.debug(u'Scanning file %s with depth %d/%d' % (entry, depth, max_depth))
|
||||
if depth != 0: # trust the user: only check for valid format if recursing
|
||||
if mimetypes.guess_type(entry)[0] not in MIMETYPES and os.path.splitext(entry)[1] not in EXTENSIONS:
|
||||
return []
|
||||
video = Video.from_path(entry)
|
||||
return [(video, video.scan())]
|
||||
logger.warning(u'Scanning entry %s failed with depth %d/%d' % (entry, depth, max_depth))
|
||||
return [] # anything else
|
||||
|
||||
|
||||
def hash_opensubtitles(path):
|
||||
"""Compute a hash using OpenSubtitles' algorithm
|
||||
|
||||
:param string path: path
|
||||
:return: hash
|
||||
:rtype: string
|
||||
|
||||
"""
|
||||
longlongformat = 'q' # long long
|
||||
bytesize = struct.calcsize(longlongformat)
|
||||
with open(path, 'rb') as f:
|
||||
filesize = os.path.getsize(path)
|
||||
filehash = filesize
|
||||
if filesize < 65536 * 2:
|
||||
return []
|
||||
return None
|
||||
for _ in range(65536 / bytesize):
|
||||
filebuffer = f.read(bytesize)
|
||||
(l_value,) = struct.unpack(longlongformat, filebuffer)
|
||||
@@ -112,103 +246,24 @@ class Video(object):
|
||||
(l_value,) = struct.unpack(longlongformat, filebuffer)
|
||||
filehash += l_value
|
||||
filehash = filehash & 0xFFFFFFFFFFFFFFFF
|
||||
f.close()
|
||||
returnedhash = '%016x' % filehash
|
||||
return returnedhash
|
||||
|
||||
def _computeHashTheSubDB(self):
|
||||
"""Hash a file like TheSubDB"""
|
||||
readsize = 64 * 1024
|
||||
with open(self.path, 'rb') as f:
|
||||
data = f.read(readsize)
|
||||
f.seek(-readsize, os.SEEK_END)
|
||||
data += f.read(readsize)
|
||||
return hashlib.md5(data).hexdigest()
|
||||
|
||||
def mkvmerge(self, subs, out=None, mkvmerge_bin='mkvmerge', title=None):
|
||||
"""Merge the video with subs"""
|
||||
if not out:
|
||||
out = self.path + '.merged.mkv'
|
||||
args = [mkvmerge_bin, '-o', out, self.path]
|
||||
if title:
|
||||
args += ['--title', title]
|
||||
for sub in subs:
|
||||
if sub.language:
|
||||
track_id = 0
|
||||
if isinstance(sub, subtitles.EmbeddedSubtitle):
|
||||
track_id = sub.track_id
|
||||
args += ['--language', str(track_id) + ':' + sub.language, sub.path]
|
||||
continue
|
||||
args += [sub.path]
|
||||
with open(os.devnull, 'w') as devnull:
|
||||
p = subprocess.Popen(args, stdout=devnull, stderr=devnull)
|
||||
p.wait()
|
||||
|
||||
def scan(self):
|
||||
"""Scan and return associated Subtitles"""
|
||||
if not self.exists:
|
||||
return []
|
||||
basepath = os.path.splitext(self.path)[0]
|
||||
results = []
|
||||
video_infos = None
|
||||
try:
|
||||
video_infos = enzyme.parse(self.path)
|
||||
except enzyme.ParseError:
|
||||
pass
|
||||
if isinstance(video_infos, enzyme.core.AVContainer):
|
||||
results.extend([subtitles.EmbeddedSubtitle.fromEnzyme(self.path, s) for s in video_infos.subtitles])
|
||||
for l in list_languages(1):
|
||||
for e in subtitles.EXTENSIONS:
|
||||
single_path = basepath + '%s' % e
|
||||
if os.path.exists(single_path):
|
||||
results.append(subtitles.ExternalSubtitle(single_path, None))
|
||||
multi_path = basepath + '.%s%s' % (l, e)
|
||||
if os.path.exists(multi_path):
|
||||
results.append(subtitles.ExternalSubtitle(multi_path, l))
|
||||
return results
|
||||
returnedhash = '%016x' % filehash
|
||||
logger.debug(u'Computed OpenSubtitle hash %s for %s' % (returnedhash, path))
|
||||
return returnedhash
|
||||
|
||||
|
||||
class Episode(Video):
|
||||
"""Episode class"""
|
||||
def __init__(self, release, series, season, episode, title=None, guess=None, tvdbid=None, imdbid=None):
|
||||
super(Episode, self).__init__(release, guess, imdbid)
|
||||
self.series = series
|
||||
self.title = title
|
||||
self.season = season
|
||||
self.episode = episode
|
||||
self.tvdbid = tvdbid
|
||||
def hash_thesubdb(path):
|
||||
"""Compute a hash using TheSubDB's algorithm
|
||||
|
||||
:param string path: path
|
||||
:return: hash
|
||||
:rtype: string
|
||||
|
||||
class Movie(Video):
|
||||
"""Movie class"""
|
||||
def __init__(self, release, title, year=None, guess=None, imdbid=None):
|
||||
super(Movie, self).__init__(release, guess, imdbid)
|
||||
self.title = title
|
||||
self.year = year
|
||||
|
||||
|
||||
class UnknownVideo(Video):
|
||||
"""Unknown video"""
|
||||
def __init__(self, release, guess, imdbid=None):
|
||||
super(UnknownVideo, self).__init__(release, guess, imdbid)
|
||||
self.guess = guess
|
||||
|
||||
|
||||
def scan(entry, max_depth=3, depth=0):
|
||||
"""Scan a path and return a list of tuples (video, [subtitle])"""
|
||||
if depth > max_depth and max_depth != 0: # we do not want to search the whole file system except if max_depth = 0
|
||||
return []
|
||||
if depth == 0:
|
||||
entry = os.path.abspath(entry)
|
||||
if os.path.isfile(entry): # a file? scan it
|
||||
if depth != 0: # trust the user: only check for valid format if recursing
|
||||
if mimetypes.guess_type(entry)[0] not in MIMETYPES and os.path.splitext(entry)[1] not in EXTENSIONS:
|
||||
return []
|
||||
video = Video.fromPath(entry)
|
||||
return [(video, video.scan())]
|
||||
if os.path.isdir(entry): # a dir? recurse
|
||||
result = []
|
||||
for e in os.listdir(entry):
|
||||
result.extend(scan(os.path.join(entry, e), max_depth, depth + 1))
|
||||
return result
|
||||
return [] # anything else
|
||||
"""
|
||||
readsize = 64 * 1024
|
||||
with open(path, 'rb') as f:
|
||||
data = f.read(readsize)
|
||||
f.seek(-readsize, os.SEEK_END)
|
||||
data += f.read(readsize)
|
||||
returnedhash = hashlib.md5(data).hexdigest()
|
||||
logger.debug(u'Computed TheSubDB hash %s for %s' % (returnedhash, path))
|
||||
return returnedhash
|
||||
|
||||
Reference in New Issue
Block a user