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
