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
def skip_show(wanted_item_index, season): log.info('Skipping a show') # Get wanted queue lock if not 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]) WantedItemsDb().delete_wanted_item(wanted_item_to_delete) i -= 1 log.info('Skipped show %s season %s', show, season) # Release wanted queue lock release_wanted_queue_lock() return True
def save_subtitle(wanted_item_index, subtitle_index): log.info('Saving an individual subtitle') # Get wanted queue lock if not 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 wanted subtitle wanted_subtitle = _get_wanted_subtitle(subtitles, subtitle_index) # Save subtitle (skip notify and post_process) download_item = _construct_download_item(wanted_item, [wanted_subtitle], language, single) downloaded = SubDownloader(download_item).save() # Release wanted queue lock release_wanted_queue_lock() return downloaded
def post_process_no_subtitle(wanted_item_index): log.info('Post processing without subtitle') # Get wanted queue lock if not 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)) WantedItemsDb().delete_wanted_item(wanted_item) log.debug('Removed %s from wanted_items database', wanted_item.videopath) else: send_websocket_notification('Unable to handle post processing! Please check the log file!', type='error') # Release wanted queue lock release_wanted_queue_lock() return processed
def delete_video(wanted_item_index, cleanup): log.info('Deleting an individual video file') # Get wanted queue lock if not 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)) WantedItemsDb().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=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 release_wanted_queue_lock() return deleted
def flush_wanted_items(self): if get_wanted_queue_lock(): # Flush db and wanted queue WantedItemsDb().flush_wanted_items() autosubliminal.WANTEDQUEUE = [] release_wanted_queue_lock() send_websocket_notification( 'Flushed wanted items database. Please launch \'Scan Disk\' from the \'System\' menu.') else: send_websocket_notification('Cannot flush wanted items database when wanted queue is in use!', type='notice') redirect('/home')
def update(self, force_update=False): log.info('Updating version') # Only get lock for force run because when called from run, we already have a queue lock if force_update and not get_wanted_queue_lock(): return # Update version self.manager.update_version() # Release wanted queue lock if force_update: release_wanted_queue_lock()
def update(self, force_update=False): log.info('Updating version') # Only get lock for force run because when called from run, we already have a queue lock if force_update and not get_wanted_queue_lock(): return # Update version self.manager.update_version() # Release wanted queue lock if force_update: release_wanted_queue_lock()
def post_process(wanted_item_index, subtitle_index): log.info('Post processing an individual subtitle') # Get wanted queue lock if not 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: WantedItemsDb().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)) WantedItemsDb().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 release_wanted_queue_lock() return processed
def update_wanted_item(self, wanted_item_index, **kwargs): if get_wanted_queue_lock(): # Get wanted item and update all keys that are passed wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)] for key in kwargs: wanted_item.set_attr(key, kwargs[key]) # Release wanted queue lock release_wanted_queue_lock() # Only return updatable fields # These values will be shown in the view through jquery, so apply the display_value() on it! return { 'displaytitle': display_item_title(wanted_item), 'title': display_value(wanted_item.title), 'year': display_value(wanted_item.year), 'season': display_value(wanted_item.season), 'episode': display_value(wanted_item.episode), 'source': display_value(wanted_item.source, default_value='N/A', uppercase=True), 'quality': display_value(wanted_item.quality, default_value='N/A', uppercase=True), 'codec': display_value(wanted_item.codec, default_value='N/A', uppercase=True), 'releasegrp': display_value(wanted_item.releasegrp, default_value='N/A', uppercase=True) } # Show notification if wanted queue is in use send_websocket_notification( 'Cannot update wanted item when wanted queue is in use!', type='notice')
def skip_movie(wanted_item_index): log.info('Skipping a movie') # Get wanted queue lock if not get_wanted_queue_lock(): return False # Remove wanted item from queue and db wanted_item = autosubliminal.WANTEDQUEUE.pop(int(wanted_item_index)) WantedItemsDb().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 release_wanted_queue_lock() return True
def force_id_search(wanted_item_index): log.info('Force id search') # Get wanted queue lock if not 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.is_episode: wanted_item.tvdbid = autosubliminal.SHOWINDEXER.get_tvdb_id(title, year, force_search=True) WantedItemsDb().update_wanted_item(wanted_item) elif wanted_item.is_movie: wanted_item.imdbid, wanted_item.year = autosubliminal.MOVIEINDEXER.get_imdb_id_and_year(title, year, force_search=True) WantedItemsDb().update_wanted_item(wanted_item) # Release wanted queue lock release_wanted_queue_lock()
def reset_wanted_item(self, wanted_item_index, **kwargs): if get_wanted_queue_lock(): # Get wanted item and reset values wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)] wanted_item_db = WantedItemsDb().get_wanted_item( wanted_item.videopath) wanted_item_db.copy_to(wanted_item) # Release wanted queue lock release_wanted_queue_lock() # Only return updatable fields # These values represent the original values, so apply default display_value() on it! return { 'displaytitle': display_item_title(wanted_item), 'title': display_value(wanted_item.title), 'year': display_value(wanted_item.year), 'season': display_value(wanted_item.season), 'episode': display_value(wanted_item.episode), 'source': display_value(wanted_item.source, default_value='N/A'), 'quality': display_value(wanted_item.quality, default_value='N/A'), 'codec': display_value(wanted_item.codec, default_value='N/A'), 'releasegrp': display_value(wanted_item.releasegrp, default_value='N/A') } # Show notification if wanted queue is in use send_websocket_notification( 'Cannot reset wanted item when wanted queue is in use!', type='notice')
def delete_subtitle(wanted_item_index): log.info('Deleting an individual subtitle') # Get wanted queue lock if not 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 release_wanted_queue_lock() return deleted
def _run_process(self, current_time): # Check if the run needs a lock run_lock = self.process.force_run_lock if self._force_run else self.process.run_lock # Delay process if lock cannot be acquired if run_lock and not get_wanted_queue_lock(): # Increase delay with 1 second each time the process cannot yet run self._delay += 1 return try: # Mark as running self.process.running = True send_websocket_event(PROCESS_STARTED, data=self.to_json()) log.debug('Running %s thread process', self.name) self.process.run(self._force_run) # Update process properties after process run self.last_run = current_time self._delay = 0 if self._force_run: self._force_run = False # Mark as finished self.process.running = False send_websocket_event(PROCESS_FINISHED, data=self.to_json()) except: print(traceback.format_exc()) self.process.running = False os._exit(1) finally: # Release lock if needed if run_lock: release_wanted_queue_lock()
def _run_process(self, current_time): # Check if the run needs a lock run_lock = self.process.force_run_lock if self._force_run else self.process.run_lock # Delay process if lock cannot be acquired if run_lock and not get_wanted_queue_lock(): # Increase delay with 1 second each time the process cannot yet run self._delay += 1 return try: # Mark as running self.process.running = True send_websocket_event(PROCESS_STARTED, data=self.to_json()) log.debug('Running %s thread process', self.name) self.process.run(self._force_run) # Update process properties after process run self.last_run = current_time self._delay = 0 if self._force_run: self._force_run = False # Mark as finished self.process.running = False send_websocket_event(PROCESS_FINISHED, data=self.to_json()) except: print(traceback.format_exc()) self.process.running = False os._exit(1) finally: # Release lock if needed if run_lock: release_wanted_queue_lock()
def reset_wanted_item(self, wanted_item_index, **kwargs): if get_wanted_queue_lock(): # Get wanted item and reset values wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)] wanted_item_db = WantedItemsDb().get_wanted_item(wanted_item.videopath) wanted_item_db.copy_to(wanted_item) # Release wanted queue lock release_wanted_queue_lock() # Only return updatable fields # These values represent the original values, so apply default display_value() on it! return {'displaytitle': display_item_title(wanted_item), 'title': display_value(wanted_item.title), 'year': display_value(wanted_item.year), 'season': display_value(wanted_item.season), 'episode': display_value(wanted_item.episode), 'source': display_value(wanted_item.source, default_value='N/A'), 'quality': display_value(wanted_item.quality, default_value='N/A'), 'codec': display_value(wanted_item.codec, default_value='N/A'), 'releasegrp': display_value(wanted_item.releasegrp, default_value='N/A')} # Show notification if wanted queue is in use send_websocket_notification('Cannot reset wanted item when wanted queue is in use!', type='notice')
def update_wanted_item(self, wanted_item_index, **kwargs): if get_wanted_queue_lock(): # Get wanted item and update all keys that are passed wanted_item = autosubliminal.WANTEDQUEUE[int(wanted_item_index)] for key in kwargs: wanted_item.set_attr(key, kwargs[key]) # Release wanted queue lock release_wanted_queue_lock() # Only return updatable fields # These values will be shown in the view through jquery, so apply the display_value() on it! return {'displaytitle': display_item_title(wanted_item), 'title': display_value(wanted_item.title), 'year': display_value(wanted_item.year), 'season': display_value(wanted_item.season), 'episode': display_value(wanted_item.episode), 'source': display_value(wanted_item.source, default_value='N/A', uppercase=True), 'quality': display_value(wanted_item.quality, default_value='N/A', uppercase=True), 'codec': display_value(wanted_item.codec, default_value='N/A', uppercase=True), 'releasegrp': display_value(wanted_item.releasegrp, default_value='N/A', uppercase=True)} # Show notification if wanted queue is in use send_websocket_notification('Cannot update wanted item when wanted queue is in use!', type='notice')
def test_function(): get_wanted_queue_lock() assert autosubliminal.WANTEDQUEUELOCK raise Exception('unexpected')
def search_subtitle(wanted_item_index, lang): log.info('Searching for an individual subtitle') subs = [] # Get wanted queue lock if not 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, is_manual=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, is_manual=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 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