def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += constants.DEFAULT_LANGUAGES
gettext.bindtextdomain(constants.SF_COMPACT_NAME,
constants.LOCALE_DIR)
gettext.textdomain(constants.SF_COMPACT_NAME)
language = gettext.translation(constants.SF_COMPACT_NAME,
constants.LOCALE_DIR,
languages = languages,
fallback = True)
_ = language.gettext
self.series_manager = SeriesManager()
self.settings = Settings()
self.settingsWrapper = SettingsWrapper()
load_conf_item = AsyncItem(self.settings.load,
(constants.SF_CONF_FILE,),
self._settings_load_finished)
load_shows_item = AsyncItem(self.series_manager.load,
(constants.SF_DB_FILE,),
self._load_finished)
self.request = AsyncWorker(True)
self.request.queue.put(load_conf_item)
self.request.queue.put(load_shows_item)
self.request.start()
self.version = constants.SF_VERSION
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += constants.DEFAULT_LANGUAGES
gettext.bindtextdomain(constants.SF_COMPACT_NAME,
constants.LOCALE_DIR)
gettext.textdomain(constants.SF_COMPACT_NAME)
language = gettext.translation(constants.SF_COMPACT_NAME,
constants.LOCALE_DIR,
languages = languages,
fallback = True)
_ = language.gettext
self.series_manager = SeriesManager()
self.settings = Settings()
self.settingsWrapper = SettingsWrapper()
load_conf_item = AsyncItem(self.settings.load,
(constants.SF_CONF_FILE,),
self._settings_load_finished)
load_shows_item = AsyncItem(self.series_manager.load,
(constants.SF_DB_FILE,),
self._load_finished)
self.request = AsyncWorker(True)
self.request.queue.put(load_conf_item)
self.request.queue.put(load_shows_item)
self.request.start()
self.version = constants.SF_VERSION
def update_episode_list(self, episode_list):
add_special_seasons = Settings().getConf(Settings.ADD_SPECIAL_SEASONS)
series_manager = SeriesManager()
for episode in episode_list:
exists = False
for ep in self.episode_list:
if ep == episode:
exists = True
ep.merge_episode(episode)
series_manager.changed = True
if not exists:
if not add_special_seasons and \
self.is_special_season(episode.season_number):
continue
self.episode_list.append(episode)
series_manager.changed = True
def get_seasons_model(self):
season_list = []
for season in self.get_seasons():
season_list.append({
'seasonName':
self.get_season_name(season),
'seasonNumber':
season,
'seasonInfoMarkup':
self.get_season_info_markup(season),
'seasonImage':
self.get_season_image(season),
'isWatched':
self.is_completely_watched(season, only_aired=True)
})
return SortedSeasonsList(season_list, Settings())
def _get_complete_show_from_id(self, show_id, language):
tvdb_show_episodes = self.thetvdb.get_show_and_episodes(
show_id, language)
if not tvdb_show_episodes:
return None
show = self._convert_thetvdbshow_to_show(tvdb_show_episodes[0])
show.id = self._get_id_for_show()
show.episode_list = []
for tvdb_ep in tvdb_show_episodes[1]:
episode = self._convert_thetvdbepisode_to_episode(tvdb_ep, show)
add_special_seasons = Settings().getConf(
Settings.ADD_SPECIAL_SEASONS)
if not add_special_seasons and \
show.is_special_season(episode.season_number):
continue
show.episode_list.append(episode)
self.series_list.append(show)
self.changed = True
self.isUpdating = False
pyotherside.send('showListChanged', self.changed)
pyotherside.send('updating', self.isUpdating)
return show
def update_all_shows_episodes(self, show_list=[]):
self.isUpdating = True
pyotherside.send('updating', self.isUpdating)
show_list = show_list or self.series_list
async_worker = AsyncWorker(False)
update_images_worker = AsyncWorker(True)
i = 0
n_shows = len(show_list)
for i in range(n_shows):
update_ended_shows = Settings().getConf(
Settings.UPDATE_ENDED_SHOWS)
show = show_list[i]
if show.status and show.status == 'Ended' and not update_ended_shows:
async_item = AsyncItem(
self._empty_callback, (),
self._set_show_episodes_complete_cb,
(show, update_images_worker, i == n_shows - 1))
async_worker.queue.put(async_item)
continue
pyotherside.send('episodesListUpdating', show.get_name())
show.set_updating(True)
async_item = AsyncItem(
self.thetvdb.get_show_and_episodes, (
show.thetvdb_id,
show.language,
), self._set_show_episodes_complete_cb,
(show, update_images_worker, i == n_shows - 1))
async_worker.queue.put(async_item)
async_item = AsyncItem(
self._set_show_images,
(show, ),
None,
)
update_images_worker.queue.put(async_item)
async_worker.start()
return async_worker
def get_series_list_by_prio(self):
series_list = []
for show in self.series_list:
series_list.append(show.get_dict())
return SortedSeriesList(series_list, Settings(), by_prio=True)
class SeriesFinale:
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += constants.DEFAULT_LANGUAGES
gettext.bindtextdomain(constants.SF_COMPACT_NAME,
constants.LOCALE_DIR)
gettext.textdomain(constants.SF_COMPACT_NAME)
language = gettext.translation(constants.SF_COMPACT_NAME,
constants.LOCALE_DIR,
languages = languages,
fallback = True)
_ = language.gettext
self.series_manager = SeriesManager()
self.settings = Settings()
self.settingsWrapper = SettingsWrapper()
load_conf_item = AsyncItem(self.settings.load,
(constants.SF_CONF_FILE,),
self._settings_load_finished)
load_shows_item = AsyncItem(self.series_manager.load,
(constants.SF_DB_FILE,),
self._load_finished)
self.request = AsyncWorker(True)
self.request.queue.put(load_conf_item)
self.request.queue.put(load_shows_item)
self.request.start()
self.version = constants.SF_VERSION
def getVersion(self):
return self.version
def getStatistics(self):
n_series = len(self.series_manager.series_list)
n_series_watched = 0
n_series_ended = 0
n_all_episodes = 0
n_episodes_to_watch = 0
time_watched = 0
for i in range(n_series):
show = self.series_manager.series_list[i]
episodes = show.episode_list
aired_episodes = [episode for episode in episodes \
if episode.already_aired()]
episodes_to_watch = [episode for episode in aired_episodes \
if not episode.watched]
n_all_episodes += len(aired_episodes)
if episodes_to_watch:
n_episodes_to_watch += len(episodes_to_watch)
else:
n_series_watched += 1
if show.runtime:
time_watched += (len(aired_episodes)-len(episodes_to_watch))*int(show.runtime)
if show.status and show.status == 'Ended':
n_series_ended += 1
return {'numSeries': n_series,
'numSeriesWatched': n_series_watched,
'numSeriesEnded': n_series_ended,
'numEpisodes': n_all_episodes,
'numEpisodesWatched': n_all_episodes-n_episodes_to_watch,
'timeWatched': time_watched}
def closeEvent(self):
# If the shows list is empty but the user hasn't deleted
# any, then we don't save in order to avoid overwriting
# the current db (for the shows list might be empty due
# to an error)
logging.debug('Going down...')
if not self.series_manager.series_list and not self.series_manager.have_deleted:
return
self.series_manager.auto_save(False)
save_shows_item = AsyncItem(self.series_manager.save,
(constants.SF_DB_FILE,))
save_conf_item = AsyncItem(self.settings.save,
(constants.SF_CONF_FILE,),
self._save_finished_cb)
async_worker = AsyncWorker(False)
async_worker.queue.put(save_shows_item)
async_worker.queue.put(save_conf_item)
async_worker.start()
# Wait for the saving thread to complete.
async_worker.join()
def saveSettings(self):
self.settings.save(constants.SF_CONF_FILE)
def _settings_load_finished(self, dummy_arg, error):
#self.series_manager.sorted_series_list.resort()
pass
def _load_finished(self, dummy_arg, error):
self.request = None
self.series_manager.auto_save(False)
def _save_finished_cb(self, dummy_arg, error):
logging.debug('All saved!')
def getHighlightSpecial(self):
return Settings().getConf(Settings.HIGHLIGHT_SPECIAL)
def getLastCompleteUpdate(self):
return Settings().getConf(Settings.LAST_COMPLETE_UPDATE)
def getUpdateEndedShows(self):
return Settings().getConf(Settings.UPDATE_ENDED_SHOWS)
def getSearchLanguage(self):
return Settings().getConf(Settings.SEARCH_LANGUAGE)
def getSortByPrio(self):
return Settings().getConf(Settings.SHOWS_SORT_BY_PRIO)
def getHideCompletedShows(self):
return Settings().getConf(Settings.HIDE_COMPLETED_SHOWS)
def setAddSpecialSeasons(self, add):
Settings().setConf(Settings.ADD_SPECIAL_SEASONS, add)
def getAddSpecialSeasons(self):
return Settings().getConf(Settings.ADD_SPECIAL_SEASONS)
class SeriesFinale:
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += constants.DEFAULT_LANGUAGES
gettext.bindtextdomain(constants.SF_COMPACT_NAME,
constants.LOCALE_DIR)
gettext.textdomain(constants.SF_COMPACT_NAME)
language = gettext.translation(constants.SF_COMPACT_NAME,
constants.LOCALE_DIR,
languages = languages,
fallback = True)
_ = language.gettext
self.series_manager = SeriesManager()
self.settings = Settings()
self.settingsWrapper = SettingsWrapper()
load_conf_item = AsyncItem(self.settings.load,
(constants.SF_CONF_FILE,),
self._settings_load_finished)
load_shows_item = AsyncItem(self.series_manager.load,
(constants.SF_DB_FILE,),
self._load_finished)
self.request = AsyncWorker(True)
self.request.queue.put(load_conf_item)
self.request.queue.put(load_shows_item)
self.request.start()
self.version = constants.SF_VERSION
def getVersion(self):
return self.version
def closeEvent(self):
# If the shows list is empty but the user hasn't deleted
# any, then we don't save in order to avoid overwriting
# the current db (for the shows list might be empty due
# to an error)
logging.debug('Going down...')
if not self.series_manager.series_list and not self.series_manager.have_deleted:
return
self.series_manager.auto_save(False)
save_shows_item = AsyncItem(self.series_manager.save,
(constants.SF_DB_FILE,))
save_conf_item = AsyncItem(self.settings.save,
(constants.SF_CONF_FILE,),
self._save_finished_cb)
async_worker = AsyncWorker(False)
async_worker.queue.put(save_shows_item)
async_worker.queue.put(save_conf_item)
async_worker.start()
# Wait for the saving thread to complete.
async_worker.join()
def saveSettings(self):
self.settings.save(constants.SF_CONF_FILE)
def _settings_load_finished(self, dummy_arg, error):
#self.series_manager.sorted_series_list.resort()
pass
def _load_finished(self, dummy_arg, error):
self.request = None
self.series_manager.auto_save(False)
def _save_finished_cb(self, dummy_arg, error):
logging.debug('All saved!')
class SeriesFinale:
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += constants.DEFAULT_LANGUAGES
gettext.bindtextdomain(constants.SF_COMPACT_NAME,
constants.LOCALE_DIR)
gettext.textdomain(constants.SF_COMPACT_NAME)
language = gettext.translation(constants.SF_COMPACT_NAME,
constants.LOCALE_DIR,
languages = languages,
fallback = True)
_ = language.gettext
self.series_manager = SeriesManager()
self.settings = Settings()
self.settingsWrapper = SettingsWrapper()
load_conf_item = AsyncItem(self.settings.load,
(constants.SF_CONF_FILE,),
self._settings_load_finished)
load_shows_item = AsyncItem(self.series_manager.load,
(constants.SF_DB_FILE,),
self._load_finished)
self.request = AsyncWorker(True)
self.request.queue.put(load_conf_item)
self.request.queue.put(load_shows_item)
self.request.start()
self.version = constants.SF_VERSION
def getVersion(self):
return self.version
def getStatistics(self):
n_series = len(self.series_manager.series_list)
n_series_watched = 0
n_series_ended = 0
n_all_episodes = 0
n_episodes_to_watch = 0
time_watched = 0
for i in range(n_series):
show = self.series_manager.series_list[i]
episodes = show.episode_list
aired_episodes = [episode for episode in episodes \
if episode.already_aired()]
episodes_to_watch = [episode for episode in aired_episodes \
if not episode.watched]
n_all_episodes += len(aired_episodes)
if episodes_to_watch:
n_episodes_to_watch += len(episodes_to_watch)
else:
n_series_watched += 1
if show.runtime:
time_watched += (len(aired_episodes)-len(episodes_to_watch))*int(show.runtime)
if show.status and show.status == 'Ended':
n_series_ended += 1
return {'numSeries': n_series,
'numSeriesWatched': n_series_watched,
'numSeriesEnded': n_series_ended,
'numEpisodes': n_all_episodes,
'numEpisodesWatched': n_all_episodes-n_episodes_to_watch,
'timeWatched': time_watched}
def closeEvent(self):
# If the shows list is empty but the user hasn't deleted
# any, then we don't save in order to avoid overwriting
# the current db (for the shows list might be empty due
# to an error)
logging.debug('Going down...')
if not self.series_manager.series_list and not self.series_manager.have_deleted:
return
self.series_manager.auto_save(False)
save_shows_item = AsyncItem(self.series_manager.save,
(constants.SF_DB_FILE,))
save_conf_item = AsyncItem(self.settings.save,
(constants.SF_CONF_FILE,),
self._save_finished_cb)
async_worker = AsyncWorker(False)
async_worker.queue.put(save_shows_item)
async_worker.queue.put(save_conf_item)
async_worker.start()
# Wait for the saving thread to complete.
async_worker.join()
def saveSettings(self):
self.settings.save(constants.SF_CONF_FILE)
def _settings_load_finished(self, dummy_arg, error):
#self.series_manager.sorted_series_list.resort()
pass
def _load_finished(self, dummy_arg, error):
self.request = None
self.series_manager.auto_save(False)
def _save_finished_cb(self, dummy_arg, error):
logging.debug('All saved!')
def getSortByGenre(self):
return Settings().getConf(Settings.SHOWS_SORT_BY_GENRE)
def setSortByGenre(self, add):
Settings().setConf(Settings.SHOWS_SORT_BY_GENRE, add)
def setHideCompletedShows(self, add):
Settings().setConf(Settings.HIDE_COMPLETED_SHOWS, add)
def setSortByPrio(self, add):
Settings().setConf(Settings.SHOWS_SORT_BY_PRIO, add)
def getEpisodesOrder(self):
return Settings().getConf(Settings.EPISODES_ORDER_CONF_NAME)
def setSearchLanguage(self, language):
Settings().setConf(Settings.SEARCH_LANGUAGE, language)
def setEpisodesOrder(self, newOrder):
Settings().setConf(Settings.EPISODES_ORDER_CONF_NAME, newOrder)
def setUpdateEndedShows(self, add):
Settings().setConf(Settings.UPDATE_ENDED_SHOWS, add)
def getSeasonsOrder(self):
return Settings().getConf(Settings.SEASONS_ORDER_CONF_NAME)
def setLastCompleteUpdate(self, date):
Settings().setConf(Settings.LAST_COMPLETE_UPDATE, date)
def get_sorted_episode_list_by_season(self, season):
episode_list = []
for episode in self.get_episode_list_by_season(season):
episode_list.append(episode.get_dict())
return SortedEpisodesList(episode_list, Settings())
def setHighlightSpecial(self, add):
Settings().setConf(Settings.HIGHLIGHT_SPECIAL, add)
def getShowsSort(self):
return Settings().getConf(Settings.SHOWS_SORT)
def setSeasonsOrder(self, newOrder):
Settings().setConf(Settings.SEASONS_ORDER_CONF_NAME, newOrder)
def setShowsSort(self, newOrder):
Settings().setConf(Settings.SHOWS_SORT, newOrder)
