def test_save_subtitles(self):
        videos = [EPISODES[0], EPISODES[1]]
        for video in videos:
            video.name = os.path.join(TEST_DIR, os.path.split(video.name)[1])
        languages = {Language('eng'), Language('fra')}
        subtitles = list_subtitles(videos, languages)

        # make a list of subtitles to download (one per language per video)
        subtitles_to_download = []
        for video, video_subtitles in subtitles.items():
            video_subtitle_languages = set()
            for video_subtitle in video_subtitles:
                if video_subtitle.language in video_subtitle_languages:
                    continue
                subtitles_to_download.append(video_subtitle)
                video_subtitle_languages.add(video_subtitle.language)
                if video_subtitle_languages == languages:
                    break
        self.assertEqual(len(subtitles_to_download), 4)

        # download
        download_subtitles(subtitles_to_download)
        save_subtitles(subtitles)
        for video in videos:
            self.assertTrue(os.path.exists(os.path.splitext(video.name)[0] + '.en.srt'))
            self.assertTrue(os.path.exists(os.path.splitext(video.name)[0] + '.fr.srt'))
Exemple #2
0
    def test_save_subtitles(self):
        videos = [EPISODES[0], EPISODES[1]]
        for video in videos:
            video.name = os.path.join(TEST_DIR, os.path.split(video.name)[1])
        languages = {Language('eng'), Language('fra')}
        subtitles = list_subtitles(videos, languages)

        # make a list of subtitles to download (one per language per video)
        subtitles_to_download = []
        for video, video_subtitles in subtitles.items():
            video_subtitle_languages = set()
            for video_subtitle in video_subtitles:
                if video_subtitle.language in video_subtitle_languages:
                    continue
                subtitles_to_download.append(video_subtitle)
                video_subtitle_languages.add(video_subtitle.language)
                if video_subtitle_languages == languages:
                    break
        self.assertEqual(len(subtitles_to_download), 4)

        # download
        download_subtitles(subtitles_to_download)
        save_subtitles(subtitles)
        for video in videos:
            self.assertTrue(
                os.path.exists(os.path.splitext(video.name)[0] + '.en.srt'))
            self.assertTrue(
                os.path.exists(os.path.splitext(video.name)[0] + '.fr.srt'))
Exemple #3
0
 def test_download_subtitles_multi_noforce(self):
     results_first = download_subtitles(test_dir, languages=['en', 'fr'], cache_dir=cache_dir, multi=True, force=False, services=['thesubdb'])
     results = download_subtitles(test_dir, languages=['en', 'fr'], cache_dir=cache_dir, multi=True, force=False, services=['thesubdb'])
     self.assertTrue(len(results) == 0)
     for _, subtitles in results_first.iteritems():
         for subtitle in subtitles:
             os.remove(subtitle.path)
 def test_download_subtitles(self):
     videos = [EPISODES[0]]
     for video in videos:
         video.name = os.path.join(TEST_DIR, os.path.split(video.name)[1])
     languages = {Language('eng')}
     subtitles = list_subtitles(videos, languages)
     download_subtitles(subtitles[videos[0]][:5])
     self.assertGreaterEqual(len([s for s in subtitles[videos[0]] if s.content is not None]), 4)
 def test_download_subtitles_single(self):
     videos = [EPISODES[0], EPISODES[1]]
     for video in videos:
         video.name = os.path.join(TEST_DIR, video.name.split(os.sep)[-1])
     languages = {Language("eng"), Language("fra")}
     subtitles = list_subtitles(videos, languages)
     download_subtitles(subtitles, single=True)
     for video in videos:
         self.assertTrue(os.path.exists(os.path.splitext(video.name)[0] + ".srt"))
Exemple #6
0
 def test_download_subtitles(self):
     videos = [EPISODES[0]]
     for video in videos:
         video.name = os.path.join(TEST_DIR, os.path.split(video.name)[1])
     languages = {Language('eng')}
     subtitles = list_subtitles(videos, languages)
     download_subtitles(subtitles[videos[0]][:5])
     self.assertGreaterEqual(
         len([s for s in subtitles[videos[0]] if s.content is not None]), 4)
Exemple #7
0
 def test_download_subtitles_single(self):
     videos = [EPISODES[0], EPISODES[1]]
     for video in videos:
         video.name = os.path.join(TEST_DIR, video.name.split(os.sep)[-1])
     languages = {Language('eng'), Language('fra')}
     subtitles = list_subtitles(videos, languages)
     download_subtitles(subtitles, single=True)
     for video in videos:
         self.assertTrue(
             os.path.exists(os.path.splitext(video.name)[0] + '.srt'))
Exemple #8
0
 def test_download_subtitles_noforce(self):
     results_first = download_subtitles(test_dir,
                                        languages=['en', 'fr'],
                                        cache_dir=cache_dir,
                                        force=False,
                                        services=['thesubdb'])
     results = download_subtitles(test_dir,
                                  languages=['en', 'fr'],
                                  cache_dir=cache_dir,
                                  force=False,
                                  services=['thesubdb'])
     self.assertTrue(len(results) == 0)
     for _, subtitles in results_first.iteritems():
         for subtitle in subtitles:
             os.remove(subtitle.path)
