code: def read_until_regex(self, regex: bytes, max_bytes: int = None) -> Awaitable[bytes]:
          
          future = self._start_read()
          self._read_regex = re.compile(regex)
          self._read_max_bytes = max_bytes
          try:
              self._try_inline_read()
          except UnsatisfiableReadError as e:
              # Handle this the same way as in _handle_events.
              gen_log.info("Unsatisfiable read, closing connection: %s" % e)
              self.close(exc_info=e)
              return future
          except:
              # Ensure that the future doesn't log an error because its
              # failure was never examined.
              future.add_done_callback(lambda f: f.exception())
              raise
          return future
docs: Asynchronously read until we have matched the given regex.
  
          The result includes the data that matches the regex and anything
          that came before it.
  
          If ``max_bytes`` is not None, the connection will be closed
          if more than ``max_bytes`` bytes have been read and the regex is
          not satisfied.
  
          .. versionchanged:: 4.0
              Added the ``max_bytes`` argument.  The ``callback`` argument is
              now optional and a `.Future` will be returned if it is omitted.
  
          .. versionchanged:: 6.0
  
             The ``callback`` argument was removed. Use the returned
             `.Future` instead.