docs: def connect(self, hostname, port=SSH_PORT, username=None, password=None, pkey=None,
                  key_filename=None, timeout=None, allow_agent=True, look_for_keys=True,
                  compress=False, sock=None):
          """
          Connect to an SSH server and authenticate to it.  The server's host key
          is checked against the system host keys (see `load_system_host_keys`)
          and any local host keys (`load_host_keys`).  If the server's hostname
          is not found in either set of host keys, the missing host key policy
          is used (see `set_missing_host_key_policy`).  The default policy is
          to reject the key and raise an `.SSHException`.
  
          Authentication is attempted in the following order of priority:
  
              - The ``pkey`` or ``key_filename`` passed in (if any)
              - Any key we can find through an SSH agent
              - Any "id_rsa" or "id_dsa" key discoverable in ``~/.ssh/``
              - Plain username/password auth, if a password was given
  
          If a private key requires a password to unlock it, and a password is
          passed in, that password will be used to attempt to unlock the key.
  
          :param str hostname: the server to connect to
          :param int port: the server port to connect to
          :param str username:
              the username to authenticate as (defaults to the current local
              username)
          :param str password:
              a password to use for authentication or for unlocking a private key
          :param .PKey pkey: an optional private key to use for authentication
          :param str key_filename:
              the filename, or list of filenames, of optional private key(s) to
              try for authentication
          :param float timeout: an optional timeout (in seconds) for the TCP connect
          :param bool allow_agent: set to False to disable connecting to the SSH agent
          :param bool look_for_keys:
              set to False to disable searching for discoverable private key
              files in ``~/.ssh/``
          :param bool compress: set to True to turn on compression
          :param socket sock:
              an open socket or socket-like object (such as a `.Channel`) to use
              for communication to the target host
  
          :raises BadHostKeyException: if the server's host key could not be
              verified
          :raises AuthenticationException: if authentication failed
          :raises SSHException: if there was any other error connecting or
              establishing an SSH session
          :raises socket.error: if a socket error occurred while connecting
          """
          if not sock:
              for (family, socktype, proto, canonname, sockaddr) in socket.getaddrinfo(hostname, port, socket.AF_UNSPEC, socket.SOCK_STREAM):
                  if socktype == socket.SOCK_STREAM:
                      af = family
                      addr = sockaddr
                      break
              else:
                  # some OS like AIX don't indicate SOCK_STREAM support, so just guess. :(
                  af, _, _, _, addr = socket.getaddrinfo(hostname, port, socket.AF_UNSPEC, socket.SOCK_STREAM)
              sock = socket.socket(af, socket.SOCK_STREAM)
              if timeout is not None:
                  try:
                      sock.settimeout(timeout)
                  except:
                      pass
              retry_on_signal(lambda: sock.connect(addr))
  
          t = self._transport = Transport(sock)
          t.use_compression(compress=compress)
          if self._log_channel is not None:
              t.set_log_channel(self._log_channel)
          t.start_client()
          ResourceManager.register(self, t)
  
          server_key = t.get_remote_server_key()
          keytype = server_key.get_name()
  
          if port == SSH_PORT:
              server_hostkey_name = hostname
          else:
              server_hostkey_name = "[%s]:%d" % (hostname, port)
          our_server_key = self._system_host_keys.get(server_hostkey_name, {}).get(keytype, None)
          if our_server_key is None:
              our_server_key = self._host_keys.get(server_hostkey_name, {}).get(keytype, None)
          if our_server_key is None:
              # will raise exception if the key is rejected; let that fall out
              self._policy.missing_host_key(self, server_hostkey_name, server_key)
              # if the callback returns, assume the key is ok
              our_server_key = server_key
  
          if server_key != our_server_key:
              raise BadHostKeyException(hostname, server_key, our_server_key)
  
          if username is None:
              username = getpass.getuser()
  
          if key_filename is None:
              key_filenames = []
          elif isinstance(key_filename, string_types):
              key_filenames = [key_filename]
          else:
              key_filenames = key_filename
          self._auth(username, password, pkey, key_filenames, allow_agent, look_for_keys)