示例#1
0
def test_wanted_queue_lock():
    assert get_wanted_queue_lock()
    assert autosubliminal.WANTEDQUEUELOCK
    assert not get_wanted_queue_lock()
    assert autosubliminal.WANTEDQUEUELOCK
    release_wanted_queue_lock()
    assert not autosubliminal.WANTEDQUEUELOCK
    release_wanted_queue_lock()
    assert not autosubliminal.WANTEDQUEUELOCK
示例#2
0
def save_subtitle(wanted_item_index, subtitle_index):
    log.info("Saving an individual subtitle")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    found_subtitles = wanted_item['found_subtitles']
    subtitles = found_subtitles['subtitles']
    language = found_subtitles['language']
    single = found_subtitles['single']

    # Get selected subtitle
    wanted_subtitles = _get_wanted_subtitle(subtitles, subtitle_index)

    # Save subtitle (skip notify and post_process)
    download_item = _construct_download_item(wanted_item, wanted_subtitles,
                                             language, single)
    downloaded = SubDownloader(download_item).save()

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return downloaded
示例#3
0
def save_subtitle(wanted_item_index, subtitle_index):
    log.info("Saving an individual subtitle")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    found_subtitles = wanted_item['found_subtitles']
    subtitles = found_subtitles['subtitles']
    language = found_subtitles['language']
    single = found_subtitles['single']

    # Get selected subtitle
    wanted_subtitles = _get_wanted_subtitle(subtitles, subtitle_index)

    # Save subtitle (skip notify and post_process)
    download_item = _construct_download_item(wanted_item, wanted_subtitles, language, single)
    downloaded = SubDownloader(download_item).save()

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return downloaded
示例#4
0
def post_process_no_subtitle(wanted_item_index):
    log.info('Post processing without subtitle')

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]

    # Post process only (no need to check for individual or not because we are forcing post processing)
    processed = PostProcessor(wanted_item).run()

    # Remove wanted item if processed
    if processed:
        autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index))
        log.debug('Removed item from the wanted queue at index %s',
                  int(wanted_item_index))
        WantedItems().delete_wanted_item(wanted_item)
        log.debug('Removed %s from wanted_items database',
                  wanted_item['videopath'])
    else:
        utils.add_notification_message(
            'Unable to handle post processing! Please check the log file!',
            'error')

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return processed
示例#5
0
def skip_show(wanted_item_index, season):
    log.info('Skipping a show')

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    show = wanted_item['title']

    # Remove all wanted items for the same show and season
    to_delete_wanted_queue = []
    for index, item in enumerate(autosubliminal.WANTEDQUEUE):
        if item['title'] == show:
            # Skip show all seasons
            if season == '00':
                to_delete_wanted_queue.append(index)
            # Skip season (and specials = season 0)
            elif season == item['season']:
                to_delete_wanted_queue.append(index)
    # Start at the end to delete to prevent index out of range error
    i = len(to_delete_wanted_queue) - 1
    while i >= 0:
        wanted_item_to_delete = autosubliminal.WANTEDQUEUE.pop(
            to_delete_wanted_queue[i])
        WantedItems().delete_wanted_item(wanted_item_to_delete)
        i -= 1
    log.info('Skipped show %s season %s', show, season)

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return True
示例#6
0
    def run(self, force_run):
        log.info("Checking version")

        # Wait for internet connection
        utils.wait_for_internet_connection()

        # Block version check (and update) in no force run mode when another process is using the wanted queue
        # We do not want to auto update the version while the application is busy with another process
        if not force_run and not utils.get_wanted_queue_lock():
            return False

        # Check version
        self.manager.check_version(force_run)

        # Release wanted queue lock
        if not force_run:
            utils.release_wanted_queue_lock()

        # Only update and restart when: no force run, update is allowed and auto update is enabled
        if not force_run and self.manager.update_allowed and autosubliminal.CHECKVERSIONAUTOUPDATE:
            self.update()
            # Restart the app with exit of current process to have a clean restart
            scheduler.restart_app(exit=True)

        # Always return 'True' because we don't want to retry it until the next scheduled run
        return True
