def RecentlyPlayedMenu(): base_title = _("Recently Played") oc = SubFolderObjectContainer(title2=base_title, replace_parent=True) for item in [ get_item(rating_key) for rating_key in Dict["last_played_items"] ]: if not item: continue if getattr(getattr(item, "__class__"), "__name__") not in ("Episode", "Movie"): continue item_title = get_item_title(item) oc.add( DirectoryObject(thumb=get_item_thumb(item) or default_thumb, title=item_title, key=Callback(ItemDetailsMenu, title=base_title + " > " + item.title, item_title=item.title, rating_key=item.rating_key))) return oc
def SelectStoredSubForItemMenu(**kwargs): rating_key = kwargs["rating_key"] part_id = kwargs["part_id"] language = Language.fromietf(kwargs["language"]) item_type = kwargs["item_type"] sub_key = tuple(kwargs.pop("sub_key").split("__")) plex_item = get_item(rating_key) storage = get_subtitle_storage() stored_subs = storage.load(plex_item.rating_key) subtitles = stored_subs.get_all(part_id, language) subtitle = subtitles[sub_key] save_stored_sub(subtitle, rating_key, part_id, language, item_type, plex_item=plex_item, storage=storage, stored_subs=stored_subs) stored_subs.set_current(part_id, language, sub_key) storage.save(stored_subs) storage.destroy() kwa = { "header": _("Success"), "message": _("Subtitle saved to disk"), "title": kwargs["title"], "item_title": kwargs["item_title"], "base_title": kwargs.get("base_title") } # fixme: return to SubtitleOptionsMenu properly? (needs recomputation of current_data return ItemDetailsMenu(rating_key, randomize=timestamp(), **kwa)
def season_extract_embedded(rating_key, requested_language, with_mods=False, force=False): # get stored subtitle info for item id subtitle_storage = get_subtitle_storage() try: for data in get_all_items(key="children", value=rating_key, base="library/metadata"): item = get_item(data[MI_KEY]) if item: stored_subs = subtitle_storage.load_or_new(item) for part in get_all_parts(item): embedded_subs = stored_subs.get_by_provider(part.id, requested_language, "embedded") current = stored_subs.get_any(part.id, requested_language) if not embedded_subs or force: stream_data = get_embedded_subtitle_streams(part, requested_language=requested_language, get_forced=config.forced_only) if stream_data: stream = stream_data[0]["stream"] set_current = not current or force refresh = not current extract_embedded_sub(rating_key=item.rating_key, part_id=part.id, stream_index=str(stream.index), set_current=set_current, refresh=refresh, language=requested_language, with_mods=with_mods) finally: subtitle_storage.destroy()
def store_subtitle_info(scanned_video_part_map, downloaded_subtitles, storage_type, mode="a"): """ stores information about downloaded subtitles in plex's Dict() """ for video, video_subtitles in downloaded_subtitles.items(): part = scanned_video_part_map[video] part_id = str(part.id) video_id = str(video.id) plex_item = get_item(video_id) metadata = video.plexapi_metadata title = get_title_for_video_metadata(metadata) subtitle_storage = get_subtitle_storage() stored_subs = subtitle_storage.load_or_new(plex_item) for subtitle in video_subtitles: lang = str(subtitle.language) subtitle.normalize() Log.Debug(u"Adding subtitle to storage: %s, %s, %s, %s, %s" % (video_id, part_id, lang, title, subtitle.guess_encoding())) ret_val = stored_subs.add(part_id, lang, subtitle, storage_type, mode=mode) if ret_val: Log.Debug("Subtitle stored") else: Log.Debug("Subtitle already existing in storage") Log.Debug("Saving subtitle storage for %s" % video_id) subtitle_storage.save(stored_subs) subtitle_storage.destroy()
def RecentlyPlayedMenu(): base_title = "Recently Played" oc = SubFolderObjectContainer(title2=base_title, replace_parent=True) for item in [get_item(rating_key) for rating_key in Dict["last_played_items"]]: if not item: continue kind = get_item_kind_from_item(item) if kind not in ("episode", "movie"): continue if kind == "episode": item_title = get_plex_item_display_title(item, "show", parent=item.season, section_title=None, parent_title=item.show.title) else: item_title = get_plex_item_display_title(item, kind, section_title=None) oc.add(DirectoryObject( title=item_title, key=Callback(ItemDetailsMenu, title=base_title + " > " + item.title, item_title=item.title, rating_key=item.rating_key) )) return oc
def ItemDetailsMenu(rating_key, title=None, base_title=None, item_title=None, randomize=None): """ displays the item details menu of an item that doesn't contain any deeper tree, such as a movie or an episode :param rating_key: :param title: :param base_title: :param item_title: :param randomize: :return: """ title = unicode(base_title) + " > " + unicode(title) if base_title else unicode(title) item = get_item(rating_key) oc = ObjectContainer(title2=title, replace_parent=True) oc.add(DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=item_title, randomize=timestamp()), title=u"Refresh: %s" % item_title, summary="Refreshes the item, possibly picking up new subtitles on disk", thumb=item.thumb or default_thumb )) oc.add(DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=item_title, force=True, randomize=timestamp()), title=u"Force-Refresh: %s" % item_title, summary="Issues a forced refresh, ignoring known subtitles and searching for new ones", thumb=item.thumb or default_thumb )) add_ignore_options(oc, "videos", title=item_title, rating_key=rating_key, callback_menu=IgnoreMenu) return oc
def store_subtitle_info(scanned_video_part_map, downloaded_subtitles, storage_type, mode="a", set_current=True): """ stores information about downloaded subtitles in plex's Dict() """ subtitle_storage = get_subtitle_storage() for video, video_subtitles in downloaded_subtitles.items(): part = scanned_video_part_map[video] part_id = str(part.id) video_id = str(video.id) plex_item = get_item(video_id) if not plex_item: Log.Warn("Plex item not found: %s", video_id) continue metadata = video.plexapi_metadata title = get_title_for_video_metadata(metadata) stored_subs = subtitle_storage.load(video_id) is_new = False if not stored_subs: is_new = True Log.Debug(u"Creating new subtitle storage: %s, %s", video_id, part_id) stored_subs = subtitle_storage.new(plex_item) for subtitle in video_subtitles: lang = str(subtitle.language) subtitle.normalize() Log.Debug( u"Adding subtitle to storage: %s, %s, %s, %s, %s" % (video_id, part_id, lang, title, subtitle.guess_encoding())) last_mod = None if subtitle.storage_path: last_mod = datetime.datetime.fromtimestamp( os.path.getmtime(subtitle.storage_path)) ret_val = stored_subs.add(part_id, lang, subtitle, storage_type, mode=mode, last_mod=last_mod, set_current=set_current) if ret_val: Log.Debug("Subtitle stored") else: Log.Debug("Subtitle already existing in storage") if is_new or video_subtitles: Log.Debug("Saving subtitle storage for %s" % video_id) subtitle_storage.save(stored_subs) subtitle_storage.destroy()
def SelectStoredSubForItemMenu(**kwargs): rating_key = kwargs["rating_key"] part_id = kwargs["part_id"] language = Language.fromietf(kwargs["language"]) item_type = kwargs["item_type"] sub_key = tuple(kwargs.pop("sub_key").split("__")) plex_item = get_item(rating_key) storage = get_subtitle_storage() stored_subs = storage.load(plex_item.rating_key) subtitles = stored_subs.get_all(part_id, language) subtitle = subtitles[sub_key] subtitles["current"] = sub_key save_stored_sub(subtitle, rating_key, part_id, language, item_type, plex_item=plex_item, storage=storage, stored_subs=stored_subs) storage.destroy() kwargs.pop("randomize") kwargs["header"] = 'Success' kwargs["message"] = 'Subtitle saved to disk' return SubtitleOptionsMenu(randomize=timestamp(), **kwargs)
def BlacklistAllPartsSubtitleMenu(**kwargs): rating_key = kwargs.get("rating_key") language = kwargs.get("language") if language: language = Language.fromietf(language) item = get_item(rating_key) if not item: return item_title = get_item_title(item) subtitle_storage = get_subtitle_storage() stored_subs = subtitle_storage.load_or_new(item) for part_id, languages in stored_subs.parts.iteritems(): sub_dict = languages if language: key = str(language) if key not in sub_dict: continue sub_dict = {key: sub_dict[key]} for language, subs in sub_dict.iteritems(): if "current" in subs: stored_subs.blacklist(part_id, language, subs["current"]) Log.Info("Added %s to blacklist", subs["current"]) subtitle_storage.save(stored_subs) subtitle_storage.destroy() return RefreshItem(rating_key=rating_key, item_title=item_title, force=True, randomize=timestamp(), timeout=30000)
def season_extract_embedded(rating_key, requested_language, with_mods=False, force=False): # get stored subtitle info for item id subtitle_storage = get_subtitle_storage() try: for data in get_all_items(key="children", value=rating_key, base="library/metadata"): item = get_item(data[MI_KEY]) if item: stored_subs = subtitle_storage.load_or_new(item) for part in get_all_parts(item): embedded_subs = stored_subs.get_by_provider(part.id, requested_language, "embedded") current = stored_subs.get_any(part.id, requested_language) if not embedded_subs or force: stream_data = get_embedded_subtitle_streams(part, requested_language=requested_language) if stream_data: stream = stream_data[0]["stream"] set_current = not current or force refresh = not current extract_embedded_sub(rating_key=item.rating_key, part_id=part.id, stream_index=str(stream.index), set_current=set_current, refresh=refresh, language=requested_language, with_mods=with_mods, extract_mode="m") finally: subtitle_storage.destroy()
def ListEmbeddedSubsForItemMenu(**kwargs): rating_key = kwargs["rating_key"] part_id = kwargs["part_id"] title = kwargs["title"] kwargs.pop("randomize") oc = SubFolderObjectContainer(title2=title, replace_parent=True) oc.add( DirectoryObject(key=Callback(ItemDetailsMenu, rating_key=kwargs["rating_key"], item_title=kwargs["item_title"], base_title=kwargs["base_title"], title=kwargs["item_title"], randomize=timestamp()), title=u"< Back to %s" % kwargs["title"], thumb=default_thumb)) plex_item = get_item(rating_key) part = get_part(plex_item, part_id) if part: for stream_data in get_embedded_subtitle_streams( part, skip_duplicate_unknown=False): language = stream_data["language"] is_unknown = stream_data["is_unknown"] stream = stream_data["stream"] is_forced = stream_data["is_forced"] if language: oc.add( DirectoryObject( key=Callback(TriggerExtractEmbeddedSubForItemMenu, randomize=timestamp(), stream_index=str(stream.index), language=language, with_mods=True, **kwargs), title=u"Extract stream %s, " u"%s%s%s%s with default mods" % (stream.index, display_language(language), " (unknown)" if is_unknown else "", " (forced)" if is_forced else "", " (\"%s\")" % stream.title if stream.title else ""), )) oc.add( DirectoryObject( key=Callback(TriggerExtractEmbeddedSubForItemMenu, randomize=timestamp(), stream_index=str(stream.index), language=language, **kwargs), title=u"Extract stream %s, %s%s%s%s" % (stream.index, display_language(language), " (unknown)" if is_unknown else "", " (forced)" if is_forced else "", " (\"%s\")" % stream.title if stream.title else ""), )) return oc
def item_discover_missing_subs(rating_key, kind="show", added_at=None, section_title=None, internal=False, external=True, languages=()): item_id = int(rating_key) item = get_item(rating_key) if kind == "show": item_title = get_plex_item_display_title(item, kind, parent=item.season, section_title=section_title, parent_title=item.show.title) else: item_title = get_plex_item_display_title(item, kind, section_title=section_title) missing = set() languages_set = set(languages) for media in item.media: existing_subs = {"internal": [], "external": [], "count": 0} for part in media.parts: for stream in part.streams: if stream.stream_type == 3: if stream.index: key = "internal" else: key = "external" existing_subs[key].append( Locale.Language.Match(stream.language_code or "")) existing_subs["count"] = existing_subs["count"] + 1 missing_from_part = set(languages_set) if existing_subs["count"]: existing_flat = set( (existing_subs["internal"] if internal else []) + (existing_subs["external"] if external else [])) if languages_set.issubset(existing_flat) or ( len(existing_flat) >= 1 and Prefs['subtitles.only_one']): # all subs found #Log.Info(u"All subtitles exist for '%s'", item_title) continue missing_from_part = languages_set - existing_flat if missing_from_part: Log.Info(u"Subs still missing for '%s' (%s: %s): %s", item_title, rating_key, media.id, missing_from_part) missing.update(missing_from_part) if missing: return added_at, item_id, item_title, item, missing
def ListEmbeddedSubsForItemMenu(**kwargs): rating_key = kwargs["rating_key"] part_id = kwargs["part_id"] title = kwargs["title"] kwargs.pop("randomize") oc = SubFolderObjectContainer(title2=title, replace_parent=True) oc.add(DirectoryObject( key=Callback(ItemDetailsMenu, rating_key=kwargs["rating_key"], item_title=kwargs["item_title"], base_title=kwargs["base_title"], title=kwargs["item_title"], randomize=timestamp()), title=_("< Back to %s", kwargs["title"]), thumb=default_thumb )) plex_item = get_item(rating_key) part = get_part(plex_item, part_id) if part: for stream_data in get_embedded_subtitle_streams(part, skip_duplicate_unknown=False): language = stream_data["language"] is_unknown = stream_data["is_unknown"] stream = stream_data["stream"] is_forced = stream_data["is_forced"] if language: oc.add(DirectoryObject( key=Callback(TriggerExtractEmbeddedSubForItemMenu, randomize=timestamp(), stream_index=str(stream.index), language=language, with_mods=True, **kwargs), title=_(u"Extract stream %(stream_index)s, %(language)s%(unknown_state)s%(forced_state)s" u"%(stream_title)s with default mods", stream_index=stream.index, language=display_language(language), unknown_state=_(" (unknown)") if is_unknown else "", forced_state=_(" (forced)") if is_forced else "", stream_title=" (\"%s\")" % stream.title if stream.title else ""), )) oc.add(DirectoryObject( key=Callback(TriggerExtractEmbeddedSubForItemMenu, randomize=timestamp(), stream_index=str(stream.index), language=language, **kwargs), title=_(u"Extract stream %(stream_index)s, %(language)s%(unknown_state)s%(forced_state)s" u"%(stream_title)s", stream_index=stream.index, language=display_language(language), unknown_state=_(" (unknown)") if is_unknown else "", forced_state=_(" (forced)") if is_forced else "", stream_title=" (\"%s\")" % stream.title if stream.title else ""), )) return oc
def store_subtitle_info(scanned_video_part_map, downloaded_subtitles, storage_type, mode="a", set_current=True): """ stores information about downloaded subtitles in plex's Dict() """ subtitle_storage = get_subtitle_storage() for video, video_subtitles in downloaded_subtitles.items(): part = scanned_video_part_map[video] part_id = str(part.id) video_id = str(video.id) plex_item = get_item(video_id) if not plex_item: Log.Warn("Plex item not found: %s", video_id) continue metadata = video.plexapi_metadata title = get_title_for_video_metadata(metadata) stored_subs = subtitle_storage.load(video_id) is_new = False if not stored_subs: is_new = True Log.Debug(u"Creating new subtitle storage: %s, %s", video_id, part_id) stored_subs = subtitle_storage.new(plex_item) for subtitle in video_subtitles: lang = str(subtitle.language) subtitle.normalize() Log.Debug(u"Adding subtitle to storage: %s, %s, %s, %s, %s" % (video_id, part_id, lang, title, subtitle.guess_encoding())) last_mod = None if subtitle.storage_path: last_mod = datetime.datetime.fromtimestamp(os.path.getmtime(subtitle.storage_path)) ret_val = stored_subs.add(part_id, lang, subtitle, storage_type, mode=mode, last_mod=last_mod, set_current=set_current) if ret_val: Log.Debug("Subtitle stored") else: Log.Debug("Subtitle already existing in storage") if is_new or video_subtitles: Log.Debug("Saving subtitle storage for %s" % video_id) subtitle_storage.save(stored_subs) subtitle_storage.destroy()
def RecentlyPlayedMenu(): base_title = _("Recently Played") oc = SubFolderObjectContainer(title2=base_title, replace_parent=True) for item in [get_item(rating_key) for rating_key in Dict["last_played_items"]]: if not item: continue if getattr(getattr(item, "__class__"), "__name__") not in ("Episode", "Movie"): continue item_title = get_item_title(item) oc.add(DirectoryObject( thumb=get_item_thumb(item) or default_thumb, title=item_title, key=Callback(ItemDetailsMenu, title=base_title + " > " + item.title, item_title=item.title, rating_key=item.rating_key) )) return oc
def MetadataMenu(rating_key, title=None, base_title=None, display_items=False, previous_item_type=None, previous_rating_key=None, randomize=None): """ displays the contents of a section based on whether it has a deeper tree or not (movies->movie (item) list; series->series list) :param rating_key: :param title: :param base_title: :param display_items: :param previous_item_type: :param previous_rating_key: :return: """ title = unicode(title) item_title = title title = base_title + " > " + title oc = SubFolderObjectContainer(title2=title, no_cache=True, no_history=True) current_kind = get_item_kind_from_rating_key(rating_key) if display_items: timeout = 30 # add back to series for season if current_kind == "season": timeout = 360 show = get_item(previous_rating_key) oc.add( DirectoryObject(key=Callback(MetadataMenu, rating_key=show.rating_key, title=show.title, base_title=show.section.title, previous_item_type="section", display_items=True, randomize=timestamp()), title=u"< Back to %s" % show.title, thumb=show.thumb or default_thumb)) elif current_kind == "series": timeout = 1800 items = get_all_items(key="children", value=rating_key, base="library/metadata") kind, deeper = get_items_info(items) dig_tree(oc, items, MetadataMenu, pass_kwargs={ "base_title": title, "display_items": deeper, "previous_item_type": kind, "previous_rating_key": rating_key }) # we don't know exactly where we are here, only add ignore option to series if should_display_ignore(items, previous=previous_item_type): add_ignore_options(oc, "series", title=item_title, rating_key=rating_key, callback_menu=IgnoreMenu) # add refresh oc.add( DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=title, refresh_kind=current_kind, previous_rating_key=previous_rating_key, timeout=timeout * 1000, randomize=timestamp()), title=u"Refresh: %s" % item_title, summary= "Refreshes the %s, possibly searching for missing and picking up new subtitles on disk" % current_kind)) oc.add( DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=title, force=True, refresh_kind=current_kind, previous_rating_key=previous_rating_key, timeout=timeout * 1000, randomize=timestamp()), title=u"Auto-Find subtitles: %s" % item_title, summary= "Issues a forced refresh, ignoring known subtitles and searching for new ones" )) else: return ItemDetailsMenu(rating_key=rating_key, title=title, item_title=item_title) return oc
def MetadataMenu(rating_key, title=None, base_title=None, display_items=False, previous_item_type=None, previous_rating_key=None, message=None, header=None, randomize=None): """ displays the contents of a section based on whether it has a deeper tree or not (movies->movie (item) list; series->series list) :param rating_key: :param title: :param base_title: :param display_items: :param previous_item_type: :param previous_rating_key: :return: """ title = unicode(title) item_title = title title = base_title + " > " + title oc = SubFolderObjectContainer(title2=title, no_cache=True, no_history=True, header=header, message=message, view_group="full_details") current_kind = get_item_kind_from_rating_key(rating_key) if display_items: timeout = 30 show = None # add back to series for season if current_kind == "season": timeout = 720 show = get_item(previous_rating_key) oc.add(DirectoryObject( key=Callback(MetadataMenu, rating_key=show.rating_key, title=show.title, base_title=show.section.title, previous_item_type="section", display_items=True, randomize=timestamp()), title=_(u"< Back to %s", show.title), thumb=show.thumb or default_thumb )) elif current_kind == "series": # it shouldn't take more than 6 minutes to scan all of a series' files and determine the force refresh timeout = 3600 items = get_all_items(key="children", value=rating_key, base="library/metadata") kind, deeper = get_items_info(items) dig_tree(oc, items, MetadataMenu, pass_kwargs={"base_title": title, "display_items": deeper, "previous_item_type": kind, "previous_rating_key": rating_key}) # we don't know exactly where we are here, only add ignore option to series if current_kind in ("series", "season"): item = get_item(rating_key) sub_title = get_item_title(item) add_incl_excl_options(oc, current_kind, title=sub_title, rating_key=rating_key, callback_menu=InclExclMenu) # mass-extract embedded if current_kind == "season" and config.plex_transcoder: for lang in config.lang_list: oc.add(DirectoryObject( key=Callback(SeasonExtractEmbedded, rating_key=rating_key, language=lang, base_title=show.section.title, display_items=display_items, item_title=item_title, title=title, previous_item_type=previous_item_type, with_mods=True, previous_rating_key=previous_rating_key, randomize=timestamp()), title=_(u"Extract missing %(language)s embedded subtitles", language=display_language(lang)), summary=_("Extracts the not yet extracted embedded subtitles of all episodes for the current " "season with all configured default modifications") )) oc.add(DirectoryObject( key=Callback(SeasonExtractEmbedded, rating_key=rating_key, language=lang, base_title=show.section.title, display_items=display_items, item_title=item_title, title=title, force=True, previous_item_type=previous_item_type, with_mods=True, previous_rating_key=previous_rating_key, randomize=timestamp()), title=_(u"Extract and activate %(language)s embedded subtitles", language=display_language(lang)), summary=_("Extracts embedded subtitles of all episodes for the current season " "with all configured default modifications") )) # add refresh oc.add(DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=title, refresh_kind=current_kind, previous_rating_key=previous_rating_key, timeout=timeout * 1000, randomize=timestamp()), title=_(u"Refresh: %s", item_title), summary=_("Refreshes %(the_movie_series_season_episode)s, possibly searching for missing and picking up " "new subtitles on disk", the_movie_series_season_episode=_(u"the %s" % current_kind)) )) oc.add(DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=title, force=True, refresh_kind=current_kind, previous_rating_key=previous_rating_key, timeout=timeout * 1000, randomize=timestamp()), title=_(u"Auto-Find subtitles: %s", item_title), summary=_("Issues a forced refresh, ignoring known subtitles and searching for new ones") )) else: return ItemDetailsMenu(rating_key=rating_key, title=title, item_title=item_title) return oc
def run(self): super(FindBetterSubtitles, self).run() self.running = True better_found = 0 try: max_search_days = int(Prefs[ "scheduler.tasks.FindBetterSubtitles.max_days_after_added"]. strip()) except ValueError: Log.Error( "Please only put numbers into the FindBetterSubtitles.max_days_after_added setting. Exiting" ) return else: if max_search_days > 30: Log.Error( "FindBetterSubtitles.max_days_after_added is too big. Max is 30 days." ) return now = datetime.datetime.now() for video_id, parts in Dict["subs"].iteritems(): video_id = str(video_id) try: plex_item = get_item(video_id) except: Log.Error("Couldn't get item info for %s", video_id) continue cutoff = self.series_cutoff if plex_item.type == "episode" else self.movies_cutoff added_date = datetime.datetime.fromtimestamp(plex_item.added_at) # don't search for better subtitles until at least 30 minutes have passed if added_date + datetime.timedelta(minutes=30) > now: Log.Debug("Item %s too new, skipping", video_id) continue # added_date <= max_search_days? if added_date + datetime.timedelta(days=max_search_days) <= now: continue ditch_parts = [] # look through all stored subtitle data for part_id, languages in parts.iteritems(): part_id = str(part_id) # all languages for language, current_subs in languages.iteritems(): current_key = current_subs.get("current") current = current_subs.get(current_key) # currently got subtitle? if not current: continue current_score = int(current["score"]) current_mode = current.get("mode", "a") # late cutoff met? skip if current_score >= cutoff: Log.Debug( u"Skipping finding better subs, cutoff met (current: %s, cutoff: %s): %s", current_score, cutoff, current["title"]) continue # got manual subtitle but don't want to touch those? if current_mode == "m" and \ not cast_bool(Prefs["scheduler.tasks.FindBetterSubtitles.overwrite_manually_selected"]): Log.Debug( u"Skipping finding better subs, had manual: %s", current["title"]) continue try: subs = self.list_subtitles(video_id, plex_item.type, part_id, language) except PartUnknownException: Log.Info( "Part %s unknown/gone; ditching subtitle info", part_id) ditch_parts.append(part_id) continue if subs: # subs are already sorted by score sub = subs[0] if sub.score > current_score: Log.Debug( "Better subtitle found for %s, downloading", video_id) self.download_subtitle(sub, video_id, mode="b") better_found += 1 if ditch_parts: for part_id in ditch_parts: try: del parts[part_id] except KeyError: pass if better_found: Log.Debug("Task: %s, done. Better subtitles found for %s items", self.name, better_found) self.running = False
def ItemDetailsMenu(rating_key, title=None, base_title=None, item_title=None, randomize=None, header=None): """ displays the item details menu of an item that doesn't contain any deeper tree, such as a movie or an episode :param rating_key: :param title: :param base_title: :param item_title: :param randomize: :return: """ from interface.main import IgnoreMenu title = unicode(base_title) + " > " + unicode(title) if base_title else unicode(title) item = plex_item = get_item(rating_key) current_kind = get_item_kind_from_rating_key(rating_key) timeout = 30 oc = SubFolderObjectContainer(title2=title, replace_parent=True, header=header) if not item: oc.add(DirectoryObject( key=Callback(ItemDetailsMenu, rating_key=rating_key, title=title, base_title=base_title, item_title=item_title, randomize=timestamp()), title=u"Item not found: %s!" % item_title, summary="Plex didn't return any information about the item, please refresh it and come back later", thumb=default_thumb )) return oc # add back to season for episode if current_kind == "episode": from interface.menu import MetadataMenu show = get_item(item.show.rating_key) season = get_item(item.season.rating_key) oc.add(DirectoryObject( key=Callback(MetadataMenu, rating_key=season.rating_key, title=season.title, base_title=show.title, previous_item_type="show", previous_rating_key=show.rating_key, display_items=True, randomize=timestamp()), title=u"< Back to %s" % season.title, summary="Back to %s > %s" % (show.title, season.title), thumb=season.thumb or default_thumb )) oc.add(DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=item_title, randomize=timestamp(), timeout=timeout * 1000), title=u"Refresh: %s" % item_title, summary="Refreshes the %s, possibly searching for missing and picking up new subtitles on disk" % current_kind, thumb=item.thumb or default_thumb )) oc.add(DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=item_title, force=True, randomize=timestamp(), timeout=timeout * 1000), title=u"Force-find subtitles: %s" % item_title, summary="Issues a forced refresh, ignoring known subtitles and searching for new ones", thumb=item.thumb or default_thumb )) # get stored subtitle info for item id subtitle_storage = get_subtitle_storage() stored_subs = subtitle_storage.load_or_new(item) # look for subtitles for all available media parts and all of their languages has_multiple_parts = len(plex_item.media) > 1 part_index = 0 for media in plex_item.media: for part in media.parts: filename = os.path.basename(part.file) if not os.path.exists(part.file): continue part_id = str(part.id) part_index += 1 part_index_addon = "" part_summary_addon = "" if has_multiple_parts: part_index_addon = u"File %s: " % part_index part_summary_addon = "%s " % filename # iterate through all configured languages for lang in config.lang_list: # get corresponding stored subtitle data for that media part (physical media item), for language current_sub = stored_subs.get_any(part_id, lang) current_sub_id = None current_sub_provider_name = None summary = u"%sNo current subtitle in storage" % part_summary_addon current_score = None if current_sub: current_sub_id = current_sub.id current_sub_provider_name = current_sub.provider_name current_score = current_sub.score summary = u"%sCurrent subtitle: %s (added: %s, %s), Language: %s, Score: %i, Storage: %s" % \ (part_summary_addon, current_sub.provider_name, df(current_sub.date_added), current_sub.mode_verbose, display_language(lang), current_sub.score, current_sub.storage_type) oc.add(DirectoryObject( key=Callback(SubtitleOptionsMenu, rating_key=rating_key, part_id=part_id, title=title, item_title=item_title, language=lang, language_name=display_language(lang), current_id=current_sub_id, item_type=plex_item.type, filename=filename, current_data=summary, randomize=timestamp(), current_provider=current_sub_provider_name, current_score=current_score), title=u"%sManage %s subtitle" % (part_index_addon, display_language(lang)), summary=summary )) else: oc.add(DirectoryObject( key=Callback(ListAvailableSubsForItemMenu, rating_key=rating_key, part_id=part_id, title=title, item_title=item_title, language=lang, language_name=display_language(lang), current_id=current_sub_id, item_type=plex_item.type, filename=filename, current_data=summary, randomize=timestamp(), current_provider=current_sub_provider_name, current_score=current_score), title=u"%sList %s subtitles" % (part_index_addon, display_language(lang)), summary=summary )) if config.plex_transcoder: # embedded subtitles embedded_count = 0 embedded_langs = [] for stream in part.streams: # subtitle stream if stream.stream_type == 3 and not stream.stream_key and stream.codec in TEXT_SUBTITLE_EXTS: lang = get_language_from_stream(stream.language_code) if not lang and config.treat_und_as_first: lang = list(config.lang_list)[0] if lang: embedded_langs.append(lang) embedded_count += 1 if embedded_count: oc.add(DirectoryObject( key=Callback(ListEmbeddedSubsForItemMenu, rating_key=rating_key, part_id=part_id, title=title, item_type=plex_item.type, item_title=item_title, base_title=base_title, randomize=timestamp()), title=u"%sEmbedded subtitles (%s)" % (part_index_addon, ", ".join(display_language(l) for l in set(embedded_langs))), summary=u"Extract and activate embedded subtitle streams" )) ignore_title = item_title if current_kind == "episode": ignore_title = get_item_title(item) add_ignore_options(oc, "videos", title=ignore_title, rating_key=rating_key, callback_menu=IgnoreMenu) subtitle_storage.destroy() return oc
def item_discover_missing_subs(rating_key, kind="show", added_at=None, section_title=None, internal=False, external=True, languages=()): item_id = int(rating_key) item = get_item(rating_key) if kind == "show": item_title = get_plex_item_display_title(item, kind, parent=item.season, section_title=section_title, parent_title=item.show.title) else: item_title = get_plex_item_display_title(item, kind, section_title=section_title) subtitle_storage = get_subtitle_storage() stored_subs = subtitle_storage.load(rating_key) subtitle_storage.destroy() subtitle_target_dir, tdir_is_absolute = config.subtitle_sub_dir missing = set() languages_set = set([Language.rebuild(l) for l in languages]) for media in item.media: existing_subs = {"internal": [], "external": [], "own_external": [], "count": 0} for part in media.parts: # did we already download an external subtitle before? if subtitle_target_dir and stored_subs: for language in languages_set: if has_external_subtitle(part.id, stored_subs, language): # check the existence of the actual subtitle file # get media filename without extension part_basename = os.path.splitext(os.path.basename(part.file))[0] # compute target directory for subtitle # fixme: move to central location if tdir_is_absolute: possible_subtitle_path_base = subtitle_target_dir else: possible_subtitle_path_base = os.path.join(os.path.dirname(part.file), subtitle_target_dir) possible_subtitle_path_base = os.path.realpath(possible_subtitle_path_base) # folder actually exists? if not os.path.isdir(possible_subtitle_path_base): continue found_any = False for ext in config.subtitle_formats: if cast_bool(Prefs['subtitles.only_one']): possible_subtitle_path = os.path.join(possible_subtitle_path_base, u"%s.%s" % (part_basename, ext)) else: possible_subtitle_path = os.path.join(possible_subtitle_path_base, u"%s.%s.%s" % (part_basename, language, ext)) # check for subtitle existence if os.path.isfile(possible_subtitle_path): found_any = True Log.Debug(u"Found: %s", possible_subtitle_path) break if found_any: existing_subs["own_external"].append(language) existing_subs["count"] = existing_subs["count"] + 1 for stream in part.streams: if stream.stream_type == 3: is_forced = is_stream_forced(stream) if stream.index: key = "internal" else: key = "external" if not config.exotic_ext and stream.codec.lower() not in TEXT_SUBTITLE_EXTS: continue # treat unknown language as lang1? if not stream.language_code and config.treat_und_as_first: lang = Language.rebuild(list(config.lang_list)[0]) # we can't parse empty language codes elif not stream.language_code or not stream.codec: continue else: # parse with internal language parser first try: lang = get_language_from_stream(stream.language_code) if not lang: if config.treat_und_as_first: lang = Language.rebuild(list(config.lang_list)[0]) else: continue except (ValueError, LanguageReverseError): continue if lang: # Log.Debug("Found babelfish language: %r", lang) lang.forced = is_forced existing_subs[key].append(lang) existing_subs["count"] = existing_subs["count"] + 1 missing_from_part = set([Language.rebuild(l) for l in languages]) if existing_subs["count"]: # fixme: this is actually somewhat broken with IETF, as Plex doesn't store the country portion # (pt instead of pt-BR) inside the database. So it might actually download pt-BR if there's a local pt-BR # subtitle but not our own. existing_flat = set((existing_subs["internal"] if internal else []) + (existing_subs["external"] if external else []) + existing_subs["own_external"]) check_languages = set([Language.rebuild(l) for l in languages]) alpha3_map = {} if config.ietf_as_alpha3: for language in existing_flat: if language.country: alpha3_map[language.alpha3] = language.country language.country = None for language in check_languages: if language.country: alpha3_map[language.alpha3] = language.country language.country = None # compare sets of strings, not sets of different Language instances check_languages_str = set(str(l) for l in check_languages) existing_flat_str = set(str(l) for l in existing_flat) if check_languages_str.issubset(existing_flat_str) or \ (len(existing_flat) >= 1 and Prefs['subtitles.only_one']): # all subs found #Log.Info(u"All subtitles exist for '%s'", item_title) continue missing_from_part = set(Language.fromietf(l) for l in check_languages_str - existing_flat_str) if config.ietf_as_alpha3: for language in missing_from_part: language.country = alpha3_map.get(language.alpha3, None) if missing_from_part: Log.Info(u"Subs still missing for '%s' (%s: %s): %s", item_title, rating_key, media.id, missing_from_part) missing.update(missing_from_part) if missing: # deduplicate missing = set(Language.fromietf(la) for la in set(str(l) for l in missing)) return added_at, item_id, item_title, item, missing
def ItemDetailsMenu(rating_key, title=None, base_title=None, item_title=None, randomize=None): """ displays the item details menu of an item that doesn't contain any deeper tree, such as a movie or an episode :param rating_key: :param title: :param base_title: :param item_title: :param randomize: :return: """ from interface.main import IgnoreMenu title = unicode(base_title) + " > " + unicode( title) if base_title else unicode(title) item = get_item(rating_key) current_kind = get_item_kind_from_rating_key(rating_key) timeout = 30 oc = SubFolderObjectContainer(title2=title, replace_parent=True) # add back to season for episode if current_kind == "episode": from interface.menu import MetadataMenu show = get_item(item.show.rating_key) season = get_item(item.season.rating_key) oc.add( DirectoryObject(key=Callback(MetadataMenu, rating_key=season.rating_key, title=season.title, base_title=show.title, previous_item_type="show", previous_rating_key=show.rating_key, display_items=True, randomize=timestamp()), title=u"< Back to %s" % season.title, summary="Back to %s > %s" % (show.title, season.title), thumb=season.thumb or default_thumb)) oc.add( DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=item_title, randomize=timestamp(), timeout=timeout * 1000), title=u"Refresh: %s" % item_title, summary= "Refreshes the %s, possibly searching for missing and picking up new subtitles on disk" % current_kind, thumb=item.thumb or default_thumb)) oc.add( DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=item_title, force=True, randomize=timestamp(), timeout=timeout * 1000), title=u"Force-find subtitles: %s" % item_title, summary= "Issues a forced refresh, ignoring known subtitles and searching for new ones", thumb=item.thumb or default_thumb)) # get stored subtitle info for item id subtitle_storage = get_subtitle_storage() stored_subs = subtitle_storage.load_or_new(item) # get the plex item plex_item = get_item(rating_key) # look for subtitles for all available media parts and all of their languages has_multiple_parts = len(plex_item.media) > 1 part_index = 0 for media in plex_item.media: for part in media.parts: filename = os.path.basename(part.file) if not os.path.exists(part.file): continue part_id = str(part.id) part_index += 1 # iterate through all configured languages for lang in config.lang_list: # get corresponding stored subtitle data for that media part (physical media item), for language current_sub = stored_subs.get_any(part_id, lang) current_sub_id = None current_sub_provider_name = None part_index_addon = "" part_summary_addon = "" if has_multiple_parts: part_index_addon = u"File %s: " % part_index part_summary_addon = "%s " % filename summary = u"%sNo current subtitle in storage" % part_summary_addon current_score = None if current_sub: current_sub_id = current_sub.id current_sub_provider_name = current_sub.provider_name current_score = current_sub.score summary = u"%sCurrent subtitle: %s (added: %s, %s), Language: %s, Score: %i, Storage: %s" % \ (part_summary_addon, current_sub.provider_name, df(current_sub.date_added), current_sub.mode_verbose, lang, current_sub.score, current_sub.storage_type) oc.add( DirectoryObject(key=Callback( SubtitleOptionsMenu, rating_key=rating_key, part_id=part_id, title=title, item_title=item_title, language=lang, language_name=lang.name, current_id=current_sub_id, item_type=plex_item.type, filename=filename, current_data=summary, randomize=timestamp(), current_provider=current_sub_provider_name, current_score=current_score), title=u"%sActions for %s subtitle" % (part_index_addon, lang.name), summary=summary)) else: oc.add( DirectoryObject(key=Callback( ListAvailableSubsForItemMenu, rating_key=rating_key, part_id=part_id, title=title, item_title=item_title, language=lang, language_name=lang.name, current_id=current_sub_id, item_type=plex_item.type, filename=filename, current_data=summary, randomize=timestamp(), current_provider=current_sub_provider_name, current_score=current_score), title=u"%sList %s subtitles" % (part_index_addon, lang.name), summary=summary)) add_ignore_options(oc, "videos", title=item_title, rating_key=rating_key, callback_menu=IgnoreMenu) subtitle_storage.destroy() return oc
def MetadataMenu(rating_key, title=None, base_title=None, display_items=False, previous_item_type=None, previous_rating_key=None, message=None, header=None, randomize=None): """ displays the contents of a section based on whether it has a deeper tree or not (movies->movie (item) list; series->series list) :param rating_key: :param title: :param base_title: :param display_items: :param previous_item_type: :param previous_rating_key: :return: """ title = unicode(title) item_title = title title = base_title + " > " + title oc = SubFolderObjectContainer(title2=title, no_cache=True, no_history=True, header=header, message=message, view_group="full_details") current_kind = get_item_kind_from_rating_key(rating_key) if display_items: timeout = 30 show = None # add back to series for season if current_kind == "season": timeout = 720 show = get_item(previous_rating_key) oc.add(DirectoryObject( key=Callback(MetadataMenu, rating_key=show.rating_key, title=show.title, base_title=show.section.title, previous_item_type="section", display_items=True, randomize=timestamp()), title=_(u"< Back to %s", show.title), thumb=show.thumb or default_thumb )) elif current_kind == "series": # it shouldn't take more than 6 minutes to scan all of a series' files and determine the force refresh timeout = 3600 items = get_all_items(key="children", value=rating_key, base="library/metadata") kind, deeper = get_items_info(items) dig_tree(oc, items, MetadataMenu, pass_kwargs={"base_title": title, "display_items": deeper, "previous_item_type": kind, "previous_rating_key": rating_key}) # we don't know exactly where we are here, only add ignore option to series if current_kind in ("series", "season"): item = get_item(rating_key) sub_title = get_item_title(item) add_ignore_options(oc, current_kind, title=sub_title, rating_key=rating_key, callback_menu=IgnoreMenu) # mass-extract embedded if current_kind == "season" and config.plex_transcoder: for lang in config.lang_list: oc.add(DirectoryObject( key=Callback(SeasonExtractEmbedded, rating_key=rating_key, language=lang, base_title=show.section.title, display_items=display_items, item_title=item_title, title=title, previous_item_type=previous_item_type, with_mods=True, previous_rating_key=previous_rating_key, randomize=timestamp()), title=_(u"Extract missing %(language)s embedded subtitles", language=display_language(lang)), summary=_("Extracts the not yet extracted embedded subtitles of all episodes for the current " "season with all configured default modifications") )) oc.add(DirectoryObject( key=Callback(SeasonExtractEmbedded, rating_key=rating_key, language=lang, base_title=show.section.title, display_items=display_items, item_title=item_title, title=title, force=True, previous_item_type=previous_item_type, with_mods=True, previous_rating_key=previous_rating_key, randomize=timestamp()), title=_(u"Extract and activate %(language)s embedded subtitles", language=display_language(lang)), summary=_("Extracts embedded subtitles of all episodes for the current season " "with all configured default modifications") )) # add refresh oc.add(DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=title, refresh_kind=current_kind, previous_rating_key=previous_rating_key, timeout=timeout * 1000, randomize=timestamp()), title=_(u"Refresh: %s", item_title), summary=_("Refreshes %(the_movie_series_season_episode)s, possibly searching for missing and picking up " "new subtitles on disk", the_movie_series_season_episode=_(u"the %s" % current_kind)) )) oc.add(DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=title, force=True, refresh_kind=current_kind, previous_rating_key=previous_rating_key, timeout=timeout * 1000, randomize=timestamp()), title=_(u"Auto-Find subtitles: %s", item_title), summary=_("Issues a forced refresh, ignoring known subtitles and searching for new ones") )) else: return ItemDetailsMenu(rating_key=rating_key, title=title, item_title=item_title) return oc
def ItemDetailsMenu(rating_key, title=None, base_title=None, item_title=None, randomize=None, header=None, message=None): """ displays the item details menu of an item that doesn't contain any deeper tree, such as a movie or an episode :param rating_key: :param title: :param base_title: :param item_title: :param randomize: :return: """ from interface.main import InclExclMenu title = unicode(base_title) + " > " + unicode(title) if base_title else unicode(title) item = plex_item = get_item(rating_key) current_kind = get_item_kind_from_rating_key(rating_key) timeout = 30 oc = SubFolderObjectContainer( title2=title, replace_parent=True, header=header, message=message) if not item: oc.add(DirectoryObject( key=Callback( ItemDetailsMenu, rating_key=rating_key, title=title, base_title=base_title, item_title=item_title, randomize=timestamp()), title=_(u"Item not found: %s!", item_title), summary=_("Plex didn't return any information about the item, please refresh it and come back later"), thumb=default_thumb )) return oc # add back to season for episode if current_kind == "episode": from interface.menu import MetadataMenu show = get_item(item.show.rating_key) season = get_item(item.season.rating_key) oc.add(DirectoryObject( key=Callback( MetadataMenu, rating_key=season.rating_key, title=season.title, base_title=show.title, previous_item_type="show", previous_rating_key=show.rating_key, display_items=True, randomize=timestamp()), title=_(u"< Back to %s", season.title), summary=_("Back to %s > %s", show.title, season.title), thumb=season.thumb or default_thumb )) oc.add(DirectoryObject( key=Callback( RefreshItem, rating_key=rating_key, item_title=item_title, randomize=timestamp(), timeout=timeout * 1000), title=_(u"Refresh: %s", item_title), summary=_("Refreshes %(the_movie_series_season_episode)s, possibly searching for missing and picking up " "new subtitles on disk", the_movie_series_season_episode=_(u"the %s" % current_kind)), thumb=item.thumb or default_thumb )) oc.add(DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=item_title, force=True, randomize=timestamp(), timeout=timeout * 1000), title=_(u"Force-find subtitles: %(item_title)s", item_title=item_title), summary=_("Issues a forced refresh, ignoring known subtitles and searching for new ones"), thumb=item.thumb or default_thumb )) # get stored subtitle info for item id subtitle_storage = get_subtitle_storage() stored_subs = subtitle_storage.load_or_new(item) # look for subtitles for all available media parts and all of their languages has_multiple_parts = len(plex_item.media) > 1 part_index = 0 for media in plex_item.media: for part in media.parts: filename = os.path.basename(part.file) if not os.path.exists(part.file): continue part_id = str(part.id) part_index += 1 part_index_addon = u"" part_summary_addon = u"" if has_multiple_parts: part_index_addon = _(u"File %(file_part_index)s: ", file_part_index=part_index) part_summary_addon = u"%s " % filename # iterate through all configured languages for lang in config.lang_list: # get corresponding stored subtitle data for that media part (physical media item), for language current_sub = stored_subs.get_any(part_id, lang) current_sub_id = None current_sub_provider_name = None summary = _(u"%(part_summary)sNo current subtitle in storage", part_summary=part_summary_addon) current_score = None if current_sub: current_sub_id = current_sub.id current_sub_provider_name = current_sub.provider_name current_score = current_sub.score summary = _(u"%(part_summary)sCurrent subtitle: %(provider_name)s (added: %(date_added)s, " u"%(mode)s), Language: %(language)s, Score: %(score)i, Storage: %(storage_type)s", part_summary=part_summary_addon, provider_name=_(current_sub.provider_name), date_added=df(current_sub.date_added), mode=_(current_sub.mode_verbose), language=display_language(lang), score=current_sub.score, storage_type=current_sub.storage_type) oc.add(DirectoryObject( key=Callback(SubtitleOptionsMenu, rating_key=rating_key, part_id=part_id, title=title, item_title=item_title, language=lang, language_name=display_language(lang), current_id=current_sub_id, item_type=plex_item.type, filename=filename, current_data=summary, randomize=timestamp(), current_provider=current_sub_provider_name, current_score=current_score), title=_(u"%(part_summary)sManage %(language)s subtitle", part_summary=part_index_addon, language=display_language(lang)), summary=summary )) else: oc.add(DirectoryObject( key=Callback(ListAvailableSubsForItemMenu, rating_key=rating_key, part_id=part_id, title=title, item_title=item_title, language=lang, language_name=display_language(lang), current_id=current_sub_id, item_type=plex_item.type, filename=filename, current_data=summary, randomize=timestamp(), current_provider=current_sub_provider_name, current_score=current_score), title=_(u"%(part_summary)sList %(language)s subtitles", part_summary=part_index_addon, language=display_language(lang)), summary=summary )) if config.plex_transcoder: # embedded subtitles embedded_count = 0 embedded_langs = [] for stream in part.streams: # subtitle stream if stream.stream_type == 3 and not stream.stream_key and stream.codec in TEXT_SUBTITLE_EXTS: lang = get_language_from_stream(stream.language_code) is_forced = is_stream_forced(stream) if not lang and config.treat_und_as_first: lang = list(config.lang_list)[0] if lang: lang = Language.rebuild(lang, forced=is_forced) embedded_langs.append(lang) embedded_count += 1 if embedded_count: oc.add(DirectoryObject( key=Callback(ListEmbeddedSubsForItemMenu, rating_key=rating_key, part_id=part_id, title=title, item_type=plex_item.type, item_title=item_title, base_title=base_title, randomize=timestamp()), title=_(u"%(part_summary)sEmbedded subtitles (%(languages)s)", part_summary=part_index_addon, languages=", ".join(display_language(l) for l in list(OrderedDict.fromkeys(embedded_langs)))), summary=_(u"Extract embedded subtitle streams") )) ignore_title = item_title if current_kind == "episode": ignore_title = get_item_title(item) add_incl_excl_options(oc, "videos", title=ignore_title, rating_key=rating_key, callback_menu=InclExclMenu) subtitle_storage.destroy() return oc
def item_discover_missing_subs(rating_key, kind="show", added_at=None, section_title=None, internal=False, external=True, languages=()): item_id = int(rating_key) item = get_item(rating_key) if kind == "show": item_title = get_plex_item_display_title(item, kind, parent=item.season, section_title=section_title, parent_title=item.show.title) else: item_title = get_plex_item_display_title(item, kind, section_title=section_title) subtitle_storage = get_subtitle_storage() stored_subs = subtitle_storage.load(rating_key) subtitle_storage.destroy() subtitle_target_dir, tdir_is_absolute = config.subtitle_sub_dir missing = set() languages_set = set([Language.rebuild(l) for l in languages]) for media in item.media: existing_subs = {"internal": [], "external": [], "own_external": [], "count": 0} for part in media.parts: update_stream_info(part) # did we already download an external subtitle before? if subtitle_target_dir and stored_subs: for language in languages_set: if has_external_subtitle(part.id, stored_subs, language): # check the existence of the actual subtitle file # get media filename without extension part_basename = os.path.splitext(os.path.basename(part.file))[0] # compute target directory for subtitle # fixme: move to central location if tdir_is_absolute: possible_subtitle_path_base = subtitle_target_dir else: possible_subtitle_path_base = os.path.join(os.path.dirname(part.file), subtitle_target_dir) possible_subtitle_path_base = os.path.realpath(possible_subtitle_path_base) # folder actually exists? if not os.path.isdir(possible_subtitle_path_base): continue found_any = False for ext in config.subtitle_formats: if cast_bool(Prefs['subtitles.only_one']): possible_subtitle_path = os.path.join(possible_subtitle_path_base, u"%s.%s" % (part_basename, ext)) else: possible_subtitle_path = os.path.join(possible_subtitle_path_base, u"%s.%s.%s" % (part_basename, language, ext)) # check for subtitle existence if os.path.isfile(possible_subtitle_path): found_any = True Log.Debug(u"Found: %s", possible_subtitle_path) break if found_any: existing_subs["own_external"].append(language) existing_subs["count"] = existing_subs["count"] + 1 for stream in part.streams: if stream.stream_type == 3: is_forced = is_stream_forced(stream) if stream.index: key = "internal" else: key = "external" if not config.exotic_ext and stream.codec.lower() not in TEXT_SUBTITLE_EXTS: continue # treat unknown language as lang1? if not stream.language_code and config.treat_und_as_first: lang = Language.rebuild(list(config.lang_list)[0]) # we can't parse empty language codes elif not stream.language_code or not stream.codec: continue else: # parse with internal language parser first try: lang = get_language_from_stream(stream.language_code) if not lang: if config.treat_und_as_first: lang = Language.rebuild(list(config.lang_list)[0]) else: continue except (ValueError, LanguageReverseError): continue if lang: # Log.Debug("Found babelfish language: %r", lang) lang.forced = is_forced existing_subs[key].append(lang) existing_subs["count"] = existing_subs["count"] + 1 missing_from_part = set([Language.rebuild(l) for l in languages]) if existing_subs["count"]: # fixme: this is actually somewhat broken with IETF, as Plex doesn't store the country portion # (pt instead of pt-BR) inside the database. So it might actually download pt-BR if there's a local pt-BR # subtitle but not our own. existing_flat = set((existing_subs["internal"] if internal else []) + (existing_subs["external"] if external else []) + existing_subs["own_external"]) check_languages = set([Language.rebuild(l) for l in languages]) alpha3_map = {} if config.ietf_as_alpha3: for language in existing_flat: if language.country: alpha3_map[language.alpha3] = language.country language.country = None for language in check_languages: if language.country: alpha3_map[language.alpha3] = language.country language.country = None # compare sets of strings, not sets of different Language instances check_languages_str = set(str(l) for l in check_languages) existing_flat_str = set(str(l) for l in existing_flat) if check_languages_str.issubset(existing_flat_str) or \ (len(existing_flat) >= 1 and Prefs['subtitles.only_one']): # all subs found #Log.Info(u"All subtitles exist for '%s'", item_title) continue missing_from_part = set(Language.fromietf(l) for l in check_languages_str - existing_flat_str) if config.ietf_as_alpha3: for language in missing_from_part: language.country = alpha3_map.get(language.alpha3, None) if missing_from_part: Log.Info(u"Subs still missing for '%s' (%s: %s): %s", item_title, rating_key, media.id, missing_from_part) missing.update(missing_from_part) if missing: # deduplicate missing = set(Language.fromietf(la) for la in set(str(l) for l in missing)) return added_at, item_id, item_title, item, missing
def ItemDetailsMenu(rating_key, title=None, base_title=None, item_title=None, randomize=None): """ displays the item details menu of an item that doesn't contain any deeper tree, such as a movie or an episode :param rating_key: :param title: :param base_title: :param item_title: :param randomize: :return: """ title = unicode(base_title) + " > " + unicode( title) if base_title else unicode(title) item = get_item(rating_key) current_kind = get_item_kind_from_rating_key(rating_key) timeout = 30 oc = SubFolderObjectContainer(title2=title, replace_parent=True) oc.add( DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=item_title, randomize=timestamp(), timeout=timeout * 1000), title=u"Refresh: %s" % item_title, summary= "Refreshes the %s, possibly searching for missing and picking up new subtitles on disk" % current_kind, thumb=item.thumb or default_thumb)) oc.add( DirectoryObject( key=Callback(RefreshItem, rating_key=rating_key, item_title=item_title, force=True, randomize=timestamp(), timeout=timeout * 1000), title=u"Auto-search: %s" % item_title, summary= "Issues a forced refresh, ignoring known subtitles and searching for new ones", thumb=item.thumb or default_thumb)) # get stored subtitle info for item id subtitle_storage = get_subtitle_storage() stored_subs = subtitle_storage.load_or_new(item) # get the plex item plex_item = list(Plex["library"].metadata(rating_key))[0] # get current media info for that item media = plex_item.media # look for subtitles for all available media parts and all of their languages for part in media.parts: filename = os.path.basename(part.file) part_id = str(part.id) # iterate through all configured languages for lang in config.lang_list: lang_a2 = lang.alpha2 # ietf lang? if cast_bool(Prefs["subtitles.language.ietf"]) and "-" in lang_a2: lang_a2 = lang_a2.split("-")[0] # get corresponding stored subtitle data for that media part (physical media item), for language current_sub = stored_subs.get_any(part_id, lang_a2) current_sub_id = None current_sub_provider_name = None summary = u"No current subtitle in storage" current_score = None if current_sub: current_sub_id = current_sub.id current_sub_provider_name = current_sub.provider_name current_score = current_sub.score summary = u"Current subtitle: %s (added: %s, %s), Language: %s, Score: %i, Storage: %s" % \ (current_sub.provider_name, df(current_sub.date_added), current_sub.mode_verbose, lang, current_sub.score, current_sub.storage_type) oc.add( DirectoryObject(key=Callback( ListAvailableSubsForItemMenu, rating_key=rating_key, part_id=part_id, title=title, item_title=item_title, language=lang, current_id=current_sub_id, item_type=plex_item.type, filename=filename, current_data=summary, randomize=timestamp(), current_provider=current_sub_provider_name, current_score=current_score), title=u"List %s subtitles" % lang.name, summary=summary)) add_ignore_options(oc, "videos", title=item_title, rating_key=rating_key, callback_menu=IgnoreMenu) return oc
def extract_embedded_sub(**kwargs): rating_key = kwargs["rating_key"] part_id = kwargs.pop("part_id") stream_index = kwargs.pop("stream_index") with_mods = kwargs.pop("with_mods", False) language = Language.fromietf(kwargs.pop("language")) refresh = kwargs.pop("refresh", True) set_current = kwargs.pop("set_current", True) plex_item = get_item(rating_key) item_type = get_item_kind_from_item(plex_item) part = get_part(plex_item, part_id) if part: metadata = get_plex_metadata(rating_key, part_id, item_type, plex_item=plex_item) scanned_parts = scan_videos([metadata], ignore_all=True, skip_hashing=True) for stream in part.streams: # subtitle stream if str(stream.index) == stream_index: forced = stream.forced bn = os.path.basename(part.file) set_refresh_menu_state(u"Extracting subtitle %s of %s" % (stream_index, bn)) Log.Info(u"Extracting stream %s (%s) of %s", stream_index, display_language(language), bn) args = [ config.plex_transcoder, "-i", part.file, "-map", "0:%s" % stream_index, "-f", "srt", "-" ] output = None try: output = subprocess.check_output(quote_args(args), stderr=subprocess.PIPE, shell=True) except: Log.Error("Extraction failed: %s", traceback.format_exc()) if output: subtitle = ModifiedSubtitle( language, mods=config.default_mods if with_mods else None) subtitle.content = output subtitle.provider_name = "embedded" subtitle.id = "stream_%s" % stream_index subtitle.score = 0 subtitle.set_encoding("utf-8") # fixme: speedup video; only video.name is needed save_successful = save_subtitles( scanned_parts, {scanned_parts.keys()[0]: [subtitle]}, mode="m", set_current=set_current) set_refresh_menu_state(None) if save_successful and refresh: refresh_item(rating_key)
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 extract_embedded_sub(**kwargs): rating_key = kwargs["rating_key"] part_id = kwargs.pop("part_id") stream_index = kwargs.pop("stream_index") with_mods = kwargs.pop("with_mods", False) language = Language.fromietf(kwargs.pop("language")) refresh = kwargs.pop("refresh", True) set_current = kwargs.pop("set_current", True) plex_item = kwargs.pop("plex_item", get_item(rating_key)) item_type = get_item_kind_from_item(plex_item) part = kwargs.pop("part", get_part(plex_item, part_id)) scanned_videos = kwargs.pop("scanned_videos", None) extract_mode = kwargs.pop("extract_mode", "a") any_successful = False if part: if not scanned_videos: metadata = get_plex_metadata(rating_key, part_id, item_type, plex_item=plex_item) scanned_videos = scan_videos([metadata], ignore_all=True, skip_hashing=True) for stream in part.streams: # subtitle stream if str(stream.index) == stream_index: is_forced = is_stream_forced(stream) bn = os.path.basename(part.file) set_refresh_menu_state( _(u"Extracting subtitle %(stream_index)s of %(filename)s", stream_index=stream_index, filename=bn)) Log.Info(u"Extracting stream %s (%s) of %s", stream_index, str(language), bn) out_codec = stream.codec if stream.codec != "mov_text" else "srt" args = [ config.plex_transcoder, "-i", part.file, "-map", "0:%s" % stream_index, "-f", out_codec, "-" ] output = None try: output = subprocess.check_output(quote_args(args), stderr=subprocess.PIPE, shell=True) except: Log.Error("Extraction failed: %s", traceback.format_exc()) if output: subtitle = ModifiedSubtitle( language, mods=config.default_mods if with_mods else None) subtitle.content = output subtitle.provider_name = "embedded" subtitle.id = "stream_%s" % stream_index subtitle.score = 0 subtitle.set_encoding("utf-8") # fixme: speedup video; only video.name is needed video = scanned_videos.keys()[0] save_successful = save_subtitles(scanned_videos, {video: [subtitle]}, mode="m", set_current=set_current) set_refresh_menu_state(None) if save_successful and refresh: refresh_item(rating_key) # add item to history item_title = get_title_for_video_metadata( video.plexapi_metadata, add_section_title=False, add_episode_title=True) history = get_history() history.add( item_title, video.id, section_title=video.plexapi_metadata["section"], thumb=video.plexapi_metadata["super_thumb"], subtitle=subtitle, mode=extract_mode) history.destroy() any_successful = True return any_successful
def extract_embedded_sub(**kwargs): rating_key = kwargs["rating_key"] part_id = kwargs.pop("part_id") stream_index = kwargs.pop("stream_index") with_mods = kwargs.pop("with_mods", False) language = Language.fromietf(kwargs.pop("language")) refresh = kwargs.pop("refresh", True) set_current = kwargs.pop("set_current", True) plex_item = kwargs.pop("plex_item", get_item(rating_key)) item_type = get_item_kind_from_item(plex_item) part = kwargs.pop("part", get_part(plex_item, part_id)) scanned_videos = kwargs.pop("scanned_videos", None) extract_mode = kwargs.pop("extract_mode", "a") any_successful = False if part: if not scanned_videos: metadata = get_plex_metadata(rating_key, part_id, item_type, plex_item=plex_item) scanned_videos = scan_videos([metadata], ignore_all=True, skip_hashing=True) for stream in part.streams: # subtitle stream if str(stream.index) == stream_index: is_forced = is_stream_forced(stream) bn = os.path.basename(part.file) set_refresh_menu_state(_(u"Extracting subtitle %(stream_index)s of %(filename)s", stream_index=stream_index, filename=bn)) Log.Info(u"Extracting stream %s (%s) of %s", stream_index, str(language), bn) out_codec = stream.codec if stream.codec != "mov_text" else "srt" args = [ config.plex_transcoder, "-i", part.file, "-map", "0:%s" % stream_index, "-f", out_codec, "-" ] cmdline = quote_args(args) Log.Debug(u"Calling: %s", cmdline) if mswindows: Log.Debug("MSWindows: Fixing encoding") cmdline = cmdline.encode("mbcs") output = None try: output = subprocess.check_output(cmdline, stderr=subprocess.PIPE, shell=True) except: Log.Error("Extraction failed: %s", traceback.format_exc()) if output: subtitle = ModifiedSubtitle(language, mods=config.default_mods if with_mods else None) subtitle.content = output subtitle.provider_name = "embedded" subtitle.id = "stream_%s" % stream_index subtitle.score = 0 subtitle.set_encoding("utf-8") # fixme: speedup video; only video.name is needed video = scanned_videos.keys()[0] save_successful = save_subtitles(scanned_videos, {video: [subtitle]}, mode="m", set_current=set_current) set_refresh_menu_state(None) if save_successful and refresh: refresh_item(rating_key) # add item to history item_title = get_title_for_video_metadata(video.plexapi_metadata, add_section_title=False, add_episode_title=True) history = get_history() history.add(item_title, video.id, section_title=video.plexapi_metadata["section"], thumb=video.plexapi_metadata["super_thumb"], subtitle=subtitle, mode=extract_mode) history.destroy() any_successful = True return any_successful