Reformat with black.

basicswap/bin/run.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # Copyright (c) 2019-2024 tecnovert
+# Copyright (c) 2024 The Basicswap developers
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
@@ -32,7 +33,7 @@ swap_client = None
 
 
 class Daemon:
-    __slots__ = ('handle', 'files')
+    __slots__ = ("handle", "files")
 
     def __init__(self, handle, files):
         self.handle = handle
@@ -41,14 +42,14 @@ class Daemon:
 
 def is_known_coin(coin_name: str) -> bool:
     for k, v in chainparams.items():
-        if coin_name == v['name']:
+        if coin_name == v["name"]:
             return True
     return False
 
 
 def signal_handler(sig, frame):
     global swap_client
-    logger.info('Signal %d detected, ending program.' % (sig))
+    logger.info("Signal %d detected, ending program." % (sig))
     if swap_client is not None:
         swap_client.stopRunning()
 
@@ -59,9 +60,9 @@ def startDaemon(node_dir, bin_dir, daemon_bin, opts=[], extra_config={}):
 
     # Rewrite litecoin.conf for 0.21.3
     # TODO: Remove
-    ltc_conf_path = os.path.join(datadir_path, 'litecoin.conf')
+    ltc_conf_path = os.path.join(datadir_path, "litecoin.conf")
     if os.path.exists(ltc_conf_path):
-        config_to_add = ['blockfilterindex=0', 'peerblockfilters=0']
+        config_to_add = ["blockfilterindex=0", "peerblockfilters=0"]
         with open(ltc_conf_path) as fp:
             for line in fp:
                 line = line.strip()
@@ -69,23 +70,30 @@ def startDaemon(node_dir, bin_dir, daemon_bin, opts=[], extra_config={}):
                     config_to_add.remove(line)
 
         if len(config_to_add) > 0:
-            logger.info('Rewriting litecoin.conf')
-            shutil.copyfile(ltc_conf_path, ltc_conf_path + '.last')
-            with open(ltc_conf_path, 'a') as fp:
+            logger.info("Rewriting litecoin.conf")
+            shutil.copyfile(ltc_conf_path, ltc_conf_path + ".last")
+            with open(ltc_conf_path, "a") as fp:
                 for line in config_to_add:
-                    fp.write(line + '\n')
+                    fp.write(line + "\n")
 
-    args = [daemon_bin, ]
-    add_datadir: bool = extra_config.get('add_datadir', True)
+    args = [
+        daemon_bin,
+    ]
+    add_datadir: bool = extra_config.get("add_datadir", True)
     if add_datadir:
-        args.append('-datadir=' + datadir_path)
+        args.append("-datadir=" + datadir_path)
     args += opts
-    logger.info('Starting node {}'.format(daemon_bin))
-    logger.debug('Arguments {}'.format(' '.join(args)))
+    logger.info("Starting node {}".format(daemon_bin))
+    logger.debug("Arguments {}".format(" ".join(args)))
 
     opened_files = []
-    if extra_config.get('stdout_to_file', False):
-        stdout_dest = open(os.path.join(datadir_path, extra_config.get('stdout_filename', 'core_stdout.log')), 'w')
+    if extra_config.get("stdout_to_file", False):
+        stdout_dest = open(
+            os.path.join(
+                datadir_path, extra_config.get("stdout_filename", "core_stdout.log")
+            ),
+            "w",
+        )
         opened_files.append(stdout_dest)
         stderr_dest = stdout_dest
     else:
@@ -93,62 +101,113 @@ def startDaemon(node_dir, bin_dir, daemon_bin, opts=[], extra_config={}):
         stderr_dest = subprocess.PIPE
 
     shell: bool = False
-    if extra_config.get('use_shell', False):
-        args = ' '.join(args)
+    if extra_config.get("use_shell", False):
+        args = " ".join(args)
         shell = True