示例#7
0
def post_process(wanted_item_index, subtitle_index):
    log.info("Post processing an individual subtitle")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    found_subtitles = wanted_item['found_subtitles']
    subtitles = found_subtitles['subtitles']
    language = found_subtitles['language']
    single = found_subtitles['single']

    # Only execute post processing when a subtitle is present
    processed = False
    subtitle_path = _get_subtitle_path(wanted_item)
    if os.path.exists(subtitle_path):
        # Get selected subtitle
        wanted_subtitles = _get_wanted_subtitle(subtitles, subtitle_index)

        # Post process only
        download_item = _construct_download_item(wanted_item, wanted_subtitles, language, single)
        processed = SubDownloader(download_item).post_process()

        # Remove from wanted queue is downloaded
        if processed:
            autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index))
    else:
        log.warning("No subtitle downloaded, skipping post processing")

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return processed
示例#8
0
    def run(self, force_run):
        log.info("Starting round of local disk checking at %s" % autosubliminal.VIDEOPATHS)

        # Get wanted queue lock
        if not utils.get_wanted_queue_lock():
            return False

        # Show info message (only when run was forced manually)
        if force_run:
            utils.add_notification_message("Scanning disk...")

        # Check if a directory exists to scan
        one_dir_exists = False
        for videodir in autosubliminal.VIDEOPATHS:
            if os.path.exists(videodir):
                one_dir_exists = True
            else:
                # In case of a network path, it's possible that the path is not directly found -> sleep and check again
                time.sleep(15)
                if os.path.exists(videodir):
                    one_dir_exists = True
        if not one_dir_exists:
            # Release wanted queue lock
            log.error("None of the configured video paths (%s) exist, aborting..." % autosubliminal.VIDEOPATHS)
            utils.release_wanted_queue_lock()
            return True

        # Reset the wanted queue before walking through paths and adding the wanted items
        autosubliminal.WANTEDQUEUE = []
        for videodir in autosubliminal.VIDEOPATHS:
            try:
                walk_dir(videodir)
            except Exception, e:
                log.error("Could not scan the video path (%s), skipping..." % videodir)
                log.exception(e)
示例#9
0
    def run(self, force_run):
        log.info("Checking version")

        # Wait for internet connection
        utils.wait_for_internet_connection()

        # Block version check (and update) in no force run mode when another process is using the wanted queue
        # We do not want to auto update the version while the application is busy with another process
        if not force_run and not utils.get_wanted_queue_lock():
            return False

        # Check version
        self.manager.check_version(force_run)

        # Release wanted queue lock
        if not force_run:
            utils.release_wanted_queue_lock()

        # Only update and restart when: no force run, update is allowed and auto update is enabled
        if not force_run and self.manager.update_allowed and autosubliminal.CHECKVERSIONAUTOUPDATE:
            self.update()
            # Restart the app with exit of current process to have a clean restart
            scheduler.restart_app(exit=True)

        # Always return 'True' because we don't want to retry it until the next scheduled run
        return True
