docs: async def connect(
          self,
          hostname: str = None,
          port: int = None,
          source_address: DefaultStrType = _default,
          timeout: DefaultNumType = _default,
          loop: asyncio.AbstractEventLoop = None,
          use_tls: bool = None,
          validate_certs: bool = None,
          client_cert: DefaultStrType = _default,
          client_key: DefaultStrType = _default,
          tls_context: DefaultSSLContextType = _default,
          cert_bundle: DefaultStrType = _default,
      ) -> SMTPResponse:
          """
          Initialize a connection to the server. Options provided to
          :meth:`.connect` take precedence over those used to initialize the
          class.
  
          :keyword hostname:  Server name (or IP) to connect to
          :keyword port: Server port. Defaults to 25 if ``use_tls`` is
              False, 465 if ``use_tls`` is True.
          :keyword source_address: The hostname of the client. Defaults to the
              result of :func:`socket.getfqdn`. Note that this call blocks.
          :keyword timeout: Default timeout value for the connection, in seconds.
              Defaults to 60.
          :keyword loop: event loop to run on. If not set, uses
              :func:`asyncio.get_event_loop()`.
          :keyword use_tls: If True, make the initial connection to the server
              over TLS/SSL. Note that if the server supports STARTTLS only, this
              should be False.
          :keyword validate_certs: Determines if server certificates are
              validated. Defaults to True.
          :keyword client_cert: Path to client side certificate, for TLS.
          :keyword client_key: Path to client side key, for TLS.
          :keyword tls_context: An existing :class:`ssl.SSLContext`, for TLS.
              Mutually exclusive with ``client_cert``/``client_key``.
          :keyword cert_bundle: Path to certificate bundle, for TLS verification.
  
          :raises ValueError: mutually exclusive options provided
          """
          await self._connect_lock.acquire()
  
          if hostname is not None:
              self.hostname = hostname
          if loop is not None:
              self.loop = loop
          if use_tls is not None:
              self.use_tls = use_tls
          if validate_certs is not None:
              self.validate_certs = validate_certs
  
          if port is not None:
              self.port = port
  
          if self.port is None:
              self.port = SMTP_TLS_PORT if self.use_tls else SMTP_PORT
  
          if timeout is not _default:
              self.timeout = timeout  # type: ignore
          if source_address is not _default:
              self._source_address = source_address  # type: ignore
          if client_cert is not _default:
              self.client_cert = client_cert  # type: ignore
          if client_key is not _default:
              self.client_key = client_key  # type: ignore
          if tls_context is not _default:
              self.tls_context = tls_context  # type: ignore
          if cert_bundle is not _default:
              self.cert_bundle = cert_bundle  # type: ignore
  
          if self.tls_context is not None and self.client_cert is not None:
              raise ValueError(
                  "Either a TLS context or a certificate/key must be provided"
              )
  
          response = await self._create_connection()
  
          return response