-    return Daemon(subprocess.Popen(args, shell=shell, stdin=subprocess.PIPE, stdout=stdout_dest, stderr=stderr_dest, cwd=datadir_path), opened_files)
+    return Daemon(
+        subprocess.Popen(
+            args,
+            shell=shell,
+            stdin=subprocess.PIPE,
+            stdout=stdout_dest,
+            stderr=stderr_dest,
+            cwd=datadir_path,
+        ),
+        opened_files,
+    )
 
 
 def startXmrDaemon(node_dir, bin_dir, daemon_bin, opts=[]):
     daemon_path = os.path.expanduser(os.path.join(bin_dir, daemon_bin))
 
     datadir_path = os.path.expanduser(node_dir)
-    config_filename = 'wownerod.conf' if daemon_bin.startswith('wow') else 'monerod.conf'
-    args = [daemon_path, '--non-interactive', '--config-file=' + os.path.join(datadir_path, config_filename)] + opts
-    logger.info('Starting node {}'.format(daemon_bin))
-    logger.debug('Arguments {}'.format(' '.join(args)))
+    config_filename = (
+        "wownerod.conf" if daemon_bin.startswith("wow") else "monerod.conf"
+    )
+    args = [
+        daemon_path,
+        "--non-interactive",
+        "--config-file=" + os.path.join(datadir_path, config_filename),
+    ] + opts
+    logger.info("Starting node {}".format(daemon_bin))
+    logger.debug("Arguments {}".format(" ".join(args)))
 
     # return subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    file_stdout = open(os.path.join(datadir_path, 'core_stdout.log'), 'w')
-    file_stderr = open(os.path.join(datadir_path, 'core_stderr.log'), 'w')
-    return Daemon(subprocess.Popen(args, stdin=subprocess.PIPE, stdout=file_stdout, stderr=file_stderr, cwd=datadir_path), [file_stdout, file_stderr])
+    file_stdout = open(os.path.join(datadir_path, "core_stdout.log"), "w")
+    file_stderr = open(os.path.join(datadir_path, "core_stderr.log"), "w")
+    return Daemon(
+        subprocess.Popen(
+            args,
+            stdin=subprocess.PIPE,
+            stdout=file_stdout,
+            stderr=file_stderr,
+            cwd=datadir_path,
+        ),
+        [file_stdout, file_stderr],
+    )
 
 
 def startXmrWalletDaemon(node_dir, bin_dir, wallet_bin, opts=[]):
     daemon_path = os.path.expanduser(os.path.join(bin_dir, wallet_bin))
-    args = [daemon_path, '--non-interactive']
+    args = [daemon_path, "--non-interactive"]
 
     needs_rewrite: bool = False
-    config_to_remove = ['daemon-address=', 'untrusted-daemon=', 'trusted-daemon=', 'proxy=']
+    config_to_remove = [
+        "daemon-address=",
+        "untrusted-daemon=",
+        "trusted-daemon=",
+        "proxy=",
+    ]
 
     data_dir = os.path.expanduser(node_dir)
 
-    wallet_config_filename = 'wownero-wallet-rpc.conf' if wallet_bin.startswith('wow') else 'monero_wallet.conf'
+    wallet_config_filename = (
+        "wownero-wallet-rpc.conf"
+        if wallet_bin.startswith("wow")
+        else "monero_wallet.conf"
+    )
     config_path = os.path.join(data_dir, wallet_config_filename)
     if os.path.exists(config_path):
-        args += ['--config-file=' + config_path]
+        args += ["--config-file=" + config_path]
         with open(config_path) as fp:
             for line in fp:
-                if any(line.startswith(config_line) for config_line in config_to_remove):
-                    logger.warning('Found old config in monero_wallet.conf: {}'.format(line.strip()))
+                if any(
+                    line.startswith(config_line) for config_line in config_to_remove
+                ):
+                    logger.warning(
+                        "Found old config in monero_wallet.conf: {}".format(
+                            line.strip()
+                        )
+                    )
                     needs_rewrite = True
     args += opts
 
     if needs_rewrite:
-        logger.info('Rewriting wallet config')
-        shutil.copyfile(config_path, config_path + '.last')
-        with open(config_path + '.last') as fp_from, open(config_path, 'w') as fp_to:
+        logger.info("Rewriting wallet config")
+        shutil.copyfile(config_path, config_path + ".last")
+        with open(config_path + ".last") as fp_from, open(config_path, "w") as fp_to:
             for line in fp_from:
