| import threading |
| import time |
| import urllib.robotparser |
| from urllib.parse import urlsplit |
|
|
| import httpx |
|
|
| USER_AGENT = "Dutch-GOV-Datasets (+https://github.com/ethux/Dutch-GOV-Datasets)" |
| RETRY_STATUS = {429, 500, 502, 503, 504} |
|
|
|
|
| class FetchError(Exception): |
| pass |
|
|
|
|
| class RateLimiter: |
| """Spaces calls at least 1/per_second apart, across threads.""" |
|
|
| def __init__(self, per_second: float): |
| self.interval = 1.0 / per_second |
| self.lock = threading.Lock() |
| self.next_at = 0.0 |
|
|
| def wait(self) -> None: |
| with self.lock: |
| now = time.monotonic() |
| at = max(now, self.next_at) |
| self.next_at = at + self.interval |
| time.sleep(max(0.0, at - now)) |
|
|
|
|
| class Fetcher: |
| def __init__( |
| self, |
| per_second: float, |
| *, |
| max_retries: int = 5, |
| backoff: float = 2.0, |
| robots_exempt: set[str] = frozenset(), |
| transport: httpx.BaseTransport | None = None, |
| ): |
| self.client = httpx.Client( |
| headers={"User-Agent": USER_AGENT, "Accept": "application/xml, text/html;q=0.9, */*;q=0.8"}, |
| timeout=120, |
| follow_redirects=True, |
| transport=transport, |
| ) |
| self.limiter = RateLimiter(per_second) |
| self.max_retries = max_retries |
| self.backoff = backoff |
| self.robots_exempt = set(robots_exempt) |
| self._robots: dict[str, urllib.robotparser.RobotFileParser] = {} |
| self._robots_lock = threading.Lock() |
|
|
| def allowed(self, url: str) -> bool: |
| parts = urlsplit(url) |
| if parts.hostname in self.robots_exempt: |
| return True |
| origin = f"{parts.scheme}://{parts.netloc}" |
| with self._robots_lock: |
| rp = self._robots.get(origin) |
| if rp is None: |
| rp = urllib.robotparser.RobotFileParser() |
| try: |
| r = self.client.get(origin + "/robots.txt") |
| rp.parse(r.text.splitlines() if r.status_code == 200 else []) |
| except httpx.HTTPError: |
| rp.parse([]) |
| self._robots[origin] = rp |
| return rp.can_fetch(USER_AGENT, url) |
|
|
| def get(self, url: str) -> httpx.Response: |
| if not self.allowed(url): |
| raise FetchError(f"disallowed by robots.txt: {url}") |
| last = "" |
| for attempt in range(self.max_retries + 1): |
| self.limiter.wait() |
| try: |
| r = self.client.get(url) |
| except httpx.TransportError as e: |
| last = repr(e) |
| except httpx.HTTPError as e: |
| raise FetchError(f"{e!r}: {url}") from e |
| else: |
| if r.status_code == 200: |
| return r |
| if r.status_code not in RETRY_STATUS: |
| raise FetchError(f"HTTP {r.status_code}: {url}") |
| last = f"HTTP {r.status_code}" |
| if attempt < self.max_retries: |
| time.sleep(self.backoff**attempt if self.backoff else 0) |
| raise FetchError(f"gave up after {self.max_retries} retries ({last}): {url}") |
|
|
