def list_subtitles(self, rating_key, item_type, part_id, language): metadata = get_plex_metadata(rating_key, part_id, item_type) if item_type == "episode": min_score = 66 else: min_score = 23 scanned_parts = scan_videos( [metadata], kind="series" if item_type == "episode" else "movie", ignore_all=True) if not scanned_parts: Log.Error("Couldn't list available subtitles for %s", rating_key) return video, plex_part = scanned_parts.items()[0] config.init_subliminal_patches() available_subs = list_all_subtitles( scanned_parts, {Language.fromietf(language)}, providers=config.providers, provider_configs=config.provider_settings) use_hearing_impaired = Prefs['subtitles.search.hearingImpaired'] in ( "prefer", "force HI") # sort subtitles by score unsorted_subtitles = [] for s in available_subs[video]: Log.Debug("Starting score computation for %s", s) try: matches = s.get_matches(video, hearing_impaired=use_hearing_impaired) except AttributeError: Log.Error("Match computation failed for %s: %s", s, traceback.format_exc()) continue unsorted_subtitles.append((s, compute_score(matches, video), matches)) scored_subtitles = sorted(unsorted_subtitles, key=operator.itemgetter(1), reverse=True) subtitles = [] for subtitle, score, matches in scored_subtitles: # check score if score < min_score: Log.Info('Score %d is below min_score (%d)', score, min_score) continue subtitle.score = score subtitle.matches = matches subtitle.part_id = part_id subtitle.item_type = item_type subtitles.append(subtitle) return subtitles
def update(self, metadata, media, lang): Log.Debug("Sub-Zero %s, %s update called" % (config.version, self.agent_type)) intent = get_intent() if not media: Log.Error( "Called with empty media, something is really wrong with your setup!" ) return item_ids = [] try: config.init_subliminal_patches() videos = media_to_videos(media, kind=self.agent_type) # find local media update_local_media(metadata, media, media_type=self.agent_type) # media ignored? use_any_parts = False for video in videos: if is_ignored(video["id"]): Log.Debug(u"Ignoring %s" % video) continue use_any_parts = True if not use_any_parts: Log.Debug(u"Nothing to do.") return try: use_score = int(Prefs[self.score_prefs_key].strip()) except ValueError: Log.Error( "Please only put numbers into the scores setting. Exiting") return set_refresh_menu_state(media, media_type=self.agent_type) # scanned_video_part_map = {subliminal.Video: plex_part, ...} scanned_video_part_map = scan_videos(videos, kind=self.agent_type) downloaded_subtitles = None if not config.enable_agent: Log.Debug("Skipping Sub-Zero agent(s)") else: # downloaded_subtitles = {subliminal.Video: [subtitle, subtitle, ...]} downloaded_subtitles = download_best_subtitles( scanned_video_part_map, min_score=use_score) item_ids = get_media_item_ids(media, kind=self.agent_type) downloaded_any = False if downloaded_subtitles: downloaded_any = any(downloaded_subtitles.values()) if downloaded_any: save_subtitles(scanned_video_part_map, downloaded_subtitles, mods=config.default_mods) track_usage("Subtitle", "refreshed", "download", 1) for video, video_subtitles in downloaded_subtitles.items(): # store item(s) in history for subtitle in video_subtitles: item_title = get_title_for_video_metadata( video.plexapi_metadata, add_section_title=False) history = get_history() history.add( item_title, video.id, section_title=video.plexapi_metadata["section"], subtitle=subtitle) else: # store subtitle info even if we've downloaded none store_subtitle_info( scanned_video_part_map, dict((k, []) for k in scanned_video_part_map.keys()), None, mode="a") update_local_media(metadata, media, media_type=self.agent_type) finally: # update the menu state set_refresh_menu_state(None) # notify any running tasks about our finished update for item_id in item_ids: #scheduler.signal("updated_metadata", item_id) # resolve existing intent for that id intent.resolve("force", item_id) Dict.Save()
def run(self): super(SearchAllRecentlyAddedMissing, self).run() self.running = True self.prepare() from support.history import get_history history = get_history() now = datetime.datetime.now() min_score_series = int( Prefs["subtitles.search.minimumTVScore2"].strip()) min_score_movies = int( Prefs["subtitles.search.minimumMovieScore2"].strip()) series_providers = config.get_providers(media_type="series") movie_providers = config.get_providers(media_type="movies") is_recent_str = Prefs["scheduler.item_is_recent_age"] num, ident = is_recent_str.split() max_search_days = 0 if ident == "days": max_search_days = int(num) elif ident == "weeks": max_search_days = int(num) * 7 subtitle_storage = get_subtitle_storage() recent_files = subtitle_storage.get_recent_files( age_days=max_search_days) self.items_searching = len(recent_files) download_count = 0 videos_with_downloads = 0 config.init_subliminal_patches() Log.Info(u"%s: Searching for subtitles for %s items", self.name, self.items_searching) def skip_item(): self.items_searching = self.items_searching - 1 self.percentage = int( self.items_done * 100 / self.items_searching) if self.items_searching > 0 else 100 # search for subtitles in viable items try: for fn in recent_files: stored_subs = subtitle_storage.load(filename=fn) if not stored_subs: Log.Debug("Skipping item %s because storage is empty", fn) skip_item() continue video_id = stored_subs.video_id # added_date <= max_search_days? if stored_subs.added_at + datetime.timedelta( days=max_search_days) <= now: Log.Debug("Skipping item %s because it's too old", video_id) skip_item() continue if stored_subs.item_type == "episode": min_score = min_score_series providers = series_providers else: min_score = min_score_movies providers = movie_providers parts = [] plex_item = get_item(video_id) if not plex_item: Log.Info(u"%s: Item %s unknown, skipping", self.name, video_id) skip_item() continue if not is_wanted(video_id, item=plex_item): skip_item() continue for media in plex_item.media: parts += media.parts downloads_per_video = 0 hit_providers = False for part in parts: part_id = part.id try: metadata = get_plex_metadata(video_id, part_id, stored_subs.item_type) except PartUnknownException: Log.Info(u"%s: Part %s:%s unknown, skipping", self.name, video_id, part_id) continue if not metadata: Log.Info(u"%s: Part %s:%s unknown, skipping", self.name, video_id, part_id) continue Log.Debug(u"%s: Looking for missing subtitles: %s", self.name, get_item_title(plex_item)) scanned_parts = scan_videos([metadata], providers=providers) downloaded_subtitles = download_best_subtitles( scanned_parts, min_score=min_score, providers=providers) hit_providers = downloaded_subtitles is not None download_successful = False if downloaded_subtitles: downloaded_any = any(downloaded_subtitles.values()) if not downloaded_any: continue try: save_subtitles(scanned_parts, downloaded_subtitles, mode="a", mods=config.default_mods) Log.Debug( u"%s: Downloaded subtitle for item with missing subs: %s", self.name, video_id) download_successful = True refresh_item(video_id) track_usage("Subtitle", "manual", "download", 1) except: Log.Error( u"%s: Something went wrong when downloading specific subtitle: %s", self.name, traceback.format_exc()) finally: scanned_parts = None try: item_title = get_title_for_video_metadata( metadata, add_section_title=False) if download_successful: # store item in history for video, video_subtitles in downloaded_subtitles.items( ): if not video_subtitles: continue for subtitle in video_subtitles: downloads_per_video += 1 history.add( item_title, video.id, section_title=metadata[ "section"], thumb=video.plexapi_metadata[ "super_thumb"], subtitle=subtitle, mode="a") downloaded_subtitles = None except: Log.Error(u"%s: DEBUG HIT: %s", self.name, traceback.format_exc()) Log.Debug(u"%s: Waiting %s seconds before continuing", self.name, self.PROVIDER_SLACK) Thread.Sleep(self.PROVIDER_SLACK) download_count += downloads_per_video if downloads_per_video: videos_with_downloads += 1 self.items_done = self.items_done + 1 self.percentage = int( self.items_done * 100 / self.items_searching) if self.items_searching > 0 else 100 stored_subs = None if downloads_per_video: Log.Debug( u"%s: Subtitles have been downloaded, " u"waiting %s seconds before continuing", self.name, self.DL_PROVIDER_SLACK) Thread.Sleep(self.DL_PROVIDER_SLACK) else: if hit_providers: Log.Debug(u"%s: Waiting %s seconds before continuing", self.name, self.PROVIDER_SLACK) Thread.Sleep(self.PROVIDER_SLACK) finally: subtitle_storage.destroy() history.destroy() if download_count: Log.Debug( u"%s: done. Missing subtitles found for %s/%s items (%s subs downloaded)", self.name, videos_with_downloads, self.items_searching, download_count) else: Log.Debug(u"%s: done. No subtitles found for %s items", self.name, self.items_searching)
def list_subtitles(self, rating_key, item_type, part_id, language, skip_wrong_fps=True, metadata=None, scanned_parts=None, air_date_cutoff=None): if not metadata: metadata = get_plex_metadata(rating_key, part_id, item_type) if not metadata: return providers = config.get_providers( media_type="series" if item_type == "episode" else "movies") if not scanned_parts: scanned_parts = scan_videos([metadata], ignore_all=True, providers=providers) if not scanned_parts: Log.Error(u"%s: Couldn't list available subtitles for %s", self.name, rating_key) return video, plex_part = scanned_parts.items()[0] refine_video(video, refiner_settings=config.refiner_settings) if air_date_cutoff is not None and metadata["item"].year and \ metadata["item"].year + air_date_cutoff < datetime.date.today().year: Log.Debug( "Skipping searching for subtitles: %s, it aired over %s year(s) ago.", rating_key, air_date_cutoff) return config.init_subliminal_patches() provider_settings = config.provider_settings if not skip_wrong_fps: provider_settings["opensubtitles"]["skip_wrong_fps"] = False if item_type == "episode": min_score = 240 if video.is_special: min_score = 180 else: min_score = 60 languages = {Language.fromietf(language)} available_subs = list_all_subtitles( [video], languages, providers=providers, provider_configs=provider_settings, pool_class=config.provider_pool, throttle_callback=config.provider_throttle, language_hook=language_hook) use_hearing_impaired = Prefs['subtitles.search.hearingImpaired'] in ( "prefer", "force HI") # sort subtitles by score unsorted_subtitles = [] for s in available_subs[video]: Log.Debug(u"%s: Starting score computation for %s", self.name, s) try: matches = s.get_matches(video) except AttributeError: Log.Error(u"%s: Match computation failed for %s: %s", self.name, s, traceback.format_exc()) continue # skip wrong season/episodes if item_type == "episode": can_verify_series = True if not s.hash_verifiable and "hash" in matches: can_verify_series = False if can_verify_series and not {"series", "season", "episode" }.issubset(matches): if "series" not in matches: s.wrong_series = True else: s.wrong_season_ep = True unsorted_subtitles.append( (s, compute_score(matches, s, video, hearing_impaired=use_hearing_impaired), matches)) scored_subtitles = sorted(unsorted_subtitles, key=operator.itemgetter(1), reverse=True) subtitles = [] for subtitle, score, matches in scored_subtitles: # check score if score < min_score and not subtitle.wrong_series: Log.Info(u'%s: Score %d is below min_score (%d)', self.name, score, min_score) continue subtitle.score = score subtitle.matches = matches subtitle.part_id = part_id subtitle.item_type = item_type subtitles.append(subtitle) return subtitles
def update(self, metadata, media, lang): if not config.enable_agent: Log.Debug("Skipping Sub-Zero agent(s)") return Log.Debug("Sub-Zero %s, %s update called" % (config.version, self.agent_type)) intent = get_intent() if not media: Log.Error( "Called with empty media, something is really wrong with your setup!" ) return item_ids = [] try: config.init_subliminal_patches() videos = media_to_videos(media, kind=self.agent_type) # find local media update_local_media(metadata, media, media_type=self.agent_type) # media ignored? use_any_parts = False for video in videos: if is_ignored(video["id"]): Log.Debug(u"Ignoring %s" % video) continue use_any_parts = True if not use_any_parts: Log.Debug(u"Nothing to do.") return try: use_score = int(Prefs[self.score_prefs_key].strip()) except ValueError: Log.Error( "Please only put numbers into the scores setting. Exiting") return set_refresh_menu_state(media, media_type=self.agent_type) # scanned_video_part_map = {subliminal.Video: plex_part, ...} providers = config.get_providers(media_type=self.agent_type) try: scanned_video_part_map = scan_videos(videos, providers=providers) except IOError, e: Log.Exception( "Permission error, please check your folder/file permissions. Exiting." ) if cast_bool(Prefs["check_permissions"]): config.permissions_ok = False config.missing_permissions = e.message return # auto extract embedded if config.embedded_auto_extract: if config.plex_transcoder: agent_extract_embedded(scanned_video_part_map) else: Log.Warning( "Plex Transcoder not found, can't auto extract") # clear missing subtitles menu data if not scheduler.is_task_running("MissingSubtitles"): scheduler.clear_task_data("MissingSubtitles") downloaded_subtitles = None # debounce for self.debounce seconds now = datetime.datetime.now() if "last_call" in Dict: last_call = Dict["last_call"] if last_call + datetime.timedelta(seconds=self.debounce) > now: wait = self.debounce - (now - last_call).seconds if wait >= 1: Log.Debug("Waiting %s seconds until continuing", wait) Thread.Sleep(wait) # downloaded_subtitles = {subliminal.Video: [subtitle, subtitle, ...]} try: downloaded_subtitles = download_best_subtitles( scanned_video_part_map, min_score=use_score, throttle_time=self.debounce, providers=providers) except: Log.Exception( "Something went wrong when downloading subtitles") if downloaded_subtitles is not None: Dict["last_call"] = datetime.datetime.now() item_ids = get_media_item_ids(media, kind=self.agent_type) downloaded_any = False if downloaded_subtitles: downloaded_any = any(downloaded_subtitles.values()) if downloaded_any: save_successful = False try: save_successful = save_subtitles(scanned_video_part_map, downloaded_subtitles, mods=config.default_mods) except: Log.Exception("Something went wrong when saving subtitles") track_usage("Subtitle", "refreshed", "download", 1) # store SZ meta info even if download wasn't successful if not save_successful: self.store_blank_subtitle_metadata(scanned_video_part_map) else: for video, video_subtitles in downloaded_subtitles.items(): # store item(s) in history for subtitle in video_subtitles: item_title = get_title_for_video_metadata( video.plexapi_metadata, add_section_title=False) history = get_history() history.add(item_title, video.id, section_title=video. plexapi_metadata["section"], subtitle=subtitle) history.destroy() else: # store SZ meta info even if we've downloaded none self.store_blank_subtitle_metadata(scanned_video_part_map) update_local_media(metadata, media, media_type=self.agent_type)
def list_subtitles(self, rating_key, item_type, part_id, language, skip_wrong_fps=True, metadata=None, scanned_parts=None): if not metadata: metadata = get_plex_metadata(rating_key, part_id, item_type) if not metadata: return if not scanned_parts: scanned_parts = scan_videos( [metadata], kind="series" if item_type == "episode" else "movie", ignore_all=True) if not scanned_parts: Log.Error(u"%s: Couldn't list available subtitles for %s", self.name, rating_key) return video, plex_part = scanned_parts.items()[0] config.init_subliminal_patches() provider_settings = config.provider_settings.copy() if not skip_wrong_fps: provider_settings = config.provider_settings.copy() provider_settings["opensubtitles"]["skip_wrong_fps"] = False if item_type == "episode": min_score = 240 if video.is_special: min_score = 180 else: min_score = 60 languages = {Language.fromietf(language)} available_subs = list_all_subtitles(scanned_parts, languages, providers=config.providers, provider_configs=provider_settings, pool_class=config.provider_pool) use_hearing_impaired = Prefs['subtitles.search.hearingImpaired'] in ( "prefer", "force HI") # sort subtitles by score unsorted_subtitles = [] for s in available_subs[video]: Log.Debug(u"%s: Starting score computation for %s", self.name, s) try: matches = s.get_matches(video) except AttributeError: Log.Error(u"%s: Match computation failed for %s: %s", self.name, s, traceback.format_exc()) continue unsorted_subtitles.append( (s, compute_score(matches, s, video, hearing_impaired=use_hearing_impaired), matches)) scored_subtitles = sorted(unsorted_subtitles, key=operator.itemgetter(1), reverse=True) subtitles = [] for subtitle, score, matches in scored_subtitles: # check score if score < min_score: Log.Info(u'%s: Score %d is below min_score (%d)', self.name, score, min_score) continue subtitle.score = score subtitle.matches = matches subtitle.part_id = part_id subtitle.item_type = item_type subtitles.append(subtitle) return subtitles