def __rateOnTrakt(rating, media_type, media, unrate=False):
logger.debug("Sending rating (%s) to Trakt.tv" % rating)
params = media
if utils.isMovie(media_type):
key = 'movies'
params['rating'] = rating
elif utils.isShow(media_type):
key = 'shows'
params['rating'] = rating
elif utils.isSeason(media_type):
key = 'shows'
params['seasons'] = [{'rating': rating, 'number': media['season']}]
elif utils.isEpisode(media_type):
key = 'episodes'
params['rating'] = rating
else:
return
root = {key: [params]}
if not unrate:
data = globals.traktapi.addRating(root)
else:
data = globals.traktapi.removeRating(root)
if data:
s = utils.getFormattedItemName(media_type, media)
if 'not_found' in data and not data['not_found']['movies'] and not data['not_found']['episodes'] and not data['not_found']['shows']:
if not unrate:
utils.notification(utils.getString(32040), s)
else:
utils.notification(utils.getString(32042), s)
else:
utils.notification(utils.getString(32044), s)
def traktUpdateMovies(self, movies):
if len(movies) == 0:
self.updateProgress(60, line2=utilities.getString(1469))
Debug("[Movies Sync] trakt.tv movie playcount is up to date")
return
titles = ", ".join(["%s (%s)" % (m['title'], m['imdb_id']) for m in movies])
Debug("[Movies Sync] %i movie(s) playcount will be updated on trakt.tv" % len(movies))
Debug("[Movies Sync] Movies updated: %s" % titles)
self.updateProgress(40, line2="%i %s" % (len(movies), utilities.getString(1428)))
# Send request to update playcounts on trakt.tv
chunked_movies = utilities.chunks([self.sanitizeMovieData(movie) for movie in movies], 50)
i = 0
x = float(len(chunked_movies))
for chunk in chunked_movies:
if self.isCanceled():
return
params = {'movies': chunk}
if self.simulate:
Debug("[Movies Sync] %s" % str(params))
else:
self.traktapi.updateSeenMovie(params)
i = i + 1
y = ((i / x) * 20) + 40
self.updateProgress(int(y), line2=utilities.getString(1478))
self.updateProgress(60, line2=utilities.getString(1470) % len(movies))
def __traktRemoveMovies(self, movies):
if len(movies) == 0:
self.__updateProgress(40, line2=utilities.getString(1474))
Debug(
"[Movies Sync] trakt.tv movie collection is clean, no movies to remove."
)
return
titles = ", ".join(["%s" % (m['title']) for m in movies])
Debug(
"[Movies Sync] %i movie(s) will be removed from trakt.tv collection."
% len(movies))
Debug("[Movies Sync] Movies removed: %s" % titles)
self.__updateProgress(20,
line2="%i %s" %
(len(movies), utilities.getString(1444)))
for movie in movies:
del (movie['collected_at'])
moviesToRemove = {'movies': movies}
self.traktapi.removeFromCollection(moviesToRemove)
self.__updateProgress(40,
line2=utilities.getString(1475) % len(movies))
def __traktUpdateMovies(self, movies):
if len(movies) == 0:
self.__updateProgress(60, line2=utilities.getString(1469))
Debug("[Movies Sync] trakt.tv movie playcount is up to date")
return
titles = ", ".join(["%s" % (m['title']) for m in movies])
Debug(
"[Movies Sync] %i movie(s) playcount will be updated on trakt.tv" %
len(movies))
Debug("[Movies Sync] Movies updated: %s" % titles)
self.__updateProgress(40,
line2="%i %s" %
(len(movies), utilities.getString(1428)))
# Send request to update playcounts on trakt.tv
chunked_movies = utilities.chunks([movie for movie in movies], 200)
i = 0
x = float(len(chunked_movies))
for chunk in chunked_movies:
if self.__isCanceled():
return
params = {'movies': chunk}
self.traktapi.addToHistory(params)
i += 1
y = ((i / x) * 20) + 40
self.__updateProgress(int(y), line2=utilities.getString(1478))
self.__updateProgress(60,
line2=utilities.getString(1470) % len(movies))
def __traktLoadShows(self):
self.__updateProgress(10,
line1=utilities.getString(1485),
line2=utilities.getString(1486))
Debug('[Episodes Sync] Getting episode collection from trakt.tv')
traktShows = {}
traktShows = self.traktapi.getShowsCollected(traktShows)
traktShows = self.traktapi.getShowsWatched(traktShows)
traktShows = traktShows.items()
if not isinstance(traktShows, list):
Debug(
"[Episodes Sync] Invalid trakt.tv show list, possible error getting data from trakt, aborting trakt.tv collection update."
)
return False
self.__updateProgress(12, line2=utilities.getString(1487))
shows = {'shows': []}
for key, show in traktShows:
#will keep the data in python structures - just like the KODI response
show = show.to_info()
shows['shows'].append(show)
return shows
def traktRemoveMovies(self, movies):
if len(movies) == 0:
self.updateProgress(98, line2=utilities.getString(1474))
Debug("[Movies Sync] trakt.tv movie collection is clean, no movies to remove.")
return
titles = ", ".join(["%s (%s)" % (m['title'], m['imdb_id']) for m in movies])
Debug("[Movies Sync] %i movie(s) will be removed from trakt.tv collection." % len(movies))
Debug("[Movies Sync] Movies removed: %s" % titles)
self.updateProgress(80, line2="%i %s" % (len(movies), utilities.getString(1444)))
chunked_movies = utilities.chunks([self.sanitizeMovieData(movie) for movie in movies], 50)
i = 0
x = float(len(chunked_movies))
for chunk in chunked_movies:
if self.isCanceled():
return
params = {'movies': chunk}
if self.simulate:
Debug("[Movies Sync] %s" % str(params))
else:
self.traktapi.removeMovie(params)
i = i + 1
y = ((i / x) * 20) + 80
self.updateProgress(int(y), line2=utilities.getString(1476))
self.updateProgress(98, line2=utilities.getString(1475) % len(movies))
def __addMovieProgressToKodi(self, traktMovies, kodiMovies):
if utilities.getSettingAsBool('trakt_movie_playback') and traktMovies and not self.__isCanceled():
updateKodiTraktMovies = copy.deepcopy(traktMovies)
updateKodiKodiMovies = copy.deepcopy(kodiMovies)
kodiMoviesToUpdate = self.__compareMovies(updateKodiTraktMovies['movies'], updateKodiKodiMovies, restrict=True, playback=True)
if len(kodiMoviesToUpdate) == 0:
self.__updateProgress(99, line2=utilities.getString(32125))
logger.debug("[Movies Sync] Kodi movie playbacks are up to date.")
return
logger.debug("[Movies Sync] %i movie(s) playbacks will be updated in Kodi" % len(kodiMoviesToUpdate))
self.__updateProgress(85, line2=utilities.getString(32126) % len(kodiMoviesToUpdate))
#need to calculate the progress in int from progress in percent from Trakt
#split movie list into chunks of 50
chunksize = 50
chunked_movies = utilities.chunks([{"jsonrpc": "2.0", "id": i, "method": "VideoLibrary.SetMovieDetails", "params": {"movieid": kodiMoviesToUpdate[i]['movieid'], "resume": {"position": kodiMoviesToUpdate[i]['runtime']/100.0*kodiMoviesToUpdate[i]['progress']}}} for i in range(len(kodiMoviesToUpdate))], chunksize)
i = 0
x = float(len(kodiMoviesToUpdate))
for chunk in chunked_movies:
if self.__isCanceled():
return
i += 1
y = ((i / x) * 14) + 85
self.__updateProgress(int(y), line2=utilities.getString(32127) % ((i)*chunksize if (i)*chunksize < x else x, x))
utilities.kodiJsonRequest(chunk)
self.__updateProgress(99, line2=utilities.getString(32128) % len(kodiMoviesToUpdate))
def xbmcUpdateMovies(self, movies):
if len(movies) == 0:
self.updateProgress(80, line2=utilities.getString(1471))
Debug("[Movies Sync] XBMC movie playcount is up to date.")
return
titles = ", ".join(["%s (%s)" % (m['title'], m['imdb_id']) for m in movies])
Debug("[Movies Sync] %i movie(s) playcount will be updated in XBMC" % len(movies))
Debug("[Movies Sync] Movies updated: %s" % titles)
self.updateProgress(60, line2="%i %s" % (len(movies), utilities.getString(1430)))
#split movie list into chunks of 50
chunked_movies = utilities.chunks([{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": {"movieid": movies[i]['movieid'], "playcount": movies[i]['plays']}, "id": i} for i in range(len(movies))], 50)
i = 0
x = float(len(chunked_movies))
for chunk in chunked_movies:
if self.isCanceled():
return
if self.simulate:
Debug("[Movies Sync] %s" % str(chunk))
else:
utilities.xbmcJsonRequest(chunk)
i = i + 1
y = ((i / x) * 20) + 60
self.updateProgress(int(y), line2=utilities.getString(1472))
self.updateProgress(80, line2=utilities.getString(1473) % len(movies))
def __addMoviesToTraktCollection(self, kodiMovies, traktMovies):
if utilities.getSettingAsBool('add_movies_to_trakt') and not self.__isCanceled():
addTraktMovies = copy.deepcopy(traktMovies)
addKodiMovies = copy.deepcopy(kodiMovies)
traktMoviesToAdd = self.__compareMovies(addKodiMovies, addTraktMovies)
self.sanitizeMovies(traktMoviesToAdd)
logger.debug("[Movies Sync] Compared movies, found %s to add." % len(traktMoviesToAdd))
if len(traktMoviesToAdd) == 0:
self.__updateProgress(48, line2=utilities.getString(32084))
logger.debug("[Movies Sync] Trakt.tv movie collection is up to date.")
return
titles = ", ".join(["%s" % (m['title']) for m in traktMoviesToAdd])
logger.debug("[Movies Sync] %i movie(s) will be added to Trakt.tv collection." % len(traktMoviesToAdd))
logger.debug("[Movies Sync] Movies to add : %s" % titles)
self.__updateProgress(37, line2=utilities.getString(32063) % len(traktMoviesToAdd))
moviesToAdd = {'movies': traktMoviesToAdd}
#logger.debug("Movies to add: %s" % moviesToAdd)
try:
self.traktapi.addToCollection(moviesToAdd)
except Exception as ex:
message = utilities.createError(ex)
logging.fatal(message)
self.__updateProgress(48, line2=utilities.getString(32085) % len(traktMoviesToAdd))
def traktRemoveEpisodes(self, shows):
if len(shows) == 0:
Debug('[Episodes Sync] trakt.tv episode collection is clean')
return
Debug("[Episodes Sync] %i show(s) will have episodes removed from trakt.tv collection." % len(shows))
for show in shows:
Debug("[Episodes Sync] Episodes removed: %s" % self.getShowAsString(show, short=True))
if self.show_progress:
progress.update(90, line1=utilities.getString(1445), line2='%i %s' % (len(shows), utilities.getString(1446)))
for show in shows:
if self.isCanceled():
return
epCount = self.countEpisodes([show])
title = show['title'].encode('utf-8', 'ignore')
if self.show_progress:
progress.update(95, line1=utilities.getString(1445), line2=title, line3='%i %s' % (epCount, utilities.getString(1447)))
s = self.traktFormatShow(show)
if self.simulate:
Debug("[Episodes Sync] %s" % str(s))
else:
self.traktapi.removeEpisode(s)
def __deleteEpisodesFromTraktCollection(self, traktShows, kodiShows):
if utilities.getSettingAsBool('clean_trakt_episodes') and not self.__isCanceled():
removeTraktShows = copy.deepcopy(traktShows)
removeKodiShows = copy.deepcopy(kodiShows)
traktShowsRemove = self.__compareShows(removeTraktShows, removeKodiShows)
self.sanitizeShows(traktShowsRemove)
if len(traktShowsRemove['shows']) == 0:
self.__updateProgress(65, line1=utilities.getString(32077), line2=utilities.getString(32110))
logger.debug('[Episodes Sync] Trakt.tv episode collection is clean, no episodes to remove.')
return
logger.debug("[Episodes Sync] %i show(s) will have episodes removed from Trakt.tv collection." % len(traktShowsRemove['shows']))
for show in traktShowsRemove['shows']:
logger.debug("[Episodes Sync] Episodes removed: %s" % self.__getShowAsString(show, short=True))
self.__updateProgress(50, line1=utilities.getString(32077), line2=utilities.getString(32111) % self.__countEpisodes(traktShowsRemove), line3=" ")
logger.debug("[traktRemoveEpisodes] Shows to remove %s" % traktShowsRemove)
try:
self.traktapi.removeFromCollection(traktShowsRemove)
except Exception as ex:
message = utilities.createError(ex)
logging.fatal(message)
self.__updateProgress(65, line2=utilities.getString(32112) % self.__countEpisodes(traktShowsRemove), line3=" ")
def traktAddMovies(self, movies):
if len(movies) == 0:
self.updateProgress(40, line2=utilities.getString(1467))
Debug("[Movies Sync] trakt.tv movie collection is up to date.")
return
titles = ", ".join(["%s (%s)" % (m['title'], m['imdb_id']) for m in movies])
Debug("[Movies Sync] %i movie(s) will be added to trakt.tv collection." % len(movies))
Debug("[Movies Sync] Movies added: %s" % titles)
self.updateProgress(20, line2="%i %s" % (len(movies), utilities.getString(1426)))
chunked_movies = utilities.chunks([self.sanitizeMovieData(movie) for movie in movies], 50)
i = 0
x = float(len(chunked_movies))
for chunk in chunked_movies:
if self.isCanceled():
return
params = {'movies': chunk}
if self.simulate:
Debug("[Movies Sync] %s" % str(params))
else:
self.traktapi.addMovie(params)
i = i + 1
y = ((i / x) * 20) + 20
self.updateProgress(int(y), line2=utilities.getString(1477))
self.updateProgress(40, line2=utilities.getString(1468) % len(movies))
def traktAddEpisodes(self, shows):
if len(shows) == 0:
Debug("[Episodes Sync] trakt.tv episode collection is up to date.")
return
Debug("[Episodes Sync] %i show(s) have episodes (%d) to be added to your trakt.tv collection." % (len(shows), self.countEpisodes(shows)))
for show in shows:
Debug("[Episodes Sync] Episodes added: %s" % self.getShowAsString(show, short=True))
if self.show_progress:
progress.update(35, line1=utilities.getString(1435), line2='%i %s' % (len(shows), utilities.getString(1436)))
for show in shows:
if self.isCanceled():
return
epCount = self.countEpisodes([show])
title = show['title'].encode('utf-8', 'ignore')
if self.show_progress:
progress.update(45, line1=utilities.getString(1435), line2=title, line3='%i %s' % (epCount, utilities.getString(1437)))
s = self.traktFormatShow(show)
if self.simulate:
Debug("[Episodes Sync] %s" % str(s))
else:
self.traktapi.addEpisode(s)
def __kodiUpdateEpisodes(self, shows):
if len(shows['shows']) == 0:
self.__updateProgress(82, line1=utilities.getString(1441), line2=utilities.getString(1493))
Debug("[Episodes Sync] Kodi episode playcounts are up to date.")
return
Debug("[Episodes Sync] %i show(s) shows are missing playcounts on Kodi" % len(shows['shows']))
for s in ["%s" % self.__getShowAsString(s, short=True) for s in shows['shows']]:
Debug("[Episodes Sync] Episodes updated: %s" % s)
self.__updateProgress(64, line1=utilities.getString(1441), line2="%i %s" % (len(shows['shows']), utilities.getString(1439)), line3=" ")
episodes = []
for show in shows['shows']:
for season in show['seasons']:
for episode in season['episodes']:
episodes.append({'episodeid': episode['ids']['episodeid'], 'playcount': 1})
#split episode list into chunks of 50
chunked_episodes = utilities.chunks([{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": episodes[i], "id": i} for i in range(len(episodes))], 50)
i = 0
x = float(len(chunked_episodes))
for chunk in chunked_episodes:
if self.__isCanceled():
return
Debug("[Episodes Sync] chunk %s" % str(chunk))
result = utilities.kodiJsonRequest(chunk)
Debug("[Episodes Sync] result %s" % str(result))
i += 1
y = ((i / x) * 18) + 64
self.__updateProgress(int(y), line2=utilities.getString(1494))
self.__updateProgress(82, line2=utilities.getString(1495) % len(episodes))
def __addMoviesToKodiWatched(self, traktMovies, kodiMovies):
if utilities.getSettingAsBool('kodi_movie_playcount') and not self.__isCanceled():
updateKodiTraktMovies = copy.deepcopy(traktMovies)
updateKodiKodiMovies = copy.deepcopy(kodiMovies)
kodiMoviesToUpdate = self.__compareMovies(updateKodiTraktMovies, updateKodiKodiMovies, watched=True, restrict=True)
if len(kodiMoviesToUpdate) == 0:
self.__updateProgress(84, line2=utilities.getString(32088))
logger.debug("[Movies Sync] Kodi movie playcount is up to date.")
return
titles = ", ".join(["%s" % (m['title']) for m in kodiMoviesToUpdate])
logger.debug("[Movies Sync] %i movie(s) playcount will be updated in Kodi" % len(kodiMoviesToUpdate))
logger.debug("[Movies Sync] Movies to add: %s" % titles)
self.__updateProgress(73, line2=utilities.getString(32065) % len(kodiMoviesToUpdate))
#split movie list into chunks of 50
chunksize = 50
chunked_movies = utilities.chunks([{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": {"movieid": kodiMoviesToUpdate[i]['movieid'], "playcount": kodiMoviesToUpdate[i]['plays'], "lastplayed": utilities.convertUtcToDateTime(kodiMoviesToUpdate[i]['last_watched_at'])}, "id": i} for i in range(len(kodiMoviesToUpdate))], chunksize)
i = 0
x = float(len(kodiMoviesToUpdate))
for chunk in chunked_movies:
if self.__isCanceled():
return
i += 1
y = ((i / x) * 11) + 73
self.__updateProgress(int(y), line2=utilities.getString(32089) % ((i)*chunksize if (i)*chunksize < x else x, x))
utilities.kodiJsonRequest(chunk)
self.__updateProgress(84, line2=utilities.getString(32090) % len(kodiMoviesToUpdate))
def testAccount(self, force=False):
if self.__username == "":
notification('trakt', getString(
1106)) # please enter your Username and Password in settings
setSetting('account_valid', False)
return False
elif self.__password == "":
notification(
"trakt",
getString(1107)) # please enter your Password in settings
setSetting('account_valid', False)
return False
if not getSettingAsBool('account_valid') or force:
Debug("[traktAPI] Testing account '%s'." % self.__username)
url = "%s/account/test/%s" % (self.__baseURL, self.__apikey)
Debug("[traktAPI] testAccount(url: %s)" % url)
args = json.dumps({
'username': self.__username,
'password': self.__password
})
response = None
try:
# get data from trakt.tv
response = self.__getData(url, args)
except traktError, e:
if isinstance(e, traktAuthProblem):
Debug(
"[traktAPI] testAccount(): Account '%s' failed authentication. (%s)"
% (self.__username, e.value))
elif isinstance(e, traktServerBusy):
Debug("[traktAPI] testAccount(): Server Busy (%s)" %
e.value)
elif isinstance(e, traktNetworkError):
Debug("[traktAPI] testAccount(): Network error: %s" %
e.value)
elif isinstance(e, traktUnknownError):
Debug("[traktAPI] testAccount(): Other problem (%s)" %
e.value)
else:
pass
if response:
data = None
try:
data = json.loads(response)
except ValueError:
pass
if 'status' in data:
if data['status'] == 'success':
setSetting('account_valid', True)
Debug(
"[traktAPI] testAccount(): Account '%s' is valid."
% self.__username)
return True
def __traktLoadShowsPlaybackProgress(self):
if utilities.getSettingAsBool('trakt_episode_playback') and not self.__isCanceled():
self.__updateProgress(10, line1=utilities.getString(1485), line2=utilities.getString(32119))
logger.debug('[Playback Sync] Getting playback progress from Trakt.tv')
try:
traktProgressShows = self.traktapi.getEpisodePlaybackProgress()
except Exception:
logger.debug("[Playback Sync] Invalid Trakt.tv progress list, possible error getting data from Trakt, aborting Trakt.tv playback update.")
return False
i = 0
x = float(len(traktProgressShows))
showsProgress = {'shows': []}
for show in traktProgressShows:
i += 1
y = ((i / x) * 20) + 6
self.__updateProgress(int(y), line2=utilities.getString(32120) % (i, x))
#will keep the data in python structures - just like the KODI response
show = show.to_dict()
showsProgress['shows'].append(show)
self.__updateProgress(32, line2=utilities.getString(32121))
return showsProgress
def __traktRemoveEpisodes(self, shows):
if len(shows['shows']) == 0:
self.__updateProgress(48,
line1=utilities.getString(1445),
line2=utilities.getString(1496))
Debug(
'[Episodes Sync] trakt.tv episode collection is clean, no episodes to remove.'
)
return
Debug(
"[Episodes Sync] %i show(s) will have episodes removed from trakt.tv collection."
% len(shows['shows']))
for show in shows['shows']:
Debug("[Episodes Sync] Episodes removed: %s" %
self.__getShowAsString(show, short=True))
self.__updateProgress(33,
line1=utilities.getString(1445),
line2=utilities.getString(1497) %
self.__countEpisodes(shows),
line3=" ")
Debug("[trakt][traktRemoveEpisodes] Shows to remove %s" % shows)
result = self.traktapi.removeFromCollection(shows)
Debug("[trakt][traktRemoveEpisodes] Result %s" % result)
self.__updateProgress(48,
line2=utilities.getString(1498) %
self.__countEpisodes(shows),
line3=" ")
def traktUpdateEpisodes(self, shows):
if len(shows) == 0:
self.updateProgress(64, line1=utilities.getString(1438), line2=utilities.getString(1492))
Debug("[Episodes Sync] trakt.tv episode playcounts are up to date.")
return
Debug("[Episodes Sync] %i show(s) are missing playcounts on trakt.tv" % len(shows))
for show in shows:
Debug("[Episodes Sync] Episodes updated: %s" % self.getShowAsString(show, short=True))
self.updateProgress(46, line1=utilities.getString(1438), line2="%i %s" % (len(shows), utilities.getString(1439)), line3=" ")
i = 0
x = float(len(shows))
for show in shows:
if self.isCanceled():
return
epCount = self.countEpisodes([show])
title = show['title'].encode('utf-8', 'ignore')
i = i + 1
y = ((i / x) * 18) + 46
self.updateProgress(70, line2=title, line3="%i %s" % (epCount, utilities.getString(1440)))
s = self.traktFormatShow(show)
if self.simulate:
Debug("[Episodes Sync] %s" % str(s))
else:
self.traktapi.updateSeenEpisode(s)
self.updateProgress(64, line2="%i %s" % (len(shows), utilities.getString(1439)))
def __traktLoadShows(self):
self.__updateProgress(10,
line1=utilities.getString(1485),
line2=utilities.getString(1486))
Debug('[Episodes Sync] Getting episode collection from trakt.tv')
try:
traktShows = {}
traktShows = self.traktapi.getShowsCollected(traktShows)
self.__updateProgress(12, line2=utilities.getString(1487))
traktShows = self.traktapi.getShowsWatched(traktShows)
traktShows = traktShows.items()
except Exception:
Debug(
"[Episodes Sync] Invalid trakt.tv show list, possible error getting data from trakt, aborting trakt.tv collection update."
)
return False
i = 0
x = float(len(traktShows))
shows = {'shows': []}
for key, show in traktShows:
#will keep the data in python structures - just like the KODI response
show = show.to_info()
shows['shows'].append(show)
i += 1
y = ((i / x) * 20) + 12
self.__updateProgress(int(y),
line2=utilities.getString(1488) % (i + 1, x))
self.__updateProgress(32, line2=utilities.getString(1489))
return shows
def __addMoviesToTraktWatched(self, kodiMovies, traktMovies, fromPercent,
toPercent):
if utilities.getSettingAsBool(
'trakt_movie_playcount') and not self.sync.IsCanceled():
updateTraktTraktMovies = copy.deepcopy(traktMovies)
updateTraktKodiMovies = copy.deepcopy(kodiMovies)
traktMoviesToUpdate = self.__compareMovies(updateTraktKodiMovies,
updateTraktTraktMovies,
watched=True)
self.sanitizeMovies(traktMoviesToUpdate)
if len(traktMoviesToUpdate) == 0:
self.sync.UpdateProgress(toPercent,
line2=utilities.getString(32086))
logger.debug(
"[Movies Sync] Trakt.tv movie playcount is up to date")
return
titles = ", ".join(
["%s" % (m['title']) for m in traktMoviesToUpdate])
logger.debug(
"[Movies Sync] %i movie(s) playcount will be updated on Trakt.tv"
% len(traktMoviesToUpdate))
logger.debug("[Movies Sync] Movies updated: %s" % titles)
self.sync.UpdateProgress(fromPercent,
line2=utilities.getString(32064) %
len(traktMoviesToUpdate))
# Send request to update playcounts on Trakt.tv
chunksize = 200
chunked_movies = utilities.chunks(
[movie for movie in traktMoviesToUpdate], chunksize)
errorcount = 0
i = 0
x = float(len(traktMoviesToUpdate))
for chunk in chunked_movies:
if self.sync.IsCanceled():
return
i += 1
y = ((i / x) * (toPercent - fromPercent)) + fromPercent
self.sync.UpdateProgress(int(y),
line2=utilities.getString(32093) %
((i) * chunksize if
(i) * chunksize < x else x, x))
params = {'movies': chunk}
# logger.debug("moviechunk: %s" % params)
try:
self.sync.traktapi.addToHistory(params)
except Exception as ex:
message = utilities.createError(ex)
logging.fatal(message)
errorcount += 1
logger.debug("[Movies Sync] Movies updated: %d error(s)" %
errorcount)
self.sync.UpdateProgress(toPercent,
line2=utilities.getString(32087) %
len(traktMoviesToUpdate))
def xbmcUpdateEpisodes(self, shows):
if len(shows) == 0:
self.updateProgress(82, line1=utilities.getString(1441), line2=utilities.getString(1493))
Debug("[Episodes Sync] XBMC episode playcounts are up to date.")
return
Debug("[Episodes Sync] %i show(s) shows are missing playcounts on XBMC" % len(shows))
for s in ["%s" % self.getShowAsString(s, short=True) for s in shows]:
Debug("[Episodes Sync] Episodes updated: %s" % s)
self.updateProgress(64, line1=utilities.getString(1441), line2="%i %s" % (len(shows), utilities.getString(1439)), line3=" ")
episodes = []
for show in shows:
for season in show['seasons']:
for episode in show['seasons'][season]:
episodes.append({'episodeid': show['seasons'][season][episode]['id'], 'playcount': 1})
#split episode list into chunks of 50
chunked_episodes = utilities.chunks([{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": episodes[i], "id": i} for i in range(len(episodes))], 50)
i = 0
x = float(len(chunked_episodes))
for chunk in chunked_episodes:
if self.isCanceled():
return
if self.simulate:
Debug("[Episodes Sync] %s" % str(chunk))
else:
utilities.xbmcJsonRequest(chunk)
i = i + 1
y = ((i / x) * 18) + 64
self.updateProgress(int(y), line2=utilities.getString(1494))
self.updateProgress(82, line2=utilities.getString(1495) % len(episodes))
def __traktLoadMoviesPlaybackProgress(self):
if utilities.getSettingAsBool('trakt_movie_playback') and not self.__isCanceled():
self.__updateProgress(25, line2=utilities.getString(32122))
logger.debug('[Movies Sync] Getting playback progress from Trakt.tv')
try:
traktProgressMovies = self.traktapi.getMoviePlaybackProgress()
except Exception:
logger.debug("[Movies Sync] Invalid Trakt.tv playback progress list, possible error getting data from Trakt, aborting Trakt.tv playback update.")
return False
i = 0
x = float(len(traktProgressMovies))
moviesProgress = {'movies': []}
for movie in traktProgressMovies:
i += 1
y = ((i / x) * 25) + 11
self.__updateProgress(int(y), line2=utilities.getString(32123) % (i, x))
#will keep the data in python structures - just like the KODI response
movie = movie.to_dict()
moviesProgress['movies'].append(movie)
self.__updateProgress(36, line2=utilities.getString(32124))
return moviesProgress
def rateOnTrakt(rating, media_type, media):
Debug("[Rating] Sending rating (%s) to trakt.tv" % rating)
if utilities.isMovie(media_type):
params = {}
params['title'] = media['title']
params['year'] = media['year']
params['rating'] = rating
params['tmdb_id'] = media['tmdb_id']
params['imdb_id'] = media['imdb_id']
data = globals.traktapi.rateMovie(params)
elif utilities.isEpisode(media_type):
params = {}
params['title'] = media['show']['title']
params['year'] = media['show']['year']
params['season'] = media['episode']['season']
params['episode'] = media['episode']['number']
params['rating'] = rating
params['tvdb_id'] = media['show']['tvdb_id']
params['imdb_id'] = media['show']['imdb_id']
data = globals.traktapi.rateEpisode(params)
else:
return
if data != None:
notification(utilities.getString(1201), utilities.getString(1167)) # Rating submitted successfully
def __traktUpdateEpisodes(self, shows):
if len(shows['shows']) == 0:
self.__updateProgress(64, line1=utilities.getString(1438), line2=utilities.getString(1492))
Debug("[Episodes Sync] trakt.tv episode playcounts are up to date.")
return
Debug("[Episodes Sync] %i show(s) are missing playcounts on trakt.tv" % len(shows['shows']))
for show in shows['shows']:
Debug("[Episodes Sync] Episodes updated: %s" % self.__getShowAsString(show, short=True))
self.__updateProgress(46, line1=utilities.getString(1438), line2="%i %s" % (len(shows['shows']), utilities.getString(1439)), line3=" ")
for show in shows['shows']:
if self.__isCanceled():
return
epCount = self.__countEpisodes([show])
title = show['title'].encode('utf-8', 'ignore')
self.__updateProgress(70, line2=title, line3="%i %s" % (epCount, utilities.getString(1440)))
s = { 'shows': [show]}
Debug("[trakt][traktUpdateEpisodes] Shows to update %s" % s)
result = self.traktapi.updateSeenEpisode(s)
Debug("[trakt][traktUpdateEpisodes] Result %s" % result)
self.__updateProgress(64, line2="%i %s" % (len(shows['shows']), utilities.getString(1439)))
def __deleteMoviesFromTraktCollection(self, traktMovies, kodiMovies):
if utilities.getSettingAsBool('clean_trakt_movies') and not self.__isCanceled():
removeTraktMovies = copy.deepcopy(traktMovies)
removeKodiMovies = copy.deepcopy(kodiMovies)
logger.debug("[Movies Sync] Starting to remove.")
traktMoviesToRemove = self.__compareMovies(removeTraktMovies, removeKodiMovies)
self.sanitizeMovies(traktMoviesToRemove)
logger.debug("[Movies Sync] Compared movies, found %s to remove." % len(traktMoviesToRemove))
if len(traktMoviesToRemove) == 0:
self.__updateProgress(60, line2=utilities.getString(32091))
logger.debug("[Movies Sync] Trakt.tv movie collection is clean, no movies to remove.")
return
titles = ", ".join(["%s" % (m['title']) for m in traktMoviesToRemove])
logger.debug("[Movies Sync] %i movie(s) will be removed from Trakt.tv collection." % len(traktMoviesToRemove))
logger.debug("[Movies Sync] Movies removed: %s" % titles)
self.__updateProgress(49, line2=utilities.getString(32076) % len(traktMoviesToRemove))
moviesToRemove = {'movies': traktMoviesToRemove}
try:
self.traktapi.removeFromCollection(moviesToRemove)
except Exception as ex:
message = utilities.createError(ex)
logging.fatal(message)
self.__updateProgress(60, line2=utilities.getString(32092) % len(traktMoviesToRemove))
def __addMoviesToKodiWatched(self, traktMovies, kodiMovies):
if utilities.getSettingAsBool(
'kodi_movie_playcount') and not self.__isCanceled():
updateKodiTraktMovies = copy.deepcopy(traktMovies)
updateKodiKodiMovies = copy.deepcopy(kodiMovies)
kodiMoviesToUpdate = self.__compareMovies(updateKodiTraktMovies,
updateKodiKodiMovies,
watched=True,
restrict=True)
if len(kodiMoviesToUpdate) == 0:
self.__updateProgress(99, line2=utilities.getString(32088))
logger.debug(
"[Movies Sync] Kodi movie playcount is up to date.")
return
titles = ", ".join(
["%s" % (m['title']) for m in kodiMoviesToUpdate])
logger.debug(
"[Movies Sync] %i movie(s) playcount will be updated in Kodi" %
len(kodiMoviesToUpdate))
logger.debug("[Movies Sync] Movies to add: %s" % titles)
self.__updateProgress(83,
line2=utilities.getString(32065) %
len(kodiMoviesToUpdate))
#split movie list into chunks of 50
chunksize = 50
chunked_movies = utilities.chunks([{
"jsonrpc": "2.0",
"method": "VideoLibrary.SetMovieDetails",
"params": {
"movieid": kodiMoviesToUpdate[i]['movieid'],
"playcount": kodiMoviesToUpdate[i]['plays']
},
"id": i
} for i in range(len(kodiMoviesToUpdate))], chunksize)
i = 0
x = float(len(kodiMoviesToUpdate))
for chunk in chunked_movies:
if self.__isCanceled():
return
i += 1
y = ((i / x) * 16) + 83
self.__updateProgress(int(y),
line2=utilities.getString(32089) %
((i) * chunksize if
(i) * chunksize < x else x, x))
utilities.kodiJsonRequest(chunk)
self.__updateProgress(99,
line2=utilities.getString(32090) %
len(kodiMoviesToUpdate))
def onFocus(self, controlID):
if controlID in self.focus_labels:
s = utils.getString(self.focus_labels[controlID])
if self.rerate:
if self.media['rating'] == self.buttons[controlID] or self.media['rating_advanced'] == self.buttons[controlID]:
s = utils.getString(1325)
self.getControl(10013).setLabel(s)
else:
self.getControl(10013).setLabel('')
def __init__(self, show_progress=False, api=None):
self.traktapi = api
self.show_progress = show_progress
self.notify = utilities.getSettingAsBool('show_sync_notifications')
self.simulate = utilities.getSettingAsBool('simulate_sync')
if self.simulate:
Debug("[Sync] Sync is configured to be simulated.")
if self.show_progress:
progress.create('%s %s' % (utilities.getString(1400), utilities.getString(1402)), line1=' ', line2=' ', line3=' ')
def __kodiLoadShows(self):
self.sync.UpdateProgress(1, line1=utilities.getString(32094), line2=utilities.getString(32095))
logger.debug("[Episodes Sync] Getting show data from Kodi")
data = utilities.kodiJsonRequest({'jsonrpc': '2.0', 'method': 'VideoLibrary.GetTVShows', 'params': {'properties': ['title', 'imdbnumber', 'year', 'userrating']}, 'id': 0})
if data['limits']['total'] == 0:
logger.debug("[Episodes Sync] Kodi json request was empty.")
return None, None
tvshows = utilities.kodiRpcToTraktMediaObjects(data)
logger.debug("[Episode Sync] Getting shows from kodi finished %s" % tvshows)
if tvshows is None:
return None, None
self.sync.UpdateProgress(2, line2=utilities.getString(32096))
resultCollected = {'shows': []}
resultWatched = {'shows': []}
i = 0
x = float(len(tvshows))
logger.debug("[Episodes Sync] Getting episode data from Kodi")
for show_col1 in tvshows:
i += 1
y = ((i / x) * 8) + 2
self.sync.UpdateProgress(int(y), line2=utilities.getString(32097) % (i, x))
show = {'title': show_col1['title'], 'ids': {}, 'year': show_col1['year'], 'rating': show_col1['rating'],
'tvshowid': show_col1['tvshowid'], 'seasons': []}
if 'ids' in show_col1 and 'tvdb' in show_col1['ids']:
show['ids'] = {'tvdb': show_col1['ids']['tvdb']}
data = utilities.kodiJsonRequest({'jsonrpc': '2.0', 'method': 'VideoLibrary.GetEpisodes', 'params': {'tvshowid': show_col1['tvshowid'], 'properties': ['season', 'episode', 'playcount', 'uniqueid', 'lastplayed', 'file', 'dateadded', 'runtime', 'userrating']}, 'id': 0})
if not data:
logger.debug("[Episodes Sync] There was a problem getting episode data for '%s', aborting sync." % show['title'])
return None, None
elif 'episodes' not in data:
logger.debug("[Episodes Sync] '%s' has no episodes in Kodi." % show['title'])
continue
if 'tvshowid' in show_col1:
del(show_col1['tvshowid'])
showWatched = copy.deepcopy(show)
data2 = copy.deepcopy(data)
show['seasons'] = utilities.kodiRpcToTraktMediaObjects(data)
showWatched['seasons'] = utilities.kodiRpcToTraktMediaObjects(data2, 'watched')
resultCollected['shows'].append(show)
resultWatched['shows'].append(showWatched)
self.sync.UpdateProgress(10, line2=utilities.getString(32098))
return resultCollected, resultWatched
def __kodiLoadMovies(self):
self.__updateProgress(1, line2=utilities.getString(1460))
Debug("[Movies Sync] Getting movie data from Kodi")
data = utilities.kodiJsonRequest({'jsonrpc': '2.0', 'id': 0, 'method': 'VideoLibrary.GetMovies', 'params': {'properties': ['title', 'imdbnumber', 'year', 'playcount', 'lastplayed', 'file']}})
if not data:
Debug("[Movies Sync] Kodi JSON request was empty.")
return
if not 'movies' in data:
Debug('[Movies Sync] Key "movies" not found')
return
movies = data['movies']
Debug("[Movies Sync] Kodi JSON Result: '%s'" % str(movies))
i = 0
x = float(len(movies))
xbmc_movies = []
# reformat movie array
for movie in movies:
if self.__checkExclusion(movie['file']):
continue
if movie['lastplayed']:
movie['last_played'] = utilities.sqlDateToUnixDate(movie['lastplayed'])
movie['plays'] = movie.pop('playcount')
movie['collected'] = 1 #this is in our kodi so it should be collected
movie['watched'] = 1 if movie['plays'] > 0 else 0
movie['ids'] = {}
id = movie['imdbnumber']
if id.startswith("tt"):
movie['ids']['imdb'] = ""
movie['ids']['imdb'] = id
if id.isdigit():
movie['ids']['tmdb'] = ""
movie['ids']['tmdb'] = id
del(movie['imdbnumber'])
del(movie['lastplayed'])
del(movie['label'])
del(movie['file'])
xbmc_movies.append(movie)
i += 1
y = ((i / x) * 4) + 1
self.__updateProgress(int(y))
self.__updateProgress(5, line2=utilities.getString(1461))
return xbmc_movies
def __rateOnTrakt(rating, media_type, media, unrate=False):
utils.Debug("[Rating] Sending rating (%s) to trakt.tv" % rating)
params = {}
if utils.isMovie(media_type):
params = media
params['rating'] = rating
root = {}
listing = [params]
root['movies'] = listing
elif utils.isShow(media_type):
params['rating'] = rating
params['title'] = media['title']
params['year'] = media['year']
params['ids'] = {}
params['ids']['tmdb'] = media['ids']['tmdb']
params['ids']['imdb'] = media['ids']['imdb']
params['ids']['tvdb'] = media['ids']['tvdb']
root = {}
listing = [params]
root['shows'] = listing
elif utils.isEpisode(media_type):
params = media
params['rating'] = rating
root = {}
listing = [params]
root['episodes'] = listing
else:
return
if not unrate:
data = globals.traktapi.addRating(root)
else:
data = globals.traktapi.removeRating(root)
if data:
utils.Debug("data rate: %s" % data)
s = utils.getFormattedItemName(media_type, media)
if 'not_found' in data and not data['not_found']['movies'] and not data[
'not_found']['episodes'] and not data['not_found']['shows']:
if not unrate:
utils.notification(utils.getString(1350), s)
else:
utils.notification(utils.getString(1352), s)
else:
utils.notification(utils.getString(1354), s)
def __rateOnTrakt(rating, media_type, media, unrate=False):
logger.debug("Sending rating (%s) to Trakt.tv" % rating)
params = {}
if utils.isMovie(media_type):
params = media
params['rating'] = rating
root = {}
listing = [params]
root['movies'] = listing
elif utils.isShow(media_type):
params['rating'] = rating
params['title'] = media['title']
params['year'] = media['year']
params['ids'] = {}
params['ids']['tmdb'] = media['ids']['tmdb']
params['ids']['imdb'] = media['ids']['imdb']
params['ids']['tvdb'] = media['ids']['tvdb']
root = {}
listing = [params]
root['shows'] = listing
elif utils.isEpisode(media_type):
params = media
params['rating'] = rating
root = {}
listing = [params]
root['episodes'] = listing
else:
return
if not unrate:
data = globals.traktapi.addRating(root)
else:
data = globals.traktapi.removeRating(root)
if data:
s = utils.getFormattedItemName(media_type, media)
if 'not_found' in data and not data['not_found']['movies'] and not data['not_found']['episodes'] and not data['not_found']['shows']:
if not unrate:
utils.notification(utils.getString(32040), s)
else:
utils.notification(utils.getString(32042), s)
else:
utils.notification(utils.getString(32044), s)
def __syncMovies(self):
if not self.show_progress and self.sync_on_update and self.notify and self.notify_during_playback:
notification(
'%s %s' %
(utilities.getString(32045), utilities.getString(32046)),
utilities.getString(32061)) #Sync started
if self.show_progress and not self.run_silent:
progress.create(
"%s %s" %
(utilities.getString(32045), utilities.getString(32046)),
line1=" ",
line2=" ",
line3=" ")
kodiMovies = self.__kodiLoadMovies()
if not isinstance(kodiMovies, list) and not kodiMovies:
logger.debug(
"[Movies Sync] Kodi movie list is empty, aborting movie Sync.")
if self.show_progress and not self.run_silent:
progress.close()
return
try:
traktMovies = self.__traktLoadMovies()
except Exception:
logger.debug(
"[Movies Sync] Error getting trakt.tv movie list, aborting movie Sync."
)
if self.show_progress and not self.run_silent:
progress.close()
return
self.__addMoviesToTraktCollection(kodiMovies, traktMovies)
self.__deleteMoviesFromTraktCollection(traktMovies, kodiMovies)
self.__addMoviesToTraktWatched(kodiMovies, traktMovies)
self.__addMoviesToKodiWatched(traktMovies, kodiMovies)
if self.show_progress and not self.run_silent:
self.__updateProgress(100,
line1=utilities.getString(32066),
line2=" ",
line3=" ")
progress.close()
if not self.show_progress and self.sync_on_update and self.notify and self.notify_during_playback:
notification(
'%s %s' %
(utilities.getString(32045), utilities.getString(32046)),
utilities.getString(32062)) #Sync complete
logger.debug(
"[Movies Sync] Movies on trakt.tv (%d), movies in Kodi (%d)." %
(self.__countMovies(traktMovies), len(kodiMovies)))
logger.debug("[Movies Sync] Complete.")
def xbmcLoadMovies(self):
self.updateProgress(1, line2=utilities.getString(1460))
Debug("[Movies Sync] Getting movie data from XBMC")
data = utilities.xbmcJsonRequest({'jsonrpc': '2.0', 'id': 0, 'method': 'VideoLibrary.GetMovies', 'params': {'properties': ['title', 'imdbnumber', 'year', 'playcount', 'lastplayed', 'file']}})
if not data:
Debug("[Movies Sync] XBMC JSON request was empty.")
return
if not 'movies' in data:
Debug('[Movies Sync] Key "movies" not found')
return
movies = data['movies']
Debug("[Movies Sync] XBMC JSON Result: '%s'" % str(movies))
i = 0
x = float(len(movies))
xbmc_movies = []
# reformat movie array
for movie in movies:
if self.checkExclusion(movie['file']):
continue
if movie['lastplayed']:
movie['last_played'] = utilities.sqlDateToUnixDate(movie['lastplayed'])
movie['plays'] = movie.pop('playcount')
movie['in_collection'] = True
movie['imdb_id'] = ""
movie['tmdb_id'] = ""
id = movie['imdbnumber']
if id.startswith("tt"):
movie['imdb_id'] = id
if id.isdigit():
movie['tmdb_id'] = id
del(movie['imdbnumber'])
del(movie['lastplayed'])
del(movie['label'])
del(movie['file'])
xbmc_movies.append(movie)
i = i + 1
y = ((i / x) * 4) + 1
self.updateProgress(int(y))
self.updateProgress(5, line2=utilities.getString(1461))
return xbmc_movies
def __kodiLoadMovies(self):
self.__updateProgress(1, line2=utilities.getString(32079))
logger.debug("[Movies Sync] Getting movie data from Kodi")
data = utilities.kodiJsonRequest({'jsonrpc': '2.0', 'id': 0, 'method': 'VideoLibrary.GetMovies', 'params': {'properties': ['title', 'imdbnumber', 'year', 'playcount', 'lastplayed', 'file', 'dateadded', 'runtime']}})
if data['limits']['total'] == 0:
logger.debug("[Movies Sync] Kodi JSON request was empty.")
return
kodi_movies = utilities.kodiRpcToTraktMediaObjects(data)
self.__updateProgress(10, line2=utilities.getString(32080))
return kodi_movies
def __syncEpisodes(self):
if not self.show_progress and self.sync_on_update and self.notify and self.notify_during_playback:
notification('%s %s' % (utilities.getString(32045), utilities.getString(32050)), utilities.getString(32061)) #Sync started
if self.show_progress and not self.run_silent:
progress.create("%s %s" % (utilities.getString(32045), utilities.getString(32050)), line1=" ", line2=" ", line3=" ")
kodiShowsCollected, kodiShowsWatched = self.__kodiLoadShows()
if not isinstance(kodiShowsCollected, list) and not kodiShowsCollected:
logger.debug("[Episodes Sync] Kodi collected show list is empty, aborting tv show Sync.")
if self.show_progress and not self.run_silent:
progress.close()
return
if not isinstance(kodiShowsWatched, list) and not kodiShowsWatched:
logger.debug("[Episodes Sync] Kodi watched show list is empty, aborting tv show Sync.")
if self.show_progress and not self.run_silent:
progress.close()
return
traktShowsCollected, traktShowsWatched = self.__traktLoadShows()
if not traktShowsCollected:
logger.debug("[Episodes Sync] Error getting Trakt.tv collected show list, aborting tv show sync.")
if self.show_progress and not self.run_silent:
progress.close()
return
if not traktShowsWatched:
logger.debug("[Episodes Sync] Error getting Trakt.tv watched show list, aborting tv show sync.")
if self.show_progress and not self.run_silent:
progress.close()
return
#we need a correct runtime for episodes until we have that this is commented out
#traktShowsProgress = self.__traktLoadShowsPlaybackProgress()
self.__addEpisodesToTraktCollection(kodiShowsCollected, traktShowsCollected)
self.__deleteEpisodesFromTraktCollection(traktShowsCollected, kodiShowsCollected)
self.__addEpisodesToTraktWatched(kodiShowsWatched, traktShowsWatched)
self.__addEpisodesToKodiWatched(traktShowsWatched, kodiShowsWatched, kodiShowsCollected)
#we need a correct runtime for episodes until we have that this is commented out
#self.__addEpisodeProgressToKodi(traktShowsProgress, kodiShowsCollected)
if not self.show_progress and self.sync_on_update and self.notify and self.notify_during_playback:
notification('%s %s' % (utilities.getString(32045), utilities.getString(32050)), utilities.getString(32062)) #Sync complete
if self.show_progress and not self.run_silent:
self.__updateProgress(100, line1=" ", line2=utilities.getString(32075), line3=" ")
progress.close()
logger.debug("[Episodes Sync] Shows on Trakt.tv (%d), shows in Kodi (%d)." % (len(traktShowsCollected['shows']), len(kodiShowsCollected['shows'])))
logger.debug("[Episodes Sync] Episodes on Trakt.tv (%d), episodes in Kodi (%d)." % (self.__countEpisodes(traktShowsCollected), self.__countEpisodes(kodiShowsCollected)))
logger.debug("[Episodes Sync] Complete.")
def __kodiLoadShows(self):
self.__updateProgress(1, line1=utilities.getString(1480), line2=utilities.getString(1481))
tvshows = self.__kodiLoadShowList()
if tvshows is None:
return None
self.__updateProgress(2, line2=utilities.getString(1482))
result = {'shows': []}
i = 0
x = float(len(tvshows))
Debug("[Episodes Sync] Getting episode data from Kodi")
for show_col1 in tvshows:
show = {'title': show_col1['title'], 'ids': {'tvdb': show_col1['ids']['tvdb']}, 'year': show_col1['year'], 'seasons': []}
data = utilities.kodiJsonRequest({'jsonrpc': '2.0', 'method': 'VideoLibrary.GetEpisodes', 'params': {'tvshowid': show_col1['tvshowid'], 'properties': ['season', 'episode', 'playcount', 'uniqueid', 'file']}, 'id': 0})
if not data:
Debug("[Episodes Sync] There was a problem getting episode data for '%s', aborting sync." % show['title'])
return None
if not 'episodes' in data:
Debug("[Episodes Sync] '%s' has no episodes in Kodi." % show['title'])
continue
a_episodes = {}
seasons = []
for episode in data['episodes']:
watched = 0;
if episode['playcount'] > 0:
watched = 1
while not episode['season'] in a_episodes :
s_no = episode['season']
a_episodes[s_no] = []
s_no = episode['season']
a_episodes[s_no].append({ 'number': episode['episode'], 'ids': { 'tvdb': episode['uniqueid']['unknown'], 'episodeid' : episode['episodeid']}, 'watched': watched })
for episode in a_episodes:
seasons.append({'number': episode, 'episodes': a_episodes[episode]})
show['seasons'] = seasons
if 'tvshowid' in show_col1:
del(show_col1['tvshowid'])
result['shows'].append(show)
i += 1
y = ((i / x) * 8) + 2
self.__updateProgress(int(y), line2=utilities.getString(1483))
self.__updateProgress(10, line2=utilities.getString(1484))
return result
def __syncEpisodeRatings(self, traktShows, kodiShows, fromPercent, toPercent):
if utilities.getSettingAsBool('trakt_sync_ratings') and traktShows and not self.sync.IsCanceled():
updateKodiTraktShows = copy.deepcopy(traktShows)
updateKodiKodiShows = copy.deepcopy(kodiShows)
traktShowsToUpdate = self.__compareEpisodes(updateKodiKodiShows, updateKodiTraktShows, rating=True)
if len(traktShowsToUpdate['shows']) == 0:
self.sync.UpdateProgress(toPercent, line1='', line2=utilities.getString(32181))
logger.debug("[Episodes Sync] Trakt episode ratings are up to date.")
else:
logger.debug("[Episodes Sync] %i show(s) will have episode ratings added on Trakt" % len(traktShowsToUpdate['shows']))
self.sync.UpdateProgress(fromPercent, line1='', line2=utilities.getString(32182) % len(traktShowsToUpdate['shows']))
self.sync.traktapi.addRating(traktShowsToUpdate)
kodiShowsUpdate = self.__compareEpisodes(updateKodiTraktShows, updateKodiKodiShows, restrict=True, rating=True)
if len(kodiShowsUpdate['shows']) == 0:
self.sync.UpdateProgress(toPercent, line1='', line2=utilities.getString(32173))
logger.debug("[Episodes Sync] Kodi episode ratings are up to date.")
else:
logger.debug("[Episodes Sync] %i show(s) will have episode ratings added in Kodi" % len(kodiShowsUpdate['shows']))
for s in ["%s" % self.__getShowAsString(s, short=True) for s in kodiShowsUpdate['shows']]:
logger.debug("[Episodes Sync] Episodes updated: %s" % s)
episodes = []
for show in kodiShowsUpdate['shows']:
for season in show['seasons']:
for episode in season['episodes']:
episodes.append({'episodeid': episode['ids']['episodeid'], 'rating': episode['rating']})
# split episode list into chunks of 50
chunksize = 50
chunked_episodes = utilities.chunks([{"jsonrpc": "2.0", "id": i, "method": "VideoLibrary.SetEpisodeDetails",
"params": {"episodeid": episodes[i]['episodeid'],
"userrating": episodes[i]['rating']}} for i in range(len(episodes))],
chunksize)
i = 0
x = float(len(episodes))
for chunk in chunked_episodes:
if self.sync.IsCanceled():
return
i += 1
y = ((i / x) * (toPercent-fromPercent)) + fromPercent
self.sync.UpdateProgress(int(y), line1='', line2=utilities.getString(32174) % ((i) * chunksize if (i) * chunksize < x else x, x))
utilities.kodiJsonRequest(chunk)
self.sync.UpdateProgress(toPercent, line2=utilities.getString(32175) % len(episodes))
def onInit(self):
self.pin_edit_control = self.__add_editcontrol(30, 240, 40, 450)
self.setFocus(self.pin_edit_control)
auth = self.getControl(AUTH_BUTTON)
never = self.getControl(NEVER_BUTTON)
instuction = self.getControl(INSTRUCTION_LABEL)
instuction.setLabel(getString(32158) + "\n1) " + getString(32159).format("[COLOR skyblue]http://trakt.tv/pin/999[/COLOR]") + "\n2) " + getString(32160) + "\n3) " + getString(32161) + "\n\n" + getString(32162))
self.pin_edit_control.controlUp(never)
self.pin_edit_control.controlLeft(never)
self.pin_edit_control.controlDown(auth)
self.pin_edit_control.controlRight(auth)
auth.controlUp(self.pin_edit_control)
auth.controlLeft(self.pin_edit_control)
never.controlDown(self.pin_edit_control)
never.controlRight(self.pin_edit_control)
def __traktAddMovies(self, movies):
if len(movies) == 0:
self.__updateProgress(98, line2=utilities.getString(1467))
Debug("[Movies Sync] trakt.tv movie collection is up to date.")
return
Debug("[Movies Sync] %i movie(s) will be added to trakt.tv collection." % len(movies))
self.__updateProgress(80, line2="%i %s" % (len(movies), utilities.getString(1426)))
moviesToAdd = {'movies': movies}
self.traktapi.addToCollection(moviesToAdd)
self.__updateProgress(98, line2=utilities.getString(1468) % len(movies))
def scrobbleNotification(self, info):
if not self.curVideoInfo:
return
if utilities.getSettingAsBool("scrobble_notification"):
s = utilities.getFormattedItemName(self.curVideo['type'], info)
utilities.notification(utilities.getString(1049), s)
def __traktAddEpisodes(self, shows):
if len(shows['shows']) == 0:
self.__updateProgress(98, line1=utilities.getString(1435), line2=utilities.getString(1490))
Debug("[Episodes Sync] trakt.tv episode collection is up to date.")
return
Debug("[Episodes Sync] %i show(s) have episodes (%d) to be added to your trakt.tv collection." % (len(shows['shows']), self.__countEpisodes(shows['shows'])))
for show in shows['shows']:
Debug("[Episodes Sync] Episodes added: %s" % self.__getShowAsString(show, short=True))
self.__updateProgress(82, line1=utilities.getString(1435), line2="%i %s" % (len(shows['shows']), utilities.getString(1436)), line3=" ")
Debug("[trakt][traktAddEpisodes] Shows to add %s" % shows)
result = self.traktapi.addToCollection(shows)
Debug("[trakt][traktAddEpisodes] Result %s" % result)
self.__updateProgress(98, line1=utilities.getString(1435), line2=utilities.getString(1491) % self.__countEpisodes(shows['shows']))
def scrobbleNotification(self, info):
if not self.curVideoInfo:
return
if utilities.getSettingAsBool("scrobble_notification"):
s = utilities.getFormattedItemName(self.curVideo['type'], info)
utilities.notification(utilities.getString(1049), s)
def __scrobbleNotification(self, info):
if not self.curVideoInfo:
return
if utilities.getSettingAsBool("scrobble_notification"):
s = utilities.getFormattedItemName(self.curVideo["type"], info[self.curVideo["type"]])
utilities.notification(utilities.getString(32015), s)
def main():
grahamIntrinsicValue = GIV.calculateGiv(GIV)
companyName = util.getString("Company name")
print(companyName)
stockPrice = util.getFloat("current stock price")
print(stockPrice)
# ----------------------Cost Of Debt-----------------------------
costOfDebt = WACC.calculateCostOfDebt(WACC)
print(costOfDebt)
effectiveTaxRate = WACC.calculateEffectiveTaxRate(WACC)
print(effectiveTaxRate)
costOfDebtFinal = WACC.calculateCostOfDebtFinal(WACC)
print(costOfDebtFinal)
# ----------------------Cost Of Equity -----------------------------
costOfEquity = WACC.calculateCostOfEquity(WACC)
print(costOfEquity)
# ----------------------Calculating Weight Of Debt and Equity -----------------------------
result = WACC.calculateWeightOfDebtAndEquity(WACC)
weightOfDebt = result[0]
weightOfEquity = result[1]
print(weightOfDebt)
print(weightOfEquity)
wacc = WACC.calculateWACC(WACC)
print(wacc)
def testAccount(self, force=False):
if self.__username == "":
notification('trakt', getString(1106)) # please enter your Username and Password in settings
setSetting('account_valid', False)
return False
elif self.__password == "":
notification("trakt", getString(1107)) # please enter your Password in settings
setSetting('account_valid', False)
return False
if not getSettingAsBool('account_valid') or force:
Debug("[traktAPI] Testing account '%s'." % self.__username)
url = "%s/account/test/%s" % (self.__baseURL, self.__apikey)
Debug("[traktAPI] testAccount(url: %s)" % url)
args = json.dumps({'username': self.__username, 'password': self.__password})
response = None
try:
# get data from trakt.tv
response = self.__getData(url, args)
except traktError, e:
if isinstance(e, traktAuthProblem):
Debug("[traktAPI] testAccount(): Account '%s' failed authentication. (%s)" % (self.__username, e.value))
elif isinstance(e, traktServerBusy):
Debug("[traktAPI] testAccount(): Server Busy (%s)" % e.value)
elif isinstance(e, traktNetworkError):
Debug("[traktAPI] testAccount(): Network error: %s" % e.value)
elif isinstance(e, traktUnknownError):
Debug("[traktAPI] testAccount(): Other problem (%s)" % e.value)
else:
pass
if response:
data = None
try:
data = json.loads(response)
except ValueError:
pass
if 'status' in data:
if data['status'] == 'success':
setSetting('account_valid', True)
Debug("[traktAPI] testAccount(): Account '%s' is valid." % self.__username)
return True
def __syncShowsRatings(self, traktShows, kodiShows, fromPercent, toPercent):
if utilities.getSettingAsBool('trakt_sync_ratings') and traktShows and not self.sync.IsCanceled():
updateKodiTraktShows = copy.deepcopy(traktShows)
updateKodiKodiShows = copy.deepcopy(kodiShows)
traktShowsToUpdate = self.__compareShows(updateKodiKodiShows, updateKodiTraktShows, rating=True)
if len(traktShowsToUpdate['shows']) == 0:
self.sync.UpdateProgress(toPercent, line1='', line2=utilities.getString(32181))
logger.debug("[Episodes Sync] Trakt show ratings are up to date.")
else:
logger.debug("[Episodes Sync] %i show(s) will have show ratings added on Trakt" % len(traktShowsToUpdate['shows']))
self.sync.UpdateProgress(fromPercent, line1='', line2=utilities.getString(32182) % len(traktShowsToUpdate['shows']))
self.sync.traktapi.addRating(traktShowsToUpdate)
# needs to be restricted, because we can't add a rating to an episode which is not in our Kodi collection
kodiShowsUpdate = self.__compareShows(updateKodiTraktShows, updateKodiKodiShows, rating=True, restrict = True)
if len(kodiShowsUpdate['shows']) == 0:
self.sync.UpdateProgress(toPercent, line1='', line2=utilities.getString(32176))
logger.debug("[Episodes Sync] Kodi show ratings are up to date.")
else:
logger.debug("[Episodes Sync] %i show(s) will have show ratings added in Kodi" % len(kodiShowsUpdate['shows']))
shows = []
for show in kodiShowsUpdate['shows']:
shows.append({'tvshowid': show['tvshowid'], 'rating': show['rating']})
# split episode list into chunks of 50
chunksize = 50
chunked_episodes = utilities.chunks([{"jsonrpc": "2.0", "id": i, "method": "VideoLibrary.SetTVShowDetails",
"params": {"tvshowid": shows[i]['tvshowid'],
"userrating": shows[i]['rating']}} for i in range(len(shows))],
chunksize)
i = 0
x = float(len(shows))
for chunk in chunked_episodes:
if self.sync.IsCanceled():
return
i += 1
y = ((i / x) * (toPercent-fromPercent)) + fromPercent
self.sync.UpdateProgress(int(y), line1='', line2=utilities.getString(32177) % ((i) * chunksize if (i) * chunksize < x else x, x))
utilities.kodiJsonRequest(chunk)
self.sync.UpdateProgress(toPercent, line2=utilities.getString(32178) % len(shows))
def onFocus(self, controlID):
if controlID in self.focus_labels:
s = utils.getString(self.focus_labels[controlID])
if self.rerate:
if self.media['rating'] == self.buttons[controlID] or self.media['rating_advanced'] == self.buttons[controlID]:
if utils.isMovie(self.media_type):
s = utils.getString(1325)
elif utils.isShow(self.media_type):
s = utils.getString(1326)
elif utils.isEpisode(self.media_type):
s = utils.getString(1327)
else:
pass
self.getControl(10013).setLabel(s)
else:
self.getControl(10013).setLabel('')
def onFocus(self, controlID):
if controlID in self.focus_labels:
s = utils.getString(self.focus_labels[controlID])
if self.rerate:
if self.media['user']['ratings'] and self.media['user']['ratings']['rating'] == self.buttons[controlID]:
if utils.isMovie(self.media_type):
s = utils.getString(32037)
elif utils.isShow(self.media_type):
s = utils.getString(32038)
elif utils.isEpisode(self.media_type):
s = utils.getString(32039)
else:
pass
self.getControl(10013).setLabel(s)
else:
self.getControl(10013).setLabel('')
def __deleteEpisodesFromTraktCollection(self, traktShows, kodiShows):
if utilities.getSettingAsBool(
'clean_trakt_episodes') and not self.__isCanceled():
removeTraktShows = copy.deepcopy(traktShows)
removeKodiShows = copy.deepcopy(kodiShows)
traktShowsRemove = self.__compareShows(removeTraktShows,
removeKodiShows)
self.sanitizeShows(traktShowsRemove)
if len(traktShowsRemove['shows']) == 0:
self.__updateProgress(65,
line1=utilities.getString(32077),
line2=utilities.getString(32110))
logger.debug(
'[Episodes Sync] trakt.tv episode collection is clean, no episodes to remove.'
)
return
logger.debug(
"[Episodes Sync] %i show(s) will have episodes removed from trakt.tv collection."
% len(traktShowsRemove['shows']))
for show in traktShowsRemove['shows']:
logger.debug("[Episodes Sync] Episodes removed: %s" %
self.__getShowAsString(show, short=True))
self.__updateProgress(50,
line1=utilities.getString(32077),
line2=utilities.getString(32111) %
self.__countEpisodes(traktShowsRemove),
line3=" ")
logger.debug("[traktRemoveEpisodes] Shows to remove %s" %
traktShowsRemove)
try:
self.traktapi.removeFromCollection(traktShowsRemove)
except Exception as ex:
message = utilities.createError(ex)
logging.fatal(message)
self.__updateProgress(65,
line2=utilities.getString(32112) %
self.__countEpisodes(traktShowsRemove),
line3=" ")
def __deleteMoviesFromTraktCollection(self, traktMovies, kodiMovies,
fromPercent, toPercent):
if utilities.getSettingAsBool(
'clean_trakt_movies') and not self.sync.IsCanceled():
removeTraktMovies = copy.deepcopy(traktMovies)
removeKodiMovies = copy.deepcopy(kodiMovies)
logger.debug("[Movies Sync] Starting to remove.")
traktMoviesToRemove = self.__compareMovies(removeTraktMovies,
removeKodiMovies)
self.sanitizeMovies(traktMoviesToRemove)
logger.debug("[Movies Sync] Compared movies, found %s to remove." %
len(traktMoviesToRemove))
if len(traktMoviesToRemove) == 0:
self.sync.UpdateProgress(toPercent,
line2=utilities.getString(32091))
logger.debug(
"[Movies Sync] Trakt.tv movie collection is clean, no movies to remove."
)
return
titles = ", ".join(
["%s" % (m['title']) for m in traktMoviesToRemove])
logger.debug(
"[Movies Sync] %i movie(s) will be removed from Trakt.tv collection."
% len(traktMoviesToRemove))
logger.debug("[Movies Sync] Movies removed: %s" % titles)
self.sync.UpdateProgress(fromPercent,
line2=utilities.getString(32076) %
len(traktMoviesToRemove))
moviesToRemove = {'movies': traktMoviesToRemove}
try:
self.sync.traktapi.removeFromCollection(moviesToRemove)
except Exception as ex:
message = utilities.createError(ex)
logging.fatal(message)
self.sync.UpdateProgress(toPercent,
line2=utilities.getString(32092) %
len(traktMoviesToRemove))
def xbmcLoadShows(self):
self.updateProgress(1, line1=utilities.getString(1480), line2=utilities.getString(1481))
tvshows = self.xbmcLoadShowList()
if tvshows is None:
return None
self.updateProgress(2, line2=utilities.getString(1482))
i = 0
x = float(len(tvshows))
Debug("[Episodes Sync] Getting episode data from XBMC")
for show in tvshows:
show['seasons'] = {}
show['watched'] = {}
data = utilities.xbmcJsonRequest({'jsonrpc': '2.0', 'method': 'VideoLibrary.GetEpisodes', 'params': {'tvshowid': show['tvshowid'], 'properties': ['season', 'episode', 'playcount', 'uniqueid', 'file']}, 'id': 0})
if not data:
Debug("[Episodes Sync] There was a problem getting episode data for '%s', aborting sync." % show['title'])
return None
if not 'episodes' in data:
Debug("[Episodes Sync] '%s' has no episodes in XBMC." % show['title'])
continue
episodes = data['episodes']
for e in episodes:
if self.checkExclusion(e['file']):
continue
_season = e['season']
_episode = e['episode']
if not _season in show['seasons']:
show['seasons'][_season] = {}
show['watched'][_season] = []
if not _episode in show['seasons'][_season]:
show['seasons'][_season][_episode] = {'id': e['episodeid'], 'episode_tvdb_id': e['uniqueid']['unknown']}
if e['playcount'] > 0:
if not _episode in show['watched'][_season]:
show['watched'][_season].append(_episode)
i = i + 1
y = ((i / x) * 8) + 2
self.updateProgress(int(y), line2=utilities.getString(1483))
self.updateProgress(10, line2=utilities.getString(1484))
return tvshows
def traktRemoveMovies(self, movies):
if len(movies) == 0:
self.updateProgress(98, line2=utilities.getString(1474))
Debug("[Movies Sync] trakt.tv movie collection is clean, no movies to remove.")
return
titles = ", ".join(["%s (%s)" % (m['title'], m['imdb_id']) for m in movies])
Debug("[Movies Sync] %i movie(s) will be removed from trakt.tv collection." % len(movies))
Debug("[Movies Sync] Movies removed: %s" % titles)
self.updateProgress(80, line2="%i %s" % (len(movies), utilities.getString(1444)))
params = {'movies': [self.sanitizeMovieData(movie) for movie in movies]}
if self.simulate:
Debug("[Movies Sync] %s" % str(params))
else:
self.traktapi.removeMovie(params)
self.updateProgress(98, line2=utilities.getString(1475) % len(movies))