示例#10
0
def delete_video(wanted_item_index, cleanup):
    log.info('Deleting an individual video file')

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Remove wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index))
    log.debug('Removed item from the wanted queue at index %s',
              int(wanted_item_index))
    WantedItems().delete_wanted_item(wanted_item)
    log.debug('Removed %s from wanted_items database',
              wanted_item['videopath'])

    # Physically delete the video file (and optionally leftovers)
    deleted = False
    video_path = wanted_item['videopath']
    # Delete with cleanup
    if cleanup:
        norm_video_path = os.path.normcase(os.path.normpath(video_path))
        norm_video_folder = os.path.dirname(norm_video_path).rstrip(os.sep)
        for root_folder in autosubliminal.VIDEOPATHS:
            # Get root folder
            norm_root_folder = os.path.normcase(
                os.path.normpath(root_folder)).rstrip(os.sep)
            # Check if video is located in subfolder underneath root folder
            if os.path.commonprefix([norm_root_folder,
                                     norm_video_path]) == norm_root_folder:
                if norm_video_folder != norm_root_folder:
                    # Move up until the first subfolder underneath the root folder to cleanup
                    while norm_video_folder != norm_root_folder:
                        folder_to_clean = norm_video_folder
                        norm_video_folder = os.path.dirname(
                            norm_video_folder).rstrip(os.sep)
                    try:
                        # Remove the folder of the video underneath the root folder
                        shutil.rmtree(folder_to_clean,
                                      onerror=utils.set_rw_and_remove)
                        log.info('Deleted video folder: %s', folder_to_clean)
                        deleted = True
                        # Break for loop
                        break
                    except Exception:
                        log.exception('Unable to delete video folder: %s',
                                      folder_to_clean)
    # Delete video file only
    if not deleted:
        try:
            os.remove(video_path)
            log.info('Deleted file: %s', video_path)
            deleted = True
        except Exception:
            log.exception('Unable to delete file: %s', video_path)

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return deleted
示例#11
0
def post_process(wanted_item_index, subtitle_index):
    log.info('Post processing an individual subtitle')

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    found_subtitles = wanted_item['found_subtitles']
    subtitles = found_subtitles['subtitles']
    language = found_subtitles['language']
    single = found_subtitles['single']

    # Only execute post processing when a subtitle is present
    processed = False
    subtitle_path = _get_subtitle_path(wanted_item)
    if os.path.exists(subtitle_path):
        # Get wanted subtitle
        wanted_subtitle = _get_wanted_subtitle(subtitles, subtitle_index)

        # Handle download
        download_item = _construct_download_item(wanted_item,
                                                 [wanted_subtitle], language,
                                                 single)
        downloader = SubDownloader(download_item)
        downloader.mark_downloaded()
        processed = downloader.post_process()

        if processed:
            # Remove downloaded language from wanted languages
            wanted_item['languages'].remove(language)

            # Update wanted item if there are still wanted languages
            if len(wanted_item['languages']) > 0:
                WantedItems().update_wanted_item(wanted_item)

            # Remove wanted item if there are no more wanted languages
            else:
                # Remove wanted item
                autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index))
                log.debug('Removed item from the wanted queue at index %s',
                          int(wanted_item_index))
                WantedItems().delete_wanted_item(wanted_item)
                log.debug('Removed %s from wanted_items database',
                          wanted_item['videopath'])

    else:
        log.warning('No subtitle downloaded, skipping post processing')

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return processed
示例#12
0
    def run(self, force_run):
        log.info("Starting round of subtitle checking")
        to_delete_wanted_queue = []

        # Wait for internet connection
        utils.wait_for_internet_connection()

        # Get wanted queue lock
        if not utils.get_wanted_queue_lock():
            return False

        # Show info message (only when run was forced manually)
        if force_run:
            utils.add_notification_message("Checking subtitles...")

        # Process all items in wanted queue
        for index, wanted_item in enumerate(autosubliminal.WANTEDQUEUE):
            # Scan wanted_item for video, skip when no video could be determined
            video = _scan_wanted_item_for_video(wanted_item)
            if not video:
                continue

            # Check subtitles for each language
            langs = wanted_item['lang']
            for lang in langs[:]:
                # Search the best subtitle with the minimal score
                subtitles, language, single = _search_subtitles(
                    video, lang, True)

                # Save when a subtitle is found for the video
                if subtitles[video]:
                    download_item = _construct_download_item(
                        wanted_item, subtitles, language, single)
                    SubDownloader(download_item).run()

                    # Remove from wanted queue if needed (if no additional languages are still needed)
                    langs.remove(lang)
                    if len(langs) == 0:
                        to_delete_wanted_queue.append(index)

        # Cleanup wanted queue
        i = len(to_delete_wanted_queue) - 1
        while i >= 0:
            log.debug("Removed item from the wanted queue at index %s" %
                      to_delete_wanted_queue[i])
            autosubliminal.WANTEDQUEUE.pop(to_delete_wanted_queue[i])
            i -= 1

        # Release wanted queue lock
        log.info("Finished round of subtitle checking")
        utils.release_wanted_queue_lock()

        return True
示例#13
0
 def flush_wanted_items(self):
     if utils.get_wanted_queue_lock():
         # Flush db and wanted queue
         WantedItems().flush_wanted_items()
         autosubliminal.WANTEDQUEUE = []
         utils.release_wanted_queue_lock()
         utils.add_notification_message(
             'Flushed wanted items database. Please launch system \'Scan Disk\'.'
         )
     else:
         utils.add_notification_message(
             'Cannot flush wanted items database when wanted queue is in use!',
             'notice')
     redirect('/home')
示例#14
0
    def run(self, force_run):
        log.info("Starting round of subtitle checking")
        to_delete_wanted_queue = []

        # Wait for internet connection
        utils.wait_for_internet_connection()

        # Get wanted queue lock
        if not utils.get_wanted_queue_lock():
            return False

        # Show info message (only when run was forced manually)
        if force_run:
            utils.add_notification_message("Checking subtitles...")

        # Process all items in wanted queue
        for index, wanted_item in enumerate(autosubliminal.WANTEDQUEUE):
            # Scan wanted_item for video, skip when no video could be determined
            video = _scan_wanted_item_for_video(wanted_item)
            if not video:
                continue

            # Check subtitles for each language
            langs = wanted_item['lang']
            for lang in langs[:]:
                # Search the best subtitle with the minimal score
                subtitles, language, single = _search_subtitles(video, lang, True)

                # Save when a subtitle is found for the video
                if subtitles[video]:
                    download_item = _construct_download_item(wanted_item, subtitles, language, single)
                    SubDownloader(download_item).run()

                    # Remove from wanted queue if needed (if no additional languages are still needed)
                    langs.remove(lang)
                    if len(langs) == 0:
                        to_delete_wanted_queue.append(index)

        # Cleanup wanted queue
        i = len(to_delete_wanted_queue) - 1
        while i >= 0:
            log.debug("Removed item from the wanted queue at index %s" % to_delete_wanted_queue[i])
            autosubliminal.WANTEDQUEUE.pop(to_delete_wanted_queue[i])
            i -= 1

        # Release wanted queue lock
        log.info("Finished round of subtitle checking")
        utils.release_wanted_queue_lock()

        return True