-                if not any(line.startswith(config_line) for config_line in config_to_remove):
+                if not any(
+                    line.startswith(config_line) for config_line in config_to_remove
+                ):
                     fp_to.write(line)
 
-    logger.info('Starting wallet daemon {}'.format(wallet_bin))
-    logger.debug('Arguments {}'.format(' '.join(args)))
+    logger.info("Starting wallet daemon {}".format(wallet_bin))
+    logger.debug("Arguments {}".format(" ".join(args)))
 
     # TODO: return subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=data_dir)
-    wallet_stdout = open(os.path.join(data_dir, 'wallet_stdout.log'), 'w')
-    wallet_stderr = open(os.path.join(data_dir, 'wallet_stderr.log'), 'w')
-    return Daemon(subprocess.Popen(args, stdin=subprocess.PIPE, stdout=wallet_stdout, stderr=wallet_stderr, cwd=data_dir), [wallet_stdout, wallet_stderr])
+    wallet_stdout = open(os.path.join(data_dir, "wallet_stdout.log"), "w")
+    wallet_stderr = open(os.path.join(data_dir, "wallet_stderr.log"), "w")
+    return Daemon(
+        subprocess.Popen(
+            args,
+            stdin=subprocess.PIPE,
+            stdout=wallet_stdout,
+            stderr=wallet_stderr,
+            cwd=data_dir,
+        ),
+        [wallet_stdout, wallet_stderr],
+    )
 
 
 def ws_new_client(client, server):
@@ -165,25 +224,29 @@ def ws_client_left(client, server):
 
 def ws_message_received(client, server, message):
     if len(message) > 200:
-        message = message[:200] + '..'
+        message = message[:200] + ".."
     if swap_client:
         swap_client.log.debug(f'ws_message_received {client["id"]} {message}')
 
 
 def getCoreBinName(coin_id: int, coin_settings, default_name: str) -> str:
-    return coin_settings.get('core_binname', chainparams[coin_id].get('core_binname', default_name)) + ('.exe' if os.name == 'nt' else '')
+    return coin_settings.get(
+        "core_binname", chainparams[coin_id].get("core_binname", default_name)
+    ) + (".exe" if os.name == "nt" else "")
 
 
 def getWalletBinName(coin_id: int, coin_settings, default_name: str) -> str:
-    return coin_settings.get('wallet_binname', chainparams[coin_id].get('wallet_binname', default_name)) + ('.exe' if os.name == 'nt' else '')
+    return coin_settings.get(
+        "wallet_binname", chainparams[coin_id].get("wallet_binname", default_name)
+    ) + (".exe" if os.name == "nt" else "")
 
 
 def getCoreBinArgs(coin_id: int, coin_settings):
     extra_args = []
-    if 'config_filename' in coin_settings:
-        extra_args.append('--conf=' + coin_settings['config_filename'])
-    if 'port' in coin_settings:
-        extra_args.append('--port=' + str(int(coin_settings['port'])))
+    if "config_filename" in coin_settings:
+        extra_args.append("--conf=" + coin_settings["config_filename"])
+    if "port" in coin_settings:
+        extra_args.append("--port=" + str(int(coin_settings["port"])))
     return extra_args
 
 
@@ -193,17 +256,21 @@ def runClient(fp, data_dir, chain, start_only_coins):
     pids = []
     threads = []
     settings_path = os.path.join(data_dir, cfg.CONFIG_FILENAME)
-    pids_path = os.path.join(data_dir, '.pids')
+    pids_path = os.path.join(data_dir, ".pids")
 
-    if os.getenv('WALLET_ENCRYPTION_PWD', '') != '':
-        if 'decred' in start_only_coins:
+    if os.getenv("WALLET_ENCRYPTION_PWD", "") != "":
+        if "decred" in start_only_coins:
             # Workaround for dcrwallet requiring password for initial startup
