def post(self, url, hidden=False, **kwargs):
kodi.log("LOADING: %s" % url)
if kwargs and not hidden:
kodi.log("Payload: %s" % kwargs)
req = self.session.post(url, timeout=30, **kwargs)
req.soup = MethodType(self.soup, req)
return req
def func_mapper(task):
'''Stores indication of whether function errored'''
try:
task.func(task.obj)
except Exception as exc:
kodi.log("Error removing %s:\n%s" % (task.obj, traceback.format_exc().decode(sys.getfilesystemencoding())))
task.exception = exc
def tap(self, keycode, character, press_bool):
"""get single key then stop keyboardevent"""
if press_bool:
self.keycode = keycode
self.character = character
kodi.log(keycode)
kodi.log(character)
self.stop()
def run(self, player):
self.player = player
funcmap = {button.code: button.func for button in self.mapping if button.code}
self.listener = PlaybackListener(funcmap)
self.listener.run()
missing_keys = [button.name for button in self.mapping if button.code not in funcmap]
if missing_keys:
kodi.log("Note, following actions are not mapped to remote: %s" % missing_keys)
def monitor_movie_progress(self, playingfile):
kodi.log("starting monitoring")
movie = MediaItem(name=playingfile["label"], kodiid=playingfile["id"], playcount=playingfile["playcount"],
runtime=dt.timedelta(seconds=playingfile["runtime"]))
started_watching_at = dt.datetime.now()
self.stop_event.wait()
self.mark_watched(movie, started_watching_at)
kodi.log("finished monitoring")
def _getapiurl(contextdata):
kodi.log("setting api url")
try:
shakti_api_root = contextdata["serverDefs"]["data"]["SHAKTI_API_ROOT"]
build_identifier = contextdata["serverDefs"]["data"]["BUILD_IDENTIFIER"]
except KeyError:
kodi.log(contextdata)
raise
api = shakti_api_root + "/" + build_identifier
return api
def setup(self):
self.load_cookies()
kodi.log("Checking login")
page = self.get("https://www.netflix.com/login")
if page.url != "https://www.netflix.com/browse":
raise Exception("Login failed. Ensure chrome is logged in")
contextdata = _extract_contextdata(page.text)
if kodi.settings["geolocation"] and kodi.settings["geolocation"] != "Any country":
_check_location(contextdata)
self.endpoints = contextdata["serverDefs"]["data"]["endpointIdentifiers"]
self.authurl = contextdata["userInfo"]["data"]["authURL"]
def mark_watched(self, mediaitem, started_watching_at):
finished_watching_at = dt.datetime.now()
watch_duration = finished_watching_at - started_watching_at
if 0 in (mediaitem.runtime.seconds, watch_duration.seconds):
return
if watch_duration.seconds / mediaitem.runtime.seconds >= 0.9:
kodi.rpc("VideoLibrary.SetEpisodeDetails", episodeid=mediaitem.kodiid,
playcount=mediaitem.playcount + 1, lastplayed=finished_watching_at.strftime("%d-%m-%Y %H:%M:%S"))
kodi.log("%s: Marked as watched" % mediaitem.name)
else:
kodi.log("%s: Skipped, only partially watched (%s vs. %s)" %
(mediaitem.name, mediaitem.runtime.seconds, watch_duration.seconds))
def coro_mapper(task):
'''Executes next step in coroutine sent as arg,
Prints traceback otherwise swallowed due to multithreading
Stores indication of whether coroutine is finished (stopiteration), errored (exception), or unfinished
'''
try:
next(task.coroutine)
except StopIteration:
task.finished = True
except Exception as exc:
kodi.log("Error adding/updating %s:\n%s" % (task.obj, traceback.format_exc().decode(sys.getfilesystemencoding())))
task.exception = exc
task.finished = True
def connect(self):
try:
self.browser = Chromote(host="localhost", port=9222)
except requests.exceptions.ConnectionError:
self.browser = Chromote(host="localhost", port=9222, internet_explorer=True)
kodi.log("connected to %s: %s" % (self.browser.browsertype, self.browser))
while not self.stop_event.check():
try:
self.tab = next(tab for tab, title, url in self.browser.tabs if url != "about:blank" and "file://" not in url)
break
except StopIteration:
xbmc.sleep(200)
self.tab.connect_websocket()
kodi.log("websocket connected: %s" % self.tab.url)
def run_schedule():
timeout = minutes_to_next_rounded_update_time()
kodi.log("Starting update scheduler, next update at %s" %
(dt.datetime.now() + dt.timedelta(seconds=timeout)).strftime("%H:%M"))
while True:
abort = xbmc.Monitor().waitForAbort(timeout)
if abort:
kodi.log("Closing background service")
break
timeout = {
"15 min": 900,
"30 min": 1800,
"1 hour": 3600,
"2 hours": 7200
}[kodi.settings["schedule frequency"]]
scheduler_enabled = kodi.settings["enable schedule"]
player_active = kodi.rpc("Player.GetActivePlayers")
koala_active = xbmcgui.Window(10000).getProperty("%s running" % const.addonname) == "true"
if player_active or koala_active or not scheduler_enabled:
continue
kodi.log("Starting scheduled update next update at %s" %
(dt.datetime.now() + dt.timedelta(seconds=timeout)).strftime("%H:%M"))
xbmc.executebuiltin("RunScript(%s, mode=library, action=schedule)" % const.addonid)
def setup(self):
playingfile = self.get_playing_file()
if not playingfile["file"].startswith((utils.uni_join(const.libpath, const.provider),
utils.uni_join(const.addonpath, "resources"))):
return
try:
kodi.log("Start playback setup")
self.player = Player(stop_event=self.stop_event)
if kodi.settings["remote"]:
self.remote = remote.Remote()
self.remote.run(player=self.player)
self.player.connect()
if playingfile["type"] == "episode":
Thread(target=self.monitor_episodes_progress, args=[playingfile]).start()
elif playingfile["type"] == "movie":
Thread(target=self.monitor_movie_progress, args=[playingfile]).start()
kodi.log("Finished playback setup")
except self.player.exceptions:
pass
except:
kodi.log("Exception occured during playback\n%s" % traceback.format_exc().decode(sys.getfilesystemencoding()))
finally:
self.stop_event.wait()
kodi.log("Start playback cleanup")
if self.remote:
self.remote.close()
if self.player:
self.player.disconnect()
kodi.log("Finish playback cleanup")
def library_mode(action):
if xbmcgui.Window(10000).getProperty("%s running" % const.addonname) == "true":
if action in ["startup", "schedule"]:
return
run = kodi.Dialog.yesno(heading="Running", line1="Koala is running. ",
line2="Running multiple instances may cause instablity.", line3="Continue?")
if not run:
return
koalasetup()
if not is_libpath_added():
kodi.Dialog.ok(heading="Koala path not in video sources",
line1="Koala library paths have not been added to Kodi video sources:",
line2=utils.uni_join(const.libpath, "%s shows" % const.provider),
line3=utils.uni_join(const.libpath, "%s movies" % const.provider))
return
starttime = dt.datetime.now()
kodi.log("Starting %s" % action)
xbmcgui.Window(10000).setProperty("%s running" % const.addonname, "true")
try:
library.main(action)
finally:
xbmcgui.Window(10000).setProperty("%s running" % const.addonname, "false")
kodi.log("Finished %s in %s" % (action, str(dt.datetime.now() - starttime)))
def remove_show(show):
kodi.log("Removing show: %s" % show.title)
koala_stored_episodes = show.get_koala_stored_eps()
for lib_entry in koala_stored_episodes:
lib_entry.save_playcount()
lib_entry.delete_htm()
lib_entry.remove_from_lib()
databases.stored_shows.remove(show)
kodi.log("Removed episodes: %s, %s" % (show.title, sorted(koala_stored_episodes)))
kodi.log("Finished removing show: %s" % show.title)
def get_watchlist_changes(session, tasks):
available_movies, available_shows = session.get_watchlist()
unav_movies = databases.stored_movies - available_movies
kodi.log("unavailable_movies:\n %s" % unav_movies)
tasks["removals"].extend([Task(movie, remove_movie) for movie in unav_movies])
unav_shows = databases.stored_shows - available_shows
kodi.log("unavailable_shows:\n %s" % unav_shows)
tasks["removals"].extend([Task(show, remove_show) for show in unav_shows])
new_movies = available_movies - (databases.stored_movies | databases.excluded_movies)
kodi.log("new_movies:\n %s" % new_movies)
tasks["updates"].extend([Task(movie, add_movie) for movie in new_movies])
new_shows = available_shows - (databases.stored_shows | databases.excluded_shows)
kodi.log("new_shows:\n %s" % new_shows)
tasks["updates"].extend([Task(show, update_add_show) for show in new_shows])
def remove_movie(movie):
kodi.log("Removing movie: %s" % movie)
lib_entry = movie.get_lib_entry()
if lib_entry:
lib_entry.save_playcount()
lib_entry.remove_from_lib()
lib_entry.delete_htm()
else:
kodi.log("Couldn't find in library: %s" % (movie))
if kodi.settings["added_notifications"]:
kodi.Dialog.notification(heading="%s movie removed:" % const.provider, message=movie.title)
databases.stored_movies.remove(movie)
kodi.log("Finished removing movie: %s" % movie)
def add_movie(movie, session):
kodi.log("Adding movie: %s" % movie)
movie.write_htm()
yield
lib_entry = movie.get_lib_entry()
if not lib_entry:
metadata = session.get_movie_metadata(movie)
movie.write_nfo(metadata)
movie.write_htm()
kodi.log("NFO created, waiting for second lib update: %s" % movie.title)
yield
lib_entry = movie.get_lib_entry()
if not lib_entry:
kodi.log("Failed to add movie: %s" % movie)
return
lib_entry.load_playcount()
if kodi.settings["added_notifications"]:
kodi.Dialog.notification(heading="%s movie added:" % const.provider, message=movie.title)
databases.stored_movies.add(movie)
kodi.log("Finished adding movie: %s" % movie)
def monitor_episodes_progress(self, playingfile):
kodi.log("starting monitoring")
first_urlid, stored_episodes = self.get_episodes(playingfile)
current_urlid = first_urlid
episode_watching = stored_episodes[current_urlid]
started_watching_at = dt.datetime.now()
while not self.stop_event.is_set:
new_urlid = self.player.wait_for_new_episode(starting_urlid=current_urlid)
if new_urlid is None:
break # browser closed
if episode_watching:
self.mark_watched(episode_watching, started_watching_at)
kodi.log("new urlid: %s" % new_urlid)
current_urlid = new_urlid
episode_watching = stored_episodes.get(current_urlid)
started_watching_at = dt.datetime.now()
self.mark_watched(episode_watching, started_watching_at)
kodi.log("finished monitoring")
def exclude_show(show):
kodi.log("Excluding show: %s" % show.title)
remove_show(show)
databases.excluded_shows.add(show)
kodi.log("Finished excluding show: %s" % show.title)
def readd_movie(movie, session):
kodi.log("Readding movie: %s" % movie.title)
for step in add_movie(movie, session):
yield
databases.excluded_movies.remove(movie)
kodi.log("Finished readding movie: %s" % movie.title)
def exclude_movie(movie):
kodi.log("Excluding movie: %s" % movie.title)
remove_movie(movie)
databases.excluded_movies.add(movie)
kodi.log("Finished excluding movie: %s" % movie.title)
def cont(self):
kodi.log("Remote: cont triggered")
self.player.cont()
def playpause(self):
kodi.log("Remote: playpause triggered")
self.player.playpause()
def readd_show(show, session):
kodi.log("Readding show: %s" % show.title)
for step in update_add_show(show, session):
yield
databases.excluded_shows.remove(show)
kodi.log("Finished readding show: %s" % show.title)
def stop(self):
PyKeyboardEvent.stop(self)
kodi.log("keygetter stopped")
def next(self):
kodi.log("Remote: next triggered")
self.player.next()
def forward(self):
kodi.log("Remote: forward triggered")
self.player.forward()
def update_add_show(show, session):
kodi.log("Updating show: %s" % show.title)
show_metadata, available_episodes = session.get_showdata_episodes(show)
unav_episodes, new_episodes = show.get_episode_availability(available_episodes)
if unav_episodes:
for lib_entry in unav_episodes:
lib_entry.save_playcount()
lib_entry.delete_htm()
lib_entry.remove_from_lib()
kodi.log("Removed episodes: %s, %s" % (show, sorted(unav_episodes)))
if new_episodes:
for episode in new_episodes:
episode.write_htm()
kodi.log("htms created, waiting for lib update: %s %s" %
(show, sorted(new_episodes)))
yield
koala_stored_episodes = show.get_koala_stored_eps()
nonadded_episodes = new_episodes - koala_stored_episodes
if nonadded_episodes:
if not koala_stored_episodes:
show.write_nfo(show_metadata)
for episode in nonadded_episodes:
episode.write_nfo()
episode.write_htm()
kodi.log("NFOs created, waiting for second lib update: %s, %s" %
(show, sorted(nonadded_episodes)))
yield
koala_stored_episodes = show.get_koala_stored_eps()
nonadded_episodes = new_episodes - koala_stored_episodes
if nonadded_episodes:
kodi.log("Failed to add episodes: %s, %s" % (show, sorted(nonadded_episodes)))
added_episodes = koala_stored_episodes - nonadded_episodes
for lib_entry in added_episodes:
lib_entry.load_playcount()
if kodi.settings["added_notifications"]:
if len(new_episodes) == 1:
message = "Added episode: %s" % list(new_episodes)[0].code
elif len(new_episodes) <= 3:
message = "Added episodes: %s" % ", ".join(sorted([ep.code for ep in new_episodes]))
else:
message = "Added %s episodes" % len(new_episodes)
kodi.Dialog.notification(heading=show.title, message=message)
kodi.log("Added episodes: %s, %s" % (show, sorted(added_episodes)))
databases.stored_shows.upsert(show)
kodi.log("Finished updating show: %s" % show)
def stop(self):
kodi.log("Remote: stop triggered")
self.player.stop()
def rewind(self):
kodi.log("Remote: rewind triggered")
self.player.rewind()