示例#15
0
    def update(self):
        log.info("Updating version")

        # Block update when another process is using the wanted queue
        # We do not want to update the version while the application is busy with another process
        if not utils.get_wanted_queue_lock():
            return False

        # Update version
        self.manager.update_version()

        # Release wanted queue lock
        utils.release_wanted_queue_lock()

        return True
示例#16
0
    def update(self):
        log.info("Updating version")

        # Block update when another process is using the wanted queue
        # We do not want to update the version while the application is busy with another process
        if not utils.get_wanted_queue_lock():
            return False

        # Update version
        self.manager.update_version()

        # Release wanted queue lock
        utils.release_wanted_queue_lock()

        return True
示例#17
0
def force_id_search(wanted_item_index):
    log.info("Force id search")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return

    # Force id search
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    title = wanted_item['title']
    year = wanted_item['year']
    if wanted_item['type'] == 'episode':
        wanted_item['tvdbid'] = utils.get_tvdb_id(title, True)
    elif wanted_item['type'] == 'movie':
        wanted_item['imdbid'], wanted_item['year'] = utils.get_imdb_info(title, year, True)

    # Release wanted queue lock
    utils.release_wanted_queue_lock()
示例#18
0
def delete_subtitle(wanted_item_index):
    log.info("Deleting an individual subtitle")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]

    # Delete subtitle
    deleted = False
    subtitle_path = _get_subtitle_path(wanted_item)
    try:
        os.remove(subtitle_path)
        deleted = True
    except Exception, e:
        log.error("Unable to delete subtitle: %s" % subtitle_path)
        log.error("Exception: %s" % e)
示例#19
0
def delete_video(wanted_item_index, cleanup):
    log.info("Deleting an individual video file")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Remove wanted item for queue
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index))

    # Physically delete the video file (and optionally leftovers)
    deleted = False
    video_path = wanted_item['originalFileLocationOnDisk']
    # Delete with cleanup
    if cleanup:
        norm_video_path = os.path.normcase(os.path.normpath(video_path))
        norm_video_folder = os.path.dirname(norm_video_path).rstrip(os.sep)
        for root_folder in autosubliminal.VIDEOPATHS:
            # Get root folder
            norm_root_folder = os.path.normcase(
                os.path.normpath(root_folder)).rstrip(os.sep)
            # Check if video is located in subfolder underneath root folder
            if os.path.commonprefix([norm_root_folder,
                                     norm_video_path]) == norm_root_folder:
                if norm_video_folder != norm_root_folder:
                    # Move up until the first subfolder underneath the root folder to cleanup
                    while norm_video_folder != norm_root_folder:
                        folder_to_clean = norm_video_folder
                        norm_video_folder = os.path.dirname(
                            norm_video_folder).rstrip(os.sep)
                    try:
                        # Remove the folder of the video underneath the root folder
                        shutil.rmtree(folder_to_clean,
                                      onerror=utils.set_rw_and_remove)
                        log.info("Deleted video folder: %s" % folder_to_clean)
                        deleted = True
                        # Break for loop
                        break
                    except Exception, e:
                        log.error("Unable to delete video folder: %s" %
                                  folder_to_clean)
                        log.error("Exception: %s" % e)
示例#20
0
def skip_movie(wanted_item_index):
    log.info('Skipping a movie')

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Remove wanted item from queue and db
    wanted_item = autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index))
    WantedItems().delete_wanted_item(wanted_item)
    movie = wanted_item['title']
    if wanted_item['year']:
        movie += ' (' + wanted_item['year'] + ')'
    log.info('Skipped movie %s', movie)

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return True
示例#21
0
def force_id_search(wanted_item_index):
    log.info("Force id search")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return

    # Force id search
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    title = wanted_item['title']
    year = wanted_item['year']
    if wanted_item['type'] == 'episode':
        wanted_item['tvdbid'] = utils.get_tvdb_id(title, True)
    elif wanted_item['type'] == 'movie':
        wanted_item['imdbid'], wanted_item['year'] = utils.get_imdb_info(
            title, year, True)

    # Release wanted queue lock
    utils.release_wanted_queue_lock()
示例#22
0
def delete_subtitle(wanted_item_index):
    log.info("Deleting an individual subtitle")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]

    # Delete subtitle
    deleted = False
    subtitle_path = _get_subtitle_path(wanted_item)
    try:
        os.remove(subtitle_path)
        deleted = True
    except Exception, e:
        log.error("Unable to delete subtitle: %s" % subtitle_path)
        log.error("Exception: %s" % e)