-            logger.warning('Allowing set WALLET_ENCRYPTION_PWD var with --startonlycoin=decred.')
+            logger.warning(
+                "Allowing set WALLET_ENCRYPTION_PWD var with --startonlycoin=decred."
+            )
         else:
-            raise ValueError('Please unset the WALLET_ENCRYPTION_PWD environment variable.')
+            raise ValueError(
+                "Please unset the WALLET_ENCRYPTION_PWD environment variable."
+            )
 
     if not os.path.exists(settings_path):
-        raise ValueError('Settings file not found: ' + str(settings_path))
+        raise ValueError("Settings file not found: " + str(settings_path))
 
     with open(settings_path) as fs:
         settings = json.load(fs)
@@ -215,7 +282,7 @@ def runClient(fp, data_dir, chain, start_only_coins):
         with open(pids_path) as fd:
             for ln in fd:
                 # TODO: try close
-                logger.warning('Found pid for daemon {} '.format(ln.strip()))
+                logger.warning("Found pid for daemon {} ".format(ln.strip()))
 
     # Ensure daemons are stopped
     swap_client.stopDaemons()
@@ -224,155 +291,227 @@ def runClient(fp, data_dir, chain, start_only_coins):
     settings = swap_client.settings
     try:
         # Try start daemons
-        for c, v in settings['chainclients'].items():
+        for c, v in settings["chainclients"].items():
             if len(start_only_coins) > 0 and c not in start_only_coins:
                 continue
             try:
                 coin_id = swap_client.getCoinIdFromName(c)
                 display_name = getCoinName(coin_id)
-            except Exception as e:
-                logger.warning('Not starting unknown coin: {}'.format(c))
+            except Exception as e:  # noqa: F841
+                logger.warning("Not starting unknown coin: {}".format(c))
                 continue
-            if c in ('monero', 'wownero'):
-                if v['manage_daemon'] is True:
-                    swap_client.log.info(f'Starting {display_name} daemon')
-                    filename: str = getCoreBinName(coin_id, v, c + 'd')
+            if c in ("monero", "wownero"):
+                if v["manage_daemon"] is True:
+                    swap_client.log.info(f"Starting {display_name} daemon")
+                    filename: str = getCoreBinName(coin_id, v, c + "d")
 
-                    daemons.append(startXmrDaemon(v['datadir'], v['bindir'], filename))
+                    daemons.append(startXmrDaemon(v["datadir"], v["bindir"], filename))
                     pid = daemons[-1].handle.pid
-                    swap_client.log.info('Started {} {}'.format(filename, pid))
+                    swap_client.log.info("Started {} {}".format(filename, pid))
 
-                if v['manage_wallet_daemon'] is True:
-                    swap_client.log.info(f'Starting {display_name} wallet daemon')
-                    daemon_addr = '{}:{}'.format(v['rpchost'], v['rpcport'])
-                    trusted_daemon: bool = swap_client.getXMRTrustedDaemon(coin_id, v['rpchost'])
-                    opts = ['--daemon-address', daemon_addr, ]
+                if v["manage_wallet_daemon"] is True:
+                    swap_client.log.info(f"Starting {display_name} wallet daemon")
+                    daemon_addr = "{}:{}".format(v["rpchost"], v["rpcport"])
+                    trusted_daemon: bool = swap_client.getXMRTrustedDaemon(
+                        coin_id, v["rpchost"]
+                    )
+                    opts = [
+                        "--daemon-address",
+                        daemon_addr,
+                    ]
 
-                    proxy_log_str = ''
-                    proxy_host, proxy_port = swap_client.getXMRWalletProxy(coin_id, v['rpchost'])
+                    proxy_log_str = ""
+                    proxy_host, proxy_port = swap_client.getXMRWalletProxy(
+                        coin_id, v["rpchost"]
+                    )
                     if proxy_host:
-                        proxy_log_str = ' through proxy'
-                        opts += ['--proxy', f'{proxy_host}:{proxy_port}', '--daemon-ssl-allow-any-cert', ]
+                        proxy_log_str = " through proxy"
+                        opts += [
+                            "--proxy",
+                            f"{proxy_host}:{proxy_port}",
+                            "--daemon-ssl-allow-any-cert",
+                        ]
 
