code: def connect(self):
          
          device = None
          # logger.debug("Connecting to: {}".format(str(self)))
          for device in self.devices:
              if not device.connected:
                  self.connection.emit_message("Connecting {}".format(str(device)), log_level=logging.INFO)
                  protocol_name = device.get_protocol_name()
                  device.protocol = make_protocol(protocol_name, device)
                  command = device.protocol.get_command()
                  self.ctrl.spawn_session(command=command)
                  try:
                      result = device.connect(self.ctrl)
                  except CommandSyntaxError as exc:
                      # all commands during discovery provides itself in exception except
                      # spawn session which is handled differently. If command syntax error is detected during spawning
                      # a new session then the problem is either on jumphost or csm server.
                      # The problem with spawning session is detected in connect FSM for telnet and ssh.
                      if exc.command:
                          cmd = exc.command
                          host = device.hostname
                      else:
                          cmd = command
                          host = "Jumphost/CSM"
  
                      self.connection.log(
                          "Command not supported or not authorized on {}: '{}'".format(host, cmd))
                      raise CommandError(message="Command not supported or not authorized",
                                         command=cmd,
                                         host=host)
  
                  if result:
                      # logger.info("Connected to {}".format(device))
                      self.connection.emit_message("Connected {}".format(device), log_level=logging.INFO)
                  else:
                      if device.last_error_msg:
                          message = device.last_error_msg
                          device.last_error_msg = None
                      else:
                          message = "Connection error"
  
                      self.connection.log(message)
                      raise ConnectionError(message)  # , host=str(device))
  
          if device is None:
              raise ConnectionError("No devices")
  
          return True
docs: Connect to the target device using the intermediate jumphosts.