docs: async def edit_2fa(
              self, current_password=None, new_password=None,
              *, hint='', email=None, email_code_callback=None):
          """
          Changes the 2FA settings of the logged in user, according to the
          passed parameters. Take note of the parameter explanations.
  
          Note that this method may be *incredibly* slow depending on the
          prime numbers that must be used during the process to make sure
          that everything is safe.
  
          Has no effect if both current and new password are omitted.
  
          current_password (`str`, optional):
              The current password, to authorize changing to ``new_password``.
              Must be set if changing existing 2FA settings.
              Must **not** be set if 2FA is currently disabled.
              Passing this by itself will remove 2FA (if correct).
  
          new_password (`str`, optional):
              The password to set as 2FA.
              If 2FA was already enabled, ``current_password`` **must** be set.
              Leaving this blank or ``None`` will remove the password.
  
          hint (`str`, optional):
              Hint to be displayed by Telegram when it asks for 2FA.
              Leaving unspecified is highly discouraged.
              Has no effect if ``new_password`` is not set.
  
          email (`str`, optional):
              Recovery and verification email. If present, you must also
              set `email_code_callback`, else it raises ``ValueError``.
  
          email_code_callback (`callable`, optional):
              If an email is provided, a callback that returns the code sent
              to it must also be set. This callback may be asynchronous.
              It should return a string with the code. The length of the
              code will be passed to the callback as an input parameter.
  
              If the callback returns an invalid code, it will raise
              ``CodeInvalidError``.
  
          Returns:
              ``True`` if successful, ``False`` otherwise.
          """
          if new_password is None and current_password is None:
              return False
  
          if email and not callable(email_code_callback):
              raise ValueError('email present without email_code_callback')
  
          pwd = await self(functions.account.GetPasswordRequest())
          pwd.new_algo.salt1 += os.urandom(32)
          assert isinstance(pwd, types.account.Password)
          if not pwd.has_password and current_password:
              current_password = None
  
          if current_password:
              password = pwd_mod.compute_check(pwd, current_password)
          else:
              password = types.InputCheckPasswordEmpty()
  
          if new_password:
              new_password_hash = pwd_mod.compute_digest(
                  pwd.new_algo, new_password)
          else:
              new_password_hash = b''
  
          try:
              await self(functions.account.UpdatePasswordSettingsRequest(
                  password=password,
                  new_settings=types.account.PasswordInputSettings(
                      new_algo=pwd.new_algo,
                      new_password_hash=new_password_hash,
                      hint=hint,
                      email=email,
                      new_secure_settings=None
                  )
              ))
          except errors.EmailUnconfirmedError as e:
              code = email_code_callback(e.code_length)
              if inspect.isawaitable(code):
                  code = await code
  
              code = str(code)
              await self(functions.account.ConfirmPasswordEmailRequest(code))
  
          return True