def create_json_genre(self, result_set):
""" Creates a MediaItem of type 'folder' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
genres = []
for cluster in result_set['clusters']:
Logger.trace(cluster)
url = "%s%s" % (self.baseUrl, cluster['contentUrl'])
genre = MediaItem(cluster['name'], url)
genre.icon = self.icon
genre.description = cluster.get('description')
genre.fanart = cluster.get(
'backgroundImage') or self.parentItem.fanart
genre.fanart = self.__get_thumb(genre.fanart,
thumb_size="/extralarge/")
genre.thumb = cluster.get('thumbnailImage') or self.noImage
genre.thumb = self.__get_thumb(genre.thumb)
genres.append(genre)
return genres
def create_json_tag_item(self, result_set):
""" Creates a MediaItem of type 'folder' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
Logger.trace(result_set)
url = "https://www.svtplay.se/api/cluster_titles_and_episodes?cluster={}".format(
result_set['slug'])
genre = MediaItem(result_set['name'], url)
genre.icon = self.icon
genre.description = result_set.get('description')
genre.fanart = result_set.get(
'backgroundImage') or self.parentItem.fanart
genre.fanart = self.__get_thumb(genre.fanart,
thumb_size="/extralarge/")
genre.thumb = result_set.get('thumbnailImage') or self.noImage
genre.thumb = self.__get_thumb(genre.thumb)
return genre
def AddLiveChannel(self, data):
Logger.Info("Performing Pre-Processing")
# if self.channelCode != "vtm":
# return data, []
username = AddonSettings.GetSetting("mediaan_username")
if not username:
return data, []
items = []
if self.channelCode == "vtm":
item = MediaItem("Live VTM", "#livestream")
else:
item = MediaItem("Live Q2", "#livestream")
item.type = "video"
item.isLive = True
item.fanart = self.fanart
item.thumb = self.noImage
now = datetime.datetime.now()
item.SetDate(now.year, now.month, now.day, now.hour, now.minute, now.second)
items.append(item)
if self.channelCode == "vtm":
recent = MediaItem("\a.: Recent :.", "https://vtm.be/video/volledige-afleveringen/id")
item.fanart = self.fanart
item.thumb = self.noImage
item.dontGroup = True
items.append(recent)
Logger.Debug("Pre-Processing finished")
return data, items
def create_video_item(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
Logger.trace(result_set)
url = "%s%s" % (self.baseUrl, result_set["Url"])
item = MediaItem(result_set["Title"], url)
item.type = "video"
item.thumb = result_set["Thumb"]
item.complete = False
if self.parentItem is None:
item.fanart = self.fanart
else:
item.fanart = self.parentItem.fanart
return item
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):
""" 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/")
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 create_series_season_item(self, result_set):
""" Creates a MediaItem of type 'folder' for a season using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param list[str]|dict result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
title = "Sesong {}".format(result_set["name"])
season_id = result_set["id"]
if not result_set.get("hasOnDemandRightsEpisodes", True):
return None
parent_url, qs = self.parentItem.url.split("?", 1)
url = "{}/seasons/{}/episodes?apiKey={}".format(
parent_url, season_id, self.__api_key)
item = MediaItem(title, url)
item.type = 'folder'
item.thumb = self.parentItem.thumb
item.fanart = self.parentItem.fanart
return item
def create_category_item(self, result_set):
""" Creates a MediaItem of type 'folder' for a category using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
title = result_set["displayValue"]
category_id = result_set["id"]
url = "https://psapi.nrk.no/medium/tv/categories/{}/indexelements?apiKey={}"\
.format(category_id, self.__api_key)
item = MediaItem(title, url)
item.icon = self.icon
item.type = 'folder'
item.fanart = self.fanart
item.thumb = self.__category_thumbs.get(category_id.lower(),
self.noImage)
return item
def create_alpha_item(self, result_set):
""" Creates a MediaItem of type 'folder' using the Alpha chars available. It uses
the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
program_count = result_set.get("availableInternationally", 0)
if program_count <= 0:
return None
title = result_set["title"]
url_part = title.lower()
if url_part == "0-9":
url_part = "$"
url = "https://psapi.nrk.no/medium/tv/letters/{}/indexelements?onlyOnDemandRights=false&" \
"apiKey={}".format(url_part, self.__api_key)
title = LanguageHelper.get_localized_string(
LanguageHelper.StartWith) % (title, )
item = MediaItem(title, url)
item.icon = self.icon
item.type = 'folder'
item.fanart = self.fanart
item.thumb = self.noImage
return item
def create_instalment_season_item(self, result_set):
""" Creates a MediaItem of type 'folder' for a season using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param list[str]|dict result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
title = result_set["title"]
season_id = result_set["name"]
if title != season_id:
title = "{} - {}".format(season_id, title)
url = "{}{}?apiKey={}".format(self.baseUrl, result_set["href"],
self.__api_key)
item = MediaItem(title, url)
item.type = 'folder'
item.thumb = self.parentItem.thumb
item.fanart = self.parentItem.fanart
return item
def create_json_season_item(self, result_set):
""" Creates a MediaItem of type 'folder' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
Logger.trace(result_set)
# {
# "seasonNumber": 3,
# "id": "season-3",
# "episodesId": "achtergeslotendeuren.net5-season-3-episodes",
# "clipsId": "achtergeslotendeuren.net5-season-3-clips",
# "title": "Seizoen 3",
# "format": "achtergeslotendeuren",
# "channel": "net5",
# "episodesLink": "https://api.kijk.nl/v1/default/seasons/achtergeslotendeuren.net5/3/episodes",
# "clipsLink": "https://api.kijk.nl/v1/default/seasons/achtergeslotendeuren.net5/3/clips"
# }
# https://api.kijk.nl/v1/default/seasons/achtergeslotendeuren.net5/2/episodes?limit=100&offset=1
url = "{}?limit=100&offset=1".format(result_set["episodesLink"])
item = MediaItem(result_set["title"], url)
item.fanart = self.parentItem.fanart
item.thumb = self.parentItem.thumb
return item
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 create_trailer(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
Logger.trace(result_set)
url = self.parentItem.url
item = MediaItem(result_set["caption"], url, "video")
item.icon = self.icon
item.thumb = result_set["still"].replace("nocropthumb/[format]/", "")
item.fanart = item.thumb
item.append_single_stream(result_set['filename'])
item.complete = True
item.HttpHeaders = self.httpHeaders
return item
def create_page_item(self, result_set):
""" Creates a MediaItem of type 'page' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'page'.
:rtype: MediaItem|None
"""
Logger.trace(result_set)
next_page = result_set["next"]
if not next_page:
Logger.debug("No more items available")
return None
more = LanguageHelper.get_localized_string(LanguageHelper.MorePages)
url = "%s=%s" % (self.parentItem.url.rsplit("=", 1)[0], next_page)
item = MediaItem(more, url)
item.thumb = self.parentItem.thumb
item.icon = self.icon
item.fanart = self.parentItem.fanart
item.complete = True
return item
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 create_video_item(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
# Logger.Trace(resultSet)
title = result_set["title"]
url = "%s/%s" % (self.baseUrl, result_set["url"])
thumb = "https://assets.ur.se/id/%(id)s/images/1_l.jpg" % result_set
item = MediaItem(title, url)
item.type = "video"
item.thumb = thumb
item.description = result_set["description"]
item.fanart = self.parentItem.fanart
item.icon = self.icon
item.complete = False
self.__videoItemFound = True
return item
def create_single_video_item(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param str result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
if self.__hasAlreadyVideoItems:
# we already have items, so don't show this one, it will be a duplicate
return None
result_set = result_set.replace('\\x27', "'")
json_data = JsonHelper(result_set)
url = self.parentItem.url
title = json_data.get_value("name")
description = HtmlHelper.to_text(json_data.get_value("description"))
item = MediaItem(title, url, type="video")
item.description = description
item.thumb = self.parentItem.thumb
item.fanart = self.parentItem.fanart
return item
def create_episode_item(self, result_set, append_subtitle=True):
""" Creates a new MediaItem for an episode.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:param bool append_subtitle: Should we append a subtitle?
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
Logger.trace(result_set)
url = result_set['href']
if not url.startswith("http"):
url = "{}{}".format(self.baseUrl, url)
title = result_set["title"]
if title is None:
title = self.parentItem.name
elif append_subtitle and "subtitle" in result_set:
title = "{} - {}".format(title, result_set["subtitle"])
item = MediaItem(title, url)
item.description = result_set.get('synopsis', item.description)
image_template = result_set.get("imageTemplate")
item.fanart = image_template.replace("{recipe}", "1920x1080")
item.thumb = image_template.replace("{recipe}", "608x342")
return item
def create_folder_item(self, result_set):
""" Creates a MediaItem of type 'folder' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
Logger.trace(result_set)
if result_set["Type"] == "sport":
# http://www.foxsports.nl/video/filter/alle/tennis/
url = "%s/video/filter/fragments/1/alle/%s/" % (self.baseUrl, result_set["Url"])
elif result_set["Type"] == "meest_bekeken":
url = "%s/video/filter/fragments/1/meer" % (self.baseUrl, )
else:
# http://www.foxsports.nl/video/filter/samenvattingen/
url = "%s/video/filter/fragments/1/%s/" % (self.baseUrl, result_set["Url"])
title = result_set["Title"]
if not title[0].isupper():
title = "%s%s" % (title[0].upper(), title[1:])
item = MediaItem(title, url)
item.complete = True
item.thumb = self.noImage
item.fanart = self.fanart
return item
def create_page_item(self, result_set):
""" Creates a MediaItem of type 'page' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'page'.
:rtype: MediaItem|None
"""
Logger.debug("Starting create_page_item")
total = ''
for result in result_set:
total = "%s%s" % (total, result)
total = HtmlEntityHelper.strip_amp(total)
if not self.pageNavigationRegexIndex == '':
item = MediaItem(result_set[self.pageNavigationRegexIndex],
parse.urljoin(self.baseUrl, total))
else:
item = MediaItem("0", "")
item.type = "page"
item.fanart = self.fanart
item.HttpHeaders = self.httpHeaders
Logger.debug("Created '%s' for url %s", item.name, item.url)
return item
def create_episode_item(self, result_set):
""" Creates a new MediaItem for an episode.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
Logger.trace(result_set)
title = result_set["title"].replace("-", " ").title()
# http://www.nickjr.nl/data/propertyStreamPage.json?&urlKey=dora&apiKey=nl_global_Nickjr_web&page=1
url = "%s/data/propertyStreamPage.json?&urlKey=%s&apiKey=%s&page=1" % (
self.baseUrl, result_set["seriesKey"], self.__apiKey)
item = MediaItem(title, url)
item.icon = self.icon
item.complete = True
item.fanart = self.fanart
item.HttpHeaders = self.httpHeaders
return item
def __ShowEmptyInformation(self, items, favs=False):
""" Adds an empty item to a list or just shows a message.
@type favs: boolean indicating that we are dealing with favourites
@param items: the list of items
@rtype : boolean indicating succes or not
"""
if self.channelObject:
Statistics.RegisterError(self.channelObject)
if favs:
title = LanguageHelper.GetLocalizedString(LanguageHelper.NoFavsId)
else:
title = LanguageHelper.GetLocalizedString(LanguageHelper.ErrorNoEpisodes)
behaviour = AddonSettings.GetEmptyListBehaviour()
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
emptyListItem = MediaItem("- %s -" % (title.strip("."), ), "", type='video')
emptyListItem.icon = self.channelObject.icon
emptyListItem.thumb = self.channelObject.noImage
emptyListItem.fanart = self.channelObject.fanart
emptyListItem.dontGroup = True
emptyListItem.description = "This listing was left empty intentionally."
emptyListItem.complete = True
emptyListItem.fanart = self.channelObject.fanart
# add funny stream here?
# part = emptyListItem.CreateNewEmptyMediaPart()
# for s, b in YouTube.GetStreamsFromYouTube("", self.channelObject.proxy):
# part.AppendMediaStream(s, b)
# if we add one, set OK to True
ok = True
items.append(emptyListItem)
else:
ok = True
XbmcWrapper.ShowNotification(LanguageHelper.GetLocalizedString(LanguageHelper.ErrorId),
title, XbmcWrapper.Error, 2500)
return ok
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 create_instalment_video_item(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param list[str]|dict[str,str|dict] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
title = result_set["titles"]["title"]
sub_title = result_set["titles"]["subtitle"]
# noinspection PyTypeChecker
if result_set.get("availability", {}).get("status",
"available") != "available":
Logger.debug("Found '%s' with a non-available status", title)
return None
url = "https://psapi.nrk.no/programs/{}?apiKey={}".format(
result_set["prfId"], self.__api_key)
item = MediaItem(title, url)
item.type = 'video'
item.thumb = self.__get_image(result_set["image"], "width", "url")
item.fanart = self.parentItem.fanart
# noinspection PyTypeChecker
item.isGeoLocked = result_set.get("usageRights", {}).get(
"geoBlock", {}).get("isGeoBlocked", False)
if sub_title and sub_title.strip():
item.description = sub_title
if "firstTransmissionDateDisplayValue" in result_set:
Logger.trace("Using 'firstTransmissionDateDisplayValue' for date")
day, month, year = result_set[
"firstTransmissionDateDisplayValue"].split(".")
item.set_date(year, month, day)
elif "usageRights" in result_set and "from" in result_set[
"usageRights"] and result_set["usageRights"][
"from"] is not None:
Logger.trace("Using 'usageRights.from.date' for date")
# noinspection PyTypeChecker
date_value = result_set["usageRights"]["from"]["date"].split(
"+")[0]
time_stamp = DateHelper.get_date_from_string(
date_value, date_format="%Y-%m-%dT%H:%M:%S")
item.set_date(*time_stamp[0:6])
return item
def create_json_genre_item(self, result_set):
""" Creates a MediaItem of type 'folder/video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
if "__typename" not in result_set:
return None
item_type = result_set["__typename"].lower()
if item_type not in ("episode", "single", "clip", "tvseries") or "name" not in result_set:
return None
Logger.trace("%s->%s", item_type, result_set)
title = result_set["name"]
if item_type == 'episode' and "parent" in result_set:
# noinspection PyTypeChecker
parent_data = self.__apollo_data[result_set["parent"]["id"]]
parent_title = parent_data["name"]
title = "{} - {}".format(parent_title, title)
if item_type == "clip":
url = "https://www.svtplay.se/klipp/{}/".format(result_set["id"])
elif "urls" in result_set:
# noinspection PyTypeChecker
url_data = self.__apollo_data[result_set["urls"]["id"]]
url = url_data["svtplay"]
url = "{}{}".format(self.baseUrl, url)
else:
Logger.debug("No url found for: %s", title)
return None
item = MediaItem(title, url)
item.description = result_set.get("longDescription")
item.fanart = self.parentItem.fanart
item.type = "video" if item_type != "tvseries" else "folder"
if "image" in result_set:
# noinspection PyTypeChecker
image = result_set["image"]["id"]
image_data = self.__apollo_data[image]
image_url = "https://www.svtstatic.se/image/medium/520/{id}/{changed}".format(**image_data)
item.thumb = image_url
if "restrictions" in result_set:
# noinspection PyTypeChecker
restrictions = self.__apollo_data[result_set["restrictions"]["id"]]
item.isGeoLocked = restrictions.get('onlyAvailableInSweden', False)
return item
def create_video_item(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param dict[str,str|dict] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
Logger.trace(result_set)
is_serie_title = result_set["seriesTitle"]
if not is_serie_title:
return None
if result_set["mediaType"] == "game":
return None
elif result_set["mediaType"] == "episode":
title = "%(title)s (Episode)" % result_set
else:
title = result_set["title"]
video_id = result_set["id"]
url = "http://media.mtvnservices.com/pmt/e1/access/index.html?uri=mgid:%s:%s&configtype=edge" \
% (self.__mgid, video_id, )
item = MediaItem(title, url)
item.description = result_set.get("description", None)
item.type = "video"
item.icon = self.icon
item.fanart = self.fanart
item.HttpHeaders = self.httpHeaders
item.complete = False
if "datePosted" in result_set:
date = DateHelper.get_date_from_posix(
float(result_set["datePosted"]["unixOffset"]) / 1000)
item.set_date(date.year, date.month, date.day, date.hour,
date.minute, date.second)
if "images" in result_set:
images = result_set.get("images", {})
thumbs = images.get("thumbnail", {})
item.thumb = thumbs.get("r16-9", self.noImage)
return item
def create_video_item(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
Logger.trace(result_set)
# Validate the input and raise errors
if not isinstance(result_set, dict):
Logger.critical(
"No Dictionary as a result_set. Implement a custom create_video_item"
)
raise NotImplementedError(
"No Dictionary as a result_set. Implement a custom create_video_item"
)
elif "title" not in result_set or "url" not in result_set:
Logger.warning("No ?P<title> or ?P<url> in result_set")
raise LookupError("No ?P<title> or ?P<url> in result_set")
# The URL
url = self._prefix_urls(result_set["url"])
# The title
if "subtitle" in result_set and result_set["subtitle"]:
# noinspection PyStringFormat
title = "%(title)s - %(subtitle)s" % result_set
else:
title = result_set["title"]
if title.isupper():
title = title.title()
item = MediaItem(title, url)
item.thumb = self._prefix_urls(result_set.get("thumburl", ""))
item.description = result_set.get("description", "")
item.icon = self.icon
item.type = 'video'
item.fanart = self.fanart
item.HttpHeaders = self.httpHeaders
item.complete = False
return item
def create_video_item(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param dict[str,str|dict] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
Logger.trace(result_set)
title = result_set["title"]
if title is None:
Logger.warning("Found item with all <null> items. Skipping")
return None
if "subtitle" in result_set and result_set['subtitle'].lower(
) not in title.lower():
title = "%(title)s - %(subtitle)s" % result_set
url = "http://m.schooltv.nl/api/v1/afleveringen/%(mid)s.json" % result_set
item = MediaItem(title, url)
item.description = result_set.get("description", "")
age_groups = result_set.get('ageGroups', ['Onbekend'])
item.description = "%s\n\nLeeftijden: %s" % (item.description,
", ".join(age_groups))
item.thumb = result_set.get("image", "")
item.icon = self.icon
item.type = 'video'
item.fanart = self.fanart
item.complete = False
item.set_info_label("duration", result_set['duration'])
if "publicationDate" in result_set:
broadcast_date = DateHelper.get_date_from_posix(
int(result_set['publicationDate']))
item.set_date(broadcast_date.year, broadcast_date.month,
broadcast_date.day, broadcast_date.hour,
broadcast_date.minute, broadcast_date.second)
return item
def create_page_item(self, result_set):
""" Creates a MediaItem of type 'page' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'page'.
:rtype: MediaItem|None
"""
if "totalPages" not in result_set:
return None
Logger.debug("Starting create_page_item")
# current page?
page_uri_part = "page%5Bnumber%5D="
if page_uri_part not in self.parentItem.url:
page = 1
url_format = "{0}&page%5Bnumber%5D={{0:d}}".format(
self.parentItem.url)
else:
base_url, page_part = self.parentItem.url.rsplit(page_uri_part, 1)
next_part = page_part.find("&")
if next_part < 0:
# end
page = int(page_part)
url_format = "{0}&page%5Bnumber%5D={{0:d}}".format(base_url)
else:
page = int(page_part[0:next_part])
url_format = "{0}&page%5Bnumber%5D={{0:d}}&{1}".format(
base_url, page_part[next_part:])
max_pages = result_set.get("totalPages", 0)
Logger.trace("Current Page: %d of %d (%s)", page, max_pages,
self.parentItem.url)
if page + 1 > max_pages:
return None
title = LanguageHelper.get_localized_string(LanguageHelper.MorePages)
url = url_format.format(page + 1)
item = MediaItem(title, url)
item.fanart = self.parentItem.fanart
item.thumb = self.parentItem.thumb
return item
def create_folder_item(self, result_set):
""" Creates a MediaItem of type 'folder' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
Logger.trace(result_set)
# Validate the input and raise errors
if not isinstance(result_set, dict):
Logger.critical(
"No Dictionary as a result_set. Implement a custom create_video_item"
)
raise NotImplementedError(
"No Dictionary as a result_set. Implement a custom create_video_item"
)
elif "title" not in result_set or "url" not in result_set:
Logger.warning("No ?P<title> or ?P<url> in result_set")
raise LookupError("No ?P<title> or ?P<url> in result_set")
# The URL
url = self._prefix_urls(result_set["url"])
# The title
title = result_set["title"]
if title.isupper():
title = title.title()
item = MediaItem(title, url)
item.description = result_set.get("description", "")
item.thumb = result_set.get("thumburl", "")
item.icon = self.icon
item.type = 'folder'
item.fanart = self.fanart
item.HttpHeaders = self.httpHeaders
item.complete = True
return item
