Add detailed dataset card and the scraping pipeline used to build it

README.md

@@ -1,4 +1,41 @@
 ---
+language:
+- en
+pretty_name: POLITICO Europe (politico.eu)
+size_categories:
+- 100K<n<1M
+task_categories:
+- text-generation
+- text-classification
+- summarization
+- feature-extraction
+tags:
+- brussels
+- english
+- eu-affairs
+- journalism
+- media
+- media-bias
+- news
+- news-articles
+- policy-journalism
+- political-news
+- research-only
+- text-and-data-mining
+- web-scraping
+annotations_creators:
+- no-annotation
+language_creators:
+- found
+multilinguality:
+- monolingual
+source_datasets:
+- original
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*
 dataset_info:
   features:
   - name: title
@@ -31,17 +68,375 @@ dataset_info:
     num_examples: 122268
   download_size: 420200866
   dataset_size: 715885507
-configs:
-- config_name: default
-  data_files:
-  - split: train
-    path: data/train-*
-language:
-- en
-tags:
-- Newspaper
-- Europe
-- Politics
-size_categories:
-- 100K<n<1M
 ---
+
+# POLITICO Europe (politico.eu)
+
+**122 268 English-language news articles** crawled from
+[`www.politico.eu`](https://www.politico.eu/) and published as a Hugging Face dataset.
+This is part of the [International Newspapers collection](https://huggingface.co/collections/SinclairSchneider/international-newspapers-6900fdd5083089f336574c82),
+a set of comparable corpora covering English-language newspapers and EU-affairs outlets, all built with the same crawler and the same
+extraction pipeline so that they can be compared and combined directly.
+
+> ## ⚠️ For scientific research only
+>
+> This corpus is published **exclusively for scientific research** under the German
+> research exception for text and data mining — the *Forschungsprivileg* of
+> **§ 60d UrhG** (implementing Art. 3 of EU Directive 2019/790). The article texts remain
+> the copyright of their publisher and are **not** licensed for commercial use,
+> redistribution, or republication. By downloading it you confirm that you use it for
+> non-commercial scientific research. See [Licensing and intended use](#licensing-and-intended-use).
+>
+> The articles are reproduced verbatim from the publisher's website; their content expresses
+> the views of that publisher, not of the dataset author.
+
+## At a glance
+
+| | |
+|---|---|
+| **Source** | [`www.politico.eu`](https://www.politico.eu/) |
+| **Rows** | 122 268 |
+| **Columns** | 12 (`title`, `content`, `author`, `description`, `keywords`, `category`, `countries`, `dateCreated`, `datePublished`, `dateModified`, `post_id`, `url`) |
+| **Language** | English (`en`) |
+| **Split** | `train` (single split) |
+| **Format** | Parquet, 2 shards, ≈ 401 MB download / 683 MB in memory |
+| **Intended use** | Scientific research only (*Forschungsprivileg*, § 60d UrhG) |
+| **Mirror** | [`NLP-UniBW/politico_eu`](https://huggingface.co/datasets/NLP-UniBW/politico_eu) |
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("SinclairSchneider/politico_eu", split="train")
+print(ds[0]["title"])
+```
+
+## About the source
+
+[POLITICO Europe](https://www.politico.eu/) is a Brussels-based news organisation covering
+European Union politics and policy. It launched in 2015 as a joint venture between the American
+outlet POLITICO and the German publisher Axel Springer SE, which took full ownership of POLITICO
+worldwide in 2021. Its newsroom is aimed primarily at EU policy professionals — officials,
+lobbyists, diplomats and national correspondents in Brussels — and its coverage is organised
+around the Commission, Parliament and Council, national capitals, and sectoral policy beats. A large
+part of its output, the POLITICO Pro tier, is subscription-only and therefore outside this dataset.
+
+## Dataset structure
+
+Single `train` split with 122 268 rows and the following columns:
+
+| Column | Type | Description | Extracted from |
+|---|---|---|---|
+| `title` | `string` | Headline of the article. | `<meta property="og:title">` |
+| `content` | `string` | Full plain-text body of the article. | all `<p>` inside the article body container `<article class="article">`, space-joined |
+| `author` | `string` | Author(s) as published by the outlet. | the first entry of `author` in `ld+json` |
+| `description` | `string` | Teaser / meta description of the article. | `description` from `ld+json` |
+| `keywords` | `list[string]` | Topic keywords / tags assigned by the publisher. | `keywords` from `ld+json` |
+| `category` | `string` | Section the article was published in. | `articleSection` from `ld+json` |
+| `countries` | `list[string]` | — | the country tag links in `div.tags__taxonomy--country` — the EU member states the CMS associates with the article |
+| `dateCreated` | `string` | Timestamp at which the CMS record was created. | `dateCreated` from `ld+json` |
+| `datePublished` | `string` | Publication timestamp. | `datePublished` from `ld+json` |
+| `dateModified` | `string` | Timestamp of the last editorial update. | `dateModified` from `ld+json` |
+| `post_id` | `int64` | — | `post_id` from the `custom_metadata` object inside `ld+json` — POLITICO's internal article id |
+| `url` | `string` | Canonical URL the article was fetched from. | the crawled URL |
+
+### Example record
+
+```json
+{
+  "title": "Home and Away",
+  "content": "AI generated Text-to-speech Presented by Intuit By DAN BLOOM with BETHANY DAWSON PRESENTED BY  Send tips here | Subscribe for free | Listen to Playbook and view in your browser Good Monday morning. This is Dan Bloom. HOME (OFFICE) AND AWAY: Keir Starmer will spend the day in Turkey finalizing a deal to sell fighter jets — but his efforts look set to be buried (again) by a blizzard of crime, justic …",
+  "author": "Dan Bloom",
+  "description": "",
+  "keywords": [],
+  "category": "Uncategorized",
+  "countries": [],
+  "dateCreated": "2025-10-27T07:00:46Z",
+  "datePublished": "2025-10-27T07:00:46Z",
+  "dateModified": "2025-10-27T07:01:10Z",
+  "post_id": 7395360,
+  "url": "https://www.politico.eu/newsletter/london-playbook/home-and-away/"
+}
+```
+
+## Temporal coverage
+
+The `datePublished` column could be parsed for **122 268 of 122 268** rows (100.0 %). Those rows span **1995-09-20 → 2025-10-29**.
+
+| Year | Articles | |
+|---:|---:|:---|
+| 1995 | 627 | `██` |
+| 1996 | 1 873 | `█████` |
+| 1997 | 2 069 | `█████` |
+| 1998 | 2 151 | `██████` |
+| 1999 | 1 865 | `█████` |
+| 2000 | 1 720 | `█████` |
+| 2001 | 1 822 | `█████` |
+| 2002 | 2 152 | `██████` |
+| 2003 | 2 262 | `██████` |
+| 2004 | 1 954 | `█████` |
+| 2005 | 2 196 | `██████` |
+| 2006 | 2 215 | `██████` |
+| 2007 | 2 066 | `█████` |
+| 2008 | 3 070 | `████████` |
+| 2009 | 2 678 | `███████` |
+| 2010 | 2 472 | `███████` |
+| 2011 | 2 456 | `██████` |
+| 2012 | 2 389 | `██████` |
+| 2013 | 2 359 | `██████` |
+| 2014 | 3 025 | `████████` |
+| 2015 | 4 893 | `█████████████` |
+| 2016 | 8 177 | `██████████████████████` |
+| 2017 | 8 501 | `██████████████████████` |
+| 2018 | 6 830 | `██████████████████` |
+| 2019 | 5 873 | `████████████████` |
+| 2020 | 6 225 | `████████████████` |
+| 2021 | 6 589 | `█████████████████` |
+| 2022 | 6 947 | `██████████████████` |
+| 2023 | 8 098 | `█████████████████████` |
+| 2024 | 9 085 | `████████████████████████` |
+| 2025 | 7 629 | `████████████████████` |
+
+## How the data was collected
+
+The whole pipeline is contained in this repository under [`scraping/`](./scraping) and consists
+of two steps: a distributed crawler that walks the site and writes one JSON file per article, and
+a consolidation notebook that merges those files into the dataset you are reading.
+
+### 1. Crawling — [`scraping/crawler.py`](./scraping/crawler.py)
+
+The crawler is a breadth-first whole-site crawler built on
+[MechanicalSoup](https://mechanicalsoup.readthedocs.io/) and `multiprocessing`:
+
+1. **Sharded frontier.** 32 worker processes each own one `multiprocessing.Manager().Queue()`.
+   A URL is assigned to a worker by `int(md5(url).hexdigest(), 16) % 32`, so every URL is always
+   handled by the same worker and no locking or cross-process deduplication is needed.
+2. **Seed.** The crawl is seeded with a single article URL
+   (`https://www.politico.eu/article/swedens-still-ahead-in-the-preparedness-game-and-now-it-means-business`) and discovers
+   everything else by following links.
+3. **Link discovery.** Every fetched page is parsed with BeautifulSoup/lxml; all `<a href>` values
+   that start with `https://www.politico.eu/` or with `/` (which are then made absolute) are added to the
+   frontier. URLs containing `#` are dropped.
+4. **URL filtering.** Before fetching, a URL is skipped when it contains `/files/`, `/video/`,
+   `.jpg`, `.pdf`, `.xml`, `.pptx`, `.shtml` or `.epub`, or when it has fewer than five path
+   segments (which filters out section index pages).
+5. **Fetching.** Each URL gets up to 10 attempts with a 10 s timeout.
+6. **Extraction.** `get_content()` turns the HTML into a record (see below). Only pages with a
+   non-empty `content` are written out, as `pages/<flattened-url>.json`.
+7. **Resumability.** Each worker appends every known and every visited URL to
+   `data/thread_<id>_pages.txt` and `data/thread_<id>_pages_visited.txt`, and re-reads them on
+   start, so an interrupted crawl continues where it stopped. Creating a file named `killall.txt`
+   in the working directory stops all workers cleanly.
+
+Crawler settings used for this site:
+
+- **Worker processes:** 32 (`iNumberOfThreads = 32`)
+- **Retries per URL:** 10, with a 10-second socket timeout per attempt
+- **Proxy pool:** used — requests were sent through a rotating pool of forward proxies (the published script reproduces this via `SCRAPER_PROXIES`, see below)
+- **User-agent rotation:** yes, a random UA per request via `fake_useragent`
+- **Politeness delay:** none — throttling was handled by the proxy pool / retry loop
+- **Bot-challenge handling:** responses containing `#challenge-error-text` or `You don't have permission to access` are discarded and retried after a short pause
+- **Raw HTML dump:** enabled (`raw/`), used for debugging the parser
+
+**Paywall handling.** The site serves its articles without a paywall, so no paywall filter was necessary.
+
+### 2. Article extraction
+
+`get_content()` reads the fields from the page's JSON-LD (`<script type="application/ld+json">`)
+and/or its HTML, as follows:
+
+| Field | Source in the page |
+|---|---|
+| `title` | `<meta property="og:title">` |
+| `content` | all `<p>` inside the article body container `<article class="article">`, space-joined |
+| `author` | the first entry of `author` in `ld+json` |
+| `description` | `description` from `ld+json` |
+| `keywords` | `keywords` from `ld+json` |
+| `category` | `articleSection` from `ld+json` |
+| `countries` | the country tag links in `div.tags__taxonomy--country` — the EU member states the CMS associates with the article |
+| `dateCreated` | `dateCreated` from `ld+json` |
+| `datePublished` | `datePublished` from `ld+json` |
+| `dateModified` | `dateModified` from `ld+json` |
+| `post_id` | `post_id` from the `custom_metadata` object inside `ld+json` — POLITICO's internal article id |
+| `url` | the crawled URL |
+
+`custom_metadata` arrives as a JSON string nested inside the JSON-LD block, so it is
+parsed twice: once for the outer block and once for the embedded object that carries `post_id`.
+
+Each article is stored as a JSON file of the shape
+
+```json
+{
+  "title": "…",
+  "content": "…",
+  "additional_attributes": { "author": "…", "description": "…", "keywords": "…", "category": "…", "countries": "…", "dateCreated": "…", "datePublished": "…", "dateModified": "…", "post_id": "…", "url": "…" }
+}
+```
+
+### 3. Consolidation — [`scraping/finalize.ipynb`](./scraping/finalize.ipynb)
+
+1. `glob("pages/*.json")` collects every article file.
+2. The nested records are flattened into one `pandas.DataFrame` column per field.
+3. `df.drop_duplicates(subset=['title'])` removes duplicates — the same article is often reachable
+   under several URLs (print/mobile variants, tracking parameters, section mirrors), and
+   the headline is the most reliable identity key available.
+4. The frame is written to `politico_eu.json` and pushed with
+   `datasets.Dataset.from_pandas(df).push_to_hub("SinclairSchneider/politico_eu")`.
+
+### Dataset-specific notes
+
+- `countries` is the publisher's own geographic tagging, not an extraction from the text; it is empty for articles the CMS did not tag.
+
+### Reproducing the crawl
+
+```bash
+pip install mechanicalsoup beautifulsoup4 lxml python-dateutil fake-useragent \
+            pandas datasets huggingface_hub tqdm
+
+mkdir politico_eu && cd politico_eu
+curl -L -O https://huggingface.co/datasets/SinclairSchneider/politico_eu/resolve/main/scraping/crawler.py
+
+python crawler.py          # writes pages/*.json; `touch killall.txt` to stop
+jupyter notebook finalize.ipynb
+```
+
+#### Routing the crawl through your own proxies
+
+The original crawl ran behind a pool of forward proxies on a private network. Those addresses are
+infrastructure-specific and have been **removed** from the published script. Instead, `crawler.py`
+reads the `SCRAPER_PROXIES` environment variable: a comma-separated list of proxies, written with
+or without a scheme (`http://` is assumed when none is given). One entry is picked per request, so
+a pool spreads the load across several exits.
+
+```bash
+# a single proxy
+export SCRAPER_PROXIES="proxy-a.example.com:3128"
+
+# a pool, rotated per request
+export SCRAPER_PROXIES="proxy-a.example.com:3128,proxy-b.example.com:3128"
+
+# with an explicit scheme and credentials
+export SCRAPER_PROXIES="http://user:pass@proxy.example.com:3128"
+
+# SOCKS, if PySocks is installed
+export SCRAPER_PROXIES="socks5://localhost:9050"
+
+# back to a direct connection — this is the default
+unset SCRAPER_PROXIES
+
+python crawler.py
+```
+
+Internally this becomes `requests`' standard `{'http': …, 'https': …}` proxy mapping; with the
+variable unset the mapping is empty and the crawler connects directly. No credentials, cookies or
+personal data are contained in the published code.
+
+**Please crawl responsibly:** respect `robots.txt` and the site's terms of use, keep the
+concurrency far below the 32 workers used here unless you have the site's permission, and prefer
+this published dataset over re-crawling.
+
+## Usage
+
+```python
+from datasets import load_dataset
+import pandas as pd
+
+ds = load_dataset("SinclairSchneider/politico_eu", split="train")
+
+# stream instead of downloading everything
+stream = load_dataset("SinclairSchneider/politico_eu", split="train", streaming=True)
+print(next(iter(stream))["title"])
+
+# as a DataFrame
+df = ds.to_pandas()
+df["datePublished"] = pd.to_datetime(df["datePublished"], errors="coerce", utc=True, format="mixed")
+recent = df[df["datePublished"].dt.year >= 2024]
+print(len(recent), "articles from 2024 onwards")
+```
+
+Combining several outlets into one comparative corpus:
+
+```python
+from datasets import load_dataset, concatenate_datasets
+
+outlets = ["SinclairSchneider/politico_eu", "SinclairSchneider/tagesschau_de"]
+parts = []
+for name in outlets:
+    d = load_dataset(name, split="train").select_columns(["title", "content", "url"])
+    parts.append(d.add_column("outlet", [name.split("/")[-1]] * len(d)))
+corpus = concatenate_datasets(parts)
+```
+
+## Limitations and biases
+
+- **Crawl, not archive.** Coverage is whatever was reachable by following links from the seed URL
+  at crawl time. Articles that were deleted, depublished or orphaned before the crawl are missing,
+  and old content is covered less densely than recent content.
+- **Free content only.** All articles on this site are freely accessible, so no paywall bias applies — but non-article page types (galleries, video pages, live tickers) are mostly absent because they have no extractable body text.
+- **Deduplication by headline.** Two genuinely different articles with an identical headline
+  (common for recurring formats such as weather or daily briefings) collapse into one row.
+- **Noisy metadata.** `author`, `category` and `keywords` come straight from the publisher's markup,
+  which changed over the years; empty strings are common and category labels are not harmonised
+  across outlets.
+- **Editorial perspective.** This is the output of a single outlet. Any model trained on it alone
+  inherits that outlet's selection of topics, framing and vocabulary — which is exactly why the
+  collection provides the same pipeline across the political spectrum.
+- **No text normalisation.** Bodies are the concatenated paragraphs as published, including
+  typographic quotes, soft hyphens and occasional residual boilerplate.
+
+## Licensing and intended use
+
+### Scientific research only — *Forschungsprivileg* (§ 60d UrhG)
+
+This dataset is made available **solely for the purpose of scientific research**. The legal basis
+is the German text-and-data-mining exception for research, the so-called **Forschungsprivileg**:
+
+- **§ 60d UrhG** — *Text und Data Mining für Zwecke der wissenschaftlichen Forschung* — allows
+  research organisations to make reproductions of lawfully accessible works in order to carry out
+  text and data mining for **non-commercial** scientific research, and to share the resulting
+  corpus with a specifically limited circle of people for joint research and with individual third
+  parties for the purpose of quality assurance.
+- It implements **Art. 3 of Directive (EU) 2019/790** (the DSM Directive); comparable research
+  exceptions exist in the other EU member states.
+- § 60d UrhG does **not** cover commercial exploitation. Research organisations that give a
+  commercial enterprise preferential access are explicitly excluded from the privilege.
+
+### What this means for you
+
+✅ **Permitted** — using the corpus for non-commercial scientific research: text and data mining,
+corpus linguistics, media-bias and discourse analysis, training and evaluating research models,
+reproducing published findings, and quality checks by individual third parties.
+
+❌ **Not permitted** — commercial use or commercial model training; redistributing or republishing
+the article texts; presenting the texts as your own; building products or services on the article
+texts; any use that substitutes for reading the publisher's own website.
+
+The **article texts remain the copyright of POLITICO Europe and its publisher.** No licence to them is
+granted or implied by this repository. Only the crawling and extraction code in `scraping/` is
+offered for free reuse.
+
+If your intended use falls outside the research exception, obtain permission from the rights
+holder, or use only the derived, non-expressive data (statistics, embeddings, counts). Note that
+§ 60d UrhG also expects research corpora to be deleted once they are no longer needed for the
+research purpose, with archiving permitted at trusted institutions.
+
+If you are a rights holder and want content removed, please open a discussion on this repository.
+
+> This section is an orientation for researchers, not legal advice. Responsibility for your own
+> use of the data remains with you and your institution.
+
+## Citation
+
+```bibtex
+@misc{politico_eu_dataset,
+  title        = {POLITICO Europe (politico.eu): a corpus of German news articles},
+  author       = {Schneider, Sinclair},
+  year         = {2025},
+  howpublished = {Hugging Face},
+  url          = {https://huggingface.co/datasets/SinclairSchneider/politico_eu}
+}
+```
+
+## See also
+
+- The full [International Newspapers collection](https://huggingface.co/collections/SinclairSchneider/international-newspapers-6900fdd5083089f336574c82)
+- Mirror of this dataset: [`NLP-UniBW/politico_eu`](https://huggingface.co/datasets/NLP-UniBW/politico_eu)

scraping/.env.example

@@ -0,0 +1,52 @@
+# ---------------------------------------------------------------------------
+#  crawler.py configuration for www.politico.eu
+#
+#  Copy this file to `.env` and uncomment the lines you need:
+#
+#      cp .env.example .env
+#
+#  Variables that are already set in the real environment take precedence over
+#  this file, so a single run can still be overridden on the command line:
+#
+#      SCRAPER_THREADS=4 python crawler.py
+#
+#  Everything here is optional - the defaults shown are exactly the values that
+#  were used for the original crawl.
+# ---------------------------------------------------------------------------
+
+
+# === Proxies ===============================================================
+
+# Inline pool. Separate entries with commas, semicolons, spaces or newlines.
+# A scheme is optional - "http://" is assumed when none is given. One entry is
+# picked per request, so several entries spread the load over several exits.
+#SCRAPER_PROXIES=proxy-a.example.com:3128,proxy-b.example.com:3128
+
+# ... with an explicit scheme and credentials:
+#SCRAPER_PROXIES=http://user:pass@proxy.example.com:3128
+
+# ... SOCKS (requires PySocks):
+#SCRAPER_PROXIES=socks5://localhost:9050
+
+# For a whole proxy farm, keep the list in its own file instead: one proxy per
+# line, blank lines and "#" comments allowed. See `proxies.example.txt`.
+# This scales to thousands of entries and can be regenerated by another tool
+# without ever touching this file. Both settings may be combined.
+#SCRAPER_PROXY_FILE=proxies.txt
+
+# Leave both unset to crawl over a direct connection - that is the default.
+
+
+# === Crawler tuning ========================================================
+
+# Number of worker processes sharing the URL frontier.
+#SCRAPER_THREADS=32
+
+# Socket timeout per request, in seconds.
+#SCRAPER_TIMEOUT=10.0
+
+# Attempts per URL before it is given up on.
+#SCRAPER_RETRIES=10
+
+# Seed URL the crawl starts from. Any article URL on the site works.
+#SCRAPER_START_URL=https://www.politico.eu/article/swedens-still-ahead-in-the-preparedness-game-and-now-it-means-business

scraping/README.md

@@ -0,0 +1,83 @@
+# How this dataset was built
+
+| File | Purpose |
+|---|---|
+| [`crawler.py`](./crawler.py) | Distributed whole-site crawler for `www.politico.eu`. Writes one JSON file per article to `pages/`. |
+| [`finalize.ipynb`](./finalize.ipynb) | Merges `pages/*.json` into a single table, deduplicates it and pushes it to the Hub. |
+| [`.env.example`](./.env.example) | Configuration template. Copy to `.env` and uncomment what you need. |
+| [`proxies.example.txt`](./proxies.example.txt) | Proxy-list template for `SCRAPER_PROXY_FILE` — one proxy per line. |
+
+```bash
+pip install mechanicalsoup beautifulsoup4 lxml python-dateutil fake-useragent \
+            pandas datasets huggingface_hub tqdm
+
+python crawler.py          # writes pages/*.json; `touch killall.txt` to stop
+jupyter notebook finalize.ipynb
+```
+
+## Configuration
+
+All settings are optional and are read from the environment or from a `.env`
+file next to `crawler.py`. The defaults are exactly the values used for the
+original crawl.
+
+```bash
+cp .env.example .env     # then uncomment what you need
+```
+
+| Variable | Meaning |
+|---|---|
+| `SCRAPER_PROXIES` | Inline proxy pool — entries separated by commas, semicolons, spaces or newlines. |
+| `SCRAPER_PROXY_FILE` | Path to a file with **one proxy per line** — the practical form for a proxy farm. |
+| `SCRAPER_THREADS` | Number of worker processes sharing the URL frontier. |
+| `SCRAPER_TIMEOUT` | Socket timeout per request, in seconds. |
+| `SCRAPER_RETRIES` | Attempts per URL before giving up. |
+| `SCRAPER_START_URL` | Seed URL the crawl starts from. |
+
+Environment variables take precedence over `.env`, so a single run can be
+overridden on the command line:
+
+```bash
+SCRAPER_THREADS=4 python crawler.py
+```
+
+### Proxies
+
+The original crawl ran behind a pool of forward proxies on a private network.
+Those addresses have been removed from this published copy. A scheme is
+optional on every entry (`http://` is assumed); one entry is picked per
+request, so a pool spreads the load over several exits.
+
+```bash
+# a single proxy
+export SCRAPER_PROXIES="proxy-a.example.com:3128"
+
+# a small pool, rotated per request
+export SCRAPER_PROXIES="proxy-a.example.com:3128,proxy-b.example.com:3128"
+
+# with an explicit scheme and credentials
+export SCRAPER_PROXIES="http://user:pass@proxy.example.com:3128"
+
+# SOCKS, if PySocks is installed
+export SCRAPER_PROXIES="socks5://localhost:9050"
+```
+
+For a **whole proxy farm**, keep the list in its own file — one proxy per line,
+blank lines and `#` comments allowed — and point `SCRAPER_PROXY_FILE` at it.
+The file can hold thousands of entries and be regenerated by another tool
+without touching `.env` or the script:
+
+```bash
+cp proxies.example.txt proxies.txt   # then fill in your own entries
+echo 'SCRAPER_PROXY_FILE=proxies.txt' >> .env
+python crawler.py
+```
+
+Leave both unset to crawl over a direct connection — that is the default and
+what most of the crawls in this collection used.
+
+The scripts contain no credentials, cookies or personal data.
+
+Please crawl responsibly: honour `robots.txt` and the site's terms of use, keep
+concurrency well below the 32 workers used here unless you have the operator's
+permission, and prefer the published dataset over re-crawling.

scraping/crawler.py

@@ -0,0 +1,376 @@
+"""
+Whole-site crawler for www.politico.eu (POLITICO Europe).
+
+This is the exact script that produced the Hugging Face dataset
+https://huggingface.co/datasets/SinclairSchneider/politico_eu — see that dataset card for a
+step-by-step description of the pipeline.
+
+Overview
+--------
+* 32 worker processes share the URL frontier; a URL is routed to a worker by
+  ``int(md5(url).hexdigest(), 16) % 32`` so that no locking is required.
+* The crawl is seeded with one article URL and discovers everything else by
+  following links below ``https://www.politico.eu/``.
+* ``get_content()`` turns an article page into a record; pages with an empty
+  body are dropped. Each surviving article is written to
+  ``pages/<flattened-url>.json``.
+* Known and visited URLs are appended to ``data/thread_<id>_pages*.txt``, so an
+  interrupted crawl resumes where it left off. Create a file named
+  ``killall.txt`` in the working directory to stop all workers cleanly.
+
+Usage
+-----
+    pip install mechanicalsoup beautifulsoup4 lxml python-dateutil fake-useragent
+    python crawler.py
+
+Configuration
+-------------
+Copy ``.env.example`` to ``.env`` and uncomment what you need - proxies, worker
+count, timeout, retries and the seed URL are all read from there (environment
+variables still win over the file). For a large proxy farm put one proxy per
+line into a text file and point ``SCRAPER_PROXY_FILE`` at it; see
+``proxies.example.txt``. The private proxy addresses used in the original crawl
+have been removed from this published copy.
+
+Please crawl responsibly: honour robots.txt and the site's terms of use, and
+lower the worker count unless you have the operator's permission.
+"""
+
+import hashlib
+import multiprocessing
+import mechanicalsoup
+
+from bs4 import BeautifulSoup
+import re
+import json
+import os
+import io
+import time
+import random
+from fake_useragent import UserAgent
+
+from dateutil.parser import parse
+
+base_url = "https://www.politico.eu/"
+
+# --- Configuration ---------------------------------------------------------
+# Every setting below can be supplied through the environment or through a
+# ".env" file placed next to this script.  Copy ".env.example" to ".env" and
+# uncomment what you need:
+#
+#     cp .env.example .env
+#
+# Nothing has to be set - the defaults are exactly the values that were used
+# for the original crawl.
+def _load_dotenv(path=".env"):
+    """Read a ".env" file: KEY=VALUE per line, "#" starts a comment.
+
+    Variables that are already set in the real environment win, so a single run
+    can still be overridden with e.g. ``SCRAPER_THREADS=4 python crawler.py``.
+    """
+    if not os.path.isfile(path):
+        return
+    with io.open(path, "r", encoding="utf-8") as handle:
+        for line in handle:
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, _, value = line.partition("=")
+            key = key.strip()
+            value = value.strip().strip('"').strip("'")
+            if key and key not in os.environ:
+                os.environ[key] = value
+
+
+_load_dotenv()
+
+
+def _load_proxy_pool():
+    """Build the proxy pool from SCRAPER_PROXIES and/or SCRAPER_PROXY_FILE.
+
+    SCRAPER_PROXIES     inline list; entries separated by commas, semicolons,
+                        spaces or newlines.
+    SCRAPER_PROXY_FILE  path to a file holding one proxy per line, with blank
+                        lines and "#" comments allowed.  This is the practical
+                        form for a whole proxy farm: the pool can be swapped or
+                        regenerated without touching the script or the .env.
+
+    Both may be combined.  Entries may be written with or without a scheme
+    ("http://" is assumed when none is given).  Duplicates are dropped and an
+    empty pool simply means "connect directly".
+    """
+    raw = os.environ.get("SCRAPER_PROXIES", "")
+    proxy_file = os.environ.get("SCRAPER_PROXY_FILE", "").strip()
+    if proxy_file:
+        if not os.path.isfile(proxy_file):
+            raise SystemExit("SCRAPER_PROXY_FILE points to a missing file: " + proxy_file)
+        with io.open(proxy_file, "r", encoding="utf-8") as handle:
+            raw = raw + "\n" + handle.read()
+    cleaned = []
+    for line in raw.splitlines():
+        line = line.split("#", 1)[0].strip()
+        if line:
+            cleaned.append(line)
+    pool = []
+    for entry in re.split(r"[,;\s]+", " ".join(cleaned)):
+        entry = entry.strip()
+        if not entry:
+            continue
+        if "://" not in entry:
+            entry = "http://" + entry
+        if entry not in pool:
+            pool.append(entry)
+    return pool
+
+
+PROXY_POOL = _load_proxy_pool()
+NUM_THREADS = int(os.environ.get("SCRAPER_THREADS", "32"))
+REQUEST_TIMEOUT = float(os.environ.get("SCRAPER_TIMEOUT", "10.0"))
+MAX_RETRIES = int(os.environ.get("SCRAPER_RETRIES", "10"))
+START_URL = os.environ.get("SCRAPER_START_URL", "https://www.politico.eu/article/swedens-still-ahead-in-the-preparedness-game-and-now-it-means-business")
+
+def log(number, url):
+    if not os.path.isdir("log"):
+        os.mkdir("log")
+    with open("log"+os.sep+"thread_"+str(number)+".txt", "w") as f:
+        f.write(url)
+
+def error(number, url):
+    if not os.path.isdir("error"):
+        os.mkdir("error")
+    with open("error"+os.sep+"thread_"+str(number)+".txt", "w") as f:
+        f.write(url)
+
+def raw(number, url, page_str):
+    if not os.path.isdir("raw"):
+        os.mkdir("raw")
+    with open("raw"+os.sep+"thread_"+str(number)+".txt", "w") as f:
+        f.write(url)
+        f.write(page_str)
+
+def get_content(url, page_str):
+    additional_attributes = {
+        'author':'',
+        'description':'',
+        'keywords':'',
+        'category':'',
+        'countries':'',
+        'dateCreated':'',
+        'datePublished':'',
+        'dateModified':'',
+        'post_id':'',
+        'url':'',
+    }
+    dict_return = {'content':'', 'title':'', 'additional_attributes': additional_attributes}
+
+    if page_str=="":
+        return dict_return
+
+    page_bs = BeautifulSoup(page_str, "lxml")
+    
+    title = page_bs.find("meta", {'property':'og:title'}).get('content') if page_bs.find("meta", {'property':'og:title'}) != None else ""
+    content = " ".join([x.text.strip() for x in page_bs.find("article", {'class', 'article'}).find_all("p")]) if page_bs.find("article", {'class', 'article'}) != None else ""
+    author = json.loads(page_bs.find("script", {'type': 'application/ld+json'}).text).get('author', [{}]) if page_bs.find("script", {'type': 'application/ld+json'}) != None else ""
+    author = author[0].get('name', '') if len(author) > 0 else ""
+    description = json.loads(page_bs.find("script", {'type': 'application/ld+json'}).text).get('description', '') if page_bs.find("script", {'type': 'application/ld+json'}) != None else ""
+    keywords = json.loads(page_bs.find("script", {'type': 'application/ld+json'}).text).get('keywords', '') if page_bs.find("script", {'type': 'application/ld+json'}) != None else ""
+    category = json.loads(page_bs.find("script", {'type': 'application/ld+json'}).text).get('articleSection', '') if page_bs.find("script", {'type': 'application/ld+json'}) else ""
+    countries = [x.text.strip() for x in page_bs.find("div", {'class': 'tags__taxonomy--country'}).find_all("a")] if page_bs.find("div", {'class': 'tags__taxonomy--country'}) != None else []
+    dateCreated = json.loads(page_bs.find("script", {'type': 'application/ld+json'}).text).get('dateCreated', '') if page_bs.find("script", {'type': 'application/ld+json'}) else ""
+    datePublished = json.loads(page_bs.find("script", {'type': 'application/ld+json'}).text).get('datePublished', '') if page_bs.find("script", {'type': 'application/ld+json'}) else ""
+    dateModified = json.loads(page_bs.find("script", {'type': 'application/ld+json'}).text).get('dateModified', '') if page_bs.find("script", {'type': 'application/ld+json'}) else ""
+    post_id = json.loads(str(json.loads(page_bs.find("script", {'type': 'application/ld+json'}).text).get('custom_metadata', {}))).get('post_id') if page_bs.find("script", {'type': 'application/ld+json'}) != None else ""
+    
+    additional_attributes = {
+        'author':author,
+        'description':description,
+        'keywords':keywords,
+        'category':category,
+        'countries':countries,
+        'dateCreated':dateCreated,
+        'datePublished':datePublished,
+        'dateModified':dateModified,
+        'post_id':post_id,
+        'url':url,
+    }
+    dict_return = {'content':content, 'title':title, 'additional_attributes': additional_attributes}
+    return dict_return
+    
+def get_urls(page_str):
+    return_urls = set()
+    page_bs = BeautifulSoup(page_str, "lxml")
+    for tag in page_bs.findAll("a", href=True):
+        url = tag.get("href", '')
+        if "#" in url:
+            continue
+        if url.startswith(base_url):
+            return_urls.add(url)
+        if url.startswith("/"):
+            url = base_url + url
+            return_urls.add(url)
+    return return_urls
+
+def readSavedData(iId, sPageset, sPagesetVisited):
+    if not os.path.isdir("data"):
+        os.mkdir("data")
+    if os.path.isfile("data/thread_"+str(iId)+"_pages.txt"):
+        with io.open("data/thread_"+str(iId)+"_pages.txt", "r", encoding="utf-8") as f:
+            for line in f:
+                if "#" in line:
+                    continue
+                line = line.replace("\n", "")
+                if line != "":
+                    sPageset.add(line)
+
+    if os.path.isfile("data/thread_"+str(iId)+"_pages_visited.txt"):
+        with io.open("data/thread_"+str(iId)+"_pages_visited.txt", "r", encoding="utf-8") as f:
+            for line in f:
+                if "#" in line:
+                    continue
+                line = line.replace("\n", "")
+                if line != "":
+                    sPagesetVisited.add(line)
+
+def addStartChannel(sPage, iNumberOfThreads, lQueues):
+    iIndex = int(hashlib.md5(sPage.encode("utf")).hexdigest(),16)%iNumberOfThreads
+    lQueues[iIndex].put(sPage)
+
+def getNextPage(lQueues, iId, sPageset, sPagesetVisited):
+    while True:
+        if os.path.isfile("killall.txt"):
+            return None
+
+        while not lQueues[iId].empty():
+            sPage = lQueues[iId].get()
+            iLenBefore = len(sPageset)
+            sPageset.add(sPage)
+            iLenAfter = len(sPageset)
+            if iLenBefore != iLenAfter:
+                with io.open("data/thread_"+str(iId)+"_pages.txt", "a", encoding="utf-8") as f:
+                    if sPage != "" and sPage != "\t":
+                        f.write(sPage + "\n")
+        sPagesetToVisit = sPageset - sPagesetVisited
+
+        if len(sPagesetToVisit) != 0:
+            sPage = list(sPagesetToVisit)[0]
+            return sPage
+        else:
+            print("Thread " + str(iId) + " is waiting")
+            time.sleep(3)
+
+def addPagesToVisit(sPages, iNumberOfThreads, lQueues):
+    for sPage in sPages:
+        if sPage != "":
+            iIndex = int(hashlib.md5(sPage.encode("utf")).hexdigest(), 16) % iNumberOfThreads
+            lQueues[iIndex].put(sPage)
+
+def addVisitedPages(sPage, sPagesetsetVisited, iId):
+    iLenBefore = len(sPagesetsetVisited)
+    sPagesetsetVisited.add(sPage)
+    iLenAfter = len(sPagesetsetVisited)
+    if iLenBefore != iLenAfter:
+        with io.open("data/thread_"+str(iId)+"_pages_visited.txt", "a", encoding="utf-8") as f:
+            if sPage != "":
+                f.write(sPage+"\n")
+
+def crawler(iId, iNumberOfThreads, lQueues):
+    sPageset = set()
+    sPagesetVisited = set()
+    readSavedData(iId, sPageset, sPagesetVisited)
+
+    while True:
+        sPage = getNextPage(lQueues, iId, sPageset, sPagesetVisited)
+        if sPage is None:
+            break
+        if "#" in sPage:
+            continue
+
+        if (not "/files/" in sPage) and \
+            (not "/video/" in sPage) and \
+            (not ".jpg" in sPage) and \
+            (not ".pdf" in sPage) and \
+            (not ".xml" in sPage) and \
+            (not ".pptx" in sPage) and \
+            (not ".shtml" in sPage) and \
+            len(sPage.split('/')) > 4 and \
+            (not ".epub" in sPage):
+
+            log(iId, sPage)
+            for i in range(MAX_RETRIES):
+                try:
+                    lproxies = PROXY_POOL
+                    proxy = lproxies[int((int(time.time())/1))%len(lproxies)] if lproxies else None
+                    proxy = lproxies[int(iId)%len(lproxies)] if lproxies else None
+                    proxies = {'https': proxy, 'http': proxy} if proxy else {}
+                    browser = mechanicalsoup.StatefulBrowser()
+                    ua = UserAgent()
+                    browser.set_user_agent(ua.random)
+                    browser.session.proxies = proxies
+
+                    
+                    browser.open(sPage, timeout=REQUEST_TIMEOUT)
+                    page = browser.get_current_page()
+                    page_str = str(page)
+                    if "#challenge-error-text" in page_str:
+                        print("error, we will wait a moment and continue")
+                        time.sleep(1)
+                        continue
+                    if "You don't have permission to access" in page_str:
+                        print("error, we will wait a moment and continue")
+                        time.sleep(1)
+                        continue
+                    raw(iId, sPage, page_str)
+                    break
+                except:
+                    print(sPage)
+                    print("retry")
+                    browser.close()
+                    continue
+
+            browser.close()
+        else:
+            page_str = ""
+
+        try:
+            content = get_content(sPage, page_str)
+        except:
+            error(iId, sPage)
+            
+        if content['content'] != '':
+            file_path = sPage.replace(base_url+"/", "").replace("/", "_")[-200:]
+            file_path = "pages/"+file_path
+            file_path = file_path[:-1] if file_path.endswith("_") else file_path
+            file_path = file_path+".json"
+            content_json = json.dumps(content)
+            with open(file_path, "w", encoding = "utf-8") as f:
+                f.write(content_json)
+        else:
+            pass
+
+        sPages = get_urls(page_str)
+        addPagesToVisit(sPages, iNumberOfThreads, lQueues)
+        addVisitedPages(sPage, sPagesetVisited, iId)
+
+        print("Thread: " + str(iId) + " chanels visited: " + str(len(sPagesetVisited)) + " channels to visit: " + str(len(sPageset - sPagesetVisited)))
+
+def main():
+    if not os.path.isdir("pages"):
+        os.mkdir("pages")
+
+    iNumberOfThreads = NUM_THREADS
+    lQueues = []
+    mgr = multiprocessing.Manager()
+    for i in range(iNumberOfThreads):
+        qQueue = mgr.Queue()
+        lQueues.append(qQueue)
+
+    lIds = range(0, iNumberOfThreads)
+    lNumberOfThreads = [iNumberOfThreads] * iNumberOfThreads
+    llQueues = [lQueues] * iNumberOfThreads
+    addStartChannel(START_URL, iNumberOfThreads, lQueues)
+    lArguments = list(zip(lIds, lNumberOfThreads, llQueues))
+    with multiprocessing.Pool(processes=iNumberOfThreads) as pool:
+        pool.starmap(crawler, lArguments)
+
+if __name__ == "__main__":
+    main()

scraping/finalize.ipynb

@@ -0,0 +1,221 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# `POLITICO Europe (politico.eu)` — consolidation notebook\n",
+    "\n",
+    "This notebook is the second half of the pipeline behind\n",
+    "[`SinclairSchneider/politico_eu`](https://huggingface.co/datasets/SinclairSchneider/politico_eu).\n",
+    "\n",
+    "`crawler.py` writes one JSON file per article into `pages/`. This notebook\n",
+    "\n",
+    "1. reads every `pages/*.json`,\n",
+    "2. flattens the nested records into one `pandas` column per field,\n",
+    "3. drops duplicate articles by headline (`drop_duplicates(subset=['title'])`),\n",
+    "4. writes `politico_eu.json` and pushes the result to the Hugging Face Hub.\n",
+    "\n",
+    "Outputs have been cleared before publication.\n",
+    ""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import glob\n",
+    "import json\n",
+    "import pandas as pd\n",
+    "from datasets import Dataset\n",
+    "import huggingface_hub\n",
+    "from dateutil.parser import parse\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"pages/ylvie-goulard-cleared-from-charges-that-could-have-costed-her-commissioner-job-commission-candidate-sylvie-goulard-cleared-from-embezzlement-charges-emmanuel-macron-european-commission-presidency-thi.json\", \"r\", encoding=\"utf-8\") as f:\n",
+    "    json_input = f.read()\n",
+    "    dict_input_example = json.loads(json_input)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dict_input_example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "json_files = glob.glob(\"pages/*.json\")\n",
+    "len(json_files)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "title = []\n",
+    "content = []\n",
+    "author = []\n",
+    "description = []\n",
+    "keywords = []\n",
+    "category = []\n",
+    "countries = []\n",
+    "dateCreated = []\n",
+    "datePublished = []\n",
+    "dateModified = []\n",
+    "post_id = []\n",
+    "url = []\n",
+    "for file in tqdm(json_files):\n",
+    "    with open(file, \"r\") as f:\n",
+    "        d = json.loads(f.read())\n",
+    "        title.append(d['title'])\n",
+    "        content.append(d['content'])\n",
+    "        author.append(d['additional_attributes']['author'])\n",
+    "        description.append(d['additional_attributes']['description'])\n",
+    "        keywords.append(d['additional_attributes']['keywords'])\n",
+    "        category.append(d['additional_attributes']['category'])\n",
+    "        countries.append(d['additional_attributes']['countries'])\n",
+    "        dateCreated.append(d['additional_attributes']['dateCreated'])\n",
+    "        datePublished.append(d['additional_attributes']['datePublished'])\n",
+    "        dateModified.append(d['additional_attributes']['dateModified'])\n",
+    "        post_id.append(d['additional_attributes']['post_id'])\n",
+    "        url.append(d['additional_attributes']['url'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.DataFrame(\n",
+    "    {\n",
+    "        'title':title,\n",
+    "        'content':content,\n",
+    "        'author':author,\n",
+    "        'description':description,\n",
+    "        'keywords':keywords,\n",
+    "        'category':category,\n",
+    "        'countries':countries,\n",
+    "        'dateCreated':dateCreated,\n",
+    "        'datePublished':datePublished,\n",
+    "        'dateModified':dateModified,\n",
+    "        'post_id':post_id,\n",
+    "        'url':url,\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df['keywords']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = df.drop_duplicates(subset=['title'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = df[df['datePublished']!=\"\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = df.sort_values(by=['datePublished'], ascending=False).reset_index(drop=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.to_json(\"politico_eu.json\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds = Dataset.from_pandas(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds.push_to_hub(\"SinclairSchneider/politico_eu\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds.push_to_hub(\"NLP-UniBW/politico_eu\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

scraping/proxies.example.txt

@@ -0,0 +1,15 @@
+# One proxy per line. Blank lines and "#" comments are ignored.
+# A scheme is optional - "http://" is assumed when none is given.
+#
+# Copy this file (e.g. to `proxies.txt`), fill in your own entries and point
+# SCRAPER_PROXY_FILE at it:
+#
+#     SCRAPER_PROXY_FILE=proxies.txt
+#
+# This is the convenient form for a large proxy farm - the file can hold
+# thousands of lines and be regenerated by another tool at any time.
+
+proxy-a.example.com:3128
+proxy-b.example.com:3128
+http://user:pass@proxy-c.example.com:3128
+socks5://localhost:9050