vortex-nwp 2.0.0b1__py3-none-any.whl → 2.0.0b2__py3-none-any.whl

vortex/tools/net.py

@@ -44,28 +44,28 @@ def uriparse(uristring):
     * username
     * password
     """
-    (realscheme, other) = uristring.split(':', 1)
-    rp = urlparse.urlparse('http:' + other)
+    (realscheme, other) = uristring.split(":", 1)
+    rp = urlparse.urlparse("http:" + other)
     uridict = rp._asdict()
-    netloc = uridict['netloc'].split('@', 1)
-    hostport = netloc.pop().split(':')
-    uridict['netloc'] = hostport.pop(0)
+    netloc = uridict["netloc"].split("@", 1)
+    hostport = netloc.pop().split(":")
+    uridict["netloc"] = hostport.pop(0)
     if hostport:
-        uridict['port'] = hostport.pop()
+        uridict["port"] = hostport.pop()
     else:
-        uridict['port'] = None
+        uridict["port"] = None
     if netloc:
-        userpass = netloc.pop().split(':')
-        uridict['username'] = userpass.pop(0)
+        userpass = netloc.pop().split(":")
+        uridict["username"] = userpass.pop(0)
         if userpass:
-            uridict['password'] = userpass.pop()
+            uridict["password"] = userpass.pop()
         else:
-            uridict['password'] = None
+            uridict["password"] = None
     else:
-        uridict['username'] = None
-        uridict['password'] = None
-    uridict['scheme'] = realscheme
-    uridict['query'] = urlparse.parse_qs(uridict['query'])
+        uridict["username"] = None
+        uridict["password"] = None
+    uridict["scheme"] = realscheme
+    uridict["query"] = urlparse.parse_qs(uridict["query"])
     return uridict
 
 
@@ -74,20 +74,24 @@ def uriunparse(uridesc):
     return urlparse.urlunparse(uridesc)
 
 
-def http_post_data(url, data, ok_statuses=(), proxies=None, headers=None, verify=None):
+def http_post_data(
+    url, data, ok_statuses=(), proxies=None, headers=None, verify=None
+):
     """Make a http/https POST request, encoding **data**."""
     if isinstance(proxies, (list, tuple)):
-        proxies = {scheme: proxies for scheme in ('http', 'https')}
+        proxies = {scheme: proxies for scheme in ("http", "https")}
     # Try to use the requests package
     try:
         import requests
+
         use_requests = True
     except ImportError:
         use_requests = False
     # The modern way
     if use_requests:
-        resp = requests.post(url=url, data=data, headers=headers,
-                             proxies=proxies, verify=verify)
+        resp = requests.post(
+            url=url, data=data, headers=headers, proxies=proxies, verify=verify
+        )
         if ok_statuses:
             is_ok = resp.status_code in ok_statuses
         else:
@@ -95,16 +99,20 @@ def http_post_data(url, data, ok_statuses=(), proxies=None, headers=None, verify
         return is_ok, resp.status_code, resp.headers, resp.text
     else:
         if not isinstance(data, bytes):
-            data = urlparse.urlencode(data).encode('utf-8')
-        if uriparse(url)['scheme'] == 'https':
-            raise RuntimeError('HTTPS is not properly supported by urllib.request ({}).'
-                               .format(url))
+            data = urlparse.urlencode(data).encode("utf-8")
+        if uriparse(url)["scheme"] == "https":
+            raise RuntimeError(
+                "HTTPS is not properly supported by urllib.request ({}).".format(
+                    url
+                )
+            )
         handlers = []
         if isinstance(proxies, dict):
             handlers.append(urlrequest.ProxyHandler(proxies))
-        opener = urlrequest.build_opener(* handlers)
-        req = urlrequest.Request(url=url, data=data,
-                                 headers={} if headers is None else headers)
+        opener = urlrequest.build_opener(*handlers)
+        req = urlrequest.Request(
+            url=url, data=data, headers={} if headers is None else headers
+        )
         try:
             req_f = opener.open(req)
         except Exception as e:
@@ -116,7 +124,7 @@ def http_post_data(url, data, ok_statuses=(), proxies=None, headers=None, verify
             try:
                 req_rc = req_f.getcode()
                 req_info = req_f.info()
-                req_data = req_f.read().decode('utf-8')
+                req_data = req_f.read().decode("utf-8")
                 if ok_statuses:
                     return req_rc in ok_statuses, req_rc, req_info, req_data
                 else:
@@ -146,21 +154,21 @@ def netrc_lookup(logname, hostname, nrcfile=None):
         auth = nrc.authenticators(hostname, login=logname)
         if not auth:
             # self.host may be a FQDN, try to guess only the hostname
-            auth = nrc.authenticators(hostname.split('.')[0], login=logname)
+            auth = nrc.authenticators(hostname.split(".")[0], login=logname)
         # for backward compatibility: This might be removed one day
         if not auth:
             auth = nrc.authenticators(hostname)
         if not auth:
             # self.host may be a FQDN, try to guess only the hostname
-            auth = nrc.authenticators(hostname.split('.')[0])
+            auth = nrc.authenticators(hostname.split(".")[0])
         # End of backward compatibility section
         if auth:
             actual_logname = auth[0]
             actual_pwd = auth[2]
         else:
-            logger.warning('netrc lookup failed (%s)', str(auth))
+            logger.warning("netrc lookup failed (%s)", str(auth))
     else:
-        logger.warning('unable to fetch .netrc file')
+        logger.warning("unable to fetch .netrc file")
     return actual_logname, actual_pwd
 
 
@@ -170,7 +178,7 @@ class ExtendedFtplib:
     It wraps the standard ftplib object to add or overwrite methods.
     """
 
-    def __init__(self, system, ftpobj, hostname='', port=DEFAULT_FTP_PORT):
+    def __init__(self, system, ftpobj, hostname="", port=DEFAULT_FTP_PORT):
         """
         :param ~vortex.tools.systems.OSExtended system: The system object to work with
         :param ftplib.FTP ftpobj: The FTP object to work with / to extend
@@ -178,7 +186,7 @@ class ExtendedFtplib:
         self._system = system
         self._ftplib = ftpobj
         self._closed = True
-        self._logname = 'not_logged_in'
+        self._logname = "not_logged_in"
         self._created = datetime.now()
         self._opened = None
         self._deleted = None
@@ -200,8 +208,8 @@ class ExtendedFtplib:
         Nicely formatted print, built as the concatenation
         of the class full name and `logname` and `length` attributes.
         """
