def execute(self):
generic_queue.QueueItem.execute(self)
episodes = []
for epObj in episodes:
(release, provider) = failed_history.findRelease(self.show, epObj.season, epObj.episode)
if release:
logger.log(u"Marking release as bad: " + release)
failed_history.markFailed(self.show, epObj.season, epObj.episode)
failed_history.logFailed(release)
history.logFailed(self.show.indexerid, epObj.season, epObj.episode, epObj.status, release, provider)
failed_history.revertEpisode(self.show, epObj.season, epObj.episode)
episodes.append(epObj)
# get search results
results = search.searchProviders(self.show, episodes[0].season, episodes)
# download whatever we find
for curResult in results:
self.success = search.snatchEpisode(curResult)
time.sleep(5)
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
for season in self.segment:
sickbeard.searchBacklog.BacklogSearcher.currentSearchInfo = {'title': self.show.name + " Season " + str(season)}
wantedEps = self.segment[season]
# check if we want to search for season packs instead of just season/episode
seasonSearch = False
seasonEps = self.show.getAllEpisodes(season)
if len(seasonEps) == len(wantedEps) and not sickbeard.PREFER_EPISODE_RELEASES:
seasonSearch = True
try:
logger.log("Beginning backlog search for episodes from [" + self.show.name + "] - Season[" + str(season) + "]")
searchResult = search.searchProviders(self, self.show, season, wantedEps, seasonSearch, False)
if searchResult:
SearchQueue().snatch_item(searchResult)
else:
logger.log(u"No needed episodes found during backlog search")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
failed_episodes = []
for season in self.segment:
epObj = self.segment[season]
(release, provider) = failed_history.findRelease(epObj)
if release:
logger.log(u"Marking release as bad: " + release)
failed_history.markFailed(epObj)
failed_history.logFailed(release)
history.logFailed(epObj, release, provider)
failed_history.revertEpisode(epObj)
failed_episodes.append(epObj)
logger.log(
"Beginning failed download search for [" + epObj.prettyName() + "]")
if len(failed_episodes):
try:
searchResult = search.searchProviders(self, self.show, failed_episodes[0].season, failed_episodes, False, True)
if searchResult:
SearchQueue().snatch_item(searchResult)
else:
logger.log(u"No episodes found to retry for failed downloads return from providers!")
except Exception, e:
logger.log(traceback.format_exc(), logger.DEBUG)
def execute(self):
generic_queue.QueueItem.execute(self)
episodes = []
for i, epObj in enumerate(episodes):
# convert indexer numbering to scene numbering for searches
(episodes[i].scene_season, self.episodes[i].scene_episode) = sickbeard.scene_numbering.get_scene_numbering(
self.show.indexerid, self.show.indexer, epObj.season, epObj.episode)
logger.log(
"Beginning failed download search for " + epObj.prettyName() + ' as ' + epObj.prettySceneName())
(release, provider) = failed_history.findRelease(self.show, epObj.season, epObj.episode)
if release:
logger.log(u"Marking release as bad: " + release)
failed_history.markFailed(self.show, epObj.season, epObj.episode)
failed_history.logFailed(release)
history.logFailed(self.show.indexerid, epObj.season, epObj.episode, epObj.status, release, provider)
failed_history.revertEpisode(self.show, epObj.season, epObj.episode)
episodes.append(epObj)
# get search results
results = search.searchProviders(self.show, episodes[0].season, episodes)
# download whatever we find
for curResult in results:
self.success = search.snatchEpisode(curResult)
time.sleep(5)
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
# check if we want to search for season packs instead of just season/episode
seasonSearch = False
seasonEps = self.show.getAllEpisodes(self.segment)
if len(seasonEps) == len(self.wantedEpisodes):
seasonSearch = True
# convert indexer numbering to scene numbering for searches
for i, epObj in enumerate(self.wantedEpisodes):
(self.wantedEpisodes[i].scene_season,
self.wantedEpisodes[i].scene_episode) = sickbeard.scene_numbering.get_scene_numbering(self.show.indexerid,
self.show.indexer,
epObj.season,
epObj.episode)
logger.log(
"Beginning backlog search for " + self.wantedEpisodes[i].prettyName() + ' as ' + self.wantedEpisodes[
i].prettySceneName())
# search for our wanted items and return the results
results = search.searchProviders(self.show, self.segment, self.wantedEpisodes, seasonSearch=seasonSearch)
# download whatever we find
for curResult in results:
search.snatchEpisode(curResult)
time.sleep(5)
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
logger.log("Beginning manual search for " + self.ep_obj.prettyName())
foundResults = search.searchProviders(self.ep_obj.show, self.ep_obj.season, [self.ep_obj], manualSearch=True)
result = False
if not foundResults:
ui.notifications.message('No downloads were found',
"Couldn't find a download for <i>%s</i>" % self.ep_obj.prettyName())
logger.log(u"Unable to find a download for " + self.ep_obj.prettyName())
self.success = result
else:
for foundResult in foundResults:
# just use the first result for now
logger.log(u"Downloading " + foundResult.name + " from " + foundResult.provider.name)
result = search.snatchEpisode(foundResult)
providerModule = foundResult.provider
if not result:
ui.notifications.error('Error while attempting to snatch ' + foundResult.name + ', check your logs')
elif providerModule == None:
ui.notifications.error('Provider is configured incorrectly, unable to download')
self.success = result
def run(self):
generic_queue.QueueItem.run(self)
try:
logger.log(u"Marking episode as bad: [" + self.segment.prettyName() + "]")
failed_history.markFailed(self.segment)
(release, provider) = failed_history.findRelease(self.segment)
if release:
failed_history.logFailed(release)
history.logFailed(self.segment, release, provider)
failed_history.revertEpisode(self.segment)
logger.log("Beginning failed download search for [" + self.segment.prettyName() + "]")
searchResult = search.searchProviders(self.show, [self.segment], True)
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log(u"Downloading " + result.name + " from " + result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
logger.log(u"No valid episode found to retry for [" + self.segment.prettyName() + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
if self.success is None:
self.success = False
self.finish()
def run(self):
generic_queue.QueueItem.run(self)
try:
logger.log("Beginning manual search for: [" + self.segment.prettyName() + "]")
self.started = True
searchResult = search.searchProviders(self.show, [self.segment], True, self.downCurQuality)
if searchResult:
# just use the first result for now
logger.log(u"Downloading " + searchResult[0].name + " from " + searchResult[0].provider.name)
self.success = search.snatchEpisode(searchResult[0])
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
ui.notifications.message('No downloads were found',
"Couldn't find a download for <i>%s</i>" % self.segment.prettyName())
logger.log(u"Unable to find a download for: [" + self.segment.prettyName() + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
### Keep a list with the 100 last executed searches
fifo(MANUAL_SEARCH_HISTORY, self, MANUAL_SEARCH_HISTORY_SIZE)
if self.success is None:
self.success = False
self.finish()
def run(self):
generic_queue.QueueItem.run(self)
if not self.show.paused:
try:
logger.log(u"Beginning backlog search for: [" +
self.show.name + "]")
searchResult = search.searchProviders(self.show, self.segment,
False)
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log(u"Downloading " + result.name + " from " +
result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
logger.log(
u"No needed episodes found during backlog search for: ["
+ self.show.name + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
self.finish()
def process(self, curProvider):
if self.ep_obj.show.air_by_date:
logger.log("Beginning manual search for " + self.ep_obj.prettyABDName())
else:
logger.log("Beginning manual search for " + self.ep_obj.prettyName())
return search.searchProviders(self.ep_obj.show, self.ep_obj.season, [self.ep_obj], curProvider, False, True)
def run(self):
generic_queue.QueueItem.run(self)
try:
logger.log("Beginning manual search for [" +
self.segment.prettyName() + "]")
searchResult = search.searchProviders(self.show,
self.segment.season,
[self.segment], True)
if searchResult:
# just use the first result for now
logger.log(u"Downloading " + searchResult[0].name + " from " +
searchResult[0].provider.name)
self.success = search.snatchEpisode(searchResult[0])
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
ui.notifications.message(
'No downloads were found',
"Couldn't find a download for <i>%s</i>" %
self.segment.prettyName())
logger.log(u"Unable to find a download for " +
self.segment.prettyName())
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
if self.success is None:
self.success = False
self.finish()
def do_test():
"""
Test to perform
"""
global search_items # pylint: disable=global-statement
search_items = cur_data["i"]
show = TVShow(1, tvdb_id)
show.name = show_name
show.quality = cur_data["q"]
show.saveToDB()
sickbeard.showList.append(show)
episode = None
for epNumber in cur_data["e"]:
episode = TVEpisode(show, cur_data["s"], epNumber)
episode.status = common.WANTED
episode.saveToDB()
best_result = search.searchProviders(show, episode.episode,
force_search)
if not best_result:
assert cur_data["b"] == best_result
# pylint: disable=no-member
assert cur_data[
"b"] == best_result.name # first is expected, second is chosen one
def execute(self):
generic_queue.QueueItem.execute(self)
# check if we want to search for season packs instead of just season/episode
seasonSearch = False
seasonEps = self.show.getAllEpisodes(self.segment)
if len(seasonEps) == len(self.wantedEpisodes):
seasonSearch = True
providers = [x for x in sickbeard.providers.sortedProviderList() if x.isActive() and x]
try:
logger.log("Beginning backlog search for episodes from [" + self.show.name + "] - Season[" + str(self.segment) + "]")
searchResult = search.searchProviders(self, self.show, self.segment, self.wantedEpisodes, seasonSearch, False)
if searchResult:
self.success = SearchQueue().snatch_item(searchResult)
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
if not self.success:
logger.log(u"No needed episodes found during backlog search")
self.finish()
def run(self):
generic_queue.QueueItem.run(self)
try:
logger.log("Beginning downloadable search for [" + self.show.name +
"]")
searchResult = search.searchProviders(self.show, self.segment,
"skipEp", False)
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log(u"Marking Available " + result.name + " from " +
result.provider.name)
search.downloadableEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
logger.log(
u"No available episodes found during downloadable search for ["
+ self.show.name + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
if self.success is None:
self.success = False
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
for season in self.segment:
sickbeard.searchBacklog.BacklogSearcher.currentSearchInfo = {
'title': self.show.name + " Season " + str(season)}
wantedEps = self.segment[season]
try:
logger.log("Beginning backlog search for [" + self.show.name + "]")
searchResult = search.searchProviders(self.show, season, wantedEps, False)
# reset thread back to original name
threading.currentThread().name = self.thread_name
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log(u"Downloading " + result.name + " from " + result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
logger.log(u"No needed episodes found during backlog search for [" + self.show.name + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
try:
logger.log("Beginning manual search for [" + self.segment.prettyName() + "]")
searchResult = search.searchProviders(self.show, self.segment.season, [self.segment], True)
# reset thread back to original name
threading.currentThread().name = self.thread_name
if searchResult:
# just use the first result for now
logger.log(u"Downloading " + searchResult[0].name + " from " + searchResult[0].provider.name)
self.success = search.snatchEpisode(searchResult[0])
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
ui.notifications.message('No downloads were found',
"Couldn't find a download for <i>%s</i>" % self.segment.prettyName())
logger.log(u"Unable to find a download for " + self.segment.prettyName())
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
def run(self):
generic_queue.QueueItem.run(self)
try:
for season in self.segment:
sickbeard.searchBacklog.BacklogSearcher.currentSearchInfo = {
'title': self.show.name + " Season " + str(season)
}
wantedEps = self.segment[season]
logger.log("Beginning backlog search for [" + self.show.name +
"]")
searchResult = search.searchProviders(self.show, season,
wantedEps, False)
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log(u"Downloading " + result.name + " from " +
result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
logger.log(
u"No needed episodes found during backlog search for ["
+ self.show.name + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
self.finish()
def run(self):
generic_queue.QueueItem.run(self)
try:
logger.log(u"Beginning manual search for: [" + self.segment.prettyName() + "]")
self.started = True
searchResult = search.searchProviders(self.show, [self.segment], True, self.downCurQuality)
if searchResult:
# just use the first result for now
logger.log(u"Downloading " + searchResult[0].name + " from " + searchResult[0].provider.name)
self.success = search.snatchEpisode(searchResult[0])
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
ui.notifications.message('No downloads were found',
"Couldn't find a download for <i>%s</i>" % self.segment.prettyName())
logger.log(u"Unable to find a download for: [" + self.segment.prettyName() + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
### Keep a list with the 100 last executed searches
fifo(MANUAL_SEARCH_HISTORY, self, MANUAL_SEARCH_HISTORY_SIZE)
if self.success is None:
self.success = False
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
episodes = []
for i, epObj in enumerate(episodes):
(release, provider) = failed_history.findRelease(self.show, epObj.season, epObj.episode)
if release:
logger.log(u"Marking release as bad: " + release)
failed_history.markFailed(self.show, epObj.season, epObj.episode)
failed_history.logFailed(release)
history.logFailed(self.show.indexerid, epObj.season, epObj.episode, epObj.status, release, provider)
failed_history.revertEpisode(self.show, epObj.season, epObj.episode)
episodes.append(epObj)
providers = [x for x in sickbeard.providers.sortedProviderList() if x.isActive()]
try:
logger.log(
"Beginning failed download search for episodes from Season [" + str(self.episodes[0].season) + "]")
searchResult = search.searchProviders(self.show, self.episodes[0].season, self.episodes, False, True)
if searchResult:
self.success = SearchQueue().snatch_item(searchResult)
except Exception, e:
logger.log(traceback.format_exc(), logger.DEBUG)
def execute(self):
generic_queue.QueueItem.execute(self)
for season, episodes in self.segment.items():
for epObj in episodes:
logger.log(u"Marking episode as bad: [" + epObj.prettyName() + "]")
failed_history.markFailed(epObj)
(release, provider) = failed_history.findRelease(epObj)
if release:
failed_history.logFailed(release)
history.logFailed(epObj, release, provider)
failed_history.revertEpisode(epObj)
logger.log("Beginning failed download search for [" + epObj.prettyName() + "]")
try:
searchResult = search.searchProviders(self.show, season, [epObj], True)
# reset thread back to original name
threading.currentThread().name = self.thread_name
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log(u"Downloading " + result.name + " from " + result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
logger.log(u"No valid episode found to retry for [" + epObj.prettyName() + "]")
except Exception, e:
logger.log(traceback.format_exc(), logger.DEBUG)
def execute(self):
generic_queue.QueueItem.execute(self)
for season, episode in self.segment.iteritems():
epObj = self.show.getEpisode(season, episode)
(release,
provider) = failed_history.findRelease(self.show, season, episode)
if release:
logger.log(u"Marking release as bad: " + release)
failed_history.markFailed(self.show, season, episode)
failed_history.logFailed(release)
history.logFailed(self.show.indexerid, season, episode,
epObj.status, release, provider)
failed_history.revertEpisode(self.show, season, episode)
# get search results
results = search.searchProviders(self.show, season, episode)
# download whatever we find
for curResult in results:
self.success = search.snatchEpisode(curResult)
time.sleep(5)
self.finish()
def process(self, curProvider):
# check if we want to search for season packs instead of just season/episode
seasonSearch = False
seasonEps = self.show.getAllEpisodes(self.segment)
if len(seasonEps) == len(self.wantedEpisodes):
seasonSearch = True
return search.searchProviders(self.show, self.segment, self.wantedEpisodes, curProvider, seasonSearch, False)
def run(self):
"""
Run forced search thread
"""
generic_queue.QueueItem.run(self)
self.started = True
try:
logger.log(u"Beginning {0} {1}search for: [{2}]".
format(('forced', 'manual')[bool(self.manual_search)],
('', 'season pack ')[bool(self.manual_search_type == 'season')], self.segment[0].prettyName()))
search_result = search.searchProviders(self.show, self.segment, True, self.downCurQuality,
self.manual_search, self.manual_search_type)
if not self.manual_search and search_result:
# just use the first result for now
if search_result[0].seeders not in (-1, None) and search_result[0].leechers not in (-1, None):
logger.log(u"Downloading {0} with {1} seeders and {2} leechers from {3}".
format(search_result[0].name,
search_result[0].seeders, search_result[0].leechers, search_result[0].provider.name))
else:
logger.log(u"Downloading {0} from {1}".format(search_result[0].name, search_result[0].provider.name))
self.success = search.snatchEpisode(search_result[0])
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
elif self.manual_search and search_result:
self.results = search_result
self.success = True
if self.manual_search_type == 'season':
ui.notifications.message("We have found season pack results for {0}".format(self.show.name),
"These should become visible in the manual select page.")
else:
ui.notifications.message("We have found single results for {0}".format(self.segment[0].prettyName()),
"These should become visible in the manual select page.")
else:
ui.notifications.message('No results were found')
logger.log(u"Unable to find {0} {1}results for: [{2}]".
format(('forced', 'manual')[bool(self.manual_search)],
('', 'season pack ')[bool(self.manual_search_type == 'season')],
self.segment[0].prettyName()))
except Exception:
self.success = False
logger.log(traceback.format_exc(), logger.DEBUG)
# ## Keep a list with the 100 last executed searches
fifo(FORCED_SEARCH_HISTORY, self, FORCED_SEARCH_HISTORY_SIZE)
if self.success is None:
self.success = False
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
results = search.searchProviders(self.show, self.segment)
# download whatever we find
for curResult in results:
search.snatchEpisode(curResult)
time.sleep(5)
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
results = search.searchProviders(self.show, self.segment, self.wantedEpisodes)
# download whatever we find
for curResult in results:
search.snatchEpisode(curResult)
time.sleep(5)
self.finish()
def run(self):
"""
Run failed thread
"""
generic_queue.QueueItem.run(self)
self.started = True
try:
for epObj in self.segment:
logger.log(u"Marking episode as bad: [" + epObj.prettyName() + "]")
failed_history.markFailed(epObj)
(release, provider) = failed_history.findRelease(epObj)
if release:
failed_history.logFailed(release)
history.logFailed(epObj, release, provider)
failed_history.revertEpisode(epObj)
logger.log(u"Beginning failed download search for: [" + epObj.prettyName() + "]")
# If it is wanted, self.downCurQuality doesnt matter
# if it isnt wanted, we need to make sure to not overwrite the existing ep that we reverted to!
search_result = search.searchProviders(self.show, self.segment, True, False, False)
if search_result:
for result in search_result:
# just use the first result for now
if result.seeders not in (-1, None) and result.leechers not in (-1, None):
logger.log(u"Downloading {0} with {1} seeders and {2} leechers from {3}".format(result.name,
result.seeders, result.leechers, result.provider.name))
else:
logger.log(u"Downloading {0} from {1}".format(result.name, result.provider.name))
self.success = search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
logger.log(u"No needed episodes found during failed search for: [" + self.show.name + "]")
except Exception:
self.success = False
logger.log(traceback.format_exc(), logger.DEBUG)
# ## Keep a list with the 100 last executed searches
fifo(FORCED_SEARCH_HISTORY, self, FORCED_SEARCH_HISTORY_SIZE)
if self.success is None:
self.success = False
self.finish()
def run(self):
super(FailedQueueItem, self).run()
self.started = True
try:
for epObj in self.segment:
logger.log("Marking episode as bad: [" + epObj.prettyName() +
"]")
failed_history.markFailed(epObj)
(release, provider) = failed_history.findRelease(epObj)
if release:
failed_history.logFailed(release)
history.logFailed(epObj, release, provider)
failed_history.revertEpisode(epObj)
logger.log("Beginning failed download search for: [" +
epObj.prettyName() + "]")
# If it is wanted, self.downCurQuality doesnt matter
# if it isnt wanted, we need to make sure to not overwrite the existing ep that we reverted to!
searchResult = search.searchProviders(self.show, self.segment,
True, False)
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log("Downloading " + result.name + " from " +
result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
pass
# logger.log(u"No valid episode found to retry for: [" + self.segment.prettyName() + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
# ## Keep a list with the 100 last executed searches
fifo(MANUAL_SEARCH_HISTORY, self, MANUAL_SEARCH_HISTORY_SIZE)
if self.success is None:
self.success = False
super(FailedQueueItem, self).finish()
self.finish()
def run(self):
generic_queue.QueueItem.run(self)
self.started = True
try:
for epObj in self.segment:
logger.log(u'Marking episode as bad: [' + epObj.prettyName() +
']')
failed_history.markFailed(epObj)
(release, provider) = failed_history.findRelease(epObj)
if release:
failed_history.logFailed(release)
history.logFailed(epObj, release, provider)
failed_history.revertEpisode(epObj)
logger.log('Beginning failed download search for: [' +
epObj.prettyName() + ']')
searchResult = search.searchProviders(self.show, self.segment,
True)
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log(u'Downloading ' + result.name + ' from ' +
result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
pass
#logger.log(u"No valid episode found to retry for: [" + self.segment.prettyName() + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
finally:
### Keep a list with the 100 last executed searches
fifo(MANUAL_SEARCH_HISTORY, self, MANUAL_SEARCH_HISTORY_SIZE)
if self.success is None:
self.success = False
self.finish()
def run(self):
super(FailedQueueItem, self).run()
self.started = True
try:
for epObj in self.segment:
logger.log("Marking episode as bad: [" + epObj.pretty_name() + "]")
failed_history.markFailed(epObj)
(release, provider) = failed_history.findRelease(epObj)
if release:
failed_history.logFailed(release)
history.logFailed(epObj, release, provider)
failed_history.revertEpisode(epObj)
logger.log("Beginning failed download search for: [" + epObj.pretty_name() + "]")
# If it is wanted, self.downCurQuality doesnt matter
# if it isnt wanted, we need to make sure to not overwrite the existing ep that we reverted to!
searchResult = search.searchProviders(self.show, self.segment, True, False)
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log("Downloading " + result.name + " from " + result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
pass
# logger.log(u"No valid episode found to retry for: [" + self.segment.pretty_name() + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
# ## Keep a list with the 100 last executed searches
fifo(MANUAL_SEARCH_HISTORY, self, MANUAL_SEARCH_HISTORY_SIZE)
if self.success is None:
self.success = False
super(FailedQueueItem, self).finish()
self.finish()
def test(self):
global searchItems
searchItems = curData["i"]
show = TVShow(1, tvdbdid)
show.name = show_name
show.quality = curData["q"]
show.saveToDB()
sickbeard.showList.append(show)
episode = None
for epNumber in curData["e"]:
episode = TVEpisode(show, curData["s"], epNumber)
episode.status = c.WANTED
episode.saveToDB()
bestResult = search.searchProviders(show, episode.season, episode.episode, forceSearch)
if not bestResult:
self.assertEqual(curData["b"], bestResult)
self.assertEqual(curData["b"], bestResult.name) #first is expected, second is choosen one
def run(self):
generic_queue.QueueItem.run(self)
self.started = True
try:
for epObj in self.segment:
logger.log(u'Marking episode as bad: [' + epObj.prettyName() + ']')
failed_history.markFailed(epObj)
(release, provider) = failed_history.findRelease(epObj)
if release:
failed_history.logFailed(release)
history.logFailed(epObj, release, provider)
failed_history.revertEpisode(epObj)
logger.log('Beginning failed download search for: [' + epObj.prettyName() + ']')
searchResult = search.searchProviders(self.show, self.segment, True)
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log(u'Downloading ' + result.name + ' from ' + result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
pass
#logger.log(u"No valid episode found to retry for: [" + self.segment.prettyName() + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
finally:
### Keep a list with the 100 last executed searches
fifo(MANUAL_SEARCH_HISTORY, self, MANUAL_SEARCH_HISTORY_SIZE)
if self.success is None:
self.success = False
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
try:
logger.log("Beginning manual search for [" + self.ep_obj.prettyName() + "]")
searchResult = search.searchProviders(self, self.show, self.ep_obj.season, [self.ep_obj],False,True)
if searchResult:
self.success = SearchQueue().snatch_item(searchResult)
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
if not self.success:
ui.notifications.message('No downloads were found',
"Couldn't find a download for <i>%s</i>" % self.ep_obj.prettyName())
logger.log(u"Unable to find a download for " + self.ep_obj.prettyName())
self.finish()
def run(self):
generic_queue.QueueItem.run(self)
try:
logger.log("Beginning backlog search for: [" + self.show.name + "]")
searchResult = search.searchProviders(self.show, self.segment, False)
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log(u"Downloading " + result.name + " from " + result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
logger.log(u"No needed episodes found during backlog search for: [" + self.show.name + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
self.finish()
def execute(self):
generic_queue.QueueItem.execute(self)
logger.log("Beginning manual search for " + self.ep_obj.prettyName())
foundResults = search.searchProviders(self.ep_obj.show,
self.ep_obj.season,
self.ep_obj.episode,
manualSearch=True)
result = False
if not foundResults:
ui.notifications.message(
'No downloads were found',
"Couldn't find a download for <i>%s</i>" %
self.ep_obj.prettyName())
logger.log(u"Unable to find a download for " +
self.ep_obj.prettyName())
self.success = result
else:
for foundResult in foundResults:
# just use the first result for now
logger.log(u"Downloading " + foundResult.name + " from " +
foundResult.provider.name)
result = search.snatchEpisode(foundResult)
providerModule = foundResult.provider
if not result:
ui.notifications.error(
'Error while attempting to snatch ' +
foundResult.name + ', check your logs')
elif providerModule == None:
ui.notifications.error(
'Provider is configured incorrectly, unable to download'
)
self.success = result
def run(self):
generic_queue.QueueItem.run(self)
try:
logger.log(u"Marking episode as bad: [" +
self.segment.prettyName() + "]")
failed_history.markFailed(self.segment)
(release, provider) = failed_history.findRelease(self.segment)
if release:
failed_history.logFailed(release)
history.logFailed(self.segment, release, provider)
failed_history.revertEpisode(self.segment)
logger.log("Beginning failed download search for: [" +
self.segment.prettyName() + "]")
searchResult = search.searchProviders(self.show, [self.segment],
True)
if searchResult:
for result in searchResult:
# just use the first result for now
logger.log(u"Downloading " + result.name + " from " +
result.provider.name)
search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
logger.log(u"No valid episode found to retry for: [" +
self.segment.prettyName() + "]")
except Exception:
logger.log(traceback.format_exc(), logger.DEBUG)
if self.success is None:
self.success = False
self.finish()
def process(self, curProvider):
episodes = []
for i, epObj in enumerate(episodes):
time.sleep(0.01)
if epObj.show.air_by_date:
logger.log("Beginning manual search for " + epObj.prettyABDName())
else:
logger.log(
"Beginning failed download search for " + epObj.prettyName())
(release, provider) = failed_history.findRelease(self.show, epObj.season, epObj.episode)
if release:
logger.log(u"Marking release as bad: " + release)
failed_history.markFailed(self.show, epObj.season, epObj.episode)
failed_history.logFailed(release)
history.logFailed(self.show.indexerid, epObj.season, epObj.episode, epObj.status, release, provider)
failed_history.revertEpisode(self.show, epObj.season, epObj.episode)
episodes.append(epObj)
return search.searchProviders(self.show, self.episodes[0].season, self.episodes, curProvider, False, False)
def do_test():
"""
Test to perform
"""
global search_items # pylint: disable=global-statement
search_items = cur_data["i"]
show = TVShow(1, tvdb_id)
show.name = show_name
show.quality = cur_data["q"]
show.saveToDB()
sickbeard.showList.append(show)
episode = None
for epNumber in cur_data["e"]:
episode = TVEpisode(show, cur_data["s"], epNumber)
episode.status = common.WANTED
episode.saveToDB()
best_result = search.searchProviders(show, episode.episode, force_search)
if not best_result:
assert cur_data["b"] == best_result
# pylint: disable=no-member
assert cur_data["b"] == best_result.name # first is expected, second is chosen one
def execute(self):
generic_queue.QueueItem.execute(self)
for season, episode in self.segment.iteritems():
epObj = self.show.getEpisode(season, episode)
(release, provider) = failed_history.findRelease(self.show, season, episode)
if release:
logger.log(u"Marking release as bad: " + release)
failed_history.markFailed(self.show, season, episode)
failed_history.logFailed(release)
history.logFailed(self.show.indexerid, season, episode, epObj.status, release, provider)
failed_history.revertEpisode(self.show, season, episode)
# get search results
results = search.searchProviders(self.show, season, episode)
# download whatever we find
for curResult in results:
self.success = search.snatchEpisode(curResult)
time.sleep(5)
self.finish()
def run(self):
"""
Run backlog search thread
"""
generic_queue.QueueItem.run(self)
self.started = True
if not self.show.paused:
try:
logger.log(u"Beginning backlog search for: [" + self.show.name + "]")
search_result = search.searchProviders(self.show, self.segment, False, False)
if search_result:
for result in search_result:
# just use the first result for now
if result.seeders not in (-1, None) and result.leechers not in (-1, None):
logger.log(u"Downloading {0} with {1} seeders and {2} leechers from {3}".
format(result.name,
result.seeders, result.leechers, result.provider.name))
else:
logger.log(u"Downloading {0} from {1}".format(result.name, result.provider.name))
self.success = search.snatchEpisode(result)
# give the CPU a break
time.sleep(common.cpu_presets[sickbeard.CPU_PRESET])
else:
logger.log(u"No needed episodes found during backlog search for: [" + self.show.name + "]")
except Exception:
self.success = False
logger.log(traceback.format_exc(), logger.DEBUG)
if self.success is None:
self.success = False
self.finish()