Exemple #9
0
    def searchSingle(self, group):
        if self.isDisabled():
            return

        try:
            available_languages = sum(group["subtitle_language"].values(), [])
            downloaded = []
            files = [toUnicode(x) for x in group["files"]["movie"]]
            log.debug("Searching for subtitles for: %s", files)

            for lang in self.getLanguages():
                if lang not in available_languages:
                    download = subliminal.download_subtitles(
                        files,
                        multi=True,
                        force=self.conf("force"),
                        languages=[lang],
                        services=self.services,
                        cache_dir=Env.get("cache_dir"),
                    )
                    for subtitle in download:
                        downloaded.extend(download[subtitle])

            for d_sub in downloaded:
                log.info("Found subtitle (%s): %s", (d_sub.language.alpha2, files))
                group["files"]["subtitle"].append(sp(d_sub.path))
                group["before_rename"].append(sp(d_sub.path))
                group["subtitle_language"][sp(d_sub.path)] = [d_sub.language.alpha2]

            return True

        except:
            log.error("Failed searching for subtitle: %s", (traceback.format_exc()))

        return False
    def searchSingle(self, group):
        if self.isDisabled(): return

        try:
            available_languages = sum(group['subtitle_language'].values(), [])
            downloaded = []
            files = [toUnicode(x) for x in group['files']['movie']]
            log.debug('Searching for subtitles for: %s', files)

            for lang in self.getLanguages():
                if lang not in available_languages:
                    download = subliminal.download_subtitles(files, multi = True, force = self.conf('force'), languages = [lang], services = self.services, cache_dir = Env.get('cache_dir'))
                    for subtitle in download:
                        downloaded.extend(download[subtitle])

            for d_sub in downloaded:
                log.info('Found subtitle (%s): %s', (d_sub.language.alpha2, files))
                group['files']['subtitle'].append(sp(d_sub.path))
                group['before_rename'].append(sp(d_sub.path))
                group['subtitle_language'][sp(d_sub.path)] = [d_sub.language.alpha2]

            return True

        except:
            log.error('Failed searching for subtitle: %s', (traceback.format_exc()))

        return False
    def searchSingle(self, group):

        if self.isDisabled(): return

        try:
            available_languages = sum(group['subtitle_language'].itervalues(), [])
            downloaded = []
            files = [toUnicode(x) for x in group['files']['movie']]
            log.debug('Searching for subtitles for: %s', files)

            for lang in self.getLanguages():
                if lang not in available_languages:
                    download = subliminal.download_subtitles(files, multi = True, force = False, languages = [lang], services = self.services, cache_dir = Env.get('cache_dir'))
                    for subtitle in download:
                        downloaded.extend(download[subtitle])

            for d_sub in downloaded:
                log.info('Found subtitle (%s): %s', (d_sub.language.alpha2, files))
                group['files']['subtitle'].add(d_sub.path)
                group['subtitle_language'][d_sub.path] = [d_sub.language.alpha2]

            return True

        except:
            log.error('Failed searching for subtitle: %s', (traceback.format_exc()))

        return False
Exemple #12
0
def test_download_subtitles(mock_providers):
    subtitles = [
        Addic7edSubtitle(Language('eng'), True, None, 'The Big Bang Theory', 7, 5, 'The Workplace Proximity', 2007,
                         'DIMENSION', None),
        TheSubDBSubtitle(Language('eng'), 'ad32876133355929d814457537e12dc2'),
        TVsubtitlesSubtitle(Language('por'), None, 261077, 'Game of Thrones', 3, 10, None, '1080p.BluRay', 'DEMAND')
    ]

    download_subtitles(subtitles)

    # test providers
    assert provider_manager['addic7ed'].plugin.download_subtitle.called
    assert not provider_manager['opensubtitles'].plugin.download_subtitle.called
    assert not provider_manager['podnapisi'].plugin.download_subtitle.called
    assert provider_manager['thesubdb'].plugin.download_subtitle.called
    assert provider_manager['tvsubtitles'].plugin.download_subtitle.called
Exemple #13
0
    def searchSingle(self, group):

        if self.isDisabled(): return

        try:
            available_languages = sum(group['subtitle_language'].itervalues(),
                                      [])
            downloaded = []
            files = [toUnicode(x) for x in group['files']['movie']]

            for lang in self.getLanguages():
                if lang not in available_languages:
                    download = subliminal.download_subtitles(
                        files,
                        multi=True,
                        force=False,
                        languages=[lang],
                        services=self.services,
                        cache_dir=Env.get('cache_dir'))
                    for subtitle in download:
                        downloaded.extend(download[subtitle])

            for d_sub in downloaded:
                group['files']['subtitle'].add(d_sub.path)
                group['subtitle_language'][d_sub.path] = [
                    d_sub.language.alpha2
                ]

            return True

        except:
            log.error('Failed searching for subtitle: %s',
                      (traceback.format_exc()))

        return False
Exemple #14
0
 def test_download_subtitles_languages(self):
     results = download_subtitles('Dexter/Season 04/S04E08 - Road Kill - 720p BluRay.mkv', languages=['en'],
                                  cache_dir=cache_dir, multi=True, force=False, services=['subtitulos', 'tvsubtitles'])
     self.assertTrue(len(results) == 1)
     for _, subtitles in results.iteritems():
         self.assertTrue(len(subtitles) == 1)
         for subtitle in subtitles:
             os.remove(subtitle.path)
