def add_graphql_extras(self, data): """ Adds additional items to the main listings :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] if self.parentItem is not None: return data, items popular_url = self.__get_api_query_url( "trendingPrograms", "{__typename,title,description,guid,updated,seriesTvSeasons{id},imageMedia{url,label}}" ) popular_title = LanguageHelper.get_localized_string( LanguageHelper.Popular) popular = MediaItem("\a.: {} :.".format(popular_title), popular_url) popular.dontGroup = True popular.content_type = contenttype.TVSHOWS items.append(popular) # https://graph.kijk.nl/graphql?operationName=programsByDate&variables={"date":"2020-04-19","numOfDays":7}&extensions={"persistedQuery":{"version":1,"sha256Hash":"1445cc0d283e10fa21fcdf95b127207d5f8c22834c1d0d17df1aacb8a9da7a8e"}} recent_url = "#recentgraphql" recent_title = LanguageHelper.get_localized_string( LanguageHelper.Recent) recent = MediaItem("\a.: {} :.".format(recent_title), recent_url) recent.dontGroup = True items.append(recent) search_title = LanguageHelper.get_localized_string( LanguageHelper.Search) search = MediaItem("\a.: {} :.".format(search_title), "#searchSite") search.dontGroup = True items.append(search) movie_url = self.__get_api_persisted_url( "programs", "cd8d5f074397e43ccd27b1c958d8c24264b0a92a94f3162e8281f6a2934d0391", variables={ "programTypes": "MOVIE", "limit": 100 }) movie_url = self.__get_api_query_url( "programs(programTypes: MOVIE)", "{totalResults,items{type,__typename,guid,title,description,duration,displayGenre," "imageMedia{url,label},epgDate,sources{type,file,drm},tracks{type,kind,label,file}}}" ) movies_title = LanguageHelper.get_localized_string( LanguageHelper.Movies) movies = MediaItem("\a.: {} :.".format(movies_title), movie_url) movies.dontGroup = True movies.content_type = contenttype.MOVIES items.append(movies) return data, items
def add_live_streams(self, data): """ Performs pre-process actions for data processing. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] if self.parentItem is None: live_item = MediaItem( "\a.: Live TV :.", "https://d5ms27yy6exnf.cloudfront.net/live/omroepflevoland/tv/index.m3u8" ) live_item.icon = self.icon live_item.thumb = self.noImage live_item.type = 'video' live_item.dontGroup = True now = datetime.datetime.now() live_item.set_date(now.year, now.month, now.day, now.hour, now.minute, now.second) items.append(live_item) live_item = MediaItem( "\a.: Live Radio :.", "https://d5ms27yy6exnf.cloudfront.net/live/omroepflevoland/radio/index.m3u8" ) live_item.icon = self.icon live_item.thumb = self.noImage live_item.type = 'video' live_item.dontGroup = True now = datetime.datetime.now() live_item.set_date(now.year, now.month, now.day, now.hour, now.minute, now.second) items.append(live_item) # add "More" more = LanguageHelper.get_localized_string(LanguageHelper.MorePages) current_url = self.parentItem.url if self.parentItem is not None else self.mainListUri url, page = current_url.rsplit("=", 1) url = "{}={}".format(url, int(page) + 1) item = MediaItem(more, url) item.thumb = self.noImage item.icon = self.icon item.fanart = self.fanart item.complete = True items.append(item) return data, items
def add_recent_items(self, data): """ Builds the "Recent" folder for this channel. :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] recent = MediaItem("\a .: Recent :.", "") recent.type = "folder" recent.complete = True recent.dontGroup = True items.append(recent) today = datetime.datetime.now() days = [ "Maandag", "Dinsdag", "Woensdag", "Donderdag", "Vrijdag", "Zaterdag", "Zondag" ] for i in range(0, 7, 1): air_date = today - datetime.timedelta(i) Logger.trace("Adding item for: %s", air_date) # Determine a nice display date day = days[air_date.weekday()] if i == 0: day = "Vandaag" elif i == 1: day = "Gisteren" elif i == 2: day = "Eergisteren" title = "%04d-%02d-%02d - %s" % (air_date.year, air_date.month, air_date.day, day) # url = "https://www.npostart.nl/media/series?page=1&dateFrom=%04d-%02d-%02d&tileMapping=normal&tileType=teaser&pageType=catalogue" % \ url = "https://xlapi.rtl.nl/version=1/fun=gemist/model=svod/bcdate=" \ "{0:04d}{1:02d}{2:02d}/".format(air_date.year, air_date.month, air_date.day) extra = MediaItem(title, url) extra.complete = True extra.icon = self.icon extra.thumb = self.noImage extra.dontGroup = True extra.set_date(air_date.year, air_date.month, air_date.day, text="") recent.items.append(extra) news = MediaItem("\a .: Zoeken :.", "#searchSite") news.type = "folder" news.complete = True news.dontGroup = True items.append(news) return data, items
def add_others(self, data): """ Performs pre-process actions for data processing. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Performing Pre-Processing") items = [] others = MediaItem( "\b.: Populair :.", "https://api.kijk.nl/v2/default/sections/popular_PopularVODs?offset=0" ) items.append(others) days = MediaItem("\b.: Deze week :.", "#lastweek") items.append(days) search = MediaItem("\b.: Zoeken :.", "searchSite") search.complete = True search.dontGroup = True search.HttpHeaders = {"X-Requested-With": "XMLHttpRequest"} items.append(search) if self.channelCode == "veronica": live = LanguageHelper.get_localized_string( LanguageHelper.LiveStreamTitleId) live_radio = MediaItem("Radio Veronica {}".format(live), "") live_radio.type = "video" live_radio.dontGroup = True part = live_radio.create_new_empty_media_part() live_stream = "https://talparadiohls-i.akamaihd.net/hls/live/585615/VR-Veronica-1/playlist.m3u8" if AddonSettings.use_adaptive_stream_add_on(with_encryption=False, channel=self): stream = part.append_media_stream(live_stream, 0) M3u8.set_input_stream_addon_input(stream, self.proxy) live_radio.complete = True else: for s, b in M3u8.get_streams_from_m3u8(live_stream, self.proxy): live_radio.complete = True part.append_media_stream(s, b) items.append(live_radio) Logger.debug("Pre-Processing finished") return data, items
def add_search_and_genres(self, data): """ Performs pre-process actions for data processing and adds a search option and genres. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Performing Pre-Processing") items = [] if self.parentItem is not None and "genre" in self.parentItem.metaData: self.__genre = self.parentItem.metaData["genre"] Logger.debug("Parsing a specific genre: %s", self.__genre) return data, items search_item = MediaItem("\a.: Sök :.", "searchSite") search_item.complete = True search_item.thumb = self.noImage search_item.dontGroup = True search_item.fanart = self.fanart # search_item.set_date(2099, 1, 1, text="") # -> No items have dates, so adding this will force a date sort in Retrospect items.append(search_item) genres_item = MediaItem("\a.: Genrer :.", "") genres_item.complete = True genres_item.thumb = self.noImage genres_item.dontGroup = True genres_item.fanart = self.fanart items.append(genres_item) # find the actual genres genre_regex = '<li[^>]+genre[^>]*><button[^>]+data-value="(?<genre>[^"]+)"[^>]*>' \ '(?<title>[^>]+)</button></li>' genre_regex = Regexer.from_expresso(genre_regex) genres = Regexer.do_regex(genre_regex, data) for genre in genres: if genre["genre"] == "all": continue genre_item = MediaItem(genre["title"], self.mainListUri) genre_item.complete = True genre_item.thumb = self.noImage genre_item.fanart = self.fanart genre_item.metaData = {"genre": genre["genre"]} genres_item.items.append(genre_item) Logger.debug("Pre-Processing finished") return data, items
def add_categories(self, data): """ Performs pre-process actions for data processing. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Performing Pre-Processing") items = [] cat = MediaItem( "\b.: Categorieën :.", "http://m.schooltv.nl/api/v1/categorieen.json?size=100") cat.complete = True cat.dontGroup = True items.append(cat) tips = MediaItem( "\b.: Tips :.", "http://m.schooltv.nl/api/v1/programmas/tips.json?size=100") tips.complete = True tips.dontGroup = True items.append(tips) data = JsonHelper(data) ages = MediaItem("\b.: Leeftijden :.", "") ages.complete = True ages.dontGroup = True for age in ("0-4", "5-6", "7-8", "9-12", "13-15", "16-18"): age_item = MediaItem( "%s Jaar" % (age, ), "http://m.schooltv.nl/api/v1/leeftijdscategorieen/%s/afleveringen.json?" "size=%s&sort=Nieuwste" % (age, self.__PageSize)) age_item.complete = True age_item.dontGroup = True ages.items.append(age_item) # We should list programs instead of videos, so just prefill them here. for program in data.get_value(): if age in program['ageGroups']: age_item.items.append(self.create_episode_item(program)) items.append(ages) Logger.debug("Pre-Processing finished") return data, items
def add_other_items(self, data): """ Performs pre-process actions for data processing and adds the live channels if present. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] if self.liveUrls: live_title = LanguageHelper.get_localized_string( LanguageHelper.LiveStreamTitleId) live_item = MediaItem("\a{}".format(live_title), "") live_item.dontGroup = True items.append(live_item) for name, url in self.liveUrls.items(): item = MediaItem(name, url) item.type = "video" item.isLive = True live_item.items.append(item) elif self.liveUrl: Logger.debug("Adding live item") live_title = LanguageHelper.get_localized_string( LanguageHelper.LiveStreamTitleId) live_item = MediaItem("\a{}".format(live_title), self.liveUrl) live_item.dontGroup = True items.append(live_item) if self.recentUrl: Logger.debug("Adding recent item") recent_title = LanguageHelper.get_localized_string( LanguageHelper.Recent) recent_item = MediaItem("\a{}".format(recent_title), self.recentUrl) recent_item.dontGroup = True items.append(recent_item) return data, items
def add_live_streams_and_recent(self, data): """ Adds the live streams for RTL-Z. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] # let's add the RTL-Z live stream rtlz_live = MediaItem("RTL Z Live Stream", "") rtlz_live.icon = self.icon rtlz_live.thumb = self.noImage rtlz_live.complete = True rtlz_live.isLive = True rtlz_live.dontGroup = True stream_item = MediaItem( "RTL Z: Live Stream", "http://www.rtl.nl/(config=RTLXLV2,channel=rtlxl,progid=rtlz,zone=inlineplayer.rtl.nl/rtlz,ord=0)/system/video/wvx/components/financien/rtlz/miMedia/livestream/rtlz_livestream.xml/1500.wvx" ) stream_item.icon = self.icon stream_item.thumb = self.noImage stream_item.complete = True stream_item.type = "video" stream_item.dontGroup = True stream_item.append_single_stream("http://mss6.rtl7.nl/rtlzbroad", 1200) stream_item.append_single_stream("http://mss26.rtl7.nl/rtlzbroad", 1200) stream_item.append_single_stream("http://mss4.rtl7.nl/rtlzbroad", 1200) stream_item.append_single_stream("http://mss5.rtl7.nl/rtlzbroad", 1200) stream_item.append_single_stream("http://mss3.rtl7.nl/rtlzbroad", 1200) rtlz_live.items.append(stream_item) items.append(rtlz_live) # Add recent items data, recent_items = self.add_recent_items(data) return data, recent_items
def add_categories(self, data): """ Adds categories to the main listings. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Performing Pre-Processing") items = [] if self.parentItem and "code" in self.parentItem.metaData: self.__currentChannel = self.parentItem.metaData["code"] Logger.info("Only showing items for channel: '%s'", self.__currentChannel) return data, items cat = MediaItem("\a.: Categoriën :.", "https://www.vrt.be/vrtnu/categorieen.model.json") cat.fanart = self.fanart cat.thumb = self.noImage cat.icon = self.icon cat.dontGroup = True items.append(cat) live = MediaItem("\a.: Live Streams :.", "https://services.vrt.be/videoplayer/r/live.json") live.fanart = self.fanart live.thumb = self.noImage live.icon = self.icon live.dontGroup = True live.isLive = True items.append(live) channel_text = LanguageHelper.get_localized_string(30010) channels = MediaItem("\a.: %s :." % (channel_text, ), "#channels") channels.fanart = self.fanart channels.thumb = self.noImage channels.icon = self.icon channels.dontGroup = True items.append(channels) Logger.debug("Pre-Processing finished") return data, items
def add_graphql_recents(self, data): items = [] today = datetime.datetime.now() days = LanguageHelper.get_days_list() for i in range(0, 7, 1): air_date = today - datetime.timedelta(i) Logger.trace("Adding item for: %s", air_date) # Determine a nice display date day = days[air_date.weekday()] if i == 0: day = LanguageHelper.get_localized_string(LanguageHelper.Today) elif i == 1: day = LanguageHelper.get_localized_string(LanguageHelper.Yesterday) title = "%04d-%02d-%02d - %s" % (air_date.year, air_date.month, air_date.day, day) recent_url = self.__get_api_query_url( "programsByDate(date:\"{:04d}-{:02d}-{:02d}\",numOfDays:0)".format( air_date.year, air_date.month, air_date.day), "{items{__typename,title,description,guid,updated,seriesTvSeasons{id}," "imageMedia{url,label},type,sources{type,drm,file},series{title},seasonNumber," "tvSeasonEpisodeNumber,lastPubDate}}" ) extra = MediaItem(title, recent_url) extra.complete = True extra.dontGroup = True extra.metaData["title_format"] = "{2} - s{0:02d}e{1:02d}" extra.set_date(air_date.year, air_date.month, air_date.day, text="") items.append(extra) return data, items
def add_category_and_live_items(self, data): """ Performs pre-process actions for data processing. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Performing Pre-Processing") items = [] sub_items = { "\a.: Direct :.": "%s/auvio/direct/" % (self.baseUrl, ), "\a.: Catégories :.": "http://www.rtbf.be/news/api/menu?site=media" } for k, v in sub_items.items(): item = MediaItem(k, v) item.complete = True item.dontGroup = True items.append(item) item.isLive = v.endswith('/direct/') Logger.debug("Pre-Processing finished") return data, items
def add_search(self, data): """ Adds a search item. The return values should always be instantiated in at least ("", []). :param JsonHelper data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Performing Pre-Processing") items = [] title = "\a.: %s :." % (self.searchInfo.get( self.language, self.searchInfo["se"])[1], ) Logger.trace("Adding search item: %s", title) search_item = MediaItem(title, "searchSite") search_item.thumb = self.noImage search_item.fanart = self.fanart search_item.dontGroup = True items.append(search_item) Logger.debug("Pre-Processing finished") return data, items
def add_special_categories(self, data): """ Adds extra items to the mainlist. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] extras = { # "Verwacht": "https://connect.pathe.nl/v1/movies/comingsoon/", "Verwacht": "https://connect.pathe.nl/v1/movies/lists/", "Specials": "https://connect.pathe.nl/v1/specials/movies/" } for title, url in extras.items(): expected = MediaItem("\a{}".format(title), url) expected.content_type = contenttype.MOVIES expected.dontGroup = True items.append(expected) return data, items
def list_channels(self, data): """ Lists all the available channels. :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] for name, meta in self.__channelData.items(): if "metaCode" not in meta: continue channel = MediaItem(meta["title"], self.mainListUri) # noinspection PyArgumentList channel.fanart = meta.get("fanart", self.fanart) # noinspection PyArgumentList channel.thumb = meta.get("icon", self.icon) # noinspection PyArgumentList channel.icon = meta.get("icon", self.icon) channel.dontGroup = True channel.metaData["code"] = meta["metaCode"] items.append(channel) return data, items
def add_graphql_recents(self, data): items = [] today = datetime.datetime.now() days = LanguageHelper.get_days_list() for i in range(0, 7, 1): air_date = today - datetime.timedelta(i) Logger.trace("Adding item for: %s", air_date) # Determine a nice display date day = days[air_date.weekday()] if i == 0: day = LanguageHelper.get_localized_string(LanguageHelper.Today) elif i == 1: day = LanguageHelper.get_localized_string( LanguageHelper.Yesterday) title = "%04d-%02d-%02d - %s" % (air_date.year, air_date.month, air_date.day, day) recent_url = self.__get_api_query_url( "programsByDate(date:\"{:04d}-{:02d}-{:02d}\",numOfDays:0)". format(air_date.year, air_date.month, air_date.day), self.__video_fields) extra = MediaItem(title, recent_url) extra.complete = True extra.dontGroup = True extra.metaData["title_format"] = "{2} - s{0:02d}e{1:02d}" extra.set_date(air_date.year, air_date.month, air_date.day, text="") items.append(extra) return data, items
def add_live_items(self, data): """ Performs pre-process actions for data processing and adds the live channels if present. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] if self.liveUrl: Logger.debug("Adding live item") live_item = MediaItem("\aLive TV", self.liveUrl) live_item.dontGroup = True items.append(live_item) return data, items
def add_categories_and_search(self, data): """ Adds some generic items such as search and categories to the main listing. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Performing Pre-Processing") items = [] max_items = 200 categories = { LanguageHelper.Popular: "https://urplay.se/api/bff/v1/search?product_type=program&query=&rows={}&start=0&view=most_viewed".format(max_items), LanguageHelper.MostRecentEpisodes: "https://urplay.se/api/bff/v1/search?product_type=program&rows={}&start=0&view=published".format(max_items), LanguageHelper.LastChance: "https://urplay.se/api/bff/v1/search?product_type=program&rows={}&start=0&view=last_chance".format(max_items), LanguageHelper.Categories: "https://urplay.se/", LanguageHelper.Search: "searchSite" } for cat in categories: title = "\a.: {} :.".format(LanguageHelper.get_localized_string(cat)) item = MediaItem(title, categories[cat]) item.thumb = self.noImage item.complete = True item.icon = self.icon item.dontGroup = True items.append(item) Logger.debug("Pre-Processing finished") return data, items
def alpha_listing(self, data): """ Creates a alpha listing with items pointing to the alpha listing on line. :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Generating an Alpha list for BBC") items = [] # https://www.bbc.co.uk/iplayer/a-z/a title_format = LanguageHelper.get_localized_string(LanguageHelper.StartWith) url_format = "https://www.bbc.co.uk/iplayer/a-z/%s" for char in "abcdefghijklmnopqrstuvwxyz0": if char == "0": char = "0-9" sub_item = MediaItem(title_format % (char.upper(),), url_format % (char,)) sub_item.complete = True sub_item.dontGroup = True sub_item.HttpHeaders = {"X-Requested-With": "XMLHttpRequest"} items.append(sub_item) return data, items
def __show_empty_information(self, items, favs=False): """ Adds an empty item to a list or just shows a message. @type favs: boolean @param items: :param list[MediaItem] items: The list of items. :param bool favs: Indicating that we are dealing with favourites. :return: boolean indicating to report the listing as succes or not. :rtype: ok """ if favs: title = LanguageHelper.get_localized_string(LanguageHelper.NoFavsId) else: title = LanguageHelper.get_localized_string(LanguageHelper.ErrorNoEpisodes) behaviour = AddonSettings.get_empty_list_behaviour() Logger.debug("Showing empty info for mode (favs=%s): [%s]", favs, behaviour) if behaviour == "error": # show error ok = False elif behaviour == "dummy" and not favs: # We should add a dummy items, but not for favs empty_list_item = MediaItem("- %s -" % (title.strip("."), ), "", type='video') if self.channelObject: empty_list_item.icon = self.channelObject.icon empty_list_item.thumb = self.channelObject.noImage empty_list_item.fanart = self.channelObject.fanart else: icon = Config.icon fanart = Config.fanart empty_list_item.icon = icon empty_list_item.thumb = fanart empty_list_item.fanart = fanart empty_list_item.dontGroup = True empty_list_item.description = "This listing was left empty intentionally." empty_list_item.complete = True # add funny stream here? # part = empty_list_item.create_new_empty_media_part() # for s, b in YouTube.get_streams_from_you_tube("", self.channelObject.proxy): # part.append_media_stream(s, b) # if we add one, set OK to True ok = True items.append(empty_list_item) else: ok = True XbmcWrapper.show_notification(LanguageHelper.get_localized_string(LanguageHelper.ErrorId), title, XbmcWrapper.Error, 2500) return ok
def add_graphql_extras(self, data): """ Adds additional items to the main listings :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] if self.parentItem is not None: return data, items popular_url = self.__get_api_query_url( "trendingPrograms", "{__typename,title,description,guid,updated,seriesTvSeasons{id},imageMedia{url,label}}" ) popular_title = LanguageHelper.get_localized_string(LanguageHelper.Popular) popular = MediaItem( "\a.: {} :.".format(popular_title), popular_url ) popular.dontGroup = True items.append(popular) # https://graph.kijk.nl/graphql?operationName=programsByDate&variables={"date":"2020-04-19","numOfDays":7}&extensions={"persistedQuery":{"version":1,"sha256Hash":"1445cc0d283e10fa21fcdf95b127207d5f8c22834c1d0d17df1aacb8a9da7a8e"}} recent_url = "#recentgraphql" recent_title = LanguageHelper.get_localized_string(LanguageHelper.Recent) recent = MediaItem( "\a.: {} :.".format(recent_title), recent_url ) recent.dontGroup = True items.append(recent) search_title = LanguageHelper.get_localized_string(LanguageHelper.Search) search = MediaItem("\a.: {} :.".format(search_title), "#searchSite") search.dontGroup = True items.append(search) return data, items
def __show_empty_information(self, items, favs=False): """ Adds an empty item to a list or just shows a message. @type favs: boolean @param items: :param list[MediaItem] items: The list of items. :param bool favs: Indicating that we are dealing with favourites. :return: boolean indicating to report the listing as succes or not. :rtype: ok """ if favs: title = LanguageHelper.get_localized_string( LanguageHelper.NoFavsId) else: title = LanguageHelper.get_localized_string( LanguageHelper.ErrorNoEpisodes) behaviour = AddonSettings.get_empty_list_behaviour() Logger.debug("Showing empty info for mode (favs=%s): [%s]", favs, behaviour) if behaviour == "error": # show error ok = False elif behaviour == "dummy" and not favs: # We should add a dummy items, but not for favs empty_list_item = MediaItem("- %s -" % (title.strip("."), ), "", type='video') empty_list_item.dontGroup = True empty_list_item.complete = True # if we add one, set OK to True ok = True items.append(empty_list_item) else: ok = True XbmcWrapper.show_notification( LanguageHelper.get_localized_string(LanguageHelper.ErrorId), title, XbmcWrapper.Error, 2500) return ok
def extract_json(self, data): """ Extracts JSON data from pages :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] recent = MediaItem("\a .: Recent :.", "https://www.een.be/deze-week") recent.type = "folder" recent.complete = True recent.dontGroup = True items.append(recent) data = Regexer.do_regex(r'epgAZ\W+({"data"[\w\W]+?);<', data)[0] return data, items
def add_page_items(self, data): """ Performs pre-process actions for data processing. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Performing Pre-Processing") items = [] json = JsonHelper(data) total_results = json.get_value("totalResults") from_value = json.get_value("from") size_value = json.get_value("size") if from_value + size_value < total_results: more_pages = LanguageHelper.get_localized_string( LanguageHelper.MorePages) url = self.parentItem.url.split('?')[0] url = "%s?size=%s&from=%s&sort=Nieuwste" % ( url, size_value, from_value + size_value) Logger.debug("Adding next-page item from %s to %s", from_value + size_value, from_value + size_value + size_value) next_page = MediaItem(more_pages, url) next_page.icon = self.parentItem.icon next_page.fanart = self.parentItem.fanart next_page.thumb = self.parentItem.thumb next_page.dontGroup = True items.append(next_page) Logger.debug("Pre-Processing finished") return json, items
def add_recent_items(self, data): """ Performs pre-process actions for data processing. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] today = datetime.datetime.now() days = LanguageHelper.get_days_list() for d in range(0, 7, 1): air_date = today - datetime.timedelta(d) Logger.trace("Adding item for: %s", air_date) # Determine a nice display date day = days[air_date.weekday()] if d == 0: day = LanguageHelper.get_localized_string(LanguageHelper.Today) elif d == 1: day = LanguageHelper.get_localized_string(LanguageHelper.Yesterday) title = "%04d-%02d-%02d - %s" % (air_date.year, air_date.month, air_date.day, day) url = "https://www.goplay.be/api/epg/{}/{:04d}-{:02d}-{:02d}".\ format(self.__channel_brand, air_date.year, air_date.month, air_date.day) extra = MediaItem(title, url) extra.complete = True extra.dontGroup = True extra.set_date(air_date.year, air_date.month, air_date.day, text="") extra.content_type = contenttype.VIDEOS items.append(extra) return data, items
def add_search(self, data): """ Add a "search" item to the listing. :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Performing Pre-Processing") items = [] title = "\a.: %s :." % (self.searchInfo.get(self.language, self.searchInfo["se"])[1], ) Logger.trace("Adding search item: %s", title) search_item = MediaItem(title, "searchSite") search_item.dontGroup = True items.append(search_item) Logger.debug("Pre-Processing finished") return data, items
def add_live_channel(self, data): """ Adds the live channel. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ # Only get the first bit items = [] item = MediaItem("\a.: Live :.", "http://sporza.be/cm/sporza/matchcenter/mc_livestream") item.type = "folder" item.dontGroup = True item.complete = False items.append(item) return data, items
def add_pages(self, data): """ Performs pre-process actions for data processing. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Adding pages") # extract the current page from: # http://www.foxsports.nl/video/filter/fragments/1/alle/tennis/ current_pages = Regexer.do_regex(r'(.+filter/fragments)/(\d+)/(.+)', self.parentItem.url) if not current_pages: return data, [] current_page = current_pages[0] items = [] url = "%s/%s/%s" % (current_page[0], int(current_page[1]) + 1, current_page[2]) page_item = MediaItem( LanguageHelper.get_localized_string(LanguageHelper.MorePages), url) page_item.fanart = self.parentItem.fanart page_item.thumb = self.parentItem.thumb page_item.dontGroup = True items.append(page_item) return data, items
def load_programs(self, data): """ Performs pre-process actions for data processing. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ items = [] # fetch al pages p = 1 url_format = "https://{0}/content/shows?" \ "include=images" \ "&page%5Bsize%5D=100&page%5Bnumber%5D={{0}}".format(self.baseUrlApi) # "include=images%2CprimaryChannel" \ url = url_format.format(p) data = UriHandler.open(url, proxy=self.proxy) json = JsonHelper(data) pages = json.get_value("meta", "totalPages") programs = json.get_value("data") or [] # extract the images self.__update_image_lookup(json) for p in range(2, pages + 1, 1): url = url_format.format(p) Logger.debug("Loading: %s", url) data = UriHandler.open(url, proxy=self.proxy) json = JsonHelper(data) programs += json.get_value("data") or [] # extract the images self.__update_image_lookup(json) Logger.debug("Found a total of %s items over %s pages", len(programs), pages) for p in programs: item = self.create_program_item(p) if item is not None: items.append(item) if self.recentUrl: recent_text = LanguageHelper.get_localized_string( LanguageHelper.Recent) recent = MediaItem("\b.: {} :.".format(recent_text), self.recentUrl) recent.dontGroup = True items.append(recent) # live items if self.liveUrl: live = MediaItem("\b.: Live :.", self.liveUrl) live.type = "video" live.dontGroup = True live.isGeoLocked = True live.isLive = True items.append(live) search = MediaItem("\a.: Sök :.", "searchSite") search.type = "folder" search.dontGroup = True items.append(search) return data, items
def add_categories_and_specials(self, data): """ Performs pre-process actions for data processing. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Performing Pre-Processing") items = [] extras = { LanguageHelper.get_localized_string(LanguageHelper.Search): ("searchSite", None, False), LanguageHelper.get_localized_string(LanguageHelper.TvShows): ("https://api.tv4play.se/play/programs?is_active=true&platform=tablet" "&per_page=1000&fl=nid,name,program_image,is_premium,updated_at,channel&start=0", None, False) } # Channel 4 specific items if self.channelCode == "tv4se": extras.update({ LanguageHelper.get_localized_string(LanguageHelper.Categories): ("https://api.tv4play.se/play/categories.json", None, False), LanguageHelper.get_localized_string(LanguageHelper.MostViewedEpisodes): ("https://api.tv4play.se/play/video_assets/most_viewed?type=episode" "&platform=tablet&is_live=false&per_page=%s&start=0" % (self.maxPageSize, ), None, False), }) today = datetime.datetime.now() days = [ LanguageHelper.get_localized_string(LanguageHelper.Monday), LanguageHelper.get_localized_string(LanguageHelper.Tuesday), LanguageHelper.get_localized_string(LanguageHelper.Wednesday), LanguageHelper.get_localized_string(LanguageHelper.Thursday), LanguageHelper.get_localized_string(LanguageHelper.Friday), LanguageHelper.get_localized_string(LanguageHelper.Saturday), LanguageHelper.get_localized_string(LanguageHelper.Sunday) ] for i in range(0, 7, 1): start_date = today - datetime.timedelta(i) end_date = start_date + datetime.timedelta(1) day = days[start_date.weekday()] if i == 0: day = LanguageHelper.get_localized_string( LanguageHelper.Today) elif i == 1: day = LanguageHelper.get_localized_string( LanguageHelper.Yesterday) Logger.trace("Adding item for: %s - %s", start_date, end_date) # Old URL: # url = "https://api.tv4play.se/play/video_assets?exclude_node_nids=" \ # "nyheterna,v%C3%A4der,ekonomi,lotto,sporten,nyheterna-blekinge,nyheterna-bor%C3%A5s," \ # "nyheterna-dalarna,nyheterna-g%C3%A4vle,nyheterna-g%C3%B6teborg,nyheterna-halland," \ # "nyheterna-helsingborg,nyheterna-j%C3%B6nk%C3%B6ping,nyheterna-kalmar,nyheterna-link%C3%B6ping," \ # "nyheterna-lule%C3%A5,nyheterna-malm%C3%B6,nyheterna-norrk%C3%B6ping,nyheterna-skaraborg," \ # "nyheterna-skellefte%C3%A5,nyheterna-stockholm,nyheterna-sundsvall,nyheterna-ume%C3%A5," \ # "nyheterna-uppsala,nyheterna-v%C3%A4rmland,nyheterna-v%C3%A4st,nyheterna-v%C3%A4ster%C3%A5s," \ # "nyheterna-v%C3%A4xj%C3%B6,nyheterna-%C3%B6rebro,nyheterna-%C3%B6stersund,tv4-tolken," \ # "fotbollskanalen-europa" \ # "&platform=tablet&per_page=32&is_live=false&product_groups=2&type=episode&per_page=100" url = "https://api.tv4play.se/play/video_assets?exclude_node_nids=" \ "&platform=tablet&per_page=32&is_live=false&product_groups=2&type=episode&per_page=100" url = "%s&broadcast_from=%s&broadcast_to=%s&" % ( url, start_date.strftime("%Y%m%d"), end_date.strftime("%Y%m%d")) extras[day] = (url, start_date, False) extras[LanguageHelper.get_localized_string( LanguageHelper.CurrentlyPlayingEpisodes )] = ( "https://api.tv4play.se/play/video_assets?exclude_node_nids=&platform=tablet&" "per_page=32&is_live=true&product_groups=2&type=episode&per_page=100", None, False) for name in extras: title = name url, date, is_live = extras[name] item = MediaItem(title, url) item.dontGroup = True item.complete = True item.HttpHeaders = self.httpHeaders item.isLive = is_live if date is not None: item.set_date(date.year, date.month, date.day, 0, 0, 0, text=date.strftime("%Y-%m-%d")) items.append(item) if not self.channelCode == "tv4se": return data, items # Add Live TV # live = MediaItem("\a.: Live-TV :.", # "http://tv4events1-lh.akamaihd.net/i/EXTRAEVENT5_1@324055/master.m3u8", # type="video") # live.dontGroup = True # # live.isDrmProtected = True # live.isGeoLocked = True # live.isLive = True # items.append(live) Logger.debug("Pre-Processing finished") return data, items
def add_live_channels_and_folders(self, data): """ Performs pre-process actions for data processing. Accepts an data from the process_folder_list method, BEFORE the items are processed. Allows setting of parameters (like title etc) for the channel. Inside this method the <data> could be changed and additional items can be created. The return values should always be instantiated in at least ("", []). :param str data: The retrieve data that was loaded for the current item and URL. :return: A tuple of the data and a list of MediaItems that were generated. :rtype: tuple[str|JsonHelper,list[MediaItem]] """ Logger.info("Generating Live channels") items = [] live_channels = [ {"name": "BBC 1 HD", "code": "bbc_one_hd", "image": "bbc1large.png"}, {"name": "BBC 2 HD", "code": "bbc_two_hd", "image": "bbc2large.png"}, {"name": "BBC 3 HD", "code": "bbc_three_hd", "image": "bbc3large.png"}, {"name": "BBC 4 HD", "code": "bbc_four_hd", "image": "bbc4large.png"}, {"name": "CBBC", "code": "cbbc_hd", "image": "cbbclarge.png"}, {"name": "CBeebies", "code": "cbeebies_hd", "image": "cbeebieslarge.png"}, {"name": "BBC News Channel", "code": "bbc_news24", "image": "bbcnewslarge.png"}, {"name": "BBC Parliament", "code": "bbc_parliament", "image": "bbcparliamentlarge.png"}, {"name": "Alba", "code": "bbc_alba", "image": "bbcalbalarge.png"}, {"name": "S4C", "code": "s4cpbs", "image": "bbchdlarge.png"}, {"name": "BBC One London", "code": "bbc_one_london", "image": "bbchdlarge.png"}, {"name": "BBC One Scotland", "code": "bbc_one_scotland_hd", "image": "bbchdlarge.png"}, {"name": "BBC One Northern Ireland", "code": "bbc_one_northern_ireland_hd", "image": "bbchdlarge.png"}, {"name": "BBC One Wales", "code": "bbc_one_wales_hd", "image": "bbchdlarge.png"}, {"name": "BBC Two Scotland", "code": "bbc_two_scotland", "image": "bbchdlarge.png"}, {"name": "BBC Two Northern Ireland", "code": "bbc_two_northern_ireland_digital", "image": "bbchdlarge.png"}, {"name": "BBC Two Wales", "code": "bbc_two_wales_digital", "image": "bbchdlarge.png"}, ] live = MediaItem("Live Channels", "") live.dontGroup = True live.type = "folder" items.append(live) for channel in live_channels: url = "http://a.files.bbci.co.uk/media/live/manifesto/audio_video/simulcast/hds/uk/pc/ak/%(code)s.f4m" % channel item = MediaItem(channel["name"], url) item.isGeoLocked = True item.isLive = True item.type = "video" item.complete = False item.thumb = self.get_image_location(channel["image"]) live.items.append(item) extra = MediaItem("Shows (A-Z)", "#alphalisting") extra.complete = True extra.description = "Alphabetical show listing of BBC shows" extra.dontGroup = True items.append(extra) return data, items