-        return '{:s} | host={:s} logname={:s} since={!s}>'.format(
-            repr(self).rstrip('>'),
+        return "{:s} | host={:s} logname={:s} since={!s}>".format(
+            repr(self).rstrip(">"),
             self.host,
             self.logname,
             self.length,
@@ -212,10 +220,11 @@ class ExtendedFtplib:
         """Gateway to undefined method or attributes if present in ``_ftplib``."""
         actualattr = getattr(self._ftplib, key)
         if callable(actualattr):
+
             def osproxy(*args, **kw):
                 cmd = [key]
                 cmd.extend(args)
-                cmd.extend(['{:s}={!s}'.format(x, kw[x]) for x in kw.keys()])
+                cmd.extend(["{:s}={!s}".format(x, kw[x]) for x in kw.keys()])
                 self.stderr(*cmd)
                 return actualattr(*args, **kw)
 
@@ -234,7 +243,7 @@ class ExtendedFtplib:
 
     def stderr(self, cmd, *args):
         """Proxy to local system's standard error."""
-        self.system.stderr('ftp:' + cmd, *args)
+        self.system.stderr("ftp:" + cmd, *args)
 
     @property
     def closed(self):
@@ -254,12 +263,14 @@ class ExtendedFtplib:
             topnow = datetime.now() if self._deleted is None else self._deleted
             timelength = (topnow - self._opened).total_seconds()
         except TypeError:
-            logger.warning('Could not evaluate connexion length %s', repr(self))
+            logger.warning(
+                "Could not evaluate connexion length %s", repr(self)
+            )
         return timelength
 
     def close(self):
         """Proxy to ftplib :meth:`ftplib.FTP.close`."""
-        self.stderr('close')
+        self.stderr("close")
         rc = True
         if not self.closed:
             rc = self._ftplib.close() or True
@@ -269,7 +280,7 @@ class ExtendedFtplib:
 
     def login(self, *args):
         """Proxy to ftplib :meth:`ftplib.FTP.login`."""
-        self.stderr('login', args[0])
+        self.stderr("login", args[0])
         self._logname = args[0]
         # kept for debugging, but this exposes the user's password!
         # logger.debug('FTP login <args:%s>', str(args))
@@ -279,48 +290,48 @@ class ExtendedFtplib:
             self._deleted = None
             self._opened = datetime.now()
         else:
-            logger.warning('FTP could not login <args:%s>', str(args))
+            logger.warning("FTP could not login <args:%s>", str(args))
         return rc
 
     def list(self, *args):
         """Returns standard directory listing from ftp protocol."""
-        self.stderr('list', *args)
+        self.stderr("list", *args)
         contents = []
-        self.retrlines('LIST', callback=contents.append)
+        self.retrlines("LIST", callback=contents.append)
         return contents
 
     def dir(self, *args):
         """Proxy to ftplib :meth:`ftplib.FTP.dir`."""
-        self.stderr('dir', *args)
+        self.stderr("dir", *args)
         return self._ftplib.dir(*args)
 
     def ls(self, *args):
         """Returns directory listing."""
-        self.stderr('ls', *args)
+        self.stderr("ls", *args)
         return self.dir(*args)
 
     ll = ls
 
     def get(self, source, destination):
         """Retrieve a remote `destination` file to a local `source` file object."""
-        self.stderr('get', source, destination)
+        self.stderr("get", source, destination)
         if isinstance(destination, str):
             self.system.filecocoon(destination)
-            target = open(destination, 'wb')
+            target = open(destination, "wb")
             xdestination = True
         else:
             target = destination
             xdestination = False
-        logger.info('FTP <get:{:s}>'.format(source))
+        logger.info("FTP <get:{:s}>".format(source))
         rc = False
         try:
-            self.retrbinary('RETR ' + source, target.write)
+            self.retrbinary("RETR " + source, target.write)
             if xdestination:
                 target.seek(0, io.SEEK_END)
                 if self.size(source) == target.tell():
                     rc = True
                 else:
-                    logger.error('FTP incomplete get %s', repr(source))
+                    logger.error("FTP incomplete get %s", repr(source))
             else:
                 rc = True
         finally:
@@ -341,9 +352,9 @@ class ExtendedFtplib:
         When `exact` is True, the size is checked against the size of the
         destination, and a mismatch is considered a failure.
         """
-        self.stderr('put', source, destination)
+        self.stderr("put", source, destination)
         if isinstance(source, str):
-            inputsrc = open(source, 'rb')
+            inputsrc = open(source, "rb")
             xsource = True
         else:
             inputsrc = source
@@ -354,43 +365,60 @@ class ExtendedFtplib:
             exact = True
             inputsrc.seek(0)
         except AttributeError:
-            logger.warning('Could not rewind <source:%s>', str(source))
+            logger.warning("Could not rewind <source:%s>", str(source))
         except OSError:
-            logger.debug('Seek trouble <source:%s>', str(source))
+            logger.debug("Seek trouble <source:%s>", str(source))
 
         self.rmkdir(destination)
         try:
             self.delete(destination)
-            logger.info('Replacing <file:%s>', str(destination))
+            logger.info("Replacing <file:%s>", str(destination))
         except ftplib.error_perm:
-            logger.info('Creating <file:%s>', str(destination))
-        except (ValueError, TypeError, OSError,
-                ftplib.error_proto, ftplib.error_reply, ftplib.error_temp) as e:
-            logger.error('Serious delete trouble <file:%s> <error:%s>',
-                         str(destination), str(e))
-
-        logger.info('FTP <put:%s>', str(destination))
+            logger.info("Creating <file:%s>", str(destination))
+        except (
+            ValueError,
+            TypeError,
+            OSError,
+            ftplib.error_proto,
+            ftplib.error_reply,
+            ftplib.error_temp,
+        ) as e:
+            logger.error(
+                "Serious delete trouble <file:%s> <error:%s>",
+                str(destination),
+                str(e),
+            )
+
+        logger.info("FTP <put:%s>", str(destination))
         rc = False
 
         if size is not None:
             try:
-                self.voidcmd('ALLO {:d}'.format(size))
+                self.voidcmd("ALLO {:d}".format(size))
             except ftplib.error_perm:
                 pass
 
         try:
-            self.storbinary('STOR ' + destination, inputsrc)
+            self.storbinary("STOR " + destination, inputsrc)
             if exact:
                 if self.size(destination) == size:
                     rc = True
                 else:
-                    logger.error('FTP incomplete put %s (%d / %d bytes)', repr(source),
-                                 self.size(destination), size)
+                    logger.error(
+                        "FTP incomplete put %s (%d / %d bytes)",
+                        repr(source),
+                        self.size(destination),
+                        size,
+                    )
             else:
                 rc = True
                 if self.size(destination) != size:
-                    logger.info('FTP put %s: estimated %s bytes, real %s bytes',
-                                repr(source), str(size), self.size(destination))
+                    logger.info(
+                        "FTP put %s: estimated %s bytes, real %s bytes",
+                        repr(source),
+                        str(size),
+                        self.size(destination),
+                    )
         finally:
             if xsource:
                 inputsrc.close()
@@ -398,29 +426,29 @@ class ExtendedFtplib:
 
     def rmkdir(self, destination):
         """Recursive directory creation (mimics `mkdir -p`)."""
-        self.stderr('rmkdir', destination)
+        self.stderr("rmkdir", destination)
         origin = self.pwd()
-        if destination.startswith('/'):
-            path_pre = '/'
-        elif destination.startswith('~'):
-            path_pre = ''
+        if destination.startswith("/"):
+            path_pre = "/"
+        elif destination.startswith("~"):
+            path_pre = ""
         else:
-            path_pre = origin + '/'
+            path_pre = origin + "/"
 
-        for subdir in self.system.path.dirname(destination).split('/'):
+        for subdir in self.system.path.dirname(destination).split("/"):
             current = path_pre + subdir
             try:
                 self.cwd(current)
-                path_pre = current + '/'
+                path_pre = current + "/"
             except ftplib.error_perm:
-                self.stderr('mkdir', current)
+                self.stderr("mkdir", current)
                 try:
                     self.mkd(current)
                 except ftplib.error_perm as errmkd:
-                    if 'File exists' not in str(errmkd):
+                    if "File exists" not in str(errmkd):
                         raise
                 self.cwd(current)
-            path_pre = current + '/'
+            path_pre = current + "/"
         self.cwd(origin)
 
     def cd(self, destination):
@@ -433,16 +461,16 @@ class ExtendedFtplib:
 
     def mtime(self, filename):
         """Retrieve the modification time of a file."""
-        resp = self.sendcmd('MDTM ' + filename)
-        if resp[:3] == '213':
+        resp = self.sendcmd("MDTM " + filename)
+        if resp[:3] == "213":
             s = resp[3:].strip().split()[-1]
             return int(s)
 
     def size(self, filename):
         """Retrieve the size of a file."""
         # The SIZE command is defined in RFC-3659
-        resp = self.sendcmd('SIZE ' + filename)
-        if resp[:3] == '213':
+        resp = self.sendcmd("SIZE " + filename)
+        if resp[:3] == "213":
             s = resp[3:].strip().split()[-1]
             return int(s)
 
@@ -465,11 +493,23 @@ class StdFtp:
     :class:`ExtendedFtplib` and :class:`ftplib.FTP` class).
     """
 
-    _PROXY_TYPES = ('no-auth-logname-based', )
-
-    _NO_AUTOLOGIN = ('set_debuglevel', 'connect', 'login', 'stderr',)
-
-    def __init__(self, system, hostname, port=DEFAULT_FTP_PORT, nrcfile=None, ignoreproxy=False):
+    _PROXY_TYPES = ("no-auth-logname-based",)
+
+    _NO_AUTOLOGIN = (
+        "set_debuglevel",
+        "connect",
+        "login",
+        "stderr",
+    )
+
+    def __init__(
+        self,
+        system,
+        hostname,
+        port=DEFAULT_FTP_PORT,
+        nrcfile=None,
+        ignoreproxy=False,
+    ):
         """
         :param ~vortex.tools.systems.OSExtended system: The system object to work with
         :param str hostname: The remote host's network name
@@ -477,12 +517,18 @@ class StdFtp:
         :param str nrcfile: The path to the .netrc file (if `None` the ~/.netrc default is used)
         :param bool ignoreproxy: Forcibly ignore any proxy related environment variables
         """
-        logger.debug('FTP init <host:%s>', hostname)
+        logger.debug("FTP init <host:%s>", hostname)
         self._system = system
         if ignoreproxy:
-            self._proxy_host, self._proxy_port, self._proxy_type = (None, None, None)
+            self._proxy_host, self._proxy_port, self._proxy_type = (
+                None,
+                None,
+                None,
+            )
         else:
-            self._proxy_host, self._proxy_port, self._proxy_type = self._proxy_init()
+            self._proxy_host, self._proxy_port, self._proxy_type = (
+                self._proxy_init()
+            )
         self._hostname = hostname
         self._port = port
         self._nrcfile = nrcfile
@@ -495,18 +541,22 @@ class StdFtp:
         """Return the proxy type, address and port."""
         p_netloc = (None, None)
         p_url = self.system.env.get(
-            'VORTEX_FTP_PROXY', self.system.env.get('FTP_PROXY', None)
+            "VORTEX_FTP_PROXY", self.system.env.get("FTP_PROXY", None)
         )
         if p_url:
-            p_netloc = p_url.split(':', 1)
+            p_netloc = p_url.split(":", 1)
             if len(p_netloc) == 1:
                 p_netloc.append(DEFAULT_FTP_PORT)
             else:
                 p_netloc[1] = int(p_netloc[1])
-        p_type = self.system.env.get('VORTEX_FTP_PROXY_TYPE', self._PROXY_TYPES[0])
+        p_type = self.system.env.get(
+            "VORTEX_FTP_PROXY_TYPE", self._PROXY_TYPES[0]
+        )
         if p_type not in self._PROXY_TYPES:
-            raise ValueError('Incorrect value for the VORTEX_FTP_PROXY_TYPE ' +
-                             'environment variable (got: {:s})'.format(p_type))
+            raise ValueError(
+                "Incorrect value for the VORTEX_FTP_PROXY_TYPE "
+                + "environment variable (got: {:s})".format(p_type)
+            )
         return p_netloc[0], p_netloc[1], p_type
 
     def _extended_ftp_host_and_port(self):
@@ -523,9 +573,9 @@ class StdFtp:
         It is created on-demand.
         """
         if self._internal_ftp is None:
-            self._internal_ftp = ExtendedFtplib(self._system,
-                                                ftplib.FTP(),
-                                                * self._extended_ftp_host_and_port())
+            self._internal_ftp = ExtendedFtplib(
+                self._system, ftplib.FTP(), *self._extended_ftp_host_and_port()
+            )
         return self._internal_ftp
 
     _loginlike_extended_ftp = _extended_ftp
@@ -559,7 +609,7 @@ class StdFtp:
     @property
     def proxy(self):
         if self._proxy_host:
-            return '{0._proxy_host}:{0._proxy_port}'.format(self)
+            return "{0._proxy_host}:{0._proxy_port}".format(self)
         else:
             return None
 
@@ -570,15 +620,20 @@ class StdFtp:
 
     def netpath(self, remote):
         """The complete qualified net path of the remote resource."""
-        return '{:s}@{:s}:{:s}'.format(self.logname if self.logname is not None else 'unknown',
-                                       self.host, remote)
+        return "{:s}@{:s}:{:s}".format(
+            self.logname if self.logname is not None else "unknown",
+            self.host,
+            remote,
+        )
 
     def delayedlogin(self):
         """Login to the FTP server (if it was not already done)."""
         if self._loginlike_extended_ftp.closed:
             if self._logname is None or self.cached_pwd is None:
-                logger.warning('FTP logname/password must be set first. Use the fastlogin method.')
-                raise RuntimeError('logname/password were not provided')
+                logger.warning(
+                    "FTP logname/password must be set first. Use the fastlogin method."
+                )
+                raise RuntimeError("logname/password were not provided")
             return self.login(self._logname, self.cached_pwd)
         else:
             return True
@@ -588,11 +643,15 @@ class StdFtp:
         if logname and password:
             bare_logname = logname
         else:
-            bare_logname, password = netrc_lookup(logname, self.host, nrcfile=self._nrcfile)
+            bare_logname, password = netrc_lookup(
+                logname, self.host, nrcfile=self._nrcfile
+            )
         logname = bare_logname
         if logname and self._proxy_host:
             if self._proxy_type == self._PROXY_TYPES[0]:
-                logname = '{0:s}@{1.host:s}:{1.port:d}'.format(bare_logname, self)
+                logname = "{0:s}@{1.host:s}:{1.port:d}".format(
+                    bare_logname, self
+                )
         if logname:
             return logname, password, bare_logname
         else:
@@ -614,7 +673,9 @@ class StdFtp:
         necessary).
         """
         rc = False
-        p_logname, p_password, p_barelogname = self._process_logname_password(logname, password)
+        p_logname, p_password, p_barelogname = self._process_logname_password(
+            logname, password
+        )
         if p_logname and p_password:
             self._logname = p_logname
             self._cached_pwd = p_password
@@ -627,7 +688,7 @@ class StdFtp:
 
     def _extended_ftp_lookup_check(self, key):
         """Are we allowed to look for *key* in the `self._extended_ftp` object ?"""
-        return not key.startswith('_')
+        return not key.startswith("_")
 
     def _extended_ftp_lookup(self, key):
         """Look if the `self._extended_ftp` object can provide a given method.
@@ -637,6 +698,7 @@ class StdFtp:
         """
         actualattr = getattr(self._extended_ftp, key)
         if callable(actualattr):
+
             def osproxy(*args, **kw):
                 # For most of the native commands, we want autologin to be performed
                 if key not in self._NO_AUTOLOGIN:
@@ -679,9 +741,20 @@ class AutoRetriesFtp(StdFtp):
     the retry-on-failure capability.
     """
 
-    def __init__(self, system, hostname, port=DEFAULT_FTP_PORT, nrcfile=None, ignoreproxy=False,
-                 retrycount_default=6, retrycount_connect=8, retrycount_login=3,
-                 retrydelay_default=15, retrydelay_connect=15, retrydelay_login=10):
+    def __init__(
+        self,
+        system,
+        hostname,
+        port=DEFAULT_FTP_PORT,
+        nrcfile=None,
+        ignoreproxy=False,
+        retrycount_default=6,
+        retrycount_connect=8,
+        retrycount_login=3,
+        retrydelay_default=15,
+        retrydelay_connect=15,
+        retrydelay_login=10,
+    ):
         """
         :param ~vortex.tools.systems.OSExtended system: The system object to work with.
         :param str hostname: The remote host's network name.
@@ -695,7 +768,7 @@ class AutoRetriesFtp(StdFtp):
         :param int retrycount_login: The maximum number of retries when login in to the FTP server.
         :param int retrydelay_login: The delay (in seconds) between two retries when login in to the FTP server.
         """
-        logger.debug('AutoRetries FTP init <host:%s>', hostname)
+        logger.debug("AutoRetries FTP init <host:%s>", hostname)
         # Retry stuff
         self.retrycount_default = retrycount_default
         self.retrycount_connect = retrycount_connect
@@ -706,11 +779,17 @@ class AutoRetriesFtp(StdFtp):
         # Reset everything
         self._initialise()
         # Finalise
-        super().__init__(system, hostname, port=port, nrcfile=nrcfile, ignoreproxy=ignoreproxy)
+        super().__init__(
+            system,
+            hostname,
+            port=port,
+            nrcfile=nrcfile,
+            ignoreproxy=ignoreproxy,
+        )
 
     def _initialise(self):
         self._internal_retries_max = None
-        self._cwd = ''
+        self._cwd = ""
         self._autodestroy()
 
     def _autodestroy(self):
@@ -720,25 +799,39 @@ class AutoRetriesFtp(StdFtp):
     def _get_extended_ftp(self, retrycount, retrydelay, exceptions_extras):
         """Delay the call to 'connect' as much as possible."""
         if self._internal_ftp is None:
-            eftplib = self._retry_wrapped_callable(ExtendedFtplib,
-                                                   retrycount=retrycount,
-                                                   retrydelay=retrydelay,
-                                                   exceptions_extras=exceptions_extras)
-            self._internal_ftp = eftplib(self._system, ftplib.FTP(),
-                                         * self._extended_ftp_host_and_port())
+            eftplib = self._retry_wrapped_callable(
+                ExtendedFtplib,
+                retrycount=retrycount,
+                retrydelay=retrydelay,
+                exceptions_extras=exceptions_extras,
+            )
+            self._internal_ftp = eftplib(
+                self._system, ftplib.FTP(), *self._extended_ftp_host_and_port()
+            )
         return self._internal_ftp
 
     @property
     def _extended_ftp(self):
         """Delay the call to 'connect' as much as possible."""
-        return self._get_extended_ftp(self.retrycount_connect, self.retrydelay_connect,
-                                      [socket.timeout, ])
+        return self._get_extended_ftp(
+            self.retrycount_connect,
+            self.retrydelay_connect,
+            [
+                socket.timeout,
+            ],
+        )
 
     @property
     def _loginlike_extended_ftp(self):
         """Delay the call to 'connect' as much as possible."""
-        return self._get_extended_ftp(self.retrycount_login, self.retrydelay_login,
-                                      [ftplib.error_perm, socket.error, ])
+        return self._get_extended_ftp(
+            self.retrycount_login,
+            self.retrydelay_login,
+            [
+                ftplib.error_perm,
+                socket.error,
+            ],
+        )
 
     def _actual_login(self, *args):
         """Actually log in + save logname/password + correct the cwd if needed."""
@@ -750,22 +843,23 @@ class AutoRetriesFtp(StdFtp):
             self._cached_pwd = args[1]
         if rc and self._cwd:
             cocoondir = self._cwd
-            self._cwd = ''
+            self._cwd = ""
             rc = rc and self.cwd(cocoondir)
         return rc
 
     def login(self, *args):
         """Proxy to ftplib :meth:`ftplib.FTP.login`."""
-        wftplogin = self._retry_wrapped_callable(self._actual_login,
-                                                 retrycount=self.retrycount_login,
-                                                 retrydelay=self.retrydelay_login,
-                                                 exceptions_extras=[ftplib.error_perm,
-                                                                    socket.error,
-                                                                    EOFError])
+        wftplogin = self._retry_wrapped_callable(
+            self._actual_login,
+            retrycount=self.retrycount_login,
+            retrydelay=self.retrydelay_login,
+            exceptions_extras=[ftplib.error_perm, socket.error, EOFError],
+        )
         return wftplogin(*args)
 
-    def _retry_wrapped_callable(self, func, retrycount=None, retrydelay=None,
-                                exceptions_extras=None):
+    def _retry_wrapped_callable(
+        self, func, retrycount=None, retrydelay=None, exceptions_extras=None
+    ):
         """
         Wraps the *func* function in order to implement a retry on failure
         mechanism.
@@ -782,7 +876,11 @@ class AutoRetriesFtp(StdFtp):
         """
         actual_rcount = retrycount or self.retrycount_default
         actual_rdelay = retrydelay or self.retrydelay_default
-        actual_exc = [ftplib.error_temp, ftplib.error_proto, ftplib.error_reply, ]
+        actual_exc = [
+            ftplib.error_temp,
+            ftplib.error_proto,
+            ftplib.error_reply,
+        ]
         if exceptions_extras:
             actual_exc.extend(exceptions_extras)
         actual_exc = tuple(actual_exc)
@@ -791,22 +889,29 @@ class AutoRetriesFtp(StdFtp):
             globalcounter_driver = self._internal_retries_max is None
             if globalcounter_driver:
                 self._internal_retries_max = actual_rcount
-            retriesleft = max(min(self._internal_retries_max, actual_rcount), 1)
+            retriesleft = max(
+                min(self._internal_retries_max, actual_rcount), 1
+            )
             try:
                 while retriesleft:
                     try:
                         return func(*args, **kw)
                     except actual_exc as e:
-                        logger.warning('An error occurred (in "%s"): %s',
-                                       func.__name__, e)
+                        logger.warning(
+                            'An error occurred (in "%s"): %s', func.__name__, e
+                        )
                         retriesleft -= 1
                         self._internal_retries_max -= 1
                         if not retriesleft:
-                            logger.warning('The maximum number of retries (%d) was reached.',
-                                           actual_rcount)
+                            logger.warning(
+                                "The maximum number of retries (%d) was reached.",
+                                actual_rcount,
+                            )
                             raise
-                        logger.warning('Sleeping %d sec. before the next attempt.',
-                                       actual_rdelay)
+                        logger.warning(
+                            "Sleeping %d sec. before the next attempt.",
+                            actual_rdelay,
+                        )
                         self._autodestroy()
                         self.system.sleep(actual_rdelay)
             finally:
@@ -825,15 +930,19 @@ class AutoRetriesFtp(StdFtp):
             attr = self._extended_ftp_lookup(key)
             if callable(attr):
                 if key not in self._NO_AUTOLOGIN:
-                    attr = self._retry_wrapped_callable(attr,
-                                                        exceptions_extras=[socket.error, ])
+                    attr = self._retry_wrapped_callable(
+                        attr,
+                        exceptions_extras=[
+                            socket.error,
+                        ],
+                    )
                 setattr(self, key, attr)
             return attr
         raise AttributeError(key)
 
     def cwd(self, pathname):
         """Change the current directory to the *pathname* directory."""
-        todo = self._retry_wrapped_callable(self._extended_ftp_lookup('cwd'))
+        todo = self._retry_wrapped_callable(self._extended_ftp_lookup("cwd"))
         rc = todo(pathname)
         if rc:
             if self.system.path.isabs(pathname):
@@ -850,7 +959,9 @@ class AutoRetriesFtp(StdFtp):
     def quit(self):
         """Quit the current ftp session politely."""
         try:
-            rc = self._retry_wrapped_callable(self._extended_ftp_lookup('quit'))()
+            rc = self._retry_wrapped_callable(
+                self._extended_ftp_lookup("quit")
+            )()
         finally:
             self._initialise()
         return rc
@@ -885,7 +996,7 @@ class ResetableAutoRetriesFtp(AutoRetriesFtp):
     def reset(self):
         """Reset the current working directory to its initial value."""
         if self._initialpath is not None and self._cwd:
-            self._cwd = ''
+            self._cwd = ""
             return self.cwd(self._initialpath)
 
 
@@ -904,7 +1015,9 @@ class PooledResetableAutoRetriesFtp(ResetableAutoRetriesFtp):
         """
         self._pool = pool
         super().__init__(*kargs, **kwargs)
-        logger.debug('Pooled FTP init <host:%s> <pool:%s>', self.host, repr(pool))
+        logger.debug(
+            "Pooled FTP init <host:%s> <pool:%s>", self.host, repr(pool)
+        )
 
     def forceclose(self):
         """Really quit the ftp session."""
@@ -965,40 +1078,60 @@ class FtpConnectionPool:
 
     def __str__(self):
         """Print a summary of the connection pool activity."""
-        out = 'Current connection pool size: {:d}\n'.format(self.poolsize)
-        out += '  # of created objects: {:d}\n'.format(self._created)
-        out += '  # of re-used objects: {:d}\n'.format(self._reused)
-        out += '  # of given back objects: {:d}\n'.format(self._givenback)
+        out = "Current connection pool size: {:d}\n".format(self.poolsize)
+        out += "  # of created objects: {:d}\n".format(self._created)
+        out += "  # of re-used objects: {:d}\n".format(self._reused)
+        out += "  # of given back objects: {:d}\n".format(self._givenback)
         if self.poolsize:
-            out += '\nDetailed list of current spare clients:\n'
+            out += "\nDetailed list of current spare clients:\n"
             for ident, hpool in self._reusable.items():
                 for client in hpool:
-                    out += '  - {id[1]:s}@{id[0]:s}: {cl!r}\n'.format(id=ident, cl=client)
+                    out += "  - {id[1]:s}@{id[0]:s}: {cl!r}\n".format(
+                        id=ident, cl=client
+                    )
         return out
 
-    def deal(self, hostname, logname, port=DEFAULT_FTP_PORT, delayed=True, ignoreproxy=False):
+    def deal(
+        self,
+        hostname,
+        logname,
+        port=DEFAULT_FTP_PORT,
+        delayed=True,
+        ignoreproxy=False,
+    ):
         """Retrieve an FTP client for the *hostname*/*logname* pair."""
         p_logname, _ = netrc_lookup(logname, hostname, nrcfile=self._nrcfile)
         if self._reusable[(hostname, port, p_logname)]:
             ftpc = self._reusable[(hostname, port, p_logname)].pop()
             ftpc.reset()
-            logger.debug('Re-using a client: %s', repr(ftpc))
+            logger.debug("Re-using a client: %s", repr(ftpc))
             if not delayed:
                 # If requested, ensure that we are logged in
                 ftpc.delayedlogin()
             self._reused += 1
             return ftpc
         else:
-            ftpc = self._FTPCLIENT_CLASS(self, self._system, hostname,
-                                         port=port, nrcfile=self._nrcfile,
-                                         ignoreproxy=self._ignoreproxy)
+            ftpc = self._FTPCLIENT_CLASS(
+                self,
+                self._system,
+                hostname,
+                port=port,
+                nrcfile=self._nrcfile,
+                ignoreproxy=self._ignoreproxy,
+            )
             rc = ftpc.fastlogin(p_logname, delayed=delayed)
             if rc:
-                logger.debug('Creating a new client: %s', repr(ftpc))
+                logger.debug("Creating a new client: %s", repr(ftpc))
                 self._created += 1
                 return ftpc
             else:
-                logger.warning('Could not login on %s:%d as %s [%s]', hostname, port, p_logname, str(rc))
+                logger.warning(
+                    "Could not login on %s:%d as %s [%s]",
+                    hostname,
+                    port,
+                    p_logname,
+                    str(rc),
+                )
                 return None
 
     def relinquishing(self, client):
@@ -1010,19 +1143,32 @@ class FtpConnectionPool:
         its `close` method is called.
         """
         assert isinstance(client, self._FTPCLIENT_CLASS)
-        self._reusable[(client.host, client.port, client.logname)].append(client)
+        self._reusable[(client.host, client.port, client.logname)].append(
+            client
+        )
         self._givenback += 1
-        logger.debug("Spare client for %s@%s:%d has been stored (poolsize=%d).",
-                     client.logname, client.host, client.port, self.poolsize)
+        logger.debug(
+            "Spare client for %s@%s:%d has been stored (poolsize=%d).",
+            client.logname,
+            client.host,
+            client.port,
+            self.poolsize,
+        )
         if self.poolsize >= self._REUSABLE_THRESHOLD:
-            logger.warning('The FTP pool is too big ! (%d  >= %d). Here are the details:\n%s',
-                           self.poolsize, self._REUSABLE_THRESHOLD, str(self))
+            logger.warning(
+                "The FTP pool is too big ! (%d  >= %d). Here are the details:\n%s",
+                self.poolsize,
+                self._REUSABLE_THRESHOLD,
+                str(self),
+            )
 
     def clear(self):
         """Destroy all the spare FTP clients."""
         for hpool in self._reusable.values():
             for client in hpool:
-                logger.debug("Destroying client for %s@%s", client.logname, client.host)
+                logger.debug(
+                    "Destroying client for %s@%s", client.logname, client.host
+                )
                 client.forceclose()
             hpool.clear()
 
@@ -1047,14 +1193,16 @@ class Ssh:
         self._remote = hostname
 
         target = sh.default_target
-        self._sshcmd = target.get(key='services:sshcmd', default='ssh')
-        self._scpcmd = target.get(key='services:scpcmd', default='scp')
+        self._sshcmd = target.get(key="services:sshcmd", default="ssh")
+        self._scpcmd = target.get(key="services:scpcmd", default="scp")
         self._sshopts = (
-            target.get(key='services:sshopts', default='-x').split() +
-            (sshopts or '').split())
+            target.get(key="services:sshopts", default="-x").split()
+            + (sshopts or "").split()
+        )
         self._scpopts = (
-            target.get(key='services:scpopts', default='-Bp').split() +
-            (scpopts or '').split())
+            target.get(key="services:scpopts", default="-Bp").split()
+            + (scpopts or "").split()
+        )
 
     @property
     def sh(self):
@@ -1062,13 +1210,15 @@ class Ssh:
 
     @property
     def remote(self):
-        return ('' if self._logname is None else self._logname + '@') + self._remote
+        return (
+            "" if self._logname is None else self._logname + "@"
+        ) + self._remote
 
     def check_ok(self):
         """Is the connexion ok ?"""
-        return self.execute('true') is not False
+        return self.execute("true") is not False
 
-    def execute(self, remote_command, sshopts=''):
+    def execute(self, remote_command, sshopts=""):
         """Execute the command remotely.
 
         Return the output of the command (list of lines), or False on error.
@@ -1083,12 +1233,24 @@ class Ssh:
         myremote = self.remote
         if myremote is None:
             return False
-        cmd = ([self._sshcmd, ] +
-               self._sshopts + sshopts.split() +
-               [myremote, ] + [remote_command, ])
+        cmd = (
+            [
+                self._sshcmd,
+            ]
+            + self._sshopts
+            + sshopts.split()
+            + [
+                myremote,
+            ]
+            + [
+                remote_command,
+            ]
+        )
         return self.sh.spawn(cmd, output=True, fatal=False)
 
-    def background_execute(self, remote_command, sshopts='', stdout=None, stderr=None):
+    def background_execute(
+        self, remote_command, sshopts="", stdout=None, stderr=None
+    ):
         """Execute the command remotely and return the object representing the ssh process.
 
         Return a Popen object representing the ssh process. The user is reponsible
@@ -1097,9 +1259,19 @@ class Ssh:
         myremote = self.remote
         if myremote is None:
             return False
-        cmd = ([self._sshcmd, ] +
-               self._sshopts + sshopts.split() +
-               [myremote, ] + [remote_command, ])
+        cmd = (
+            [
+                self._sshcmd,
+            ]
+            + self._sshopts
+            + sshopts.split()
+            + [
+                myremote,
+            ]
+            + [
+                remote_command,
+            ]
+        )
         return self.sh.popen(cmd, stdout=stdout, stderr=stderr)
 
     def cocoon(self, destination):
@@ -1108,14 +1280,18 @@ class Ssh:
         Return ``False`` on failure.
         """
         remote_dir = self.sh.path.dirname(destination)
-        if remote_dir == '':
+        if remote_dir == "":
             return True
         logger.debug('Cocooning remote directory "%s"', remote_dir)
         cmd = 'mkdir -p "{}"'.format(remote_dir)
         rc = self.execute(cmd)
         if not rc:
-            logger.error('Cannot cocoon on %s (user: %s) for %s',
-                         str(self._remote), str(self._logname), destination)
+            logger.error(
+                "Cannot cocoon on %s (user: %s) for %s",
+                str(self._remote),
+                str(self._logname),
+                destination,
+            )
         return rc
 
     def remove(self, target):
@@ -1128,33 +1304,43 @@ class Ssh:
         cmd = 'rm -fr "{}"'.format(target)
         rc = self.execute(cmd)
         if not rc:
-            logger.error('Cannot remove from %s (user: %s) item "%s"',
-                         str(self._remote), str(self._logname), target)
+            logger.error(
+                'Cannot remove from %s (user: %s) item "%s"',
+                str(self._remote),
+                str(self._logname),
+                target,
+            )
         return rc
 
     def _scp_putget_commons(self, source, destination):
         """Common checks on source and destination."""
         if not isinstance(source, str):
-            msg = 'Source is not a plain file path: {!r}'.format(source)
+            msg = "Source is not a plain file path: {!r}".format(source)
             raise TypeError(msg)
         if not isinstance(destination, str):
-            msg = 'Destination is not a plain file path: {!r}'.format(destination)
+            msg = "Destination is not a plain file path: {!r}".format(
+                destination
+            )
             raise TypeError(msg)
 
         # avoid special cases
-        if destination == '' or destination == '.':
-            destination = './'
+        if destination == "" or destination == ".":
+            destination = "./"
         else:
-            if destination.endswith('..'):
-                destination += '/'
-            if '../' in destination:
-                raise ValueError('"../" is not allowed in the destination path')
-        if destination.endswith('/'):
-            destination = self.sh.path.join(destination, self.sh.path.basename(source))
+            if destination.endswith(".."):
+                destination += "/"
+            if "../" in destination:
+                raise ValueError(
+                    '"../" is not allowed in the destination path'
+                )
+        if destination.endswith("/"):
+            destination = self.sh.path.join(
+                destination, self.sh.path.basename(source)
+            )
 
         return source, destination
 
-    def scpput(self, source, destination, scpopts=''):
+    def scpput(self, source, destination, scpopts=""):
         r"""Send ``source`` to ``destination``.
 
         - ``source`` is a single file or a directory, not a pattern (no '\*.grib').
@@ -1170,7 +1356,7 @@ class Ssh:
         source, destination = self._scp_putget_commons(source, destination)
 
         if not self.sh.path.exists(source):
-            logger.error('No such file or directory: %s', source)
+            logger.error("No such file or directory: %s", source)
             return False
 
         source = self.sh.path.realpath(source)
@@ -1186,25 +1372,29 @@ class Ssh:
             return False
 
         if self.sh.path.isdir(source):
-            scpopts += ' -r'
+            scpopts += " -r"
 
-        if not self.remove(destination + '.tmp'):
+        if not self.remove(destination + ".tmp"):
             return False
 
         # transfer to a temporary place.
         # when ``destination`` contains spaces, 1 round of quoting
         # is necessary, to avoid an 'scp: ambiguous target' error.
-        cmd = ([self._scpcmd, ] +
-               self._scpopts + scpopts.split() +
-               [source,
-                myremote + ':' + shlex.quote(destination + '.tmp')])
+        cmd = (
+            [
+                self._scpcmd,
+            ]
+            + self._scpopts
+            + scpopts.split()
+            + [source, myremote + ":" + shlex.quote(destination + ".tmp")]
+        )
         rc = self.sh.spawn(cmd, output=False, fatal=False)
         if rc:
             # success, rename the tmp
             rc = self.execute('mv "{0}.tmp" "{0}"'.format(destination))
         return rc
 
-    def scpget(self, source, destination, scpopts='', isadir=False):
+    def scpget(self, source, destination, scpopts="", isadir=False):
         r"""Send ``source`` to ``destination``.
 
         - ``source`` is the remote name, not a pattern (no '\*.grib').
@@ -1229,19 +1419,23 @@ class Ssh:
         if isadir:
             if not self.sh.remove(destination):
                 return False
-            scpopts += ' -r'
+            scpopts += " -r"
 
         # transfer to a temporary place.
         # when ``source`` contains spaces, 1 round of quoting
         # is necessary, to avoid an 'scp: ambiguous target' error.
-        cmd = ([self._scpcmd, ] +
-               self._scpopts + scpopts.split() +
-               [myremote + ':' + shlex.quote(source),
-                destination + '.tmp'])
+        cmd = (
+            [
+                self._scpcmd,
+            ]
+            + self._scpopts
+            + scpopts.split()
+            + [myremote + ":" + shlex.quote(source), destination + ".tmp"]
+        )
         rc = self.sh.spawn(cmd, output=False, fatal=False)
         if rc:
             # success, rename the tmp
-            rc = self.sh.move(destination + '.tmp', destination)
+            rc = self.sh.move(destination + ".tmp", destination)
         return rc
 
     def get_permissions(self, source):
@@ -1252,7 +1446,7 @@ class Ssh:
         mode = self.sh.stat(source).st_mode
         return stat.S_IMODE(mode)
 
-    def scpput_stream(self, stream, destination, permissions=None, sshopts=''):
+    def scpput_stream(self, stream, destination, permissions=None, sshopts=""):
         """Send the ``stream`` to the ``destination``.
 
         - ``stream`` is a ``file`` (typically returned by open(),
@@ -1262,11 +1456,15 @@ class Ssh:
         Return True for ok, False on error.
         """
         if not isinstance(stream, io.IOBase):
-            msg = "stream is a {}, should be a <type 'file'>".format(type(stream))
+            msg = "stream is a {}, should be a <type 'file'>".format(
+                type(stream)
+            )
             raise TypeError(msg)
 
         if not isinstance(destination, str):
-            msg = 'Destination is not a plain file path: {!r}'.format(destination)
+            msg = "Destination is not a plain file path: {!r}".format(
+                destination
+            )
             raise TypeError(msg)
 
         myremote = self.remote
@@ -1277,16 +1475,25 @@ class Ssh:
             return False
 
         # transfer to a tmp, rename and set permissions in one go
-        remote_cmd = 'cat > {0}.tmp && mv {0}.tmp {0}'.format(shlex.quote(destination))
+        remote_cmd = "cat > {0}.tmp && mv {0}.tmp {0}".format(
+            shlex.quote(destination)
+        )
         if permissions:
-            remote_cmd += ' && chmod -v {:o} {}'.format(permissions, shlex.quote(destination))
-
-        cmd = ([self._sshcmd, ] +
-               self._sshopts + sshopts.split() +
-               [myremote, remote_cmd])
+            remote_cmd += " && chmod -v {:o} {}".format(
+                permissions, shlex.quote(destination)
+            )
+
+        cmd = (
+            [
+                self._sshcmd,
+            ]
+            + self._sshopts
+            + sshopts.split()
+            + [myremote, remote_cmd]
+        )
         return self.sh.spawn(cmd, stdin=stream, output=False, fatal=False)
 
-    def scpget_stream(self, source, stream, sshopts=''):
+    def scpget_stream(self, source, stream, sshopts=""):
         """Send the ``source`` to the ``stream``.
 
         - ``source`` is the remote file name.
@@ -1296,11 +1503,13 @@ class Ssh:
         Return True for ok, False on error.
         """
         if not isinstance(stream, io.IOBase):
-            msg = "stream is a {}, should be a <type 'file'>".format(type(stream))
+            msg = "stream is a {}, should be a <type 'file'>".format(
+                type(stream)
+            )
             raise TypeError(msg)
 
         if not isinstance(source, str):
-            msg = 'Source is not a plain file path: {!r}'.format(source)
+            msg = "Source is not a plain file path: {!r}".format(source)
             raise TypeError(msg)
 
         myremote = self.remote
@@ -1308,14 +1517,25 @@ class Ssh:
             return False
 
         # transfer to a tmp, rename and set permissions in one go
-        remote_cmd = 'cat {}'.format(shlex.quote(source))
-        cmd = ([self._sshcmd, ] +
-               self._sshopts + sshopts.split() +
-               [myremote, remote_cmd])
+        remote_cmd = "cat {}".format(shlex.quote(source))
+        cmd = (
+            [
+                self._sshcmd,
+            ]
+            + self._sshopts
+            + sshopts.split()
+            + [myremote, remote_cmd]
+        )
         return self.sh.spawn(cmd, output=stream, fatal=False)
 
-    def tunnel(self, finaldestination, finalport=0, entranceport=None,
-               maxwait=3., checkdelay=0.25):
+    def tunnel(
+        self,
+        finaldestination,
+        finalport=0,
+        entranceport=None,
+        maxwait=3.0,
+        checkdelay=0.25,
+    ):
         """Create an SSH tunnel and check that it actually starts.
 
         :param str finaldestination: The destination hostname (i.e the machine
@@ -1343,45 +1563,84 @@ class Ssh:
             entranceport = self.sh.available_localport()
         else:
             if self.sh.check_localport(entranceport):
-                logger.error('The SSH tunnel creation failed ' +
-                             '(entrance: %d, dest: %s:%d, via %s).',
-                             entranceport, finaldestination, finalport, myremote)
-                logger.error('The entrance port is already in use.')
+                logger.error(
+                    "The SSH tunnel creation failed "
+                    + "(entrance: %d, dest: %s:%d, via %s).",
+                    entranceport,
+                    finaldestination,
+                    finalport,
+                    myremote,
+                )
+                logger.error("The entrance port is already in use.")
                 return False
-        if finaldestination == 'socks':
-            p = self.sh.popen([self._sshcmd, ] + self._sshopts +
-                              ['-N', '-D', '{:d}'.format(entranceport), myremote],
-                              stdin=False, output=False)
+        if finaldestination == "socks":
+            p = self.sh.popen(
+                [
+                    self._sshcmd,
+                ]
+                + self._sshopts
+                + ["-N", "-D", "{:d}".format(entranceport), myremote],
+                stdin=False,
+                output=False,
+            )
         else:
             if finalport <= 0:
-                raise ValueError('Erroneous finalport value: {!s}'.format(finalport))
-            p = self.sh.popen([self._sshcmd, ] + self._sshopts +
-                              ['-N', '-L',
-                               '{:d}:{:s}:{:d}'.format(entranceport,
-                                                       finaldestination, finalport),
-                               myremote],
-                              stdin=False, output=False)
-        tunnel = ActiveSshTunnel(self.sh, p, entranceport, finaldestination, finalport)
-        elapsed = 0.
-        while (not self.sh.check_localport(entranceport)) and elapsed < maxwait:
+                raise ValueError(
+                    "Erroneous finalport value: {!s}".format(finalport)
+                )
+            p = self.sh.popen(
+                [
+                    self._sshcmd,
+                ]
+                + self._sshopts
+                + [
+                    "-N",
+                    "-L",
+                    "{:d}:{:s}:{:d}".format(
+                        entranceport, finaldestination, finalport
+                    ),
+                    myremote,
+                ],
+                stdin=False,
+                output=False,
+            )
+        tunnel = ActiveSshTunnel(
+            self.sh, p, entranceport, finaldestination, finalport
+        )
+        elapsed = 0.0
+        while (
+            not self.sh.check_localport(entranceport)
+        ) and elapsed < maxwait:
             self.sh.sleep(checkdelay)
             elapsed += checkdelay
         if not self.sh.check_localport(entranceport):
-            logger.error('The SSH tunnel creation failed ' +
-                         '(entrance: %d, dest: %s:%d, via %s).',
-                         entranceport, finaldestination, finalport, myremote)
+            logger.error(
+                "The SSH tunnel creation failed "
+                + "(entrance: %d, dest: %s:%d, via %s).",
+                entranceport,
+                finaldestination,
+                finalport,
+                myremote,
+            )
             tunnel.close()
             tunnel = False
-        logger.info('SSH tunnel opened, enjoy the ride ! ' +
-                    '(entrance: %d, dest: %s:%d, via %s).',
-                    entranceport, finaldestination, finalport, myremote)
+        logger.info(
+            "SSH tunnel opened, enjoy the ride ! "
+            + "(entrance: %d, dest: %s:%d, via %s).",
+            entranceport,
+            finaldestination,
+            finalport,
+            myremote,
+        )
         return tunnel
 
 
 class ActiveSshTunnel:
     """Hold an opened SSH tunnel."""
 
-    def __init__(self, sh, activeprocess, entranceport, finaldestination, finalport):
+    def __init__(
+        self, sh, activeprocess, entranceport, finaldestination, finalport
+    ):
         """
         :param Popen activeprocess: The active tunnel process.
         :param int entranceport: Tunnel's entrance port.
@@ -1407,12 +1666,18 @@ class ActiveSshTunnel:
             t0 = time.time()
             while self.opened and time.time() - t0 < 5:
                 self._sh.sleep(0.1)
-            logger.debug("Tunnel termination took: %f seconds", time.time() - t0)
+            logger.debug(
+                "Tunnel termination took: %f seconds", time.time() - t0
+            )
             if self.opened:
                 logger.debug("Tunnel termination failed: issuing SIGKILL")
                 self.activeprocess.kill()
-            logger.info('SSH tunnel closed (entrance: %d, dest: %s:%d).',
-                        self.entranceport, self.finaldestination, self.finalport)
+            logger.info(
+                "SSH tunnel closed (entrance: %d, dest: %s:%d).",
+                self.entranceport,
+                self.finaldestination,
+                self.finalport,
+            )
 
     @property
     def opened(self):
@@ -1444,9 +1709,14 @@ def _check_fatal(func):
             try:
                 rc = func(self, *args[1:], **kwargs)
                 if not rc:
-                    logger.error("The maximum number of retries (%s) was reached...", self._maxtries)
+                    logger.error(
+                        "The maximum number of retries (%s) was reached...",
+                        self._maxtries,
+                    )
                     if self._fatal:
-                        raise RuntimeError("Could not execute the SSH command.")
+                        raise RuntimeError(
+                            "Could not execute the SSH command."
+                        )
             finally:
                 self._fatal_in_progress = False
             return rc
@@ -1474,7 +1744,11 @@ def _tryagain(func):
                 rc = func(self, *args[1:], **kwargs)
                 while not rc and trycount < self._maxtries:
                     trycount += 1
-                    logger.info("Trying again (retries=%d/%d)...", trycount, self._maxtries)
+                    logger.info(
+                        "Trying again (retries=%d/%d)...",
+                        trycount,
+                        self._maxtries,
+                    )
                     self.sh.sleep(self._triesdelay)
                     rc = func(self, *args[1:], **kwargs)
             finally:
@@ -1503,13 +1777,17 @@ class _AssistedSshMeta(type):
         """
         bare_methods = list(d.keys())
         # Add the tryagain decorator...
-        for tagain in [x for x in d['_auto_retries'] if x not in bare_methods]:
+        for tagain in [x for x in d["_auto_retries"] if x not in bare_methods]:
             inherited = [base for base in b if hasattr(base, tagain)]
             d[tagain] = _tryagain(getattr(inherited[0], tagain))
         # Add the check_fatal decorator...
-        for cfatal in [x for x in d['_auto_checkfatal'] if x not in bare_methods]:
+        for cfatal in [
+            x for x in d["_auto_checkfatal"] if x not in bare_methods
+        ]:
             inherited = [base for base in b if hasattr(base, cfatal)]
-            d[cfatal] = _check_fatal(d.get(cfatal, getattr(inherited[0], cfatal)))
+            d[cfatal] = _check_fatal(
+                d.get(cfatal, getattr(inherited[0], cfatal))
+            )
         return super().__new__(cls, n, b, d)
 
 
@@ -1577,16 +1855,42 @@ class AssistedSsh(Ssh, metaclass=_AssistedSshMeta):
 
     """
 
-    _auto_checkfatal = ['check_ok', 'execute', 'cocoon', 'remove',
-                        'scpput', 'scpget', 'scpput_stream', 'scpget_stream',
-                        'tunnel']
+    _auto_checkfatal = [
+        "check_ok",
+        "execute",
+        "cocoon",
+        "remove",
+        "scpput",
+        "scpget",
+        "scpput_stream",
+        "scpget_stream",
+        "tunnel",
+    ]
     # No retries on scpput_stream since it's not guaranteed that the stream is seekable.
-    _auto_retries = ['check_ok', 'execute', 'cocoon', 'remove',
-                     'scpput', 'scpget', 'tunnel']
-
-    def __init__(self, sh, hostname, logname=None, sshopts=None, scpopts=None,
-                 maxtries=1, triesdelay=1, virtualnode=False, permut=True,
-                 fatal=False, mandatory_hostcheck=True):
+    _auto_retries = [
+        "check_ok",
+        "execute",
+        "cocoon",
+        "remove",
+        "scpput",
+        "scpget",
+        "tunnel",
+    ]
+
+    def __init__(
+        self,
+        sh,
+        hostname,
+        logname=None,
+        sshopts=None,
+        scpopts=None,
+        maxtries=1,
+        triesdelay=1,
+        virtualnode=False,
+        permut=True,
+        fatal=False,
+        mandatory_hostcheck=True,
+    ):
         """
         :param System sh: The :class:`System` object that is to be used.
         :param hostname: The target hostname(s).
@@ -1616,7 +1920,9 @@ class AssistedSsh(Ssh, metaclass=_AssistedSshMeta):
         self._fatal = fatal
         self._mandatory_hostcheck = mandatory_hostcheck
         if self._virtualnode and isinstance(self._remote, (list, tuple)):
-            raise ValueError('When virtual nodes are used, the hostname must be a string')
+            raise ValueError(
+                "When virtual nodes are used, the hostname must be a string"
+            )
 
         self._retry_in_progress = False
         self._fatal_in_progress = False
@@ -1640,7 +1946,7 @@ class AssistedSsh(Ssh, metaclass=_AssistedSshMeta):
             else:
                 targets = [self._remote]
         if self._logname is not None:
-            targets = [self._logname + '@' + x for x in targets]
+            targets = [self._logname + "@" + x for x in targets]
         if self._permut:
             random.shuffle(targets)
         return targets
@@ -1667,7 +1973,16 @@ class AssistedSsh(Ssh, metaclass=_AssistedSshMeta):
         if self._mandatory_hostcheck:
             if self._chosen_target is None:
                 for guess in self.targets:
-                    cmd = [self._sshcmd, ] + self._sshopts + [guess, 'true', ]
+                    cmd = (
+                        [
+                            self._sshcmd,
+                        ]
+                        + self._sshopts
+                        + [
+                            guess,
+                            "true",
+                        ]
+                    )
                     try:
                         self.sh.spawn(cmd, output=False, silent=True)
                     except Exception:
@@ -1680,9 +1995,16 @@ class AssistedSsh(Ssh, metaclass=_AssistedSshMeta):
             return next(self._targets_iter)
 
 
-_ConnectionStatusAttrs = ('Family', 'LocalAddr', 'LocalPort', 'DestAddr', 'DestPort', 'Status')
-TcpConnectionStatus = namedtuple('TcpConnectionStatus', _ConnectionStatusAttrs)
-UdpConnectionStatus = namedtuple('UdpConnectionStatus', _ConnectionStatusAttrs)
+_ConnectionStatusAttrs = (
+    "Family",
+    "LocalAddr",
+    "LocalPort",
+    "DestAddr",
+    "DestPort",
+    "Status",
+)
+TcpConnectionStatus = namedtuple("TcpConnectionStatus", _ConnectionStatusAttrs)
+UdpConnectionStatus = namedtuple("UdpConnectionStatus", _ConnectionStatusAttrs)
 
 
 class AbstractNetstats(metaclass=abc.ABCMeta):
@@ -1730,11 +2052,9 @@ class AbstractNetstats(metaclass=abc.ABCMeta):
 class LinuxNetstats(AbstractNetstats):
     """A Netstats implementation for Linux (based on the /proc/net data)."""
 
-    _LINUX_LPORT = '/proc/sys/net/ipv4/ip_local_port_range'
-    _LINUX_PORTS_V4 = {'tcp': '/proc/net/tcp',
-                       'udp': '/proc/net/udp'}
-    _LINUX_PORTS_V6 = {'tcp': '/proc/net/tcp6',
-                       'udp': '/proc/net/udp6'}
+    _LINUX_LPORT = "/proc/sys/net/ipv4/ip_local_port_range"
+    _LINUX_PORTS_V4 = {"tcp": "/proc/net/tcp", "udp": "/proc/net/udp"}
+    _LINUX_PORTS_V6 = {"tcp": "/proc/net/tcp6", "udp": "/proc/net/udp6"}
     _LINUX_AF_INET4 = socket.AF_INET
     _LINUX_AF_INET6 = socket.AF_INET6
 
@@ -1747,7 +2067,9 @@ class LinuxNetstats(AbstractNetstats):
             with open(self._LINUX_LPORT) as tmprange:
                 tmpports = [int(x) for x in tmprange.readline().split()]
             unports = set(range(5001, 65536))
-            self.__unprivileged_ports = sorted(unports - set(range(tmpports[0], tmpports[1] + 1)))
+            self.__unprivileged_ports = sorted(
+                unports - set(range(tmpports[0], tmpports[1] + 1))
+            )
         return self.__unprivileged_ports
 
     @classmethod
@@ -1755,8 +2077,7 @@ class LinuxNetstats(AbstractNetstats):
         if family == cls._LINUX_AF_INET4:
             packed = struct.pack(b"<I", int(hexip, 16))
         elif family == cls._LINUX_AF_INET6:
-            packed = struct.unpack(b">IIII",
-                                   binascii.a2b_hex(hexip))
+            packed = struct.unpack(b">IIII", binascii.a2b_hex(hexip))
             packed = struct.pack(b"@IIII", *packed)
         else:
             raise ValueError("Unknown address family.")
@@ -1766,25 +2087,38 @@ class LinuxNetstats(AbstractNetstats):
         tmpports = dict()
         with open(self._LINUX_PORTS_V4[proto]) as netstats:
             netstats.readline()  # Skip the header line
-            tmpports[self._LINUX_AF_INET4] = [re.split(r':\b|\s+', x.strip())[1:6]
-                                              for x in netstats.readlines()]
+            tmpports[self._LINUX_AF_INET4] = [
+                re.split(r":\b|\s+", x.strip())[1:6]
+                for x in netstats.readlines()
+            ]
         try:
             with open(self._LINUX_PORTS_V6[proto]) as netstats:
                 netstats.readline()  # Skip the header line
-                tmpports[self._LINUX_AF_INET6] = [re.split(r':\b|\s+', x.strip())[1:6]
-                                                  for x in netstats.readlines()]
+                tmpports[self._LINUX_AF_INET6] = [
+                    re.split(r":\b|\s+", x.strip())[1:6]
+                    for x in netstats.readlines()
+                ]
         except OSError:
             # Apparently, no IPv6 support on this machine
             tmpports[self._LINUX_AF_INET6] = []
-        tmpports = [[rclass(family,
-                            self._ip_from_hex(l[0], family), int(l[1], 16),
-                            self._ip_from_hex(l[2], family), int(l[3], 16),
-                            int(l[4], 16)) for l in tmpports[family]]
-                    for family in (self._LINUX_AF_INET4, self._LINUX_AF_INET6)]
+        tmpports = [
+            [
+                rclass(
+                    family,
+                    self._ip_from_hex(l[0], family),
+                    int(l[1], 16),
+                    self._ip_from_hex(l[2], family),
+                    int(l[3], 16),
+                    int(l[4], 16),
+                )
+                for l in tmpports[family]
+            ]
+            for family in (self._LINUX_AF_INET4, self._LINUX_AF_INET6)
+        ]
         return functools.reduce(operator.add, tmpports)
 
     def tcp_netstats(self):
-        return self._generic_netstats('tcp', TcpConnectionStatus)
+        return self._generic_netstats("tcp", TcpConnectionStatus)
 
     def udp_netstats(self):
-        return self._generic_netstats('udp', UdpConnectionStatus)
+        return self._generic_netstats("udp", UdpConnectionStatus)