def run(self):
"""Run daily search thread."""
generic_queue.QueueItem.run(self)
self.started = True
try:
log.info('Beginning daily search for new episodes')
found_results = search_for_needed_episodes(self.scheduler_start_time, force=self.force)
if not found_results:
log.info('No needed episodes found')
else:
for result in found_results:
# just use the first result for now
if result.seeders not in (-1, None) and result.leechers not in (-1, None):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers'
' and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
else:
log.info(
'Downloading {name} with size: {size} from {provider}', {
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
# Set the search_type for the result.
result.search_type = SearchType.DAILY_SEARCH
# Create the queue item
snatch_queue_item = SnatchQueueItem(result.series, result.episodes, result)
# Add the queue item to the queue
app.manual_snatch_scheduler.action.add_item(snatch_queue_item)
self.success = False
while snatch_queue_item.success is False:
if snatch_queue_item.started and snatch_queue_item.success:
self.success = True
time.sleep(1)
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
except Exception as error:
self.success = False
log.exception('DailySearchQueueItem Exception, error: {error}', {'error': error})
if self.success is None:
self.success = False
self.finish()
def run(self):
"""Run daily search thread."""
generic_queue.QueueItem.run(self)
self.started = True
try:
log.info('Beginning daily search for new episodes')
found_results = search_for_needed_episodes(self.scheduler_start_time, force=self.force)
if not found_results:
log.info('No needed episodes found')
else:
for result in found_results:
# just use the first result for now
if result.seeders not in (-1, None) and result.leechers not in (-1, None):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers'
' and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
else:
log.info(
'Downloading {name} with size: {size} from {provider}', {
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
# Set the search_type for the result.
result.search_type = SearchType.DAILY_SEARCH
# Create the queue item
snatch_queue_item = SnatchQueueItem(result.series, result.episodes, result)
# Add the queue item to the queue
app.manual_snatch_scheduler.action.add_item(snatch_queue_item)
self.success = False
while snatch_queue_item.success is False:
if snatch_queue_item.started and snatch_queue_item.success:
self.success = True
time.sleep(1)
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
except Exception as error:
self.success = False
log.exception('DailySearchQueueItem Exception, error: {error}', {'error': error})
if self.success is None:
self.success = False
self.finish()
def run(self):
"""Run manual snatch job."""
generic_queue.QueueItem.run(self)
self.started = True
result = self.search_result
try:
log.info('Beginning to snatch release: {name}',
{'name': result.name})
# Push an update to any open Web UIs through the WebSocket
msg = ws.Message('QueueItemUpdate', self.to_json)
msg.push()
if result:
if result.seeders not in (-1, None) and result.leechers not in (-1, None):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers'
' and size {size} from {provider}, through a {search_type} search', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
'search_type': result.search_type
}
)
else:
log.info(
'Downloading {name} with size: {size} from {provider}, through a {search_type} search', {
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
'search_type': result.search_type
}
)
self.success = snatch_episode(result)
else:
log.info('Unable to snatch release: {name}',
{'name': result.name})
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
except Exception:
self.success = False
log.exception('Snatch failed! For result: {name}', {'name': result.name})
ui.notifications.message('Error while snatching selected result',
'Unable to snatch the result for <i>{name}</i>'.format(name=result.name))
if self.success is None:
self.success = False
# Push an update to any open Web UIs through the WebSocket
msg = ws.Message('QueueItemUpdate', self.to_json)
msg.push()
self.finish()
def run(self):
"""Run backlog search thread."""
generic_queue.QueueItem.run(self)
self.started = True
if not self.show.paused:
try:
log.info('Beginning backlog search for: {name}',
{'name': self.show.name})
search_result = search_providers(self.show, self.segment)
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):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers '
'and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
})
else:
log.info(
'Downloading {name} with size: {size} from {provider}',
{
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
})
self.success = snatch_episode(result)
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
else:
log.info(
'No needed episodes found during backlog search for: {name}',
{'name': self.show.name})
# TODO: Remove the catch all exception.
except Exception:
self.success = False
log.debug(traceback.format_exc())
if self.success is None:
self.success = False
self.finish()
def run(self):
"""Run manual snatch job."""
generic_queue.QueueItem.run(self)
self.started = True
result = self.search_result
try:
log.info('Beginning to snatch release: {name}',
{'name': result.name})
if result:
if result.seeders not in (-1, None) and result.leechers not in (-1, None):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers'
' and size {size} from {provider}, through a {search_type} search', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
'search_type': result.search_type
}
)
else:
log.info(
'Downloading {name} with size: {size} from {provider}, through a {search_type} search', {
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
'search_type': result.search_type
}
)
self.success = snatch_episode(result)
else:
log.info('Unable to snatch release: {name}',
{'name': result.name})
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
except Exception:
self.success = False
log.exception('Snatch failed! For result: {name}', {'name': result.name})
ui.notifications.message('Error while snatching selected result',
'Unable to snatch the result for <i>{name}</i>'.format(name=result.name))
if self.success is None:
self.success = False
self.finish()
def run(self):
"""Run daily search thread."""
generic_queue.QueueItem.run(self)
self.started = True
try:
log.info('Beginning daily search for new episodes')
found_results = search_for_needed_episodes(force=self.force)
if not found_results:
log.info('No needed episodes found')
else:
for result in found_results:
# just use the first result for now
if result.seeders not in (
-1, None) and result.leechers not in (-1, None):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers'
' and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
})
else:
log.info(
'Downloading {name} with size: {size} from {provider}',
{
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
})
self.success = snatch_episode(result)
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
except Exception as error:
self.success = False
log.exception('DailySearchQueueItem Exception, error: {error}',
{'error': error})
if self.success is None:
self.success = False
self.finish()
def run(self):
"""Run failed thread."""
generic_queue.QueueItem.run(self)
self.started = True
try:
for ep_obj in self.segment:
log.info('Marking episode as bad: {ep}',
{'ep': ep_obj.pretty_name()})
failed_history.mark_failed(ep_obj)
(release, provider) = failed_history.find_release(ep_obj)
if release:
failed_history.log_failed(release)
history.log_failed(ep_obj, release, provider)
failed_history.revert_episode(ep_obj)
log.info('Beginning failed download search for: {ep}',
{'ep': ep_obj.pretty_name()})
# If it is wanted, self.down_cur_quality doesnt matter
# if it isn't wanted, we need to make sure to not overwrite the existing ep that we reverted to!
search_result = search_providers(self.show, self.segment, True)
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):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers '
'and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
})
else:
log.info(
'Downloading {name} with size: {size} from {provider}',
{
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
})
# Set the search_type for the result.
result.search_type = SearchType.FAILED_SEARCH
# Create the queue item
snatch_queue_item = SnatchQueueItem(
result.series, result.episodes, result)
# Add the queue item to the queue
app.manual_snatch_scheduler.action.add_item(
snatch_queue_item)
self.success = False
while snatch_queue_item.success is False:
if snatch_queue_item.started and snatch_queue_item.success:
self.success = True
time.sleep(1)
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
else:
log.info(
'No needed episodes found during failed search for: {name}',
{'name': self.show.name})
# TODO: Replace the catch all exception with a more specific one.
except Exception:
self.success = False
log.info(traceback.format_exc())
# ## 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):
"""Run backlog search thread."""
generic_queue.QueueItem.run(self)
self.started = True
if not self.show.paused:
try:
log.info('Beginning backlog search for: {name}',
{'name': self.show.name})
search_result = search_providers(self.show, self.segment)
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):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers '
'and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
})
else:
log.info(
'Downloading {name} with size: {size} from {provider}',
{
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
})
# Set the search_type for the result.
result.search_type = SearchType.BACKLOG_SEARCH
# Create the queue item
snatch_queue_item = SnatchQueueItem(
result.series, result.episodes, result)
# Add the queue item to the queue
app.manual_snatch_scheduler.action.add_item(
snatch_queue_item)
self.success = False
while snatch_queue_item.success is False:
if snatch_queue_item.started and snatch_queue_item.success:
self.success = True
time.sleep(1)
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
else:
log.info(
'No needed episodes found during backlog search for: {name}',
{'name': self.show.name})
# TODO: Remove the catch all exception.
except Exception:
self.success = False
log.debug(traceback.format_exc())
if self.success is None:
self.success = False
self.finish()
def run(self):
"""Run forced search thread."""
generic_queue.QueueItem.run(self)
self.started = True
try:
log.info(
'Beginning {search_type} {season_pack}search for: {ep}', {
'search_type':
('forced', 'manual')[bool(self.manual_search)],
'season_pack': ('', 'season pack ')[bool(
self.manual_search_type == 'season')],
'ep':
self.segment[0].pretty_name()
})
search_result = search_providers(self.show, self.segment, True,
self.down_cur_quality,
self.manual_search,
self.manual_search_type)
if not self.manual_search and 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):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers '
'and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
})
else:
log.info(
'Downloading {name} with size: {size} from {provider}',
{
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
})
# Set the search_type for the result.
result.search_type = SearchType.FORCED_SEARCH
# Create the queue item
snatch_queue_item = SnatchQueueItem(
result.series, result.episodes, result)
# Add the queue item to the queue
app.manual_snatch_scheduler.action.add_item(
snatch_queue_item)
self.success = False
while snatch_queue_item.success is False:
if snatch_queue_item.started and snatch_queue_item.success:
self.success = True
time.sleep(1)
# Give the CPU a break
time.sleep(common.cpu_presets[app.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 packs for {show_name}'.format(
show_name=self.show.name),
'These should become visible in the manual select page.'
)
else:
ui.notifications.message(
'We have found results for {ep}'.format(
ep=self.segment[0].pretty_name()),
'These should become visible in the manual select page.'
)
else:
ui.notifications.message('No results were found')
log.info(
'Unable to find {search_type} {season_pack}results for: {ep}',
{
'search_type':
('forced', 'manual')[bool(self.manual_search)],
'season_pack': ('', 'season pack ')[bool(
self.manual_search_type == 'season')],
'ep':
self.segment[0].pretty_name()
})
# TODO: Remove catch all exception.
except Exception:
self.success = False
log.debug(traceback.format_exc())
# 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):
"""Run manual snatch job."""
generic_queue.QueueItem.run(self)
self.started = True
result = providers.get_provider_class(self.provider).get_result(self.segment)
result.series = self.show
result.url = self.cached_result['url']
result.quality = int(self.cached_result['quality'])
result.name = self.cached_result['name']
result.size = int(self.cached_result['size'])
result.seeders = int(self.cached_result['seeders'])
result.leechers = int(self.cached_result['leechers'])
result.release_group = self.cached_result['release_group']
result.version = int(self.cached_result['version'])
result.proper_tags = self.cached_result['proper_tags'].split('|') \
if self.cached_result['proper_tags'] else ''
result.manually_searched = True
try:
log.info('Beginning to manual snatch release: {name}',
{'name': result.name})
if result:
if result.seeders not in (-1, None) and result.leechers not in (-1, None):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers'
' and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
else:
log.info(
'Downloading {name} with size: {size} from {provider}', {
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
self.success = snatch_episode(result)
else:
log.info('Unable to snatch release: {name}',
{'name': result.name})
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
except Exception:
self.success = False
log.exception('Manual snatch failed! For result: {name}', {'name': result.name})
ui.notifications.message('Error while snatching selected result',
'Unable to snatch the result for <i>{name}</i>'.format(name=result.name))
if self.success is None:
self.success = False
self.finish()
def run(self):
"""Run failed thread."""
generic_queue.QueueItem.run(self)
self.started = True
try:
for ep_obj in self.segment:
log.info('Marking episode as bad: {ep}',
{'ep': ep_obj.pretty_name()})
failed_history.mark_failed(ep_obj)
(release, provider) = failed_history.find_release(ep_obj)
if release:
failed_history.log_failed(release)
history.log_failed(ep_obj, release, provider)
failed_history.revert_episode(ep_obj)
log.info('Beginning failed download search for: {ep}',
{'ep': ep_obj.pretty_name()})
# If it is wanted, self.down_cur_quality doesnt matter
# if it isn't wanted, we need to make sure to not overwrite the existing ep that we reverted to!
search_result = search_providers(self.show, self.segment, True)
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):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers '
'and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
else:
log.info(
'Downloading {name} with size: {size} from {provider}', {
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
# Set the search_type for the result.
result.search_type = SearchType.FAILED_SEARCH
# Create the queue item
snatch_queue_item = SnatchQueueItem(result.series, result.episodes, result)
# Add the queue item to the queue
app.manual_snatch_scheduler.action.add_item(snatch_queue_item)
self.success = False
while snatch_queue_item.success is False:
if snatch_queue_item.started and snatch_queue_item.success:
self.success = True
time.sleep(1)
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
else:
log.info('No needed episodes found during failed search for: {name}',
{'name': self.show.name})
# TODO: Replace the catch all exception with a more specific one.
except Exception:
self.success = False
log.info(traceback.format_exc())
# ## 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):
"""Run backlog search thread."""
generic_queue.QueueItem.run(self)
self.started = True
if not self.show.paused:
try:
log.info('Beginning backlog search for: {name}',
{'name': self.show.name})
search_result = search_providers(self.show, self.segment)
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):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers '
'and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
else:
log.info(
'Downloading {name} with size: {size} from {provider}', {
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
# Set the search_type for the result.
result.search_type = SearchType.BACKLOG_SEARCH
# Create the queue item
snatch_queue_item = SnatchQueueItem(result.series, result.episodes, result)
# Add the queue item to the queue
app.manual_snatch_scheduler.action.add_item(snatch_queue_item)
self.success = False
while snatch_queue_item.success is False:
if snatch_queue_item.started and snatch_queue_item.success:
self.success = True
time.sleep(1)
# give the CPU a break
time.sleep(common.cpu_presets[app.CPU_PRESET])
else:
log.info('No needed episodes found during backlog search for: {name}',
{'name': self.show.name})
# TODO: Remove the catch all exception.
except Exception:
self.success = False
log.debug(traceback.format_exc())
if self.success is None:
self.success = False
self.finish()
def run(self):
"""Run forced search thread."""
generic_queue.QueueItem.run(self)
self.started = True
try:
log.info(
'Beginning {search_type} {season_pack}search for: {ep}', {
'search_type': ('forced', 'manual')[bool(self.manual_search)],
'season_pack': ('', 'season pack ')[bool(self.manual_search_type == 'season')],
'ep': self.segment[0].pretty_name()
}
)
search_result = search_providers(self.show, self.segment, True, self.down_cur_quality,
self.manual_search, self.manual_search_type)
if not self.manual_search and 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):
log.info(
'Downloading {name} with {seeders} seeders and {leechers} leechers '
'and size {size} from {provider}', {
'name': result.name,
'seeders': result.seeders,
'leechers': result.leechers,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
else:
log.info(
'Downloading {name} with size: {size} from {provider}', {
'name': result.name,
'size': pretty_file_size(result.size),
'provider': result.provider.name,
}
)
# Set the search_type for the result.
result.search_type = SearchType.FORCED_SEARCH
# Create the queue item
snatch_queue_item = SnatchQueueItem(result.series, result.episodes, result)
# Add the queue item to the queue
app.manual_snatch_scheduler.action.add_item(snatch_queue_item)
self.success = False
while snatch_queue_item.success is False:
if snatch_queue_item.started and snatch_queue_item.success:
self.success = True
time.sleep(1)
# Give the CPU a break
time.sleep(common.cpu_presets[app.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 packs for {show_name}'
.format(show_name=self.show.name),
'These should become visible in the manual select page.')
else:
ui.notifications.message('We have found results for {ep}'
.format(ep=self.segment[0].pretty_name()),
'These should become visible in the manual select page.')
else:
ui.notifications.message('No results were found')
log.info(
'Unable to find {search_type} {season_pack}results for: {ep}', {
'search_type': ('forced', 'manual')[bool(self.manual_search)],
'season_pack': ('', 'season pack ')[bool(self.manual_search_type == 'season')],
'ep': self.segment[0].pretty_name()
}
)
# TODO: Remove catch all exception.
except Exception:
self.success = False
log.debug(traceback.format_exc())
# 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()
