# # This file is part of SickGear. # # SickGear is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # SickGear is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with SickGear. If not, see <http://www.gnu.org/licenses/>. import datetime import os import traceback import exceptions_helper from exceptions_helper import ex import sickgear from . import db, logger, network_timezones, properFinder, ui # noinspection PyUnreachableCode if False: from sickgear.tv import TVShow def clean_ignore_require_words(): """ removes duplicate ignore/require words from shows and global lists """ try: for s in sickgear.showList: # type: TVShow # test before set to prevent dirty setter from setting unchanged shows to dirty if s.rls_ignore_words - sickgear.IGNORE_WORDS != s.rls_ignore_words: s.rls_ignore_words -= sickgear.IGNORE_WORDS if 0 == len(s.rls_ignore_words): s.rls_ignore_words_regex = False if s.rls_require_words - sickgear.REQUIRE_WORDS != s.rls_require_words: s.rls_require_words -= sickgear.REQUIRE_WORDS if 0 == len(s.rls_require_words): s.rls_require_words_regex = False if s.rls_global_exclude_ignore & sickgear.IGNORE_WORDS != s.rls_global_exclude_ignore: s.rls_global_exclude_ignore &= sickgear.IGNORE_WORDS if s.rls_global_exclude_require & sickgear.REQUIRE_WORDS != s.rls_global_exclude_require: s.rls_global_exclude_require &= sickgear.REQUIRE_WORDS if s.dirty: s.save_to_db() except (BaseException, Exception): pass class ShowUpdater(object): def __init__(self): self.amActive = False def run(self): self.amActive = True try: update_datetime = datetime.datetime.now() update_date = update_datetime.date() # backup db's if sickgear.db.db_supports_backup and 0 < sickgear.BACKUP_DB_MAX_COUNT: logger.log('backing up all db\'s') try: sickgear.db.backup_all_dbs(sickgear.BACKUP_DB_PATH or os.path.join(sickgear.DATA_DIR, 'backup')) except (BaseException, Exception): logger.error('backup db error') # refresh network timezones try: network_timezones.update_network_dict() except (BaseException, Exception): logger.error('network timezone update error') logger.error(traceback.format_exc()) # refresh webdl types try: properFinder.load_webdl_types() except (BaseException, Exception): logger.debug('error loading webdl_types') # update xem id lists try: sickgear.scene_exceptions.get_xem_ids() except (BaseException, Exception): logger.error('xem id list update error') logger.error(traceback.format_exc()) # update scene exceptions try: sickgear.scene_exceptions.retrieve_exceptions() except (BaseException, Exception): logger.error('scene exceptions update error') logger.error(traceback.format_exc()) # clear the data of unused providers try: sickgear.helpers.clear_unused_providers() except (BaseException, Exception): logger.error('unused provider cleanup error') logger.error(traceback.format_exc()) # cleanup image cache try: sickgear.helpers.cleanup_cache() except (BaseException, Exception): logger.error('image cache cleanup error') logger.error(traceback.format_exc()) # check tvinfo cache try: for i in sickgear.TVInfoAPI().all_sources: sickgear.TVInfoAPI(i).setup().check_cache() except (BaseException, Exception): logger.error('tvinfo cache check error') logger.error(traceback.format_exc()) # cleanup tvinfo cache try: for i in sickgear.TVInfoAPI().all_sources: sickgear.TVInfoAPI(i).setup().clean_cache() except (BaseException, Exception): logger.error('tvinfo cache cleanup error') logger.error(traceback.format_exc()) # cleanup ignore and require lists try: clean_ignore_require_words() except (BaseException, Exception): logger.error('ignore, require words cleanup error') logger.error(traceback.format_exc()) # cleanup manual search history sickgear.search_queue.remove_old_fifo(sickgear.search_queue.MANUAL_SEARCH_HISTORY) # add missing mapped ids if not sickgear.background_mapping_task.is_alive(): logger.log('Updating the TV info mappings') import threading try: sickgear.background_mapping_task = threading.Thread( name='MAPPINGSUPDATER', target=sickgear.indexermapper.load_mapped_ids, kwargs={'update': True}) sickgear.background_mapping_task.start() except (BaseException, Exception): logger.error('missing mapped ids update error') logger.error(traceback.format_exc()) logger.log('Doing full update on all shows') # clean out cache directory, remove everything > 12 hours old try: sickgear.helpers.clear_cache() except (BaseException, Exception): logger.error('cache dir cleanup error') logger.error(traceback.format_exc()) # select 10 'Ended' tv_shows updated more than 90 days ago # and all shows not updated more than 180 days ago to include in this update stale_should_update = [] stale_update_date = (update_date - datetime.timedelta(days=90)).toordinal() stale_update_date_max = (update_date - datetime.timedelta(days=180)).toordinal() # last_update_date <= 90 days, sorted ASC because dates are ordinal from sickgear.tv import TVidProdid my_db = db.DBConnection() # noinspection SqlRedundantOrderingDirection mass_sql_result = my_db.mass_action([ ['SELECT indexer || ? || indexer_id AS tvid_prodid' ' FROM tv_shows' ' WHERE last_update_indexer <= ?' ' AND last_update_indexer >= ?' ' ORDER BY last_update_indexer ASC LIMIT 10;', [TVidProdid.glue, stale_update_date, stale_update_date_max]], ['SELECT indexer || ? || indexer_id AS tvid_prodid' ' FROM tv_shows' ' WHERE last_update_indexer < ?;', [TVidProdid.glue, stale_update_date_max]]]) for sql_result in mass_sql_result: for cur_result in sql_result: stale_should_update.append(cur_result['tvid_prodid']) # start update process show_updates = {} for src in sickgear.TVInfoAPI().search_sources: tvinfo_config = sickgear.TVInfoAPI(src).api_params.copy() t = sickgear.TVInfoAPI(src).setup(**tvinfo_config) show_updates.update({src: t.get_updated_shows()}) pi_list = [] for cur_show_obj in sickgear.showList: # type: sickgear.tv.TVShow try: # if should_update returns True (not 'Ended') or show is selected stale 'Ended' then update, # otherwise just refresh if cur_show_obj.should_update( update_date=update_date, last_indexer_change=show_updates.get(cur_show_obj.tvid, {}).get(cur_show_obj.prodid)) \ or cur_show_obj.tvid_prodid in stale_should_update: cur_queue_item = sickgear.show_queue_scheduler.action.update_show( cur_show_obj, scheduled_update=True) else: logger.debug(f'Not updating episodes for show {cur_show_obj.unique_name} because it\'s' f' marked as ended and last/next episode is not within the grace period.') cur_queue_item = sickgear.show_queue_scheduler.action.refresh_show(cur_show_obj, True, True) pi_list.append(cur_queue_item) except (exceptions_helper.CantUpdateException, exceptions_helper.CantRefreshException) as e: logger.error(f'Automatic update failed: {ex(e)}') if len(pi_list): sickgear.show_queue_scheduler.action.daily_update_running = True ui.ProgressIndicators.set_indicator('dailyUpdate', ui.QueueProgressIndicator('Daily Update', pi_list)) logger.log('Added all shows to show queue for full update') finally: self.amActive = False def __del__(self): pass