示例#23
0
def post_process_no_subtitle(wanted_item_index):
    log.info("Post processing without subtitle")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]

    # Post process only
    processed = PostProcessor(wanted_item).run()

    # Remove from wanted queue is downloaded
    if processed:
        autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index))

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return processed
示例#24
0
def post_process_no_subtitle(wanted_item_index):
    log.info("Post processing without subtitle")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]

    # Post process only
    processed = PostProcessor(wanted_item).run()

    # Remove from wanted queue is downloaded
    if processed:
        autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index))

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return processed
示例#25
0
    def run(self, force_run):
        log.info("Starting round of local disk checking at %s" %
                 autosubliminal.VIDEOPATHS)

        # Get wanted queue lock
        if not utils.get_wanted_queue_lock():
            return False

        # Show info message (only when run was forced manually)
        if force_run:
            utils.add_notification_message("Scanning disk...")

        # Check if a directory exists to scan
        one_dir_exists = False
        for videodir in autosubliminal.VIDEOPATHS:
            if os.path.exists(videodir):
                one_dir_exists = True
            else:
                # In case of a network path, it's possible that the path is not directly found -> sleep and check again
                time.sleep(15)
                if os.path.exists(videodir):
                    one_dir_exists = True
        if not one_dir_exists:
            # Release wanted queue lock
            log.error(
                "None of the configured video paths (%s) exist, aborting..." %
                autosubliminal.VIDEOPATHS)
            utils.release_wanted_queue_lock()
            return True

        # Reset the wanted queue before walking through paths and adding the wanted items
        autosubliminal.WANTEDQUEUE = []
        for videodir in autosubliminal.VIDEOPATHS:
            try:
                walk_dir(videodir)
            except Exception, e:
                log.error("Could not scan the video path (%s), skipping..." %
                          videodir)
                log.exception(e)
示例#26
0
def delete_video(wanted_item_index, cleanup):
    log.info("Deleting an individual video file")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Remove wanted item for queue
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index))

    # Physically delete the video file (and optionally leftovers)
    deleted = False
    video_path = wanted_item['originalFileLocationOnDisk']
    # Delete with cleanup
    if cleanup:
        norm_video_path = os.path.normcase(os.path.normpath(video_path))
        norm_video_folder = os.path.dirname(norm_video_path).rstrip(os.sep)
        for root_folder in autosubliminal.VIDEOPATHS:
            # Get root folder
            norm_root_folder = os.path.normcase(os.path.normpath(root_folder)).rstrip(os.sep)
            # Check if video is located in subfolder underneath root folder
            if os.path.commonprefix([norm_root_folder, norm_video_path]) == norm_root_folder:
                if norm_video_folder != norm_root_folder:
                    # Move up until the first subfolder underneath the root folder to cleanup
                    while norm_video_folder != norm_root_folder:
                        folder_to_clean = norm_video_folder
                        norm_video_folder = os.path.dirname(norm_video_folder).rstrip(os.sep)
                    try:
                        # Remove the folder of the video underneath the root folder
                        shutil.rmtree(folder_to_clean, onerror=utils.set_rw_and_remove)
                        log.info("Deleted video folder: %s" % folder_to_clean)
                        deleted = True
                        # Break for loop
                        break
                    except Exception, e:
                        log.error("Unable to delete video folder: %s" % folder_to_clean)
                        log.error("Exception: %s" % e)
示例#27
0
def force_id_search(wanted_item_index):
    log.info('Force id search')

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return

    # Force id search
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    title = wanted_item['title']
    year = wanted_item['year']
    if wanted_item['type'] == 'episode':
        wanted_item['tvdbid'] = autosubliminal.SHOWINDEXER.get_tvdb_id(
            title, year, force_search=True)
        WantedItems().update_wanted_item(wanted_item)
    elif wanted_item['type'] == 'movie':
        wanted_item['imdbid'], wanted_item[
            'year'] = autosubliminal.MOVIEINDEXER.get_imdb_id_and_year(
                title, year, True)
        WantedItems().update_wanted_item(wanted_item)

    # Release wanted queue lock
    utils.release_wanted_queue_lock()
