def unwatchlater(uuid, title, url):
''' The API interface to unwatch an episode used by the context menu '''
from resumepoints import ResumePoints
ResumePoints().unwatchlater(uuid=uuid,
title=to_unicode(
unquote_plus(from_unicode(title))),
url=url)
def watchlater(asset_id, title, url):
"""The API interface to watch an episode used by the context menu"""
from resumepoints import ResumePoints
ResumePoints().watchlater(asset_id=asset_id,
title=to_unicode(
unquote_plus(from_unicode(title))),
url=url)
def __init__(self):
"""PlayerInfo initialisation"""
self.resumepoints = ResumePoints()
self.apihelper = ApiHelper(Favorites(), self.resumepoints)
self.last_pos = None
self.listen = False
self.paused = False
self.total = 100
self.positionthread = None
self.quit = Event()
self.asset_str = None
# FIXME On Kodi 17, use ListItem.Filenameandpath because Player.FilenameAndPath returns the stream manifest url and
# this definitely breaks "Up Next" on Kodi 17, but this is not supported or available through the Kodi add-on repo anyway
self.path_infolabel = 'ListItem.Filenameandpath' if kodi_version_major(
) < 18 else 'Player.FilenameAndPath'
self.path = None
self.title = None
self.ep_id = None
self.episode_id = None
self.episode_title = None
self.video_id = None
from random import randint
self.thread_id = randint(1, 10001)
log(3, '[PlayerInfo {id}] Initialized', id=self.thread_id)
super(PlayerInfo, self).__init__()
def __init__(self):
"""VRT Monitor initialisation"""
self._resumepoints = ResumePoints()
self._playerinfo = None
self._favorites = None
self._apihelper = None
self.init_watching_activity()
super(VrtMonitor, self).__init__()
class TestResumePoints(unittest.TestCase):
_favorites = Favorites()
_resumepoints = ResumePoints()
_apihelper = ApiHelper(_favorites, _resumepoints)
@unittest.skipUnless(addon.settings.get('username'),
'Skipping as VRT username is missing.')
@unittest.skipUnless(addon.settings.get('password'),
'Skipping as VRT password is missing.')
def test_get_watchlater_episodes(self):
''' Test items, sort and order '''
episode_items, sort, ascending, content = self._apihelper.list_episodes(
page=1, variety='watchlater')
self.assertTrue(episode_items)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
@unittest.skipUnless(addon.settings.get('username'),
'Skipping as VRT username is missing.')
@unittest.skipUnless(addon.settings.get('password'),
'Skipping as VRT password is missing.')
def test_get_continue_episodes(self):
''' Test items, sort and order '''
episode_items, sort, ascending, content = self._apihelper.list_episodes(
page=1, variety='continue')
self.assertTrue(episode_items)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
@unittest.skipUnless(addon.settings.get('username'),
'Skipping as VRT username is missing.')
@unittest.skipUnless(addon.settings.get('password'),
'Skipping as VRT password is missing.')
def test_update_watchlist(self):
self._resumepoints.refresh(ttl=0)
assetuuid, first_entry = next(
iter(self._resumepoints._resumepoints.items())) # pylint: disable=protected-access
print('%s = %s' % (assetuuid, first_entry))
url = first_entry.get('value').get('url')
self._resumepoints.watchlater(uuid=assetuuid, title='Foo bar', url=url)
self._resumepoints.unwatchlater(uuid=assetuuid,
title='Foo bar',
url=url)
self._resumepoints.refresh(ttl=0)
assetuuid, first_entry = next(
iter(self._resumepoints._resumepoints.items())) # pylint: disable=protected-access
print('%s = %s' % (assetuuid, first_entry))
def test_assetpath_to_uuid(self):
self.assertEqual(None, self._resumepoints.assetpath_to_uuid(None))
assetpath = '/content/dam/vrt/2019/08/14/woodstock-depot_WP00157456'
uuid = 'contentdamvrt20190814woodstockdepotwp00157456'
self.assertEqual(uuid, self._resumepoints.assetpath_to_uuid(assetpath))
def __init__(self):
''' VRT Monitor initialisiation '''
self._resumepoints = ResumePoints()
self._container = None
self._playerinfo = None
self._favorites = None
self._apihelper = None
self.init_watching_activity()
Monitor.__init__(self)
class TestSearch(unittest.TestCase):
_favorites = Favorites()
_resumepoints = ResumePoints()
_apihelper = ApiHelper(_favorites, _resumepoints)
def test_search_journaal(self):
''' Test for journaal '''
search_items, sort, ascending, content = self._apihelper.list_search(
'journaal', page=1)
# Test we get a non-empty search result
self.assertEqual(len(search_items), 50)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
def test_search_journaal_page2(self):
''' Test for journaal '''
search_items, sort, ascending, content = self._apihelper.list_search(
'journaal', page=2)
# Test we get a non-empty search result
self.assertEqual(len(search_items), 50)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
def test_search_weer(self):
''' Test for journaal '''
search_items, sort, ascending, content = self._apihelper.list_search(
'weer', page=1)
# Test we get a non-empty search result
self.assertEqual(len(search_items), 50)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
def test_search_unicode(self):
''' Test for unicode '''
search_items, sort, ascending, content = self._apihelper.list_search(
'René', page=1)
# Test we get a non-empty search result
self.assertGreater(len(search_items), 0)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
@staticmethod
def test_search_empty():
''' Test for empty search '''
Search().search(keywords='')
def resumepoints_refresh():
''' The API interface to refresh the resumepoints cache '''
from resumepoints import ResumePoints
ResumePoints().refresh(ttl=0)
notification(message=localize(30983))
def __init__(self):
"""Initialize searchtes, relies on XBMC vfs"""
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._search_history = addon_profile() + 'search_history.json'
def __init__(self):
''' Initialise object '''
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._apihelper = ApiHelper(self._favorites, self._resumepoints)
def unwatchlater(episode_id, title):
"""The API interface to unwatch an episode used by the context menu"""
from resumepoints import ResumePoints
ResumePoints().unwatchlater(episode_id=episode_id,
title=to_unicode(
unquote_plus(from_unicode(title))))
def __init__(self):
"""Initializes TV-guide object"""
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._metadata = Metadata(self._favorites, self._resumepoints)
class TestFavorites(unittest.TestCase):
_favorites = Favorites()
_resumepoints = ResumePoints()
_apihelper = ApiHelper(_favorites, _resumepoints)
def test_get_recent_episodes(self):
''' Test items, sort and order '''
episode_items, sort, ascending, content = self._apihelper.list_episodes(page=1, variety='recent')
self.assertEqual(len(episode_items), 50)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
def test_get_offline_episodes(self):
''' Test items, sort and order '''
episode_items, sort, ascending, content = self._apihelper.list_episodes(page=1, variety='offline')
self.assertTrue(episode_items)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
@unittest.SkipTest
def test_unfollow_all(self):
programs = self._apihelper.get_tvshows()
for program_item in programs:
program_title = program_item.get('title')
program = program_item.get('programName')
if self._favorites.is_favorite(program):
# Unfollow
self._favorites.unfollow(program=program, title=program_title)
self.assertFalse(self._favorites.is_favorite(program))
@unittest.SkipTest
def test_follow_number(self):
number = 118
programs = self._apihelper.get_tvshows()
shuffle(programs)
print('VRT NU has %d programs available' % len(programs))
for program_item in programs[:number]:
program_title = program_item.get('title')
program = program_item.get('programName')
# Follow
self._favorites.follow(program=program, title=program_title)
self.assertTrue(self._favorites.is_favorite(program))
# Unfollow
# self._favorites.unfollow(program=program, title=program_title)
# self.assertFalse(self._favorites.is_favorite(program))
@unittest.skipUnless(addon.settings.get('username'), 'Skipping as VRT username is missing.')
@unittest.skipUnless(addon.settings.get('password'), 'Skipping as VRT password is missing.')
def test_follow_unfollow(self):
programs = [
{'program_title': 'Winteruur', 'program': 'winteruur'},
{'program_title': 'De Campus Cup', 'program': 'de-campus-cup'},
{'program_title': 'Terug naar Siberië', 'program': 'terug-naar-siberie'},
{'program_title': 'Belle & Sebastian', 'program': 'belle---sebastian'},
]
for program_item in programs:
program_title = program_item.get('program_title')
program = program_item.get('program')
self._favorites.follow(program=program, title=program_title)
self.assertTrue(self._favorites.is_favorite(program))
self._favorites.unfollow(program=program, title=program_title)
self.assertFalse(self._favorites.is_favorite(program))
self._favorites.follow(program=program, title=program_title)
self.assertTrue(self._favorites.is_favorite(program))
def test_programs(self):
programs = self._favorites.programs()
# NOTE: Getting favorites requires credentials
if addon.settings.get('username') and addon.settings.get('password'):
self.assertTrue(programs)
print(programs)
def test_titles(self):
titles = self._favorites.titles()
# NOTE: Getting favorites requires credentials
if addon.settings.get('username') and addon.settings.get('password'):
self.assertTrue(titles)
print(sorted(titles))
def __init__(self):
''' Initializes TV-guide object '''
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._metadata = Metadata(self._favorites, self._resumepoints)
install_opener(build_opener(ProxyHandler(get_proxies())))
class TestVRTPlayer(unittest.TestCase):
_favorites = Favorites()
_resumepoints = ResumePoints()
_apihelper = ApiHelper(_favorites, _resumepoints)
_vrtplayer = VRTPlayer()
def test_show_videos_single_episode_shows_videos(self):
program = 'marathonradio'
episode_items, sort, ascending, content = self._apihelper.list_episodes(
program=program)
self.assertTrue(episode_items, msg=program)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
self._vrtplayer.show_episodes_menu(program)
def test_show_videos_single_season_shows_videos(self):
program = 'het-weer'
episode_items, sort, ascending, content = self._apihelper.list_episodes(
program=program)
self.assertTrue(episode_items, msg=program)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
self._vrtplayer.show_episodes_menu(program)
def test_show_videos_multiple_seasons_shows_videos(self):
program = 'pano'
episode_items, sort, ascending, content = self._apihelper.list_episodes(
program=program)
self.assertTrue(episode_items)
self.assertEqual(sort, 'label')
self.assertFalse(ascending)
self.assertEqual(content, 'seasons')
self._vrtplayer.show_episodes_menu(program)
def test_show_videos_specific_seasons_shows_videos(self):
program = 'thuis'
episode_items, sort, ascending, content = self._apihelper.list_episodes(
program=program)
self.assertTrue(episode_items, msg=program)
self.assertEqual(sort, 'label')
self.assertFalse(ascending)
self.assertEqual(content, 'seasons')
self._vrtplayer.show_episodes_menu(program)
def test_categories_scraping(self):
''' Test to ensure our hardcoded categories conforms to scraped categories '''
# Remove thumbnails from scraped categories first
categories_scraped = [
dict(id=c['id'], name=c['name'])
for c in self._apihelper.get_categories()
]
categories_stored = [
dict(id=c['id'], name=c['name']) for c in CATEGORIES
]
self.assertEqual(categories_scraped, categories_stored)
def test_random_tvshow_episodes(self):
''' Rest episode from a random tvshow in a random category '''
categories = self._apihelper.get_categories()
self.assertTrue(categories)
category = random.choice(categories)
tvshow_items = self._apihelper.list_tvshows(category['id'])
self.assertTrue(tvshow_items, msg=category['id'])
tvshow = random.choice(tvshow_items)
if tvshow.path.startswith('plugin://plugin.video.vrt.nu/programs/'):
# When random program has episodes
episode_items, sort, ascending, content = self._apihelper.list_episodes(
tvshow.path.split('/')[4].replace('.relevant', ''))
self.assertTrue(episode_items, msg=tvshow.path.split('/')[4])
self.assertTrue(
sort in ['dateadded', 'episode', 'label', 'unsorted'])
self.assertTrue(ascending is True or ascending is False)
self.assertTrue(
content in ['episodes', 'seasons'],
"Content for '%s' is '%s'" % (tvshow.title, content))
elif tvshow.path.startswith('plugin://plugin.video.vrt.nu/play/id/'):
# When random program is playable item
pass
else:
self.fail(
'We did not expect this, either we find episodes or it is a playable item'
)
def test_categories(self):
''' Test to ensure our hardcoded categories conforms to scraped categories '''
category_items = self._apihelper.list_categories()
self.assertEqual(len(category_items), 17)
def test_featured(self):
''' Test to ensure our hardcoded categories conforms to scraped categories '''
featured_items = self._apihelper.list_featured()
self.assertEqual(len(featured_items), 9)
def test_play_unknown_program(self):
''' Test playing latest episode of an unknown program '''
self._vrtplayer.play_latest_episode(program='foobar')
def test_play_unknown_airdate(self):
''' Test playing unknown airdate '''
self._vrtplayer.play_episode_by_air_date(
channel='een',
start_date='2100-01-01T23:59:58',
end_date='2100-01-01T23:59:59')
self._vrtplayer.play_episode_by_air_date(
channel='foo',
start_date='2100-01-01T23:59:58',
end_date='2100-01-01T23:59:59')
def test_play_unknown_whatson_id(self):
''' Test playing unknown whatson id '''
self._vrtplayer.play_whatson(whatson_id='1234567890')
class TestApiHelper(unittest.TestCase):
_favorites = Favorites()
_resumepoints = ResumePoints()
_apihelper = ApiHelper(_favorites, _resumepoints)
def test_get_api_data_single_season(self):
title_items, sort, ascending, content = self._apihelper.list_episodes(
program='het-journaal')
self.assertTrue(110 <= len(title_items) <= 140,
'We got %s items instead.' % len(title_items))
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
def test_get_api_data_multiple_seasons(self):
title_items, sort, ascending, content = self._apihelper.list_episodes(
program='thuis')
self.assertTrue(len(title_items) < 5)
self.assertEqual(sort, 'label')
self.assertFalse(ascending)
self.assertEqual(content, 'seasons')
def test_get_api_data_specific_season(self):
title_items, sort, ascending, content = self._apihelper.list_episodes(
program='pano')
self.assertEqual(len(title_items), 5)
self.assertEqual(sort, 'label')
self.assertFalse(ascending)
self.assertEqual(content, 'seasons')
def test_get_api_data_specific_season_without_broadcastdate(self):
title_items, sort, ascending, content = self._apihelper.list_episodes(
program='postbus-x')
self.assertEqual(len(title_items), 4)
self.assertEqual(sort, 'label')
self.assertTrue(ascending)
self.assertEqual(content, 'seasons')
def test_get_recent_episodes(self):
''' Test items, sort and order '''
episode_items, sort, ascending, content = self._apihelper.list_episodes(
page=1, variety='recent')
self.assertEqual(len(episode_items), 50)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
def test_get_recent_episodes_page1(self):
''' Test items, sort and order '''
episode_items, sort, ascending, content = self._apihelper.list_episodes(
page=2, variety='recent')
self.assertEqual(len(episode_items), 50)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
def test_get_recent_episodes_page2(self):
''' Test items, sort and order '''
episode_items, sort, ascending, content = self._apihelper.list_episodes(
page=3, variety='recent')
self.assertEqual(len(episode_items), 50)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
def test_get_offline_episodes(self):
''' Test items, sort and order '''
episode_items, sort, ascending, content = self._apihelper.list_episodes(
page=1, variety='offline')
self.assertTrue(episode_items)
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
def test_get_tvshows(self):
''' Test get tvshows '''
category = 'humor'
tvshow_items = self._apihelper.get_tvshows(category=category)
self.assertTrue(tvshow_items)
def test_list_tvshows(self):
''' Test items, sort and order '''
category = 'nieuws-en-actua'
tvshow_items = self._apihelper.list_tvshows(category=category)
self.assertTrue(tvshow_items)
def test_tvshows(self):
''' Test A-Z tvshow listing and CHANNELS list '''
tvshow_items = self._apihelper.list_tvshows(category=None)
# Test we get a non-empty A-Z listing back
self.assertTrue(tvshow_items)
# Test every brand is a known channel studio name
bogus_brands = ['lang-zullen-we-lezen', 'VRT']
channel_studios = [c.get('studio') for c in CHANNELS] + bogus_brands
for tvshow in tvshow_items:
self.assertTrue(
tvshow.info_dict['studio'] in channel_studios, '%s | %s | %s' %
(tvshow.title, tvshow.info_dict['studio'], channel_studios))
def test_get_latest_episode(self):
video = self._apihelper.get_latest_episode(program='het-journaal')
self.assertTrue(video.get('listitem') is not None)
self.assertTrue(video.get('video_id') is not None)
self.assertTrue(video.get('publication_id') is not None)
def test_episode_plot(self):
title_items, sort, ascending, content = self._apihelper.list_episodes(
program='thuis', season='allseasons')
self.assertEqual(sort, 'dateadded')
self.assertFalse(ascending)
self.assertEqual(content, 'episodes')
plot = title_items[0].info_dict['plot']
print(kodi_to_ansi(plot))
def test_upnext(self):
current_episode = dict(
program='winteruur',
path='plugin://plugin.video.vrt.nu/play/whatson/705308178527',
playcount='0',
rating='0',
runtime='600',
)
next_episode = self._apihelper.get_upnext(info=current_episode)
print(next_episode)
def __init__(self):
"""Initialise object"""
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._apihelper = ApiHelper(self._favorites, self._resumepoints)
wait_for_resumepoints()
def __init__(self):
''' Initialize searchtes, relies on XBMC vfs '''
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._search_history = get_userdata_path() + 'search_history.json'
