def fetch_program_api_data(self, data):
""" Loaded the data that contains the main episodes for a show.
: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]]
This is done to prevent performance issues of the self.__get_api_url() method when
a lot of items are generated.
"""
items = []
slug = self.parentItem.metaData["slug"]
variables = {"titleSlugs": [slug.strip("/")]}
hash_value = "4122efcb63970216e0cfb8abb25b74d1ba2bb7e780f438bbee19d92230d491c5"
url = self.__get_api_url("TitlePage", hash_value, variables)
data = UriHandler.open(url, proxy=self.proxy)
json_data = JsonHelper(data)
# Get the parent thumb info
parent_item_thumb_data = json_data.get_value("data", "listablesBySlug",
0, "image")
possible_folders = json_data.get_value("data", "listablesBySlug", 0,
"associatedContent")
possible_folders = [
p for p in possible_folders if p["id"] != "upcoming"
]
if self.__folder_id in self.parentItem.metaData:
folder_id = self.parentItem.metaData[self.__folder_id]
Logger.debug("Retrieving folder with id='%s'", folder_id)
json_data.json = {
"videos":
[f for f in possible_folders
if f["id"] == folder_id][0]["items"]
}
elif len(possible_folders) == 1:
json_data.json = {"videos": possible_folders[0]["items"]}
else:
json_data.json = {"folders": possible_folders}
if "folders" in json_data.json:
[
folder.update({self.__parent_images: parent_item_thumb_data})
for folder in json_data.json["folders"]
]
if "videos" in json_data.json:
[
video.update({self.__parent_images: parent_item_thumb_data})
for video in json_data.json["videos"]
]
return json_data, items
def extract_json_episodes(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 = []
data = Regexer.do_regex(
r'window.__DATA__ = ([\w\W]+?});\s*window.__PUSH_STATE__', data)[0]
json_data = JsonHelper(data)
main_container = [
m for m in json_data.get_value("children")
if m["type"] == "MainContainer"
]
line_list = [
item for item in main_container[0]["children"]
if item["type"] == "LineList"
]
line_list = line_list[0]["props"]
json_data.json = line_list
return json_data, items
def extract_json(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_data = Regexer.do_regex('type="application/json">([^<]+)<', data)
if not json_data:
Logger.warning("No JSON data found.")
return data, items
json = JsonHelper(json_data[0])
result = []
for key, value in json.json.items():
result.append(value)
value["title"] = key
# set new json and return JsonHelper object
json.json = result
return json, items
def load_all_episodes(self, data):
episodes_json = []
data, items = self.add_live_channel(data)
for i in range(0, 20):
url = self.apiFormat.format(i)
data = UriHandler.open(url)
json_data = JsonHelper(data)
item_data = json_data.get_value("category", "news", fallback=[])
episodes_json += item_data
if len(item_data) < json_data.get_value("pageSize"):
break
amsterdam_vandaag = MediaItem(
"Amsterdam Vandaag",
"https://ditisdesupercooleappapi.at5.nl/api/article/p123")
amsterdam_vandaag.thumb = "https://media.at5.nl/cache/i/459000/images/459628.w1600.r16-9.6ef7807.q90.jpg"
now = datetime.datetime.now() - datetime.timedelta(days=1)
amsterdam_vandaag.set_date(now.year, now.month, now.day)
items.append(amsterdam_vandaag)
dummy = JsonHelper("{}")
dummy.json = episodes_json
return dummy, items
def extract_json_video(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 = []
data = Regexer.do_regex(r'window.__DATA__ = ([\w\W]+?});\s*window.__PUSH_STATE__', data)[0]
json_data = JsonHelper(data)
# Get the main content container
main_container = [m for m in json_data.get_value("children") if m["type"] == "MainContainer"]
# Extract seasons
seasons = []
if not self.parentItem.metaData.get("is_season", False):
seasons = [
lst["props"]["items"]
for lst in main_container[0]["children"]
if lst["type"] == "SeasonSelector"
]
if seasons:
seasons = [s for s in seasons[0] if s["url"]]
# Inject them
json_data.json["seasons"] = seasons
# Find the actual
line_lists = [lst for lst in main_container[0]["children"] if lst["type"] == "LineList"]
for line_list in line_lists:
if line_list.get("props", {}).get("type") == "video-guide":
json_data.json = line_list["props"]
# Get the actual full episode list
all_episodes = json_data.get_value("filters", "items", 0, "url")
url_all_episodes = "{}{}".format(self.baseUrl, all_episodes)
data = UriHandler.open(url_all_episodes)
json_data = JsonHelper(data)
# And append seasons again
if seasons:
json_data.json["seasons"] = seasons
return json_data, items
Logger.warning("Cannot extract video items")
return json_data, items
def extract_live_channel_data(self, data):
""" Adds the channel items 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]]
"""
json_string, _ = self.extract_json_data(data)
json_data = JsonHelper(json_string)
channels = json_data.get_value("guidePage", "channels")
channel_list = {}
# get a dictionary with channels
for channel_data in channels:
channel_tag = channel_data["urlName"]
# find the corresponding episode
channel_list[channel_tag] = channel_data
programs = dict([
kv for kv in json_data.get_value("guidePage", "programs").items()
if kv[1].get("isActiveBroadcast", False)
])
schedules = json_data.get_value("guidePage", "schedules")
for channel_name, program_ids in schedules.items():
channel_tag = channel_name.split(":")[0]
channel = channel_list.get(channel_tag, None)
if channel is None:
continue
# see what program is playing
program_id = [p for p in program_ids if p in programs]
if not program_id:
del channel_list[channel_tag]
continue
program_id = program_id[0]
if program_id.startswith("TT"):
del channel_list[channel_tag]
continue
program = programs.get(program_id)
if program is None:
del channel_list[channel_tag]
continue
channel.update(program)
json_data.json = channel_list.values()
return json_data, []
def fetch_genre_api_data(self, data):
url = self.__get_api_url(
"GenreProgramsAO",
"189b3613ec93e869feace9a379cca47d8b68b97b3f53c04163769dcffa509318",
{"genre": [self.parentItem.metaData[self.__genre_id]]}
)
data = UriHandler.open(url, proxy=self.proxy)
json_data = JsonHelper(data)
possible_lists = json_data.get_value("data", "genres", 0, "selectionsForWeb")
program_items = [genres["items"] for genres in possible_lists if genres["selectionType"] == "all"]
clip_items = [genres["items"] for genres in possible_lists if genres["selectionType"] == "clips"]
json_data.json = {
"programs": [p["item"] for p in program_items[0]],
"videos": [c["item"] for c in clip_items[0]]
}
return json_data, []
def load_all_episodes(self, data):
episodes_json = []
data, items = self.add_live_channel(data)
for i in range(0, 20):
url = "https://at5news.vinsontv.com/api/news?source=web&slug=tv&page={}".format(i)
data = UriHandler.open(url, proxy=self.proxy)
json_data = JsonHelper(data)
item_data = json_data.get_value("category", "news", fallback=[])
episodes_json += item_data
if len(item_data) < json_data.get_value("pageSize"):
break
dummy = JsonHelper("{}")
dummy.json = episodes_json
return dummy, items
def extract_live_channel_data(self, data):
""" Adds the channel items 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]]
"""
json_string, _ = self.extract_json_data(data)
json_data = JsonHelper(json_string)
channels = json_data.get_value("channelsPage", "schedule")
channel_list = []
for channel_name, channel_data in channels.items():
if "channel" not in channel_data:
continue
channel_list.append(channel_data)
json_data.json = channel_list
return json_data, []
def extract_hero_data(self, data):
""" Extacts the Hero json data
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[JsonHelper,list[MediaItem]]
"""
Logger.info("Performing Pre-Processing")
items = []
hero_data = Regexer.do_regex(r'data-hero="([^"]+)', data)[0]
hero_data = HtmlEntityHelper.convert_html_entities(hero_data)
Logger.trace(hero_data)
hero_json = JsonHelper(hero_data)
hero_playlists = hero_json.get_value("data", "playlists")
if not hero_playlists:
# set an empty object
hero_json.json = {}
current = self.parentItem.metaData.get("current_playlist", None)
if current == "clips":
Logger.debug("Found 'clips' metadata, only listing clips")
hero_json.json = {}
return hero_json, items
if current is None:
# Add clips folder
clip_title = LanguageHelper.get_localized_string(
LanguageHelper.Clips)
clips = MediaItem("\a.: %s :." % (clip_title, ),
self.parentItem.url)
clips.metaData[self.__meta_playlist] = "clips"
self.__no_clips = True
items.append(clips)
# See if there are seasons to show
if len(hero_playlists) == 1:
# first items, list all, except if there is only a single season
Logger.debug("Only one folder playlist found. Listing that one")
return hero_json, items
if current is None:
# list all folders
for playlist in hero_playlists:
folder = self.create_folder_item(playlist)
items.append(folder)
# clear the json item to prevent further listing
hero_json.json = {}
return hero_json, items
# list the correct folder
current_list = [l for l in hero_playlists if l["id"] == current]
if current_list:
# we are listing a subfolder, put that one on index 0 and then also
hero_playlists.insert(0, current_list[0])
self.__no_clips = True
Logger.debug("Pre-Processing finished")
return hero_json, items