示例#28
0
def delete_subtitle(wanted_item_index):
    log.info('Deleting an individual subtitle')

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]

    # Delete subtitle
    deleted = False
    subtitle_path = _get_subtitle_path(wanted_item)
    try:
        os.remove(subtitle_path)
        deleted = True
    except Exception:
        log.exception('Unable to delete subtitle: %s', subtitle_path)

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return deleted
示例#29
0
def post_process(wanted_item_index, subtitle_index):
    log.info("Post processing an individual subtitle")

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return False

    # Get wanted item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
    found_subtitles = wanted_item['found_subtitles']
    subtitles = found_subtitles['subtitles']
    language = found_subtitles['language']
    single = found_subtitles['single']

    # Only execute post processing when a subtitle is present
    processed = False
    subtitle_path = _get_subtitle_path(wanted_item)
    if os.path.exists(subtitle_path):
        # Get selected subtitle
        wanted_subtitles = _get_wanted_subtitle(subtitles, subtitle_index)

        # Post process only
        download_item = _construct_download_item(wanted_item, wanted_subtitles,
                                                 language, single)
        processed = SubDownloader(download_item).post_process()

        # Remove from wanted queue is downloaded
        if processed:
            autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index))
    else:
        log.warning("No subtitle downloaded, skipping post processing")

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    return processed
示例#30
0
def search_subtitle(wanted_item_index, lang):
    log.info("Searching for an individual subtitle")
    subs = []

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return subs, "Skipping! Cannot get a wanted queue lock because another threat is using the queues!"

    # Get wanted_item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]

    # Scan wanted_item for video
    video = _scan_wanted_item_for_video(wanted_item)
    if video:
        # Search the subtitles with the default minimal score (to get all the possibilities to select from)
        subtitles, language, single = _search_subtitles(video, lang, False)
        # Check if subtitles are found for the video
        if subtitles[video]:
            # Add found subtitles to wanted_item
            wanted_item['found_subtitles'] = {'subtitles': subtitles, 'language': language, 'single': single}
            # Order subtitles by score and create new dict
            # Use subliminal scoring (scores=None)
            for index, subtitle, score in sorted([(index, s, subliminal.compute_score(
                    s.get_matches(video, hearing_impaired=utils.include_hearing_impaired()), video, scores=None))
                                                  for index, s in enumerate(subtitles[video])],
                                                 key=operator.itemgetter(2), reverse=True):
                # Only add subtitle when content is found
                if subtitle.content:
                    # Create new sub dict for showing result
                    sub = {'subtitle_index': index, 'score': score, 'provider_name': subtitle.provider_name,
                           'content': subtitle.content, 'language': language, 'single': single,
                           'page_link': subtitle.page_link, 'releases': _get_releases(subtitle),
                           'wanted_item_index': wanted_item_index,
                           'playvideo_url': _construct_playvideo_url(wanted_item)}
                    # Get content preview (the first 28 lines and last 30 lines of the subtitle)
                    content_split = subtitle.content.splitlines(False)
                    if len(content_split) < 58:
                        content_preview = "This seems to be an invalid subtitle."
                        content_preview += "<br> It has less than 58 lines to preview."
                    else:
                        try:
                            # First 28 lines
                            content_preview = "<br>".join(
                                x.replace('"', "'") for x in content_split[:28])
                            # Separator
                            content_preview += "<br>"
                            content_preview += "<br>"
                            content_preview += "..."
                            content_preview += "<br>"
                            content_preview += "<br>"
                            # Last 30 lines
                            content_preview += "<br>".join(
                                x.replace('"', "'") for x in content_split[len(content_split) - 30:])
                        except:
                            content_preview = "Problem with parsing the first 28 and/or last 30 lines of the file."
                    sub['content_preview'] = content_preview
                    subs.append(sub)

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    if not len(subs):
        return subs, "No subtitles could be found or downloaded!"

    return subs, None
示例#31
0
def search_subtitle(wanted_item_index, lang):
    log.info('Searching for an individual subtitle')
    subs = []

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return subs, 'Skipping! Cannot get a wanted queue lock because another thread is using the queues!'

    # Setup provider pool
    provider_pool = _get_provider_pool()
    if provider_pool:
        log.info('Searching subtitles with providers: %s',
                 ', '.join(provider_pool.providers))

        # Get wanted_item
        wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]
        log.info('Searching subtitles for video: %s', wanted_item['videopath'])

        # Scan wanted_item for video
        video = _scan_wanted_item_for_video(wanted_item, True)
        if video:
            # Search the subtitles with the default minimal score (to get all the possibilities to select from)
            default_min_score = _get_min_match_score(video, True)
            subtitles, language, single = _search_subtitles(
                video, lang, False, provider_pool)

            # Check if subtitles are found for the video
            if subtitles:
                # Add found subtitles to wanted_item
                wanted_item['found_subtitles'] = {
                    'subtitles': subtitles,
                    'language': language,
                    'single': single
                }

                # Order subtitles by score and create new dict
                # Use subliminal default compute_score
                for index, subtitle, score in sorted(
                    [(index, s,
                      subliminal.compute_score(
                          s, video, autosubliminal.PREFERHEARINGIMPAIRED))
                     for index, s in enumerate(subtitles)],
                        key=operator.itemgetter(2),
                        reverse=True):

                    # Filter out subtitles that do not match the default score
                    if score < default_min_score:
                        log.debug('Skipping subtitle %s with score below %d',
                                  subtitle, default_min_score)
                        break

                    # Only add subtitle when content is found
                    if subtitle.content:
                        # Create new sub dict for showing result
                        sub = {
                            'subtitle_index': index,
                            'score': score,
                            'provider_name': subtitle.provider_name,
                            'content': subtitle.content,
                            'language': language,
                            'single': single,
                            'page_link': subtitle.page_link,
                            'releases': _get_releases(subtitle),
                            'wanted_item_index': wanted_item_index,
                            'playvideo_url':
                            _construct_playvideo_url(wanted_item)
                        }
                        # Get content preview (the first 28 lines and last 30 lines of the subtitle)
                        # Use the subtitle text (decoded content) instead of content to generate the preview
                        content_split = subtitle.text.splitlines(False)
                        if len(content_split) < 58:
                            content_preview = 'This seems to be an invalid subtitle.'
                            content_preview += '<br> It has less than 58 lines to preview.'
                        else:
                            try:
                                # First 28 lines
                                content_preview = '<br>'.join(
                                    x.replace('"', '\'')
                                    for x in content_split[:28])
                                # Separator
                                content_preview += '<br>'
                                content_preview += '<br>'
                                content_preview += '...'
                                content_preview += '<br>'
                                content_preview += '<br>'
                                # Last 30 lines
                                content_preview += '<br>'.join(
                                    x.replace('"', '\'')
                                    for x in content_split[len(content_split) -
                                                           30:])
                            except Exception:
                                content_preview = 'Problem with parsing the first 28 and/or last 30 lines of the file.'
                        sub['content_preview'] = content_preview
                        subs.append(sub)

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    if not provider_pool:
        return subs, 'Skipping! No subliminal providers are configured!'

    if not len(subs):
        return subs, 'No subtitles could be found or downloaded!'

    return subs, None
