Eine Suchmaschine

Lege neben search.rb eine neue Datei webcrawler.rb an:

require 'net/http'
require 'uri'

# Wer der Crawler ist; viele Websites schreiben das in ihr Protokoll
USER_AGENT = 'Hackschule-Crawler (Informatikkurs, Hackschule Workspace)'
# Höchstens so viele Seiten, und so viele Sekunden Pause vor jeder
MAX_PAGES = 30
PAUSE = 1

# Die Ziele aller Links einer Seite, so wie sie im HTML stehen
def href_targets(html)
  html.scan(/<a\s[^>]*?href\s*=\s*["']([^"']*)["']/i).flatten
end

# Was robots.txt allen Crawlern verbietet (User-agent: *), als Liste von
# Anfängen von Pfaden; vereinfacht, RFC 9309 kennt noch mehr
def robots_rules(text)
  rules = []
  applies = false
  text.each_line do |line|
    key, value = line.sub(/#.*/, '').split(':', 2).map(&:strip)
    next if value.nil?

    case key.downcase
    when 'user-agent' then applies = (value == '*')
    when 'disallow' then rules << value if applies && !value.empty?
    end
  end
  rules
end

# Eine Anfrage mit dem User-Agent des Crawlers
def get(url)
  uri = URI(url)
  Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https',
                  open_timeout: 10, read_timeout: 10) do |http|
    http.get(uri.request_uri, 'User-Agent' => USER_AGENT)
  end
end

# robots.txt der Website, oder nichts, wenn es keine gibt
def fetch_robots(start)
  response = get(URI.join(start, '/robots.txt').to_s)
  response.is_a?(Net::HTTPSuccess) ? response.body.force_encoding('UTF-8').scrub : ''
rescue StandardError
  ''
end

# Eine HTML-Seite als [Adresse, HTML], oder nil; folgt Weiterleitungen,
# solange sie auf derselben Website bleiben
def fetch_url(url)
  host = URI(url).host
  5.times do
    response = get(url)
    if response.is_a?(Net::HTTPRedirection)
      url = URI.join(url, response['location']).to_s
      return nil unless URI(url).host == host

      next
    end
    return nil unless response.is_a?(Net::HTTPSuccess) && response['content-type'].to_s.start_with?('text/html')

    return [url, response.body.force_encoding('UTF-8').scrub]
  end
  nil
rescue StandardError
  nil
end

# Höchstens max_pages Seiten der Website von start, mit Pause und nach
# robots.txt, als Hash von Adresse zu HTML
def polite_crawl(start, max_pages = MAX_PAGES)
  rules = robots_rules(fetch_robots(start))
  puts "robots.txt verbietet: #{rules.empty? ? 'nichts' : rules.join(', ')}"
  pages = {}
  queue = [start]
  seen = [start]
  until queue.empty? || pages.size >= max_pages
    url = queue.shift
    unless allowed?(rules, URI(url).request_uri)
      puts "übersprungen: #{url}"
      next
    end
    sleep PAUSE
    found = fetch_url(url)
    next if found.nil?

    address, html = found
    puts "geholt: #{address}"
    pages[address] = html
    absolute_links(html, address).each do |link|
      next if seen.include?(link)

      seen << link
      queue << link
    end
  end
  pages
end

• href_targets findet das Ziel jedes Links, so wie es im HTML steht, auch in einfachen Anführungszeichen.
• get schickt eine Anfrage mit dem User-Agent des Crawlers; nach zehn Sekunden ohne Antwort gibt sie auf.
• fetch_url holt eine Seite. Leitet der Server weiter, etwa von http auf https, folgt sie, solange die Weiterleitung auf derselben Website bleibt. Ist die Antwort keine HTML-Seite, sondern ein Bild oder ein PDF, oder lehnt der Server ab, gibt sie nil zurück, und der Crawler macht mit der nächsten Adresse weiter.
• polite_crawl ist dein crawl, nur mit ganzen Adressen statt Pfaden, mit der Pause und der Grenze, und mit den Regeln aus robots.txt. Zwei Funktionen, die es aufruft, fehlen noch: absolute_links und allowed?.

Lege neben search.py eine neue Datei webcrawler.py an:

import re
import time
import urllib.error
import urllib.request
from urllib.parse import urldefrag, urljoin, urlparse

# Wer der Crawler ist; viele Websites schreiben das in ihr Protokoll
USER_AGENT = 'Hackschule-Crawler (Informatikkurs, Hackschule Workspace)'
# Höchstens so viele Seiten, und so viele Sekunden Pause vor jeder
MAX_PAGES = 30
PAUSE = 1


def href_targets(html):
    """Die Ziele aller Links einer Seite, so wie sie im HTML stehen"""
    return re.findall(r'<a\s[^>]*?href\s*=\s*["\']([^"\']*)["\']', html, re.IGNORECASE)


def robots_rules(text):
    """Was robots.txt allen Crawlern verbietet (User-agent: *), als Liste von
    Anfängen von Pfaden; vereinfacht, RFC 9309 kennt noch mehr"""
    rules = []
    applies = False
    for line in text.splitlines():
        line = line.split('#', 1)[0]
        if ':' not in line:
            continue
        key, value = (part.strip() for part in line.split(':', 1))
        if key.lower() == 'user-agent':
            applies = value == '*'
        elif key.lower() == 'disallow' and applies and value:
            rules.append(value)
    return rules


def get(url):
    """Eine Anfrage mit dem User-Agent des Crawlers"""
    request = urllib.request.Request(url, headers={'User-Agent': USER_AGENT})
    return urllib.request.urlopen(request, timeout=10)


