Change rename misuse of terminology `frequency` to `interval`.

Change rename schedulers to pythonic.

CHANGES.md

@@ -69,6 +69,7 @@
 * Change add response rate limit handling for generic providers
 * Change add newznab retry handling
 * Change add 2s interval fetch retry for Github as it can sometimes return no data
+* Change rename misuse of terminology `frequency` to `interval`
 
 
 [develop changelog]

gui/slick/interfaces/default/config_general.tmpl

@@ -178,7 +178,7 @@
 								<span class="component-desc">
 									<input type="checkbox" name="version_notify" id="version_notify"#echo ('', $checked)[$sg_var('VERSION_NOTIFY', True)]#>
 									<p>and display notifications when updates are available.
-									Checks are run on startup and at the frequency set below*</p>
+									Checks are run on startup and at the interval set below*</p>
 								</span>
 							</label>
 						</div>
@@ -189,7 +189,7 @@
 								<span class="component-desc">
 									<input type="checkbox" name="auto_update" id="auto_update"#echo ('', $checked)[$sg_var('AUTO_UPDATE')]#>
 									<p>fetch and install software updates.
-									Updates are run on startup and in the background at the frequency set below<sup>1</sup></p>
+									Updates are run on startup and in the background at the interval set below<sup>1</sup></p>
 								</span>
 							</label>
 						</div>
@@ -198,7 +198,7 @@
 							<label>
 								<span class="component-title">Check the server every<sup>1</sup></span>
 								<span class="component-desc">
-									<input type="text" name="update_frequency" id="update_frequency" value="$sg_var('UPDATE_FREQUENCY', 12)" class="form-control input-sm input75">
+									<input type="text" name="update_interval" id="update_interval" value="$sg_var('UPDATE_INTERVAL', 12)" class="form-control input-sm input75">
 									<p>hours for software updates (default:12)</p>
 								</span>
 							</label>

gui/slick/interfaces/default/config_notifications.tmpl

@@ -92,7 +92,7 @@
 										<select id="emby-watched-interval" name="emby_watched_interval" class="form-control input-sm view-if">
 											<option value="0"#if not $sg_var('EMBY_WATCHEDSTATE_SCHEDULED')#${selected}#end if#>Off </option>
     #for v in [10, 15, 30, 45, 60]
-											<option value="$v"#if $sg_var('EMBY_WATCHEDSTATE_SCHEDULED') and $v == $sg_var('EMBY_WATCHEDSTATE_FREQUENCY')#${selected}#end if#>$v #if not $sg_var('EMBY_WATCHEDSTATE_SCHEDULED') and $v == $sg_var('EMBY_WATCHEDSTATE_FREQUENCY')#(recent) #end if#</option>
+											<option value="$v"#if $sg_var('EMBY_WATCHEDSTATE_SCHEDULED') and $v == $sg_var('EMBY_WATCHEDSTATE_INTERVAL')#${selected}#end if#>$v #if not $sg_var('EMBY_WATCHEDSTATE_SCHEDULED') and $v == $sg_var('EMBY_WATCHEDSTATE_INTERVAL')#(recent) #end if#</option>
     #end for
 										</select>
 										<span>minutes to fetch episode watched states for the history page</span>
@@ -328,7 +328,7 @@
 											<select id="plex-watched-interval" name="plex_watched_interval" class="form-control input-sm view-if">
 												<option value="0"#if not $sg_var('PLEX_WATCHEDSTATE_SCHEDULED')#${selected}#end if#>Off </option>
 #for v in [10, 15, 30, 45, 60]
-												<option value="$v"#if $sg_var('PLEX_WATCHEDSTATE_SCHEDULED') and $v == $sg_var('PLEX_WATCHEDSTATE_FREQUENCY')#${selected}#end if#>$v #if not $sg_var('PLEX_WATCHEDSTATE_SCHEDULED') and $v == $sg_var('PLEX_WATCHEDSTATE_FREQUENCY')#(recent) #end if#</option>
+												<option value="$v"#if $sg_var('PLEX_WATCHEDSTATE_SCHEDULED') and $v == $sg_var('PLEX_WATCHEDSTATE_INTERVAL')#${selected}#end if#>$v #if not $sg_var('PLEX_WATCHEDSTATE_SCHEDULED') and $v == $sg_var('PLEX_WATCHEDSTATE_INTERVAL')#(recent) #end if#</option>
 #end for
 											</select>
 											<span>minutes to fetch episode watched states for the history page</span>

gui/slick/interfaces/default/config_postProcessing.tmpl

@@ -91,10 +91,10 @@
 						</div>
 
 						<div class="field-pair">
-							<label for="autopostprocesser_frequency">
+							<label for="mediaprocess_interval">
-								<span class="component-title">Run post process every</span>
+								<span class="component-title">Run media process every</span>
 								<span class="component-desc">
-									<input type="text" name="autopostprocesser_frequency" id="autopostprocesser_frequency" value="$sickbeard.AUTOPOSTPROCESSER_FREQUENCY" class="form-control input-sm input75">
+									<input type="text" name="mediaprocess_interval" id="mediaprocess_interval" value="$sickbeard.MEDIAPROCESS_INTERVAL" class="form-control input-sm input75">
 									<p>minutes to check for new files to process (e.g. 10)</p>
 								</span>
 							</label>

gui/slick/interfaces/default/config_search.tmpl

@@ -81,10 +81,10 @@
 
 						<div class="field-pair">
 							<label>
-								<span class="component-title">Recent search frequency</span>
+								<span class="component-title">Recent search interval</span>
 								<span class="component-desc">
-									<input type="text" name="recentsearch_frequency" value="$sickbeard.RECENTSEARCH_FREQUENCY" class="form-control input-sm input75">
+									<input type="text" name="recentsearch_interval" value="$sickbeard.RECENTSEARCH_INTERVAL" class="form-control input-sm input75">
-									<p>minutes between checking recent updated shows (minimum $sickbeard.MIN_RECENTSEARCH_FREQUENCY)</p>
+									<p>minutes between checking recent updated shows (minimum $sickbeard.MIN_RECENTSEARCH_INTERVAL)</p>
 								</span>
 							</label>
 						</div>
@@ -93,7 +93,7 @@
 							<label>
 								<span class="component-title">Limited backlog search</span>
 								<span class="component-desc">
-									<input type="text" name="backlog_days" value="$sickbeard.BACKLOG_DAYS" class="form-control input-sm input75">
+									<input type="text" name="backlog_limited_period" value="$sickbeard.BACKLOG_LIMITED_PERIOD" class="form-control input-sm input75">
 									<p>day(s) that the limited search will cover (e.g. 7)</p>
 								</span>
 							</label>
@@ -121,8 +121,8 @@
 							<label>
 								<span class="component-title">Backlog search spread</span>
 								<span class="component-desc">
-									<input type="text" name="backlog_frequency" value="$sickbeard.BACKLOG_FREQUENCY" class="form-control input-sm input75">
+									<input type="text" name="backlog_period" value="$sickbeard.BACKLOG_PERIOD" class="form-control input-sm input75">
-									<p>days to spread full backlog searches over (min $sickbeard.MIN_BACKLOG_FREQUENCY, default $sickbeard.DEFAULT_BACKLOG_FREQUENCY, max $sickbeard.MAX_BACKLOG_FREQUENCY)</p>
+									<p>days to spread full backlog searches over (min $sickbeard.MIN_BACKLOG_PERIOD, default $sickbeard.DEFAULT_BACKLOG_PERIOD, max $sickbeard.MAX_BACKLOG_PERIOD)</p>
 								</span>
 							</label>
 						</div>

gui/slick/interfaces/default/config_subtitles.tmpl

@@ -97,8 +97,8 @@
 								</div>
 								<div class="field-pair">
 									<label class="nocheck">
-										<span class="component-title">Subtitle Find Frequency</span>
+										<span class="component-title">Subtitle Find Interval</span>
-										<input type="number" name="subtitles_finder_frequency" value="$sickbeard.SUBTITLES_FINDER_FREQUENCY" hours="1" class="form-control input-sm input75">
+										<input type="number" name="subtitles_finder_interval" value="$sickbeard.SUBTITLES_FINDER_INTERVAL" hours="1" class="form-control input-sm input75">
 									</label>
 									<label class="nocheck">
 										<span class="component-title">&nbsp;</span>

gui/slick/interfaces/default/home.tmpl

@@ -99,7 +99,7 @@
 	<div id="$cur_list_id" class="clearfix container" style="clear:both#if 'poster' == $layout#;padding:0#end if#">
 		<div class="posterview">
         ##
-        #for $curLoadingShow in $sickbeard.showQueueScheduler.action.loadingShowList
+        #for $curLoadingShow in $sickbeard.show_queue_scheduler.action.loadingShowList
             ##
             #if $curLoadingShow.show_obj != None and $curLoadingShow.show_obj in $sg_str('showList')
                 #continue
@@ -291,7 +291,7 @@
 		</tfoot>
 
 		<tbody>
-        #for $curLoadingShow in $sickbeard.showQueueScheduler.action.loadingShowList
+        #for $curLoadingShow in $sickbeard.show_queue_scheduler.action.loadingShowList
             #if $curLoadingShow.show_obj != None and $curLoadingShow.show_obj in $sg_str('showList')
                 #continue
             #end if

gui/slick/interfaces/default/manage.tmpl

@@ -131,41 +131,41 @@ $xsrf_form_html
 #for $cur_show_obj in $show_list
     #set $option_state = '<input type="checkbox" class="%sCheck" id="%s-{0:s}"%s>'.format($cur_show_obj.tvid_prodid)
     ##
-    #set $curUpdate_disabled = $sickbeard.showQueueScheduler.action.isBeingUpdated($cur_show_obj)\
+    #set $curUpdate_disabled = $sickbeard.show_queue_scheduler.action.isBeingUpdated($cur_show_obj)\
-                               or $sickbeard.showQueueScheduler.action.isInUpdateQueue($cur_show_obj)
+                               or $sickbeard.show_queue_scheduler.action.isInUpdateQueue($cur_show_obj)
     #set $reason = $disabled_inprogress_tip % 'Update'
     #set $curUpdate = '%s>%s' % (('', $reason)[$curUpdate_disabled],
                                  $option_state % ('update', 'update', ('', $disabled + $reason)[$curUpdate_disabled]))
     ##
-    #set $curRefresh_disabled = $sickbeard.showQueueScheduler.action.isBeingRefreshed($cur_show_obj)\
+    #set $curRefresh_disabled = $sickbeard.show_queue_scheduler.action.isBeingRefreshed($cur_show_obj)\
-                                or $sickbeard.showQueueScheduler.action.isInRefreshQueue($cur_show_obj)
+                                or $sickbeard.show_queue_scheduler.action.isInRefreshQueue($cur_show_obj)
     #set $reason = $disabled_inprogress_tip % 'Rescan'
     #set $curRefresh = '%s>%s' % (('', $reason)[$curRefresh_disabled],
                                   $option_state % ('refresh', 'refresh', ('', $disabled + $reason)[$curRefresh_disabled]))
     ##
-    #set $curRename_disabled = $sickbeard.showQueueScheduler.action.isBeingRenamed($cur_show_obj)\
+    #set $curRename_disabled = $sickbeard.show_queue_scheduler.action.isBeingRenamed($cur_show_obj)\
-                               or $sickbeard.showQueueScheduler.action.isInRenameQueue($cur_show_obj)
+                               or $sickbeard.show_queue_scheduler.action.isInRenameQueue($cur_show_obj)
     #set $reason = $disabled_inprogress_tip % 'Rename'
     #set $curRename = '%s>%s' % (('', $reason)[$curRename_disabled],
                                  $option_state % ('rename', 'rename', ('', $disabled + $reason)[$curRename_disabled]))
     ##
     #set $subtitles_disabled = not $cur_show_obj.subtitles\
-                               or $sickbeard.showQueueScheduler.action.isBeingSubtitled($cur_show_obj)\
+                               or $sickbeard.show_queue_scheduler.action.isBeingSubtitled($cur_show_obj)\
-                               or $sickbeard.showQueueScheduler.action.isInSubtitleQueue($cur_show_obj)
+                               or $sickbeard.show_queue_scheduler.action.isInSubtitleQueue($cur_show_obj)
     #set $reason = ($disabled_inprogress_tip % 'Search subtitle', $disabled_subtitles_tip)[not $cur_show_obj.subtitles]
     #set $curSubtitle = '%s>%s' % (('', $reason)[$subtitles_disabled],
                                    $option_state % ('subtitle', 'subtitle', ('', $disabled + $reason)[$subtitles_disabled]))
     ##
-    #set $curDelete_disabled = $sickbeard.showQueueScheduler.action.isBeingRenamed($cur_show_obj)\
+    #set $curDelete_disabled = $sickbeard.show_queue_scheduler.action.isBeingRenamed($cur_show_obj)\
-                               or $sickbeard.showQueueScheduler.action.isInRenameQueue($cur_show_obj)\
+                               or $sickbeard.show_queue_scheduler.action.isInRenameQueue($cur_show_obj)\
-                               or $sickbeard.showQueueScheduler.action.isInRefreshQueue($cur_show_obj)
+                               or $sickbeard.show_queue_scheduler.action.isInRefreshQueue($cur_show_obj)
     #set $reason = $disabled_inprogress_tip % 'Rename or rescan'
     #set $curDelete = '%s>%s' % (('', $reason)[$curDelete_disabled],
                                  $option_state % ('delete', 'delete', ('', $disabled + $reason)[$curDelete_disabled]))
     ##
-    #set $curRemove_disabled = $sickbeard.showQueueScheduler.action.isBeingRenamed($cur_show_obj)\
+    #set $curRemove_disabled = $sickbeard.show_queue_scheduler.action.isBeingRenamed($cur_show_obj)\
-                               or $sickbeard.showQueueScheduler.action.isInRenameQueue($cur_show_obj)\
+                               or $sickbeard.show_queue_scheduler.action.isInRenameQueue($cur_show_obj)\
-                               or $sickbeard.showQueueScheduler.action.isInRefreshQueue($cur_show_obj)
+                               or $sickbeard.show_queue_scheduler.action.isInRefreshQueue($cur_show_obj)
     ##set $reason = $disabled_inprogress_tip % 'Rename or rescan'
     #set $curRemove = '%s>%s' % (('', $reason)[$curRemove_disabled],
                                  $option_state % ('remove', 'remove', ('', $disabled + $reason)[$curRemove_disabled]))

sickbeard/__init__.py

@@ -60,7 +60,7 @@ from browser_ua import get_ua
 from configobj import ConfigObj
 from libtrakt import TraktAPI
 
-from _23 import b64encodestring, decode_bytes, filter_iter, list_items, map_list, scandir
+from _23 import b64encodestring, decode_bytes, filter_iter, list_items, map_list, ordered_dict, scandir
 from six import iteritems, PY2, string_types
 import sg_helpers
 
@@ -93,21 +93,21 @@ DATA_DIR = ''
 # noinspection PyTypeChecker
 events = None  # type: Events
 
-recentSearchScheduler = None
+recent_search_scheduler = None
-backlogSearchScheduler = None
+backlog_search_scheduler = None
-showUpdateScheduler = None
+show_update_scheduler = None
-versionCheckScheduler = None
+version_check_scheduler = None
-showQueueScheduler = None
+show_queue_scheduler = None
-searchQueueScheduler = None
+search_queue_scheduler = None
-properFinderScheduler = None
+proper_finder_scheduler = None
-autoPostProcesserScheduler = None
+media_process_scheduler = None
-subtitlesFinderScheduler = None
+subtitles_finder_scheduler = None
-# traktCheckerScheduler = None
+# trakt_checker_scheduler = None
+emby_watched_state_scheduler = None
+plex_watched_state_scheduler = None
+watched_state_queue_scheduler = None
 # noinspection PyTypeChecker
 background_mapping_task = None  # type: threading.Thread
-embyWatchedStateScheduler = None
-plexWatchedStateScheduler = None
-watchedStateQueueScheduler = None
 
 provider_ping_thread_pool = {}
 
@@ -243,29 +243,29 @@ WEBDL_TYPES = []
 ALLOW_HIGH_PRIORITY = False
 NEWZNAB_DATA = ''
 
-DEFAULT_AUTOPOSTPROCESSER_FREQUENCY = 10
+DEFAULT_MEDIAPROCESS_INTERVAL = 10
-DEFAULT_BACKLOG_FREQUENCY = 21
+DEFAULT_BACKLOG_PERIOD = 21
-DEFAULT_RECENTSEARCH_FREQUENCY = 40
+DEFAULT_RECENTSEARCH_INTERVAL = 40
-DEFAULT_UPDATE_FREQUENCY = 1
+DEFAULT_UPDATE_INTERVAL = 1
-DEFAULT_WATCHEDSTATE_FREQUENCY = 10
+DEFAULT_WATCHEDSTATE_INTERVAL = 10
 