示例#32
0
    def run(self, force_run):
        # Get wanted queue lock
        if not utils.get_wanted_queue_lock():
            return False

        log.info('Starting round of local disk checking at %r',
                 autosubliminal.VIDEOPATHS)

        # Show info message (only when run was forced manually)
        if force_run:
            utils.add_notification_message('Scanning disk...')

        # Check if a directory exists to scan
        one_dir_exists = False
        for videodir in autosubliminal.VIDEOPATHS:
            if os.path.exists(videodir):
                one_dir_exists = True
            else:
                # In case of a network path, it's possible that the path is not directly found -> sleep and check again
                time.sleep(15)
                if os.path.exists(videodir):
                    one_dir_exists = True
        if not one_dir_exists:
            # Release wanted queue lock
            log.error(
                'None of the configured video paths (%r) exists, aborting...',
                autosubliminal.VIDEOPATHS)
            utils.release_wanted_queue_lock()
            return True

        # Walk through paths to search for wanted items
        new_wanted_items = []
        db = WantedItems()
        old_wanted_items = db.get_wanted_items()
        for videodir in autosubliminal.VIDEOPATHS:
            try:
                new_wanted_items.extend(walk_dir(videodir))
            except Exception:
                log.exception(
                    'Could not scan the video path (%s), skipping it',
                    videodir)

        # Cleanup wanted items that have been removed from disk manually but are still stored in the db
        log.debug(
            'Checking for non existing wanted items in wanted_items database')
        for item in old_wanted_items:
            if item not in new_wanted_items:
                db.delete_wanted_item(item)
                log.debug('Deleted non existing wanted item: %s',
                          item['videopath'])

        # Populate WANTEDQUEUE with all items from wanted_items database
        log.info('Listing videos with missing subtitles:')
        autosubliminal.WANTEDQUEUE = []
        for item in db.get_wanted_items():
            log.info('%s %s', item['videopath'], item['languages'])
            autosubliminal.WANTEDQUEUE.append(item)

        # Release wanted queue lock
        log.info('Finished round of local disk checking')
        utils.release_wanted_queue_lock()

        # Send home page reload event
        utils.add_event_message('HOME_PAGE_RELOAD')

        return True