-                    swap_client.log.info('daemon-address: {} ({}){}'.format(daemon_addr, 'trusted' if trusted_daemon else 'untrusted', proxy_log_str))
+                    swap_client.log.info(
+                        "daemon-address: {} ({}){}".format(
+                            daemon_addr,
+                            "trusted" if trusted_daemon else "untrusted",
+                            proxy_log_str,
+                        )
+                    )
 
-                    daemon_rpcuser = v.get('rpcuser', '')
-                    daemon_rpcpass = v.get('rpcpassword', '')
-                    if daemon_rpcuser != '':
-                        opts.append('--daemon-login')
-                        opts.append(daemon_rpcuser + ':' + daemon_rpcpass)
+                    daemon_rpcuser = v.get("rpcuser", "")
+                    daemon_rpcpass = v.get("rpcpassword", "")
+                    if daemon_rpcuser != "":
+                        opts.append("--daemon-login")
+                        opts.append(daemon_rpcuser + ":" + daemon_rpcpass)
 
-                    opts.append('--trusted-daemon' if trusted_daemon else '--untrusted-daemon')
-                    filename: str = getWalletBinName(coin_id, v, c + '-wallet-rpc')
+                    opts.append(
+                        "--trusted-daemon" if trusted_daemon else "--untrusted-daemon"
+                    )
+                    filename: str = getWalletBinName(coin_id, v, c + "-wallet-rpc")
 
-                    daemons.append(startXmrWalletDaemon(v['datadir'], v['bindir'], filename, opts))
+                    daemons.append(
+                        startXmrWalletDaemon(v["datadir"], v["bindir"], filename, opts)
+                    )
                     pid = daemons[-1].handle.pid
-                    swap_client.log.info('Started {} {}'.format(filename, pid))
+                    swap_client.log.info("Started {} {}".format(filename, pid))
 
                 continue  # /monero
 
-            if c == 'decred':
-                appdata = v['datadir']
-                extra_opts = [f'--appdata="{appdata}"', ]
-                use_shell: bool = True if os.name == 'nt' else False
-                if v['manage_daemon'] is True:
-                    swap_client.log.info(f'Starting {display_name} daemon')
-                    filename: str = getCoreBinName(coin_id, v, 'dcrd')
+            if c == "decred":
+                appdata = v["datadir"]
+                extra_opts = [
+                    f'--appdata="{appdata}"',
+                ]
+                use_shell: bool = True if os.name == "nt" else False
+                if v["manage_daemon"] is True:
+                    swap_client.log.info(f"Starting {display_name} daemon")
+                    filename: str = getCoreBinName(coin_id, v, "dcrd")
 
-                    extra_config = {'add_datadir': False, 'stdout_to_file': True, 'stdout_filename': 'dcrd_stdout.log', 'use_shell': use_shell}
-                    daemons.append(startDaemon(appdata, v['bindir'], filename, opts=extra_opts, extra_config=extra_config))
+                    extra_config = {
+                        "add_datadir": False,
+                        "stdout_to_file": True,
+                        "stdout_filename": "dcrd_stdout.log",
+                        "use_shell": use_shell,
+                    }
+                    daemons.append(
+                        startDaemon(
+                            appdata,
+                            v["bindir"],
+                            filename,
+                            opts=extra_opts,
+                            extra_config=extra_config,
+                        )
+                    )
                     pid = daemons[-1].handle.pid
-                    swap_client.log.info('Started {} {}'.format(filename, pid))
+                    swap_client.log.info("Started {} {}".format(filename, pid))
 
-                if v['manage_wallet_daemon'] is True:
-                    swap_client.log.info(f'Starting {display_name} wallet daemon')
-                    filename: str = getWalletBinName(coin_id, v, 'dcrwallet')
+                if v["manage_wallet_daemon"] is True:
+                    swap_client.log.info(f"Starting {display_name} wallet daemon")
+                    filename: str = getWalletBinName(coin_id, v, "dcrwallet")
 
