docs: def connect(self, host, port):
          '''
          Connect to a host and port.
          '''
          # Clear the connect state immediately since we're no longer connected
          # at this point.
          self._connected = False
  
          # Only after the socket has connected do we clear this state; closed
          # must be False so that writes can be buffered in writePacket(). The
          # closed state might have been set to True due to a socket error or a
          # redirect.
          self._host = "%s:%d" % (host, port)
          self._closed = False
          self._close_info = {
              'reply_code': 0,
              'reply_text': 'failed to connect to %s' % (self._host),
              'class_id': 0,
              'method_id': 0
          }
  
          self._transport.connect((host, port))
          self._transport.write(PROTOCOL_HEADER)
  
          self._last_octet_time = time.time()
  
          if self._synchronous_connect:
              # Have to queue this callback just after connect, it can't go
              # into the constructor because the channel needs to be
              # "always there" for frame processing, but the synchronous
              # callback can't be added until after the protocol header has
              # been written. This SHOULD be registered before the protocol
              # header is written, in the case where the header bytes are
              # written, but this thread/greenlet/context does not return until
              # after another thread/greenlet/context has read and processed the
              # recv_start frame. Without more re-write to add_sync_cb though,
              # it will block on reading responses that will never arrive
              # because the protocol header isn't written yet. TBD if needs
              # refactoring. Could encapsulate entirely here, wherein
              # read_frames exits if protocol header not yet written. Like other
              # synchronous behaviors, adding this callback will result in a
              # blocking frame read and process loop until _recv_start and any
              # subsequent synchronous callbacks have been processed. In the
              # event that this is /not/ a synchronous transport, but the
              # caller wants the connect to be synchronous so as to ensure that
              # the connection is ready, then do a read frame loop here.
              self._channels[0].add_synchronous_cb(self._channels[0]._recv_start)
              while not self._connected:
                  self.read_frames()