示例#33
0
def search_subtitle(wanted_item_index, lang):
    log.info("Searching for an individual subtitle")
    subs = []

    # Get wanted queue lock
    if not utils.get_wanted_queue_lock():
        return subs, "Skipping! Cannot get a wanted queue lock because another threat is using the queues!"

    # Get wanted_item
    wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)]

    # Scan wanted_item for video
    video = _scan_wanted_item_for_video(wanted_item)
    if video:
        # Search the subtitles with the default minimal score (to get all the possibilities to select from)
        subtitles, language, single = _search_subtitles(video, lang, False)
        # Check if subtitles are found for the video
        if subtitles[video]:
            # Add found subtitles to wanted_item
            wanted_item['found_subtitles'] = {
                'subtitles': subtitles,
                'language': language,
                'single': single
            }
            # Order subtitles by score and create new dict
            # Use subliminal scoring (scores=None)
            for index, subtitle, score in sorted([
                (index, s,
                 subliminal.compute_score(s.get_matches(
                     video, hearing_impaired=utils.include_hearing_impaired()),
                                          video,
                                          scores=None))
                    for index, s in enumerate(subtitles[video])
            ],
                                                 key=operator.itemgetter(2),
                                                 reverse=True):
                # Only add subtitle when content is found
                if subtitle.content:
                    # Create new sub dict for showing result
                    sub = {
                        'subtitle_index': index,
                        'score': score,
                        'provider_name': subtitle.provider_name,
                        'content': subtitle.content,
                        'language': language,
                        'single': single,
                        'page_link': subtitle.page_link,
                        'releases': _get_releases(subtitle),
                        'wanted_item_index': wanted_item_index,
                        'playvideo_url': _construct_playvideo_url(wanted_item)
                    }
                    # Get content preview (the first 28 lines and last 30 lines of the subtitle)
                    content_split = subtitle.content.splitlines(False)
                    if len(content_split) < 58:
                        content_preview = "This seems to be an invalid subtitle."
                        content_preview += "<br> It has less than 58 lines to preview."
                    else:
                        try:
                            # First 28 lines
                            content_preview = "<br>".join(
                                x.replace('"', "'")
                                for x in content_split[:28])
                            # Separator
                            content_preview += "<br>"
                            content_preview += "<br>"
                            content_preview += "..."
                            content_preview += "<br>"
                            content_preview += "<br>"
                            # Last 30 lines
                            content_preview += "<br>".join(
                                x.replace('"', "'")
                                for x in content_split[len(content_split) -
                                                       30:])
                        except:
                            content_preview = "Problem with parsing the first 28 and/or last 30 lines of the file."
                    sub['content_preview'] = content_preview
                    subs.append(sub)

    # Release wanted queue lock
    utils.release_wanted_queue_lock()

    if not len(subs):
        return subs, "No subtitles could be found or downloaded!"

    return subs, None
示例#34
0
    def run(self, force_run):
        # Get wanted queue lock
        if not utils.get_wanted_queue_lock():
            return False

        # Wait for internet connection
        utils.wait_for_internet_connection()

        log.info('Starting round of subtitle checking')
        to_delete_wanted_queue = []

        # Show info message (only when run was forced manually)
        if force_run:
            utils.add_notification_message('Checking subtitles...')

        # Setup provider pool
        provider_pool = _get_provider_pool()
        if provider_pool:
            log.info('Searching subtitles with providers: %s',
                     ', '.join(provider_pool.providers))

            # Process all items in wanted queue
            db = WantedItems()
            for index, wanted_item in enumerate(autosubliminal.WANTEDQUEUE):
                log.info('Searching subtitles for video: %s',
                         wanted_item['videopath'])

                # Check if the search is currently active for the wanted_item
                if not WantedItem(wanted_item).search_active:
                    log.info('Search not active in this run for video: %s',
                             wanted_item['videopath'])
                    continue

                # Scan wanted_item for video, skip when no video could be determined
                video = _scan_wanted_item_for_video(wanted_item)
                if not video:
                    continue

                # Clear discarded providers for each new wanted_item
                provider_pool.discarded_providers.clear()

                # Check subtitles for each language
                languages = wanted_item['languages']
                for lang in languages[:]:
                    # Search the best subtitle with the minimal score
                    try:
                        subtitles, language, single = _search_subtitles(
                            video, lang, True, provider_pool)
                    except Exception:
                        log.exception(
                            'Error while searching subtitles for video %r',
                            wanted_item['videopath'])
                        continue

                    # Subtitle is found for the video
                    if subtitles:
                        # Handle download
                        download_item = _construct_download_item(
                            wanted_item, subtitles, language, single)
                        SubDownloader(download_item).run()

                        # Remove downloaded language from wanted languages
                        languages.remove(lang)

                        # Update wanted item if there are still wanted languages
                        if len(languages) > 0:
                            db.update_wanted_item(wanted_item)

                        # Mark wanted item as deleted if there are no more wanted languages
                        else:
                            to_delete_wanted_queue.append(index)

            # Cleanup wanted item(s)
            i = len(to_delete_wanted_queue) - 1
            while i >= 0:
                wanted_item_to_delete = autosubliminal.WANTEDQUEUE.pop(
                    to_delete_wanted_queue[i])
                log.debug('Removed item from the wanted queue at index %s',
                          to_delete_wanted_queue[i])
                db.delete_wanted_item(wanted_item_to_delete)
                log.debug('Removed %s from wanted_items database',
                          wanted_item_to_delete['videopath'])
                i -= 1

        else:
            log.info('No subliminal providers configured, skipping')

        # Release wanted queue lock
        log.info('Finished round of subtitle checking')
        utils.release_wanted_queue_lock()

        # Send home page reload event
        utils.add_event_message('HOME_PAGE_RELOAD')

        return True