-AUTOPOSTPROCESSER_FREQUENCY = DEFAULT_AUTOPOSTPROCESSER_FREQUENCY
+MEDIAPROCESS_INTERVAL = DEFAULT_MEDIAPROCESS_INTERVAL
-BACKLOG_FREQUENCY = DEFAULT_BACKLOG_FREQUENCY
+BACKLOG_PERIOD = DEFAULT_BACKLOG_PERIOD
-RECENTSEARCH_FREQUENCY = DEFAULT_RECENTSEARCH_FREQUENCY
+BACKLOG_LIMITED_PERIOD = 7
-UPDATE_FREQUENCY = DEFAULT_UPDATE_FREQUENCY
+RECENTSEARCH_INTERVAL = DEFAULT_RECENTSEARCH_INTERVAL
+UPDATE_INTERVAL = DEFAULT_UPDATE_INTERVAL
 
 RECENTSEARCH_STARTUP = False
 BACKLOG_NOFULL = False
 
-MIN_AUTOPOSTPROCESSER_FREQUENCY = 1
+MIN_MEDIAPROCESS_INTERVAL = 1
-MIN_RECENTSEARCH_FREQUENCY = 10
+MIN_RECENTSEARCH_INTERVAL = 10
-MIN_BACKLOG_FREQUENCY = 7
+MIN_BACKLOG_PERIOD = 7
-MAX_BACKLOG_FREQUENCY = 42
+MAX_BACKLOG_PERIOD = 42
-MIN_UPDATE_FREQUENCY = 1
+MIN_UPDATE_INTERVAL = 1
-MIN_WATCHEDSTATE_FREQUENCY = 10
+MIN_WATCHEDSTATE_INTERVAL = 10
-MAX_WATCHEDSTATE_FREQUENCY = 60
+MAX_WATCHEDSTATE_INTERVAL = 60
 
-BACKLOG_DAYS = 7
 SEARCH_UNAIRED = False
 UNAIRED_RECENT_SEARCH_ONLY = True
 
@@ -318,7 +318,7 @@ EMBY_PARENT_MAPS = None
 EMBY_HOST = None
 EMBY_APIKEY = None
 EMBY_WATCHEDSTATE_SCHEDULED = False
-EMBY_WATCHEDSTATE_FREQUENCY = DEFAULT_WATCHEDSTATE_FREQUENCY
+EMBY_WATCHEDSTATE_INTERVAL = DEFAULT_WATCHEDSTATE_INTERVAL
 
 USE_KODI = False
 KODI_ALWAYS_ON = True
@@ -344,7 +344,7 @@ PLEX_HOST = None
 PLEX_USERNAME = None
 PLEX_PASSWORD = None
 PLEX_WATCHEDSTATE_SCHEDULED = False
-PLEX_WATCHEDSTATE_FREQUENCY = DEFAULT_WATCHEDSTATE_FREQUENCY
+PLEX_WATCHEDSTATE_INTERVAL = DEFAULT_WATCHEDSTATE_INTERVAL
 
 USE_XBMC = False
 XBMC_ALWAYS_ON = True
@@ -541,7 +541,7 @@ SUBTITLES_SERVICES_LIST = []
 SUBTITLES_SERVICES_ENABLED = []
 SUBTITLES_SERVICES_AUTH = [['', '']]
 SUBTITLES_HISTORY = False
-SUBTITLES_FINDER_FREQUENCY = 1
+SUBTITLES_FINDER_INTERVAL = 1
 
 USE_FAILED_DOWNLOADS = False
 DELETE_FAILED = False
@@ -609,7 +609,7 @@ MEMCACHE_FLAG_IMAGES = {}
 
 
 def get_backlog_cycle_time():
-    cycletime = RECENTSEARCH_FREQUENCY * 2 + 7
+    cycletime = RECENTSEARCH_INTERVAL * 2 + 7
     return max([cycletime, 720])
 
 
@@ -657,7 +657,7 @@ def init_stage_1(console_logging):
     # Gen Config/Misc
     global LAUNCH_BROWSER, UPDATE_SHOWS_ON_START, SHOW_UPDATE_HOUR, \
         TRASH_REMOVE_SHOW, TRASH_ROTATE_LOGS, ACTUAL_LOG_DIR, LOG_DIR, TVINFO_TIMEOUT, ROOT_DIRS, \
-        VERSION_NOTIFY, AUTO_UPDATE, UPDATE_FREQUENCY, NOTIFY_ON_UPDATE
+        VERSION_NOTIFY, AUTO_UPDATE, UPDATE_INTERVAL, NOTIFY_ON_UPDATE
     # Gen Config/Interface
     global THEME_NAME, DEFAULT_HOME, FANART_LIMIT, SHOWLIST_TAGVIEW, SHOW_TAGS, \
         HOME_SEARCH_FOCUS, USE_IMDB_INFO, IMDB_ACCOUNTS, DISPLAY_FREESPACE, SORT_ARTICLE, FUZZY_DATING, TRIM_ZERO, \
@@ -669,8 +669,8 @@ def init_stage_1(console_logging):
     global BRANCH, CUR_COMMIT_BRANCH, GIT_REMOTE, CUR_COMMIT_HASH, GIT_PATH, CPU_PRESET, ANON_REDIRECT, \
         ENCRYPTION_VERSION, PROXY_SETTING, PROXY_INDEXERS, FILE_LOGGING_PRESET
     # Search Settings/Episode
-    global DOWNLOAD_PROPERS, PROPERS_WEBDL_ONEGRP, WEBDL_TYPES, RECENTSEARCH_FREQUENCY, \
+    global DOWNLOAD_PROPERS, PROPERS_WEBDL_ONEGRP, WEBDL_TYPES, RECENTSEARCH_INTERVAL, \
-        BACKLOG_DAYS, BACKLOG_NOFULL, BACKLOG_FREQUENCY, USENET_RETENTION, IGNORE_WORDS, REQUIRE_WORDS, \
+        BACKLOG_LIMITED_PERIOD, BACKLOG_NOFULL, BACKLOG_PERIOD, USENET_RETENTION, IGNORE_WORDS, REQUIRE_WORDS, \
         IGNORE_WORDS, IGNORE_WORDS_REGEX, REQUIRE_WORDS, REQUIRE_WORDS_REGEX, \
         ALLOW_HIGH_PRIORITY, SEARCH_UNAIRED, UNAIRED_RECENT_SEARCH_ONLY
     # Search Settings/NZB search
@@ -684,12 +684,12 @@ def init_stage_1(console_logging):
     # Media Providers
     global PROVIDER_ORDER, NEWZNAB_DATA, PROVIDER_HOMES
     # Subtitles
-    global USE_SUBTITLES, SUBTITLES_LANGUAGES, SUBTITLES_DIR, SUBTITLES_FINDER_FREQUENCY, SUBTITLES_OS_HASH, \
+    global USE_SUBTITLES, SUBTITLES_LANGUAGES, SUBTITLES_DIR, SUBTITLES_FINDER_INTERVAL, SUBTITLES_OS_HASH, \
         SUBTITLES_HISTORY, SUBTITLES_SERVICES_LIST, SUBTITLES_SERVICES_ENABLED, SUBTITLES_SERVICES_AUTH
     # Media Process/Post-Processing
-    global TV_DOWNLOAD_DIR, PROCESS_METHOD, PROCESS_AUTOMATICALLY, AUTOPOSTPROCESSER_FREQUENCY, \
+    global TV_DOWNLOAD_DIR, PROCESS_METHOD, PROCESS_AUTOMATICALLY, MEDIAPROCESS_INTERVAL, \
         POSTPONE_IF_SYNC_FILES, EXTRA_SCRIPTS, SG_EXTRA_SCRIPTS, \
-        DEFAULT_AUTOPOSTPROCESSER_FREQUENCY, MIN_AUTOPOSTPROCESSER_FREQUENCY, \
+        DEFAULT_MEDIAPROCESS_INTERVAL, MIN_MEDIAPROCESS_INTERVAL, \
         UNPACK, SKIP_REMOVED_FILES, MOVE_ASSOCIATED_FILES, NFO_RENAME, RENAME_EPISODES, AIRDATE_EPISODES, \
         USE_FAILED_DOWNLOADS, DELETE_FAILED
     # Media Process/Episode Naming
@@ -701,7 +701,7 @@ def init_stage_1(console_logging):
         METADATA_PS3, METADATA_TIVO, METADATA_WDTV, METADATA_XBMC_12PLUS
     # Notification Settings/HT and NAS
     global USE_EMBY, EMBY_UPDATE_LIBRARY, EMBY_PARENT_MAPS, EMBY_HOST, EMBY_APIKEY, \
-        EMBY_WATCHEDSTATE_SCHEDULED, EMBY_WATCHEDSTATE_FREQUENCY, \
+        EMBY_WATCHEDSTATE_SCHEDULED, EMBY_WATCHEDSTATE_INTERVAL, \
         USE_KODI, KODI_ALWAYS_ON, KODI_UPDATE_LIBRARY, KODI_UPDATE_FULL, KODI_UPDATE_ONLYFIRST, \
         KODI_PARENT_MAPS, KODI_HOST, KODI_USERNAME, KODI_PASSWORD, KODI_NOTIFY_ONSNATCH, \
         KODI_NOTIFY_ONDOWNLOAD, KODI_NOTIFY_ONSUBTITLEDOWNLOAD, \
@@ -709,7 +709,7 @@ def init_stage_1(console_logging):
         XBMC_UPDATE_LIBRARY, XBMC_UPDATE_FULL, XBMC_UPDATE_ONLYFIRST, XBMC_HOST, XBMC_USERNAME, XBMC_PASSWORD, \
         USE_PLEX, PLEX_USERNAME, PLEX_PASSWORD, PLEX_UPDATE_LIBRARY, PLEX_PARENT_MAPS, PLEX_SERVER_HOST, \
         PLEX_NOTIFY_ONSNATCH, PLEX_NOTIFY_ONDOWNLOAD, PLEX_NOTIFY_ONSUBTITLEDOWNLOAD, PLEX_HOST, \
-        PLEX_WATCHEDSTATE_SCHEDULED, PLEX_WATCHEDSTATE_FREQUENCY, \
+        PLEX_WATCHEDSTATE_SCHEDULED, PLEX_WATCHEDSTATE_INTERVAL, \
         USE_NMJ, NMJ_HOST, NMJ_DATABASE, NMJ_MOUNT, \
         USE_NMJv2, NMJv2_HOST, NMJv2_DATABASE, NMJv2_DBLOC, \
         USE_SYNOINDEX, \
@@ -951,25 +951,24 @@ def init_stage_1(console_logging):
 
     USENET_RETENTION = check_setting_int(CFG, 'General', 'usenet_retention', 500)
 
-    AUTOPOSTPROCESSER_FREQUENCY = check_setting_int(CFG, 'General', 'autopostprocesser_frequency',
+    MEDIAPROCESS_INTERVAL = check_setting_int(CFG, 'General', 'mediaprocess_interval', DEFAULT_MEDIAPROCESS_INTERVAL)
-                                                    DEFAULT_AUTOPOSTPROCESSER_FREQUENCY)
+    if MEDIAPROCESS_INTERVAL < MIN_MEDIAPROCESS_INTERVAL:
-    if AUTOPOSTPROCESSER_FREQUENCY < MIN_AUTOPOSTPROCESSER_FREQUENCY:
+        MEDIAPROCESS_INTERVAL = MIN_MEDIAPROCESS_INTERVAL
-        AUTOPOSTPROCESSER_FREQUENCY = MIN_AUTOPOSTPROCESSER_FREQUENCY
 
-    RECENTSEARCH_FREQUENCY = check_setting_int(CFG, 'General', 'recentsearch_frequency',
+    RECENTSEARCH_INTERVAL = check_setting_int(CFG, 'General', 'recentsearch_interval', DEFAULT_RECENTSEARCH_INTERVAL)
-                                               DEFAULT_RECENTSEARCH_FREQUENCY)
+    if RECENTSEARCH_INTERVAL < MIN_RECENTSEARCH_INTERVAL:
-    if RECENTSEARCH_FREQUENCY < MIN_RECENTSEARCH_FREQUENCY:
+        RECENTSEARCH_INTERVAL = MIN_RECENTSEARCH_INTERVAL
-        RECENTSEARCH_FREQUENCY = MIN_RECENTSEARCH_FREQUENCY
 
-    BACKLOG_FREQUENCY = check_setting_int(CFG, 'General', 'backlog_frequency', DEFAULT_BACKLOG_FREQUENCY)
+    # special case during dev to migrate backlog_interval to backlog_period
-    BACKLOG_FREQUENCY = minimax(BACKLOG_FREQUENCY, DEFAULT_BACKLOG_FREQUENCY,
+    BACKLOG_PERIOD = check_setting_int(CFG, 'General', 'backlog_period',
-                                MIN_BACKLOG_FREQUENCY, MAX_BACKLOG_FREQUENCY)
+                                       check_setting_int(CFG, 'General', 'backlog_interval', DEFAULT_BACKLOG_PERIOD))
+    BACKLOG_PERIOD = minimax(BACKLOG_PERIOD, DEFAULT_BACKLOG_PERIOD, MIN_BACKLOG_PERIOD, MAX_BACKLOG_PERIOD)
+    BACKLOG_LIMITED_PERIOD = check_setting_int(CFG, 'General', 'backlog_limited_period', 7)
 
-    UPDATE_FREQUENCY = check_setting_int(CFG, 'General', 'update_frequency', DEFAULT_UPDATE_FREQUENCY)
+    UPDATE_INTERVAL = check_setting_int(CFG, 'General', 'update_interval', DEFAULT_UPDATE_INTERVAL)
-    if UPDATE_FREQUENCY < MIN_UPDATE_FREQUENCY:
+    if UPDATE_INTERVAL < MIN_UPDATE_INTERVAL:
-        UPDATE_FREQUENCY = MIN_UPDATE_FREQUENCY
+        UPDATE_INTERVAL = MIN_UPDATE_INTERVAL
 
-    BACKLOG_DAYS = check_setting_int(CFG, 'General', 'backlog_days', 7)
     SEARCH_UNAIRED = bool(check_setting_int(CFG, 'General', 'search_unaired', 0))
     UNAIRED_RECENT_SEARCH_ONLY = bool(check_setting_int(CFG, 'General', 'unaired_recent_search_only', 1))
 
@@ -1043,9 +1042,9 @@ def init_stage_1(console_logging):
     EMBY_HOST = check_setting_str(CFG, 'Emby', 'emby_host', '')
     EMBY_APIKEY = check_setting_str(CFG, 'Emby', 'emby_apikey', '')
     EMBY_WATCHEDSTATE_SCHEDULED = bool(check_setting_int(CFG, 'Emby', 'emby_watchedstate_scheduled', 0))
-    EMBY_WATCHEDSTATE_FREQUENCY = minimax(check_setting_int(
+    EMBY_WATCHEDSTATE_INTERVAL = minimax(check_setting_int(
-        CFG, 'Emby', 'emby_watchedstate_frequency', DEFAULT_WATCHEDSTATE_FREQUENCY),
+        CFG, 'Emby', 'emby_watchedstate_interval', DEFAULT_WATCHEDSTATE_INTERVAL),
-        DEFAULT_WATCHEDSTATE_FREQUENCY, MIN_WATCHEDSTATE_FREQUENCY, MAX_WATCHEDSTATE_FREQUENCY)
+        DEFAULT_WATCHEDSTATE_INTERVAL, MIN_WATCHEDSTATE_INTERVAL, MAX_WATCHEDSTATE_INTERVAL)
 
     USE_KODI = bool(check_setting_int(CFG, 'Kodi', 'use_kodi', 0))
     KODI_ALWAYS_ON = bool(check_setting_int(CFG, 'Kodi', 'kodi_always_on', 1))
@@ -1083,9 +1082,9 @@ def init_stage_1(console_logging):
     PLEX_USERNAME = check_setting_str(CFG, 'Plex', 'plex_username', '')
     PLEX_PASSWORD = check_setting_str(CFG, 'Plex', 'plex_password', '')
     PLEX_WATCHEDSTATE_SCHEDULED = bool(check_setting_int(CFG, 'Plex', 'plex_watchedstate_scheduled', 0))
-    PLEX_WATCHEDSTATE_FREQUENCY = minimax(check_setting_int(
+    PLEX_WATCHEDSTATE_INTERVAL = minimax(check_setting_int(
-        CFG, 'Plex', 'plex_watchedstate_frequency', DEFAULT_WATCHEDSTATE_FREQUENCY),
+        CFG, 'Plex', 'plex_watchedstate_interval', DEFAULT_WATCHEDSTATE_INTERVAL),
-        DEFAULT_WATCHEDSTATE_FREQUENCY, MIN_WATCHEDSTATE_FREQUENCY, MAX_WATCHEDSTATE_FREQUENCY)
+        DEFAULT_WATCHEDSTATE_INTERVAL, MIN_WATCHEDSTATE_INTERVAL, MAX_WATCHEDSTATE_INTERVAL)
 
     USE_GROWL = bool(check_setting_int(CFG, 'Growl', 'use_growl', 0))
     GROWL_NOTIFY_ONSNATCH = bool(check_setting_int(CFG, 'Growl', 'growl_notify_onsnatch', 0))
