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, **kwargs):
super(JournalInterfaceManager, self).__init__(**kwargs)
self.windows = {}
# initially load the journal window as main window
journal_menu = Journal()
self.add_window("journal_menu", journal_menu)
self.load_window("journal_menu")
# add remaining windows to tracked windows
enter_tasks = AddEntry()
self.add_window("enter_tasks", enter_tasks)
update_entry = UpdateEntry()
self.add_window("update_entry", update_entry)
review_mistakes = ReviewMistakes()
self.add_window("review_mistakes", review_mistakes)
settings = Settings()
self.add_window("settings", settings)
collections = Collection()
self.add_window("collections", collections)
favourites = Favorites()
self.add_window("favorites",favourites)
def unfollow(program, title):
''' The API interface to unfollow a program used by the context menu '''
move_down = bool(plugin.args.get('move_down'))
from favorites import Favorites
Favorites().unfollow(program=program,
title=to_unicode(unquote_plus(from_unicode(title))),
move_down=move_down)
def unfollow(program_name, title, program_id=None):
"""The API interface to unfollow a program used by the context menu"""
move_down = bool(plugin.args.get('move_down'))
from favorites import Favorites
Favorites().unfollow(program_name=program_name,
title=to_unicode(unquote_plus(from_unicode(title))),
program_id=program_id,
move_down=move_down)
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_watching_activity(self):
''' Only load components for watching activity when needed '''
if self._resumepoints.is_activated():
if not self._playerinfo:
self._playerinfo = PlayerInfo(info=self.handle_info)
if not self._favorites:
self._favorites = Favorites()
if not self._apihelper:
self._apihelper = ApiHelper(self._favorites,
self._resumepoints)
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 main_page(self): favorites = Favorites() theme_manager = ThemeManager() return template( "project", CSS = theme_manager.apply(self.dao.project["theme"]), favorites_options = favorites.make_options(), theme_options = theme_manager.make_options(), is_favorite = favorites.is_favorite(), project_name = self.dao.project["name"], project = json.dumps(self.dao.project), card_background = theme_manager.theme["card_background"] )
def init_watching_activity(self):
"""Only load components for watching activity when needed"""
if self._resumepoints.is_activated():
if not self._playerinfo:
self._playerinfo = PlayerInfo()
if not self._favorites:
self._favorites = Favorites()
if not self._apihelper:
self._apihelper = ApiHelper(self._favorites,
self._resumepoints)
else:
self._playerinfo = None
def browse(self, path):
favorites = Favorites()
theme_manager = ThemeManager()
for root, folders, files in os.walk(path):
folders.sort()
return template("browse",
CSS=theme_manager.apply("default"),
favorites_options=favorites.make_options(),
theme_options=theme_manager.make_options(),
drives=self.get_drives(),
parent=os.path.abspath(
os.path.join(path, os.pardir)),
folders=folders,
path=root,
isAProject=("LUCID.json" in files))
def __init__(self, view_manager_class, model_class):
self.fav = Favorites(open(Setting.fav_filename))
self.playlist = Playlist(open(Setting.playlist_filename))
self.view = view_manager_class(controller=self)
self.thumb_view = self.view.get_thumb_view()
self.picture_view = self.view.get_picture_view()
self.video_view = self.view.get_video_view()
self.model = model_class(self)
self.history = History()
self.loader = Loader()
self.thumb_loader = self.loader.get_new_thread(
self.on_thumb_load, self.thumb_view.progress_stop)
self.picture_loader = self.loader.get_new_thread(
lambda x: self.picture_view.refresh())
self.thumb_view.set_cycle_handler(self.cycle_handler)
def follow(program, title):
''' The API interface to follow a program used by the context menu '''
from favorites import Favorites
Favorites().follow(program=program,
title=to_unicode(unquote_plus(from_unicode(title))))
def favorites_manage():
''' The API interface to manage your favorites '''
from favorites import Favorites
Favorites().manage()
def favorites_refresh():
''' The API interface to refresh the favorites cache '''
from favorites import Favorites
Favorites().refresh(ttl=0)
notification(message=localize(30982))
def __init__(self):
"""Initialize searchtes, relies on XBMC vfs"""
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._search_history = addon_profile() + 'search_history.json'
def toggle_favorite(self):
favorites = Favorites()
favorites.toggle(self.dao.project["name"])
return redirect("/")
def __init__(self):
''' Initialise object '''
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._apihelper = ApiHelper(self._favorites, self._resumepoints)
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 follow(program_name, title, program_id=None):
"""The API interface to follow a program used by the context menu"""
from favorites import Favorites
Favorites().follow(program_name=program_name,
title=to_unicode(unquote_plus(from_unicode(title))),
program_id=program_id)
def favorites_manage():
"""The API interface to manage your favorites"""
from favorites import Favorites
Favorites().manage()
def __init__(self):
''' Initialize searchtes, relies on XBMC vfs '''
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._search_history = get_userdata_path() + 'search_history.json'
'''
Favorite Files
Licensed under MIT
Copyright (c) 2012 Isaac Muse <*****@*****.**>
'''
import sublime
import sublime_plugin
from os.path import join, exists, normpath
from favorites import Favorites
Favs = Favorites(
join(sublime.packages_path(), 'User', 'favorite_files_list.json'))
class Refresh:
dummy_file = normpath(
join(sublime.packages_path(), 'FavoriteFiles', 'refresh.txt'))
on = False
class CleanOrphanedFavoritesCommand(sublime_plugin.WindowCommand):
def run(self):
# Clean out all dead links
if not Favs.load(clean=True, win_id=self.window.id()):
Favs.load(force=True, clean=True, win_id=self.window.id())
class SelectFavoriteFileCommand(sublime_plugin.WindowCommand):
def open_file(self, value, group=False):
if value >= 0:
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 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())))
def __init__(self):
"""Initialise object"""
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._apihelper = ApiHelper(self._favorites, self._resumepoints)
wait_for_resumepoints()
def __init__(self):
"""Initializes TV-guide object"""
self._favorites = Favorites()
self._resumepoints = ResumePoints()
self._metadata = Metadata(self._favorites, self._resumepoints)