-                    wallet_pwd = v['wallet_pwd']
-                    if wallet_pwd == '':
+                    wallet_pwd = v["wallet_pwd"]
+                    if wallet_pwd == "":
                         # Only set when in startonlycoin mode
-                        wallet_pwd = os.getenv('WALLET_ENCRYPTION_PWD', '')
-                    if wallet_pwd != '':
+                        wallet_pwd = os.getenv("WALLET_ENCRYPTION_PWD", "")
+                    if wallet_pwd != "":
                         extra_opts.append(f'--pass="{wallet_pwd}"')
-                    extra_config = {'add_datadir': False, 'stdout_to_file': True, 'stdout_filename': 'dcrwallet_stdout.log', 'use_shell': use_shell}
-                    daemons.append(startDaemon(appdata, v['bindir'], filename, opts=extra_opts, extra_config=extra_config))
+                    extra_config = {
+                        "add_datadir": False,
+                        "stdout_to_file": True,
+                        "stdout_filename": "dcrwallet_stdout.log",
+                        "use_shell": use_shell,
+                    }
+                    daemons.append(
+                        startDaemon(
+                            appdata,
+                            v["bindir"],
+                            filename,
+                            opts=extra_opts,
+                            extra_config=extra_config,
+                        )
+                    )
                     pid = daemons[-1].handle.pid
-                    swap_client.log.info('Started {} {}'.format(filename, pid))
+                    swap_client.log.info("Started {} {}".format(filename, pid))
 
                 continue  # /decred
 
-            if v['manage_daemon'] is True:
-                swap_client.log.info(f'Starting {display_name} daemon')
+            if v["manage_daemon"] is True:
+                swap_client.log.info(f"Starting {display_name} daemon")
 
-                filename: str = getCoreBinName(coin_id, v, c + 'd')
+                filename: str = getCoreBinName(coin_id, v, c + "d")
                 extra_opts = getCoreBinArgs(coin_id, v)
-                daemons.append(startDaemon(v['datadir'], v['bindir'], filename, opts=extra_opts))
+                daemons.append(
+                    startDaemon(v["datadir"], v["bindir"], filename, opts=extra_opts)
+                )
                 pid = daemons[-1].handle.pid
                 pids.append((c, pid))
                 swap_client.setDaemonPID(c, pid)
-                swap_client.log.info('Started {} {}'.format(filename, pid))
+                swap_client.log.info("Started {} {}".format(filename, pid))
         if len(pids) > 0:
-            with open(pids_path, 'w') as fd:
+            with open(pids_path, "w") as fd:
                 for p in pids:
-                    fd.write('{}:{}\n'.format(*p))
+                    fd.write("{}:{}\n".format(*p))
 
         signal.signal(signal.SIGINT, signal_handler)
         signal.signal(signal.SIGTERM, signal_handler)
 
         if len(start_only_coins) > 0:
-            logger.info(f'Only running {start_only_coins}. Manually exit with Ctrl + c when ready.')
+            logger.info(
+                f"Only running {start_only_coins}. Manually exit with Ctrl + c when ready."
+            )
             while not swap_client.delay_event.wait(0.5):
                 pass
         else:
             swap_client.start()
-            if 'htmlhost' in settings:
-                swap_client.log.info('Starting http server at http://%s:%d.' % (settings['htmlhost'], settings['htmlport']))
-                allow_cors = settings['allowcors'] if 'allowcors' in settings else cfg.DEFAULT_ALLOW_CORS
-                thread_http = HttpThread(fp, settings['htmlhost'], settings['htmlport'], allow_cors, swap_client)
+            if "htmlhost" in settings:
+                swap_client.log.info(
+                    "Starting http server at http://%s:%d."
+                    % (settings["htmlhost"], settings["htmlport"])
+                )
+                allow_cors = (
+                    settings["allowcors"]
+                    if "allowcors" in settings
+                    else cfg.DEFAULT_ALLOW_CORS
+                )
+                thread_http = HttpThread(
+                    fp,
+                    settings["htmlhost"],
+                    settings["htmlport"],
+                    allow_cors,
+                    swap_client,
+                )
                 threads.append(thread_http)
                 thread_http.start()
 
