From 4d0ce3bcd2e533c4c270d2afab69b6b0c3d277f2 Mon Sep 17 00:00:00 2001 From: Labrys of Knossos Date: Sat, 3 Dec 2022 18:28:29 -0500 Subject: [PATCH 1/5] Use `ProcessResult.failure` or `ProcessResult.success` --- core/auto_process/managers/sickbeard.py | 26 +++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/core/auto_process/managers/sickbeard.py b/core/auto_process/managers/sickbeard.py index 25ebb542..e7403331 100644 --- a/core/auto_process/managers/sickbeard.py +++ b/core/auto_process/managers/sickbeard.py @@ -454,16 +454,16 @@ class SickBeard: response = self.session.get(self.url, auth=(self.sb_init.username, self.sb_init.password), params=self.sb_init.fork_params, stream=True, verify=False, timeout=(30, 1800)) except requests.ConnectionError: logger.error(f'Unable to open URL: {self.url}', self.sb_init.section) - return ProcessResult( - message='{0}: Failed to post-process - Unable to connect to {0}'.format(self.sb_init.section), - status_code=1, + return ProcessResult.failure( + f'{self.sb_init.section}: Failed to post-process - Unable to ' + f'connect to {self.sb_init.section}' ) if response.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]: logger.error('Server returned status {0}'.format(response.status_code), self.sb_init.section) - return ProcessResult( - message='{0}: Failed to post-process - Server returned status {1}'.format(self.sb_init.section, response.status_code), - status_code=1, + return ProcessResult.failure( + f'{self.sb_init.section}: Failed to post-process - Server ' + f'returned status {response.status_code}' ) return self.process_response(response) @@ -487,11 +487,13 @@ class SickBeard: self.success = True if self.success: - return ProcessResult( - message='{0}: Successfully post-processed {1}'.format(self.sb_init.section, self.input_name), - status_code=0, + return ProcessResult.success( + f'{self.sb_init.section}: Successfully post-processed ' + f'{self.input_name}' ) - return ProcessResult( - message='{0}: Failed to post-process - Returned log from {0} was not as expected.'.format(self.sb_init.section), - status_code=1, # We did not receive Success confirmation. + + # We did not receive Success confirmation. + return ProcessResult.failure( + f'{self.sb_init.section}: Failed to post-process - Returned log ' + f'from {self.sb_init.section} was not as expected.' ) From a21283bd2ed5e077a1c4d202b7db2e8db49d79a9 Mon Sep 17 00:00:00 2001 From: Labrys of Knossos Date: Sat, 3 Dec 2022 18:31:11 -0500 Subject: [PATCH 2/5] Add type-hints for `SickBeard.api_call` and `SickBeard.process_response` --- core/auto_process/managers/sickbeard.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/auto_process/managers/sickbeard.py b/core/auto_process/managers/sickbeard.py index e7403331..6c0a85b8 100644 --- a/core/auto_process/managers/sickbeard.py +++ b/core/auto_process/managers/sickbeard.py @@ -432,7 +432,7 @@ class SickBeard: # delete any unused params so we don't pass them to SB by mistake [fork_params.pop(k) for k, v in list(fork_params.items()) if v is None] - def api_call(self): + def api_call(self) -> ProcessResult: """Perform a base sickbeard api call.""" self._process_fork_prarams() logger.debug(f'Opening URL: {self.url} with params: {self.sb_init.fork_params}', self.sb_init.section) @@ -468,7 +468,7 @@ class SickBeard: return self.process_response(response) - def process_response(self, response): + def process_response(self, response: requests.Response) -> ProcessResult: """Iterate over the lines returned, and log. :param response: Streamed Requests response object. From 869e23c236b7df3eb275a846a3ab119b6094137a Mon Sep 17 00:00:00 2001 From: Labrys of Knossos Date: Sat, 3 Dec 2022 18:58:00 -0500 Subject: [PATCH 3/5] Use f-strings --- core/auto_process/managers/sickbeard.py | 136 +++++++++++++++--------- 1 file changed, 88 insertions(+), 48 deletions(-) diff --git a/core/auto_process/managers/sickbeard.py b/core/auto_process/managers/sickbeard.py index 6c0a85b8..6a0d29bc 100644 --- a/core/auto_process/managers/sickbeard.py +++ b/core/auto_process/managers/sickbeard.py @@ -62,8 +62,10 @@ class InitSickBeard: # auto-detect correct section # config settings if core.FORK_SET: # keep using determined fork for multiple (manual) post-processing - logger.info('{section}:{category} fork already set to {fork}'.format - (section=self.section, category=self.input_category, fork=core.FORK_SET[0])) + logger.info( + f'{self.section}:{self.input_category} fork already set to ' + f'{core.FORK_SET[0]}' + ) return core.FORK_SET[0], core.FORK_SET[1] cfg = dict(core.CFG[self.section][self.input_category]) @@ -87,36 +89,46 @@ class InitSickBeard: protocol = 'https://' if self.ssl else 'http://' if self.section == 'NzbDrone': - logger.info('Attempting to verify {category} fork'.format - (category=self.input_category)) - url = '{protocol}{host}:{port}{root}/api/rootfolder'.format( - protocol=protocol, host=self.host, port=self.port, root=self.web_root, + logger.info(f'Attempting to verify {self.input_category} fork') + url = core.utils.common.create_url( + scheme=protocol, + host=self.host, + port=self.port, + path=f'{self.web_root}/api/rootfolder', ) headers = {'X-Api-Key': self.apikey} try: r = requests.get(url, headers=headers, stream=True, verify=False) except requests.ConnectionError: - logger.warning('Could not connect to {0}:{1} to verify fork!'.format(self.section, self.input_category)) + logger.warning(f'Could not connect to {self.section}:' + f'{self.input_category} to verify fork!') if not r.ok: - logger.warning('Connection to {section}:{category} failed! ' - 'Check your configuration'.format - (section=self.section, category=self.input_category)) + logger.warning( + f'Connection to {self.section}:{self.input_category} ' + f'failed! Check your configuration' + ) self.fork = ['default', {}] elif self.section == 'SiCKRAGE': - logger.info('Attempting to verify {category} fork'.format - (category=self.input_category)) + logger.info(f'Attempting to verify {self.input_category} fork') if self.api_version >= 2: - url = '{protocol}{host}:{port}{root}/api/v{api_version}/ping'.format( - protocol=protocol, host=self.host, port=self.port, root=self.web_root, api_version=self.api_version + url = core.utils.common.create_url( + scheme=protocol, + host=self.host, + port=self.port, + path=f'{self.web_root}/api/v{self.api_version}/ping', ) api_params = {} else: - url = '{protocol}{host}:{port}{root}/api/v{api_version}/{apikey}/'.format( - protocol=protocol, host=self.host, port=self.port, root=self.web_root, api_version=self.api_version, apikey=self.apikey, + api_version = f'v{self.api_version}' + url = core.utils.common.create_url( + scheme=protocol, + host=self.host, + port=self.port, + path=f'{self.web_root}/api/{api_version}/{self.apikey}/', ) api_params = {'cmd': 'postprocess', 'help': '1'} @@ -132,12 +144,15 @@ class InitSickBeard: r = requests.get(url, params=api_params, stream=True, verify=False) if not r.ok: - logger.warning('Connection to {section}:{category} failed! ' - 'Check your configuration'.format( - section=self.section, category=self.input_category - )) + logger.warning( + f'Connection to {self.section}:{self.input_category} ' + f'failed! Check your configuration' + ) except requests.ConnectionError: - logger.warning('Could not connect to {0}:{1} to verify API version!'.format(self.section, self.input_category)) + logger.warning( + f'Could not connect to {self.section}:' + f'{self.input_category} to verify API version!' + ) params = { 'path': None, @@ -156,8 +171,9 @@ class InitSickBeard: elif self.fork == 'auto': self.detect_fork() - logger.info('{section}:{category} fork set to {fork}'.format - (section=self.section, category=self.input_category, fork=self.fork[0])) + logger.info( + f'{self.section}:{self.input_category} fork set to {self.fork[0]}' + ) core.FORK_SET = self.fork self.fork, self.fork_params = self.fork[0], self.fork[1] # This will create the fork object, and attach to self.fork_obj. @@ -177,7 +193,7 @@ class InitSickBeard: json_data = json_data['data'] except KeyError: logger.error('Failed to get data from JSON') - logger.debug('Response received: {}'.format(json_data)) + logger.debug(f'Response received: {json_data}') raise else: if isinstance(json_data, str): @@ -189,7 +205,8 @@ class InitSickBeard: # Find excess parameters excess_parameters = set(params).difference(optional_parameters) excess_parameters.remove('cmd') # Don't remove cmd from api params - logger.debug('Removing excess parameters: {}'.format(sorted(excess_parameters))) + logger.debug(f'Removing excess parameters: ' + f'{sorted(excess_parameters)}') rem_params.extend(excess_parameters) return rem_params, True except: @@ -201,18 +218,24 @@ class InitSickBeard: detected = False params = core.ALL_FORKS rem_params = [] - logger.info('Attempting to auto-detect {category} fork'.format(category=self.input_category)) + logger.info(f'Attempting to auto-detect {self.input_category} fork') # define the order to test. Default must be first since the default fork doesn't reject parameters. # then in order of most unique parameters. if self.apikey: - url = '{protocol}{host}:{port}{root}/api/{apikey}/'.format( - protocol=self.protocol, host=self.host, port=self.port, root=self.web_root, apikey=self.apikey, + url = core.utils.common.create_url( + scheme=self.protocol, + host=self.host, + port=self.port, + path=f'{self.web_root}/api/{self.apikey}/', ) api_params = {'cmd': 'sg.postprocess', 'help': '1'} else: - url = '{protocol}{host}:{port}{root}/home/postprocess/'.format( - protocol=self.protocol, host=self.host, port=self.port, root=self.web_root, + url = core.utils.common.create_url( + scheme=self.protocol, + host=self.host, + port=self.port, + path=f'{self.web_root}/home/postprocess', ) api_params = {} @@ -221,8 +244,12 @@ class InitSickBeard: s = requests.Session() if not self.apikey and self.username and self.password: - login = '{protocol}{host}:{port}{root}/login'.format( - protocol=self.protocol, host=self.host, port=self.port, root=self.web_root) + login = core.utils.common.create_url( + scheme=self.protocol, + host=self.host, + port=self.port, + path=f'{self.web_root}/login', + ) login_params = {'username': self.username, 'password': self.password} r = s.get(login, verify=False, timeout=(30, 60)) if r.status_code in [401, 403] and r.cookies.get('_xsrf'): @@ -230,8 +257,10 @@ class InitSickBeard: s.post(login, data=login_params, stream=True, verify=False) r = s.get(url, auth=(self.username, self.password), params=api_params, verify=False) except requests.ConnectionError: - logger.info('Could not connect to {section}:{category} to perform auto-fork detection!'.format - (section=self.section, category=self.input_category)) + logger.info( + f'Could not connect to {self.section}:{self.input_category} ' + f'to perform auto-fork detection!' + ) r = [] if r and r.ok: @@ -247,8 +276,11 @@ class InitSickBeard: else: r = s.get(url, params=api_params, verify=False) except requests.ConnectionError: - logger.info('Could not connect to {section}:{category} to perform auto-fork detection!'.format - (section=self.section, category=self.input_category)) + logger.info( + f'Could not connect to {self.section}:' + f'{self.input_category} to perform auto-fork ' + f'detection!' + ) rem_params, found = self._api_check(r, params, rem_params) params['cmd'] = 'postprocess' else: @@ -256,7 +288,7 @@ class InitSickBeard: rem_params.extend( param for param in params - if 'name="{param}"'.format(param=param) not in r.text + if f'name="{param}"' not in r.text ) # Remove excess params @@ -270,15 +302,21 @@ class InitSickBeard: if detected: self.fork = fork - logger.info('{section}:{category} fork auto-detection successful ...'.format - (section=self.section, category=self.input_category)) + logger.info( + f'{self.section}:{self.input_category} fork auto-detection ' + f'successful ...' + ) elif rem_params: - logger.info('{section}:{category} fork auto-detection found custom params {params}'.format - (section=self.section, category=self.input_category, params=params)) + logger.info( + f'{self.section}:{self.input_category} fork auto-detection ' + f'found custom params {params}' + ) self.fork = ['custom', params] else: - logger.info('{section}:{category} fork auto-detection failed'.format - (section=self.section, category=self.input_category)) + logger.info( + f'{self.section}:{self.input_category} fork auto-detection ' + f'failed' + ) self.fork = list(core.FORKS.items())[list(core.FORKS.keys()).index(core.FORK_DEFAULT)] def _init_fork(self): @@ -290,13 +328,14 @@ class InitSickBeard: 'Medusa-api': PyMedusaApiV1, 'Medusa-apiv2': PyMedusaApiV2 } - logger.debug('Create object for fork {fork}'.format(fork=self.fork)) + logger.debug(f'Create object for fork {self.fork}') if self.fork and mapped_forks.get(self.fork): # Create the fork object and pass self (SickBeardInit) to it for all the data, like Config. self.fork_obj = mapped_forks[self.fork](self) else: - logger.info('{section}:{category} Could not create a fork object for {fork}. Probaly class not added yet.'.format( - section=self.section, category=self.input_category, fork=self.fork) + logger.info( + f'{self.section}:{self.input_category} Could not create a ' + f'fork object for {self.fork}. Probaly class not added yet.' ) @@ -460,7 +499,8 @@ class SickBeard: ) if response.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]: - logger.error('Server returned status {0}'.format(response.status_code), self.sb_init.section) + logger.error(f'Server returned status {response.status_code}', + self.sb_init.section) return ProcessResult.failure( f'{self.sb_init.section}: Failed to post-process - Server ' f'returned status {response.status_code}' @@ -477,7 +517,7 @@ class SickBeard: for line in response.iter_lines(): if line: line = line.decode('utf-8') - logger.postprocess('{0}'.format(line), self.sb_init.section) + logger.postprocess(line, self.sb_init.section) # if 'Moving file from' in line: # input_name = os.path.split(line)[1] # if 'added to the queue' in line: From e953bd9c91f2c9e4886c0eadab5d3fae67f61d17 Mon Sep 17 00:00:00 2001 From: Labrys of Knossos Date: Sat, 3 Dec 2022 19:03:00 -0500 Subject: [PATCH 4/5] Reduce number of return paths. --- core/auto_process/managers/sickbeard.py | 46 +++++++++++++++---------- 1 file changed, 27 insertions(+), 19 deletions(-) diff --git a/core/auto_process/managers/sickbeard.py b/core/auto_process/managers/sickbeard.py index 6a0d29bc..f61a9d09 100644 --- a/core/auto_process/managers/sickbeard.py +++ b/core/auto_process/managers/sickbeard.py @@ -493,20 +493,26 @@ class SickBeard: response = self.session.get(self.url, auth=(self.sb_init.username, self.sb_init.password), params=self.sb_init.fork_params, stream=True, verify=False, timeout=(30, 1800)) except requests.ConnectionError: logger.error(f'Unable to open URL: {self.url}', self.sb_init.section) - return ProcessResult.failure( + result = ProcessResult.failure( f'{self.sb_init.section}: Failed to post-process - Unable to ' f'connect to {self.sb_init.section}' ) - - if response.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]: - logger.error(f'Server returned status {response.status_code}', - self.sb_init.section) - return ProcessResult.failure( - f'{self.sb_init.section}: Failed to post-process - Server ' - f'returned status {response.status_code}' - ) - - return self.process_response(response) + else: + successful_statuses = [ + requests.codes.ok, + requests.codes.created, + requests.codes.accepted, + ] + if response.status_code not in successful_statuses: + logger.error(f'Server returned status {response.status_code}', + self.sb_init.section) + result = ProcessResult.failure( + f'{self.sb_init.section}: Failed to post-process - Server ' + f'returned status {response.status_code}' + ) + else: + result = self.process_response(response) + return result def process_response(self, response: requests.Response) -> ProcessResult: """Iterate over the lines returned, and log. @@ -522,18 +528,20 @@ class SickBeard: # input_name = os.path.split(line)[1] # if 'added to the queue' in line: # queued = True - # For the refactoring i'm only considering vanilla sickbeard, as for the base class. + # For the refactoring i'm only considering vanilla sickbeard, + # as for the base class. if 'Processing succeeded' in line or 'Successfully processed' in line: self.success = True if self.success: - return ProcessResult.success( + result = ProcessResult.success( f'{self.sb_init.section}: Successfully post-processed ' f'{self.input_name}' ) - - # We did not receive Success confirmation. - return ProcessResult.failure( - f'{self.sb_init.section}: Failed to post-process - Returned log ' - f'from {self.sb_init.section} was not as expected.' - ) + else: + # We did not receive Success confirmation. + result = ProcessResult.failure( + f'{self.sb_init.section}: Failed to post-process - Returned ' + f'log from {self.sb_init.section} was not as expected.' + ) + return result From c0445e97d5a409fd4ca73e0ccf186df8b33e3430 Mon Sep 17 00:00:00 2001 From: Labrys of Knossos Date: Sat, 3 Dec 2022 21:20:59 -0500 Subject: [PATCH 5/5] Blacken code --- core/auto_process/managers/sickbeard.py | 175 ++++++++++++++++++------ 1 file changed, 135 insertions(+), 40 deletions(-) diff --git a/core/auto_process/managers/sickbeard.py b/core/auto_process/managers/sickbeard.py index f61a9d09..3c98d45b 100644 --- a/core/auto_process/managers/sickbeard.py +++ b/core/auto_process/managers/sickbeard.py @@ -61,7 +61,8 @@ class InitSickBeard: def auto_fork(self): # auto-detect correct section # config settings - if core.FORK_SET: # keep using determined fork for multiple (manual) post-processing + if core.FORK_SET: + # keep using determined fork for multiple (manual) post-processing logger.info( f'{self.section}:{self.input_category} fork already set to ' f'{core.FORK_SET[0]}' @@ -98,10 +99,17 @@ class InitSickBeard: ) headers = {'X-Api-Key': self.apikey} try: - r = requests.get(url, headers=headers, stream=True, verify=False) + r = requests.get( + url, + headers=headers, + stream=True, + verify=False, + ) except requests.ConnectionError: - logger.warning(f'Could not connect to {self.section}:' - f'{self.input_category} to verify fork!') + logger.warning( + f'Could not connect to {self.section}:' + f'{self.input_category} to verify fork!' + ) if not r.ok: logger.warning( @@ -133,15 +141,36 @@ class InitSickBeard: api_params = {'cmd': 'postprocess', 'help': '1'} try: - if self.api_version >= 2 and self.sso_username and self.sso_password: - oauth = OAuth2Session(client=LegacyApplicationClient(client_id=core.SICKRAGE_OAUTH_CLIENT_ID)) - oauth_token = oauth.fetch_token(client_id=core.SICKRAGE_OAUTH_CLIENT_ID, - token_url=core.SICKRAGE_OAUTH_TOKEN_URL, - username=self.sso_username, - password=self.sso_password) - r = requests.get(url, headers={'Authorization': 'Bearer ' + oauth_token['access_token']}, stream=True, verify=False) + if ( + self.api_version >= 2 + and self.sso_username + and self.sso_password + ): + oauth = OAuth2Session( + client=LegacyApplicationClient( + client_id=core.SICKRAGE_OAUTH_CLIENT_ID + ) + ) + oauth_token = oauth.fetch_token( + client_id=core.SICKRAGE_OAUTH_CLIENT_ID, + token_url=core.SICKRAGE_OAUTH_TOKEN_URL, + username=self.sso_username, + password=self.sso_password, + ) + token = oauth_token['access_token'] + r = requests.get( + url, + headers={f'Authorization': f'Bearer {token}'}, + stream=True, + verify=False, + ) else: - r = requests.get(url, params=api_params, stream=True, verify=False) + r = requests.get( + url, + params=api_params, + stream=True, + verify=False, + ) if not r.ok: logger.warning( @@ -163,7 +192,7 @@ class InitSickBeard: 'type': None, 'delete': None, 'force_next': None, - 'is_priority': None + 'is_priority': None, } self.fork = ['default', params] @@ -205,8 +234,9 @@ class InitSickBeard: # Find excess parameters excess_parameters = set(params).difference(optional_parameters) excess_parameters.remove('cmd') # Don't remove cmd from api params - logger.debug(f'Removing excess parameters: ' - f'{sorted(excess_parameters)}') + logger.debug( + f'Removing excess parameters: ' f'{sorted(excess_parameters)}' + ) rem_params.extend(excess_parameters) return rem_params, True except: @@ -219,8 +249,9 @@ class InitSickBeard: params = core.ALL_FORKS rem_params = [] logger.info(f'Attempting to auto-detect {self.input_category} fork') - # define the order to test. Default must be first since the default fork doesn't reject parameters. - # then in order of most unique parameters. + # Define the order to test. + # Default must be first since default fork doesn't reject parameters. + # Then in order of most unique parameters. if self.apikey: url = core.utils.common.create_url( @@ -250,12 +281,20 @@ class InitSickBeard: port=self.port, path=f'{self.web_root}/login', ) - login_params = {'username': self.username, 'password': self.password} + login_params = { + 'username': self.username, + 'password': self.password, + } r = s.get(login, verify=False, timeout=(30, 60)) if r.status_code in [401, 403] and r.cookies.get('_xsrf'): login_params['_xsrf'] = r.cookies.get('_xsrf') s.post(login, data=login_params, stream=True, verify=False) - r = s.get(url, auth=(self.username, self.password), params=api_params, verify=False) + r = s.get( + url, + auth=(self.username, self.password), + params=api_params, + verify=False, + ) except requests.ConnectionError: logger.info( f'Could not connect to {self.section}:{self.input_category} ' @@ -272,7 +311,12 @@ class InitSickBeard: api_params = {'cmd': 'help', 'subject': 'postprocess'} try: if not self.apikey and self.username and self.password: - r = s.get(url, auth=(self.username, self.password), params=api_params, verify=False) + r = s.get( + url, + auth=(self.username, self.password), + params=api_params, + verify=False, + ) else: r = s.get(url, params=api_params, verify=False) except requests.ConnectionError: @@ -317,7 +361,9 @@ class InitSickBeard: f'{self.section}:{self.input_category} fork auto-detection ' f'failed' ) - self.fork = list(core.FORKS.items())[list(core.FORKS.keys()).index(core.FORK_DEFAULT)] + self.fork = list(core.FORKS.items())[ + list(core.FORKS.keys()).index(core.FORK_DEFAULT) + ] def _init_fork(self): # These need to be imported here, to prevent a circular import. @@ -326,7 +372,7 @@ class InitSickBeard: mapped_forks = { 'Medusa': PyMedusa, 'Medusa-api': PyMedusaApiV1, - 'Medusa-apiv2': PyMedusaApiV2 + 'Medusa-apiv2': PyMedusaApiV2, } logger.debug(f'Create object for fork {self.fork}') if self.fork and mapped_forks.get(self.fork): @@ -341,6 +387,7 @@ class InitSickBeard: class SickBeard: """Sickbeard base class.""" + sb_init: InitSickBeard def __init__(self, sb_init): @@ -354,7 +401,9 @@ class SickBeard: self.dir_name = None self.delete_failed = int(self.sb_init.config.get('delete_failed', 0)) - self.nzb_extraction_by = self.sb_init.config.get('nzbExtractionBy', 'Downloader') + self.nzb_extraction_by = self.sb_init.config.get( + 'nzbExtractionBy', 'Downloader' + ) self.process_method = self.sb_init.config.get('process_method') self.remote_path = int(self.sb_init.config.get('remote_path', 0)) self.wait_for = int(self.sb_init.config.get('wait_for', 2)) @@ -369,7 +418,13 @@ class SickBeard: # Keep track of result state self.success = False - def initialize(self, dir_name, input_name=None, failed=False, client_agent='manual'): + def initialize( + self, + dir_name, + input_name=None, + failed=False, + client_agent='manual', + ): """We need to call this explicitely because we need some variables. We can't pass these directly through the constructor. @@ -382,7 +437,10 @@ class SickBeard: self.extract = 0 else: self.extract = int(self.sb_init.config.get('extract', 0)) - if client_agent == core.TORRENT_CLIENT_AGENT and core.USE_LINK == 'move-sym': + if ( + client_agent == core.TORRENT_CLIENT_AGENT + and core.USE_LINK == 'move-sym' + ): self.process_method = 'symlink' @property @@ -392,10 +450,10 @@ class SickBeard: else: route = f'{self.sb_init.web_root}/home/postprocess/processEpisode' return core.utils.common.create_url( - self.sb_init.protocol, - self.sb_init.host, - self.sb_init.port, - route + scheme=self.sb_init.protocol, + host=self.sb_init.host, + port=self.sb_init.port, + path=route, ) def _process_fork_prarams(self): @@ -422,12 +480,19 @@ class SickBeard: del fork_params['quiet'] if param == 'type': - if 'type' in fork_params: # only set if we haven't already deleted for 'failed' above. + if 'type' in fork_params: + # Set if we haven't already deleted for 'failed' above. fork_params[param] = 'manual' if 'proc_type' in fork_params: del fork_params['proc_type'] - if param in ['dir_name', 'dir', 'proc_dir', 'process_directory', 'path']: + if param in [ + 'dir_name', + 'dir', + 'proc_dir', + 'process_directory', + 'path', + ]: fork_params[param] = self.dir_name if self.remote_path: fork_params[param] = remote_dir(self.dir_name) @@ -474,9 +539,16 @@ class SickBeard: def api_call(self) -> ProcessResult: """Perform a base sickbeard api call.""" self._process_fork_prarams() - logger.debug(f'Opening URL: {self.url} with params: {self.sb_init.fork_params}', self.sb_init.section) + logger.debug( + f'Opening URL: {self.url} with params: {self.sb_init.fork_params}', + self.sb_init.section, + ) try: - if not self.sb_init.apikey and self.sb_init.username and self.sb_init.password: + if ( + not self.sb_init.apikey + and self.sb_init.username + and self.sb_init.password + ): # If not using the api, we need to login using user/pass first. route = f'{self.sb_init.web_root}/login' login = core.utils.common.create_url( @@ -485,14 +557,32 @@ class SickBeard: self.sb_init.port, route, ) - login_params = {'username': self.sb_init.username, 'password': self.sb_init.password} + login_params = { + 'username': self.sb_init.username, + 'password': self.sb_init.password, + } r = self.session.get(login, verify=False, timeout=(30, 60)) if r.status_code in [401, 403] and r.cookies.get('_xsrf'): login_params['_xsrf'] = r.cookies.get('_xsrf') - self.session.post(login, data=login_params, stream=True, verify=False, timeout=(30, 60)) - response = self.session.get(self.url, auth=(self.sb_init.username, self.sb_init.password), params=self.sb_init.fork_params, stream=True, verify=False, timeout=(30, 1800)) + self.session.post( + login, + data=login_params, + stream=True, + verify=False, + timeout=(30, 60), + ) + response = self.session.get( + self.url, + auth=(self.sb_init.username, self.sb_init.password), + params=self.sb_init.fork_params, + stream=True, + verify=False, + timeout=(30, 1800), + ) except requests.ConnectionError: - logger.error(f'Unable to open URL: {self.url}', self.sb_init.section) + logger.error( + f'Unable to open URL: {self.url}', self.sb_init.section + ) result = ProcessResult.failure( f'{self.sb_init.section}: Failed to post-process - Unable to ' f'connect to {self.sb_init.section}' @@ -504,8 +594,10 @@ class SickBeard: requests.codes.accepted, ] if response.status_code not in successful_statuses: - logger.error(f'Server returned status {response.status_code}', - self.sb_init.section) + logger.error( + f'Server returned status {response.status_code}', + self.sb_init.section, + ) result = ProcessResult.failure( f'{self.sb_init.section}: Failed to post-process - Server ' f'returned status {response.status_code}' @@ -530,7 +622,10 @@ class SickBeard: # queued = True # For the refactoring i'm only considering vanilla sickbeard, # as for the base class. - if 'Processing succeeded' in line or 'Successfully processed' in line: + if ( + 'Processing succeeded' in line + or 'Successfully processed' in line + ): self.success = True if self.success: