def __create_generic_item(self, result_set, expected_item_type,
url_format):
video_info = result_set["attributes"]
name = video_info["name"]
if expected_item_type != result_set["type"]:
Logger.warning("Not %s, excluding %s", expected_item_type, name)
return None
channel_id = int(
result_set["relationships"]["primaryChannel"]["data"]["id"])
if self.primaryChannelId is not None and channel_id != self.primaryChannelId:
return None
item_id = result_set["id"]
# Show the slug?
# showSlug = video_info["alternateId"]
url = url_format.format(item_id)
item = MediaItem(name, url)
item.description = video_info.get("description")
geo_info = video_info.get("geoRestrictions", {"countries": ["world"]})
item.isGeoLocked = "world" not in geo_info.get("countries")
# set the images
if "images" in result_set["relationships"]:
thumb_id = result_set["relationships"]["images"]["data"][0]["id"]
item.thumb = self.imageLookup.get(thumb_id, self.noImage)
if item.thumb == self.noImage:
Logger.warning("No thumb found for %s", thumb_id)
# paid or not?
if "contentPackages" in result_set["relationships"]:
item.isPaid = not any(
filter(lambda p: p["id"].lower() == "free",
result_set["relationships"]["contentPackages"]["data"]))
else:
item.isPaid = False
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 result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'folder'.
:rtype: MediaItem|None
"""
# Logger.Trace(result_set)
json = result_set
title = json["name"]
program_id = json["nid"]
program_id = HtmlEntityHelper.url_encode(program_id)
url = "http://webapi.tv4play.se/play/video_assets" \
"?platform=tablet&per_page=%s&is_live=false&type=episode&" \
"page=1&node_nids=%s&start=0" % (self.maxPageSize, program_id, )
if "channel" in json and json["channel"]:
# noinspection PyTypeChecker
channel_id = json["channel"]["nid"]
Logger.trace("ChannelId found: %s", channel_id)
else:
channel_id = "tv4"
Logger.warning("ChannelId NOT found. Assuming %s", channel_id)
# match the exact channel or put them in TV4
is_match_for_channel = channel_id.startswith(self.__channelId)
is_match_for_channel |= self.channelCode == "tv4se" and not channel_id.startswith(
"sjuan") and not channel_id.startswith("tv12")
if not is_match_for_channel:
Logger.debug("Channel mismatch for '%s': %s vs %s", title,
channel_id, self.channelCode)
return None
item = MediaItem(title, url)
item.icon = self.icon
item.thumb = result_set.get("program_image", self.noImage)
item.isPaid = result_set.get("is_premium", 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 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
"""
Logger.trace(result_set)
episode_key = result_set["episode_key"]
if episode_key:
episode_data = self.episodes.get(episode_key, None)
if not episode_data:
Logger.warning("Could not find episodes data for key: %s",
episode_key)
return None
Logger.debug("Found Episode Data: %s", episode_data)
else:
Logger.debug("No Episode Data Found")
episode_data = None
title = result_set["title"]
description = None
if episode_data:
if title:
title = "%s - %s" % (episode_data["name"], title)
else:
title = episode_data["name"]
description = episode_data.get("synopsis", None)
# tarifs have datetimes
# noinspection PyStatementEffect
# """
# "ddr_timeframes": [{
# "start": 1382119200,
# "stop": 1382378399,
# "tariff": 149
# },
# {
# "start": 1382378400,
# "tariff": 0
# }],
#
# """
tariffs = result_set.get("ddr_timeframes")
premium_item = False
if tariffs:
Logger.trace(tariffs)
for tariff in tariffs: # type: dict
if tariff["tariff"] > 0:
start = tariff.get("start", 0)
end = tariff.get("stop", 2147483647)
start = DateHelper.get_date_from_posix(start)
end = DateHelper.get_date_from_posix(end)
now = datetime.datetime.now()
if start < now < end:
premium_item = True
Logger.debug(
"Found a tariff for this episode: %s - %s: %s",
start, end, tariff["tariff"])
break
uuid = result_set["uuid"]
url = "http://www.rtl.nl/system/s4m/xldata/ux/%s?context=rtlxl&d=pc&fmt=adaptive&version=3" % (
uuid, )
# The JSON urls do not yet work
# url = "http://www.rtl.nl/system/s4m/vfd/version=1/d=pc/output=json/fun=abstract/uuid=%s/fmt=smooth" % (uuid,)
item = MediaItem(title.title(), url)
item.type = "video"
item.isPaid = premium_item
item.description = description
item.thumb = "%s%s" % (
self.posterBase,
uuid,
)
station = result_set.get("station", None)
if station:
icon = self.largeIconSet.get(station.lower(), None)
if icon:
Logger.trace("Setting icon to: %s", icon)
item.icon = icon
date_time = result_set.get("display_date", None)
if date_time:
date_time = DateHelper.get_date_from_posix(int(date_time))
item.set_date(date_time.year, date_time.month, date_time.day,
date_time.hour, date_time.minute, date_time.second)
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 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('starting FormatVideoItem for %s', self.channelName)
# Logger.Trace(result_set)
# the vmanProgramId (like 1019976) leads to http://anytime.tv4.se/webtv/metafileFlash.smil?p=1019976&bw=1000&emulate=true&sl=true
program_id = result_set["id"]
# Logger.Debug("ProgId = %s", programId)
url = "https://playback-api.b17g.net/media/%s?service=tv4&device=browser&protocol=hls" % (
program_id, )
name = result_set["title"]
item = MediaItem(name, url)
item.description = result_set["description"]
if item.description is None:
item.description = item.name
# premium_expire_date_time=2099-12-31T00:00:00+01:00
date = result_set["broadcast_date_time"]
(date_part, time_part) = date.split("T")
(year, month, day) = date_part.split("-")
(hour, minutes, rest1, zone) = time_part.split(":")
item.set_date(year, month, day, hour, minutes, 00)
broadcast_date = datetime.datetime(int(year), int(month), int(day),
int(hour), int(minutes))
thumb_url = result_set.get("image", result_set.get("program_image"))
# some images need to come via a proxy:
if thumb_url and "://img.b17g.net/" in thumb_url:
item.thumb = "https://imageproxy.b17g.services/?format=jpg&shape=cut" \
"&quality=90&resize=520x293&source={}"\
.format(HtmlEntityHelper.url_encode(thumb_url))
else:
item.thumb = thumb_url
availability = result_set["availability"]
# noinspection PyTypeChecker
free_period = availability["availability_group_free"]
# noinspection PyTypeChecker
premium_period = availability["availability_group_premium"]
now = datetime.datetime.now()
if False and not premium_period == "0":
# always premium
free_expired = now - datetime.timedelta(days=99 * 365)
elif free_period == "30+" or free_period is None:
free_expired = broadcast_date + datetime.timedelta(days=99 * 365)
else:
free_expired = broadcast_date + datetime.timedelta(
days=int(free_period))
Logger.trace(
"Premium info for: %s\nPremium state: %s\nFree State: %s\nBroadcast %s vs Expired %s",
name, premium_period, free_period, broadcast_date, free_expired)
if now > free_expired:
item.isPaid = True
item.type = "video"
item.complete = False
item.icon = self.icon
item.isGeoLocked = result_set["is_geo_restricted"]
item.isDrmProtected = result_set["is_drm_protected"]
item.isLive = result_set.get("is_live", False)
if item.isLive:
item.url = "{0}&is_live=true".format(item.url)
return item