Exemple #15
0
def test_download_subtitles(mock_providers):
    subtitles = [
        Addic7edSubtitle(Language('eng'), True, None, 'The Big Bang Theory', 7, 5, 'The Workplace Proximity', 2007,
                         'DIMENSION', None),
        TheSubDBSubtitle(Language('eng'), 'ad32876133355929d814457537e12dc2'),
        TVsubtitlesSubtitle(Language('por'), None, 261077, 'Game of Thrones', 3, 10, None, '1080p.BluRay', 'DEMAND')
    ]

    download_subtitles(subtitles)

    # test providers
    assert provider_manager['addic7ed'].plugin.download_subtitle.called
    assert not provider_manager['opensubtitles'].plugin.download_subtitle.called
    assert not provider_manager['podnapisi'].plugin.download_subtitle.called
    assert provider_manager['thesubdb'].plugin.download_subtitle.called
    assert provider_manager['tvsubtitles'].plugin.download_subtitle.called
    assert not provider_manager['subscenter'].plugin.download_subtitle.called
Exemple #16
0
 def test_download_subtitles_multi(self):
     results = download_subtitles(test_video, languages=['en', 'fr'], cache_dir=cache_dir, multi=True)
     self.assertTrue(len(results) == 1)
     for video, subtitles in results.iteritems():
         self.assertTrue(video.release == test_video)
         self.assertTrue(len(subtitles) == 2)
         for subtitle in subtitles:
             self.assertTrue(os.path.exists(subtitle.path))
             os.remove(subtitle.path)
Exemple #17
0
 def test_download_subtitles(self):
     results = download_subtitles(test_video, languages=['en', 'fr'], cache_dir=cache_dir)
     self.assertTrue(len(results) == 1)
     for video, subtitles in results.iteritems():
         self.assertTrue(video.release == test_video)
         self.assertTrue(len(subtitles) == 1)
         for subtitle in subtitles:
             self.assertTrue(subtitle.path == os.path.splitext(os.path.basename(test_video))[0] + '.srt')
             self.assertTrue(os.path.exists(subtitle.path))
             os.remove(subtitle.path)
Exemple #18
0
def _search_subtitles(video, lang, best_only):
    log.debug("Searching for subtitles")

    # Determine language
    language = babelfish.Language.fromietf(lang)
    if not language:
        log.error("Invalid language '%s' specified" % lang)
        return

    # Determine if language alpha2 code suffix is needed in srt file name (f.e. <episode_name>.nl.srt)
    single = False
    if lang == autosubliminal.DEFAULTLANGUAGE and not autosubliminal.DEFAULTLANGUAGESUFFIX:
        single = True

    # Get min match score
    if isinstance(video, Episode):
        min_score = autosubliminal.SHOWMINMATCHSCORE
    elif isinstance(video, Movie):
        min_score = autosubliminal.MOVIEMINMATCHSCORE
    else:
        log.error("Invalid video found '%s'" % video)
        return

    # Search for subtitles
    videos = {video}
    languages = {language}
    if best_only:
        # Download the best subtitle with min_score (without saving it in to file)
        subtitles = subliminal.download_best_subtitles(
            videos,
            languages,
            min_score=min_score,
            hearing_impaired=utils.include_hearing_impaired(),
            only_one=True,
            providers=autosubliminal.SUBLIMINALPROVIDERLIST,
            provider_configs=autosubliminal.SUBLIMINALPROVIDERCONFIGS)
    else:
        # Download all subtitles with default min score (without saving it to file)
        subtitles = subliminal.list_subtitles(
            videos, languages, providers=autosubliminal.SUBLIMINALPROVIDERLIST)
        subliminal.download_subtitles(subtitles[video])

    return subtitles, language, single
Exemple #19
0
 def test_download_subtitles(self):
     results = download_subtitles(test_video,
                                  languages=['en', 'fr'],
                                  cache_dir=cache_dir)
     self.assertTrue(len(results) == 1)
     for video, subtitles in results.iteritems():
         self.assertTrue(video.release == test_video)
         self.assertTrue(len(subtitles) == 1)
         for subtitle in subtitles:
             self.assertTrue(os.path.exists(subtitle.path))
             os.remove(subtitle.path)
Exemple #20
0
    def download(self, path, subtitle_id, temp_folder):
        encoding = addon.getSetting('subliminal.encoding')
        option = SubtitleOption()
        subtitle = option.get_subtitle(subtitle_id)
        xbmc.log('Cached: %s' % subtitle, level=xbmc.LOGDEBUG)
        video = self.get_video(path)
        download_subtitles([subtitle])
        save_subtitles(video, [subtitle], directory=temp_folder, encoding=encoding if encoding else None)
        subtitle_path = xbmc.translatePath(get_subtitle_path(video.name, subtitle.language)).decode('utf-8')
        xbmc.log('temp_folder: %s' % temp_folder, level=xbmc.LOGDEBUG)
        xbmc.log('subtitle_path: %s' % subtitle_path, level=xbmc.LOGDEBUG)
        temp_path = os.path.join(temp_folder, os.path.basename(subtitle_path))
        xbmc.log('temp_path: %s' % temp_path, level=xbmc.LOGDEBUG)
        self.post_process(temp_path, subtitle.language, encoding)

        sub_basename = os.path.basename(subtitle_path)
        sub_url = temp_path
        xbmc.log('Subtitle url %s' % sub_url, xbmc.LOGDEBUG)

        listitem = xbmcgui.ListItem(label2=sub_basename)
        xbmcplugin.addDirectoryItem(handle=self.handle, url=sub_url, listitem=listitem, isFolder=False)
Exemple #21
0
def download(id):
    """ View function for downloading precise subtitles """

    try:
        name = session.get('name')
        language = session.get('language')
        video = find_video(name)
        subs = list_best_subtitles(video, language)
        sub = subs[id][0]
        download_subtitles([sub])
        response = make_response(sub.content)
        response.headers["Content-Disposition"] = "attachment; filename="+video.name+".srt"
        return response

    except IndexError:
        flash('Download impossible, no subtitles found', 'danger')
        return redirect(url_for('index'))

    except ValueError:
        flash('You have to enter a video name before attempting to download a subtitle', 'danger')
        return redirect(url_for('index'))
