github/nzbToMedia
1
0
Fork 0
mirror of https://github.com/clinton-hall/nzbToMedia.git synced 2025-08-21 22:03:13 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Upgrade to Python 3.7+ and pre-commit linting

Browse source
This commit is contained in:
Labrys of Knossos 2022-12-09 15:15:05 -05:00
commit 820267a1d2
66 changed files with 530 additions and 719 deletions
Download patch file Download diff file Expand all files Collapse all files

93
TorrentToMedia.py
View file

@ -1,12 +1,5 @@
#!/usr/bin/env python
# coding=utf-8
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import datetime
import os
@ -37,7 +30,7 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
found_file = 0
if client_agent != 'manual' and not core.DOWNLOAD_INFO:
logger.debug('Adding TORRENT download info for directory {0} to database'.format(input_directory))
logger.debug(f'Adding TORRENT download info for directory {input_directory} to database')
my_db = main_db.DBConnection()
@ -61,7 +54,7 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
}
my_db.upsert('downloads', new_value_dict, control_value_dict)
logger.debug('Received Directory: {0} | Name: {1} | Category: {2}'.format(input_directory, input_name, input_category))
logger.debug(f'Received Directory: {input_directory} | Name: {input_name} | Category: {input_category}')
# Confirm the category by parsing directory structure
input_directory, input_name, input_category, root = core.category_search(input_directory, input_name, input_category,
@ -71,8 +64,7 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
usercat = input_category
logger.debug('Determined Directory: {0} | Name: {1} | Category: {2}'.format
(input_directory, input_name, input_category))
logger.debug(f'Determined Directory: {input_directory} | Name: {input_name} | Category: {input_category}')
# auto-detect section
section = core.CFG.findsection(input_category).isenabled()
@ -84,26 +76,18 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
section = core.CFG.findsection('UNCAT').isenabled()
usercat = 'UNCAT'
if section is None: # We haven't found any categories to process.
logger.error('Category:[{0}] is not defined or is not enabled. '
'Please rename it or ensure it is enabled for the appropriate section '
'in your autoProcessMedia.cfg and try again.'.format
(input_category))
logger.error(f'Category:[{input_category}] is not defined or is not enabled. Please rename it or ensure it is enabled for the appropriate section in your autoProcessMedia.cfg and try again.')
return [-1, '']
if len(section) > 1:
logger.error('Category:[{0}] is not unique, {1} are using it. '
'Please rename it or disable all other sections using the same category name '
'in your autoProcessMedia.cfg and try again.'.format
(usercat, section.keys()))
logger.error(f'Category:[{usercat}] is not unique, {section.keys()} are using it. Please rename it or disable all other sections using the same category name in your autoProcessMedia.cfg and try again.')
return [-1, '']
if section:
section_name = section.keys()[0]
logger.info('Auto-detected SECTION:{0}'.format(section_name))
logger.info(f'Auto-detected SECTION:{section_name}')
else:
logger.error('Unable to locate a section with subsection:{0} '
'enabled in your autoProcessMedia.cfg, exiting!'.format
(input_category))
logger.error(f'Unable to locate a section with subsection:{input_category} enabled in your autoProcessMedia.cfg, exiting!')
return [-1, '']
section = dict(section[section_name][usercat]) # Type cast to dict() to allow effective usage of .get()
@ -134,15 +118,13 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
if output_destination in input_directory:
output_destination = input_directory
logger.info('Output directory set to: {0}'.format(output_destination))
logger.info(f'Output directory set to: {output_destination}')
if core.SAFE_MODE and output_destination == core.TORRENT_DEFAULT_DIRECTORY:
logger.error('The output directory:[{0}] is the Download Directory. '
'Edit outputDirectory in autoProcessMedia.cfg. Exiting'.format
(input_directory))
logger.error(f'The output directory:[{input_directory}] is the Download Directory. Edit outputDirectory in autoProcessMedia.cfg. Exiting')
return [-1, '']
logger.debug('Scanning files in directory: {0}'.format(input_directory))
logger.debug(f'Scanning files in directory: {input_directory}')
if section_name in ['HeadPhones', 'Lidarr']:
core.NOFLATTEN.extend(
@ -156,9 +138,9 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
input_files = core.list_media_files(input_directory, other=True, otherext=extensions)
if len(input_files) == 0 and os.path.isfile(input_directory):
input_files = [input_directory]
logger.debug('Found 1 file to process: {0}'.format(input_directory))
logger.debug(f'Found 1 file to process: {input_directory}')
else:
logger.debug('Found {0} files in {1}'.format(len(input_files), input_directory))
logger.debug(f'Found {len(input_files)} files in {input_directory}')
for inputFile in input_files:
file_path = os.path.dirname(inputFile)
file_name, file_ext = os.path.splitext(os.path.basename(inputFile))
@ -169,16 +151,14 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
if not os.path.basename(file_path) in output_destination:
target_file = core.os.path.join(
core.os.path.join(output_destination, os.path.basename(file_path)), full_file_name)
logger.debug('Setting outputDestination to {0} to preserve folder structure'.format
(os.path.dirname(target_file)))
logger.debug(f'Setting outputDestination to {os.path.dirname(target_file)} to preserve folder structure')
if root == 1:
if not found_file:
logger.debug('Looking for {0} in: {1}'.format(input_name, inputFile))
logger.debug(f'Looking for {input_name} in: {inputFile}')
if any([core.sanitize_name(input_name) in core.sanitize_name(inputFile),
core.sanitize_name(file_name) in core.sanitize_name(input_name)]):
found_file = True
logger.debug('Found file {0} that matches Torrent Name {1}'.format
(full_file_name, input_name))
logger.debug(f'Found file {full_file_name} that matches Torrent Name {input_name}')
else:
continue
@ -190,8 +170,7 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
logger.debug('Looking for files with modified/created dates less than 5 minutes old.')
if (mtime_lapse < datetime.timedelta(minutes=5)) or (ctime_lapse < datetime.timedelta(minutes=5)):
found_file = True
logger.debug('Found file {0} with date modified/created less than 5 minutes ago.'.format
(full_file_name))
logger.debug(f'Found file {full_file_name} with date modified/created less than 5 minutes ago.')
else:
continue # This file has not been recently moved or created, skip it
@ -200,12 +179,12 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
core.copy_link(inputFile, target_file, core.USE_LINK)
core.remove_read_only(target_file)
except Exception:
logger.error('Failed to link: {0} to {1}'.format(inputFile, target_file))
logger.error(f'Failed to link: {inputFile} to {target_file}')
input_name, output_destination = convert_to_ascii(input_name, output_destination)
if extract == 1:
logger.debug('Checking for archives to extract in directory: {0}'.format(input_directory))
logger.debug(f'Checking for archives to extract in directory: {input_directory}')
core.extract_files(input_directory, output_destination, keep_archive)
if input_category not in core.NOFLATTEN:
@ -217,20 +196,20 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
num_videos = len(
core.list_media_files(output_destination, media=True, audio=False, meta=False, archives=False))
if num_videos > 0:
logger.info('Found {0} media files in {1}'.format(num_videos, output_destination))
logger.info(f'Found {num_videos} media files in {output_destination}')
status = 0
elif extract != 1:
logger.info('Found no media files in {0}. Sending to {1} to process'.format(output_destination, section_name))
logger.info(f'Found no media files in {output_destination}. Sending to {section_name} to process')
status = 0
else:
logger.warning('Found no media files in {0}'.format(output_destination))
logger.warning(f'Found no media files in {output_destination}')
# Only these sections can handling failed downloads
# so make sure everything else gets through without the check for failed
if section_name not in ['CouchPotato', 'Radarr', 'SickBeard', 'SiCKRAGE', 'NzbDrone', 'Sonarr', 'Watcher3']:
status = 0
logger.info('Calling {0}:{1} to post-process:{2}'.format(section_name, usercat, input_name))
logger.info(f'Calling {section_name}:{usercat} to post-process:{input_name}')
if core.TORRENT_CHMOD_DIRECTORY:
core.rchmod(output_destination, core.TORRENT_CHMOD_DIRECTORY)
@ -283,10 +262,10 @@ def process_torrent(input_directory, input_name, input_category, input_hash, inp
# remove torrent
if core.USE_LINK == 'move-sym' and not core.DELETE_ORIGINAL == 1:
logger.debug('Checking for sym-links to re-direct in: {0}'.format(input_directory))
logger.debug(f'Checking for sym-links to re-direct in: {input_directory}')
for dirpath, _, files in os.walk(input_directory):
for file in files:
logger.debug('Checking symlink: {0}'.format(os.path.join(dirpath, file)))
logger.debug(f'Checking symlink: {os.path.join(dirpath, file)}')
replace_links(os.path.join(dirpath, file))
core.remove_torrent(client_agent, input_hash, input_id, input_name)
@ -306,11 +285,11 @@ def main(args):
client_agent = core.TORRENT_CLIENT_AGENT
logger.info('#########################################################')
logger.info('## ..::[{0}]::.. ##'.format(os.path.basename(__file__)))
logger.info(f'## ..::[{os.path.basename(__file__)}]::.. ##')
logger.info('#########################################################')
# debug command line options
logger.debug('Options passed into TorrentToMedia: {0}'.format(args))
logger.debug(f'Options passed into TorrentToMedia: {args}')
# Post-Processing Result
result = ProcessResult(
@ -337,22 +316,17 @@ def main(args):
if not core.CFG[section][subsection].isenabled():
continue
for dir_name in core.get_dirs(section, subsection, link='hard'):
logger.info('Starting manual run for {0}:{1} - Folder:{2}'.format
(section, subsection, dir_name))
logger.info(f'Starting manual run for {section}:{subsection} - Folder:{dir_name}')
logger.info('Checking database for download info for {0} ...'.format
(os.path.basename(dir_name)))
logger.info(f'Checking database for download info for {os.path.basename(dir_name)} ...')
core.DOWNLOAD_INFO = core.get_download_info(os.path.basename(dir_name), 0)
if core.DOWNLOAD_INFO:
client_agent = text_type(core.DOWNLOAD_INFO[0]['client_agent']) or 'manual'
input_hash = text_type(core.DOWNLOAD_INFO[0]['input_hash']) or ''
input_id = text_type(core.DOWNLOAD_INFO[0]['input_id']) or ''
logger.info('Found download info for {0}, '
'setting variables now ...'.format(os.path.basename(dir_name)))
logger.info(f'Found download info for {os.path.basename(dir_name)}, setting variables now ...')
else:
logger.info('Unable to locate download info for {0}, '
'continuing to try and process this release ...'.format
(os.path.basename(dir_name)))
logger.info(f'Unable to locate download info for {os.path.basename(dir_name)}, continuing to try and process this release ...')
client_agent = 'manual'
input_hash = ''
input_id = ''
@ -365,14 +339,13 @@ def main(args):
results = process_torrent(dir_name, input_name, subsection, input_hash or None, input_id or None,
client_agent)
if results.status_code != 0:
logger.error('A problem was reported when trying to perform a manual run for {0}:{1}.'.format
(section, subsection))
logger.error(f'A problem was reported when trying to perform a manual run for {section}:{subsection}.')
result = results
if result.status_code == 0:
logger.info('The {0} script completed successfully.'.format(args[0]))
logger.info(f'The {args[0]} script completed successfully.')
else:
logger.error('A problem was reported in the {0} script.'.format(args[0]))
logger.error(f'A problem was reported in the {args[0]} script.')
del core.MYAPP
return result.status_code

18
cleanup.py
View file

@ -88,7 +88,7 @@ def git_clean(remove_directories=False, force=False, dry_run=False, interactive=
except AttributeError:
pass
for exclusion in exclude:
command.append('--exclude={pattern}'.format(pattern=exclusion))
command.append(f'--exclude={exclusion}')
if ignore_rules:
command.append('-x')
if clean_ignored:
@ -116,9 +116,9 @@ def clean_bytecode():
)
print(result)
except subprocess.CalledProcessError as error:
sys.exit('Error Code: {}'.format(error.returncode))
except (IOError, OSError) as error:
sys.exit('Error: {}'.format(error))
sys.exit(f'Error Code: {error.returncode}')
except OSError as error:
sys.exit(f'Error: {error}')
else:
return result
@ -133,9 +133,9 @@ def clean_folders(*paths):
paths=paths,
)
except subprocess.CalledProcessError as error:
sys.exit('Error Code: {}'.format(error.returncode))
except (IOError, OSError) as error:
sys.exit('Error: {}'.format(error))
sys.exit(f'Error Code: {error.returncode}')
except OSError as error:
sys.exit(f'Error: {error}')
else:
return result
@ -166,7 +166,7 @@ def clean(paths):
def _report_error(msg):
print('WARNING: Automatic cleanup could not be executed.')
print(' If errors occur, manual cleanup may be required.')
print('REASON : {}'.format(msg))
print(f'REASON : {msg}')
with WorkingDirectory(module_path()) as cwd:
if cwd.working_directory != cwd.original_directory:
@ -181,7 +181,7 @@ def clean(paths):
print(result or 'No bytecode to clean')
if paths and os.path.exists('.git'):
print('\n-- Cleaning folders: {} --'.format(list(paths)))
print(f'\n-- Cleaning folders: {list(paths)} --')
try:
result = clean_folders(*paths)
except SystemExit as error:

25
core/__init__.py
View file

@ -295,7 +295,7 @@ def configure_locale():
try:
locale.setlocale(locale.LC_ALL, '')
SYS_ENCODING = locale.getpreferredencoding()
except (locale.Error, IOError):
except (locale.Error, OSError):
pass
# For OSes that are poorly configured I'll just randomly force UTF-8
@ -309,7 +309,7 @@ def configure_migration():
# run migrate to convert old cfg to new style cfg plus fix any cfg missing values/options.
if not config.migrate():
logger.error('Unable to migrate config file {0}, exiting ...'.format(CONFIG_FILE))
logger.error(f'Unable to migrate config file {CONFIG_FILE}, exiting ...')
if 'NZBOP_SCRIPTDIR' in os.environ:
pass # We will try and read config from Environment.
else:
@ -320,7 +320,7 @@ def configure_migration():
CFG = config.addnzbget()
else: # load newly migrated config
logger.info('Loading config from [{0}]'.format(CONFIG_FILE))
logger.info(f'Loading config from [{CONFIG_FILE}]')
CFG = config()
@ -338,7 +338,7 @@ def configure_logging_part_2():
if LOG_ENV:
for item in os.environ:
logger.info('{0}: {1}'.format(item, os.environ[item]), 'ENVIRONMENT')
logger.info(f'{item}: {os.environ[item]}', 'ENVIRONMENT')
def configure_general():
@ -441,23 +441,26 @@ def configure_niceness():
with open(os.devnull, 'w') as devnull:
try:
subprocess.Popen(['nice'], stdout=devnull, stderr=devnull).communicate()
if len(CFG['Posix']['niceness'].split(',')) > 1: #Allow passing of absolute command, not just value.
NICENESS.extend(CFG['Posix']['niceness'].split(','))
niceness = CFG['Posix']['niceness']
if len(niceness.split(',')) > 1: #Allow passing of absolute command, not just value.
NICENESS.extend(niceness.split(','))
else:
NICENESS.extend(['nice', '-n{0}'.format(int(CFG['Posix']['niceness']))])
NICENESS.extend(['nice', f'-n{int(niceness)}'])
except Exception:
pass
try:
subprocess.Popen(['ionice'], stdout=devnull, stderr=devnull).communicate()
try:
NICENESS.extend(['ionice', '-c{0}'.format(int(CFG['Posix']['ionice_class']))])
ionice = CFG['Posix']['ionice_class']
NICENESS.extend(['ionice', f'-c{int(ionice)}'])
except Exception:
pass
try:
if 'ionice' in NICENESS:
NICENESS.extend(['-n{0}'.format(int(CFG['Posix']['ionice_classdata']))])
ionice = CFG['Posix']['ionice_classdata']
NICENESS.extend([f'-n{int(ionice)}'])
else:
NICENESS.extend(['ionice', '-n{0}'.format(int(CFG['Posix']['ionice_classdata']))])
NICENESS.extend(['ionice', f'-n{int(ionice)}'])
except Exception:
pass
except Exception:
@ -473,7 +476,7 @@ def configure_containers():
COMPRESSED_CONTAINER = [re.compile(r'.r\d{2}$', re.I),
re.compile(r'.part\d+.rar$', re.I),
re.compile('.rar$', re.I)]
COMPRESSED_CONTAINER += [re.compile('{0}$'.format(ext), re.I) for ext in
COMPRESSED_CONTAINER += [re.compile(f'{ext}$', re.I) for ext in
CFG['Extensions']['compressedExtensions']]
MEDIA_CONTAINER = CFG['Extensions']['mediaExtensions']
AUDIO_CONTAINER = CFG['Extensions']['audioExtensions']

10
core/auto_process/books.py
View file

@ -81,7 +81,7 @@ def process(
'dir': remote_dir(dir_name) if remote_path else dir_name,
}
logger.debug('Opening URL: {0} with params: {1}'.format(url, params), section)
logger.debug(f'Opening URL: {url} with params: {params}', section)
try:
r = requests.get(url, params=params, verify=False, timeout=(30, 300))
@ -92,21 +92,21 @@ def process(
f'{section}'
)
logger.postprocess('{0}'.format(r.text), section)
logger.postprocess(f'{r.text}', section)
if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
logger.error('Server returned status {0}'.format(r.status_code), section)
logger.error(f'Server returned status {r.status_code}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Server returned status '
f'{r.status_code}'
)
elif r.text == 'OK':
logger.postprocess('SUCCESS: ForceProcess for {0} has been started in LazyLibrarian'.format(dir_name), section)
logger.postprocess(f'SUCCESS: ForceProcess for {dir_name} has been started in LazyLibrarian', section)
return ProcessResult.success(
f'{section}: Successfully post-processed {input_name}'
)
else:
logger.error('FAILED: ForceProcess of {0} has Failed in LazyLibrarian'.format(dir_name), section)
logger.error(f'FAILED: ForceProcess of {dir_name} has Failed in LazyLibrarian', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Returned log from {section} '
f'was not as expected.'

6
core/auto_process/comics.py
View file

@ -94,7 +94,7 @@ def process(
success = False
logger.debug('Opening URL: {0}'.format(url), section)
logger.debug(f'Opening URL: {url}', section)
try:
r = requests.post(url, params=params, stream=True, verify=False, timeout=(30, 300))
except requests.ConnectionError:
@ -104,7 +104,7 @@ def process(
f'{section}'
)
if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
logger.error('Server returned status {0}'.format(r.status_code), section)
logger.error(f'Server returned status {r.status_code}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Server returned status '
f'{r.status_code}'
@ -115,7 +115,7 @@ def process(
result = result.split('\n')
for line in result:
if line:
logger.postprocess('{0}'.format(line), section)
logger.postprocess(line, section)
if 'Post Processing SUCCESSFUL' in line:
success = True

10
core/auto_process/common.py
View file

@ -32,17 +32,17 @@ def command_complete(url, params, headers, section):
try:
r = requests.get(url, params=params, headers=headers, stream=True, verify=False, timeout=(30, 60))
except requests.ConnectionError:
logger.error('Unable to open URL: {0}'.format(url), section)
logger.error(f'Unable to open URL: {url}', section)
return None
if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
logger.error('Server returned status {0}'.format(r.status_code), section)
logger.error(f'Server returned status {r.status_code}', section)
return None
else:
try:
return r.json()['status']
except (ValueError, KeyError):
# ValueError catches simplejson's JSONDecodeError and json's ValueError
logger.error('{0} did not return expected json data.'.format(section), section)
logger.error(f'{section} did not return expected json data.', section)
return None
@ -50,10 +50,10 @@ def completed_download_handling(url2, headers, section='MAIN'):
try:
r = requests.get(url2, params={}, headers=headers, stream=True, verify=False, timeout=(30, 60))
except requests.ConnectionError:
logger.error('Unable to open URL: {0}'.format(url2), section)
logger.error(f'Unable to open URL: {url2}', section)
return False
if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
logger.error('Server returned status {0}'.format(r.status_code), section)
logger.error(f'Server returned status {r.status_code}', section)
return False
else:
try:

14
core/auto_process/games.py
View file

@ -88,7 +88,7 @@ def process(
'status': download_status,
}
logger.debug('Opening URL: {0}'.format(url), section)
logger.debug(f'Opening URL: {url}', section)
try:
r = requests.get(url, params=params, verify=False, timeout=(30, 300))
@ -100,13 +100,13 @@ def process(
)
result = r.json()
logger.postprocess('{0}'.format(result), section)
logger.postprocess(result, section)
if library:
logger.postprocess('moving files to library: {0}'.format(library), section)
logger.postprocess(f'moving files to library: {library}', section)
try:
shutil.move(dir_name, os.path.join(library, input_name))
except Exception:
logger.error('Unable to move {0} to {1}'.format(dir_name, os.path.join(library, input_name)), section)
logger.error(f'Unable to move {dir_name} to {os.path.join(library, input_name)}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Unable to move files'
)
@ -118,18 +118,18 @@ def process(
)
if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
logger.error('Server returned status {0}'.format(r.status_code), section)
logger.error(f'Server returned status {r.status_code}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Server returned status '
f'{r.status_code}'
)
elif result['success']:
logger.postprocess('SUCCESS: Status for {0} has been set to {1} in Gamez'.format(gamez_id, download_status), section)
logger.postprocess(f'SUCCESS: Status for {gamez_id} has been set to {download_status} in Gamez', section)
return ProcessResult.success(
f'{section}: Successfully post-processed {input_name}'
)
else:
logger.error('FAILED: Status for {0} has NOT been updated in Gamez'.format(gamez_id), section)
logger.error(f'FAILED: Status for {gamez_id} has NOT been updated in Gamez', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Returned log from {section} '
f'was not as expected.'

136
core/auto_process/movies.py
View file

@ -137,7 +137,7 @@ def process(
input_name, dir_name = convert_to_ascii(input_name, dir_name)
if not list_media_files(dir_name, media=True, audio=False, meta=False, archives=False) and list_media_files(dir_name, media=False, audio=False, meta=False, archives=True) and extract:
logger.debug('Checking for archives to extract in directory: {0}'.format(dir_name))
logger.debug(f'Checking for archives to extract in directory: {dir_name}')
core.extract_files(dir_name)
input_name, dir_name = convert_to_ascii(input_name, dir_name)
@ -155,7 +155,7 @@ def process(
rename_subs(dir_name)
if num_files and valid_files == num_files:
if status:
logger.info('Status shown as failed from Downloader, but {0} valid video files found. Setting as success.'.format(good_files), section)
logger.info(f'Status shown as failed from Downloader, but {good_files} valid video files found. Setting as success.', section)
status = 0
elif num_files and valid_files < num_files:
logger.info('Status shown as success from Downloader, but corrupt video files found. Setting as failed.', section)
@ -163,19 +163,19 @@ def process(
if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][0:5] >= '14.0':
print('[NZB] MARK=BAD')
if good_files == num_files:
logger.debug('Video marked as failed due to missing required language: {0}'.format(core.REQUIRE_LAN), section)
logger.debug(f'Video marked as failed due to missing required language: {core.REQUIRE_LAN}', section)
else:
logger.debug('Video marked as failed due to missing playable audio or video', section)
if good_files < num_files and failure_link: # only report corrupt files
failure_link += '&corrupt=true'
elif client_agent == 'manual':
logger.warning('No media files found in directory {0} to manually process.'.format(dir_name), section)
logger.warning(f'No media files found in directory {dir_name} to manually process.', section)
return ProcessResult(
message='',
status_code=0, # Success (as far as this script is concerned)
)
else:
logger.warning('No media files found in directory {0}. Processing this as a failed download'.format(dir_name), section)
logger.warning(f'No media files found in directory {dir_name}. Processing this as a failed download', section)
status = 1
if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][0:5] >= '14.0':
print('[NZB] MARK=BAD')
@ -184,31 +184,31 @@ def process(
if core.TRANSCODE == 1:
result, new_dir_name = transcoder.transcode_directory(dir_name)
if result == 0:
logger.debug('Transcoding succeeded for files in {0}'.format(dir_name), section)
logger.debug(f'Transcoding succeeded for files in {dir_name}', section)
dir_name = new_dir_name
logger.debug('Config setting \'chmodDirectory\' currently set to {0}'.format(oct(chmod_directory)), section)
logger.debug(f'Config setting \'chmodDirectory\' currently set to {oct(chmod_directory)}', section)
if chmod_directory:
logger.info('Attempting to set the octal permission of \'{0}\' on directory \'{1}\''.format(oct(chmod_directory), dir_name), section)
logger.info(f'Attempting to set the octal permission of \'{oct(chmod_directory)}\' on directory \'{dir_name}\'', section)
core.rchmod(dir_name, chmod_directory)
else:
logger.error('Transcoding failed for files in {0}'.format(dir_name), section)
logger.error(f'Transcoding failed for files in {dir_name}', section)
return ProcessResult(
message='{0}: Failed to post-process - Transcoding failed'.format(section),
message=f'{section}: Failed to post-process - Transcoding failed',
status_code=1,
)
for video in list_media_files(dir_name, media=True, audio=False, meta=False, archives=False):
if not release and '.cp(tt' not in video and imdbid:
video_name, video_ext = os.path.splitext(video)
video2 = '{0}.cp({1}){2}'.format(video_name, imdbid, video_ext)
video2 = f'{video_name}.cp({imdbid}){video_ext}'
if not (client_agent in [core.TORRENT_CLIENT_AGENT, 'manual'] and core.USE_LINK == 'move-sym'):
logger.debug('Renaming: {0} to: {1}'.format(video, video2))
logger.debug(f'Renaming: {video} to: {video2}')
os.rename(video, video2)
if not apikey: # If only using Transcoder functions, exit here.
logger.info('No CouchPotato or Radarr or Watcher3 apikey entered. Processing completed.')
return ProcessResult(
message='{0}: Successfully post-processed {1}'.format(section, input_name),
message=f'{section}: Successfully post-processed {input_name}',
status_code=0,
)
@ -227,16 +227,16 @@ def process(
else:
command = 'renamer.scan'
url = '{0}{1}'.format(base_url, command)
logger.debug('Opening URL: {0} with PARAMS: {1}'.format(url, params), section)
logger.postprocess('Starting {0} scan for {1}'.format(method, input_name), section)
url = f'{base_url}{command}'
logger.debug(f'Opening URL: {url} with PARAMS: {params}', section)
logger.postprocess(f'Starting {method} scan for {input_name}', section)
if section == 'Radarr':
payload = {'name': 'DownloadedMoviesScan', 'path': params['media_folder'], 'downloadClientId': download_id, 'importMode': import_mode}
if not download_id:
payload.pop('downloadClientId')
logger.debug('Opening URL: {0} with PARAMS: {1}'.format(base_url, payload), section)
logger.postprocess('Starting DownloadedMoviesScan scan for {0}'.format(input_name), section)
logger.debug(f'Opening URL: {base_url} with PARAMS: {payload}', section)
logger.postprocess(f'Starting DownloadedMoviesScan scan for {input_name}', section)
if section == 'Watcher3':
if input_name and os.path.isfile(os.path.join(dir_name, input_name)):
@ -244,8 +244,8 @@ def process(
payload = {'apikey': apikey, 'path': params['media_folder'], 'guid': download_id, 'mode': 'complete'}
if not download_id:
payload.pop('guid')
logger.debug('Opening URL: {0} with PARAMS: {1}'.format(base_url, payload), section)
logger.postprocess('Starting postprocessing scan for {0}'.format(input_name), section)
logger.debug(f'Opening URL: {base_url} with PARAMS: {payload}', section)
logger.postprocess(f'Starting postprocessing scan for {input_name}', section)
try:
if section == 'CouchPotato':
@ -263,65 +263,66 @@ def process(
result = r.json()
if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
logger.error('Server returned status {0}'.format(r.status_code), section)
logger.error(f'Server returned status {r.status_code}', section)
return ProcessResult(
message='{0}: Failed to post-process - Server returned status {1}'.format(section, r.status_code),
message=f'{section}: Failed to post-process - Server returned status {r.status_code}',
status_code=1,
)
elif section == 'CouchPotato' and result['success']:
logger.postprocess('SUCCESS: Finished {0} scan for folder {1}'.format(method, dir_name), section)
logger.postprocess(f'SUCCESS: Finished {method} scan for folder {dir_name}', section)
if method == 'manage':
return ProcessResult(
message='{0}: Successfully post-processed {1}'.format(section, input_name),
message=f'{section}: Successfully post-processed {input_name}',
status_code=0,
)
elif section == 'Radarr':
try:
scan_id = int(result['id'])
logger.debug('Scan started with id: {0}'.format(scan_id), section)
logger.debug(f'Scan started with id: {scan_id}', section)
except Exception as e:
logger.warning('No scan id was returned due to: {0}'.format(e), section)
logger.warning(f'No scan id was returned due to: {e}', section)
scan_id = None
elif section == 'Watcher3' and result['status'] == 'finished':
logger.postprocess('Watcher3 updated status to {0}'.format(result['tasks']['update_movie_status']))
if result['tasks']['update_movie_status'] == 'Finished':
update_movie_status = result['tasks']['update_movie_status']
logger.postprocess('Watcher3 updated status to {}'.format())
if update_movie_status == 'Finished':
return ProcessResult(
message='{0}: Successfully post-processed {1}'.format(section, input_name),
message=f'{section}: Successfully post-processed {input_name}',
status_code=status,
)
else:
return ProcessResult(
message='{0}: Failed to post-process - changed status to {1}'.format(section, result['tasks']['update_movie_status']),
message=f'{section}: Failed to post-process - changed status to {update_movie_status}',
status_code=1,
)
else:
logger.error('FAILED: {0} scan was unable to finish for folder {1}. exiting!'.format(method, dir_name),
logger.error(f'FAILED: {method} scan was unable to finish for folder {dir_name}. exiting!',
section)
return ProcessResult(
message='{0}: Failed to post-process - Server did not return success'.format(section),
message=f'{section}: Failed to post-process - Server did not return success',
status_code=1,
)
else:
core.FAILED = True
logger.postprocess('FAILED DOWNLOAD DETECTED FOR {0}'.format(input_name), section)
logger.postprocess(f'FAILED DOWNLOAD DETECTED FOR {input_name}', section)
if failure_link:
report_nzb(failure_link, client_agent)
if section == 'Radarr':
logger.postprocess('SUCCESS: Sending failed download to {0} for CDH processing'.format(section), section)
logger.postprocess(f'SUCCESS: Sending failed download to {section} for CDH processing', section)
return ProcessResult(
message='{0}: Sending failed download back to {0}'.format(section),
status_code=1, # Return as failed to flag this in the downloader.
) # Return failed flag, but log the event as successful.
elif section == 'Watcher3':
logger.postprocess('Sending failed download to {0} for CDH processing'.format(section), section)
logger.postprocess(f'Sending failed download to {section} for CDH processing', section)
path = remote_dir(dir_name) if remote_path else dir_name
if input_name and os.path.isfile(os.path.join(dir_name, input_name)):
path = os.path.join(path, input_name)
payload = {'apikey': apikey, 'path': path, 'guid': download_id, 'mode': 'failed'}
r = requests.post(base_url, data=payload, verify=False, timeout=(30, 1800))
result = r.json()
logger.postprocess('Watcher3 response: {0}'.format(result))
logger.postprocess(f'Watcher3 response: {result}')
if result['status'] == 'finished':
return ProcessResult(
message='{0}: Sending failed download back to {0}'.format(section),
@ -329,11 +330,11 @@ def process(
) # Return failed flag, but log the event as successful.
if delete_failed and os.path.isdir(dir_name) and not os.path.dirname(dir_name) == dir_name:
logger.postprocess('Deleting failed files and folder {0}'.format(dir_name), section)
logger.postprocess(f'Deleting failed files and folder {dir_name}', section)
remove_dir(dir_name)
if not release_id and not media_id:
logger.error('Could not find a downloaded movie in the database matching {0}, exiting!'.format(input_name),
logger.error(f'Could not find a downloaded movie in the database matching {input_name}, exiting!',
section)
return ProcessResult(
message='{0}: Failed to post-process - Failed download not found in {0}'.format(section),
@ -341,17 +342,17 @@ def process(
)
if release_id:
logger.postprocess('Setting failed release {0} to ignored ...'.format(input_name), section)
logger.postprocess(f'Setting failed release {input_name} to ignored ...', section)
url = '{url}release.ignore'.format(url=base_url)
url = f'{base_url}release.ignore'
params = {'id': release_id}
logger.debug('Opening URL: {0} with PARAMS: {1}'.format(url, params), section)
logger.debug(f'Opening URL: {url} with PARAMS: {params}', section)
try:
r = requests.get(url, params=params, verify=False, timeout=(30, 120))
except requests.ConnectionError:
logger.error('Unable to open URL {0}'.format(url), section)
logger.error(f'Unable to open URL {url}', section)
return ProcessResult(
message='{0}: Failed to post-process - Unable to connect to {0}'.format(section),
status_code=1,
@ -359,29 +360,29 @@ def process(
result = r.json()
if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
logger.error('Server returned status {0}'.format(r.status_code), section)
logger.error(f'Server returned status {r.status_code}', section)
return ProcessResult(
status_code=1,
message='{0}: Failed to post-process - Server returned status {1}'.format(section, r.status_code),
message=f'{section}: Failed to post-process - Server returned status {r.status_code}',
)
elif result['success']:
logger.postprocess('SUCCESS: {0} has been set to ignored ...'.format(input_name), section)
logger.postprocess(f'SUCCESS: {input_name} has been set to ignored ...', section)
else:
logger.warning('FAILED: Unable to set {0} to ignored!'.format(input_name), section)
logger.warning(f'FAILED: Unable to set {input_name} to ignored!', section)
return ProcessResult(
message='{0}: Failed to post-process - Unable to set {1} to ignored'.format(section, input_name),
message=f'{section}: Failed to post-process - Unable to set {input_name} to ignored',
status_code=1,
)
logger.postprocess('Trying to snatch the next highest ranked release.', section)
url = '{0}movie.searcher.try_next'.format(base_url)
logger.debug('Opening URL: {0}'.format(url), section)
url = f'{base_url}movie.searcher.try_next'
logger.debug(f'Opening URL: {url}', section)
try:
r = requests.get(url, params={'media_id': media_id}, verify=False, timeout=(30, 600))
except requests.ConnectionError:
logger.error('Unable to open URL {0}'.format(url), section)
logger.error(f'Unable to open URL {url}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Unable to connect to '
f'{section}'
@ -389,7 +390,7 @@ def process(
result = r.json()
if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
logger.error('Server returned status {0}'.format(r.status_code), section)
logger.error(f'Server returned status {r.status_code}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Server returned status '
f'{r.status_code}'
@ -431,25 +432,23 @@ def process(
release_status_new = release[release_id]['status']
if release_status_old is None: # we didn't have a release before, but now we do.
title = release[release_id]['title']
logger.postprocess('SUCCESS: Movie {0} has now been added to CouchPotato with release status of [{1}]'.format(
title, str(release_status_new).upper()), section)
logger.postprocess(f'SUCCESS: Movie {title} has now been added to CouchPotato with release status of [{str(release_status_new).upper()}]', section)
return ProcessResult.success(
f'{section}: Successfully post-processed {input_name}'
)
if release_status_new != release_status_old:
logger.postprocess('SUCCESS: Release {0} has now been marked with a status of [{1}]'.format(
release_id, str(release_status_new).upper()), section)
logger.postprocess(f'SUCCESS: Release {release_id} has now been marked with a status of [{str(release_status_new).upper()}]', section)
return ProcessResult.success(
f'{section}: Successfully post-processed {input_name}'
)
except Exception:
pass
elif scan_id:
url = '{0}/{1}'.format(base_url, scan_id)
url = f'{base_url}/{scan_id}'
command_status = command_complete(url, params, headers, section)
if command_status:
logger.debug('The Scan command return status: {0}'.format(command_status), section)
logger.debug(f'The Scan command return status: {command_status}', section)
if command_status in ['completed']:
logger.debug('The Scan command has completed successfully. Renaming was successful.', section)
return ProcessResult.success(
@ -463,15 +462,13 @@ def process(
# )
if not os.path.isdir(dir_name):
logger.postprocess('SUCCESS: Input Directory [{0}] has been processed and removed'.format(
dir_name), section)
logger.postprocess(f'SUCCESS: Input Directory [{dir_name}] has been processed and removed', section)
return ProcessResult.success(
f'{section}: Successfully post-processed {input_name}'
)
elif not list_media_files(dir_name, media=True, audio=False, meta=False, archives=True):
logger.postprocess('SUCCESS: Input Directory [{0}] has no remaining media files. This has been fully processed.'.format(
dir_name), section)
logger.postprocess(f'SUCCESS: Input Directory [{dir_name}] has no remaining media files. This has been fully processed.', section)
return ProcessResult.success(
f'{section}: Successfully post-processed {input_name}'
)
@ -481,13 +478,13 @@ def process(
# The status hasn't changed. we have waited wait_for minutes which is more than enough. uTorrent can resume seeding now.
if section == 'Radarr' and completed_download_handling(url2, headers, section=section):
logger.debug('The Scan command did not return status completed, but complete Download Handling is enabled. Passing back to {0}.'.format(section), section)
logger.debug(f'The Scan command did not return status completed, but complete Download Handling is enabled. Passing back to {section}.', section)
return ProcessResult.success(
f'{section}: Complete DownLoad Handling is enabled. Passing back '
f'to {section}'
)
logger.warning(
'{0} does not appear to have changed status after {1} minutes, Please check your logs.'.format(input_name, wait_for),
f'{input_name} does not appear to have changed status after {wait_for} minutes, Please check your logs.',
section,
)
@ -512,13 +509,13 @@ def get_release(base_url, imdb_id=None, download_id=None, release_id=None):
logger.debug('No information available to filter CP results')
return results
url = '{0}{1}'.format(base_url, cmd)
logger.debug('Opening URL: {0} with PARAMS: {1}'.format(url, params))
url = f'{base_url}{cmd}'
logger.debug(f'Opening URL: {url} with PARAMS: {params}')
try:
r = requests.get(url, params=params, verify=False, timeout=(30, 60))
except requests.ConnectionError:
logger.error('Unable to open URL {0}'.format(url))
logger.error(f'Unable to open URL {url}')
return results
try:
@ -527,14 +524,15 @@ def get_release(base_url, imdb_id=None, download_id=None, release_id=None):
# ValueError catches simplejson's JSONDecodeError and json's ValueError
logger.error('CouchPotato returned the following non-json data')
for line in r.iter_lines():
logger.error('{0}'.format(line))
logger.error(line)
return results
if not result['success']:
if 'error' in result:
logger.error('{0}'.format(result['error']))
logger.error(result['error'])
else:
logger.error('no media found for id {0}'.format(params['id']))
id_param = params['id']
logger.error(f'no media found for id {id_param}')
return results
# Gather release info and return it back, no need to narrow results

50
core/auto_process/music.py
View file

@ -94,7 +94,7 @@ def process(
input_name, dir_name = convert_to_ascii(input_name, dir_name)
if not list_media_files(dir_name, media=False, audio=True, meta=False, archives=False) and list_media_files(dir_name, media=False, audio=False, meta=False, archives=True) and extract:
logger.debug('Checking for archives to extract in directory: {0}'.format(dir_name))
logger.debug(f'Checking for archives to extract in directory: {dir_name}')
core.extract_files(dir_name)
input_name, dir_name = convert_to_ascii(input_name, dir_name)
@ -125,7 +125,7 @@ def process(
return res
# The status hasn't changed. uTorrent can resume seeding now.
logger.warning('The music album does not appear to have changed status after {0} minutes. Please check your Logs'.format(wait_for), section)
logger.warning(f'The music album does not appear to have changed status after {wait_for} minutes. Please check your Logs', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - No change in wanted status'
)
@ -135,17 +135,17 @@ def process(
url = core.utils.common.create_url(scheme, host, port, route)
headers = {'X-Api-Key': apikey}
if remote_path:
logger.debug('remote_path: {0}'.format(remote_dir(dir_name)), section)
logger.debug(f'remote_path: {remote_dir(dir_name)}', section)
data = {'name': 'Rename', 'path': remote_dir(dir_name)}
else:
logger.debug('path: {0}'.format(dir_name), section)
logger.debug(f'path: {dir_name}', section)
data = {'name': 'Rename', 'path': dir_name}
data = json.dumps(data)
try:
logger.debug('Opening URL: {0} with data: {1}'.format(url, data), section)
logger.debug(f'Opening URL: {url} with data: {data}', section)
r = requests.post(url, data=data, headers=headers, stream=True, verify=False, timeout=(30, 1800))
except requests.ConnectionError:
logger.error('Unable to open URL: {0}'.format(url), section)
logger.error(f'Unable to open URL: {url}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Unable to connect to '
f'{section}'
@ -154,16 +154,16 @@ def process(
try:
res = r.json()
scan_id = int(res['id'])
logger.debug('Scan started with id: {0}'.format(scan_id), section)
logger.debug(f'Scan started with id: {scan_id}', section)
except Exception as e:
logger.warning('No scan id was returned due to: {0}'.format(e), section)
logger.warning(f'No scan id was returned due to: {e}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Unable to start scan'
)
n = 0
params = {}
url = '{0}/{1}'.format(url, scan_id)
url = f'{url}/{scan_id}'
while n < 6: # set up wait_for minutes to see if command completes..
time.sleep(10 * wait_for)
command_status = command_complete(url, params, headers, section)
@ -171,9 +171,9 @@ def process(
break
n += 1
if command_status:
logger.debug('The Scan command return status: {0}'.format(command_status), section)
logger.debug(f'The Scan command return status: {command_status}', section)
if not os.path.exists(dir_name):
logger.debug('The directory {0} has been removed. Renaming was successful.'.format(dir_name), section)
logger.debug(f'The directory {dir_name} has been removed. Renaming was successful.', section)
return ProcessResult.success(
f'{section}: Successfully post-processed {input_name}'
)
@ -188,7 +188,7 @@ def process(
# f'{section}: Failed to post-process {input_name}'
# )
else:
logger.debug('The Scan command did not return status completed. Passing back to {0} to attempt complete download handling.'.format(section), section)
logger.debug(f'The Scan command did not return status completed. Passing back to {section} to attempt complete download handling.', section)
return ProcessResult(
message=f'{section}: Passing back to {section} to attempt '
f'Complete Download Handling',
@ -197,7 +197,7 @@ def process(
else:
if section == 'Lidarr':
logger.postprocess('FAILED: The download failed. Sending failed download to {0} for CDH processing'.format(section), section)
logger.postprocess(f'FAILED: The download failed. Sending failed download to {section} for CDH processing', section)
# Return as failed to flag this in the downloader.
return ProcessResult.failure(
f'{section}: Download Failed. Sending back to {section}'
@ -205,7 +205,7 @@ def process(
else:
logger.warning('FAILED DOWNLOAD DETECTED', section)
if delete_failed and os.path.isdir(dir_name) and not os.path.dirname(dir_name) == dir_name:
logger.postprocess('Deleting failed files and folder {0}'.format(dir_name), section)
logger.postprocess(f'Deleting failed files and folder {dir_name}', section)
remove_dir(dir_name)
# Return as failed to flag this in the downloader.
return ProcessResult.failure(
@ -215,14 +215,14 @@ def process(
def get_status(url, apikey, dir_name):
logger.debug('Attempting to get current status for release:{0}'.format(os.path.basename(dir_name)))
logger.debug(f'Attempting to get current status for release:{os.path.basename(dir_name)}')
params = {
'apikey': apikey,
'cmd': 'getHistory',
}
logger.debug('Opening URL: {0} with PARAMS: {1}'.format(url, params))
logger.debug(f'Opening URL: {url} with PARAMS: {params}')
try:
r = requests.get(url, params=params, verify=False, timeout=(30, 120))
@ -244,30 +244,30 @@ def get_status(url, apikey, dir_name):
def force_process(params, url, apikey, input_name, dir_name, section, wait_for):
release_status = get_status(url, apikey, dir_name)
if not release_status:
logger.error('Could not find a status for {0}, is it in the wanted list ?'.format(input_name), section)
logger.error(f'Could not find a status for {input_name}, is it in the wanted list ?', section)
logger.debug('Opening URL: {0} with PARAMS: {1}'.format(url, params), section)
logger.debug(f'Opening URL: {url} with PARAMS: {params}', section)
try:
r = requests.get(url, params=params, verify=False, timeout=(30, 300))
except requests.ConnectionError:
logger.error('Unable to open URL {0}'.format(url), section)
logger.error(f'Unable to open URL {url}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Unable to connect to '
f'{section}'
)
logger.debug('Result: {0}'.format(r.text), section)
logger.debug(f'Result: {r.text}', section)
if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
logger.error('Server returned status {0}'.format(r.status_code), section)
logger.error(f'Server returned status {r.status_code}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Server returned status {r.status_code}'
)
elif r.text == 'OK':
logger.postprocess('SUCCESS: Post-Processing started for {0} in folder {1} ...'.format(input_name, dir_name), section)
logger.postprocess(f'SUCCESS: Post-Processing started for {input_name} in folder {dir_name} ...', section)
else:
logger.error('FAILED: Post-Processing has NOT started for {0} in folder {1}. exiting!'.format(input_name, dir_name), section)
logger.error(f'FAILED: Post-Processing has NOT started for {input_name} in folder {dir_name}. exiting!', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Returned log from {section} '
f'was not as expected.'
@ -278,12 +278,12 @@ def force_process(params, url, apikey, input_name, dir_name, section, wait_for):
while time.time() < timeout:
current_status = get_status(url, apikey, dir_name)
if current_status is not None and current_status != release_status: # Something has changed. CPS must have processed this movie.
logger.postprocess('SUCCESS: This release is now marked as status [{0}]'.format(current_status), section)
logger.postprocess(f'SUCCESS: This release is now marked as status [{current_status}]', section)
return ProcessResult.success(
f'{section}: Successfully post-processed {input_name}'
)
if not os.path.isdir(dir_name):
logger.postprocess('SUCCESS: The input directory {0} has been removed Processing must have finished.'.format(dir_name), section)
logger.postprocess(f'SUCCESS: The input directory {dir_name} has been removed Processing must have finished.', section)
return ProcessResult.success(
f'{section}: Successfully post-processed {input_name}'
)

52
core/auto_process/tv.py
View file

@ -136,7 +136,7 @@ def process(
# Now check if tv files exist in destination.
if not list_media_files(dir_name, media=True, audio=False, meta=False, archives=False):
if list_media_files(dir_name, media=False, audio=False, meta=False, archives=True) and extract:
logger.debug('Checking for archives to extract in directory: {0}'.format(dir_name))
logger.debug(f'Checking for archives to extract in directory: {dir_name}')
core.extract_files(dir_name)
input_name, dir_name = convert_to_ascii(input_name, dir_name)
@ -167,13 +167,13 @@ def process(
if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][0:5] >= '14.0':
print('[NZB] MARK=BAD')
if good_files == num_files:
logger.debug('Video marked as failed due to missing required language: {0}'.format(core.REQUIRE_LAN), section)
logger.debug(f'Video marked as failed due to missing required language: {core.REQUIRE_LAN}', section)
else:
logger.debug('Video marked as failed due to missing playable audio or video', section)
if good_files < num_files and failure_link: # only report corrupt files
failure_link += '&corrupt=true'
elif client_agent == 'manual':
logger.warning('No media files found in directory {0} to manually process.'.format(dir_name), section)
logger.warning(f'No media files found in directory {dir_name} to manually process.', section)
# Success (as far as this script is concerned)
return ProcessResult.success()
elif nzb_extraction_by == 'Destination':
@ -187,7 +187,7 @@ def process(
status = 1
failed = 1
else:
logger.warning('No media files found in directory {0}. Processing this as a failed download'.format(dir_name), section)
logger.warning(f'No media files found in directory {dir_name}. Processing this as a failed download', section)
status = 1
failed = 1
if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][0:5] >= '14.0':
@ -196,15 +196,15 @@ def process(
if status == 0 and core.TRANSCODE == 1: # only transcode successful downloads
result, new_dir_name = transcoder.transcode_directory(dir_name)
if result == 0:
logger.debug('SUCCESS: Transcoding succeeded for files in {0}'.format(dir_name), section)
logger.debug(f'SUCCESS: Transcoding succeeded for files in {dir_name}', section)
dir_name = new_dir_name
logger.debug('Config setting \'chmodDirectory\' currently set to {0}'.format(oct(chmod_directory)), section)
logger.debug(f'Config setting \'chmodDirectory\' currently set to {oct(chmod_directory)}', section)
if chmod_directory:
logger.info('Attempting to set the octal permission of \'{0}\' on directory \'{1}\''.format(oct(chmod_directory), dir_name), section)
logger.info(f'Attempting to set the octal permission of \'{oct(chmod_directory)}\' on directory \'{dir_name}\'', section)
core.rchmod(dir_name, chmod_directory)
else:
logger.error('FAILED: Transcoding failed for files in {0}'.format(dir_name), section)
logger.error(f'FAILED: Transcoding failed for files in {dir_name}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Transcoding failed'
)
@ -290,17 +290,17 @@ def process(
if failure_link:
report_nzb(failure_link, client_agent)
if 'failed' in fork_params:
logger.postprocess('FAILED: The download failed. Sending \'failed\' process request to {0} branch'.format(fork), section)
logger.postprocess(f'FAILED: The download failed. Sending \'failed\' process request to {fork} branch', section)
elif section == 'NzbDrone':
logger.postprocess('FAILED: The download failed. Sending failed download to {0} for CDH processing'.format(fork), section)
logger.postprocess(f'FAILED: The download failed. Sending failed download to {fork} for CDH processing', section)
# Return as failed to flag this in the downloader.
return ProcessResult.failure(
f'{section}: Download Failed. Sending back to {section}'
)
else:
logger.postprocess('FAILED: The download failed. {0} branch does not handle failed downloads. Nothing to process'.format(fork), section)
logger.postprocess(f'FAILED: The download failed. {fork} branch does not handle failed downloads. Nothing to process', section)
if delete_failed and os.path.isdir(dir_name) and not os.path.dirname(dir_name) == dir_name:
logger.postprocess('Deleting failed files and folder {0}'.format(dir_name), section)
logger.postprocess(f'Deleting failed files and folder {dir_name}', section)
remove_dir(dir_name)
# Return as failed to flag this in the downloader.
return ProcessResult.failure(
@ -330,10 +330,10 @@ def process(
headers = {'X-Api-Key': apikey}
# params = {'sortKey': 'series.title', 'page': 1, 'pageSize': 1, 'sortDir': 'asc'}
if remote_path:
logger.debug('remote_path: {0}'.format(remote_dir(dir_name)), section)
logger.debug(f'remote_path: {remote_dir(dir_name)}', section)
data = {'name': 'DownloadedEpisodesScan', 'path': remote_dir(dir_name), 'downloadClientId': download_id, 'importMode': import_mode}
else:
logger.debug('path: {0}'.format(dir_name), section)
logger.debug(f'path: {dir_name}', section)
data = {'name': 'DownloadedEpisodesScan', 'path': dir_name, 'downloadClientId': download_id, 'importMode': import_mode}
if not download_id:
data.pop('downloadClientId')
@ -346,7 +346,7 @@ def process(
else:
s = requests.Session()
logger.debug('Opening URL: {0} with params: {1}'.format(url, fork_params), section)
logger.debug(f'Opening URL: {url} with params: {fork_params}', section)
if not apikey and username and password:
login = f'{web_root}/login'
login_params = {'username': username, 'password': password}
@ -381,17 +381,17 @@ def process(
r = s.get(url, params=params, stream=True, verify=False, timeout=(30, 1800))
elif section == 'NzbDrone':
logger.debug('Opening URL: {0} with data: {1}'.format(url, data), section)
logger.debug(f'Opening URL: {url} with data: {data}', section)
r = requests.post(url, data=data, headers=headers, stream=True, verify=False, timeout=(30, 1800))
except requests.ConnectionError:
logger.error('Unable to open URL: {0}'.format(url), section)
logger.error(f'Unable to open URL: {url}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Unable to connect to '
f'{section}'
)
if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
logger.error('Server returned status {0}'.format(r.status_code), section)
logger.error(f'Server returned status {r.status_code}', section)
return ProcessResult.failure(
f'{section}: Failed to post-process - Server returned status '
f'{r.status_code}'
@ -408,7 +408,7 @@ def process(
for line in r.iter_lines():
if line:
line = line.decode('utf-8')
logger.postprocess('{0}'.format(line), section)
logger.postprocess(line, section)
if 'Moving file from' in line:
input_name = os.path.split(line)[1]
if 'added to the queue' in line:
@ -428,15 +428,15 @@ def process(
try:
res = r.json()
scan_id = int(res['id'])
logger.debug('Scan started with id: {0}'.format(scan_id), section)
logger.debug(f'Scan started with id: {scan_id}', section)
started = True
except Exception as e:
logger.warning('No scan id was returned due to: {0}'.format(e), section)
logger.warning(f'No scan id was returned due to: {e}', section)
scan_id = None
started = False
if status != 0 and delete_failed and not os.path.dirname(dir_name) == dir_name:
logger.postprocess('Deleting failed files and folder {0}'.format(dir_name), section)
logger.postprocess(f'Deleting failed files and folder {dir_name}', section)
remove_dir(dir_name)
if success:
@ -446,7 +446,7 @@ def process(
elif section == 'NzbDrone' and started:
n = 0
params = {}
url = '{0}/{1}'.format(url, scan_id)
url = f'{url}/{scan_id}'
while n < 6: # set up wait_for minutes to see if command completes..
time.sleep(10 * wait_for)
command_status = command_complete(url, params, headers, section)
@ -454,9 +454,9 @@ def process(
break
n += 1
if command_status:
logger.debug('The Scan command return status: {0}'.format(command_status), section)
logger.debug(f'The Scan command return status: {command_status}', section)
if not os.path.exists(dir_name):
logger.debug('The directory {0} has been removed. Renaming was successful.'.format(dir_name), section)
logger.debug(f'The directory {dir_name} has been removed. Renaming was successful.', section)
return ProcessResult.success(
f'{section}: Successfully post-processed {input_name}'
)
@ -473,7 +473,7 @@ def process(
url2 = core.utils.common.create_url(scheme, host, port, route)
if completed_download_handling(url2, headers, section=section):
logger.debug('The Scan command did not return status completed, but complete Download Handling is enabled. Passing back to {0}.'.format(section),
logger.debug(f'The Scan command did not return status completed, but complete Download Handling is enabled. Passing back to {section}.',
section)
return ProcessResult(
message=f'{section}: Complete DownLoad Handling is enabled. '

54
core/configuration.py
View file

@ -9,7 +9,7 @@ import core
from core import logger
class Section(configobj.Section, object):
class Section(configobj.Section):
def isenabled(self):
# checks if subsection enabled, returns true/false if subsection specified otherwise returns true/false in {}
if not self.sections:
@ -96,14 +96,12 @@ class ConfigObj(configobj.ConfigObj, Section):
def find_key(node, kv):
if isinstance(node, list):
for i in node:
for x in ConfigObj.find_key(i, kv):
yield x
yield from ConfigObj.find_key(i, kv)
elif isinstance(node, dict):
if kv in node:
yield node[kv]
for j in node.values():
for x in ConfigObj.find_key(j, kv):
yield x
yield from ConfigObj.find_key(j, kv)
@staticmethod
def migrate():
@ -117,7 +115,7 @@ class ConfigObj(configobj.ConfigObj, Section):
shutil.copyfile(core.CONFIG_SPEC_FILE, core.CONFIG_FILE)
CFG_OLD = config(core.CONFIG_FILE)
except Exception as error:
logger.error('Error {msg} when copying to .cfg'.format(msg=error))
logger.error(f'Error {error} when copying to .cfg')
try:
# check for autoProcessMedia.cfg.spec and create if it does not exist
@ -125,7 +123,7 @@ class ConfigObj(configobj.ConfigObj, Section):
shutil.copyfile(core.CONFIG_FILE, core.CONFIG_SPEC_FILE)
CFG_NEW = config(core.CONFIG_SPEC_FILE)
except Exception as error:
logger.error('Error {msg} when copying to .spec'.format(msg=error))
logger.error(f'Error {error} when copying to .spec')
# check for autoProcessMedia.cfg and autoProcessMedia.cfg.spec and if they don't exist return and fail
if CFG_NEW is None or CFG_OLD is None:
@ -264,7 +262,7 @@ class ConfigObj(configobj.ConfigObj, Section):
CFG_NEW['SickBeard']['tv']['fork'] = 'auto'
# create a backup of our old config
CFG_OLD.filename = '{config}.old'.format(config=core.CONFIG_FILE)
CFG_OLD.filename = f'{core.CONFIG_FILE}.old'
CFG_OLD.write()
# write our new config to autoProcessMedia.cfg
@ -315,7 +313,7 @@ class ConfigObj(configobj.ConfigObj, Section):
env_keys = ['AUTO_UPDATE', 'CHECK_MEDIA', 'REQUIRE_LAN', 'SAFE_MODE', 'NO_EXTRACT_FAILED']
cfg_keys = ['auto_update', 'check_media', 'require_lan', 'safe_mode', 'no_extract_failed']
for index in range(len(env_keys)):
key = 'NZBPO_{index}'.format(index=env_keys[index])
key = f'NZBPO_{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -325,7 +323,7 @@ class ConfigObj(configobj.ConfigObj, Section):
env_keys = ['MOUNTPOINTS']
cfg_keys = ['mount_points']
for index in range(len(env_keys)):
key = 'NZBPO_{index}'.format(index=env_keys[index])
key = f'NZBPO_{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -339,7 +337,7 @@ class ConfigObj(configobj.ConfigObj, Section):
'wait_for', 'watch_dir', 'omdbapikey']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_CPS{index}'.format(index=env_keys[index])
key = f'NZBPO_CPS{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -360,7 +358,7 @@ class ConfigObj(configobj.ConfigObj, Section):
'wait_for', 'watch_dir', 'omdbapikey']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_W3{index}'.format(index=env_keys[index])
key = f'NZBPO_W3{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -381,7 +379,7 @@ class ConfigObj(configobj.ConfigObj, Section):
'nzbExtractionBy', 'remote_path', 'process_method']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_SB{index}'.format(index=env_keys[index])
key = f'NZBPO_SB{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -402,7 +400,7 @@ class ConfigObj(configobj.ConfigObj, Section):
'delete_failed', 'Torrent_NoLink', 'nzbExtractionBy', 'remote_path', 'process_method']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_SR{index}'.format(index=env_keys[index])
key = f'NZBPO_SR{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -421,7 +419,7 @@ class ConfigObj(configobj.ConfigObj, Section):
cfg_keys = ['enabled', 'apikey', 'host', 'port', 'ssl', 'web_root', 'wait_for', 'watch_dir', 'remote_path', 'delete_failed']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_HP{index}'.format(index=env_keys[index])
key = f'NZBPO_HP{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -440,7 +438,7 @@ class ConfigObj(configobj.ConfigObj, Section):
'remote_path']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_MY{index}'.format(index=env_keys[index])
key = f'NZBPO_MY{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -455,7 +453,7 @@ class ConfigObj(configobj.ConfigObj, Section):
cfg_keys = ['enabled', 'apikey', 'host', 'port', 'ssl', 'web_root', 'watch_dir', 'library', 'remote_path']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_GZ{index}'.format(index=env_keys[index])
key = f'NZBPO_GZ{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -470,7 +468,7 @@ class ConfigObj(configobj.ConfigObj, Section):
cfg_keys = ['enabled', 'apikey', 'host', 'port', 'ssl', 'web_root', 'watch_dir', 'remote_path']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_LL{index}'.format(index=env_keys[index])
key = f'NZBPO_LL{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -488,7 +486,7 @@ class ConfigObj(configobj.ConfigObj, Section):
'Torrent_NoLink', 'nzbExtractionBy', 'wait_for', 'delete_failed', 'remote_path', 'importMode']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_ND{index}'.format(index=env_keys[index])
key = f'NZBPO_ND{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -510,7 +508,7 @@ class ConfigObj(configobj.ConfigObj, Section):
'Torrent_NoLink', 'nzbExtractionBy', 'wait_for', 'delete_failed', 'remote_path', 'omdbapikey', 'importMode']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_RA{index}'.format(index=env_keys[index])
key = f'NZBPO_RA{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -531,7 +529,7 @@ class ConfigObj(configobj.ConfigObj, Section):
'Torrent_NoLink', 'nzbExtractionBy', 'wait_for', 'delete_failed', 'remote_path']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_LI{index}'.format(index=env_keys[index])
key = f'NZBPO_LI{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -546,7 +544,7 @@ class ConfigObj(configobj.ConfigObj, Section):
env_keys = ['COMPRESSEDEXTENSIONS', 'MEDIAEXTENSIONS', 'METAEXTENSIONS']
cfg_keys = ['compressedExtensions', 'mediaExtensions', 'metaExtensions']
for index in range(len(env_keys)):
key = 'NZBPO_{index}'.format(index=env_keys[index])
key = f'NZBPO_{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -556,7 +554,7 @@ class ConfigObj(configobj.ConfigObj, Section):
env_keys = ['NICENESS', 'IONICE_CLASS', 'IONICE_CLASSDATA']
cfg_keys = ['niceness', 'ionice_class', 'ionice_classdata']
for index in range(len(env_keys)):
key = 'NZBPO_{index}'.format(index=env_keys[index])
key = f'NZBPO_{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -584,7 +582,7 @@ class ConfigObj(configobj.ConfigObj, Section):
'outputSubtitleCodec', 'outputAudioChannels', 'outputAudioTrack2Channels',
'outputAudioOtherChannels', 'outputVideoResolution']
for index in range(len(env_keys)):
key = 'NZBPO_{index}'.format(index=env_keys[index])
key = f'NZBPO_{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -594,7 +592,7 @@ class ConfigObj(configobj.ConfigObj, Section):
env_keys = ['WAKE', 'HOST', 'PORT', 'MAC']
cfg_keys = ['wake', 'host', 'port', 'mac']
for index in range(len(env_keys)):
key = 'NZBPO_WOL{index}'.format(index=env_keys[index])
key = f'NZBPO_WOL{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -608,7 +606,7 @@ class ConfigObj(configobj.ConfigObj, Section):
'user_script_successCodes', 'user_script_clean', 'delay', 'remote_path']
if env_cat_key in os.environ:
for index in range(len(env_keys)):
key = 'NZBPO_{index}'.format(index=env_keys[index])
key = f'NZBPO_{env_keys[index]}'
if key in os.environ:
option = cfg_keys[index]
value = os.environ[key]
@ -618,14 +616,14 @@ class ConfigObj(configobj.ConfigObj, Section):
cfg_new[section][os.environ[env_cat_key]]['enabled'] = 1
except Exception as error:
logger.debug('Error {msg} when applying NZBGet config'.format(msg=error))
logger.debug(f'Error {error} when applying NZBGet config')
try:
# write our new config to autoProcessMedia.cfg
cfg_new.filename = core.CONFIG_FILE
cfg_new.write()
except Exception as error:
logger.debug('Error {msg} when writing changes to .cfg'.format(msg=error))
logger.debug(f'Error {error} when writing changes to .cfg')
return cfg_new

4
core/extractor/__init__.py
View file

@ -73,7 +73,7 @@ def extract(file_path, output_destination):
if ext[1] in ('.gz', '.bz2', '.lzma'):
# Check if this is a tar
if os.path.splitext(ext[0])[1] == '.tar':
cmd = extract_commands['.tar{ext}'.format(ext=ext[1])]
cmd = extract_commands[f'.tar{ext[1]}']
else: # Try gunzip
cmd = extract_commands[ext[1]]
elif ext[1] in ('.1', '.01', '.001') and os.path.splitext(ext[0])[1] in ('.rar', '.zip', '.7z'):
@ -137,7 +137,7 @@ def extract(file_path, output_destination):
continue
cmd2 = cmd
# append password here.
passcmd = '-p{pwd}'.format(pwd=password)
passcmd = f'-p{password}'
cmd2.append(passcmd)
p = Popen(cmd2, stdout=devnull, stderr=devnull, startupinfo=info) # should extract files fine.
res = p.wait()

2
core/github_api.py
View file

@ -45,6 +45,6 @@ class GitHub:
"""
return self._access_api(
['repos', self.github_repo_user, self.github_repo, 'compare',
'{base}...{head}'.format(base=base, head=head)],
f'{base}...{head}'],
params={'per_page': per_page},
)

6
core/logger.py
View file

@ -133,7 +133,7 @@ class NTMRotatingLogHandler:
i: Log number to ues
"""
return self.log_file_path + ('.{0}'.format(i) if i else '')
return self.log_file_path + (f'.{i}' if i else '')
def _num_logs(self):
"""
@ -189,9 +189,9 @@ class NTMRotatingLogHandler:
self.writes_since_check += 1
try:
message = '{0}: {1}'.format(section.upper(), to_log)
message = f'{section.upper()}: {to_log}'
except UnicodeError:
message = '{0}: Message contains non-utf-8 string'.format(section.upper())
message = f'{section.upper()}: Message contains non-utf-8 string'
out_line = message

36
core/main_db.py
View file

@ -17,7 +17,7 @@ def db_filename(filename='nzbtomedia.db', suffix=None):
@return: the correct location of the database file.
"""
if suffix:
filename = '{0}.{1}'.format(filename, suffix)
filename = f'{filename}.{suffix}'
return core.os.path.join(core.APP_ROOT, filename)
@ -51,7 +51,7 @@ class DBConnection:
while attempt < 5:
try:
if args is None:
logger.log('{name}: {query}'.format(name=self.filename, query=query), logger.DB)
logger.log(f'{self.filename}: {query}', logger.DB)
cursor = self.connection.cursor()
cursor.execute(query)
sql_result = cursor.fetchone()[0]
@ -66,14 +66,14 @@ class DBConnection:
break
except sqlite3.OperationalError as error:
if 'unable to open database file' in error.args[0] or 'database is locked' in error.args[0]:
logger.log('DB error: {msg}'.format(msg=error), logger.WARNING)
logger.log(f'DB error: {error}', logger.WARNING)
attempt += 1
time.sleep(1)
else:
logger.log('DB error: {msg}'.format(msg=error), logger.ERROR)
logger.log(f'DB error: {error}', logger.ERROR)
raise
except sqlite3.DatabaseError as error:
logger.log('Fatal error executing query: {msg}'.format(msg=error), logger.ERROR)
logger.log(f'Fatal error executing query: {error}', logger.ERROR)
raise
return sql_result
@ -94,26 +94,26 @@ class DBConnection:
sql_result.append(self.connection.execute(qu[0]))
elif len(qu) > 1:
if log_transaction:
logger.log('{query} with args {args}'.format(query=qu[0], args=qu[1]), logger.DEBUG)
logger.log(f'{qu[0]} with args {qu[1]}', logger.DEBUG)
sql_result.append(self.connection.execute(qu[0], qu[1]))
self.connection.commit()
logger.log('Transaction with {x} query\'s executed'.format(x=len(querylist)), logger.DEBUG)
logger.log(f'Transaction with {len(querylist)} query\'s executed', logger.DEBUG)
return sql_result
except sqlite3.OperationalError as error:
sql_result = []
if self.connection:
self.connection.rollback()
if 'unable to open database file' in error.args[0] or 'database is locked' in error.args[0]:
logger.log('DB error: {msg}'.format(msg=error), logger.WARNING)
logger.log(f'DB error: {error}', logger.WARNING)
attempt += 1
time.sleep(1)
else:
logger.log('DB error: {msg}'.format(msg=error), logger.ERROR)
logger.log(f'DB error: {error}', logger.ERROR)
raise
except sqlite3.DatabaseError as error:
if self.connection:
self.connection.rollback()
logger.log('Fatal error executing query: {msg}'.format(msg=error), logger.ERROR)
logger.log(f'Fatal error executing query: {error}', logger.ERROR)
raise
return sql_result
@ -128,7 +128,7 @@ class DBConnection:
while attempt < 5:
try:
if args is None:
logger.log('{name}: {query}'.format(name=self.filename, query=query), logger.DB)
logger.log(f'{self.filename}: {query}', logger.DB)
sql_result = self.connection.execute(query)
else:
logger.log('{name}: {query} with args {args}'.format
@ -139,14 +139,14 @@ class DBConnection:
break
except sqlite3.OperationalError as error:
if 'unable to open database file' in error.args[0] or 'database is locked' in error.args[0]:
logger.log('DB error: {msg}'.format(msg=error), logger.WARNING)
logger.log(f'DB error: {error}', logger.WARNING)
attempt += 1
time.sleep(1)
else:
logger.log('DB error: {msg}'.format(msg=error), logger.ERROR)
logger.log(f'DB error: {error}', logger.ERROR)
raise
except sqlite3.DatabaseError as error:
logger.log('Fatal error executing query: {msg}'.format(msg=error), logger.ERROR)
logger.log(f'Fatal error executing query: {error}', logger.ERROR)
raise
return sql_result
@ -164,7 +164,7 @@ class DBConnection:
def gen_params(my_dict):
return [
'{key} = ?'.format(key=k)
f'{k} = ?'
for k in my_dict.keys()
]
@ -194,7 +194,7 @@ class DBConnection:
def table_info(self, table_name):
# FIXME ? binding is not supported here, but I cannot find a way to escape a string manually
cursor = self.connection.execute('PRAGMA table_info({0})'.format(table_name))
cursor = self.connection.execute(f'PRAGMA table_info({table_name})')
return {
column['name']: {'type': column['type']}
for column in cursor
@ -261,8 +261,8 @@ class SchemaUpgrade:
return column in self.connection.table_info(table_name)
def add_column(self, table, column, data_type='NUMERIC', default=0):
self.connection.action('ALTER TABLE {0} ADD {1} {2}'.format(table, column, data_type))
self.connection.action('UPDATE {0} SET {1} = ?'.format(table, column), (default,))
self.connection.action(f'ALTER TABLE {table} ADD {column} {data_type}')
self.connection.action(f'UPDATE {table} SET {column} = ?', (default,))
def check_db_version(self):
result = self.connection.select('SELECT db_version FROM db_version')

8
core/plugins/downloaders/nzb/utils.py
View file

@ -11,9 +11,9 @@ def get_nzoid(input_name):
slots = []
logger.debug('Searching for nzoid from SAbnzbd ...')
if 'http' in core.SABNZBD_HOST:
base_url = '{0}:{1}/api'.format(core.SABNZBD_HOST, core.SABNZBD_PORT)
base_url = f'{core.SABNZBD_HOST}:{core.SABNZBD_PORT}/api'
else:
base_url = 'http://{0}:{1}/api'.format(core.SABNZBD_HOST, core.SABNZBD_PORT)
base_url = f'http://{core.SABNZBD_HOST}:{core.SABNZBD_PORT}/api'
url = base_url
params = {
'apikey': core.SABNZBD_APIKEY,
@ -47,7 +47,7 @@ def get_nzoid(input_name):
for nzo_id, name in slots:
if name in [input_name, clean_name]:
nzoid = nzo_id
logger.debug('Found nzoid: {0}'.format(nzoid))
logger.debug(f'Found nzoid: {nzoid}')
break
except Exception:
logger.warning('Data from SABnzbd could not be parsed')
@ -66,5 +66,5 @@ def report_nzb(failure_link, client_agent):
try:
requests.post(failure_link, headers=headers, timeout=(30, 300))
except Exception as e:
logger.error('Unable to open URL {0} due to {1}'.format(failure_link, e))
logger.error(f'Unable to open URL {failure_link} due to {e}')
return

2
core/plugins/downloaders/torrent/deluge.py
View file

@ -11,7 +11,7 @@ def configure_client():
user = core.DELUGE_USER
password = core.DELUGE_PASSWORD
logger.debug('Connecting to {0}: http://{1}:{2}'.format(agent, host, port))
logger.debug(f'Connecting to {agent}: http://{host}:{port}')
client = DelugeRPCClient(host, port, user, password)
try:
client.connect()

4
core/plugins/downloaders/torrent/qbittorrent.py
View file

@ -12,9 +12,9 @@ def configure_client():
password = core.QBITTORRENT_PASSWORD
logger.debug(
'Connecting to {0}: http://{1}:{2}'.format(agent, host, port),
f'Connecting to {agent}: http://{host}:{port}',
)
client = qBittorrentClient('http://{0}:{1}/'.format(host, port))
client = qBittorrentClient(f'http://{host}:{port}/')
try:
client.login(user, password)
except Exception:

2
core/plugins/downloaders/torrent/synology.py
View file

@ -11,7 +11,7 @@ def configure_client():
user = core.SYNO_USER
password = core.SYNO_PASSWORD
logger.debug('Connecting to {0}: http://{1}:{2}'.format(agent, host, port))
logger.debug(f'Connecting to {agent}: http://{host}:{port}')
try:
client = DownloadStation(host, port, user, password)
except Exception:

2
core/plugins/downloaders/torrent/transmission.py
View file

@ -11,7 +11,7 @@ def configure_client():
user = core.TRANSMISSION_USER
password = core.TRANSMISSION_PASSWORD
logger.debug('Connecting to {0}: http://{1}:{2}'.format(agent, host, port))
logger.debug(f'Connecting to {agent}: http://{host}:{port}')
try:
client = TransmissionClient(host, port, user, password)
except Exception:

12
core/plugins/downloaders/torrent/utils.py
View file

@ -28,7 +28,7 @@ def create_torrent_class(client_agent):
def pause_torrent(client_agent, input_hash, input_id, input_name):
logger.debug('Stopping torrent {0} in {1} while processing'.format(input_name, client_agent))
logger.debug(f'Stopping torrent {input_name} in {client_agent} while processing')
try:
if client_agent == 'utorrent' and core.TORRENT_CLASS != '':
core.TORRENT_CLASS.stop(input_hash)
@ -42,13 +42,13 @@ def pause_torrent(client_agent, input_hash, input_id, input_name):
core.TORRENT_CLASS.pause(input_hash)
time.sleep(5)
except Exception:
logger.warning('Failed to stop torrent {0} in {1}'.format(input_name, client_agent))
logger.warning(f'Failed to stop torrent {input_name} in {client_agent}')
def resume_torrent(client_agent, input_hash, input_id, input_name):
if not core.TORRENT_RESUME == 1:
return
logger.debug('Starting torrent {0} in {1}'.format(input_name, client_agent))
logger.debug(f'Starting torrent {input_name} in {client_agent}')
try:
if client_agent == 'utorrent' and core.TORRENT_CLASS != '':
core.TORRENT_CLASS.start(input_hash)
@ -62,12 +62,12 @@ def resume_torrent(client_agent, input_hash, input_id, input_name):
core.TORRENT_CLASS.resume(input_hash)
time.sleep(5)
except Exception:
logger.warning('Failed to start torrent {0} in {1}'.format(input_name, client_agent))
logger.warning(f'Failed to start torrent {input_name} in {client_agent}')
def remove_torrent(client_agent, input_hash, input_id, input_name):
if core.DELETE_ORIGINAL == 1 or core.USE_LINK == 'move':
logger.debug('Deleting torrent {0} from {1}'.format(input_name, client_agent))
logger.debug(f'Deleting torrent {input_name} from {client_agent}')
try:
if client_agent == 'utorrent' and core.TORRENT_CLASS != '':
core.TORRENT_CLASS.removedata(input_hash)
@ -82,6 +82,6 @@ def remove_torrent(client_agent, input_hash, input_id, input_name):
core.TORRENT_CLASS.delete_permanently(input_hash)
time.sleep(5)
except Exception:
logger.warning('Failed to delete torrent {0} in {1}'.format(input_name, client_agent))
logger.warning(f'Failed to delete torrent {input_name} in {client_agent}')
else:
resume_torrent(client_agent, input_hash, input_id, input_name)

2
core/plugins/downloaders/torrent/utorrent.py
View file

@ -10,7 +10,7 @@ def configure_client():
user = core.UTORRENT_USER
password = core.UTORRENT_PASSWORD
logger.debug('Connecting to {0}: {1}'.format(agent, web_ui))
logger.debug(f'Connecting to {agent}: {web_ui}')
try:
client = UTorrentClient(web_ui, user, password)
except Exception:

4
core/plugins/plex.py
View file

@ -33,13 +33,13 @@ def plex_update(category):
section = None
if not core.PLEX_SECTION:
return
logger.debug('Attempting to update Plex Library for category {0}.'.format(category), 'PLEX')
logger.debug(f'Attempting to update Plex Library for category {category}.', 'PLEX')
for item in core.PLEX_SECTION:
if item[0] == category:
section = item[1]
if section:
url = '{url}{section}/refresh?X-Plex-Token={token}'.format(url=url, section=section, token=core.PLEX_TOKEN)
url = f'{url}{section}/refresh?X-Plex-Token={core.PLEX_TOKEN}'
requests.get(url, timeout=(60, 120), verify=False)
logger.debug('Plex Library has been refreshed.', 'PLEX')
else:

18
core/plugins/subtitles.py
View file

@ -29,7 +29,7 @@ def import_subs(filename):
if not languages:
return
logger.info('Attempting to download subtitles for {0}'.format(filename), 'SUBTITLES')
logger.info(f'Attempting to download subtitles for {filename}', 'SUBTITLES')
try:
video = subliminal.scan_video(filename)
subtitles = subliminal.download_best_subtitles({video}, languages)
@ -39,7 +39,7 @@ def import_subs(filename):
subtitle_path = subliminal.subtitle.get_subtitle_path(video.name, subtitle.language)
os.chmod(subtitle_path, 0o644)
except Exception as e:
logger.error('Failed to download subtitles for {0} due to: {1}'.format(filename, e), 'SUBTITLES')
logger.error(f'Failed to download subtitles for {filename} due to: {e}', 'SUBTITLES')
def rename_subs(path):
filepaths = []
@ -78,17 +78,17 @@ def rename_subs(path):
# could call ffprobe to parse the sub information and get language if lan unknown here.
new_sub_name = name
else:
new_sub_name = '{name}.{lan}'.format(name=name, lan=str(lan))
new_sub_name = f'{name}.{str(lan)}'
new_sub = os.path.join(directory, new_sub_name) # full path and name less ext
if '{new_sub}{ext}'.format(new_sub=new_sub, ext=ext) in renamed: # If duplicate names, add unique number before ext.
if f'{new_sub}{ext}' in renamed: # If duplicate names, add unique number before ext.
for i in range(1,len(renamed)+1):
if '{new_sub}.{i}{ext}'.format(new_sub=new_sub, i=i, ext=ext) in renamed:
if f'{new_sub}.{i}{ext}' in renamed:
continue
new_sub = '{new_sub}.{i}'.format(new_sub=new_sub, i=i)
new_sub = f'{new_sub}.{i}'
break
new_sub = '{new_sub}{ext}'.format(new_sub=new_sub, ext=ext) # add extension now
new_sub = f'{new_sub}{ext}' # add extension now
if os.path.isfile(new_sub): # Don't copy over existing - final check.
logger.debug('Unable to rename sub file {old} as destination {new} already exists'.format(old=sub, new=new_sub))
logger.debug(f'Unable to rename sub file {sub} as destination {new_sub} already exists')
continue
logger.debug('Renaming sub file from {old} to {new}'.format
(old=sub, new=new_sub))
@ -96,5 +96,5 @@ def rename_subs(path):
try:
os.rename(sub, new_sub)
except Exception as error:
logger.error('Unable to rename sub file due to: {error}'.format(error=error))
logger.error(f'Unable to rename sub file due to: {error}')
return

18
core/processor/manual.py
View file

@ -27,24 +27,19 @@ def process():
continue
for dir_name in get_dirs(section, subsection, link='move'):
logger.info(
'Starting manual run for {0}:{1} - Folder: {2}'.format(
section, subsection, dir_name))
f'Starting manual run for {section}:{subsection} - Folder: {dir_name}')
logger.info(
'Checking database for download info for {0} ...'.format(
os.path.basename(dir_name)))
f'Checking database for download info for {os.path.basename(dir_name)} ...'
)
core.DOWNLOAD_INFO = get_download_info(
os.path.basename(dir_name), 0)
if core.DOWNLOAD_INFO:
logger.info('Found download info for {0}, '
'setting variables now ...'.format
(os.path.basename(dir_name)))
logger.info(f'Found download info for {os.path.basename(dir_name)}, setting variables now ...')
client_agent = core.DOWNLOAD_INFO[0]['client_agent'] or 'manual'
download_id = core.DOWNLOAD_INFO[0]['input_id'] or ''
else:
logger.info('Unable to locate download info for {0}, '
'continuing to try and process this release ...'.format
(os.path.basename(dir_name)))
logger.info(f'Unable to locate download info for {os.path.basename(dir_name)}, continuing to try and process this release ...')
client_agent = 'manual'
download_id = ''
@ -59,7 +54,6 @@ def process():
input_category=subsection)
if results.status_code != 0:
logger.error(
'A problem was reported when trying to perform a manual run for {0}:{1}.'.format
(section, subsection))
f'A problem was reported when trying to perform a manual run for {section}:{subsection}.')
result = results
return result

27
core/processor/nzb.py
View file

@ -19,8 +19,7 @@ from core.utils import (
def process(input_directory, input_name=None, status=0, client_agent='manual', download_id=None, input_category=None, failure_link=None):
if core.SAFE_MODE and input_directory == core.NZB_DEFAULT_DIRECTORY:
logger.error(
'The input directory:[{0}] is the Default Download Directory. Please configure category directories to prevent processing of other media.'.format(
input_directory))
f'The input directory:[{input_directory}] is the Default Download Directory. Please configure category directories to prevent processing of other media.')
return ProcessResult(
message='',
status_code=-1,
@ -30,7 +29,7 @@ def process(input_directory, input_name=None, status=0, client_agent='manual', d
download_id = get_nzoid(input_name)
if client_agent != 'manual' and not core.DOWNLOAD_INFO:
logger.debug('Adding NZB download info for directory {0} to database'.format(input_directory))
logger.debug(f'Adding NZB download info for directory {input_directory} to database')
my_db = main_db.DBConnection()
@ -63,8 +62,7 @@ def process(input_directory, input_name=None, status=0, client_agent='manual', d
section = core.CFG.findsection('ALL').isenabled()
if section is None:
logger.error(
'Category:[{0}] is not defined or is not enabled. Please rename it or ensure it is enabled for the appropriate section in your autoProcessMedia.cfg and try again.'.format(
input_category))
f'Category:[{input_category}] is not defined or is not enabled. Please rename it or ensure it is enabled for the appropriate section in your autoProcessMedia.cfg and try again.')
return ProcessResult(
message='',
status_code=-1,
@ -74,8 +72,7 @@ def process(input_directory, input_name=None, status=0, client_agent='manual', d
if len(section) > 1:
logger.error(
'Category:[{0}] is not unique, {1} are using it. Please rename it or disable all other sections using the same category name in your autoProcessMedia.cfg and try again.'.format(
input_category, section.keys()))
f'Category:[{input_category}] is not unique, {section.keys()} are using it. Please rename it or disable all other sections using the same category name in your autoProcessMedia.cfg and try again.')
return ProcessResult(
message='',
status_code=-1,
@ -83,10 +80,9 @@ def process(input_directory, input_name=None, status=0, client_agent='manual', d
if section:
section_name = section.keys()[0]
logger.info('Auto-detected SECTION:{0}'.format(section_name))
logger.info(f'Auto-detected SECTION:{section_name}')
else:
logger.error('Unable to locate a section with subsection:{0} enabled in your autoProcessMedia.cfg, exiting!'.format(
input_category))
logger.error(f'Unable to locate a section with subsection:{input_category} enabled in your autoProcessMedia.cfg, exiting!')
return ProcessResult(
status_code=-1,
message='',
@ -98,23 +94,22 @@ def process(input_directory, input_name=None, status=0, client_agent='manual', d
try:
if int(cfg.get('remote_path')) and not core.REMOTE_PATHS:
logger.error('Remote Path is enabled for {0}:{1} but no Network mount points are defined. Please check your autoProcessMedia.cfg, exiting!'.format(
section_name, input_category))
logger.error(f'Remote Path is enabled for {section_name}:{input_category} but no Network mount points are defined. Please check your autoProcessMedia.cfg, exiting!')
return ProcessResult(
status_code=-1,
message='',
)
except Exception:
logger.error('Remote Path {0} is not valid for {1}:{2} Please set this to either 0 to disable or 1 to enable!'.format(
cfg.get('remote_path'), section_name, input_category))
remote_path = cfg.get('remote_path')
logger.error(f'Remote Path {remote_path} is not valid for {section_name}:{input_category} Please set this to either 0 to disable or 1 to enable!')
input_name, input_directory = convert_to_ascii(input_name, input_directory)
if extract == 1 and not (status > 0 and core.NOEXTRACTFAILED):
logger.debug('Checking for archives to extract in directory: {0}'.format(input_directory))
logger.debug(f'Checking for archives to extract in directory: {input_directory}')
extract_files(input_directory)
logger.info('Calling {0}:{1} to post-process:{2}'.format(section_name, input_category, input_name))
logger.info(f'Calling {section_name}:{input_category} to post-process:{input_name}')
if section_name == 'UserScript':
result = external_script(input_directory, input_name, input_category, section[usercat])

6
core/processor/nzbget.py
View file

@ -33,7 +33,7 @@ def _parse_total_status():
status_summary = os.environ['NZBPP_TOTALSTATUS']
if status_summary != 'SUCCESS':
status = os.environ['NZBPP_STATUS']
logger.info('Download failed with status {0}.'.format(status))
logger.info(f'Download failed with status {status}.')
return 1
return 0
@ -87,9 +87,9 @@ def check_version():
version = os.environ['NZBOP_VERSION']
# Check if the script is called from nzbget 11.0 or later
if version[0:5] < '11.0':
logger.error('NZBGet Version {0} is not supported. Please update NZBGet.'.format(version))
logger.error(f'NZBGet Version {version} is not supported. Please update NZBGet.')
sys.exit(core.NZBGET_POSTPROCESS_ERROR)
logger.info('Script triggered from NZBGet Version {0}.'.format(version))
logger.info(f'Script triggered from NZBGet Version {version}.')
def process():

4
core/processor/sab.py
View file

@ -9,7 +9,7 @@ MINIMUM_ARGUMENTS = 8
def process_script():
version = os.environ['SAB_VERSION']
logger.info('Script triggered from SABnzbd {0}.'.format(version))
logger.info(f'Script triggered from SABnzbd {version}.')
return nzb.process(
input_directory=os.environ['SAB_COMPLETE_DIR'],
input_name=os.environ['SAB_FINAL_NAME'],
@ -38,7 +38,7 @@ def process(args):
8. Failure URL
"""
version = '0.7.17+' if len(args) > MINIMUM_ARGUMENTS else ''
logger.info('Script triggered from SABnzbd {}'.format(version))
logger.info(f'Script triggered from SABnzbd {version}')
return nzb.process(
input_directory=args[1],
input_name=args[2],

16
core/scene_exceptions.py
View file

@ -71,20 +71,20 @@ def rename_file(filename, newfile_path):
try:
os.rename(filename, newfile_path)
except Exception as error:
logger.error('Unable to rename file due to: {error}'.format(error=error), 'EXCEPTION')
logger.error(f'Unable to rename file due to: {error}', 'EXCEPTION')
def replace_filename(filename, dirname, name):
head, file_extension = os.path.splitext(os.path.basename(filename))
if media_pattern.search(os.path.basename(dirname).replace(' ', '.')) is not None:
newname = os.path.basename(dirname).replace(' ', '.')
logger.debug('Replacing file name {old} with directory name {new}'.format(old=head, new=newname), 'EXCEPTION')
logger.debug(f'Replacing file name {head} with directory name {newname}', 'EXCEPTION')
elif media_pattern.search(name.replace(' ', '.').lower()) is not None:
newname = name.replace(' ', '.')
logger.debug('Replacing file name {old} with download name {new}'.format
(old=head, new=newname), 'EXCEPTION')
else:
logger.warning('No name replacement determined for {name}'.format(name=head), 'EXCEPTION')
logger.warning(f'No name replacement determined for {head}', 'EXCEPTION')
newname = name
newfile = newname + file_extension
newfile_path = os.path.join(dirname, newfile)
@ -142,7 +142,7 @@ def rename_script(dirname):
try:
os.rename(orig, dest)
except Exception as error:
logger.error('Unable to rename file due to: {error}'.format(error=error), 'EXCEPTION')
logger.error(f'Unable to rename file due to: {error}', 'EXCEPTION')
def par2(dirname):
@ -164,18 +164,18 @@ def par2(dirname):
bitbucket = open('NUL')
else:
bitbucket = open('/dev/null')
logger.info('Running par2 on file {0}.'.format(parfile), 'PAR2')
logger.info(f'Running par2 on file {parfile}.', 'PAR2')
command = [core.PAR2CMD, 'r', parfile, '*']
cmd = ''
for item in command:
cmd = '{cmd} {item}'.format(cmd=cmd, item=item)
logger.debug('calling command:{0}'.format(cmd), 'PAR2')
cmd = f'{cmd} {item}'
logger.debug(f'calling command:{cmd}', 'PAR2')
try:
proc = subprocess.Popen(command, stdout=bitbucket, stderr=bitbucket)
proc.communicate()
result = proc.returncode
except Exception:
logger.error('par2 file processing for {0} has failed'.format(parfile), 'PAR2')
logger.error(f'par2 file processing for {parfile} has failed', 'PAR2')
if result == 0:
logger.info('par2 file processing succeeded', 'PAR2')
os.chdir(pwd)

149
core/transcoder.py
View file

@ -41,14 +41,15 @@ def is_video_good(videofile, status, require_lan=None):
else:
return True
logger.info('Checking [{0}] for corruption, please stand by ...'.format(file_name_ext), 'TRANSCODER')
logger.info(f'Checking [{file_name_ext}] for corruption, please stand by ...', 'TRANSCODER')
video_details, result = get_video_details(videofile)
if result != 0:
logger.error('FAILED: [{0}] is corrupted!'.format(file_name_ext), 'TRANSCODER')
logger.error(f'FAILED: [{file_name_ext}] is corrupted!', 'TRANSCODER')
return False
if video_details.get('error'):
logger.info('FAILED: [{0}] returned error [{1}].'.format(file_name_ext, video_details.get('error')), 'TRANSCODER')
error_details = video_details.get('error')
logger.info(f'FAILED: [{file_name_ext}] returned error [{error_details}].', 'TRANSCODER')
return False
if video_details.get('streams'):
video_streams = [item for item in video_details['streams'] if item['codec_type'] == 'video']
@ -58,12 +59,10 @@ def is_video_good(videofile, status, require_lan=None):
else:
valid_audio = audio_streams
if len(video_streams) > 0 and len(valid_audio) > 0:
logger.info('SUCCESS: [{0}] has no corruption.'.format(file_name_ext), 'TRANSCODER')
logger.info(f'SUCCESS: [{file_name_ext}] has no corruption.', 'TRANSCODER')
return True
else:
logger.info('FAILED: [{0}] has {1} video streams and {2} audio streams. '
'Assume corruption.'.format
(file_name_ext, len(video_streams), len(audio_streams)), 'TRANSCODER')
logger.info(f'FAILED: [{file_name_ext}] has {len(video_streams)} video streams and {len(audio_streams)} audio streams. Assume corruption.', 'TRANSCODER')
return False
@ -76,7 +75,7 @@ def zip_out(file, img, bitbucket):
try:
procin = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=bitbucket)
except Exception:
logger.error('Extracting [{0}] has failed'.format(file), 'TRANSCODER')
logger.error(f'Extracting [{file}] has failed', 'TRANSCODER')
return procin
@ -116,7 +115,7 @@ def get_video_details(videofile, img=None, bitbucket=None):
result = proc.returncode
video_details = json.loads(out.decode())
except Exception:
logger.error('Checking [{0}] has failed'.format(file), 'TRANSCODER')
logger.error(f'Checking [{file}] has failed', 'TRANSCODER')
return video_details, result
@ -147,11 +146,11 @@ def build_commands(file, new_dir, movie_name, bitbucket):
if check and core.CONCAT:
name = movie_name
elif check:
name = ('{0}.cd{1}'.format(movie_name, check.groups()[0]))
name = (f'{movie_name}.cd{check.groups()[0]}')
elif core.CONCAT and re.match('(.+)[cC][dD][0-9]', name):
name = re.sub('([ ._=:-]+[cC][dD][0-9])', '', name)
if ext == core.VEXTENSION and new_dir == directory: # we need to change the name to prevent overwriting itself.
core.VEXTENSION = '-transcoded{ext}'.format(ext=core.VEXTENSION) # adds '-transcoded.ext'
core.VEXTENSION = f'-transcoded{core.VEXTENSION}' # adds '-transcoded.ext'
new_file = file
else:
img, data = next(file.items())
@ -196,7 +195,7 @@ def build_commands(file, new_dir, movie_name, bitbucket):
if core.VBITRATE:
video_cmd.extend(['-b:v', str(core.VBITRATE)])
if core.VRESOLUTION:
video_cmd.extend(['-vf', 'scale={vres}'.format(vres=core.VRESOLUTION)])
video_cmd.extend(['-vf', f'scale={core.VRESOLUTION}'])
if core.VPRESET:
video_cmd.extend(['-preset', core.VPRESET])
if core.VCRF:
@ -258,14 +257,14 @@ def build_commands(file, new_dir, movie_name, bitbucket):
height=int((height / w_scale) / 2) * 2,
)
if w_scale > 1:
video_cmd.extend(['-vf', 'scale={width}'.format(width=scale)])
video_cmd.extend(['-vf', f'scale={scale}'])
else: # lower or matching ratio, scale by height only.
scale = '{width}:{height}'.format(
width=int((width / h_scale) / 2) * 2,
height=scale.split(':')[1],
)
if h_scale > 1:
video_cmd.extend(['-vf', 'scale={height}'.format(height=scale)])
video_cmd.extend(['-vf', f'scale={scale}'])
if core.VBITRATE:
video_cmd.extend(['-b:v', str(core.VBITRATE)])
if core.VPRESET:
@ -315,36 +314,36 @@ def build_commands(file, new_dir, movie_name, bitbucket):
a_mapped.extend([audio2[0]['index']])
bitrate = int(float(audio2[0].get('bit_rate', 0))) / 1000
channels = int(float(audio2[0].get('channels', 0)))
audio_cmd.extend(['-c:a:{0}'.format(used_audio), 'copy'])
audio_cmd.extend([f'-c:a:{used_audio}', 'copy'])
elif audio1: # right (or only) language, wrong codec.
map_cmd.extend(['-map', '0:{index}'.format(index=audio1[0]['index'])])
a_mapped.extend([audio1[0]['index']])
bitrate = int(float(audio1[0].get('bit_rate', 0))) / 1000
channels = int(float(audio1[0].get('channels', 0)))
audio_cmd.extend(['-c:a:{0}'.format(used_audio), core.ACODEC if core.ACODEC else 'copy'])
audio_cmd.extend([f'-c:a:{used_audio}', core.ACODEC if core.ACODEC else 'copy'])
elif audio4: # wrong language, right codec.
map_cmd.extend(['-map', '0:{index}'.format(index=audio4[0]['index'])])
a_mapped.extend([audio4[0]['index']])
bitrate = int(float(audio4[0].get('bit_rate', 0))) / 1000
channels = int(float(audio4[0].get('channels', 0)))
audio_cmd.extend(['-c:a:{0}'.format(used_audio), 'copy'])
audio_cmd.extend([f'-c:a:{used_audio}', 'copy'])
elif audio3: # wrong language, wrong codec. just pick the default audio track
map_cmd.extend(['-map', '0:{index}'.format(index=audio3[0]['index'])])
a_mapped.extend([audio3[0]['index']])
bitrate = int(float(audio3[0].get('bit_rate', 0))) / 1000
channels = int(float(audio3[0].get('channels', 0)))
audio_cmd.extend(['-c:a:{0}'.format(used_audio), core.ACODEC if core.ACODEC else 'copy'])
audio_cmd.extend([f'-c:a:{used_audio}', core.ACODEC if core.ACODEC else 'copy'])
if core.ACHANNELS and channels and channels > core.ACHANNELS:
audio_cmd.extend(['-ac:a:{0}'.format(used_audio), str(core.ACHANNELS)])
audio_cmd.extend([f'-ac:a:{used_audio}', str(core.ACHANNELS)])
if audio_cmd[1] == 'copy':
audio_cmd[1] = core.ACODEC
if core.ABITRATE and not (core.ABITRATE * 0.9 < bitrate < core.ABITRATE * 1.1):
audio_cmd.extend(['-b:a:{0}'.format(used_audio), str(core.ABITRATE)])
audio_cmd.extend([f'-b:a:{used_audio}', str(core.ABITRATE)])
if audio_cmd[1] == 'copy':
audio_cmd[1] = core.ACODEC
if core.OUTPUTQUALITYPERCENT:
audio_cmd.extend(['-q:a:{0}'.format(used_audio), str(core.OUTPUTQUALITYPERCENT)])
audio_cmd.extend([f'-q:a:{used_audio}', str(core.OUTPUTQUALITYPERCENT)])
if audio_cmd[1] == 'copy':
audio_cmd[1] = core.ACODEC
if audio_cmd[1] in ['aac', 'dts']:
@ -365,42 +364,42 @@ def build_commands(file, new_dir, movie_name, bitbucket):
a_mapped.extend([audio5[0]['index']])
bitrate = int(float(audio5[0].get('bit_rate', 0))) / 1000
channels = int(float(audio5[0].get('channels', 0)))
audio_cmd2.extend(['-c:a:{0}'.format(used_audio), 'copy'])
audio_cmd2.extend([f'-c:a:{used_audio}', 'copy'])
elif audio1: # right language wrong codec.
map_cmd.extend(['-map', '0:{index}'.format(index=audio1[0]['index'])])
a_mapped.extend([audio1[0]['index']])
bitrate = int(float(audio1[0].get('bit_rate', 0))) / 1000
channels = int(float(audio1[0].get('channels', 0)))
if core.ACODEC2:
audio_cmd2.extend(['-c:a:{0}'.format(used_audio), core.ACODEC2])
audio_cmd2.extend([f'-c:a:{used_audio}', core.ACODEC2])
else:
audio_cmd2.extend(['-c:a:{0}'.format(used_audio), 'copy'])
audio_cmd2.extend([f'-c:a:{used_audio}', 'copy'])
elif audio6: # wrong language, right codec
map_cmd.extend(['-map', '0:{index}'.format(index=audio6[0]['index'])])
a_mapped.extend([audio6[0]['index']])
bitrate = int(float(audio6[0].get('bit_rate', 0))) / 1000
channels = int(float(audio6[0].get('channels', 0)))
audio_cmd2.extend(['-c:a:{0}'.format(used_audio), 'copy'])
audio_cmd2.extend([f'-c:a:{used_audio}', 'copy'])
elif audio3: # wrong language, wrong codec just pick the default audio track
map_cmd.extend(['-map', '0:{index}'.format(index=audio3[0]['index'])])
a_mapped.extend([audio3[0]['index']])
bitrate = int(float(audio3[0].get('bit_rate', 0))) / 1000
channels = int(float(audio3[0].get('channels', 0)))
if core.ACODEC2:
audio_cmd2.extend(['-c:a:{0}'.format(used_audio), core.ACODEC2])
audio_cmd2.extend([f'-c:a:{used_audio}', core.ACODEC2])
else:
audio_cmd2.extend(['-c:a:{0}'.format(used_audio), 'copy'])
audio_cmd2.extend([f'-c:a:{used_audio}', 'copy'])
if core.ACHANNELS2 and channels and channels > core.ACHANNELS2:
audio_cmd2.extend(['-ac:a:{0}'.format(used_audio), str(core.ACHANNELS2)])
audio_cmd2.extend([f'-ac:a:{used_audio}', str(core.ACHANNELS2)])
if audio_cmd2[1] == 'copy':
audio_cmd2[1] = core.ACODEC2
if core.ABITRATE2 and not (core.ABITRATE2 * 0.9 < bitrate < core.ABITRATE2 * 1.1):
audio_cmd2.extend(['-b:a:{0}'.format(used_audio), str(core.ABITRATE2)])
audio_cmd2.extend([f'-b:a:{used_audio}', str(core.ABITRATE2)])
if audio_cmd2[1] == 'copy':
audio_cmd2[1] = core.ACODEC2
if core.OUTPUTQUALITYPERCENT:
audio_cmd2.extend(['-q:a:{0}'.format(used_audio), str(core.OUTPUTQUALITYPERCENT)])
audio_cmd2.extend([f'-q:a:{used_audio}', str(core.OUTPUTQUALITYPERCENT)])
if audio_cmd2[1] == 'copy':
audio_cmd2[1] = core.ACODEC2
if audio_cmd2[1] in ['aac', 'dts']:
@ -422,23 +421,23 @@ def build_commands(file, new_dir, movie_name, bitbucket):
bitrate = int(float(audio.get('bit_rate', 0))) / 1000
channels = int(float(audio.get('channels', 0)))
if audio['codec_name'] in core.ACODEC3_ALLOW:
audio_cmd3.extend(['-c:a:{0}'.format(used_audio), 'copy'])
audio_cmd3.extend([f'-c:a:{used_audio}', 'copy'])
else:
if core.ACODEC3:
audio_cmd3.extend(['-c:a:{0}'.format(used_audio), core.ACODEC3])
audio_cmd3.extend([f'-c:a:{used_audio}', core.ACODEC3])
else:
audio_cmd3.extend(['-c:a:{0}'.format(used_audio), 'copy'])
audio_cmd3.extend([f'-c:a:{used_audio}', 'copy'])
if core.ACHANNELS3 and channels and channels > core.ACHANNELS3:
audio_cmd3.extend(['-ac:a:{0}'.format(used_audio), str(core.ACHANNELS3)])
audio_cmd3.extend([f'-ac:a:{used_audio}', str(core.ACHANNELS3)])
if audio_cmd3[1] == 'copy':
audio_cmd3[1] = core.ACODEC3
if core.ABITRATE3 and not (core.ABITRATE3 * 0.9 < bitrate < core.ABITRATE3 * 1.1):
audio_cmd3.extend(['-b:a:{0}'.format(used_audio), str(core.ABITRATE3)])
audio_cmd3.extend([f'-b:a:{used_audio}', str(core.ABITRATE3)])
if audio_cmd3[1] == 'copy':
audio_cmd3[1] = core.ACODEC3
if core.OUTPUTQUALITYPERCENT > 0:
audio_cmd3.extend(['-q:a:{0}'.format(used_audio), str(core.OUTPUTQUALITYPERCENT)])
audio_cmd3.extend([f'-q:a:{used_audio}', str(core.OUTPUTQUALITYPERCENT)])
if audio_cmd3[1] == 'copy':
audio_cmd3[1] = core.ACODEC3
if audio_cmd3[1] in ['aac', 'dts']:
@ -456,7 +455,7 @@ def build_commands(file, new_dir, movie_name, bitbucket):
if core.BURN and not subs1 and not burnt and os.path.isfile(file):
for subfile in get_subs(file):
if lan in os.path.split(subfile)[1]:
video_cmd.extend(['-vf', 'subtitles={subs}'.format(subs=subfile)])
video_cmd.extend(['-vf', f'subtitles={subfile}'])
burnt = 1
for sub in subs1:
if core.BURN and not burnt and os.path.isfile(input_file):
@ -465,7 +464,7 @@ def build_commands(file, new_dir, movie_name, bitbucket):
if sub_streams[index]['index'] == sub['index']:
subloc = index
break
video_cmd.extend(['-vf', 'subtitles={sub}:si={loc}'.format(sub=input_file, loc=subloc)])
video_cmd.extend(['-vf', f'subtitles={input_file}:si={subloc}'])
burnt = 1
if not core.ALLOWSUBS:
break
@ -519,10 +518,10 @@ def build_commands(file, new_dir, movie_name, bitbucket):
except Exception:
pass
if metlan:
meta_cmd.extend(['-metadata:s:s:{x}'.format(x=len(s_mapped) + n),
'language={lang}'.format(lang=metlan.alpha3)])
meta_cmd.extend([f'-metadata:s:s:{len(s_mapped) + n}',
f'language={metlan.alpha3}'])
n += 1
map_cmd.extend(['-map', '{x}:0'.format(x=n)])
map_cmd.extend(['-map', f'{n}:0'])
if not core.ALLOWSUBS or (not s_mapped and not n):
sub_cmd.extend(['-sn'])
@ -582,20 +581,20 @@ def extract_subs(file, newfile_path, bitbucket):
lan = sub.get('tags', {}).get('language', 'unk')
if num == 1:
output_file = os.path.join(subdir, '{0}.srt'.format(name))
output_file = os.path.join(subdir, f'{name}.srt')
if os.path.isfile(output_file):
output_file = os.path.join(subdir, '{0}.{1}.srt'.format(name, n))
output_file = os.path.join(subdir, f'{name}.{n}.srt')
else:
output_file = os.path.join(subdir, '{0}.{1}.srt'.format(name, lan))
output_file = os.path.join(subdir, f'{name}.{lan}.srt')
if os.path.isfile(output_file):
output_file = os.path.join(subdir, '{0}.{1}.{2}.srt'.format(name, lan, n))
output_file = os.path.join(subdir, f'{name}.{lan}.{n}.srt')
command = [core.FFMPEG, '-loglevel', 'warning', '-i', file, '-vn', '-an',
'-codec:{index}'.format(index=idx), 'srt', output_file]
f'-codec:{idx}', 'srt', output_file]
if platform.system() != 'Windows':
command = core.NICENESS + command
logger.info('Extracting {0} subtitle from: {1}'.format(lan, file))
logger.info(f'Extracting {lan} subtitle from: {file}')
print_cmd(command)
result = 1 # set result to failed in case call fails.
try:
@ -610,7 +609,7 @@ def extract_subs(file, newfile_path, bitbucket):
shutil.copymode(file, output_file)
except Exception:
pass
logger.info('Extracting {0} subtitle from {1} has succeeded'.format(lan, file))
logger.info(f'Extracting {lan} subtitle from {file} has succeeded')
else:
logger.error('Extracting subtitles has failed')
@ -625,11 +624,11 @@ def process_list(it, new_dir, bitbucket):
for item in it:
ext = os.path.splitext(item)[1].lower()
if ext in ['.iso', '.bin', '.img'] and ext not in core.IGNOREEXTENSIONS:
logger.debug('Attempting to rip disk image: {0}'.format(item), 'TRANSCODER')
logger.debug(f'Attempting to rip disk image: {item}', 'TRANSCODER')
new_list.extend(rip_iso(item, new_dir, bitbucket))
rem_list.append(item)
elif re.match('.+VTS_[0-9][0-9]_[0-9].[Vv][Oo][Bb]', item) and '.vob' not in core.IGNOREEXTENSIONS:
logger.debug('Found VIDEO_TS image file: {0}'.format(item), 'TRANSCODER')
logger.debug(f'Found VIDEO_TS image file: {item}', 'TRANSCODER')
if not vts_path:
try:
vts_path = re.match('(.+VIDEO_TS)', item).groups()[0]
@ -637,7 +636,7 @@ def process_list(it, new_dir, bitbucket):
vts_path = os.path.split(item)[0]
rem_list.append(item)
elif re.match('.+BDMV[/\\]SOURCE[/\\][0-9]+[0-9].[Mm][Tt][Ss]', item) and '.mts' not in core.IGNOREEXTENSIONS:
logger.debug('Found MTS image file: {0}'.format(item), 'TRANSCODER')
logger.debug(f'Found MTS image file: {item}', 'TRANSCODER')
if not mts_path:
try:
mts_path = re.match('(.+BDMV[/\\]SOURCE)', item).groups()[0]
@ -665,7 +664,7 @@ def process_list(it, new_dir, bitbucket):
it.extend(new_list)
for item in rem_list:
it.remove(item)
logger.debug('Successfully extracted .vob file {0} from disk image'.format(new_list[0]), 'TRANSCODER')
logger.debug(f'Successfully extracted .vob file {new_list[0]} from disk image', 'TRANSCODER')
elif new_list and not success:
new_list = []
rem_list = []
@ -675,7 +674,7 @@ def process_list(it, new_dir, bitbucket):
def mount_iso(item, new_dir, bitbucket): #Currently only supports Linux Mount when permissions allow.
if platform.system() == 'Windows':
logger.error('No mounting options available under Windows for image file {0}'.format(item), 'TRANSCODER')
logger.error(f'No mounting options available under Windows for image file {item}', 'TRANSCODER')
return []
mount_point = os.path.join(os.path.dirname(os.path.abspath(item)),'temp')
make_dir(mount_point)
@ -688,20 +687,20 @@ def mount_iso(item, new_dir, bitbucket): #Currently only supports Linux Mount wh
for file in files:
full_path = os.path.join(root, file)
if re.match('.+VTS_[0-9][0-9]_[0-9].[Vv][Oo][Bb]', full_path) and '.vob' not in core.IGNOREEXTENSIONS:
logger.debug('Found VIDEO_TS image file: {0}'.format(full_path), 'TRANSCODER')
logger.debug(f'Found VIDEO_TS image file: {full_path}', 'TRANSCODER')
try:
vts_path = re.match('(.+VIDEO_TS)', full_path).groups()[0]
except Exception:
vts_path = os.path.split(full_path)[0]
return combine_vts(vts_path)
elif re.match('.+BDMV[/\\]STREAM[/\\][0-9]+[0-9].[Mm]', full_path) and '.mts' not in core.IGNOREEXTENSIONS:
logger.debug('Found MTS image file: {0}'.format(full_path), 'TRANSCODER')
logger.debug(f'Found MTS image file: {full_path}', 'TRANSCODER')
try:
mts_path = re.match('(.+BDMV[/\\]STREAM)', full_path).groups()[0]
except Exception:
mts_path = os.path.split(full_path)[0]
return combine_mts(mts_path)
logger.error('No VIDEO_TS or BDMV/SOURCE folder found in image file {0}'.format(mount_point), 'TRANSCODER')
logger.error(f'No VIDEO_TS or BDMV/SOURCE folder found in image file {mount_point}', 'TRANSCODER')
return ['failure'] # If we got here, nothing matched our criteria
@ -710,16 +709,16 @@ def rip_iso(item, new_dir, bitbucket):
failure_dir = 'failure'
# Mount the ISO in your OS and call combineVTS.
if not core.SEVENZIP:
logger.debug('No 7zip installed. Attempting to mount image file {0}'.format(item), 'TRANSCODER')
logger.debug(f'No 7zip installed. Attempting to mount image file {item}', 'TRANSCODER')
try:
new_files = mount_iso(item, new_dir, bitbucket) # Currently only works for Linux.
except Exception:
logger.error('Failed to mount and extract from image file {0}'.format(item), 'TRANSCODER')
logger.error(f'Failed to mount and extract from image file {item}', 'TRANSCODER')
new_files = [failure_dir]
return new_files
cmd = [core.SEVENZIP, 'l', item]
try:
logger.debug('Attempting to extract .vob or .mts from image file {0}'.format(item), 'TRANSCODER')
logger.debug(f'Attempting to extract .vob or .mts from image file {item}', 'TRANSCODER')
print_cmd(cmd)
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=bitbucket)
out, err = proc.communicate()
@ -738,7 +737,7 @@ def rip_iso(item, new_dir, bitbucket):
concat = []
m = 1
while True:
vts_name = 'VIDEO_TS{0}VTS_{1:02d}_{2:d}.VOB'.format(os.sep, n + 1, m)
vts_name = f'VIDEO_TS{os.sep}VTS_{n + 1:02d}_{m:d}.VOB'
if vts_name in file_list:
concat.append(vts_name)
m += 1
@ -783,10 +782,10 @@ def rip_iso(item, new_dir, bitbucket):
name = os.path.splitext(os.path.split(item)[1])[0]
new_files.append({item: {'name': name, 'files': combined}})
if not new_files:
logger.error('No VIDEO_TS or BDMV/SOURCE folder found in image file. Attempting to mount and scan {0}'.format(item), 'TRANSCODER')
logger.error(f'No VIDEO_TS or BDMV/SOURCE folder found in image file. Attempting to mount and scan {item}', 'TRANSCODER')
new_files = mount_iso(item, new_dir, bitbucket)
except Exception:
logger.error('Failed to extract from image file {0}'.format(item), 'TRANSCODER')
logger.error(f'Failed to extract from image file {item}', 'TRANSCODER')
new_files = [failure_dir]
return new_files
@ -803,7 +802,7 @@ def combine_vts(vts_path):
concat = []
m = 1
while True:
vts_name = 'VTS_{0:02d}_{1:d}.VOB'.format(n + 1, m)
vts_name = f'VTS_{n + 1:02d}_{m:d}.VOB'
if os.path.isfile(os.path.join(vts_path, vts_name)):
concat.append(os.path.join(vts_path, vts_name))
m += 1
@ -861,19 +860,19 @@ def combine_cd(combine):
files = [file for file in combine if
n + 1 == int(re.match('.+[cC][dD]([0-9]+).', file).groups()[0]) and item in file]
if files:
concat += '{file}|'.format(file=files[0])
concat += f'{files[0]}|'
else:
break
if concat:
new_files.append('concat:{0}'.format(concat[:-1]))
new_files.append(f'concat:{concat[:-1]}')
return new_files
def print_cmd(command):
cmd = ''
for item in command:
cmd = '{cmd} {item}'.format(cmd=cmd, item=item)
logger.debug('calling command:{0}'.format(cmd))
cmd = f'{cmd} {item}'
logger.debug(f'calling command:{cmd}')
def transcode_directory(dir_name):
@ -914,11 +913,11 @@ def transcode_directory(dir_name):
os.remove(newfile_path)
except OSError as e:
if e.errno != errno.ENOENT: # Ignore the error if it's just telling us that the file doesn't exist
logger.debug('Error when removing transcoding target: {0}'.format(e))
logger.debug(f'Error when removing transcoding target: {e}')
except Exception as e:
logger.debug('Error when removing transcoding target: {0}'.format(e))
logger.debug(f'Error when removing transcoding target: {e}')
logger.info('Transcoding video: {0}'.format(newfile_path))
logger.info(f'Transcoding video: {newfile_path}')
print_cmd(command)
result = 1 # set result to failed in case call fails.
try:
@ -930,15 +929,15 @@ def transcode_directory(dir_name):
for vob in data['files']:
procin = zip_out(vob, img, bitbucket)
if procin:
logger.debug('Feeding in file: {0} to Transcoder'.format(vob))
logger.debug(f'Feeding in file: {vob} to Transcoder')
shutil.copyfileobj(procin.stdout, proc.stdin)
procin.stdout.close()
out, err = proc.communicate()
if err:
logger.error('Transcoder returned:{0} has failed'.format(err))
logger.error(f'Transcoder returned:{err} has failed')
result = proc.returncode
except Exception:
logger.error('Transcoding of video {0} has failed'.format(newfile_path))
logger.error(f'Transcoding of video {newfile_path} has failed')
if core.SUBSDIR and result == 0 and isinstance(file, str):
for sub in get_subs(file):
@ -954,14 +953,14 @@ def transcode_directory(dir_name):
shutil.copymode(file, newfile_path)
except Exception:
pass
logger.info('Transcoding of video to {0} succeeded'.format(newfile_path))
logger.info(f'Transcoding of video to {newfile_path} succeeded')
if os.path.isfile(newfile_path) and (file in new_list or not core.DUPLICATE):
try:
os.unlink(file)
except Exception:
pass
else:
logger.error('Transcoding of video to {0} failed with result {1}'.format(newfile_path, result))
logger.error(f'Transcoding of video to {newfile_path} failed with result {result}')
# this will be 0 (successful) it all are successful, else will return a positive integer for failure.
final_result = final_result + result
if core.MOUNTED: # In case we mounted an .iso file, unmount here.

35
core/user_scripts.py
View file

@ -54,7 +54,7 @@ def external_script(output_destination, torrent_name, torrent_label, settings):
if transcoder.is_video_good(video, 0):
import_subs(video)
else:
logger.info('Corrupt video file found {0}. Deleting.'.format(video), 'USERSCRIPT')
logger.info(f'Corrupt video file found {video}. Deleting.', 'USERSCRIPT')
os.unlink(video)
for dirpath, _, filenames in os.walk(output_destination):
@ -62,7 +62,7 @@ def external_script(output_destination, torrent_name, torrent_label, settings):
file_path = core.os.path.join(dirpath, file)
file_name, file_extension = os.path.splitext(file)
logger.debug('Checking file {0} to see if this should be processed.'.format(file), 'USERSCRIPT')
logger.debug(f'Checking file {file} to see if this should be processed.', 'USERSCRIPT')
if file_extension in core.USER_SCRIPT_MEDIAEXTENSIONS or 'all' in core.USER_SCRIPT_MEDIAEXTENSIONS:
num_files += 1
@ -71,44 +71,42 @@ def external_script(output_destination, torrent_name, torrent_label, settings):
command = [core.USER_SCRIPT]
for param in core.USER_SCRIPT_PARAM:
if param == 'FN':
command.append('{0}'.format(file))
command.append(f'{file}')
continue
elif param == 'FP':
command.append('{0}'.format(file_path))
command.append(f'{file_path}')
continue
elif param == 'TN':
command.append('{0}'.format(torrent_name))
command.append(f'{torrent_name}')
continue
elif param == 'TL':
command.append('{0}'.format(torrent_label))
command.append(f'{torrent_label}')
continue
elif param == 'DN':
if core.USER_SCRIPT_RUNONCE == 1:
command.append('{0}'.format(output_destination))
command.append(f'{output_destination}')
else:
command.append('{0}'.format(dirpath))
command.append(f'{dirpath}')
continue
else:
command.append(param)
continue
cmd = ''
for item in command:
cmd = '{cmd} {item}'.format(cmd=cmd, item=item)
logger.info('Running script {cmd} on file {path}.'.format(cmd=cmd, path=file_path), 'USERSCRIPT')
cmd = f'{cmd} {item}'
logger.info(f'Running script {cmd} on file {file_path}.', 'USERSCRIPT')
try:
p = Popen(command)
res = p.wait()
if str(res) in core.USER_SCRIPT_SUCCESSCODES: # Linux returns 0 for successful.
logger.info('UserScript {0} was successfull'.format(command[0]))
logger.info(f'UserScript {command[0]} was successfull')
result = 0
else:
logger.error('UserScript {0} has failed with return code: {1}'.format(command[0], res), 'USERSCRIPT')
logger.info(
'If the UserScript completed successfully you should add {0} to the user_script_successCodes'.format(
res), 'USERSCRIPT')
logger.error(f'UserScript {command[0]} has failed with return code: {res}', 'USERSCRIPT')
logger.info(f'If the UserScript completed successfully you should add {res} to the user_script_successCodes', 'USERSCRIPT')
result = int(1)
except Exception:
logger.error('UserScript {0} has failed'.format(command[0]), 'USERSCRIPT')
logger.error(f'UserScript {command[0]} has failed', 'USERSCRIPT')
result = int(1)
final_result += result
@ -121,11 +119,10 @@ def external_script(output_destination, torrent_name, torrent_label, settings):
num_files_new += 1
if core.USER_SCRIPT_CLEAN == int(1) and num_files_new == 0 and final_result == 0:
logger.info('All files have been processed. Cleaning outputDirectory {0}'.format(output_destination))
logger.info(f'All files have been processed. Cleaning outputDirectory {output_destination}')
remove_dir(output_destination)
elif core.USER_SCRIPT_CLEAN == int(1) and num_files_new != 0:
logger.info('{0} files were processed, but {1} still remain. outputDirectory will not be cleaned.'.format(
num_files, num_files_new))
logger.info(f'{num_files} files were processed, but {num_files_new} still remain. outputDirectory will not be cleaned.')
return ProcessResult(
status_code=final_result,
message='User Script Completed',

10
core/utils/common.py
View file

@ -26,7 +26,7 @@ def clean_dir(path, section, subsection):
def process_dir(path, link):
folders = []
logger.info('Searching {0} for mediafiles to post-process ...'.format(path))
logger.info(f'Searching {path} for mediafiles to post-process ...')
dir_contents = os.listdir(path)
# search for single files and move them into their own folder for post-processing
@ -56,7 +56,7 @@ def process_dir(path, link):
try:
move_file(mediafile, path, link)
except Exception as e:
logger.error('Failed to move {0} to its own directory: {1}'.format(os.path.split(mediafile)[1], e))
logger.error(f'Failed to move {os.path.split(mediafile)[1]} to its own directory: {e}')
# removeEmptyFolders(path, removeRoot=False)
@ -97,7 +97,7 @@ def get_dirs(section, subsection, link='hard'):
try:
to_return.extend(process_dir(directory, link))
except Exception as e:
logger.error('Failed to add directories from {0} for post-processing: {1}'.format(watch_directory, e))
logger.error(f'Failed to add directories from {watch_directory} for post-processing: {e}')
if core.USE_LINK == 'move':
try:
@ -105,10 +105,10 @@ def get_dirs(section, subsection, link='hard'):
if os.path.exists(output_directory):
to_return.extend(process_dir(output_directory, link))
except Exception as e:
logger.error('Failed to add directories from {0} for post-processing: {1}'.format(core.OUTPUT_DIRECTORY, e))
logger.error(f'Failed to add directories from {core.OUTPUT_DIRECTORY} for post-processing: {e}')
if not to_return:
logger.debug('No directories identified in {0}:{1} for post-processing'.format(section, subsection))
logger.debug(f'No directories identified in {section}:{subsection} for post-processing')
return list(set(to_return))

9
core/utils/encoding.py
View file

@ -1,5 +1,4 @@
import os
from builtins import bytes
import core
from core import logger
@ -66,23 +65,23 @@ def convert_to_ascii(input_name, dir_name):
encoded, base2 = char_replace(base)
if encoded:
dir_name = os.path.join(directory, base2)
logger.info('Renaming directory to: {0}.'.format(base2), 'ENCODER')
logger.info(f'Renaming directory to: {base2}.', 'ENCODER')
os.rename(os.path.join(directory, base), dir_name)
if 'NZBOP_SCRIPTDIR' in os.environ:
print('[NZB] DIRECTORY={0}'.format(dir_name))
print(f'[NZB] DIRECTORY={dir_name}')
for dirname, dirnames, _ in os.walk(dir_name, topdown=False):
for subdirname in dirnames:
encoded, subdirname2 = char_replace(subdirname)
if encoded:
logger.info('Renaming directory to: {0}.'.format(subdirname2), 'ENCODER')
logger.info(f'Renaming directory to: {subdirname2}.', 'ENCODER')
os.rename(os.path.join(dirname, subdirname), os.path.join(dirname, subdirname2))
for dirname, _, filenames in os.walk(dir_name):
for filename in filenames:
encoded, filename2 = char_replace(filename)
if encoded:
logger.info('Renaming file to: {0}.'.format(filename2), 'ENCODER')
logger.info(f'Renaming file to: {filename2}.', 'ENCODER')
os.rename(os.path.join(dirname, filename), os.path.join(dirname, filename2))
return input_name, dir_name

26
core/utils/files.py
View file

@ -15,7 +15,7 @@ from core.utils.paths import get_dir_size, make_dir
def move_file(mediafile, path, link):
logger.debug('Found file {0} in root directory {1}.'.format(os.path.split(mediafile)[1], path))
logger.debug(f'Found file {os.path.split(mediafile)[1]} in root directory {path}.')
new_path = None
file_ext = os.path.splitext(mediafile)[1]
try:
@ -27,7 +27,7 @@ def move_file(mediafile, path, link):
album = f.album
# create new path
new_path = os.path.join(path, '{0} - {1}'.format(sanitize_name(artist), sanitize_name(album)))
new_path = os.path.join(path, f'{sanitize_name(artist)} - {sanitize_name(album)}')
elif file_ext in core.MEDIA_CONTAINER:
f = guessit.guessit(mediafile)
@ -39,7 +39,7 @@ def move_file(mediafile, path, link):
new_path = os.path.join(path, sanitize_name(title))
except Exception as e:
logger.error('Exception parsing name for media file: {0}: {1}'.format(os.path.split(mediafile)[1], e))
logger.error(f'Exception parsing name for media file: {os.path.split(mediafile)[1]}: {e}')
if not new_path:
title = os.path.splitext(os.path.basename(mediafile))[0]
@ -79,7 +79,7 @@ def is_min_size(input_name, min_size):
try:
input_size = get_dir_size(os.path.dirname(input_name))
except Exception:
logger.error('Failed to get file size for {0}'.format(input_name), 'MINSIZE')
logger.error(f'Failed to get file size for {input_name}', 'MINSIZE')
return True
# Ignore files under a certain size
@ -131,8 +131,7 @@ def list_media_files(path, min_size=0, delete_ignored=0, media=True, audio=True,
if delete_ignored == 1:
try:
os.unlink(path)
logger.debug('Ignored file {0} has been removed ...'.format
(cur_file))
logger.debug(f'Ignored file {cur_file} has been removed ...')
except Exception:
pass
else:
@ -153,8 +152,7 @@ def list_media_files(path, min_size=0, delete_ignored=0, media=True, audio=True,
if delete_ignored == 1:
try:
os.unlink(full_cur_file)
logger.debug('Ignored file {0} has been removed ...'.format
(cur_file))
logger.debug(f'Ignored file {cur_file} has been removed ...')
except Exception:
pass
continue
@ -182,7 +180,7 @@ def extract_files(src, dst=None, keep_archive=None):
extracted_folder.append(dir_path)
extracted_archive.append(archive_name)
except Exception:
logger.error('Extraction failed for: {0}'.format(full_file_name))
logger.error(f'Extraction failed for: {full_file_name}')
for folder in extracted_folder:
for inputFile in list_media_files(folder, media=False, audio=False, meta=False, archives=True):
@ -191,24 +189,24 @@ def extract_files(src, dst=None, keep_archive=None):
archive_name = re.sub(r'part[0-9]+', '', archive_name)
if archive_name not in extracted_archive or keep_archive:
continue # don't remove if we haven't extracted this archive, or if we want to preserve them.
logger.info('Removing extracted archive {0} from folder {1} ...'.format(full_file_name, folder))
logger.info(f'Removing extracted archive {full_file_name} from folder {folder} ...')
try:
if not os.access(inputFile, os.W_OK):
os.chmod(inputFile, stat.S_IWUSR)
os.remove(inputFile)
time.sleep(1)
except Exception as e:
logger.error('Unable to remove file {0} due to: {1}'.format(inputFile, e))
logger.error(f'Unable to remove file {inputFile} due to: {e}')
def backup_versioned_file(old_file, version):
num_tries = 0
new_file = '{old}.v{version}'.format(old=old_file, version=version)
new_file = f'{old_file}.v{version}'
while not os.path.isfile(new_file):
if not os.path.isfile(old_file):
logger.log('Not creating backup, {file} doesn\'t exist'.format(file=old_file), logger.DEBUG)
logger.log(f'Not creating backup, {old_file} doesn\'t exist', logger.DEBUG)
break
try:
@ -224,7 +222,7 @@ def backup_versioned_file(old_file, version):
logger.log('Trying again.', logger.DEBUG)
if num_tries >= 10:
logger.log('Unable to back up {old} to {new} please do it manually.'.format(old=old_file, new=new_file), logger.ERROR)
logger.log(f'Unable to back up {old_file} to {new_file} please do it manually.', logger.ERROR)
return False
return True

51
core/utils/identification.py
View file

@ -11,21 +11,21 @@ from core.utils.naming import sanitize_name
def find_imdbid(dir_name, input_name, omdb_api_key):
imdbid = None
logger.info('Attemping imdbID lookup for {0}'.format(input_name))
logger.info(f'Attemping imdbID lookup for {input_name}')
# find imdbid in dirName
logger.info('Searching folder and file names for imdbID ...')
m = re.search(r'\b(tt\d{7,8})\b', dir_name + input_name)
if m:
imdbid = m.group(1)
logger.info('Found imdbID [{0}]'.format(imdbid))
logger.info(f'Found imdbID [{imdbid}]')
return imdbid
if os.path.isdir(dir_name):
for file in os.listdir(dir_name):
m = re.search(r'\b(tt\d{7,8})\b', file)
if m:
imdbid = m.group(1)
logger.info('Found imdbID [{0}] via file name'.format(imdbid))
logger.info(f'Found imdbID [{imdbid}] via file name')
return imdbid
if 'NZBPR__DNZB_MOREINFO' in os.environ:
dnzb_more_info = os.environ.get('NZBPR__DNZB_MOREINFO', '')
@ -34,7 +34,7 @@ def find_imdbid(dir_name, input_name, omdb_api_key):
m = regex.match(dnzb_more_info)
if m:
imdbid = m.group(1)
logger.info('Found imdbID [{0}] from DNZB-MoreInfo'.format(imdbid))
logger.info(f'Found imdbID [{imdbid}] from DNZB-MoreInfo')
return imdbid
logger.info('Searching IMDB for imdbID ...')
try:
@ -58,13 +58,13 @@ def find_imdbid(dir_name, input_name, omdb_api_key):
logger.info('Unable to determine imdbID: No api key provided for omdbapi.com.')
return
logger.debug('Opening URL: {0}'.format(url))
logger.debug(f'Opening URL: {url}')
try:
r = requests.get(url, params={'apikey': omdb_api_key, 'y': year, 't': title},
verify=False, timeout=(60, 300))
except requests.ConnectionError:
logger.error('Unable to open URL {0}'.format(url))
logger.error(f'Unable to open URL {url}')
return
try:
@ -78,10 +78,10 @@ def find_imdbid(dir_name, input_name, omdb_api_key):
logger.error('No imdbID returned from omdbapi.com')
if imdbid:
logger.info('Found imdbID [{0}]'.format(imdbid))
logger.info(f'Found imdbID [{imdbid}]')
return imdbid
logger.warning('Unable to find a imdbID for {0}'.format(input_name))
logger.warning(f'Unable to find a imdbID for {input_name}')
return imdbid
@ -94,13 +94,13 @@ def category_search(input_directory, input_name, input_category, root, categorie
pathlist = os.path.normpath(input_directory).split(os.sep)
if input_category and input_category in pathlist:
logger.debug('SEARCH: Found the Category: {0} in directory structure'.format(input_category))
logger.debug(f'SEARCH: Found the Category: {input_category} in directory structure')
elif input_category:
logger.debug('SEARCH: Could not find the category: {0} in the directory structure'.format(input_category))
logger.debug(f'SEARCH: Could not find the category: {input_category} in the directory structure')
else:
try:
input_category = list(set(pathlist) & set(categories))[-1] # assume last match is most relevant category.
logger.debug('SEARCH: Found Category: {0} in directory structure'.format(input_category))
logger.debug(f'SEARCH: Found Category: {input_category} in directory structure')
except IndexError:
input_category = ''
logger.debug('SEARCH: Could not find a category in the directory structure')
@ -111,37 +111,37 @@ def category_search(input_directory, input_name, input_category, root, categorie
if input_category and os.path.isdir(os.path.join(input_directory, input_category)):
logger.info(
'SEARCH: Found category directory {0} in input directory directory {1}'.format(input_category, input_directory))
f'SEARCH: Found category directory {input_category} in input directory directory {input_directory}')
input_directory = os.path.join(input_directory, input_category)
logger.info('SEARCH: Setting input_directory to {0}'.format(input_directory))
logger.info(f'SEARCH: Setting input_directory to {input_directory}')
if input_name and os.path.isdir(os.path.join(input_directory, input_name)):
logger.info('SEARCH: Found torrent directory {0} in input directory directory {1}'.format(input_name, input_directory))
logger.info(f'SEARCH: Found torrent directory {input_name} in input directory directory {input_directory}')
input_directory = os.path.join(input_directory, input_name)
logger.info('SEARCH: Setting input_directory to {0}'.format(input_directory))
logger.info(f'SEARCH: Setting input_directory to {input_directory}')
tordir = True
elif input_name and os.path.isdir(os.path.join(input_directory, sanitize_name(input_name))):
logger.info('SEARCH: Found torrent directory {0} in input directory directory {1}'.format(
logger.info('SEARCH: Found torrent directory {} in input directory directory {}'.format(
sanitize_name(input_name), input_directory))
input_directory = os.path.join(input_directory, sanitize_name(input_name))
logger.info('SEARCH: Setting input_directory to {0}'.format(input_directory))
logger.info(f'SEARCH: Setting input_directory to {input_directory}')
tordir = True
elif input_name and os.path.isfile(os.path.join(input_directory, input_name)):
logger.info('SEARCH: Found torrent file {0} in input directory directory {1}'.format(input_name, input_directory))
logger.info(f'SEARCH: Found torrent file {input_name} in input directory directory {input_directory}')
input_directory = os.path.join(input_directory, input_name)
logger.info('SEARCH: Setting input_directory to {0}'.format(input_directory))
logger.info(f'SEARCH: Setting input_directory to {input_directory}')
tordir = True
elif input_name and os.path.isfile(os.path.join(input_directory, sanitize_name(input_name))):
logger.info('SEARCH: Found torrent file {0} in input directory directory {1}'.format(
logger.info('SEARCH: Found torrent file {} in input directory directory {}'.format(
sanitize_name(input_name), input_directory))
input_directory = os.path.join(input_directory, sanitize_name(input_name))
logger.info('SEARCH: Setting input_directory to {0}'.format(input_directory))
logger.info(f'SEARCH: Setting input_directory to {input_directory}')
tordir = True
elif input_name and os.path.isdir(input_directory):
for file in os.listdir(input_directory):
if os.path.splitext(file)[0] in [input_name, sanitize_name(input_name)]:
logger.info('SEARCH: Found torrent file {0} in input directory directory {1}'.format(file, input_directory))
logger.info(f'SEARCH: Found torrent file {file} in input directory directory {input_directory}')
input_directory = os.path.join(input_directory, file)
logger.info('SEARCH: Setting input_directory to {0}'.format(input_directory))
logger.info(f'SEARCH: Setting input_directory to {input_directory}')
input_name = file
tordir = True
break
@ -156,8 +156,7 @@ def category_search(input_directory, input_name, input_category, root, categorie
index = pathlist.index(input_category)
if index + 1 < len(pathlist):
tordir = True
logger.info('SEARCH: Found a unique directory {0} in the category directory'.format
(pathlist[index + 1]))
logger.info(f'SEARCH: Found a unique directory {pathlist[index + 1]} in the category directory')
if not input_name:
input_name = pathlist[index + 1]
except ValueError:
@ -165,7 +164,7 @@ def category_search(input_directory, input_name, input_category, root, categorie
if input_name and not tordir:
if input_name in pathlist or sanitize_name(input_name) in pathlist:
logger.info('SEARCH: Found torrent directory {0} in the directory structure'.format(input_name))
logger.info(f'SEARCH: Found torrent directory {input_name} in the directory structure')
tordir = True
else:
root = 1

14
core/utils/links.py
View file

@ -17,9 +17,9 @@ except ImportError:
def copy_link(src, target_link, use_link):
logger.info('MEDIAFILE: [{0}]'.format(os.path.basename(target_link)), 'COPYLINK')
logger.info('SOURCE FOLDER: [{0}]'.format(os.path.dirname(src)), 'COPYLINK')
logger.info('TARGET FOLDER: [{0}]'.format(os.path.dirname(target_link)), 'COPYLINK')
logger.info(f'MEDIAFILE: [{os.path.basename(target_link)}]', 'COPYLINK')
logger.info(f'SOURCE FOLDER: [{os.path.dirname(src)}]', 'COPYLINK')
logger.info(f'TARGET FOLDER: [{os.path.dirname(target_link)}]', 'COPYLINK')
if src != target_link and os.path.exists(target_link):
logger.info('MEDIAFILE already exists in the TARGET folder, skipping ...', 'COPYLINK')
@ -59,7 +59,7 @@ def copy_link(src, target_link, use_link):
shutil.move(src, target_link)
return True
except Exception as e:
logger.warning('Error: {0}, copying instead ... '.format(e), 'COPYLINK')
logger.warning(f'Error: {e}, copying instead ... ', 'COPYLINK')
logger.info('Copying SOURCE MEDIAFILE -> TARGET FOLDER', 'COPYLINK')
shutil.copy(src, target_link)
@ -78,10 +78,10 @@ def replace_links(link, max_depth=10):
link_depth = attempt
if not link_depth:
logger.debug('{0} is not a link'.format(link))
logger.debug(f'{link} is not a link')
elif link_depth > max_depth or (link_depth == max_depth and islink(target)):
logger.warning('Exceeded maximum depth {0} while following link {1}'.format(max_depth, link))
logger.warning(f'Exceeded maximum depth {max_depth} while following link {link}')
else:
logger.info('Changing sym-link: {0} to point directly to file: {1}'.format(link, target), 'COPYLINK')
logger.info(f'Changing sym-link: {link} to point directly to file: {target}', 'COPYLINK')
os.unlink(link)
linktastic.symlink(target, link)

20
core/utils/network.py
View file

@ -30,7 +30,7 @@ def wake_on_lan(ethernet_address):
connection.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
connection.sendto(magic_packet, ('<broadcast>', 9))
logger.info('WakeOnLan sent for mac: {0}'.format(ethernet_address))
logger.info(f'WakeOnLan sent for mac: {ethernet_address}')
def test_connection(host, port):
@ -38,7 +38,7 @@ def test_connection(host, port):
address = host, port
try:
socket.create_connection(address)
except socket.error:
except OSError:
return 'Down'
else:
return 'Up'
@ -54,9 +54,9 @@ def wake_up():
logger.info('Trying to wake On lan.')
for attempt in range(0, max_attempts):
logger.info('Attempt {0} of {1}'.format(attempt + 1, max_attempts, mac))
logger.info(f'Attempt {attempt + 1} of {max_attempts}')
if test_connection(host, port) == 'Up':
logger.info('System with mac: {0} has been woken.'.format(mac))
logger.info(f'System with mac: {mac} has been woken.')
break
wake_on_lan(mac)
time.sleep(20)
@ -69,19 +69,19 @@ def wake_up():
def server_responding(base_url):
logger.debug('Attempting to connect to server at {0}'.format(base_url), 'SERVER')
logger.debug(f'Attempting to connect to server at {base_url}', 'SERVER')
try:
requests.get(base_url, timeout=(60, 120), verify=False)
except (requests.ConnectionError, requests.exceptions.Timeout):
logger.error('Server failed to respond at {0}'.format(base_url), 'SERVER')
logger.error(f'Server failed to respond at {base_url}', 'SERVER')
return False
else:
logger.debug('Server responded at {0}'.format(base_url), 'SERVER')
logger.debug(f'Server responded at {base_url}', 'SERVER')
return True
def find_download(client_agent, download_id):
logger.debug('Searching for Download on {0} ...'.format(client_agent))
logger.debug(f'Searching for Download on {client_agent} ...')
if client_agent == 'utorrent':
torrents = core.TORRENT_CLASS.list()[1]['torrents']
for torrent in torrents:
@ -102,9 +102,9 @@ def find_download(client_agent, download_id):
return True
if client_agent == 'sabnzbd':
if 'http' in core.SABNZBD_HOST:
base_url = '{0}:{1}/api'.format(core.SABNZBD_HOST, core.SABNZBD_PORT)
base_url = f'{core.SABNZBD_HOST}:{core.SABNZBD_PORT}/api'
else:
base_url = 'http://{0}:{1}/api'.format(core.SABNZBD_HOST, core.SABNZBD_PORT)
base_url = f'http://{core.SABNZBD_HOST}:{core.SABNZBD_PORT}/api'
url = base_url
params = {
'apikey': core.SABNZBD_APIKEY,

5
core/utils/parsers.py
View file

@ -84,10 +84,11 @@ def parse_synods(args):
input_hash = os.getenv('TR_TORRENT_HASH')
if not input_name: # No info passed. Assume manual download.
return input_directory, input_name, input_category, input_hash, input_id
input_id = 'dbid_{0}'.format(os.getenv('TR_TORRENT_ID'))
torrent_id = os.getenv('TR_TORRENT_ID')
input_id = f'dbid_{torrent_id}'
#res = core.TORRENT_CLASS.tasks_list(additional_param='detail')
res = core.TORRENT_CLASS.tasks_info(input_id, additional_param='detail')
logger.debug('result from syno {0}'.format(res))
logger.debug(f'result from syno {res}')
if res['success']:
try:
tasks = res['data']['tasks']

26
core/utils/paths.py
View file

@ -28,11 +28,11 @@ def onerror(func, path, exc_info):
def remove_dir(dir_name):
logger.info('Deleting {0}'.format(dir_name))
logger.info(f'Deleting {dir_name}')
try:
shutil.rmtree(dir_name, onerror=onerror)
except Exception:
logger.error('Unable to delete folder {0}'.format(dir_name))
logger.error(f'Unable to delete folder {dir_name}')
def make_dir(path):
@ -76,7 +76,7 @@ def remove_empty_folders(path, remove_root=True):
return
# remove empty subfolders
logger.debug('Checking for empty folders in:{0}'.format(path))
logger.debug(f'Checking for empty folders in:{path}')
files = os.listdir(path)
if len(files):
for f in files:
@ -87,7 +87,7 @@ def remove_empty_folders(path, remove_root=True):
# if folder empty, delete it
files = os.listdir(path)
if len(files) == 0 and remove_root:
logger.debug('Removing empty folder:{}'.format(path))
logger.debug(f'Removing empty folder:{path}')
os.rmdir(path)
@ -102,11 +102,11 @@ def remove_read_only(filename):
try:
os.chmod(filename, stat.S_IWRITE)
except Exception:
logger.warning('Cannot change permissions of {file}'.format(file=filename), logger.WARNING)
logger.warning(f'Cannot change permissions of {filename}', logger.WARNING)
def flatten_dir(destination, files):
logger.info('FLATTEN: Flattening directory: {0}'.format(destination))
logger.info(f'FLATTEN: Flattening directory: {destination}')
for outputFile in files:
dir_path = os.path.dirname(outputFile)
file_name = os.path.basename(outputFile)
@ -119,37 +119,37 @@ def flatten_dir(destination, files):
try:
shutil.move(outputFile, target)
except Exception:
logger.error('Could not flatten {0}'.format(outputFile), 'FLATTEN')
logger.error(f'Could not flatten {outputFile}', 'FLATTEN')
remove_empty_folders(destination) # Cleanup empty directories
def clean_directory(path, files):
if not os.path.exists(path):
logger.info('Directory {0} has been processed and removed ...'.format(path), 'CLEANDIR')
logger.info(f'Directory {path} has been processed and removed ...', 'CLEANDIR')
return
if core.FORCE_CLEAN and not core.FAILED:
logger.info('Doing Forceful Clean of {0}'.format(path), 'CLEANDIR')
logger.info(f'Doing Forceful Clean of {path}', 'CLEANDIR')
remove_dir(path)
return
if files:
logger.info(
'Directory {0} still contains {1} unprocessed file(s), skipping ...'.format(path, len(files)),
f'Directory {path} still contains {len(files)} unprocessed file(s), skipping ...',
'CLEANDIRS',
)
return
logger.info('Directory {0} has been processed, removing ...'.format(path), 'CLEANDIRS')
logger.info(f'Directory {path} has been processed, removing ...', 'CLEANDIRS')
try:
shutil.rmtree(path, onerror=onerror)
except Exception:
logger.error('Unable to delete directory {0}'.format(path))
logger.error(f'Unable to delete directory {path}')
def rchmod(path, mod):
logger.log('Changing file mode of {0} to {1}'.format(path, oct(mod)))
logger.log(f'Changing file mode of {path} to {oct(mod)}')
os.chmod(path, mod)
if not os.path.isdir(path):
return # Skip files

9
core/utils/processes.py
View file

@ -1,4 +1,3 @@
import os
import socket
import subprocess
@ -44,10 +43,10 @@ class PosixProcess:
def alreadyrunning(self):
try:
self.lock_socket = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
self.lock_socket.bind('\0{path}'.format(path=self.pidpath))
self.lock_socket.bind(f'\0{self.pidpath}')
self.lasterror = False
return self.lasterror
except socket.error as e:
except OSError as e:
if 'Address already in use' in str(e):
self.lasterror = True
return self.lasterror
@ -56,7 +55,7 @@ class PosixProcess:
if os.path.exists(self.pidpath):
# Make sure it is not a 'stale' pidFile
try:
pid = int(open(self.pidpath, 'r').read().strip())
pid = int(open(self.pidpath).read().strip())
except Exception:
pid = None
# Check list of running pids, if not running it is stale so overwrite
@ -107,7 +106,7 @@ def restart():
if popen_list:
popen_list += SYS_ARGV
logger.log('Restarting nzbToMedia with {args}'.format(args=popen_list))
logger.log(f'Restarting nzbToMedia with {popen_list}')
logger.close()
p = subprocess.Popen(popen_list, cwd=os.getcwd())
p.wait()

48
core/version_check.py
View file

@ -64,7 +64,7 @@ class CheckVersion:
logger.log('Version checking is disabled, not checking for the newest version')
return False
logger.log('Checking if {install} needs an update'.format(install=self.install_type))
logger.log(f'Checking if {self.install_type} needs an update')
if not self.updater.need_update():
core.NEWEST_VERSION_STRING = None
logger.log('No update needed')
@ -111,7 +111,7 @@ class GitUpdateManager(UpdateManager):
test_cmd = 'version'
if core.GIT_PATH:
main_git = '"{git}"'.format(git=core.GIT_PATH)
main_git = f'"{core.GIT_PATH}"'
else:
main_git = 'git'
@ -120,10 +120,10 @@ class GitUpdateManager(UpdateManager):
output, err, exit_status = self._run_git(main_git, test_cmd)
if exit_status == 0:
logger.log('Using: {git}'.format(git=main_git), logger.DEBUG)
logger.log(f'Using: {main_git}', logger.DEBUG)
return main_git
else:
logger.log('Not using: {git}'.format(git=main_git), logger.DEBUG)
logger.log(f'Not using: {main_git}', logger.DEBUG)
# trying alternatives
@ -146,10 +146,10 @@ class GitUpdateManager(UpdateManager):
output, err, exit_status = self._run_git(cur_git, test_cmd)
if exit_status == 0:
logger.log('Using: {git}'.format(git=cur_git), logger.DEBUG)
logger.log(f'Using: {cur_git}', logger.DEBUG)
return cur_git
else:
logger.log('Not using: {git}'.format(git=cur_git), logger.DEBUG)
logger.log(f'Not using: {cur_git}', logger.DEBUG)
# Still haven't found a working git
logger.debug('Unable to find your git executable - '
@ -168,7 +168,7 @@ class GitUpdateManager(UpdateManager):
exit_status = 1
return output, err, exit_status
cmd = '{git} {args}'.format(git=git_path, args=args)
cmd = f'{git_path} {args}'
try:
logger.log('Executing {cmd} with your shell in {directory}'.format
@ -183,15 +183,15 @@ class GitUpdateManager(UpdateManager):
if output:
output = output.strip()
if core.LOG_GIT:
logger.log('git output: {output}'.format(output=output), logger.DEBUG)
logger.log(f'git output: {output}', logger.DEBUG)
except OSError:
logger.log('Command {cmd} didn\'t work'.format(cmd=cmd))
logger.log(f'Command {cmd} didn\'t work')
exit_status = 1
exit_status = 128 if ('fatal:' in output) or err else exit_status
if exit_status == 0:
logger.log('{cmd} : returned successful'.format(cmd=cmd), logger.DEBUG)
logger.log(f'{cmd} : returned successful', logger.DEBUG)
exit_status = 0
elif core.LOG_GIT and exit_status in (1, 128):
logger.log('{cmd} returned : {output}'.format
@ -310,7 +310,7 @@ class GitUpdateManager(UpdateManager):
try:
self._check_github_for_update()
except Exception as error:
logger.log('Unable to contact github, can\'t check for update: {msg!r}'.format(msg=error), logger.ERROR)
logger.log(f'Unable to contact github, can\'t check for update: {error!r}', logger.ERROR)
return False
if self._num_commits_behind > 0:
@ -325,7 +325,7 @@ class GitUpdateManager(UpdateManager):
Calls git pull origin <branch> in order to update Sick Beard.
Returns a bool depending on the call's success.
"""
output, err, exit_status = self._run_git(self._git_path, 'pull origin {branch}'.format(branch=self.branch)) # @UnusedVariable
output, err, exit_status = self._run_git(self._git_path, f'pull origin {self.branch}') # @UnusedVariable
if exit_status == 0:
return True
@ -352,10 +352,10 @@ class SourceUpdateManager(UpdateManager):
return
try:
with open(version_file, 'r') as fp:
with open(version_file) as fp:
self._cur_commit_hash = fp.read().strip(' \n\r')
except EnvironmentError as error:
logger.log('Unable to open \'version.txt\': {msg}'.format(msg=error), logger.DEBUG)
except OSError as error:
logger.log(f'Unable to open \'version.txt\': {error}', logger.DEBUG)
if not self._cur_commit_hash:
self._cur_commit_hash = None
@ -369,7 +369,7 @@ class SourceUpdateManager(UpdateManager):
try:
self._check_github_for_update()
except Exception as error:
logger.log('Unable to contact github, can\'t check for update: {msg!r}'.format(msg=error), logger.ERROR)
logger.log(f'Unable to contact github, can\'t check for update: {error!r}', logger.ERROR)
return False
if not self._cur_commit_hash or self._num_commits_behind > 0:
@ -444,14 +444,14 @@ class SourceUpdateManager(UpdateManager):
sb_update_dir = os.path.join(core.APP_ROOT, 'sb-update')
if os.path.isdir(sb_update_dir):
logger.log('Clearing out update folder {dir} before extracting'.format(dir=sb_update_dir))
logger.log(f'Clearing out update folder {sb_update_dir} before extracting')
shutil.rmtree(sb_update_dir)
logger.log('Creating update folder {dir} before extracting'.format(dir=sb_update_dir))
logger.log(f'Creating update folder {sb_update_dir} before extracting')
os.makedirs(sb_update_dir)
# retrieve file
logger.log('Downloading update from {url!r}'.format(url=tar_download_url))
logger.log(f'Downloading update from {tar_download_url!r}')
tar_download_path = os.path.join(sb_update_dir, 'nzbtomedia-update.tar')
urlretrieve(tar_download_url, tar_download_path)
@ -466,20 +466,20 @@ class SourceUpdateManager(UpdateManager):
return False
# extract to sb-update dir
logger.log('Extracting file {path}'.format(path=tar_download_path))
logger.log(f'Extracting file {tar_download_path}')
tar = tarfile.open(tar_download_path)
tar.extractall(sb_update_dir)
tar.close()
# delete .tar.gz
logger.log('Deleting file {path}'.format(path=tar_download_path))
logger.log(f'Deleting file {tar_download_path}')
os.remove(tar_download_path)
# find update dir name
update_dir_contents = [x for x in os.listdir(sb_update_dir) if
os.path.isdir(os.path.join(sb_update_dir, x))]
if len(update_dir_contents) != 1:
logger.log('Invalid update data, update failed: {0}'.format(update_dir_contents), logger.ERROR)
logger.log(f'Invalid update data, update failed: {update_dir_contents}', logger.ERROR)
return False
content_dir = os.path.join(sb_update_dir, update_dir_contents[0])
@ -514,7 +514,7 @@ class SourceUpdateManager(UpdateManager):
try:
with open(version_path, 'w') as ver_file:
ver_file.write(self._newest_commit_hash)
except EnvironmentError as error:
except OSError as error:
logger.log('Unable to write version file, update not complete: {msg}'.format
(msg=error), logger.ERROR)
return False
@ -522,7 +522,7 @@ class SourceUpdateManager(UpdateManager):
except Exception as error:
logger.log('Error while trying to update: {msg}'.format
(msg=error), logger.ERROR)
logger.log('Traceback: {error}'.format(error=traceback.format_exc()), logger.DEBUG)
logger.log(f'Traceback: {traceback.format_exc()}', logger.DEBUG)
return False
return True

8
libs/__init__.py
View file

@ -1,11 +1,3 @@
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import os
import site
import sys

10
libs/__main__.py
View file

@ -1,11 +1,3 @@
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import shutil
import os
import time
@ -23,5 +15,5 @@ if __name__ == '__main__':
else:
print('Removed', directory)
time.sleep(10)
requirements = 'requirements-{name}.txt'.format(name=lib)
requirements = f'requirements-{lib}.txt'
libs.util.install_requirements(requirements, file=True, path=directory)

8
libs/autoload.py
View file

@ -1,11 +1,3 @@
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import libs
__all__ = ['completed']

8
libs/util.py
View file

@ -1,11 +1,3 @@
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import subprocess
import sys
import os

7
nzbToCouchPotato.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -262,12 +261,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

7
nzbToGamez.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -102,12 +101,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

7
nzbToHeadPhones.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -124,12 +123,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

7
nzbToLazyLibrarian.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -110,12 +109,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

7
nzbToLidarr.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -239,12 +238,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

15
nzbToMedia.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -715,12 +714,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import os
import sys
@ -743,11 +736,11 @@ def main(args, section=None):
core.initialize(section)
logger.info('#########################################################')
logger.info('## ..::[{0}]::.. ##'.format(os.path.basename(__file__)))
logger.info(f'## ..::[{os.path.basename(__file__)}]::.. ##')
logger.info('#########################################################')
# debug command line options
logger.debug('Options passed into nzbToMedia: {0}'.format(args))
logger.debug(f'Options passed into nzbToMedia: {args}')
# Post-Processing Result
result = ProcessResult(
@ -774,14 +767,14 @@ def main(args, section=None):
manual.process()
if result.status_code == 0:
logger.info('The {0} script completed successfully.'.format(args[0]))
logger.info(f'The {args[0]} script completed successfully.')
if result.message:
print(result.message + '!')
if 'NZBOP_SCRIPTDIR' in os.environ: # return code for nzbget v11
del core.MYAPP
return core.NZBGET_POSTPROCESS_SUCCESS
else:
logger.error('A problem was reported in the {0} script.'.format(args[0]))
logger.error(f'A problem was reported in the {args[0]} script.')
if result.message:
print(result.message + '!')
if 'NZBOP_SCRIPTDIR' in os.environ: # return code for nzbget v11

7
nzbToMylar.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -115,12 +114,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

7
nzbToNzbDrone.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -252,12 +251,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

7
nzbToRadarr.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -257,12 +256,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

7
nzbToSiCKRAGE.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -266,12 +265,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

7
nzbToSickBeard.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -263,12 +262,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

7
nzbToWatcher3.py
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python
# coding=utf-8
#
##############################################################################
### NZBGET POST-PROCESSING SCRIPT ###
@ -257,12 +256,6 @@
### NZBGET POST-PROCESSING SCRIPT ###
##############################################################################
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import sys

9
setup.py
View file

@ -1,11 +1,4 @@
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import io
import os.path
@ -14,7 +7,7 @@ from setuptools import setup
def read(*names, **kwargs):
with io.open(
with open(
os.path.join(os.path.dirname(__file__), *names),
encoding=kwargs.get('encoding', 'utf8'),
) as fh:

7
tests/__init__.py
View file

@ -1,8 +1 @@
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
__author__ = 'Justin'

6
tests/test_initialize.py
View file

@ -1,10 +1,4 @@
#! /usr/bin/env python
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import core

6
tests/test_transcoder.py
View file

@ -1,10 +1,4 @@
#! /usr/bin/env python
from __future__ import (
absolute_import,
division,
print_function,
unicode_literals,
)
import core
from core import transcoder