def _videos_to_items(self, context, videos, channel_config):
result = []
show_only_free_videos = context.get_settings().get_bool('nowtv.videos.only_free', False)
for video in videos:
if show_only_free_videos and not video['free']:
continue
video_params = {'video_path': video['path'],
'video_id': str(video['id'])}
title = video['title']
if not video['free']:
title = '[B][%s][/B] - %s' % (video['price'], title)
video_params['free'] = '0'
video_params['price'] = video['price']
pass
video_item = VideoItem(title, context.create_uri([channel_config['id'], 'play'], video_params))
duration = datetime_parser.parse(video['duration'])
video_item.set_duration(duration.hour, duration.minute, duration.second)
published = datetime_parser.parse(video['published'])
video_item.set_aired_from_datetime(published)
video_item.set_date_from_datetime(published)
video_item.set_year_from_datetime(published)
video_item.set_studio(video['format'])
video_item.add_artist(video['format'])
video_item.set_episode(video['episode'])
video_item.set_season(video['season'])
video_item.set_plot(video['plot'])
video_item.set_image(video['images']['thumb'])
video_item.set_fanart(video['images']['fanart'])
result.append(video_item)
pass
return result
def do_xml_video_response(context, provider, video_xml):
if isinstance(video_xml, basestring):
video_xml = ET.fromstring(video_xml)
do_xml_error(context, provider, video_xml)
video_xml = video_xml.find('video')
pass
video_id = video_xml.get('id')
title = video_xml.find('title').text
video_item = VideoItem(title, context.create_uri(['play'], {'video_id': video_id}))
# channel name
channel_name = ''
owner = video_xml.find('owner')
if owner is not None:
channel_name = owner.get('username')
pass
video_item.set_studio(channel_name)
video_item.add_artist(channel_name)
# date
upload_date = video_xml.find('upload_date')
if upload_date is not None and upload_date.text is not None:
upload_date = upload_date.text
upload_date = upload_date.split(' ')
if len(upload_date) == 2:
date = upload_date[0].split('-')
time = upload_date[1].split(':')
if len(date) == 3 and len(time) == 3:
video_item.set_date(int(date[0]), int(date[1]), int(date[2]), int(time[0]), int(time[1]),
int(time[2]))
video_item.set_year(int(date[0]))
video_item.set_aired(int(date[0]), int(date[1]), int(date[2]))
video_item.set_premiered(int(date[0]), int(date[1]), int(date[2]))
pass
pass
pass
# plot
plot = video_xml.find('description').text
if plot is None:
plot = ''
pass
settings = context.get_settings()
if channel_name and settings.get_bool('vimeo.view.description.show_channel_name', True):
plot = '[UPPERCASE][B]%s[/B][/UPPERCASE][CR][CR]%s' % (channel_name, plot)
pass
video_item.set_plot(plot)
# duration
duration = int(video_xml.find('duration').text)
if duration is not None:
video_item.set_duration_from_seconds(duration)
pass
# thumbs
thumbnails = video_xml.find('thumbnails')
if thumbnails is not None:
for thumbnail in thumbnails:
height = int(thumbnail.get('height'))
if height >= 360:
video_item.set_image(thumbnail.text)
break
pass
pass
video_item.set_fanart(provider.get_fanart(context))
# context menu
context_menu = []
if provider.is_logged_in():
# like/unlike
is_like = video_xml.get('is_like') == '1'
if is_like:
like_text = context.localize(provider._local_map['vimeo.unlike'])
context_menu.append(
(like_text, 'RunPlugin(%s)' % context.create_uri(['video', 'unlike'], {'video_id': video_id})))
else:
like_text = context.localize(provider._local_map['vimeo.like'])
context_menu.append(
(like_text, 'RunPlugin(%s)' % context.create_uri(['video', 'like'], {'video_id': video_id})))
pass
# watch later
is_watch_later = video_xml.get('is_watchlater') == '1'
if is_watch_later:
watch_later_text = context.localize(provider._local_map['vimeo.watch-later.remove'])
context_menu.append(
(watch_later_text,
'RunPlugin(%s)' % context.create_uri(['video', 'watch-later', 'remove'], {'video_id': video_id})))
else:
watch_later_text = context.localize(provider._local_map['vimeo.watch-later.add'])
context_menu.append(
(watch_later_text,
'RunPlugin(%s)' % context.create_uri(['video', 'watch-later', 'add'], {'video_id': video_id})))
pass
# add to * (album, channel or group)
context_menu.append((context.localize(provider._local_map['vimeo.video.add-to']),
'RunPlugin(%s)' % context.create_uri(['video', 'add-to'], {'video_id': video_id})))
# remove from * (album, channel or group)
context_menu.append((context.localize(provider._local_map['vimeo.video.remove-from']),
'RunPlugin(%s)' % context.create_uri(['video', 'remove-from'], {'video_id': video_id})))
pass
# Go to user
owner = video_xml.find('owner')
if owner is not None:
owner_name = owner.get('display_name')
owner_id = owner.get('id')
context_menu.append((context.localize(provider._local_map['vimeo.user.go-to']) % '[B]' + owner_name + '[/B]',
'Container.Update(%s)' % context.create_uri(['user', owner_id])))
pass
video_item.set_context_menu(context_menu)
return video_item
def _list_films(self,
context,
re_match,
json_data,
show_format_title=False,
sort=True):
context.get_ui().set_view_mode('videos')
def _sort_newest(item):
return item.get_aired()
context.set_content_type(kodion.constants.content_type.EPISODES)
context.add_sort_method(kodion.constants.sort_method.UNSORTED,
kodion.constants.sort_method.VIDEO_YEAR,
kodion.constants.sort_method.VIDEO_RUNTIME)
result = []
content = json_data.get('result', {}).get('content', {})
max_page = int(content.get('maxpage', 1))
page = int(content.get('page', 1))
film_list = content.get('filmlist', {})
result_films = []
add_next_page_item = True
keys = sorted(film_list.keys())
for key in keys:
film = film_list[key]
# as soon as we find non-free episodes we don't provide pagination
# the 'continue' should skip all non-free episodes
free = str(film.get('free', '0'))
if free == '0':
add_next_page_item = False
continue
title = film['headlinelong']
format_title = film['formatlong']
if show_format_title:
title = format_title + ' - ' + title
pass
film_item = VideoItem(
title, context.create_uri(['play'], {'video_id': film['id']}))
film_item.set_studio(format_title)
film_item.add_artist(format_title)
format_id = film['formatid']
# set image
image = self.get_client(context).get_config(
)['images']['format-thumbnail-url'].replace(
'%FORMAT_ID%', format_id)
pictures = film.get('pictures', [])
if pictures and isinstance(pictures, dict):
image = film['pictures']['pic_0']
image = self.get_client(context).get_config(
)['images']['episode-thumbnail-url'].replace(
'%PIC_ID%', image)
pass
film_item.set_image(image)
# set fanart
fanart = self.get_client(
context).get_config()['images']['format-fanart-url'].replace(
'%FORMAT_ID%', format_id)
film_item.set_fanart(fanart)
# season and episode
film_item.set_season(film.get('season', '1'))
film_item.set_episode(film.get('episode', '1'))
# aired
aired = datetime_parser.parse(film['sendestart'])
film_item.set_aired_from_datetime(aired)
film_item.set_date_from_datetime(aired)
film_item.set_year_from_datetime(aired)
# duration
duration = datetime_parser.parse(film['duration'])
film_item.set_duration(duration.hour, duration.minute,
duration.second)
# plot
film_item.set_plot(film['articlelong'])
context_menu = [(
context.localize(self._local_map['now.watch_later']),
'RunPlugin(%s)' %
context.create_uri([kodion.constants.paths.WATCH_LATER, 'add'],
{'item': kodion.items.to_jsons(film_item)}))
]
film_item.set_context_menu(context_menu)
result_films.append(film_item)
pass
if sort:
result_films = sorted(result_films, key=_sort_newest, reverse=True)
pass
result.extend(result_films)
if add_next_page_item and page < max_page:
new_params = {}
new_params.update(context.get_params())
new_params['page'] = page + 1
next_page_item = kodion.items.NextPageItem(
context, current_page=page, fanart=self.get_fanart(context))
result.append(next_page_item)
pass
return result
def _list_films(self, context, re_match, json_data, show_format_title=False, sort=True):
context.get_ui().set_view_mode('videos')
def _sort_newest(item):
return item.get_aired()
context.set_content_type(kodion.constants.content_type.EPISODES)
context.add_sort_method(kodion.constants.sort_method.UNSORTED,
kodion.constants.sort_method.VIDEO_YEAR,
kodion.constants.sort_method.VIDEO_RUNTIME)
result = []
content = json_data.get('result', {}).get('content', {})
max_page = int(content.get('maxpage', 1))
page = int(content.get('page', 1))
film_list = content.get('filmlist', {})
result_films = []
add_next_page_item = True
keys = sorted(film_list.keys())
for key in keys:
film = film_list[key]
# as soon as we find non-free episodes we don't provide pagination
# the 'continue' should skip all non-free episodes
free = str(film.get('free', '0'))
if free == '0':
add_next_page_item = False
continue
title = film['headlinelong']
format_title = film['formatlong']
if show_format_title:
title = format_title + ' - ' + title
pass
film_item = VideoItem(title, context.create_uri(['play'], {'video_id': film['id']}))
film_item.set_studio(format_title)
film_item.add_artist(format_title)
format_id = film['formatid']
# set image
image = self.get_client(context).get_config()['images']['format-thumbnail-url'].replace('%FORMAT_ID%',
format_id)
pictures = film.get('pictures', [])
if pictures and isinstance(pictures, dict):
image = film['pictures']['pic_0']
image = self.get_client(context).get_config()['images']['episode-thumbnail-url'].replace('%PIC_ID%',
image)
pass
film_item.set_image(image)
# set fanart
fanart = self.get_client(context).get_config()['images']['format-fanart-url'].replace('%FORMAT_ID%', format_id)
film_item.set_fanart(fanart)
# season and episode
film_item.set_season(film.get('season', '1'))
film_item.set_episode(film.get('episode', '1'))
# aired
aired = datetime_parser.parse(film['sendestart'])
film_item.set_aired_from_datetime(aired)
film_item.set_date_from_datetime(aired)
film_item.set_year_from_datetime(aired)
# duration
duration = datetime_parser.parse(film['duration'])
film_item.set_duration(duration.hour, duration.minute, duration.second)
# plot
film_item.set_plot(film['articlelong'])
context_menu = [(context.localize(self._local_map['now.watch_later']),
'RunPlugin(%s)' % context.create_uri([kodion.constants.paths.WATCH_LATER, 'add'],
{'item': kodion.items.to_jsons(film_item)}))]
film_item.set_context_menu(context_menu)
result_films.append(film_item)
pass
if sort:
result_films = sorted(result_films, key=_sort_newest, reverse=True)
pass
result.extend(result_films)
if add_next_page_item and page < max_page:
new_params = {}
new_params.update(context.get_params())
new_params['page'] = page + 1
next_page_item = kodion.items.NextPageItem(context, current_page=page, fanart=self.get_fanart(context))
result.append(next_page_item)
pass
return result
def _videos_to_items(self, context, videos, prepend_format_title=False):
result = []
# show only free videos if not logged in or or the setting is enabled
show_only_free_videos = not self.is_logged_in() or context.get_settings().get_bool('nowtv.videos.only_free',
False)
for video in videos:
if show_only_free_videos and not video['free'] and not video['payed']:
continue
video_params = {'video_path': video['path'],
'video_id': str(video['id'])}
title = video['title']
if prepend_format_title:
title = '%s - %s' % (video['format'], title)
pass
if not video['free'] and not video['payed']:
title = '[B][%s][/B] - %s' % (video['price'], title)
video_params['free'] = '0'
video_params['price'] = video['price']
pass
video_item = VideoItem(title, context.create_uri([video['channel'], 'play'], video_params))
duration = datetime_parser.parse(video['duration'])
video_item.set_duration(duration.hour, duration.minute, duration.second)
published = datetime_parser.parse(video['published'])
video_item.set_aired_from_datetime(published)
video_item.set_date_from_datetime(published)
video_item.set_year_from_datetime(published)
video_item.set_studio(video['format'])
video_item.add_artist(video['format'])
video_item.set_episode(video['episode'])
video_item.set_season(video['season'])
video_item.set_plot(video['plot'])
video_item.set_image(video['images']['thumb'])
video_item.set_fanart(video['images']['fanart'])
context_menu = []
if self.is_logged_in():
if context.get_path() == '/nowtv/watch_later/list/':
context_menu = [(context.localize(self._local_map['nowtv.remove_from_watch_later']),
'RunPlugin(%s)' % context.create_uri(['nowtv', 'watch_later', 'delete'],
{'video_id': video['id']}))]
pass
else:
context_menu = [(context.localize(self._local_map['nowtv.add_to_watch_later']),
'RunPlugin(%s)' % context.create_uri(['nowtv', 'watch_later', 'add'],
{'video_id': video['id']}))]
pass
else:
context_menu = [(context.localize(self._local_map['nowtv.add_to_watch_later']),
'RunPlugin(%s)' % context.create_uri([kodion.constants.paths.WATCH_LATER, 'add'],
{'item': kodion.items.to_jsons(video_item)}))]
pass
if context_menu:
video_item.set_context_menu(context_menu)
pass
result.append(video_item)
pass
return result
def _videos_to_items(self, context, videos, prepend_format_title=False):
result = []
# show only free videos if not logged in or or the setting is enabled
show_only_free_videos = not self.is_logged_in(
) and context.get_settings().get_bool('nowtv.videos.only_free', False)
for video in videos:
if show_only_free_videos and not video['free'] and not video[
'payed']:
continue
video_params = {
'video_path': video['path'],
'video_id': str(video['id'])
}
title = video['title']
if prepend_format_title:
title = '%s - %s' % (video['format'], title)
pass
if not video['free'] and not video['payed']:
title = '[B][%s][/B] - %s' % (video['price'], title)
video_params['free'] = '0'
video_params['price'] = video['price']
pass
video_item = VideoItem(
title,
context.create_uri([video['channel'], 'play'], video_params))
duration = datetime_parser.parse(video['duration'])
video_item.set_duration(duration.hour, duration.minute,
duration.second)
published = datetime_parser.parse(video['published'])
video_item.set_aired_from_datetime(published)
video_item.set_date_from_datetime(published)
video_item.set_year_from_datetime(published)
video_item.set_studio(video['format'])
video_item.add_artist(video['format'])
video_item.set_episode(video['episode'])
video_item.set_season(video['season'])
video_item.set_plot(video['plot'])
video_item.set_image(video['images']['thumb'])
video_item.set_fanart(video['images']['fanart'])
context_menu = []
if self.is_logged_in():
if context.get_path() == '/nowtv/watch_later/list/':
context_menu = [
(context.localize(
self._local_map['nowtv.remove_from_watch_later']),
'RunPlugin(%s)' %
context.create_uri(['nowtv', 'watch_later', 'delete'],
{'video_id': video['id']}))
]
pass
else:
context_menu = [
(context.localize(
self._local_map['nowtv.add_to_watch_later']),
'RunPlugin(%s)' %
context.create_uri(['nowtv', 'watch_later', 'add'],
{'video_id': video['id']}))
]
pass
else:
context_menu = [
(context.localize(
self._local_map['nowtv.add_to_watch_later']),
'RunPlugin(%s)' % context.create_uri(
[kodion.constants.paths.WATCH_LATER, 'add'],
{'item': kodion.items.to_jsons(video_item)}))
]
pass
if context_menu:
video_item.set_context_menu(context_menu)
pass
result.append(video_item)
pass
return result
def make_video_item_from_json_data(context, provider, json_data, playlist_item_id_dict={}):
video_id = json_data['id']
video_item = VideoItem(json_data['title'],
uri=context.create_uri(['play'], {'video_id': video_id}))
video_item.set_image(json_data.get('image', ''))
"""
This is experimental. We try to get the most information out of the title of a video.
This is not based on any language. In some cases this won't work at all.
TODO: via language and settings provide the regex for matching episode and season.
"""
video_item.set_season(1)
video_item.set_episode(1)
for regex in __RE_SEASON_EPISODE_MATCHES__:
re_match = regex.search(video_item.get_name())
if re_match:
if 'season' in re_match.groupdict():
video_item.set_season(int(re_match.group('season')))
pass
if 'episode' in re_match.groupdict():
video_item.set_episode(int(re_match.group('episode')))
pass
break
pass
settings = context.get_settings()
# plot
channel_name = json_data.get('channel-title', '')
description = kodion.utils.strip_html_from_text(json_data.get('description', ''))
if channel_name and settings.get_bool('youtube.view.description.show_channel_name', True):
description = '[UPPERCASE][B]%s[/B][/UPPERCASE][CR][CR]%s' % (channel_name, description)
pass
video_item.set_studio(channel_name)
# video_item.add_cast(channel_name)
video_item.add_artist(channel_name)
video_item.set_plot(description)
# date time
date_str = json_data.get('date', '')
if date_str:
datetime = utils.datetime_parser.parse()
video_item.set_year_from_datetime(datetime)
video_item.set_aired_from_datetime(datetime)
video_item.set_premiered_from_datetime(datetime)
pass
# duration
duration = json_data.get('duration', '')
if duration:
duration = utils.datetime_parser.parse(duration)
# we subtract 1 seconds because YouTube returns +1 second to much
video_item.set_duration_from_seconds(duration.seconds - 1)
pass
# set fanart
video_item.set_fanart(provider.get_fanart(context))
context_menu = []
replace_context_menu = False
# Refresh ('My Subscriptions', all my playlists)
if context.get_path() == '/special/new_uploaded_videos/' or context.get_path().startswith(
'/channel/mine/playlist/'):
yt_context_menu.append_refresh(context_menu, provider, context)
pass
# Queue Video
yt_context_menu.append_queue_video(context_menu, provider, context)
# play all videos of the playlist
some_playlist_match = re.match('^/channel/(.+)/playlist/(?P<playlist_id>.*)/$', context.get_path())
if some_playlist_match:
replace_context_menu = True
playlist_id = some_playlist_match.group('playlist_id')
yt_context_menu.append_play_all_from_playlist(context_menu, provider, context, playlist_id, video_id)
yt_context_menu.append_play_all_from_playlist(context_menu, provider, context, playlist_id)
pass
# 'play with...' (external player)
if context.get_settings().is_support_alternative_player_enabled():
yt_context_menu.append_play_with(context_menu, provider, context)
pass
my_playlists = {}
if provider.is_logged_in():
resource_manager = provider.get_resource_manager(context)
my_playlists = resource_manager.get_related_playlists(channel_id='mine')
pass
if provider.is_logged_in():
# add 'Watch Later' only if we are not in my 'Watch Later' list
watch_later_playlist_id = my_playlists.get('watchLater', '')
yt_context_menu.append_watch_later(context_menu, provider, context, watch_later_playlist_id, video_id)
pass
channel_id = json_data.get('channel-id', '')
# got to [CHANNEL]
if channel_id and channel_name:
# only if we are not directly in the channel provide a jump to the channel
if kodion.utils.create_path('channel', channel_id) != context.get_path():
yt_context_menu.append_go_to_channel(context_menu, provider, context, channel_id, channel_name)
pass
pass
# description links
yt_context_menu.append_content_from_description(context_menu, provider, context, video_id)
# find related videos
yt_context_menu.append_related_videos(context_menu, provider, context, video_id)
if provider.is_logged_in():
# add 'Like Video' only if we are not in my 'Liked Videos' list
refresh_container = context.get_path().startswith(
'/channel/mine/playlist/LL') or context.get_path() == '/special/disliked_videos/'
yt_context_menu.append_rate_video(context_menu, provider, context, video_id, refresh_container)
# add video to a selected playlist
yt_context_menu.append_add_video_to_playlist(context_menu, provider, context, video_id)
# provide 'remove' for videos in my playlists
if video_id in playlist_item_id_dict:
playlist_match = re.match('^/channel/mine/playlist/(?P<playlist_id>.*)/$', context.get_path())
if playlist_match:
playlist_id = playlist_match.group('playlist_id')
# we support all playlist except 'Watch History'
if not playlist_id.startswith('HL'):
playlist_item_id = playlist_item_id_dict[video_id]
context_menu.append((context.localize(provider.LOCAL_MAP['youtube.remove']),
'RunPlugin(%s)' % context.create_uri(
['playlist', 'remove', 'video'],
{'playlist_id': playlist_id, 'video_id': playlist_item_id,
'video_name': video_item.get_name()})))
pass
pass
pass
# subscribe to the channel of the video
yt_context_menu.append_subscribe_to_channel(context_menu, provider, context, channel_id, channel_name)
pass
if len(context_menu) > 0:
video_item.set_context_menu(context_menu, replace=replace_context_menu)
pass
return video_item
def _videos_to_items(self, context, videos, prepend_format_title=False):
result = []
# show only free videos if not logged in or or the setting is enabled
show_only_free_videos = not self.is_logged_in() and context.get_settings().get_bool(
"nowtv.videos.only_free", False
)
for video in videos:
if show_only_free_videos and not video["free"] and not video["payed"]:
continue
video_params = {"video_path": video["path"], "video_id": str(video["id"])}
title = video["title"]
if prepend_format_title:
title = "%s - %s" % (video["format"], title)
pass
if not video["free"] and not video["payed"]:
title = "[B][%s][/B] - %s" % (video["price"], title)
video_params["free"] = "0"
video_params["price"] = video["price"]
pass
video_item = VideoItem(title, context.create_uri([video["channel"], "play"], video_params))
duration = datetime_parser.parse(video["duration"])
video_item.set_duration(duration.hour, duration.minute, duration.second)
published = datetime_parser.parse(video["published"])
video_item.set_aired_from_datetime(published)
video_item.set_date_from_datetime(published)
video_item.set_year_from_datetime(published)
video_item.set_studio(video["format"])
video_item.add_artist(video["format"])
video_item.set_episode(video["episode"])
video_item.set_season(video["season"])
video_item.set_plot(video["plot"])
video_item.set_image(video["images"]["thumb"])
video_item.set_fanart(video["images"]["fanart"])
context_menu = []
if self.is_logged_in():
if context.get_path() == "/nowtv/watch_later/list/":
context_menu = [
(
context.localize(self._local_map["nowtv.remove_from_watch_later"]),
"RunPlugin(%s)"
% context.create_uri(["nowtv", "watch_later", "delete"], {"video_id": video["id"]}),
)
]
pass
else:
context_menu = [
(
context.localize(self._local_map["nowtv.add_to_watch_later"]),
"RunPlugin(%s)"
% context.create_uri(["nowtv", "watch_later", "add"], {"video_id": video["id"]}),
)
]
pass
else:
context_menu = [
(
context.localize(self._local_map["nowtv.add_to_watch_later"]),
"RunPlugin(%s)"
% context.create_uri(
[kodion.constants.paths.WATCH_LATER, "add"], {"item": kodion.items.to_jsons(video_item)}
),
)
]
pass
if context_menu:
video_item.set_context_menu(context_menu)
pass
result.append(video_item)
pass
return result