-            if 'wshost' in settings:
-                ws_url = 'ws://{}:{}'.format(settings['wshost'], settings['wsport'])
-                swap_client.log.info(f'Starting ws server at {ws_url}.')
+            if "wshost" in settings:
+                ws_url = "ws://{}:{}".format(settings["wshost"], settings["wsport"])
+                swap_client.log.info(f"Starting ws server at {ws_url}.")
 
-                swap_client.ws_server = WebsocketServer(host=settings['wshost'], port=settings['wsport'])
-                swap_client.ws_server.client_port = settings.get('wsclientport', settings['wsport'])
+                swap_client.ws_server = WebsocketServer(
+                    host=settings["wshost"], port=settings["wsport"]
+                )
+                swap_client.ws_server.client_port = settings.get(
+                    "wsclientport", settings["wsport"]
+                )
                 swap_client.ws_server.set_fn_new_client(ws_new_client)
                 swap_client.ws_server.set_fn_client_left(ws_client_left)
                 swap_client.ws_server.set_fn_message_received(ws_message_received)
                 swap_client.ws_server.run_forever(threaded=True)
 
-            logger.info('Exit with Ctrl + c.')
+            logger.info("Exit with Ctrl + c.")
             while not swap_client.delay_event.wait(0.5):
                 swap_client.update()
 
-    except Exception as ex:
+    except Exception as e:  # noqa: F841
         traceback.print_exc()
 
     if swap_client.ws_server:
         try:
-            swap_client.log.info('Stopping websocket server.')
+            swap_client.log.info("Stopping websocket server.")
             swap_client.ws_server.shutdown_gracefully()
-        except Exception as ex:
+        except Exception as e:  # noqa: F841
             traceback.print_exc()
 
     swap_client.finalise()
-    swap_client.log.info('Stopping HTTP threads.')
+    swap_client.log.info("Stopping HTTP threads.")
     for t in threads:
         try:
             t.stop()
             t.join()
-        except Exception as ex:
+        except Exception as e:  # noqa: F841
             traceback.print_exc()
 
     closed_pids = []
     for d in daemons:
-        swap_client.log.info('Interrupting {}'.format(d.handle.pid))
+        swap_client.log.info("Interrupting {}".format(d.handle.pid))
         try:
-            d.handle.send_signal(signal.CTRL_C_EVENT if os.name == 'nt' else signal.SIGINT)
+            d.handle.send_signal(
+                signal.CTRL_C_EVENT if os.name == "nt" else signal.SIGINT
+            )
         except Exception as e:
-            swap_client.log.info('Interrupting %d, error %s', d.handle.pid, str(e))
+            swap_client.log.info("Interrupting %d, error %s", d.handle.pid, str(e))
     for d in daemons:
         try:
             d.handle.wait(timeout=120)
@@ -381,96 +520,106 @@ def runClient(fp, data_dir, chain, start_only_coins):
                     fp.close()
             closed_pids.append(d.handle.pid)
         except Exception as ex:
-            swap_client.log.error('Error: {}'.format(ex))
+            swap_client.log.error("Error: {}".format(ex))
 
     if os.path.exists(pids_path):
         with open(pids_path) as fd:
-            lines = fd.read().split('\n')
-        still_running = ''
+            lines = fd.read().split("\n")
+        still_running = ""
         for ln in lines:
             try:
-                if not int(ln.split(':')[1]) in closed_pids:
-                    still_running += ln + '\n'
+                if int(ln.split(":")[1]) not in closed_pids:
+                    still_running += ln + "\n"
             except Exception:
                 pass
-        with open(pids_path, 'w') as fd:
+        with open(pids_path, "w") as fd:
             fd.write(still_running)
 
 
 def printVersion():
-    logger.info('Basicswap version: %s', __version__)
+    logger.info("Basicswap version: %s", __version__)
 
 
 def printHelp():