def fetch_robots(start):
    """robots.txt der Website, oder nichts, wenn es keine gibt"""
    try:
        with get(urljoin(start, '/robots.txt')) as response:
            return response.read().decode('utf-8', errors='replace')
    except Exception:
        return ''


def fetch_url(url):
    """Eine HTML-Seite als (Adresse, HTML), oder None; urlopen folgt
    Weiterleitungen, die Seite muss aber auf derselben Website bleiben"""
    try:
        with get(url) as response:
            address = response.geturl()
            if urlparse(address).netloc != urlparse(url).netloc:
                return None
            if response.headers.get_content_type() != 'text/html':
                return None
            return address, response.read().decode('utf-8', errors='replace')
    except Exception:
        return None


def request_path(url):
    """Der Pfad einer Adresse mit dem Teil hinter ?, wie robots.txt ihn meint"""
    parts = urlparse(url)
    return (parts.path or '/') + ('?' + parts.query if parts.query else '')


def polite_crawl(start, max_pages=MAX_PAGES):
    """Höchstens max_pages Seiten der Website von start, mit Pause und nach
    robots.txt, als dict von Adresse zu HTML"""
    rules = robots_rules(fetch_robots(start))
    print('robots.txt verbietet:', ', '.join(rules) if rules else 'nichts')
    pages = {}
    queue = [start]
    seen = [start]
    while queue and len(pages) < max_pages:
        url = queue.pop(0)
        if not allowed(rules, request_path(url)):
            print('übersprungen:', url)
            continue
        time.sleep(PAUSE)
        found = fetch_url(url)
        if found is None:
            continue
        address, html = found
        print('geholt:', address)
        pages[address] = html
        for link in absolute_links(html, address):
            if link not in seen:
                seen.append(link)
                queue.append(link)
    return pages

• href_targets findet das Ziel jedes Links, so wie es im HTML steht, auch in einfachen Anführungszeichen.
• get schickt eine Anfrage mit dem User-Agent des Crawlers; nach zehn Sekunden ohne Antwort gibt sie auf.
• fetch_url holt eine Seite. Leitet der Server weiter, etwa von http auf https, folgt urlopen der Weiterleitung; die Seite muss aber auf derselben Website bleiben. Ist die Antwort keine HTML-Seite, sondern ein Bild oder ein PDF, oder lehnt der Server ab, gibt sie None zurück, und der Crawler macht mit der nächsten Adresse weiter.
• polite_crawl ist dein crawl, nur mit ganzen Adressen statt Pfaden, mit der Pause und der Grenze, und mit den Regeln aus robots.txt. Zwei Funktionen, die es aufruft, fehlen noch: absolute_links und allowed.

Das Rechnen nimmt dir URI.join ab:

URI.join('https://schule.example/tiere/katze.html', 'hund.html').to_s
# => "https://schule.example/tiere/hund.html"

Ein URI kennt die Teile einer Adresse: scheme ("https"), host ("schule.example"), port und fragment, das, was hinter # steht.

# Die Links einer Seite als ganze Adressen, nur auf ihrer eigenen Website,
# ohne #…, jede nur einmal; base ist die Adresse der Seite
def absolute_links(html, base)
  base_uri = URI(base)
  result = []
  href_targets(html).each do |target|
    uri = (URI.join(base, target) rescue nil)
    next if uri.nil?
    next unless %w[http https].include?(uri.scheme)
    next unless uri.host == base_uri.host && uri.port == base_uri.port

    uri.fragment = nil
    url = uri.to_s
    result << url unless result.include?(url)
  end
  result
end

Das Rechnen nimmt dir urljoin ab, das Abschneiden von #… urldefrag:

urljoin('https://schule.example/tiere/katze.html', 'hund.html')
# 'https://schule.example/tiere/hund.html'
urldefrag('https://schule.example/index.html#oben')[0]
# 'https://schule.example/index.html'

urlparse(url) zerlegt eine Adresse in ihre Teile: .scheme ist 'https', .netloc der Host, mit Port, wenn einer dasteht.

def absolute_links(html, base):
    """Die Links einer Seite als ganze Adressen, nur auf ihrer eigenen Website,
    ohne #…, jede nur einmal; base ist die Adresse der Seite"""
    result = []
    for target in href_targets(html):
        url = urldefrag(urljoin(base, target))[0]
        parts = urlparse(url)
        if parts.scheme not in ('http', 'https') or parts.netloc != urlparse(base).netloc:
            continue
        if url not in result:
            result.append(url)
    return result

Pythons Standardbibliothek liest die ganze Datei mit urllib.robotparser.

Das Programm dazu kommt in web.rb. Ohne Adresse fängt es beim Tierlexikon an:

require_relative 'webcrawler'

start = ARGV[0] || 'http://localhost:8000/index.html'
pages = polite_crawl(start)
puts "#{pages.size} Seiten geholt"

Starte es, während der Webserver im zweiten Terminal läuft:

ruby web.rb

Das Programm dazu kommt in web.py. Ohne Adresse fängt es beim Tierlexikon an:

import sys

from webcrawler import *

start = sys.argv[1] if len(sys.argv) > 1 else 'http://localhost:8000/index.html'
pages = polite_crawl(start)
print(f'{len(pages)} Seiten geholt')

Starte es, während der Webserver im zweiten Terminal läuft:

python3 web.py

Dann bekommt web.rb die Startseite der Website:

ruby web.rb https://www.beispiel-schule.de/

Dann bekommt web.py die Startseite der Website:

python3 web.py https://www.beispiel-schule.de/