Exemple #22
0
def _search_subtitles(video, lang, best_only):
    log.debug("Searching for subtitles")

    # Determine language
    language = babelfish.Language.fromietf(lang)
    if not language:
        log.error("Invalid language '%s' specified" % lang)
        return

    # Determine if language alpha2 code suffix is needed in srt file name (f.e. <episode_name>.nl.srt)
    single = False
    if lang == autosubliminal.DEFAULTLANGUAGE and not autosubliminal.DEFAULTLANGUAGESUFFIX:
        single = True

    # Get min match score
    if isinstance(video, Episode):
        min_score = autosubliminal.SHOWMINMATCHSCORE
    elif isinstance(video, Movie):
        min_score = autosubliminal.MOVIEMINMATCHSCORE
    else:
        log.error("Invalid video found '%s'" % video)
        return

    # Search for subtitles
    videos = {video}
    languages = {language}
    if best_only:
        # Download the best subtitle with min_score (without saving it in to file)
        subtitles = subliminal.download_best_subtitles(videos, languages,
                                                       min_score=min_score,
                                                       hearing_impaired=utils.include_hearing_impaired(),
                                                       only_one=True,
                                                       providers=autosubliminal.SUBLIMINALPROVIDERLIST,
                                                       provider_configs=autosubliminal.SUBLIMINALPROVIDERCONFIGS)
    else:
        # Download all subtitles with default min score (without saving it to file)
        subtitles = subliminal.list_subtitles(videos, languages, providers=autosubliminal.SUBLIMINALPROVIDERLIST)
        subliminal.download_subtitles(subtitles[video])

    return subtitles, language, single
Exemple #23
0
 def test_download_subtitles_languages(self):
     results = download_subtitles(
         'Dexter/Season 04/S04E08 - Road Kill - 720p BluRay.mkv',
         languages=['en'],
         cache_dir=cache_dir,
         multi=True,
         force=False,
         services=['subtitulos', 'tvsubtitles'])
     self.assertTrue(len(results) == 1)
     for _, subtitles in results.iteritems():
         self.assertTrue(len(subtitles) == 1)
         for subtitle in subtitles:
             os.remove(subtitle.path)
Exemple #24
0
    def searchSingle(self, group):

        if self.isDisabled(): return

        available_languages = sum(group['subtitle_language'].itervalues(), [])
        downloaded = []
        for lang in self.getLanguages():
            if lang not in available_languages:
                download = subliminal.download_subtitles(group['files']['movie'], multi = True, force = False, languages = [lang], services = self.services, cache_dir = Env.get('cache_dir'))
                downloaded.extend(download)

        for d_sub in downloaded:
            group['files']['subtitle'].add(d_sub.path)
            group['subtitle_language'][d_sub.path] = [d_sub.language]
SERVICES = ['addic7ed', 'bierdopje', 'opensubtitles']
CACHE_DIR = "C:\\change\\your\\path_pls\\"
#===========


logging.basicConfig(filename=LOGFILE, format="%(asctime)s -\
                    %(levelname)s:%(message)s", level=logging.DEBUG)

if len(sys.argv) < 2:
    logging.info('Too few arguments. Please let SickBeard call this script.')
    sys.exit()

fileName = os.path.basename(sys.argv[2])
filePath = os.path.split(sys.argv[1])[0] + "\\" + fileName

#processed Filepath
proc_filePath = sys.argv[1]
#processed Filepath replaced extension with srt
proc_filePath_srt = proc_filePath[:len(proc_filePath)-3] + "srt"

logging.info("got filename: " + filePath)
logging.info("Processed srt filepath: " + proc_filePath_srt)
logging.info("initiating subliminal")
logging.info(subliminal.download_subtitles(filePath, LANGUAGES, SERVICES, cache_dir=CACHE_DIR))

#replace video filename extension with srt, srt file is in SickBeard root folder, move it to the processed TV folder with processed filename
fileName_srt = fileName[:-3] + "srt"
logging.info("Moving srt file: " + fileName_srt + " to folder: " + proc_filePath_srt)
shutil.move(fileName_srt, proc_filePath_srt)

Exemple #26
0
        def downloadSubtitles(self):

	        cwd = os.path.abspath(projectDir + '/' + SubtitlePath)
	        os.chdir(cwd)	        	        

	        sub = subliminal.download_subtitles(os.path.basename(self.filePath), [SubtitleLanguageISO], cache_dir="/tmp", services=self.services)
