code: def start_client(self, event=None, timeout=None):
          
          self.active = True
          if event is not None:
              # async, return immediately and let the app poll for completion
              self.completion_event = event
              self.start()
              return
  
          # synchronous, wait for a result
          self.completion_event = event = threading.Event()
          self.start()
          max_time = time.time() + timeout if timeout is not None else None
          while True:
              event.wait(0.1)
              if not self.active:
                  e = self.get_exception()
                  if e is not None:
                      raise e
                  raise SSHException("Negotiation failed.")
              if event.is_set() or (
                  timeout is not None and time.time() >= max_time
              ):
                  break
docs: Negotiate a new SSH2 session as a client.  This is the first step after
          creating a new `.Transport`.  A separate thread is created for protocol
          negotiation.
  
          If an event is passed in, this method returns immediately.  When
          negotiation is done (successful or not), the given ``Event`` will
          be triggered.  On failure, `is_active` will return ``False``.
  
          (Since 1.4) If ``event`` is ``None``, this method will not return until
          negotiation is done.  On success, the method returns normally.
          Otherwise an SSHException is raised.
  
          After a successful negotiation, you will usually want to authenticate,
          calling `auth_password <Transport.auth_password>` or
          `auth_publickey <Transport.auth_publickey>`.
  
          .. note:: `connect` is a simpler method for connecting as a client.
  
          .. note::
              After calling this method (or `start_server` or `connect`), you
              should no longer directly read from or write to the original socket
              object.
  
          :param .threading.Event event:
              an event to trigger when negotiation is complete (optional)
  
          :param float timeout:
              a timeout, in seconds, for SSH2 session negotiation (optional)
  
          :raises:
              `.SSHException` -- if negotiation fails (and no ``event`` was
              passed in)