@@ -1248,7 +1247,7 @@ def init_stage_1(console_logging):
                                if k]
     SUBTITLES_DEFAULT = bool(check_setting_int(CFG, 'Subtitles', 'subtitles_default', 0))
     SUBTITLES_HISTORY = bool(check_setting_int(CFG, 'Subtitles', 'subtitles_history', 0))
-    SUBTITLES_FINDER_FREQUENCY = check_setting_int(CFG, 'Subtitles', 'subtitles_finder_frequency', 1)
+    SUBTITLES_FINDER_INTERVAL = check_setting_int(CFG, 'Subtitles', 'subtitles_finder_interval', 1)
     SUBTITLES_OS_HASH = bool(check_setting_int(CFG, 'Subtitles', 'subtitles_os_hash', 1))
 
     USE_FAILED_DOWNLOADS = bool(check_setting_int(CFG, 'FailedDownloads', 'use_failed_downloads', 0))
@@ -1465,25 +1464,25 @@ def init_stage_2():
     # Misc
     global __INITIALIZED__, MEMCACHE, MEMCACHE_FLAG_IMAGES, RECENTSEARCH_STARTUP
     # Schedulers
-    # global traktCheckerScheduler
+    # global trakt_checker_scheduler
-    global recentSearchScheduler, backlogSearchScheduler, showUpdateScheduler, \
+    global recent_search_scheduler, backlog_search_scheduler, show_update_scheduler, \
-        versionCheckScheduler, showQueueScheduler, searchQueueScheduler, \
+        version_check_scheduler, show_queue_scheduler, search_queue_scheduler, \
-        properFinderScheduler, autoPostProcesserScheduler, subtitlesFinderScheduler, \
+        proper_finder_scheduler, media_process_scheduler, subtitles_finder_scheduler, \
         background_mapping_task, \
-        watchedStateQueueScheduler, embyWatchedStateScheduler, plexWatchedStateScheduler
+        watched_state_queue_scheduler, emby_watched_state_scheduler, plex_watched_state_scheduler
     # Gen Config/Misc
-    global SHOW_UPDATE_HOUR, UPDATE_FREQUENCY
+    global SHOW_UPDATE_HOUR, UPDATE_INTERVAL
     # Search Settings/Episode
-    global RECENTSEARCH_FREQUENCY
+    global RECENTSEARCH_INTERVAL
     # Subtitles
-    global USE_SUBTITLES, SUBTITLES_FINDER_FREQUENCY
+    global USE_SUBTITLES, SUBTITLES_FINDER_INTERVAL
     # Media Process/Post-Processing
-    global PROCESS_AUTOMATICALLY, AUTOPOSTPROCESSER_FREQUENCY
+    global PROCESS_AUTOMATICALLY, MEDIAPROCESS_INTERVAL
     # Media Process/Metadata
     global metadata_provider_dict, METADATA_KODI, METADATA_MEDE8ER, METADATA_MEDIABROWSER, \
         METADATA_PS3, METADATA_TIVO, METADATA_WDTV, METADATA_XBMC, METADATA_XBMC_12PLUS
     # Notification Settings/HT and NAS
-    global EMBY_WATCHEDSTATE_FREQUENCY, PLEX_WATCHEDSTATE_FREQUENCY
+    global EMBY_WATCHEDSTATE_INTERVAL, PLEX_WATCHEDSTATE_INTERVAL
 
     # initialize main database
     my_db = db.DBConnection()
@@ -1520,40 +1519,40 @@ def init_stage_2():
     # initialize schedulers
     # updaters
     update_now = datetime.timedelta(minutes=0)
