docs: def search(query, tld='com', lang='en', num=10, start=0, stop=None, pause=2.0,
             only_standard=False):
      """
      Search the given query string using Google.
  
      @type  query: str
      @param query: Query string. Must NOT be url-encoded.
  
      @type  tld: str
      @param tld: Top level domain.
  
      @type  lang: str
      @param lang: Languaje.
  
      @type  num: int
      @param num: Number of results per page.
  
      @type  start: int
      @param start: First result to retrieve.
  
      @type  stop: int
      @param stop: Last result to retrieve.
          Use C{None} to keep searching forever.
  
      @type  pause: float
      @param pause: Lapse to wait between HTTP requests.
          A lapse too long will make the search slow, but a lapse too short may
          cause Google to block your IP. Your mileage may vary!
  
      @type  only_standard: bool
      @param only_standard: If C{True}, only returns the standard results from
          each page. If C{False}, it returns every possible link from each page,
          except for those that point back to Google itself. Defaults to C{False}
          for backwards compatibility with older versions of this module.
  
      @rtype:  generator
      @return: Generator (iterator) that yields found URLs. If the C{stop}
          parameter is C{None} the iterator will loop forever.
      """
  
      # Lazy import of BeautifulSoup.
      # Try to use BeautifulSoup 4 if available, fall back to 3 otherwise.
      global BeautifulSoup
      if BeautifulSoup is None:
          try:
              from bs4 import BeautifulSoup
          except ImportError:
              from BeautifulSoup import BeautifulSoup
  
      # Set of hashes for the results found.
      # This is used to avoid repeated results.
      hashes = set()
  
      # Prepare the search string.
      query = quote_plus(query)
  
      # Grab the cookie from the home page.
      get_page(url_home % vars())
  
      # Prepare the URL of the first request.
      if start:
          if num == 10:
              url = url_next_page % vars()
          else:
              url = url_next_page_num % vars()
      else:
          if num == 10:
              url = url_search % vars()
          else:
              url = url_search_num % vars()
  
      # Loop until we reach the maximum result, if any (otherwise, loop forever).
      while not stop or start < stop:
  
          # Sleep between requests.
          time.sleep(pause)
  
          # Request the Google Search results page.
          html = get_page(url)
  
          # Parse the response and process every anchored URL.
          soup = BeautifulSoup(html)
          anchors = soup.find(id='search').findAll('a')
          for a in anchors:
  
              # Leave only the "standard" results if requested.
              # Otherwise grab all possible links.
              if only_standard and (
                          not a.parent or a.parent.name.lower() != "h3"):
                  continue
  
              # Get the URL from the anchor tag.
              try:
                  link = a['href']
              except KeyError:
                  continue
  
              # Filter invalid links and links pointing to Google itself.
              link = filter_result(link)
              if not link:
                  continue
  
              # Discard repeated results.
              h = hash(link)
              if h in hashes:
                  continue
              hashes.add(h)
  
              # Yield the result.
              yield link
  
          # End if there are no more results.
          if not soup.find(id='nav'):
              break
  
          # Prepare the URL for the next request.
          start += num
          if num == 10:
              url = url_next_page % vars()
          else:
              url = url_next_page_num % vars()