Exemple #27
0
    def run(self):
        # TODO: Put that in the __init__ before starting the thread?
        if not SUBLIMINAL_SUPPORT or not sickbeard.USE_SUBTITLES:
            logger.log(u"No subtitles support of subtitles support disabled", logger.DEBUG)
            return
        if len(sickbeard.subtitles.getEnabledPluginList()) < 2:
            logger.log(
                u"Not enough plugins selected. At least 2 plugins are required to search subtitles in the background",
                logger.ERROR,
            )
            return

        logger.log(u"Checking for subtitles", logger.MESSAGE)

        # get episodes on which we want subtitles
        # criteria is:
        #  - show subtitles = 1
        #  - episode subtitles != config wanted languages or SINGLE (depends on config multi)
        #  - search count < 2 and diff(airdate, now) > 1 week : now -> 1d
        #  - search count < 7 and diff(airdate, now) <= 1 week : now -> 4h -> 8h -> 16h -> 1d -> 1d -> 1d

        myDB = db.DBConnection()
        today = datetime.date.today().toordinal()
        # you have 5 minutes to understand that one. Good luck
        sqlResults = myDB.select(
            "SELECT s.show_name, e.showid, e.season, e.episode, e.subtitles_searchcount AS searchcount, e.subtitles_lastsearch AS lastsearch, e.location, (? - e.airdate) AS airdate_daydiff FROM tv_episodes AS e INNER JOIN tv_shows AS s ON (e.showid = s.tvdb_id) WHERE s.subtitles = 1 AND e.subtitles NOT LIKE (?) AND ((e.subtitles_searchcount <= 2 AND (? - e.airdate) > 7) OR (e.subtitles_searchcount <= 7 AND (? - e.airdate) <= 7)) AND (e.status IN ("
            + ",".join([str(x) for x in Quality.DOWNLOADED + [ARCHIVED]])
            + ") OR (e.status IN ("
            + ",".join([str(x) for x in Quality.SNATCHED + Quality.SNATCHED_PROPER])
            + ') AND e.location != ""))',
            [today, wantedLanguages(True), today, today],
        )
        locations = []
        toRefresh = []
        rules = self._getRules()
        now = datetime.datetime.now()

        for epToSub in sqlResults:
            if not ek.ek(os.path.isfile, epToSub["location"]):
                logger.log(
                    u"Episode file does not exist, cannot download subtitles for episode %dx%d of show %s"
                    % (epToSub["season"], epToSub["episode"], epToSub["show_name"]),
                    logger.DEBUG,
                )
                continue
            try:
                lastsearch = datetime.datetime.strptime(epToSub["lastsearch"], "%Y-%m-%d %H:%M:%S")
            except:
                lastsearch = datetime.datetime.strptime(epToSub["lastsearch"], "%Y-%m-%d %H:%M:%S.%f")
            # Old shows rule
            if (
                epToSub["airdate_daydiff"] > 7
                and epToSub["searchcount"] < 2
                and (now - lastsearch) > datetime.timedelta(hours=rules["old"][epToSub["searchcount"]])
            ):
                logger.log(
                    u"Downloading subtitles for episode %dx%d of show %s"
                    % (epToSub["season"], epToSub["episode"], epToSub["show_name"]),
                    logger.DEBUG,
                )
                locations.append(epToSub["location"].encode("ascii", "ignore"))
                toRefresh.append((epToSub["showid"], epToSub["season"], epToSub["episode"]))
                continue
            # Recent shows rule
            if (
                epToSub["airdate_daydiff"] <= 7
                and epToSub["searchcount"] < 7
                and (now - lastsearch) > datetime.timedelta(hours=rules["new"][epToSub["searchcount"]])
            ):
                logger.log(
                    u"Downloading subtitles for episode %dx%d of show %s"
                    % (epToSub["season"], epToSub["episode"], epToSub["show_name"]),
                    logger.DEBUG,
                )
                locations.append(epToSub["location"].encode("ascii", "ignore"))
                toRefresh.append((epToSub["showid"], epToSub["season"], epToSub["episode"]))
                continue
            # Not matching my rules
            # logger.log('Do not match criteria to get downloaded: %s - %dx%d' % (epToSub['showid'], epToSub['season'], epToSub['episode']), logger.DEBUG)

        # stop here if we don't have subtitles to download
        if not locations:
            logger.log(u"No subtitles to download", logger.MESSAGE)
            return

        # download subtitles
        subtitles = subliminal.download_subtitles(
            paths=locations,
            languages=sickbeard.SUBTITLES_LANGUAGES,
            services=sickbeard.subtitles.getEnabledPluginList(),
            force=False,
            multi=sickbeard.SUBTITLES_MULTI,
            cache_dir=sickbeard.CACHE_DIR,
            max_depth=3,
            scan_filter=None,
            order=None,
        )
        for subtitle in subtitles:
            helpers.chmodAsParent(subtitle.path)
        if subtitles:
            logger.log(u"Downloaded %d subtitles" % len(subtitles), logger.MESSAGE)
        else:
            logger.log(u"No subtitles found", logger.MESSAGE)

        # refresh each show
        self._refreshShows(toRefresh, now)
                    format="%(asctime)s -\
                    %(levelname)s:%(message)s",
                    level=logging.DEBUG)

if len(sys.argv) < 2:
    logging.info('Too few arguments. Please let SickBeard call this script.')
    sys.exit()

fileName = os.path.basename(sys.argv[2])
filePath = os.path.split(sys.argv[1])[0] + "\\" + fileName

#processed Filepath
proc_filePath = sys.argv[1]
#processed Filepath replaced extension with srt
proc_filePath_srt = proc_filePath[:len(proc_filePath) - 3] + "srt"

logging.info("got filename: " + filePath)
logging.info("Processed srt filepath: " + proc_filePath_srt)
logging.info("initiating subliminal")
logging.info(
    subliminal.download_subtitles(filePath,
                                  LANGUAGES,
                                  SERVICES,
                                  cache_dir=CACHE_DIR))

#replace video filename extension with srt, srt file is in SickBeard root folder, move it to the processed TV folder with processed filename
fileName_srt = fileName[:-3] + "srt"
logging.info("Moving srt file: " + fileName_srt + " to folder: " +
             proc_filePath_srt)