-    versionCheckScheduler = scheduler.Scheduler(
+    version_check_scheduler = scheduler.Scheduler(
         version_checker.CheckVersion(),
-        cycleTime=datetime.timedelta(hours=UPDATE_FREQUENCY),
+        cycleTime=datetime.timedelta(hours=UPDATE_INTERVAL),
         threadName='CHECKVERSION',
         silent=False)
 
-    showQueueScheduler = scheduler.Scheduler(
+    show_queue_scheduler = scheduler.Scheduler(
         show_queue.ShowQueue(),
         cycleTime=datetime.timedelta(seconds=3),
         threadName='SHOWQUEUE')
 
-    showUpdateScheduler = scheduler.Scheduler(
+    show_update_scheduler = scheduler.Scheduler(
         show_updater.ShowUpdater(),
         cycleTime=datetime.timedelta(hours=1),
         start_time=datetime.time(hour=SHOW_UPDATE_HOUR),
         threadName='SHOWUPDATER',
-        prevent_cycle_run=showQueueScheduler.action.isShowUpdateRunning)  # 3AM
+        prevent_cycle_run=show_queue_scheduler.action.isShowUpdateRunning)  # 3AM
 
     # searchers
-    searchQueueScheduler = scheduler.Scheduler(
+    search_queue_scheduler = scheduler.Scheduler(
         search_queue.SearchQueue(),
         cycleTime=datetime.timedelta(seconds=3),
         threadName='SEARCHQUEUE')
 
     init_search_delay = int(os.environ.get('INIT_SEARCH_DELAY', 0))
 
-    # enter 4499 (was 4489) for experimental internal provider frequencies
+    # enter 4499 (was 4489) for experimental internal provider intervals
-    update_interval = datetime.timedelta(minutes=(RECENTSEARCH_FREQUENCY, 1)[4499 == RECENTSEARCH_FREQUENCY])
+    update_interval = datetime.timedelta(minutes=(RECENTSEARCH_INTERVAL, 1)[4499 == RECENTSEARCH_INTERVAL])
-    recentSearchScheduler = scheduler.Scheduler(
+    recent_search_scheduler = scheduler.Scheduler(
         search_recent.RecentSearcher(),
         cycleTime=update_interval,
         run_delay=update_now if RECENTSEARCH_STARTUP else datetime.timedelta(minutes=init_search_delay or 5),
         threadName='RECENTSEARCHER',
-        prevent_cycle_run=searchQueueScheduler.action.is_recentsearch_in_progress)
+        prevent_cycle_run=search_queue_scheduler.action.is_recentsearch_in_progress)
 
     if [x for x in providers.sortedProviderList() if x.is_active() and
             getattr(x, 'enable_backlog', None) and GenericProvider.NZB == x.providerType]:
@@ -1570,12 +1569,12 @@ def init_stage_2():
         backlogdelay = helpers.try_int((time_diff.total_seconds() / 60) + 10, 10)
     else:
         backlogdelay = 10
-    backlogSearchScheduler = search_backlog.BacklogSearchScheduler(
+    backlog_search_scheduler = search_backlog.BacklogSearchScheduler(
         search_backlog.BacklogSearcher(),
         cycleTime=datetime.timedelta(minutes=get_backlog_cycle_time()),
         run_delay=datetime.timedelta(minutes=init_search_delay or backlogdelay),
         threadName='BACKLOG',
-        prevent_cycle_run=searchQueueScheduler.action.is_standard_backlog_in_progress)
+        prevent_cycle_run=search_queue_scheduler.action.is_standard_backlog_in_progress)
 
     propers_searcher = search_propers.ProperSearcher()
     last_proper_search = datetime.datetime.fromtimestamp(properFinder.get_last_proper_search())
@@ -1585,46 +1584,46 @@ def init_stage_2():
     else:
         properdelay = helpers.try_int((time_diff.total_seconds() / 60) + 5, 20)
 
-    properFinderScheduler = scheduler.Scheduler(
+    proper_finder_scheduler = scheduler.Scheduler(
         propers_searcher,
         cycleTime=datetime.timedelta(days=1),
         run_delay=datetime.timedelta(minutes=init_search_delay or properdelay),
         threadName='FINDPROPERS',
-        prevent_cycle_run=searchQueueScheduler.action.is_propersearch_in_progress)
+        prevent_cycle_run=search_queue_scheduler.action.is_propersearch_in_progress)
 
     # processors
-    autoPostProcesserScheduler = scheduler.Scheduler(
+    media_process_scheduler = scheduler.Scheduler(
         auto_post_processer.PostProcesser(),
-        cycleTime=datetime.timedelta(minutes=AUTOPOSTPROCESSER_FREQUENCY),
+        cycleTime=datetime.timedelta(minutes=MEDIAPROCESS_INTERVAL),
         threadName='POSTPROCESSER',
         silent=not PROCESS_AUTOMATICALLY)
     """
-    traktCheckerScheduler = scheduler.Scheduler(
+    trakt_checker_scheduler = scheduler.Scheduler(
         traktChecker.TraktChecker(), cycleTime=datetime.timedelta(hours=1),
         threadName='TRAKTCHECKER', silent=not USE_TRAKT)
     """
-    subtitlesFinderScheduler = scheduler.Scheduler(
+    subtitles_finder_scheduler = scheduler.Scheduler(
         subtitles.SubtitlesFinder(),
-        cycleTime=datetime.timedelta(hours=SUBTITLES_FINDER_FREQUENCY),
+        cycleTime=datetime.timedelta(hours=SUBTITLES_FINDER_INTERVAL),
         threadName='FINDSUBTITLES',
         silent=not USE_SUBTITLES)
 
     background_mapping_task = threading.Thread(name='LOAD-MAPPINGS', target=indexermapper.load_mapped_ids)
 
-    watchedStateQueueScheduler = scheduler.Scheduler(
+    watched_state_queue_scheduler = scheduler.Scheduler(
         watchedstate_queue.WatchedStateQueue(),
         cycleTime=datetime.timedelta(seconds=3),
         threadName='WATCHEDSTATEQUEUE')
 
-    embyWatchedStateScheduler = scheduler.Scheduler(
+    emby_watched_state_scheduler = scheduler.Scheduler(
         EmbyWatchedStateUpdater(),
-        cycleTime=datetime.timedelta(minutes=EMBY_WATCHEDSTATE_FREQUENCY),
+        cycleTime=datetime.timedelta(minutes=EMBY_WATCHEDSTATE_INTERVAL),
         run_delay=datetime.timedelta(minutes=5),
         threadName='EMBYWATCHEDSTATE')
 
-    plexWatchedStateScheduler = scheduler.Scheduler(
+    plex_watched_state_scheduler = scheduler.Scheduler(
         PlexWatchedStateUpdater(),
-        cycleTime=datetime.timedelta(minutes=PLEX_WATCHEDSTATE_FREQUENCY),
+        cycleTime=datetime.timedelta(minutes=PLEX_WATCHEDSTATE_INTERVAL),
         run_delay=datetime.timedelta(minutes=5),
         threadName='PLEXWATCHEDSTATE')
 
@@ -1643,12 +1642,12 @@ def init_stage_2():
 
 
 def enabled_schedulers(is_init=False):
-    # ([], [traktCheckerScheduler])[USE_TRAKT] + \
+    # ([], [trakt_checker_scheduler])[USE_TRAKT] + \
     return ([], [events])[is_init] \
-           + [recentSearchScheduler, backlogSearchScheduler, showUpdateScheduler,
+           + [recent_search_scheduler, backlog_search_scheduler, show_update_scheduler,
-              versionCheckScheduler, showQueueScheduler, searchQueueScheduler, properFinderScheduler,
+              version_check_scheduler, show_queue_scheduler, search_queue_scheduler, proper_finder_scheduler,
-              autoPostProcesserScheduler, subtitlesFinderScheduler,
+              media_process_scheduler, subtitles_finder_scheduler,
-              embyWatchedStateScheduler, plexWatchedStateScheduler, watchedStateQueueScheduler]\
+              emby_watched_state_scheduler, plex_watched_state_scheduler, watched_state_queue_scheduler]\
            + ([events], [])[is_init]
 
 
@@ -1664,7 +1663,7 @@ def start():
             background_mapping_task.start()
 
             for p in providers.sortedProviderList():
-                if p.is_active() and getattr(p, 'ping_freq', None):
+                if p.is_active() and getattr(p, 'ping_iv', None):
                     # noinspection PyProtectedMember
                     provider_ping_thread_pool[p.get_id()] = threading.Thread(
                         name='PING-PROVIDER %s' % p.name, target=p._ping)
@@ -1767,7 +1766,7 @@ def save_config():
 
     # For passwords you must include the word `password` in the item_name and
     # add `helpers.encrypt(ITEM_NAME, ENCRYPTION_VERSION)` in save_config()
-    new_config['General'] = {}
+    new_config['General'] = ordered_dict()
     s_z = check_setting_int(CFG, 'General', 'stack_size', 0)
     if s_z:
         new_config['General']['stack_size'] = s_z
@@ -1807,10 +1806,11 @@ def save_config():
     new_config['General']['nzb_method'] = NZB_METHOD
     new_config['General']['torrent_method'] = TORRENT_METHOD
     new_config['General']['usenet_retention'] = int(USENET_RETENTION)
-    new_config['General']['autopostprocesser_frequency'] = int(AUTOPOSTPROCESSER_FREQUENCY)
+    new_config['General']['mediaprocess_interval'] = int(MEDIAPROCESS_INTERVAL)
-    new_config['General']['recentsearch_frequency'] = int(RECENTSEARCH_FREQUENCY)
+    new_config['General']['recentsearch_interval'] = int(RECENTSEARCH_INTERVAL)
-    new_config['General']['backlog_frequency'] = int(BACKLOG_FREQUENCY)
+    new_config['General']['backlog_period'] = int(BACKLOG_PERIOD)
-    new_config['General']['update_frequency'] = int(UPDATE_FREQUENCY)
+    new_config['General']['backlog_limited_period'] = int(BACKLOG_LIMITED_PERIOD)
+    new_config['General']['update_interval'] = int(UPDATE_INTERVAL)
     new_config['General']['download_propers'] = int(DOWNLOAD_PROPERS)
     new_config['General']['propers_webdl_onegrp'] = int(PROPERS_WEBDL_ONEGRP)
     new_config['General']['allow_high_priority'] = int(ALLOW_HIGH_PRIORITY)
@@ -1865,7 +1865,6 @@ def save_config():
     new_config['General']['metadata_mede8er'] = METADATA_MEDE8ER
     new_config['General']['metadata_kodi'] = METADATA_KODI
 
-    new_config['General']['backlog_days'] = int(BACKLOG_DAYS)
     new_config['General']['search_unaired'] = int(SEARCH_UNAIRED)
     new_config['General']['unaired_recent_search_only'] = int(UNAIRED_RECENT_SEARCH_ONLY)
 
@@ -2011,7 +2010,7 @@ def save_config():
             ('apikey', EMBY_APIKEY), ('host', EMBY_HOST),
             ('update_library', int(EMBY_UPDATE_LIBRARY)),
             ('watchedstate_scheduled', int(EMBY_WATCHEDSTATE_SCHEDULED)),
-            ('watchedstate_frequency', int(EMBY_WATCHEDSTATE_FREQUENCY)),
+            ('watchedstate_interval', int(EMBY_WATCHEDSTATE_INTERVAL)),
             ('parent_maps', EMBY_PARENT_MAPS),
         ]),
         ('Kodi', [
@@ -2029,7 +2028,7 @@ def save_config():
             ('host', PLEX_HOST),
             ('update_library', int(PLEX_UPDATE_LIBRARY)),
             ('watchedstate_scheduled', int(PLEX_WATCHEDSTATE_SCHEDULED)),
-            ('watchedstate_frequency', int(PLEX_WATCHEDSTATE_FREQUENCY)),
+            ('watchedstate_interval', int(PLEX_WATCHEDSTATE_INTERVAL)),
             ('parent_maps', PLEX_PARENT_MAPS),
             ('server_host', PLEX_SERVER_HOST),
         ]),
@@ -2270,7 +2269,7 @@ def save_config():
     new_config['Subtitles']['subtitles_dir'] = SUBTITLES_DIR
     new_config['Subtitles']['subtitles_default'] = int(SUBTITLES_DEFAULT)
     new_config['Subtitles']['subtitles_history'] = int(SUBTITLES_HISTORY)
-    new_config['Subtitles']['subtitles_finder_frequency'] = int(SUBTITLES_FINDER_FREQUENCY)
+    new_config['Subtitles']['subtitles_finder_interval'] = int(SUBTITLES_FINDER_INTERVAL)
     new_config['Subtitles']['subtitles_os_hash'] = SUBTITLES_OS_HASH
 
     new_config['FailedDownloads'] = {}

sickbeard/config.py

@@ -151,39 +151,39 @@ def change_tv_download_dir(tv_download_dir):
     return True
 
 
-def schedule_autopostprocesser(freq):
+def schedule_mediaprocess(iv):
-    sickbeard.AUTOPOSTPROCESSER_FREQUENCY = to_int(freq, default=sickbeard.DEFAULT_AUTOPOSTPROCESSER_FREQUENCY)
+    sickbeard.MEDIAPROCESS_INTERVAL = to_int(iv, default=sickbeard.DEFAULT_MEDIAPROCESS_INTERVAL)
 
-    if sickbeard.AUTOPOSTPROCESSER_FREQUENCY < sickbeard.MIN_AUTOPOSTPROCESSER_FREQUENCY:
+    if sickbeard.MEDIAPROCESS_INTERVAL < sickbeard.MIN_MEDIAPROCESS_INTERVAL:
-        sickbeard.AUTOPOSTPROCESSER_FREQUENCY = sickbeard.MIN_AUTOPOSTPROCESSER_FREQUENCY
+        sickbeard.MEDIAPROCESS_INTERVAL = sickbeard.MIN_MEDIAPROCESS_INTERVAL
 
-    sickbeard.autoPostProcesserScheduler.cycleTime = datetime.timedelta(minutes=sickbeard.AUTOPOSTPROCESSER_FREQUENCY)
+    sickbeard.media_process_scheduler.cycleTime = datetime.timedelta(minutes=sickbeard.MEDIAPROCESS_INTERVAL)
-    sickbeard.autoPostProcesserScheduler.set_paused_state()
+    sickbeard.media_process_scheduler.set_paused_state()
 
 
-def schedule_recentsearch(freq):
+def schedule_recentsearch(iv):
-    sickbeard.RECENTSEARCH_FREQUENCY = to_int(freq, default=sickbeard.DEFAULT_RECENTSEARCH_FREQUENCY)
+    sickbeard.RECENTSEARCH_INTERVAL = to_int(iv, default=sickbeard.DEFAULT_RECENTSEARCH_INTERVAL)
 
-    if sickbeard.RECENTSEARCH_FREQUENCY < sickbeard.MIN_RECENTSEARCH_FREQUENCY:
+    if sickbeard.RECENTSEARCH_INTERVAL < sickbeard.MIN_RECENTSEARCH_INTERVAL:
-        sickbeard.RECENTSEARCH_FREQUENCY = sickbeard.MIN_RECENTSEARCH_FREQUENCY
+        sickbeard.RECENTSEARCH_INTERVAL = sickbeard.MIN_RECENTSEARCH_INTERVAL
 
-    sickbeard.recentSearchScheduler.cycleTime = datetime.timedelta(minutes=sickbeard.RECENTSEARCH_FREQUENCY)
+    sickbeard.recent_search_scheduler.cycleTime = datetime.timedelta(minutes=sickbeard.RECENTSEARCH_INTERVAL)
 
 
-def schedule_backlog(freq):
+def schedule_backlog(iv):
-    sickbeard.BACKLOG_FREQUENCY = minimax(freq, sickbeard.DEFAULT_BACKLOG_FREQUENCY,
+    sickbeard.BACKLOG_PERIOD = minimax(iv, sickbeard.DEFAULT_BACKLOG_PERIOD,
-                                          sickbeard.MIN_BACKLOG_FREQUENCY, sickbeard.MAX_BACKLOG_FREQUENCY)
+                                       sickbeard.MIN_BACKLOG_PERIOD, sickbeard.MAX_BACKLOG_PERIOD)
 
-    sickbeard.backlogSearchScheduler.action.cycleTime = sickbeard.BACKLOG_FREQUENCY
+    sickbeard.backlog_search_scheduler.action.cycleTime = sickbeard.BACKLOG_PERIOD
 
 
-def schedule_update(freq):
+def schedule_update(iv):
-    sickbeard.UPDATE_FREQUENCY = to_int(freq, default=sickbeard.DEFAULT_UPDATE_FREQUENCY)
+    sickbeard.UPDATE_INTERVAL = to_int(iv, default=sickbeard.DEFAULT_UPDATE_INTERVAL)
 
-    if sickbeard.UPDATE_FREQUENCY < sickbeard.MIN_UPDATE_FREQUENCY:
+    if sickbeard.UPDATE_INTERVAL < sickbeard.MIN_UPDATE_INTERVAL:
-        sickbeard.UPDATE_FREQUENCY = sickbeard.MIN_UPDATE_FREQUENCY
+        sickbeard.UPDATE_INTERVAL = sickbeard.MIN_UPDATE_INTERVAL
 
-    sickbeard.versionCheckScheduler.cycleTime = datetime.timedelta(hours=sickbeard.UPDATE_FREQUENCY)
+    sickbeard.version_check_scheduler.cycleTime = datetime.timedelta(hours=sickbeard.UPDATE_INTERVAL)
 
 
 def schedule_version_notify(version_notify):
@@ -195,13 +195,13 @@ def schedule_version_notify(version_notify):
         sickbeard.NEWEST_VERSION_STRING = None
 
     if not old_setting and version_notify:
-        sickbeard.versionCheckScheduler.action.run()
+        sickbeard.version_check_scheduler.action.run()
 
 
 def schedule_download_propers(download_propers):
     if sickbeard.DOWNLOAD_PROPERS != download_propers:
         sickbeard.DOWNLOAD_PROPERS = download_propers
-        sickbeard.properFinderScheduler.set_paused_state()
+        sickbeard.proper_finder_scheduler.set_paused_state()
 
 
 def schedule_trakt(use_trakt):
@@ -210,12 +210,12 @@ def schedule_trakt(use_trakt):
 
     sickbeard.USE_TRAKT = use_trakt
     # if sickbeard.USE_TRAKT:
-    #     sickbeard.traktCheckerScheduler.start()
+    #     sickbeard.trakt_checker_scheduler.start()
     # else:
-    #     sickbeard.traktCheckerScheduler.stop()
+    #     sickbeard.trakt_checker_scheduler.stop()
     #     logger.log(u'Waiting for the TRAKTCHECKER thread to exit')
     #     try:
-    #         sickbeard.traktCheckerScheduler.join(10)
+    #         sickbeard.trakt_checker_scheduler.join(10)
     #     except:
     #         pass
 
@@ -223,29 +223,29 @@ def schedule_trakt(use_trakt):
 def schedule_subtitles(use_subtitles):
     if sickbeard.USE_SUBTITLES != use_subtitles:
         sickbeard.USE_SUBTITLES = use_subtitles
-        sickbeard.subtitlesFinderScheduler.set_paused_state()
+        sickbeard.subtitles_finder_scheduler.set_paused_state()
 
 
 def schedule_emby_watched(emby_watched_interval):
-    emby_watched_freq = minimax(emby_watched_interval, sickbeard.DEFAULT_WATCHEDSTATE_FREQUENCY,
+    emby_watched_iv = minimax(emby_watched_interval, sickbeard.DEFAULT_WATCHEDSTATE_INTERVAL,
-                                0, sickbeard.MAX_WATCHEDSTATE_FREQUENCY)
+                              0, sickbeard.MAX_WATCHEDSTATE_INTERVAL)
-    if emby_watched_freq and emby_watched_freq != sickbeard.EMBY_WATCHEDSTATE_FREQUENCY:
+    if emby_watched_iv and emby_watched_iv != sickbeard.EMBY_WATCHEDSTATE_INTERVAL:
-        sickbeard.EMBY_WATCHEDSTATE_FREQUENCY = emby_watched_freq
+        sickbeard.EMBY_WATCHEDSTATE_INTERVAL = emby_watched_iv
-        sickbeard.embyWatchedStateScheduler.cycleTime = datetime.timedelta(minutes=emby_watched_freq)
+        sickbeard.emby_watched_state_scheduler.cycleTime = datetime.timedelta(minutes=emby_watched_iv)
 
-    sickbeard.EMBY_WATCHEDSTATE_SCHEDULED = bool(emby_watched_freq)
+    sickbeard.EMBY_WATCHEDSTATE_SCHEDULED = bool(emby_watched_iv)
-    sickbeard.embyWatchedStateScheduler.set_paused_state()
+    sickbeard.emby_watched_state_scheduler.set_paused_state()
 
 
 def schedule_plex_watched(plex_watched_interval):
-    plex_watched_freq = minimax(plex_watched_interval, sickbeard.DEFAULT_WATCHEDSTATE_FREQUENCY,
+    plex_watched_iv = minimax(plex_watched_interval, sickbeard.DEFAULT_WATCHEDSTATE_INTERVAL,
-                                0, sickbeard.MAX_WATCHEDSTATE_FREQUENCY)
+                              0, sickbeard.MAX_WATCHEDSTATE_INTERVAL)
-    if plex_watched_freq and plex_watched_freq != sickbeard.PLEX_WATCHEDSTATE_FREQUENCY:
+    if plex_watched_iv and plex_watched_iv != sickbeard.PLEX_WATCHEDSTATE_INTERVAL:
-        sickbeard.PLEX_WATCHEDSTATE_FREQUENCY = plex_watched_freq
+        sickbeard.PLEX_WATCHEDSTATE_INTERVAL = plex_watched_iv
-        sickbeard.plexWatchedStateScheduler.cycleTime = datetime.timedelta(minutes=plex_watched_freq)
+        sickbeard.plex_watched_state_scheduler.cycleTime = datetime.timedelta(minutes=plex_watched_iv)
 
-    sickbeard.PLEX_WATCHEDSTATE_SCHEDULED = bool(plex_watched_freq)
+    sickbeard.PLEX_WATCHEDSTATE_SCHEDULED = bool(plex_watched_iv)
-    sickbeard.plexWatchedStateScheduler.set_paused_state()
+    sickbeard.plex_watched_state_scheduler.set_paused_state()
 
 
 def check_section(cfg, section):
@@ -467,7 +467,7 @@ class ConfigMigrator(object):
                                 7: 'Rename coming episodes to episode view',
                                 8: 'Disable searches on start',
                                 9: 'Rename pushbullet variables',
-                                10: 'Reset backlog frequency to default',
+                                10: 'Reset backlog interval to default',
                                 11: 'Migrate anime split view to new layout',
                                 12: 'Add "hevc" and some non-english languages to ignore words if not found',
                                 13: 'Change default dereferrer url to blank',
@@ -478,6 +478,7 @@ class ConfigMigrator(object):
                                 18: 'Update "Spanish" ignore word',
                                 19: 'Change (mis)use of Anonymous redirect dereferer.org service to nullrefer.com',
                                 20: 'Change Growl',
+                                21: 'Rename vars misusing frequency',
                                 }
 
     def migrate_config(self):
@@ -746,12 +747,12 @@ class ConfigMigrator(object):
 
     # Migration v6: Rename daily search to recent search
     def _migrate_v6(self):
-        sickbeard.RECENTSEARCH_FREQUENCY = check_setting_int(self.config_obj, 'General', 'dailysearch_frequency',
+        sickbeard.RECENTSEARCH_INTERVAL = check_setting_int(self.config_obj, 'General', 'dailysearch_frequency',
-                                                             sickbeard.DEFAULT_RECENTSEARCH_FREQUENCY)
+                                                            sickbeard.DEFAULT_RECENTSEARCH_INTERVAL)
 
         sickbeard.RECENTSEARCH_STARTUP = bool(check_setting_int(self.config_obj, 'General', 'dailysearch_startup', 1))
-        if sickbeard.RECENTSEARCH_FREQUENCY < sickbeard.MIN_RECENTSEARCH_FREQUENCY:
+        if sickbeard.RECENTSEARCH_INTERVAL < sickbeard.MIN_RECENTSEARCH_INTERVAL:
-            sickbeard.RECENTSEARCH_FREQUENCY = sickbeard.MIN_RECENTSEARCH_FREQUENCY
+            sickbeard.RECENTSEARCH_INTERVAL = sickbeard.MIN_RECENTSEARCH_INTERVAL
 
         for curProvider in sickbeard.providers.sortedProviderList():
             if hasattr(curProvider, 'enable_recentsearch'):
@@ -778,8 +779,8 @@ class ConfigMigrator(object):
 
     @staticmethod
     def _migrate_v10():
-        # reset backlog frequency to default
+        # reset backlog interval to default
-        sickbeard.BACKLOG_FREQUENCY = sickbeard.DEFAULT_BACKLOG_FREQUENCY
+        sickbeard.BACKLOG_PERIOD = sickbeard.DEFAULT_BACKLOG_PERIOD
 
     def _migrate_v11(self):
         if check_setting_int(self.config_obj, 'ANIME', 'anime_split_home', ''):
@@ -889,3 +890,26 @@ class ConfigMigrator(object):
         GROWL_PASSWORD = check_setting_str(self.config_obj, 'Growl', 'growl_password', '')
         if GROWL_PASSWORD:
             sickbeard.GROWL_HOST = '%s@%s' % (GROWL_PASSWORD, GROWL_HOST)
+
+    def _migrate_v21(self):
+        sickbeard.MEDIAPROCESS_INTERVAL = check_setting_int(
+            self.config_obj, 'General', 'autopostprocesser_frequency', sickbeard.DEFAULT_MEDIAPROCESS_INTERVAL)
+        sickbeard.BACKLOG_PERIOD = check_setting_int(
+            self.config_obj, 'General', 'backlog_frequency', sickbeard.DEFAULT_BACKLOG_PERIOD)
+        sickbeard.BACKLOG_LIMITED_PERIOD = check_setting_int(self.config_obj, 'General', 'backlog_days', 7)
+        sickbeard.RECENTSEARCH_INTERVAL = check_setting_int(
+            self.config_obj, 'General', 'recentsearch_frequency', sickbeard.DEFAULT_RECENTSEARCH_INTERVAL)
+        sickbeard.UPDATE_INTERVAL = check_setting_int(
+            self.config_obj, 'General', 'update_frequency', sickbeard.DEFAULT_UPDATE_INTERVAL)
+
+        sickbeard.EMBY_WATCHEDSTATE_INTERVAL = minimax(check_setting_int(
+            self.config_obj, 'Emby', 'emby_watchedstate_frequency', sickbeard.DEFAULT_WATCHEDSTATE_INTERVAL),
+            sickbeard.DEFAULT_WATCHEDSTATE_INTERVAL, sickbeard.MIN_WATCHEDSTATE_INTERVAL,
+            sickbeard.MAX_WATCHEDSTATE_INTERVAL)
+        sickbeard.PLEX_WATCHEDSTATE_INTERVAL = minimax(check_setting_int(
+            self.config_obj, 'Plex', 'plex_watchedstate_frequency', sickbeard.DEFAULT_WATCHEDSTATE_INTERVAL),
+            sickbeard.DEFAULT_WATCHEDSTATE_INTERVAL, sickbeard.MIN_WATCHEDSTATE_INTERVAL,
+            sickbeard.MAX_WATCHEDSTATE_INTERVAL)
+
+        sickbeard.SUBTITLES_FINDER_INTERVAL = check_setting_int(
+            self.config_obj, 'Subtitles', 'subtitles_finder_frequency', 1)

sickbeard/failedProcessor.py

@@ -97,7 +97,7 @@ class FailedProcessor(LegacyFailedProcessor):
             segment = parsed.show_obj.get_episode(parsed.season_number, episode)
 
             cur_failed_queue_item = search_queue.FailedQueueItem(parsed.show_obj, [segment])
-            sickbeard.searchQueueScheduler.action.add_item(cur_failed_queue_item)
+            sickbeard.search_queue_scheduler.action.add_item(cur_failed_queue_item)
 
         return True
 

sickbeard/image_cache.py

@@ -322,12 +322,12 @@ class ImageCache(object):
                                   ['imsg_%s_%s' % ((image_type, self.FANART)[None is image_type], provider)])
 
         if sql_result:
-            minutes_freq = 60 * 3
+            minutes_iv = 60 * 3
-            # daily_freq = 60 * 60 * 23
+            # daily_interval = 60 * 60 * 23
-            freq = minutes_freq
+            iv = minutes_iv
             now_stamp = int(timestamp_near(datetime.datetime.now()))
             the_time = int(sql_result[0]['time'])
-            return now_stamp - the_time > freq
+            return now_stamp - the_time > iv
 
         return True
 

sickbeard/metadata/kodi.py

@@ -420,8 +420,8 @@ def set_nfo_uid_updated(*args, **kwargs):
     from .. import db
     if not db.DBConnection().has_flag('kodi_nfo_uid'):
         db.DBConnection().set_flag('kodi_nfo_uid')
-    sickbeard.showQueueScheduler.action.remove_event(sickbeard.show_queue.DAILY_SHOW_UPDATE_FINISHED_EVENT,
+    sickbeard.show_queue_scheduler.action.remove_event(sickbeard.show_queue.DAILY_SHOW_UPDATE_FINISHED_EVENT,
-                                                     set_nfo_uid_updated)
+                                                       set_nfo_uid_updated)
 
 
 def remove_default_attr(*args, **kwargs):

sickbeard/properFinder.py

@@ -57,7 +57,7 @@ def search_propers(provider_proper_obj=None):
 
     logger.log(('Checking Propers from recent search', 'Beginning search for new Propers')[None is provider_proper_obj])
 
-    age_shows, age_anime = sickbeard.BACKLOG_DAYS + 2, 14
+    age_shows, age_anime = sickbeard.BACKLOG_LIMITED_PERIOD + 2, 14
     aired_since_shows = datetime.datetime.now() - datetime.timedelta(days=age_shows)
     aired_since_anime = datetime.datetime.now() - datetime.timedelta(days=age_anime)
     recent_shows, recent_anime = _recent_history(aired_since_shows, aired_since_anime)
@@ -74,7 +74,7 @@ def search_propers(provider_proper_obj=None):
     if None is provider_proper_obj:
         _set_last_proper_search(datetime.datetime.now())
 
-        proper_sch = sickbeard.properFinderScheduler
+        proper_sch = sickbeard.proper_finder_scheduler
         if None is proper_sch.start_time:
             run_in = proper_sch.lastRun + proper_sch.cycleTime - datetime.datetime.now()
             run_at = ', next check '
@@ -572,7 +572,7 @@ def get_needed_qualites(needed=None):
     if not sickbeard.DOWNLOAD_PROPERS or needed.all_needed:
         return needed
 
-    age_shows, age_anime = sickbeard.BACKLOG_DAYS + 2, 14
+    age_shows, age_anime = sickbeard.BACKLOG_LIMITED_PERIOD + 2, 14
     aired_since_shows = datetime.datetime.now() - datetime.timedelta(days=age_shows)
     aired_since_anime = datetime.datetime.now() - datetime.timedelta(days=age_anime)
 
@@ -671,7 +671,7 @@ def _set_last_proper_search(when):
 
 
 def next_proper_timeleft():
-    return sickbeard.properFinderScheduler.timeLeft()
+    return sickbeard.proper_finder_scheduler.timeLeft()
 
 
 def get_last_proper_search():

sickbeard/providers/alpharatio.py

@@ -33,7 +33,7 @@ class AlphaRatioProvider(generic.TorrentProvider):
 
     def __init__(self):
 
-        generic.TorrentProvider.__init__(self, 'AlphaRatio', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'AlphaRatio', cache_update_iv=15)
 
         self.url_base = 'https://alpharatio.cc/'
         self.urls = {'config_provider_home_uri': self.url_base,

sickbeard/providers/bb.py

@@ -33,7 +33,7 @@ class BBProvider(generic.TorrentProvider):
 
     def __init__(self):
 
-        generic.TorrentProvider.__init__(self, 'bB', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'bB', cache_update_iv=15)
 
         self.url_base = [re.sub(r'(?i)[qx\sz]+', '', x[::-1]) for x in [
             'HaQ', 'c0Rz', 'MH', 'yL6', 'NW Yi9', 'pJmbv', 'Hd', 'buMz', 'wLn J3', '=xXx=']]

sickbeard/providers/bithdtv.py

@@ -30,7 +30,7 @@ from six import iteritems
 class BitHDTVProvider(generic.TorrentProvider):
 
     def __init__(self):
-        generic.TorrentProvider.__init__(self, 'BitHDTV', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'BitHDTV', cache_update_iv=15)
 
         self.url_home = ['https://www.bit-hdtv.com/']
 

sickbeard/providers/btn.py

@@ -368,13 +368,11 @@ class BTNProvider(generic.TorrentProvider):
 class BTNCache(tvcache.TVCache):
 
     def __init__(self, this_provider):
-        tvcache.TVCache.__init__(self, this_provider)
+        tvcache.TVCache.__init__(self, this_provider, interval=15)
-
-        self.update_freq = 15
 
     def _cache_data(self, **kwargs):
 
-        return self.provider.cache_data(age=self._getLastUpdate().timetuple(), min_time=self.update_freq)
+        return self.provider.cache_data(age=self._getLastUpdate().timetuple(), min_time=self.update_iv)
 
 
 provider = BTNProvider()

sickbeard/providers/funfile.py

@@ -31,7 +31,7 @@ from six import iteritems
 class FunFileProvider(generic.TorrentProvider):
 
     def __init__(self):
-        generic.TorrentProvider.__init__(self, 'FunFile', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'FunFile', cache_update_iv=15)
 
         self.url_base = 'https://www.funfile.org/'
         self.urls = {'config_provider_home_uri': self.url_base,

sickbeard/providers/generic.py

@@ -1488,7 +1488,7 @@ class NZBProvider(GenericProvider):
             if self.should_skip(log_warning=False):
                 break
 
-            search_params = {'q': search_terms[index], 'maxage': sickbeard.BACKLOG_DAYS + 2}
+            search_params = {'q': search_terms[index], 'maxage': sickbeard.BACKLOG_LIMITED_PERIOD + 2}
             # if alt_search:
             #
             #     if do_search_alt:
@@ -1534,15 +1534,15 @@ class NZBProvider(GenericProvider):
 
 class TorrentProvider(GenericProvider):
 
-    def __init__(self, name, supports_backlog=True, anime_only=False,  cache_update_freq=7, update_freq=None):
+    def __init__(self, name, supports_backlog=True, anime_only=False, cache_update_iv=7, update_iv=None):
         # type: (AnyStr, bool, bool, int, Optional[int]) -> None
         """
 
         :param name: provider name
         :param supports_backlog: supports backlog
         :param anime_only: is anime only
-        :param cache_update_freq:
+        :param cache_update_iv:
-        :param update_freq:
+        :param update_iv:
         """
         GenericProvider.__init__(self, name, supports_backlog, anime_only)
 
@@ -1553,9 +1553,9 @@ class TorrentProvider(GenericProvider):
         self._url = None
         self.urls = {}  # type: Dict[AnyStr]
         self.cache._cache_data = self._cache_data
-        if cache_update_freq:
+        if cache_update_iv:
-            self.cache.update_freq = cache_update_freq
+            self.cache.update_iv = cache_update_iv
-        self.ping_freq = update_freq
+        self.ping_iv = update_iv
         self.ping_skip = None
         self._reject_seed = None
         self._reject_leech = None
@@ -2120,9 +2120,9 @@ class TorrentProvider(GenericProvider):
             if self.ping_skip:
                 self.ping_skip -= 1
             else:
-                self.ping_skip = ((60*60) // self.ping_freq, None)[self._authorised()]
+                self.ping_skip = ((60*60) // self.ping_iv, None)[self._authorised()]
 
-            self._sleep_with_stop(self.ping_freq)
+            self._sleep_with_stop(self.ping_iv)
 
     def get_result(self, ep_obj_list, url):
         # type: (List[TVEpisode], AnyStr) -> Optional[NZBSearchResult, TorrentSearchResult]

sickbeard/providers/grabtheinfo.py

@@ -30,7 +30,7 @@ from six import iteritems
 class GrabTheInfoProvider(generic.TorrentProvider):
 
     def __init__(self):
-        generic.TorrentProvider.__init__(self, 'GrabTheInfo', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'GrabTheInfo', cache_update_iv=15)
 
         self.url_base = 'http://grabthe.info/'
         self.urls = {'config_provider_home_uri': self.url_base,

sickbeard/providers/hdbits.py

@@ -34,7 +34,7 @@ from _23 import urlencode
 class HDBitsProvider(generic.TorrentProvider):
 
     def __init__(self):
-        generic.TorrentProvider.__init__(self, 'HDBits', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'HDBits', cache_update_iv=15)
 
         # api_spec: https://hdbits.org/wiki/API
         self.url_base = 'https://hdbits.org/'

sickbeard/providers/hdspace.py

@@ -32,7 +32,7 @@ from six import iteritems
 class HDSpaceProvider(generic.TorrentProvider):
 
     def __init__(self):
-        generic.TorrentProvider.__init__(self, 'HDSpace', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'HDSpace', cache_update_iv=15)
 
         self.url_base = 'https://hd-space.org/'
         self.urls = {'config_provider_home_uri': self.url_base,

sickbeard/providers/morethan.py

@@ -33,7 +33,7 @@ from six import iteritems
 class MoreThanProvider(generic.TorrentProvider):
 
     def __init__(self):
-        generic.TorrentProvider.__init__(self, 'MoreThan', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'MoreThan', cache_update_iv=15)
 
         self.url_base = 'https://www.morethan.tv/'
         self.urls = {'config_provider_home_uri': self.url_base,

sickbeard/providers/nebulance.py

@@ -31,7 +31,7 @@ from six import iteritems
 class NebulanceProvider(generic.TorrentProvider):
 
     def __init__(self):
-        generic.TorrentProvider.__init__(self, 'Nebulance', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'Nebulance', cache_update_iv=15)
 
         self.url_base = 'https://nebulance.io/'
         self.urls = {'config_provider_home_uri': self.url_base,

sickbeard/providers/newznab.py

@@ -1083,7 +1083,7 @@ class NewznabProvider(generic.NZBProvider):
             if self.should_skip(log_warning=False):
                 break
 
-            search_params = {'q': search_terms[index], 'maxage': sickbeard.BACKLOG_DAYS + 2}
+            search_params = {'q': search_terms[index], 'maxage': sickbeard.BACKLOG_LIMITED_PERIOD + 2}
             # if alt_search:
             #
             #     if do_search_alt:
@@ -1145,9 +1145,7 @@ class NewznabProvider(generic.NZBProvider):
 class NewznabCache(tvcache.TVCache):
 
     def __init__(self, provider):
-        tvcache.TVCache.__init__(self, provider)
+        tvcache.TVCache.__init__(self, provider, interval=5)
-
-        self.update_freq = 5  # type: int
 
     # helper method to read the namespaces from xml
     @staticmethod
@@ -1178,7 +1176,7 @@ class NewznabCache(tvcache.TVCache):
         :param needed: needed qualites class
         :param kwargs:
         """
-        if 4489 != sickbeard.RECENTSEARCH_FREQUENCY or self.should_update():
+        if 4489 != sickbeard.RECENTSEARCH_INTERVAL or self.should_update():
             n_spaces = {}
             try:
                 check = self._checkAuth()

sickbeard/providers/omgwtfnzbs.py

@@ -434,18 +434,19 @@ class OmgwtfnzbsCache(tvcache.TVCache):
         tvcache.TVCache.__init__(self, this_provider)
 
     @property
-    def update_freq(self):
+    def update_iv(self):
         try:
+            # noinspection PyProtectedMember
             ca = ':' == self.provider._check_auth()[6]
         except (BaseException, Exception):
             ca = False
         try:
-            return (10, 20 + randint(0, min(40, sickbeard.RECENTSEARCH_FREQUENCY * 3)))[ca]
+            return (10, 20 + randint(0, min(40, sickbeard.RECENTSEARCH_INTERVAL * 3)))[ca]
         except (BaseException, Exception):
             return 20
 
-    @update_freq.setter
+    @update_iv.setter
-    def update_freq(self, v):
+    def update_iv(self, v):
         return
 
     def _cache_data(self, **kwargs):

sickbeard/providers/rsstorrent.py

@@ -29,7 +29,7 @@ class TorrentRssProvider(generic.TorrentProvider):
 
     def __init__(self, name, url, cookies='', search_mode='eponly', search_fallback=False,
                  enable_recentsearch=True, enable_backlog=True):
-        generic.TorrentProvider.__init__(self, name, cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, name, cache_update_iv=15)
         self.enable_backlog = bool(try_int(enable_backlog))
         # no use for rss, so disable by removal after init uses it
         delattr(self, 'enable_scheduled_backlog')

sickbeard/providers/scenehd.py

@@ -30,7 +30,7 @@ from six import iteritems
 class SceneHDProvider(generic.TorrentProvider):
 
     def __init__(self):
-        generic.TorrentProvider.__init__(self, 'SceneHD', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'SceneHD', cache_update_iv=15)
 
         self.url_home = ['https://scenehd.org/']
 

sickbeard/providers/shazbat.py

@@ -34,7 +34,7 @@ class ShazbatProvider(generic.TorrentProvider):
 
     def __init__(self):
 
-        generic.TorrentProvider.__init__(self, 'Shazbat', cache_update_freq=15)
+        generic.TorrentProvider.__init__(self, 'Shazbat', cache_update_iv=15)
 
         self.url_base = 'https://www.shazbat.tv/'
         self.urls = {'config_provider_home_uri': self.url_base,

sickbeard/providers/speedcd.py

@@ -32,7 +32,7 @@ from six import string_types, iteritems
 class SpeedCDProvider(generic.TorrentProvider):
 
     def __init__(self):
-        generic.TorrentProvider.__init__(self, 'SpeedCD', update_freq=4*60)
+        generic.TorrentProvider.__init__(self, 'SpeedCD', update_iv=4 * 60)
 
         self.url_home = ['https://speed.cd/']
 

sickbeard/providers/tokyotoshokan.py

@@ -107,9 +107,7 @@ class TokyoToshokanProvider(generic.TorrentProvider):
 class TokyoToshokanCache(tvcache.TVCache):
 
     def __init__(self, this_provider):
-        tvcache.TVCache.__init__(self, this_provider)
+        tvcache.TVCache.__init__(self, this_provider, interval=15)
-
-        self.update_freq = 15
 
     def _cache_data(self, **kwargs):
 

sickbeard/search_backlog.py

@@ -81,7 +81,7 @@ class BacklogSearcher(object):
     def __init__(self):
 
         self._lastBacklog = self._get_last_backlog()
-        self.cycleTime = sickbeard.BACKLOG_FREQUENCY
+        self.cycleTime = sickbeard.BACKLOG_PERIOD
         self.lock = threading.Lock()
         self.amActive = False  # type: bool
         self.amPaused = False  # type: bool
@@ -136,7 +136,7 @@ class BacklogSearcher(object):
                         segment[0].show_obj, segment,
                         standard_backlog=standard_backlog, limited_backlog=limited_backlog,
                         forced=forced, torrent_only=torrent_only)
-                    sickbeard.searchQueueScheduler.action.add_item(backlog_queue_item)
+                    sickbeard.search_queue_scheduler.action.add_item(backlog_queue_item)
 
     @staticmethod
     def change_backlog_parts(old_count, new_count):
@@ -225,12 +225,12 @@ class BacklogSearcher(object):
 
         cur_date = datetime.date.today().toordinal()
         from_date = datetime.date.fromordinal(1)
-        limited_from_date = datetime.date.today() - datetime.timedelta(days=sickbeard.BACKLOG_DAYS)
+        limited_from_date = datetime.date.today() - datetime.timedelta(days=sickbeard.BACKLOG_LIMITED_PERIOD)
 
         limited_backlog = False
         if standard_backlog and (any_torrent_enabled or sickbeard.BACKLOG_NOFULL):
             logger.log(u'Running limited backlog for episodes missed during the last %s day(s)' %
-                       str(sickbeard.BACKLOG_DAYS))
+                       str(sickbeard.BACKLOG_LIMITED_PERIOD))
             from_date = limited_from_date
             limited_backlog = True
 
@@ -265,7 +265,7 @@ class BacklogSearcher(object):
 
         parts = []
         if standard_backlog and not any_torrent_enabled and not continued_backlog and not sickbeard.BACKLOG_NOFULL:
-            fullbacklogparts = sum([len(w) for w in wanted_list if w]) // sickbeard.BACKLOG_FREQUENCY
+            fullbacklogparts = sum([len(w) for w in wanted_list if w]) // sickbeard.BACKLOG_PERIOD
             h_part = []
             counter = 0
             for w in wanted_list:  # type: Dict

sickbeard/search_propers.py

@@ -36,6 +36,6 @@ class ProperSearcher(object):
         self.amActive = True
 
         propersearch_queue_item = sickbeard.search_queue.ProperSearchQueueItem()
-        sickbeard.searchQueueScheduler.action.add_item(propersearch_queue_item)
+        sickbeard.search_queue_scheduler.action.add_item(propersearch_queue_item)
 
         self.amActive = False

sickbeard/search_queue.py

@@ -348,7 +348,7 @@ class RecentSearchQueueItem(generic_queue.QueueItem):
         if propers:
             logger.log('Found Proper/Repack/Real in recent search, sending data to properfinder')
             propersearch_queue_item = sickbeard.search_queue.ProperSearchQueueItem(provider_proper_obj=propers)
-            sickbeard.searchQueueScheduler.action.add_item(propersearch_queue_item)
+            sickbeard.search_queue_scheduler.action.add_item(propersearch_queue_item)
 
     @staticmethod
     def _change_missing_episodes():

sickbeard/search_recent.py

@@ -31,6 +31,6 @@ class RecentSearcher(object):
         self.amActive = True
 
         recentsearch_queue_item = sickbeard.search_queue.RecentSearchQueueItem()
-        sickbeard.searchQueueScheduler.action.add_item(recentsearch_queue_item)
+        sickbeard.search_queue_scheduler.action.add_item(recentsearch_queue_item)
 
         self.amActive = False

sickbeard/show_queue.py

@@ -57,7 +57,7 @@ class ShowQueue(generic_queue.GenericQueue):
 
     def check_events(self):
         if self.daily_update_running and \
-                not (self.isShowUpdateRunning() or sickbeard.showUpdateScheduler.action.amActive):
+                not (self.isShowUpdateRunning() or sickbeard.show_update_scheduler.action.amActive):
             self.execute_events(DAILY_SHOW_UPDATE_FINISHED_EVENT)
             self.daily_update_running = False
 
@@ -448,8 +448,8 @@ class ShowQueueItem(generic_queue.QueueItem):
         """
         :rtype: bool
         """
-        return self in sickbeard.showQueueScheduler.action.queue + [
+        return self in sickbeard.show_queue_scheduler.action.queue + [
-            sickbeard.showQueueScheduler.action.currentItem]
+            sickbeard.show_queue_scheduler.action.currentItem]
 
     def _getName(self):
         """
@@ -803,11 +803,11 @@ class QueueItemAdd(ShowQueueItem):
 
         # if sickbeard.USE_TRAKT:
         #     # if there are specific episodes that need to be added by trakt
-        #     sickbeard.traktCheckerScheduler.action.manageNewShow(self.show_obj)
+        #     sickbeard.trakt_checker_scheduler.action.manageNewShow(self.show_obj)
         #
         #     # add show to trakt.tv library
         #     if sickbeard.TRAKT_SYNC:
-        #         sickbeard.traktCheckerScheduler.action.addShowToTraktLibrary(self.show_obj)
+        #         sickbeard.trakt_checker_scheduler.action.addShowToTraktLibrary(self.show_obj)
 
         # Load XEM data to DB for show
         sickbeard.scene_numbering.xem_refresh(self.show_obj.tvid, self.show_obj.prodid, force=True)
@@ -855,7 +855,7 @@ class QueueItemAdd(ShowQueueItem):
         # if started with WANTED eps then run the backlog
         if WANTED == self.default_status or items_wanted:
             logger.log('Launching backlog for this show since episodes are WANTED')
-            sickbeard.backlogSearchScheduler.action.search_backlog([self.show_obj])
+            sickbeard.backlog_search_scheduler.action.search_backlog([self.show_obj])
             ui.notifications.message('Show added/search', 'Adding and searching for episodes of' + msg)
         else:
             ui.notifications.message('Show added', 'Adding' + msg)
@@ -1021,8 +1021,8 @@ class QueueItemUpdate(ShowQueueItem):
         if not sickbeard.TVInfoAPI(self.show_obj.tvid).config['active']:
             logger.log('TV info source %s is marked inactive, aborting update for show %s and continue with refresh.'
                        % (sickbeard.TVInfoAPI(self.show_obj.tvid).config['name'], self.show_obj.name))
-            sickbeard.showQueueScheduler.action.refreshShow(self.show_obj, self.force, self.scheduled_update,
+            sickbeard.show_queue_scheduler.action.refreshShow(self.show_obj, self.force, self.scheduled_update,
-                                                            after_update=True)
+                                                              after_update=True)
             return
 
         logger.log('Beginning update of %s' % self.show_obj.name)
@@ -1104,9 +1104,9 @@ class QueueItemUpdate(ShowQueueItem):
 
         if self.priority != generic_queue.QueuePriorities.NORMAL:
             self.kwargs['priority'] = self.priority
-        sickbeard.showQueueScheduler.action.refreshShow(self.show_obj, self.force, self.scheduled_update,
+        sickbeard.show_queue_scheduler.action.refreshShow(self.show_obj, self.force, self.scheduled_update,
-                                                        after_update=True, force_image_cache=self.force_web,
+                                                          after_update=True, force_image_cache=self.force_web,
-                                                        **self.kwargs)
+                                                          **self.kwargs)
 
 
 class QueueItemForceUpdate(QueueItemUpdate):

sickbeard/show_updater.py

@@ -186,12 +186,12 @@ class ShowUpdater(object):
                     # otherwise just refresh
                     if cur_show_obj.should_update(update_date=update_date) \
                             or cur_show_obj.tvid_prodid in stale_should_update:
-                        cur_queue_item = sickbeard.showQueueScheduler.action.updateShow(cur_show_obj,
+                        cur_queue_item = sickbeard.show_queue_scheduler.action.updateShow(cur_show_obj,
-                                                                                        scheduled_update=True)
+                                                                                          scheduled_update=True)
                     else:
                         logger.log(u'Not updating episodes for show %s because it\'s marked as ended and last/next'
                                    u' episode is not within the grace period.' % cur_show_obj.name, logger.DEBUG)
-                        cur_queue_item = sickbeard.showQueueScheduler.action.refreshShow(cur_show_obj, True, True)
+                        cur_queue_item = sickbeard.show_queue_scheduler.action.refreshShow(cur_show_obj, True, True)
 
                     pi_list.append(cur_queue_item)
 
@@ -199,7 +199,7 @@ class ShowUpdater(object):
                     logger.log(u'Automatic update failed: ' + ex(e), logger.ERROR)
 
             if len(pi_list):
-                sickbeard.showQueueScheduler.action.daily_update_running = True
+                sickbeard.show_queue_scheduler.action.daily_update_running = True
 
             ui.ProgressIndicators.setIndicator('dailyUpdate', ui.QueueProgressIndicator('Daily Update', pi_list))
 

sickbeard/traktChecker.py

@@ -184,10 +184,10 @@ class TraktChecker(object):
                 else:
                     helpers.chmod_as_parent(showPath)
 
-                sickbeard.showQueueScheduler.action.addShow(int(tvid), int(prod_id), showPath, status,
+                sickbeard.show_queue_scheduler.action.addShow(int(tvid), int(prod_id), showPath, status,
-                                                            int(sickbeard.QUALITY_DEFAULT),
+                                                              int(sickbeard.QUALITY_DEFAULT),
-                                                            int(sickbeard.FLATTEN_FOLDERS_DEFAULT),
+                                                              int(sickbeard.FLATTEN_FOLDERS_DEFAULT),
-                                                            paused=sickbeard.TRAKT_START_PAUSED)
+                                                              paused=sickbeard.TRAKT_START_PAUSED)
             else:
                 logger.log(u"There was an error creating the show, no root directory setting found", logger.ERROR)
                 return
@@ -210,7 +210,7 @@ class TraktChecker(object):
                 ep_obj.save_to_db()
 
             backlog_queue_item = search_queue.BacklogQueueItem(show_obj, [ep_obj])
-            sickbeard.searchQueueScheduler.action.add_item(backlog_queue_item)
+            sickbeard.search_queue_scheduler.action.add_item(backlog_queue_item)
 
             logger.log(u"Starting backlog for " + show_obj.name + " season " + str(
                     s) + " episode " + str(e) + " because some eps were set to wanted")

sickbeard/tv.py

@@ -1771,7 +1771,7 @@ class TVShow(TVShowBase):
 
         # force the update
         try:
-            sickbeard.showQueueScheduler.action.updateShow(
+            sickbeard.show_queue_scheduler.action.updateShow(
                 self, force=True, web=True, priority=QueuePriorities.VERYHIGH, pausestatus_after=pausestatus_after)
         except exceptions_helper.CantUpdateException as e:
             logger.log('Unable to update this show. %s' % ex(e), logger.ERROR)

sickbeard/tvcache.py

@@ -54,12 +54,12 @@ class CacheDBConnection(db.DBConnection):
 
 
 class TVCache(object):
-    def __init__(self, provider):
+    def __init__(self, provider, interval=10):
-
+        # type: (AnyStr, int) -> None
         self.provider = provider
         self.providerID = self.provider.get_id()
         self.providerDB = None
-        self.update_freq = 10  # type: int
+        self.update_iv = interval
 
     @staticmethod
     def get_db():
@@ -255,7 +255,7 @@ class TVCache(object):
         :rtype: bool
         """
         # if we've updated recently then skip the update
-        return datetime.datetime.now() - self.lastUpdate >= datetime.timedelta(minutes=self.update_freq)
+        return datetime.datetime.now() - self.lastUpdate >= datetime.timedelta(minutes=self.update_iv)
 
     def should_clear_cache(self):
         """

sickbeard/ui.py

@@ -167,7 +167,7 @@ class QueueProgressIndicator(object):
 
     def nextName(self):
         for curItem in [
-                           sickbeard.showQueueScheduler.action.currentItem] + sickbeard.showQueueScheduler.action.queue:
+                           sickbeard.show_queue_scheduler.action.currentItem] + sickbeard.show_queue_scheduler.action.queue:
             if curItem in self.queueItemList:
                 return curItem.name
 

sickbeard/version_checker.py

@@ -60,7 +60,7 @@ class CheckVersion(object):
             if sickbeard.AUTO_UPDATE:
                 logger.log(u'New update found for SickGear, starting auto-updater...')
                 ui.notifications.message('New update found for SickGear, starting auto-updater')
-                if sickbeard.versionCheckScheduler.action.update():
+                if sickbeard.version_check_scheduler.action.update():
                     logger.log(u'Update was successful!')
                     ui.notifications.message('Update was successful')
                     sickbeard.events.put(sickbeard.events.SystemEvent.RESTART)

sickbeard/watchedstate.py

@@ -30,13 +30,13 @@ class WatchedStateUpdater(object):
 
     @property
     def prevent_run(self):
-        return sickbeard.watchedStateQueueScheduler.action.is_in_queue(self.queue_item)
+        return sickbeard.watched_state_queue_scheduler.action.is_in_queue(self.queue_item)
 
     def run(self):
         if self.is_enabled():
             self.amActive = True
             new_item = self.queue_item()
-            sickbeard.watchedStateQueueScheduler.action.add_item(new_item)
+            sickbeard.watched_state_queue_scheduler.action.add_item(new_item)
             self.amActive = False
 
 

sickbeard/webapi.py

@@ -1257,7 +1257,7 @@ class CMD_SickGearEpisodeSearch(ApiCall):
 
         # make a queue item for it and put it on the queue
         ep_queue_item = search_queue.ManualSearchQueueItem(show_obj, ep_obj)
-        sickbeard.searchQueueScheduler.action.add_item(ep_queue_item)
+        sickbeard.search_queue_scheduler.action.add_item(ep_queue_item)
 
         # wait until the queue item tells us whether it worked or not
         while None is ep_queue_item.success:
@@ -1408,7 +1408,7 @@ class CMD_SickGearEpisodeSetStatus(ApiCall):
         if start_backlog:
             for season, segment in iteritems(segments):  # type: int, List[TVEpisode]
                 backlog_queue_item = search_queue.BacklogQueueItem(show_obj, segment)
-                sickbeard.searchQueueScheduler.action.add_item(backlog_queue_item)
+                sickbeard.search_queue_scheduler.action.add_item(backlog_queue_item)
 
                 self.log(u"Starting backlog for " + show_obj.name + " season " + str(
                     season) + " because some episodes were set to WANTED")
@@ -2079,9 +2079,9 @@ class CMD_SickGearCheckScheduler(ApiCall):
         my_db = db.DBConnection()
         sql_result = my_db.select("SELECT last_backlog FROM info")
 
-        backlogPaused = sickbeard.searchQueueScheduler.action.is_backlog_paused()
+        backlogPaused = sickbeard.search_queue_scheduler.action.is_backlog_paused()
-        backlogRunning = sickbeard.searchQueueScheduler.action.is_backlog_in_progress()
+        backlogRunning = sickbeard.search_queue_scheduler.action.is_backlog_in_progress()
-        nextBacklog = sickbeard.backlogSearchScheduler.next_run().strftime(dateFormat)
+        nextBacklog = sickbeard.backlog_search_scheduler.next_run().strftime(dateFormat)
 
         data = {"backlog_is_paused": int(backlogPaused), "backlog_is_running": int(backlogRunning),
                 "last_backlog": _ordinal_to_dateForm(sql_result[0]["last_backlog"]),
@@ -2177,16 +2177,16 @@ class CMD_SickGearForceSearch(ApiCall):
     def run(self):
         """ force the specified search type to run """
         result = None
-        if 'recent' == self.searchtype and not sickbeard.searchQueueScheduler.action.is_recentsearch_in_progress() \
+        if 'recent' == self.searchtype and not sickbeard.search_queue_scheduler.action.is_recentsearch_in_progress() \
-                and not sickbeard.recentSearchScheduler.action.amActive:
+                and not sickbeard.recent_search_scheduler.action.amActive:
-            result = sickbeard.recentSearchScheduler.forceRun()
+            result = sickbeard.recent_search_scheduler.forceRun()
-        elif 'backlog' == self.searchtype and not sickbeard.searchQueueScheduler.action.is_backlog_in_progress() \
+        elif 'backlog' == self.searchtype and not sickbeard.search_queue_scheduler.action.is_backlog_in_progress() \
-                and not sickbeard.backlogSearchScheduler.action.amActive:
+                and not sickbeard.backlog_search_scheduler.action.amActive:
-            sickbeard.backlogSearchScheduler.force_search(force_type=FORCED_BACKLOG)
+            sickbeard.backlog_search_scheduler.force_search(force_type=FORCED_BACKLOG)
             result = True
-        elif 'proper' == self.searchtype and not sickbeard.searchQueueScheduler.action.is_propersearch_in_progress() \
+        elif 'proper' == self.searchtype and not sickbeard.search_queue_scheduler.action.is_propersearch_in_progress() \
-                and not sickbeard.properFinderScheduler.action.amActive:
+                and not sickbeard.proper_finder_scheduler.action.amActive:
-            result = sickbeard.properFinderScheduler.forceRun()
+            result = sickbeard.proper_finder_scheduler.forceRun()
         if result:
             return _responds(RESULT_SUCCESS, msg='%s search successfully forced' % self.searchtype)
         return _responds(RESULT_FAILURE,
@@ -2217,7 +2217,7 @@ class CMD_SickGearSearchQueue(ApiCall):
 
     def run(self):
         """ get a list of the sickgear search queue states """
-        return _responds(RESULT_SUCCESS, sickbeard.searchQueueScheduler.action.queue_length())
+        return _responds(RESULT_SUCCESS, sickbeard.search_queue_scheduler.action.queue_length())
 
 
 class CMD_SickGearGetDefaults(ApiCall):
@@ -2435,10 +2435,10 @@ class CMD_SickGearPauseBacklog(ApiCall):
     def run(self):
         """ pause the backlog search """
         if self.pause:
-            sickbeard.searchQueueScheduler.action.pause_backlog()
+            sickbeard.search_queue_scheduler.action.pause_backlog()
             return _responds(RESULT_SUCCESS, msg="Backlog paused")
         else:
-            sickbeard.searchQueueScheduler.action.unpause_backlog()
+            sickbeard.search_queue_scheduler.action.unpause_backlog()
             return _responds(RESULT_SUCCESS, msg="Backlog unpaused")
 
 
@@ -3373,9 +3373,9 @@ class CMD_SickGearShowAddExisting(ApiCall):
         if iqualityID or aqualityID:
             newQuality = Quality.combineQualities(iqualityID, aqualityID)
 
-        sickbeard.showQueueScheduler.action.addShow(int(self.tvid), int(self.prodid), self.location, SKIPPED,
+        sickbeard.show_queue_scheduler.action.addShow(int(self.tvid), int(self.prodid), self.location, SKIPPED,
-                                                    newQuality, int(self.flatten_folders),
+                                                      newQuality, int(self.flatten_folders),
-                                                    upgrade_once=self.upgradeonce)
+                                                      upgrade_once=self.upgradeonce)
 
         return _responds(RESULT_SUCCESS, {"name": indexerName}, indexerName + " has been queued to be added")
 
@@ -3533,10 +3533,10 @@ class CMD_SickGearShowAddNew(ApiCall):
             else:
                 helpers.chmod_as_parent(showPath)
 
-        sickbeard.showQueueScheduler.action.addShow(int(self.tvid), int(self.prodid), showPath, newStatus,
+        sickbeard.show_queue_scheduler.action.addShow(int(self.tvid), int(self.prodid), showPath, newStatus,
-                                                    newQuality,
+                                                      newQuality,
-                                                    int(self.flatten_folders), self.lang, self.subtitles, self.anime,
+                                                      int(self.flatten_folders), self.lang, self.subtitles, self.anime,
-                                                    self.scene, new_show=True, upgrade_once=self.upgradeonce)
+                                                      self.scene, new_show=True, upgrade_once=self.upgradeonce)
 
         return _responds(RESULT_SUCCESS, {"name": indexerName}, indexerName + " has been queued to be added")
 
@@ -3657,8 +3657,8 @@ class CMD_SickGearShowDelete(ApiCall):
         if not show_obj:
             return _responds(RESULT_FAILURE, msg="Show not found")
 
-        if sickbeard.showQueueScheduler.action.isBeingAdded(
+        if sickbeard.show_queue_scheduler.action.isBeingAdded(
-                show_obj) or sickbeard.showQueueScheduler.action.isBeingUpdated(show_obj):
+                show_obj) or sickbeard.show_queue_scheduler.action.isBeingUpdated(show_obj):
             return _responds(RESULT_FAILURE, msg="Show can not be deleted while being added or updated")
 
         show_obj.delete_show(full=self.full_delete)
@@ -4015,7 +4015,7 @@ class CMD_SickGearShowRefresh(ApiCall):
             return _responds(RESULT_FAILURE, msg="Show not found")
 
         try:
-            sickbeard.showQueueScheduler.action.refreshShow(show_obj)
+            sickbeard.show_queue_scheduler.action.refreshShow(show_obj)
             return _responds(RESULT_SUCCESS, msg="%s has queued to be refreshed" % show_obj.name)
         except exceptions_helper.CantRefreshException as e:
             # TODO: log the exception
@@ -4436,7 +4436,7 @@ class CMD_SickGearShowUpdate(ApiCall):
             return _responds(RESULT_FAILURE, msg="Show not found")
 
         try:
-            sickbeard.showQueueScheduler.action.updateShow(show_obj, True)
+            sickbeard.show_queue_scheduler.action.updateShow(show_obj, True)
             return _responds(RESULT_SUCCESS, msg="%s has queued to be updated" % show_obj.name)
         except exceptions_helper.CantUpdateException as e:
             self.log(u"Unable to update %s. %s" % (show_obj.name, ex(e)), logger.ERROR)
@@ -4635,10 +4635,11 @@ class CMD_SickGearShowsForceUpdate(ApiCall):
 
     def run(self):
         """ force the daily show update now """
-        if sickbeard.showQueueScheduler.action.isShowUpdateRunning() or sickbeard.showUpdateScheduler.action.amActive:
+        if sickbeard.show_queue_scheduler.action.isShowUpdateRunning() \
+                or sickbeard.show_update_scheduler.action.amActive:
             return _responds(RESULT_FAILURE, msg="show update already running.")
 
-        result = sickbeard.showUpdateScheduler.forceRun()
+        result = sickbeard.show_update_scheduler.forceRun()
         if result:
             return _responds(RESULT_SUCCESS, msg="daily show update started")
         return _responds(RESULT_FAILURE, msg="can't start show update currently")
@@ -4655,7 +4656,7 @@ class CMD_SickGearShowsQueue(ApiCall):
 
     def run(self):
         """ list the show update queue """
-        return _responds(RESULT_SUCCESS, sickbeard.showQueueScheduler.action.queue_length())
+        return _responds(RESULT_SUCCESS, sickbeard.show_queue_scheduler.action.queue_length())
 
 
 class CMD_SickGearShowsStats(ApiCall):

sickbeard/webserve.py

@@ -1151,8 +1151,8 @@ class MainHandler(WebHandler):
 
         now = datetime.datetime.now()
         events = [
-            ('recent', sickbeard.recentSearchScheduler.timeLeft),
+            ('recent', sickbeard.recent_search_scheduler.timeLeft),
-            ('backlog', sickbeard.backlogSearchScheduler.next_backlog_timeleft),
+            ('backlog', sickbeard.backlog_search_scheduler.next_backlog_timeleft),
         ]
 
         if sickbeard.DOWNLOAD_PROPERS:
@@ -1821,7 +1821,7 @@ class Home(MainHandler):
 
     def check_update(self):
         # force a check to see if there is a new version
-        if sickbeard.versionCheckScheduler.action.check_for_new_version(force=True):
+        if sickbeard.version_check_scheduler.action.check_for_new_version(force=True):
             logger.log(u'Forcing version check')
 
         self.redirect('/home/')
@@ -1896,7 +1896,7 @@ class Home(MainHandler):
         if str(pid) != str(sickbeard.PID):
             return self.redirect('/home/')
 
-        if sickbeard.versionCheckScheduler.action.update():
+        if sickbeard.version_check_scheduler.action.update():
             return self.restart(pid)
 
         return self._generic_message('Update Failed',
@@ -1910,7 +1910,7 @@ class Home(MainHandler):
     def pull_request_checkout(self, branch):
         pull_request = branch
         branch = branch.split(':')[1]
-        fetched = sickbeard.versionCheckScheduler.action.fetch(pull_request)
+        fetched = sickbeard.version_check_scheduler.action.fetch(pull_request)
         if fetched:
             sickbeard.BRANCH = branch
             ui.notifications.message('Checking out branch: ', branch)
@@ -1982,25 +1982,25 @@ class Home(MainHandler):
 
         show_message = ''
 
-        if sickbeard.showQueueScheduler.action.isBeingAdded(show_obj):
+        if sickbeard.show_queue_scheduler.action.isBeingAdded(show_obj):
             show_message = 'This show is in the process of being downloaded - the info below is incomplete.'
 
-        elif sickbeard.showQueueScheduler.action.isBeingUpdated(show_obj):
+        elif sickbeard.show_queue_scheduler.action.isBeingUpdated(show_obj):
             show_message = 'The information on this page is in the process of being updated.'
 
-        elif sickbeard.showQueueScheduler.action.isBeingRefreshed(show_obj):
+        elif sickbeard.show_queue_scheduler.action.isBeingRefreshed(show_obj):
             show_message = 'The episodes below are currently being refreshed from disk'
 
-        elif sickbeard.showQueueScheduler.action.isBeingSubtitled(show_obj):
+        elif sickbeard.show_queue_scheduler.action.isBeingSubtitled(show_obj):
             show_message = 'Currently downloading subtitles for this show'
 
-        elif sickbeard.showQueueScheduler.action.isInRefreshQueue(show_obj):
+        elif sickbeard.show_queue_scheduler.action.isInRefreshQueue(show_obj):
             show_message = 'This show is queued to be refreshed.'
 
-        elif sickbeard.showQueueScheduler.action.isInUpdateQueue(show_obj):
+        elif sickbeard.show_queue_scheduler.action.isInUpdateQueue(show_obj):
             show_message = 'This show is queued and awaiting an update.'
 
-        elif sickbeard.showQueueScheduler.action.isInSubtitleQueue(show_obj):
+        elif sickbeard.show_queue_scheduler.action.isInSubtitleQueue(show_obj):
             show_message = 'This show is queued and awaiting subtitles download.'
 
         if 0 != show_obj.not_found_count:
@@ -2013,8 +2013,8 @@ class Home(MainHandler):
                 % (sickbeard.WEB_ROOT, tvid_prodid, show_obj.prodid)
                 + ('', '<br>%s' % show_message)[0 < len(show_message)])
         t.force_update = 'home/update-show?tvid_prodid=%s&amp;force=1&amp;web=1' % tvid_prodid
-        if not sickbeard.showQueueScheduler.action.isBeingAdded(show_obj):
+        if not sickbeard.show_queue_scheduler.action.isBeingAdded(show_obj):
-            if not sickbeard.showQueueScheduler.action.isBeingUpdated(show_obj):
+            if not sickbeard.show_queue_scheduler.action.isBeingUpdated(show_obj):
                 t.submenu.append(
                     {'title': 'Remove',
                      'path': 'home/delete-show?tvid_prodid=%s' % tvid_prodid, 'confirm': True})
@@ -2037,7 +2037,7 @@ class Home(MainHandler):
                 t.submenu.append(
                     {'title': 'Media Rename',
                      'path': 'home/rename-media?tvid_prodid=%s' % tvid_prodid})
-                if sickbeard.USE_SUBTITLES and not sickbeard.showQueueScheduler.action.isBeingSubtitled(
+                if sickbeard.USE_SUBTITLES and not sickbeard.show_queue_scheduler.action.isBeingSubtitled(
                         show_obj) and show_obj.subtitles:
                     t.submenu.append(
                         {'title': 'Download Subtitles',
@@ -2619,7 +2619,7 @@ class Home(MainHandler):
             if bool(show_obj.flatten_folders) != bool(flatten_folders):
                 show_obj.flatten_folders = flatten_folders
                 try:
-                    sickbeard.showQueueScheduler.action.refreshShow(show_obj)
+                    sickbeard.show_queue_scheduler.action.refreshShow(show_obj)
                 except exceptions_helper.CantRefreshException as e:
                     errors.append('Unable to refresh this show: ' + ex(e))
 
@@ -2674,7 +2674,7 @@ class Home(MainHandler):
                     try:
                         show_obj.location = new_path
                         try:
-                            sickbeard.showQueueScheduler.action.refreshShow(show_obj)
+                            sickbeard.show_queue_scheduler.action.refreshShow(show_obj)
                         except exceptions_helper.CantRefreshException as e:
                             errors.append('Unable to refresh this show:' + ex(e))
                             # grab updated info from TVDB
@@ -2691,7 +2691,7 @@ class Home(MainHandler):
         # force the update
         if do_update:
             try:
-                sickbeard.showQueueScheduler.action.updateShow(show_obj, True)
+                sickbeard.show_queue_scheduler.action.updateShow(show_obj, True)
                 helpers.cpu_sleep()
             except exceptions_helper.CantUpdateException:
                 errors.append('Unable to force an update on the show.')
@@ -2729,13 +2729,13 @@ class Home(MainHandler):
         if None is show_obj:
             return self._generic_message('Error', 'Unable to find the specified show')
 
-        if sickbeard.showQueueScheduler.action.isBeingAdded(
+        if sickbeard.show_queue_scheduler.action.isBeingAdded(
-                show_obj) or sickbeard.showQueueScheduler.action.isBeingUpdated(show_obj):
+                show_obj) or sickbeard.show_queue_scheduler.action.isBeingUpdated(show_obj):
             return self._generic_message("Error", "Shows can't be deleted while they're being added or updated.")
 
         # if sickbeard.USE_TRAKT and sickbeard.TRAKT_SYNC:
         #     # remove show from trakt.tv library
-        #     sickbeard.traktCheckerScheduler.action.removeShowFromTraktLibrary(show_obj)
+        #     sickbeard.trakt_checker_scheduler.action.removeShowFromTraktLibrary(show_obj)
 
         show_obj.delete_show(bool(full))
 
@@ -2756,7 +2756,7 @@ class Home(MainHandler):
 
         # force the update from the DB
         try:
-            sickbeard.showQueueScheduler.action.refreshShow(show_obj)
+            sickbeard.show_queue_scheduler.action.refreshShow(show_obj)
         except exceptions_helper.CantRefreshException as e:
             ui.notifications.error('Unable to refresh this show.', ex(e))
 
@@ -2776,7 +2776,7 @@ class Home(MainHandler):
 
         # force the update
         try:
-            sickbeard.showQueueScheduler.action.updateShow(show_obj, bool(force), bool(web))
+            sickbeard.show_queue_scheduler.action.updateShow(show_obj, bool(force), bool(web))
         except exceptions_helper.CantUpdateException as e:
             ui.notifications.error('Unable to update this show.',
                                    ex(e))
@@ -2797,7 +2797,7 @@ class Home(MainHandler):
 
         # search and download subtitles
         if sickbeard.USE_SUBTITLES:
-            sickbeard.showQueueScheduler.action.download_subtitles(show_obj)
+            sickbeard.show_queue_scheduler.action.download_subtitles(show_obj)
 
             helpers.cpu_sleep()
 
@@ -2935,7 +2935,7 @@ class Home(MainHandler):
                 for season, segment in iteritems(segments):  # type: int, List[sickbeard.tv.TVEpisode]
                     if not show_obj.paused:
                         cur_backlog_queue_item = search_queue.BacklogQueueItem(show_obj, segment)
-                        sickbeard.searchQueueScheduler.action.add_item(cur_backlog_queue_item)
+                        sickbeard.search_queue_scheduler.action.add_item(cur_backlog_queue_item)
 
                     if season not in season_wanted:
                         season_wanted += [season]
@@ -2959,7 +2959,7 @@ class Home(MainHandler):
 
             for season, segment in iteritems(segments):  # type: int, List[sickbeard.tv.TVEpisode]
                 cur_failed_queue_item = search_queue.FailedQueueItem(show_obj, segment)
-                sickbeard.searchQueueScheduler.action.add_item(cur_failed_queue_item)
+                sickbeard.search_queue_scheduler.action.add_item(cur_failed_queue_item)
 
                 msg += '<li>Season %s</li>' % season
                 logger.log(u'Retrying search for %s season %s because some eps were set to failed' %
@@ -3090,7 +3090,7 @@ class Home(MainHandler):
             ep_queue_item = (search_queue.ManualSearchQueueItem(ep_obj.show_obj, ep_obj),
                              search_queue.FailedQueueItem(ep_obj.show_obj, [ep_obj]))[retry]
 
-            sickbeard.searchQueueScheduler.action.add_item(ep_queue_item)
+            sickbeard.search_queue_scheduler.action.add_item(ep_queue_item)
 
             if None is ep_queue_item.success:  # invocation
                 result.update(dict(result=('success', 'queuing')[not ep_queue_item.started]))
@@ -3111,10 +3111,10 @@ class Home(MainHandler):
         seen_eps = set([])
 
         # Queued searches
-        queued = sickbeard.searchQueueScheduler.action.get_queued_manual(tvid_prodid)
+        queued = sickbeard.search_queue_scheduler.action.get_queued_manual(tvid_prodid)
 
         # Active search
-        active = sickbeard.searchQueueScheduler.action.get_current_manual_item(tvid_prodid)
+        active = sickbeard.search_queue_scheduler.action.get_current_manual_item(tvid_prodid)
 
         # Finished searches
         sickbeard.search_queue.remove_old_fifo(sickbeard.search_queue.MANUAL_SEARCH_HISTORY)
@@ -5039,11 +5039,11 @@ class AddShows(Home):
         prune = config.minimax(prune, 0, 0, 9999)
 
         # add the show
-        sickbeard.showQueueScheduler.action.addShow(tvid, prodid, show_dir, int(default_status), newQuality,
+        sickbeard.show_queue_scheduler.action.addShow(tvid, prodid, show_dir, int(default_status), newQuality,
-                                                    flatten_folders, tvinfo_lang, subs, anime,
+                                                      flatten_folders, tvinfo_lang, subs, anime,
-                                                    scene, None, allowlist, blocklist,
+                                                      scene, None, allowlist, blocklist,
-                                                    wanted_begin, wanted_latest, prune, tag, new_show=new_show,
+                                                      wanted_begin, wanted_latest, prune, tag, new_show=new_show,
-                                                    show_name=show_name, upgrade_once=upgrade_once)
+                                                      show_name=show_name, upgrade_once=upgrade_once)
         # ui.notifications.message('Show added', 'Adding the specified show into ' + show_dir)
 
         return finish_add_show()
@@ -5109,14 +5109,14 @@ class AddShows(Home):
 
             if None is not tvid and None is not prodid:
                 # add the show
-                sickbeard.showQueueScheduler.action.addShow(tvid, prodid, show_dir,
+                sickbeard.show_queue_scheduler.action.addShow(tvid, prodid, show_dir,
-                                                            default_status=sickbeard.STATUS_DEFAULT,
+                                                              default_status=sickbeard.STATUS_DEFAULT,
-                                                            quality=sickbeard.QUALITY_DEFAULT,
+                                                              quality=sickbeard.QUALITY_DEFAULT,
-                                                            flatten_folders=sickbeard.FLATTEN_FOLDERS_DEFAULT,
+                                                              flatten_folders=sickbeard.FLATTEN_FOLDERS_DEFAULT,
-                                                            subtitles=sickbeard.SUBTITLES_DEFAULT,
+                                                              subtitles=sickbeard.SUBTITLES_DEFAULT,
-                                                            anime=sickbeard.ANIME_DEFAULT,
+                                                              anime=sickbeard.ANIME_DEFAULT,
-                                                            scene=sickbeard.SCENE_DEFAULT,
+                                                              scene=sickbeard.SCENE_DEFAULT,
-                                                            show_name=show_name)
+                                                              show_name=show_name)
                 num_added += 1
 
         if num_added:
@@ -5528,7 +5528,7 @@ class Manage(MainHandler):
         show_obj = helpers.find_show_by_id(tvid_prodid)
 
         if show_obj:
-            sickbeard.backlogSearchScheduler.action.search_backlog([show_obj])
+            sickbeard.backlog_search_scheduler.action.search_backlog([show_obj])
 
         self.redirect('/manage/backlog-overview/')
 
@@ -5925,7 +5925,7 @@ class Manage(MainHandler):
 
             if cur_tvid_prodid in to_update:
                 try:
-                    sickbeard.showQueueScheduler.action.updateShow(show_obj, True, True)
+                    sickbeard.show_queue_scheduler.action.updateShow(show_obj, True, True)
                     updates.append(show_obj.name)
                 except exceptions_helper.CantUpdateException as e:
                     errors.append('Unable to update show ' + show_obj.name + ': ' + ex(e))
@@ -5933,17 +5933,17 @@ class Manage(MainHandler):
             # don't bother refreshing shows that were updated anyway
             if cur_tvid_prodid in to_refresh and cur_tvid_prodid not in to_update:
                 try:
-                    sickbeard.showQueueScheduler.action.refreshShow(show_obj)
+                    sickbeard.show_queue_scheduler.action.refreshShow(show_obj)
                     refreshes.append(show_obj.name)
                 except exceptions_helper.CantRefreshException as e:
                     errors.append('Unable to refresh show ' + show_obj.name + ': ' + ex(e))
 
             if cur_tvid_prodid in to_rename:
-                sickbeard.showQueueScheduler.action.renameShowEpisodes(show_obj)
+                sickbeard.show_queue_scheduler.action.renameShowEpisodes(show_obj)
                 renames.append(show_obj.name)
 
             if sickbeard.USE_SUBTITLES and cur_tvid_prodid in to_subtitle:
-                sickbeard.showQueueScheduler.action.download_subtitles(show_obj)
+                sickbeard.show_queue_scheduler.action.download_subtitles(show_obj)
                 subs.append(show_obj.name)
 
         if 0 < len(errors):
@@ -6011,16 +6011,16 @@ class ManageSearch(Manage):
 
     def index(self):
         t = PageTemplate(web_handler=self, file='manage_manageSearches.tmpl')
-        # t.backlog_pi = sickbeard.backlogSearchScheduler.action.get_progress_indicator()
+        # t.backlog_pi = sickbeard.backlog_search_scheduler.action.get_progress_indicator()
-        t.backlog_paused = sickbeard.searchQueueScheduler.action.is_backlog_paused()
+        t.backlog_paused = sickbeard.search_queue_scheduler.action.is_backlog_paused()
         t.scheduled_backlog_active_providers = sickbeard.search_backlog.BacklogSearcher.providers_active(scheduled=True)
-        t.backlog_running = sickbeard.searchQueueScheduler.action.is_backlog_in_progress()
+        t.backlog_running = sickbeard.search_queue_scheduler.action.is_backlog_in_progress()
-        t.backlog_is_active = sickbeard.backlogSearchScheduler.action.am_running()
+        t.backlog_is_active = sickbeard.backlog_search_scheduler.action.am_running()
-        t.standard_backlog_running = sickbeard.searchQueueScheduler.action.is_standard_backlog_in_progress()
+        t.standard_backlog_running = sickbeard.search_queue_scheduler.action.is_standard_backlog_in_progress()
-        t.backlog_running_type = sickbeard.searchQueueScheduler.action.type_of_backlog_in_progress()
+        t.backlog_running_type = sickbeard.search_queue_scheduler.action.type_of_backlog_in_progress()
-        t.recent_search_status = sickbeard.searchQueueScheduler.action.is_recentsearch_in_progress()
+        t.recent_search_status = sickbeard.search_queue_scheduler.action.is_recentsearch_in_progress()
-        t.find_propers_status = sickbeard.searchQueueScheduler.action.is_propersearch_in_progress()
+        t.find_propers_status = sickbeard.search_queue_scheduler.action.is_propersearch_in_progress()
-        t.queue_length = sickbeard.searchQueueScheduler.action.queue_length()
+        t.queue_length = sickbeard.search_queue_scheduler.action.queue_length()
 
         t.submenu = self.manage_menu('Search')
 
@@ -6039,8 +6039,8 @@ class ManageSearch(Manage):
 
     def force_backlog(self):
         # force it to run the next time it looks
-        if not sickbeard.searchQueueScheduler.action.is_standard_backlog_in_progress():
+        if not sickbeard.search_queue_scheduler.action.is_standard_backlog_in_progress():
-            sickbeard.backlogSearchScheduler.force_search(force_type=FORCED_BACKLOG)
+            sickbeard.backlog_search_scheduler.force_search(force_type=FORCED_BACKLOG)
             logger.log(u'Backlog search forced')
             ui.notifications.message('Backlog search started')
 
@@ -6050,8 +6050,8 @@ class ManageSearch(Manage):
     def force_search(self):
 
         # force it to run the next time it looks
-        if not sickbeard.searchQueueScheduler.action.is_recentsearch_in_progress():
+        if not sickbeard.search_queue_scheduler.action.is_recentsearch_in_progress():
-            result = sickbeard.recentSearchScheduler.forceRun()
+            result = sickbeard.recent_search_scheduler.forceRun()
             if result:
                 logger.log(u'Recent search forced')
                 ui.notifications.message('Recent search started')
@@ -6062,7 +6062,7 @@ class ManageSearch(Manage):
     def force_find_propers(self):
 
         # force it to run the next time it looks
-        result = sickbeard.properFinderScheduler.forceRun()
+        result = sickbeard.proper_finder_scheduler.forceRun()
         if result:
             logger.log(u'Find propers search forced')
             ui.notifications.message('Find propers search started')
@@ -6072,9 +6072,9 @@ class ManageSearch(Manage):
 
     def pause_backlog(self, paused=None):
         if '1' == paused:
-            sickbeard.searchQueueScheduler.action.pause_backlog()
+            sickbeard.search_queue_scheduler.action.pause_backlog()
         else:
-            sickbeard.searchQueueScheduler.action.unpause_backlog()
+            sickbeard.search_queue_scheduler.action.unpause_backlog()
 
         time.sleep(5)
         self.redirect('/manage/search-tasks/')
@@ -6084,10 +6084,11 @@ class ShowTasks(Manage):
 
     def index(self):
         t = PageTemplate(web_handler=self, file='manage_showProcesses.tmpl')
-        t.queue_length = sickbeard.showQueueScheduler.action.queue_length()
+        t.queue_length = sickbeard.show_queue_scheduler.action.queue_length()
-        t.next_run = sickbeard.showUpdateScheduler.lastRun.replace(hour=sickbeard.showUpdateScheduler.start_time.hour)
+        t.next_run = sickbeard.show_update_scheduler.lastRun.replace(
-        t.show_update_running = sickbeard.showQueueScheduler.action.isShowUpdateRunning() \
+            hour=sickbeard.show_update_scheduler.start_time.hour)
-            or sickbeard.showUpdateScheduler.action.amActive
+        t.show_update_running = sickbeard.show_queue_scheduler.action.isShowUpdateRunning() \
+            or sickbeard.show_update_scheduler.action.amActive
 
         my_db = db.DBConnection(row_type='dict')
         sql_result = my_db.select('SELECT n.indexer || ? ||  n.indexer_id AS tvid_prodid,'
@@ -6118,7 +6119,7 @@ class ShowTasks(Manage):
 
     def force_show_update(self):
 
-        result = sickbeard.showUpdateScheduler.forceRun()
+        result = sickbeard.show_update_scheduler.forceRun()
         if result:
             logger.log(u'Show Update forced')
             ui.notifications.message('Forced Show Update started')
@@ -6713,7 +6714,7 @@ class History(MainHandler):
 
         for tvid_prodid_dict in refresh:
             try:
-                sickbeard.showQueueScheduler.action.refreshShow(
+                sickbeard.show_queue_scheduler.action.refreshShow(
                     helpers.find_show_by_id(tvid_prodid_dict))
             except (BaseException, Exception):
                 pass
@@ -6980,7 +6981,8 @@ class ConfigGeneral(Config):
                      log_dir=None, web_log=None,
                      indexer_default=None, indexer_timeout=None,
                      show_dirs_with_dots=None,
-                     version_notify=None, auto_update=None, update_frequency=None, notify_on_update=None,
+                     version_notify=None, auto_update=None, update_interval=None, notify_on_update=None,
+                     update_frequency=None,
                      theme_name=None, default_home=None, fanart_limit=None, showlist_tagview=None, show_tags=None,
                      home_search_focus=None, use_imdb_info=None, display_freespace=None, sort_article=None,
                      fuzzy_dating=None, trim_zero=None, date_preset=None, time_preset=None,
@@ -6994,6 +6996,10 @@ class ConfigGeneral(Config):
                      git_path=None, cpu_preset=None, anon_redirect=None, encryption_version=None,
                      proxy_setting=None, proxy_indexers=None, file_logging_preset=None, backup_db_oneday=None):
 
+        # prevent deprecated var issues from existing ui, delete in future, added 2020.11.07
+        if None is update_interval and None is not update_frequency:
+            update_interval = update_frequency
+
         results = []
 
         # Misc
@@ -7001,8 +7007,8 @@ class ConfigGeneral(Config):
         sickbeard.UPDATE_SHOWS_ON_START = config.checkbox_to_value(update_shows_on_start)
         sickbeard.SHOW_UPDATE_HOUR = config.minimax(show_update_hour, 3, 0, 23)
         try:
-            with sickbeard.showUpdateScheduler.lock:
+            with sickbeard.show_update_scheduler.lock:
-                sickbeard.showUpdateScheduler.start_time = datetime.time(hour=sickbeard.SHOW_UPDATE_HOUR)
+                sickbeard.show_update_scheduler.start_time = datetime.time(hour=sickbeard.SHOW_UPDATE_HOUR)
         except (BaseException, Exception) as e:
             logger.log('Could not change Show Update Scheduler time: %s' % ex(e), logger.ERROR)
         sickbeard.TRASH_REMOVE_SHOW = config.checkbox_to_value(trash_remove_show)
@@ -7021,7 +7027,7 @@ class ConfigGeneral(Config):
         # Updates
         config.schedule_version_notify(config.checkbox_to_value(version_notify))
         sickbeard.AUTO_UPDATE = config.checkbox_to_value(auto_update)
-        config.schedule_update(update_frequency)
+        config.schedule_update(update_interval)
         sickbeard.NOTIFY_ON_UPDATE = config.checkbox_to_value(notify_on_update)
 
         # Interface
@@ -7131,7 +7137,7 @@ class ConfigGeneral(Config):
             return json.dumps({'result': 'success', 'pulls': []})
         else:
             try:
-                pulls = sickbeard.versionCheckScheduler.action.list_remote_pulls()
+                pulls = sickbeard.version_check_scheduler.action.list_remote_pulls()
                 return json.dumps({'result': 'success', 'pulls': pulls})
             except (BaseException, Exception) as e:
                 logger.log(u'exception msg: ' + ex(e), logger.DEBUG)
@@ -7140,7 +7146,7 @@ class ConfigGeneral(Config):
     @staticmethod
     def fetch_branches():
         try:
-            branches = sickbeard.versionCheckScheduler.action.list_remote_branches()
+            branches = sickbeard.version_check_scheduler.action.list_remote_branches()
             return json.dumps({'result': 'success', 'branches': branches, 'current': sickbeard.BRANCH or 'master'})
         except (BaseException, Exception) as e:
             logger.log(u'exception msg: ' + ex(e), logger.DEBUG)
@@ -7174,7 +7180,8 @@ class ConfigSearch(Config):
         return t.respond()
 
     def save_search(self, nzb_dir=None, torrent_dir=None,
-                    recentsearch_frequency=None, backlog_frequency=None, backlog_days=None, backlog_nofull=None,
+                    recentsearch_interval=None, backlog_period=None, backlog_limited_period=None, backlog_nofull=None,
+                    recentsearch_frequency=None, backlog_frequency=None, backlog_days=None,
                     use_nzbs=None, use_torrents=None, nzb_method=None, torrent_method=None,
                     usenet_retention=None, ignore_words=None, require_words=None,
                     download_propers=None, propers_webdl_onegrp=None,
@@ -7187,6 +7194,14 @@ class ConfigSearch(Config):
                     torrent_verify_cert=None, torrent_path=None, torrent_seed_time=None, torrent_paused=None,
                     torrent_high_bandwidth=None, torrent_host=None):
 
+        # prevent deprecated var issues from existing ui, delete in future, added 2020.11.07
+        if None is recentsearch_interval and None is not recentsearch_frequency:
+            recentsearch_interval = recentsearch_frequency
+        if None is backlog_period and None is not backlog_frequency:
+            backlog_period = backlog_frequency
+        if None is backlog_limited_period and None is not backlog_days:
+            backlog_limited_period = backlog_days
+
         results = []
 
         if not config.change_nzb_dir(nzb_dir):
@@ -7195,13 +7210,13 @@ class ConfigSearch(Config):
         if not config.change_torrent_dir(torrent_dir):
             results += ['Unable to create directory ' + os.path.normpath(torrent_dir) + ', dir not changed.']
 
-        config.schedule_recentsearch(recentsearch_frequency)
+        config.schedule_recentsearch(recentsearch_interval)
 
-        old_backlog_frequency = sickbeard.BACKLOG_FREQUENCY
+        old_backlog_period = sickbeard.BACKLOG_PERIOD
-        config.schedule_backlog(backlog_frequency)
+        config.schedule_backlog(backlog_period)
         sickbeard.search_backlog.BacklogSearcher.change_backlog_parts(
-            old_backlog_frequency, sickbeard.BACKLOG_FREQUENCY)
+            old_backlog_period, sickbeard.BACKLOG_PERIOD)
-        sickbeard.BACKLOG_DAYS = config.to_int(backlog_days, default=7)
+        sickbeard.BACKLOG_LIMITED_PERIOD = config.to_int(backlog_limited_period, default=7)
 
         sickbeard.BACKLOG_NOFULL = bool(config.checkbox_to_value(backlog_nofull))
         if sickbeard.BACKLOG_NOFULL:
@@ -7286,7 +7301,8 @@ class ConfigMediaProcess(Config):
         t.submenu = self.config_menu('Processing')
         return t.respond()
 
-    def save_post_processing(self, tv_download_dir=None, process_automatically=None, autopostprocesser_frequency=None,
+    def save_post_processing(self, tv_download_dir=None, process_automatically=None, mediaprocess_interval=None,
+                             autopostprocesser_frequency=None,
                              unpack=None, keep_processed_dir=None, process_method=None,
                              extra_scripts='', sg_extra_scripts='',
                              rename_episodes=None, airdate_episodes=None,
@@ -7300,6 +7316,10 @@ class ConfigMediaProcess(Config):
                              naming_anime=None, naming_anime_pattern=None, naming_anime_multi_ep=None,
                              naming_abd_pattern=None, naming_sports_pattern=None):
 
+        # prevent deprecated var issues from existing ui, delete in future, added 2020.11.07
+        if None is mediaprocess_interval and None is not autopostprocesser_frequency:
+            mediaprocess_interval = autopostprocesser_frequency
+
         results = []
 
         if not config.change_tv_download_dir(tv_download_dir):
@@ -7307,7 +7327,7 @@ class ConfigMediaProcess(Config):
 
         new_val = config.checkbox_to_value(process_automatically)
         sickbeard.PROCESS_AUTOMATICALLY = new_val
-        config.schedule_autopostprocesser(autopostprocesser_frequency)
+        config.schedule_mediaprocess(mediaprocess_interval)
 
         if unpack:
             if 'not supported' != self.is_rar_supported():
@@ -7619,7 +7639,7 @@ class ConfigProviders(Config):
     @staticmethod
     def check_providers_ping():
         for p in sickbeard.providers.sortedProviderList():
-            if getattr(p, 'ping_freq', None):
+            if getattr(p, 'ping_iv', None):
                 if p.is_active() and (p.get_id() not in sickbeard.provider_ping_thread_pool
                                       or not sickbeard.provider_ping_thread_pool[p.get_id()].is_alive()):
                     # noinspection PyProtectedMember
@@ -8066,7 +8086,7 @@ class ConfigNotifications(Config):
 
         sickbeard.USE_TRAKT = config.checkbox_to_value(use_trakt)
         sickbeard.TRAKT_UPDATE_COLLECTION = build_config(**kwargs)
-        # sickbeard.traktCheckerScheduler.silent = not sickbeard.USE_TRAKT
+        # sickbeard.trakt_checker_scheduler.silent = not sickbeard.USE_TRAKT
         # sickbeard.TRAKT_DEFAULT_INDEXER = int(trakt_default_indexer)
         # sickbeard.TRAKT_SYNC = config.checkbox_to_value(trakt_sync)
         # sickbeard.TRAKT_USE_WATCHLIST = config.checkbox_to_value(trakt_use_watchlist)
@@ -8159,19 +8179,25 @@ class ConfigSubtitles(Config):
         return t.respond()
 
     def save_subtitles(self, use_subtitles=None, subtitles_languages=None, subtitles_dir=None,
-                       service_order=None, subtitles_history=None, subtitles_finder_frequency=None,
+                       service_order=None, subtitles_history=None, subtitles_finder_interval=None,
+                       subtitles_finder_frequency=None,
                        os_hash=None, os_user='', os_pass=''):
+
+        # prevent deprecated var issues from existing ui, delete in future, added 2020.11.07
+        if None is subtitles_finder_interval and None is not subtitles_finder_frequency:
+            subtitles_finder_interval = subtitles_finder_frequency
+
         results = []
 
-        if '' == subtitles_finder_frequency or None is subtitles_finder_frequency:
+        if '' == subtitles_finder_interval or None is subtitles_finder_interval:
-            subtitles_finder_frequency = 1
+            subtitles_finder_interval = 1
 
         config.schedule_subtitles(config.checkbox_to_value(use_subtitles))
         sickbeard.SUBTITLES_LANGUAGES = [lang.alpha2 for lang in subtitles.is_valid_language(
             subtitles_languages.replace(' ', '').split(','))] if '' != subtitles_languages else ''
         sickbeard.SUBTITLES_DIR = subtitles_dir
         sickbeard.SUBTITLES_HISTORY = config.checkbox_to_value(subtitles_history)
-        sickbeard.SUBTITLES_FINDER_FREQUENCY = config.to_int(subtitles_finder_frequency, default=1)
+        sickbeard.SUBTITLES_FINDER_INTERVAL = config.to_int(subtitles_finder_interval, default=1)
         sickbeard.SUBTITLES_OS_HASH = config.checkbox_to_value(os_hash)
 
         # Subtitles services

sickgear.py

@@ -554,7 +554,7 @@ class SickGear(object):
         # Start an update if we're supposed to
         if self.force_update or sickbeard.UPDATE_SHOWS_ON_START:
             sickbeard.classes.loading_msg.message = 'Starting a forced show update'
-            sickbeard.showUpdateScheduler.action.run()
+            sickbeard.show_update_scheduler.action.run()
 
         sickbeard.classes.loading_msg.message = 'Switching to default web server'
         time.sleep(2)
@@ -686,7 +686,7 @@ class SickGear(object):
 
             if sickbeard.events.SystemEvent.RESTART == ev_type:
 
-                install_type = sickbeard.versionCheckScheduler.action.install_type
+                install_type = sickbeard.version_check_scheduler.action.install_type
 
                 popen_list = []