def __set_expire_time(self, expire_date, item):
expire_date = expire_date.split("+")[0].replace("T", " ")
year = expire_date.split("-")[0]
if len(year) == 4 and int(year) < datetime.datetime.now().year + 50:
expire_date = DateHelper.get_datetime_from_string(
expire_date, date_format="%Y-%m-%d %H:%M:%S")
item.set_expire_datetime(timestamp=expire_date)
def _is_paid_or_logged_on_item(self, result_set):
""" Check whether an item is paid or not?
:param dict result_set:
:return: Indication if the item is paid?
:rtype: tuple[bool,bool]
"""
active = set()
date_format = "%Y-%m-%dT%H:%M:%SZ"
availability_windows = result_set.get("attributes",
{}).get("availabilityWindows")
if availability_windows is not None:
for availability in availability_windows:
start = availability["playableStart"]
start_date = DateHelper.get_datetime_from_string(
start, date_format)
end = availability.get("playableEnd")
if end is None:
end_date = datetime.datetime.max
else:
end_date = DateHelper.get_datetime_from_string(
end, date_format)
package = availability["package"].lower()
if start_date < self.__now < end_date:
active.add(package)
else:
content_packages = result_set.get("relationships",
{}).get("contentPackages")
if content_packages is not None:
for account_info in result_set["relationships"][
"contentPackages"]["data"]:
account_type = account_info.get("id", "free").lower()
active.add(account_type)
if "free" in active:
return False, False
if "registered" in active:
return False, True
return True, True
def __set_expire_time(self, expire_date, item):
""" Parses and sets the correct expire date.
:param str expire_date: The expire date value
:param MediaItem item: The item to update
"""
expire_date = expire_date.split("+")[0] # .replace("T", " ")
year = expire_date.split("-", 1)[0]
if len(year) == 4 and int(year) < datetime.datetime.now().year + 50:
expire_date = DateHelper.get_datetime_from_string(expire_date)
item.set_expire_datetime(timestamp=expire_date)
def __set_expire_time(self, expire_date, item):
""" Sets the expire time
:param str expire_date:
:param MediaItem item:
"""
try:
if expire_date.endswith("z"):
valid_to = DateHelper.get_datetime_from_string(
expire_date, "%Y-%m-%dT%H:%M:%SZ", "UTC")
valid_to = valid_to.astimezone(self.__timezone)
item.set_expire_datetime(timestamp=valid_to)
else:
expire_date = expire_date.split("+")[0].replace("T", " ")
year = expire_date.split("-")[0]
if len(year) == 4 and int(
year) < datetime.datetime.now().year + 50:
expire_date = DateHelper.get_datetime_from_string(
expire_date, date_format="%Y-%m-%d %H:%M:%S")
item.set_expire_datetime(timestamp=expire_date)
except:
Logger.warning("Error setting expire date from: %s", expire_date)
def create_video_item_json(self, result_set, include_show_title=False):
""" 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 result_set: The result_set of the self.episodeItemRegex
:param bool include_show_title: Should we include the show title in the title
: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"]
# We could add the main title
show_title = result_set.get('mainTitle')
episode = result_set.get('episodeNumber')
if show_title and include_show_title:
if bool(episode):
title = "{} - {} {:02d} - {}".format(show_title,
self.__episode_text,
episode, title)
else:
title = "{} - {}".format(show_title, title)
elif bool(episode):
title = "{} {:02d} - {}".format(self.__episode_text, episode,
title)
slug = result_set['slug']
url = "%s/%s" % (self.baseUrl, slug)
item = MediaItem(title, url)
item.type = "video"
item.description = result_set['description']
item.complete = False
images = result_set["image"]
thumb_fanart = None
for dimension, url in images.items():
if dimension.startswith("640x"):
item.thumb = url
elif dimension.startswith("1280x"):
thumb_fanart = url
if item.thumb and thumb_fanart:
break
# if there was a high quality thumb and no fanart (default one), the use the thumb.
if item.fanart == self.fanart and thumb_fanart:
item.fanart = thumb_fanart
duration = result_set.get("duration")
if duration:
item.set_info_label("duration", int(duration))
# Determine the date and keep timezones into account
# date = result_set.get('publishedAt')
if "accessiblePlatforms" in result_set and "urplay" in result_set[
"accessiblePlatforms"]:
start_date = result_set["accessiblePlatforms"]["urplay"][
"startTime"]
end_date = result_set["accessiblePlatforms"]["urplay"]["endTime"]
if start_date:
start_date = start_date.replace(".000Z", "Z")
date_time = DateHelper.get_datetime_from_string(
start_date,
date_format="%Y-%m-%dT%H:%M:%SZ",
time_zone="UTC")
date_time = date_time.astimezone(self.__timezone)
item.set_date(date_time.year, date_time.month, date_time.day,
date_time.hour, date_time.minute,
date_time.second)
if end_date:
end_date = end_date.replace(".000Z", "Z")
end_date_time = DateHelper.get_datetime_from_string(
end_date,
date_format="%Y-%m-%dT%H:%M:%SZ",
time_zone="UTC")
end_date_time = end_date_time.astimezone(self.__timezone)
item.set_expire_datetime(end_date_time)
return item
def create_api_episode_type(self, result_set, add_parent_title=False):
""" Creates a MediaItem of type 'video' using the result_set from the API.
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
:param bool add_parent_title: Should the parent's title be included?
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
This works for:
__typename=Episode
"""
svt_video_id = result_set.get("videoSvtId",
result_set.get("svtId", None))
if svt_video_id:
# API style
url = "https://api.svt.se/videoplayer-api/video/{}".format(
svt_video_id)
else:
# HTML style
url = "{}{}".format(self.baseUrl, result_set['urls']['svtplay'])
title = result_set.get("name", "")
if "parent" in result_set and add_parent_title:
title = "{} - {}".format(result_set["parent"]["name"], title)
item = MediaItem(title, url)
item.description = result_set.get("longDescription")
item.type = "video"
item.set_info_label("duration", int(result_set.get("duration", 0)))
item.isGeoLocked = result_set.get("restrictions",
{}).get("onlyAvailableInSweden",
False)
parent_images = result_set.get(self.__parent_images)
if bool(parent_images):
item.fanart = self.__get_thumb(parent_images)
if "image" in result_set:
item.thumb = self.__get_thumb(result_set["image"], width=720)
if not bool(item.fanart):
item.fanart = self.__get_thumb(result_set["image"])
valid_to = result_set.get("validTo", None)
if valid_to:
self.__set_expire_time(valid_to, item)
live_data = result_set.get("live")
if live_data:
is_live_now = live_data["liveNow"]
if is_live_now:
item.name = "{} [COLOR gold](live)[/COLOR]".format(item.name)
start = live_data["start"]
if start.endswith("Z"):
start_time = DateHelper.get_datetime_from_string(
start, "%Y-%m-%dT%H:%M:%SZ", "UTC")
start_time = start_time.astimezone(self.__timezone)
item.set_date(start_time.year, start_time.month,
start_time.day, start_time.hour,
start_time.minute, start_time.second)
hour = start_time.hour
minute = start_time.minute
else:
start = start.split('.')[0].split("+")[0]
start_time = DateHelper.get_date_from_string(
start, "%Y-%m-%dT%H:%M:%S")
item.set_date(*start_time[0:6])
hour = start_time.tm_hour
minute = start_time.tm_min
item.name = "{:02}:{:02} - {}".format(hour, minute, item.name)
return item
def create_api_video_asset_type(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)
program_id = result_set["id"]
url = "https://playback-api.b17g.net/media/{}?service=tv4&device=browser&protocol=dash".\
format(program_id)
name = result_set["title"]
season = result_set.get("season", 0)
episode = result_set.get("episode", 0)
is_episodic = 0 < season < 1900 and not episode == 0
if is_episodic:
episode_text = None
if " del " in name:
name, episode_text = name.split(" del ", 1)
episode_text = episode_text.lstrip("0123456789")
if episode_text:
episode_text = episode_text.lstrip(" -")
name = "{} - s{:02d}e{:02d} - {}".format(name, season, episode, episode_text)
else:
name = "{} - s{:02d}e{:02d}".format(name, season, episode)
item = MediaItem(name, url)
item.description = result_set["description"]
if item.description is None:
item.description = item.name
if is_episodic:
item.set_season_info(season, episode)
# premium_expire_date_time=2099-12-31T00:00:00+01:00
expire_in_days = result_set.get("daysLeftInService", 0)
if 0 < expire_in_days < 10000:
item.set_expire_datetime(
timestamp=datetime.datetime.now() + datetime.timedelta(days=expire_in_days))
date = result_set["broadcastDateTime"]
broadcast_date = DateHelper.get_datetime_from_string(date, "%Y-%m-%dT%H:%M:%SZ", "UTC")
broadcast_date = broadcast_date.astimezone(self.__timezone)
item.set_date(broadcast_date.year,
broadcast_date.month,
broadcast_date.day,
broadcast_date.hour,
broadcast_date.minute,
0)
item.fanart = result_set.get("program_image", self.parentItem.fanart)
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=70&resize=520x293&source={}" \
.format(HtmlEntityHelper.url_encode(thumb_url))
else:
item.thumb = thumb_url
item.type = "video"
item.complete = False
item.isGeoLocked = True
# For now, none are paid.
# item.isPaid = not result_set.get("freemium", False)
if "drmProtected" in result_set:
item.isDrmProtected = result_set["drmProtected"]
elif "is_drm_protected" in result_set:
item.isDrmProtected = result_set["is_drm_protected"]
item.isLive = result_set.get("live", False)
if item.isLive:
item.name = "{:02d}:{:02d} - {}".format(broadcast_date.hour, broadcast_date.minute, name)
item.url = "{0}&is_live=true".format(item.url)
if item.isDrmProtected:
item.url = "{}&drm=widevine&is_drm=true".format(item.url)
item.set_info_label("duration", int(result_set.get("duration", 0)))
return item