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 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 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()