docs: async def connect(self, server_info, proto_code=None, *,
                              use_tor=False, disable_cert_verify=False,
                              proxy=None, short_term=False):
          '''
              Start connection process.
              Destination must be specified in a ServerInfo() record (first arg).
          '''
          self.server_info = server_info
          if not proto_code:
               proto_code,*_ = server_info.protocols
          self.proto_code = proto_code
  
          logger.debug("Connecting to: %r" % server_info)
  
          if proto_code == 'g':       # websocket
              # to do this, we'll need a websockets implementation that
              # operates more like a asyncio.Transport
              # maybe: `asyncws` or `aiohttp` 
              raise NotImplementedError('sorry no WebSocket transport yet')
  
          hostname, port, use_ssl = server_info.get_port(proto_code)
  
          if use_tor:
              if have_aiosocks:
                  # Connect via Tor proxy proxy, assumed to be on localhost:9050
                  # unless a tuple is given with another host/port combo.
                  try:
                      socks_host, socks_port = use_tor
                  except TypeError:
                      socks_host, socks_port = 'localhost', 9050
  
                  # basically no-one has .onion SSL certificates, and
                  # pointless anyway.
                  disable_cert_verify = True
  
                  assert not proxy, "Sorry not yet supporting proxy->tor->dest"
  
                  logger.debug(" .. using TOR")
  
                  proxy = aiosocks.Socks5Addr(socks_host, int(socks_port))
              else:
                  logger.debug("Error: want to use tor, but no aiosocks module.")
  
          if use_ssl == True and disable_cert_verify:
              # Create a more liberal SSL context that won't
              # object to self-signed certicates. This is 
              # very bad on public Internet, but probably ok
              # over Tor
              use_ssl = ssl.create_default_context()
              use_ssl.check_hostname = False
              use_ssl.verify_mode = ssl.CERT_NONE
  
              logger.debug(" .. SSL cert check disabled")
  
          async def _reconnect():
              if self.protocol: return        # race/duplicate work
  
              if proxy:
                  if have_aiosocks:
                      transport, protocol = await aiosocks.create_connection(
                                              StratumProtocol, proxy=proxy,
                                              proxy_auth=None,
                                              remote_resolve=True, ssl=use_ssl,
                                              dst=(hostname, port))
                  else:
                      logger.debug("Error: want to use proxy, but no aiosocks module.")
              else:
                  transport, protocol = await self.loop.create_connection(
                                                          StratumProtocol, host=hostname,
                                                          port=port, ssl=use_ssl)
  
              self.protocol = protocol
              protocol.client = self
  
              # capture actual values used
              self.actual_connection = dict(hostname=hostname, port=int(port),
                                              ssl=bool(use_ssl), tor=bool(proxy))
              self.actual_connection['ip_addr'] = transport.get_extra_info('peername',
                                                          default=['unknown'])[0]
  
              if not short_term:
                  self.ka_task = self.loop.create_task(self._keepalive())
  
              logger.debug("Connected to: %r" % server_info)
  
          # close whatever we had
          if self.protocol:
              self.protocol.close()
              self.protocol = None
  
          self.reconnect = _reconnect
          await self.reconnect()