shutil.move(fileName_srt, proc_filePath_srt)
Exemple #29
0
def manual_download_subtitle(path, language, hi, subtitle, provider, providers_auth, sceneName, media_type):
    logging.debug('BAZARR Manually downloading subtitles for this file: ' + path)
    if hi == "True":
        hi = True
    else:
        hi = False
    subtitle = pickle.loads(codecs.decode(subtitle.encode(), "base64"))
    if media_type == 'series':
        type_of_score = 360
    elif media_type == 'movie':
        type_of_score = 120
    use_scenename = settings.general.getboolean('use_scenename')
    use_postprocessing = settings.general.getboolean('use_postprocessing')
    postprocessing_cmd = settings.general.postprocessing_cmd

    language = alpha3_from_alpha2(language)
    if language == 'pob':
        lang_obj = Language('por', 'BR')
    else:
        lang_obj = Language(language)

    try:
        if sceneName is None or use_scenename is False:
            used_sceneName = False
            video = scan_video(path)
        else:
            used_sceneName = True
            video = Video.fromname(sceneName)
    except Exception as e:
        logging.exception("BAZARR Error trying to get video information for this file: " + path)
        pass
    else:
        try:
            download_subtitles([subtitle], providers=provider, provider_configs=providers_auth)
            logging.debug('BAZARR Subtitles file downloaded for this file:' + path)
        except Exception as e:
            logging.exception('BAZARR Error downloading subtitles for this file ' + path)
            return None
        else:
            single = settings.general.getboolean('single_language')
            try:
                score = round(float(compute_score(subtitle, video, hearing_impaired=hi)) / type_of_score * 100, 2)
                if used_sceneName == True:
                    video = scan_video(path)
                if single is True:
                    result = save_subtitles(video, [subtitle], single=True, encoding='utf-8')
                else:
                    result = save_subtitles(video, [subtitle], encoding='utf-8')
            except Exception as e:
                logging.exception('BAZARR Error saving subtitles file to disk for this file:' + path)
                return None
            else:
                if len(result) > 0:
                    downloaded_provider = result[0].provider_name
                    downloaded_language = language_from_alpha3(result[0].language.alpha3)
                    downloaded_language_code2 = alpha2_from_alpha3(result[0].language.alpha3)
                    downloaded_language_code3 = result[0].language.alpha3
                    downloaded_path = get_subtitle_path(path, downloaded_language_code2)
                    logging.debug('BAZARR Subtitles file saved to disk: ' + downloaded_path)
                    message = downloaded_language + " subtitles downloaded from " + downloaded_provider + " with a score of " + unicode(score) + "% using manual search."

                    if use_postprocessing is True:
                        command = pp_replace(postprocessing_cmd, path, downloaded_path, downloaded_language, downloaded_language_code2, downloaded_language_code3)
                        try:
                            if os.name == 'nt':
                                codepage = subprocess.Popen("chcp", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                                # wait for the process to terminate
                                out_codepage, err_codepage = codepage.communicate()
                                encoding = out_codepage.split(':')[-1].strip()

                            process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                            # wait for the process to terminate
                            out, err = process.communicate()

                            if os.name == 'nt':
                                out = out.decode(encoding)

                        except:
                            if out == "":
                                logging.error('BAZARR Post-processing result for file ' + path + ' : Nothing returned from command execution')
                            else:
                                logging.error('BAZARR Post-processing result for file ' + path + ' : ' + out)
                        else:
                            if out == "":
                                logging.info('BAZARR Post-processing result for file ' + path + ' : Nothing returned from command execution')
                            else:
                                logging.info('BAZARR Post-processing result for file ' + path + ' : ' + out)

                    return message
                else:
                    logging.error("BAZARR Tried to manually download a subtitles for file: " + path + " but we weren't able to do (probably throttled by " + str(subtitle.provider_name) + ". Please retry later or select a subtitles from another provider.")
                    return None
    logging.debug('BAZARR Ended manually downloading subtitles for file: ' + path)
Exemple #30
0
# configure the path to scan
pathToScan = config['DEFAULT']['pathToScan']

# scan for videos newer than 2 weeks and their existing subtitles in a folder
videos = scan_videos(pathToScan, age=timedelta(days=30))
logger.info('Analyse video  % s ' % (videos))

# Download all shooters
shooter_providers = ['shooter']
shooter_subtitles = list_subtitles(videos, {Language('zho')},
                                   providers=shooter_providers)

for movie, subtitles in shooter_subtitles.items():
    try:
        download_subtitles(subtitles)
        for subtitle in subtitles:
            if subtitle.content is None:
                logger.error('Skipping subtitle %r: no content' % subtitle)
                continue

            # create subtitle path
            subtitle_path = get_subtitle_path(movie.name, subtitle.language)
            filename_language, file_extension = os.path.splitext(subtitle_path)
            filename, language = os.path.splitext(filename_language)
            subtitle_path = "%s.shooter-%s%s%s" % (
                filename, str(
                    subtitles.index(subtitle)), language, file_extension)
            # save content as is or in the specified encoding
            with io.open(subtitle_path, 'wb') as f:
                f.write(subtitle.content)
Exemple #31
0
def download_subtitle(path, language, hi, providers, providers_auth, sceneName, media_type):
    if hi == "True":
        hi = True
    else:
        hi = False
    language_set = set()
    if language == 'pob':
        language_set.add(Language('por', 'BR'))
    else:
        language_set.add(Language(language))

    use_scenename = get_general_settings()[9]
    minimum_score = get_general_settings()[8]
    minimum_score_movie = get_general_settings()[22]
    use_postprocessing = get_general_settings()[10]
    postprocessing_cmd = get_general_settings()[11]

    try:
        if sceneName == "None" or use_scenename is False:
            used_sceneName = False
            video = scan_video(path)
        else:
            used_sceneName = True
            video = Video.fromname(sceneName)
    except Exception as e:
        logging.exception("Error trying to get video information for this file: " + path)
    else:
        if media_type == "movie":
            max_score = 120.0
        elif media_type == "series":
            max_score = 360.0

        try:
            with AsyncProviderPool(max_workers=None, providers=providers, provider_configs=providers_auth) as p:
                subtitles = p.list_subtitles(video, language_set)
        except Exception as e:
            logging.exception("Error trying to get subtitle list from provider")
        else:
            subtitles_list = []
            sorted_subtitles = sorted([(s, compute_score(s, video, hearing_impaired=hi)) for s in subtitles], key=operator.itemgetter(1), reverse=True)
            for s, preliminary_score in sorted_subtitles:
                if media_type == "movie":
                    if (preliminary_score / max_score * 100) < int(minimum_score_movie):
                        continue
                    matched = set(s.get_matches(video))
                    if hi == s.hearing_impaired:
                        matched.add('hearing_impaired')
                    not_matched = set(score.movie_scores.keys()) - matched
                    required = set(['title'])
                    if any(elem in required for elem in not_matched):
                        continue
                elif media_type == "series":
                    if (preliminary_score / max_score * 100) < int(minimum_score):
                        continue
                    matched = set(s.get_matches(video))
                    if hi == s.hearing_impaired:
                        matched.add('hearing_impaired')
                    not_matched = set(score.episode_scores.keys()) - matched
                    required = set(['series', 'season', 'episode'])
                    if any(elem in required for elem in not_matched):
                        continue
                subtitles_list.append(s)
            if len(subtitles_list) > 0:
                best_subtitle = subtitles_list[0]
                download_subtitles([best_subtitle], providers=providers, provider_configs=providers_auth)
                try:
                    calculated_score = round(float(compute_score(best_subtitle, video, hearing_impaired=hi)) / max_score * 100, 2)
                    if used_sceneName == True:
                        video = scan_video(path)
                    single = get_general_settings()[7]
                    if single is True:
                        result = save_subtitles(video, [best_subtitle], single=True, encoding='utf-8')
                    else:
                        result = save_subtitles(video, [best_subtitle], encoding='utf-8')
                except Exception as e:
                    logging.exception('Error saving subtitles file to disk.')
                    return None
                else:
                    if len(result) > 0:
                        downloaded_provider = result[0].provider_name
                        downloaded_language = language_from_alpha3(result[0].language.alpha3)
                        downloaded_language_code2 = alpha2_from_alpha3(result[0].language.alpha3)
                        downloaded_language_code3 = result[0].language.alpha3
                        downloaded_path = get_subtitle_path(path, language=language_set)
                        if used_sceneName == True:
                            message = downloaded_language + " subtitles downloaded from " + downloaded_provider + " with a score of " + unicode(calculated_score) + "% using this scene name: " + sceneName
                        else:
                            message = downloaded_language + " subtitles downloaded from " + downloaded_provider + " with a score of " + unicode(calculated_score) + "% using filename guessing."

                        if use_postprocessing is True:
                            command = pp_replace(postprocessing_cmd, path, downloaded_path, downloaded_language, downloaded_language_code2, downloaded_language_code3)
                            try:
                                if os.name == 'nt':
                                    codepage = subprocess.Popen("chcp", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                                    # wait for the process to terminate
                                    out_codepage, err_codepage = codepage.communicate()
                                    encoding = out_codepage.split(':')[-1].strip()

                                process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                                # wait for the process to terminate
                                out, err = process.communicate()

                                if os.name == 'nt':
                                    out = out.decode(encoding)

                            except:
                                if out == "":
                                    logging.error('Post-processing result for file ' + path + ' : Nothing returned from command execution')
                                else:
                                    logging.error('Post-processing result for file ' + path + ' : ' + out)
                            else:
                                if out == "":
                                    logging.info('Post-processing result for file ' + path + ' : Nothing returned from command execution')
                                else:
                                    logging.info('Post-processing result for file ' + path + ' : ' + out)

                        return message
                    else:
                        return None
            else:
                return None
Exemple #32
0
def manual_download_subtitle(path, language, hi, subtitle, provider, providers_auth, sceneName, media_type):
    if hi == "True":
        hi = True
    else:
        hi = False
    subtitle = pickle.loads(codecs.decode(subtitle.encode(), "base64"))
    if media_type == 'series':
        type_of_score = 360
    elif media_type == 'movie':
        type_of_score = 120
    use_scenename = get_general_settings()[9]
    use_postprocessing = get_general_settings()[10]
    postprocessing_cmd = get_general_settings()[11]

    language = alpha3_from_alpha2(language)
    if language == 'pob':
        lang_obj = Language('por', 'BR')
    else:
        lang_obj = Language(language)

    try:
        if sceneName is None or use_scenename is False:
            used_sceneName = False
            video = scan_video(path)
        else:
            used_sceneName = True
            video = Video.fromname(sceneName)
    except Exception as e:
        logging.exception('Error trying to extract information from this filename: ' + path)
        return None
    else:
        try:
            best_subtitle = subtitle
            download_subtitles([best_subtitle], providers=provider, provider_configs=providers_auth)
        except Exception as e:
            logging.exception('Error downloading subtitles for ' + path)
            return None
        else:
            single = get_general_settings()[7]
            try:
                score = round(float(compute_score(best_subtitle, video, hearing_impaired=hi)) / type_of_score * 100, 2)
                if used_sceneName == True:
                    video = scan_video(path)
                if single is True:
                    result = save_subtitles(video, [best_subtitle], single=True, encoding='utf-8')
                else:
                    result = save_subtitles(video, [best_subtitle], encoding='utf-8')
            except Exception as e:
                logging.exception('Error saving subtitles file to disk.')
                return None
            else:
                if len(result) > 0:
                    downloaded_provider = result[0].provider_name
                    downloaded_language = language_from_alpha3(result[0].language.alpha3)
                    downloaded_language_code2 = alpha2_from_alpha3(result[0].language.alpha3)
                    downloaded_language_code3 = result[0].language.alpha3
                    downloaded_path = get_subtitle_path(path, language=lang_obj)
                    message = downloaded_language + " subtitles downloaded from " + downloaded_provider + " with a score of " + unicode(score) + "% using manual search."

                    if use_postprocessing is True:
                        command = pp_replace(postprocessing_cmd, path, downloaded_path, downloaded_language, downloaded_language_code2, downloaded_language_code3)
                        try:
                            if os.name == 'nt':
                                codepage = subprocess.Popen("chcp", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                                # wait for the process to terminate
                                out_codepage, err_codepage = codepage.communicate()
                                encoding = out_codepage.split(':')[-1].strip()

                            process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                            # wait for the process to terminate
                            out, err = process.communicate()

                            if os.name == 'nt':
                                out = out.decode(encoding)

                        except:
                            if out == "":
                                logging.error('Post-processing result for file ' + path + ' : Nothing returned from command execution')
                            else:
                                logging.error('Post-processing result for file ' + path + ' : ' + out)
                        else:
                            if out == "":
                                logging.info('Post-processing result for file ' + path + ' : Nothing returned from command execution')
                            else:
                                logging.info('Post-processing result for file ' + path + ' : ' + out)

                    return message
                else:
                    return None
Exemple #33
0
def download_single_subtitle(subtitle):
    download_subtitles([subtitle])
Exemple #34
0
def download(filename, results, languages, config, providers=None):
  '''Downloads the best matches for each of the input languages found


  Parameters:

    filename (str): Search subtitles for a given file on the provided languages

    results (dict): A dictionary mapping the languages asked in the input with
      subtitles found on different providers as a result from calling
      :py:func:`search_subtitles`.

    languages (list): Defines the languages of your preference. Each language
      should be an object of type :py:class:`babelfish.Language`. Subtitles for
      these languages will be downloaded and organized following an
      2-character english-based language encoding convention (ISO 639-3),
      possibily with the contry code attached (e.g. "pt-BR", if one is
      available.

    config (dict): A dictionary where the keys represent the various providers
      available and the values correspond to dictionaries with keyword-argument
      parameters that will be used on their constructor

    providers (:py:class:`list`, optional): A list of strings determining
      providers to use for the query. If not set, then use all available
      providers.

  '''

  def _check_or_reset(s):
    '''Checks if a subtitle is of type SRT, otherwise, resets it'''

    try:
      if s.content is None: return

      # get a string representation of subtitles
      srt = None
      r = chardet.detect(s.content)
      enc = r['encoding']
      if enc is not None:
        logger.info('Decoding subtitles from `%s\'', enc)
        content = s.content.decode(encoding=enc)
      else:
        logger.warn('Cannot detect subtitle encoding - ignoring errors')
        content = s.content.decode(errors='ignore')

      # checks decoding
      srt = pysrt.SubRipFile.from_string(content)
      if not srt:
        logger.warn('Discarding contents of subtitle: not parseable')
        s.content = None
        return

      # if everything checks, re-write subtitles in utf-8
      srt.clean_indexes()
      srt.eol = os.linesep
      buf = six.StringIO()
      srt.write_into(buf)
      s.content = buf.getvalue().encode(encoding='UTF-8')
      s.encoding = 'utf-8'

    except Exception as e:
      logger.warn('Discarding contents of subtitle: %s', e)
      s.content = None


  to_download = []
  lang_download = []
  for lang in languages:
    if not results[lang]:
      logger.error('Did not find any subtitle for language `%s\'', lang)
      continue
    lang_download.append(lang)
    logger.info('Scheduling download subtitle for language `%s%s\' ' \
        'from `%s\' (score: %d)', lang.alpha2,
        '-%s' % lang.country.alpha2.lower() if lang.country else '',
        results[lang][0][1].provider_name, results[lang][0][0])
    to_download.append(results[lang].pop(0)[1])

  # if you get at this point, we can download the subtitle
  logger.info('Downloading subtitles...')

  # checks if the download was successful, otherwise, tries the next sub
  while not all([z.content for z in to_download]):

    subliminal.download_subtitles(to_download, subliminal.core.ProviderPool,
              providers=providers, provider_configs=config)

    # checks the subtitle is in SRT format
    for k in to_download: _check_or_reset(k)

    for k, (lang, dl) in enumerate(zip(lang_download, to_download)):
      if not dl.content:
        logger.warn('Contents for subtitle for language `%s%s\' where not ' \
            'downloaded from `%s\'', lang.alpha2,
          '-%s' % lang.country.alpha2.lower() if lang.country else '',
          dl.provider_name)
        if results[lang]: #there are still some to consider
          to_try = results[lang].pop(0)
          logger.info('Trying next subtitle in list, with score=%d', to_try[0])
          to_download[k] = to_try[1]

  # stores the subtitles side-by-side with the movie
  logger.info('Saving subtitles in UTF-8 encoding...')
  video = _get_video(filename)
  subliminal.save_subtitles(video, to_download, encoding='UTF-8')