docs: def is_valid(url, fix=True):
      """ Returns True if this is what we consider to be a valid URL.
  
          A valid URL has:
              * http OR https scheme
              * a valid TLD
  
          If there is no scheme, it will check the URL assuming the scheme is http.
  
          Returns False if the URL is not valid.
      """
  
      try:
          # Convert the url to a string if we were given it as bytes.
          if isinstance(url, bytes):
              url = url.decode('ascii', errors='replace')
  
          # Hacky way to deal with URLs that have a username:password notation.
          user_pass_url = ''
  
          # Check for no scheme and assume http.
          split_url = urlsplit(url)
  
          # If there is no scheme, there is a higher chance that this might not actually be a URL.
          # For example, it might be something that resembles a URL that got pulled out of random bytes.
          # As such, we can probably safely exclude URLs that have unusual characters in them.
          if not split_url.scheme:
              invalid_chars = ['\'']
              if any(c in url for c in invalid_chars):
                  return False
  
          # Append the http scheme to the URL if it doesn't have any scheme.
          if fix and not split_url.scheme:
              split_url = urlsplit('http://{}'.format(url))
  
          # Check for the edge case of results returned by find_urls, such as google.com URLs
          # like: http://google.com#default#userData
          if split_url.netloc and not split_url.path and split_url.fragment:
              return False
  
          # Check if the netloc has a ':' in it, which indicates that
          # there is a port number specified. We need to remove that in order
          # to properly check if it is a valid IP address.
          if ':' in split_url.netloc:
              netloc = split_url.netloc.split(':')[0]
          else:
              netloc = split_url.netloc
  
          # Make sure the URL doesn't have a \ character in it.
          if '\\' in url:
              return False
  
          # Some quick and dirty tests to detect invalid characters from different parts of the URL.
          # Domain names need to have only: a-z, 0-9, -, and . But due to how urlsplit works, they
          # might also contain : and @ if there is a user/pass or port number specified.
          if re.compile(r'([^a-zA-Z0-9\-\.\:\@]+)').findall(split_url.netloc):
              return False
  
          # Check if the valid URL conditions are now met.
          if split_url.scheme == 'http' or split_url.scheme == 'https' or split_url.scheme == 'ftp':
  
              # Look for the edge case of the URL having a username:password notation.
              if ':' in split_url.netloc and '@' in split_url.netloc:
                  user_pass = re.compile(r'(.*?:.*?@)').findall(split_url.netloc)[0]
                  user_pass_url = url.replace(user_pass, '')
                  split_url = urlsplit(user_pass_url)
                  netloc = split_url.netloc
  
              # Check the netloc. Check if it is an IP address.
              try:
                  ipaddress.ip_address(netloc)
                  return True
              # If we got an exception, it must be a domain name.
              except:
  
                  # Hacky way to out which version of the URL we need to check.
                  if user_pass_url:
                      url_to_check = user_pass_url
                  else:
                      url_to_check = url
  
                  # Hacky way to deal with FTP URLs since the tld package cannot handle them.
                  if split_url.scheme == 'ftp':
                      url_to_check = url_to_check.replace('ftp', 'http')
  
                  # Check the URL for a valid TLD.
                  res = get_tld(url_to_check, fix_protocol=True, as_object=True)
  
                  # The tld package likes to consider single words (like "is") as a valid domain. To fix this,
                  # we want to only consider it a valid URL if there is actually a suffix. Additionally, to weed
                  # out "URLs" that are probably e-mail addresses or other garbage, we do not want to consider
                  # anything that has invalid characters in it.
                  if res.fld and res.tld and res.domain:
                      if all(ord(c) == 45 or ord(c) == 46 or (48 <= ord(c) <= 57) or (65 <= ord(c) <= 90) or (97 <= ord(c) <= 122) for c in netloc):
  
                          # Finally, check if all of the characters in the URL are ASCII.
                          if all(32 <= ord(c) <= 126 for c in url):
                              return True
  
          # Return False by default.
          return False
      except:
          return False