-    print('Usage: basicswap-run ')
-    print('\n--help, -h               Print help.')
-    print('--version, -v            Print version.')
-    print('--datadir=PATH           Path to basicswap data directory, default:{}.'.format(cfg.BASICSWAP_DATADIR))
-    print('--mainnet                Run in mainnet mode.')
-    print('--testnet                Run in testnet mode.')
-    print('--regtest                Run in regtest mode.')
-    print('--startonlycoin          Only start the provides coin daemon/s, use this if a chain requires extra processing.')
+    print("Usage: basicswap-run ")
+    print("\n--help, -h               Print help.")
+    print("--version, -v            Print version.")
+    print(
+        "--datadir=PATH           Path to basicswap data directory, default:{}.".format(
+            cfg.BASICSWAP_DATADIR
+        )
+    )
+    print("--mainnet                Run in mainnet mode.")
+    print("--testnet                Run in testnet mode.")
+    print("--regtest                Run in regtest mode.")
+    print(
+        "--startonlycoin          Only start the provides coin daemon/s, use this if a chain requires extra processing."
+    )
 
 
 def main():
     data_dir = None
-    chain = 'mainnet'
+    chain = "mainnet"
     start_only_coins = set()
 
     for v in sys.argv[1:]:
-        if len(v) < 2 or v[0] != '-':
-            logger.warning('Unknown argument %s', v)
+        if len(v) < 2 or v[0] != "-":
+            logger.warning("Unknown argument %s", v)
             continue
 
-        s = v.split('=')
+        s = v.split("=")
         name = s[0].strip()
 
         for i in range(2):
-            if name[0] == '-':
+            if name[0] == "-":
                 name = name[1:]
 
-        if name == 'v' or name == 'version':
+        if name == "v" or name == "version":
             printVersion()
             return 0
-        if name == 'h' or name == 'help':
+        if name == "h" or name == "help":
             printHelp()
             return 0
 
-        if name in ('mainnet', 'testnet', 'regtest'):
+        if name in ("mainnet", "testnet", "regtest"):
             chain = name
             continue
 
         if len(s) == 2:
-            if name == 'datadir':
+            if name == "datadir":
                 data_dir = os.path.expanduser(s[1])
                 continue
-        if name == 'startonlycoin':
-            for coin in [s.lower() for s in s[1].split(',')]:
+        if name == "startonlycoin":
+            for coin in [s.lower() for s in s[1].split(",")]:
                 if is_known_coin(coin) is False:
-                    raise ValueError(f'Unknown coin: {coin}')
+                    raise ValueError(f"Unknown coin: {coin}")
                 start_only_coins.add(coin)
             continue
 
-        logger.warning('Unknown argument %s', v)
+        logger.warning("Unknown argument %s", v)
 
-    if os.name == 'nt':
-        logger.warning('Running on windows is discouraged and windows support may be discontinued in the future.  Please consider using the WSL docker setup instead.')
+    if os.name == "nt":
+        logger.warning(
+            "Running on windows is discouraged and windows support may be discontinued in the future.  Please consider using the WSL docker setup instead."
+        )
 
     if data_dir is None:
         data_dir = os.path.join(os.path.expanduser(cfg.BASICSWAP_DATADIR))
-    logger.info('Using datadir: %s', data_dir)
-    logger.info('Chain: %s', chain)
+    logger.info("Using datadir: %s", data_dir)
+    logger.info("Chain: %s", chain)
 
     if not os.path.exists(data_dir):
         os.makedirs(data_dir)
 
-    with open(os.path.join(data_dir, 'basicswap.log'), 'a') as fp:
-        logger.info(os.path.basename(sys.argv[0]) + ', version: ' + __version__ + '\n\n')
+    with open(os.path.join(data_dir, "basicswap.log"), "a") as fp:
+        logger.info(
+            os.path.basename(sys.argv[0]) + ", version: " + __version__ + "\n\n"
+        )
         runClient(fp, data_dir, chain, start_only_coins)
 
-    logger.info('Done.')
+    logger.info("Done.")
     return swap_client.fail_code if swap_client is not None else 0
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()