Un sistema modulare di parsing intelligente per estrarre contenuti puliti da diversi domini web utilizzando Python, FastAPI e Docker. Il progetto implementa un'architettura estensibile con valutazione automatica delle metriche di qualità.
Sistema di web scraping e parsing avanzato che:
- Scarica e analizza pagine web da domini specifici
- Estrae contenuti testuali eliminando il "rumore" (menu, footer, cookie banner, ecc.)
- Valuta automaticamente la qualità dell'estrazione tramite 8 diverse metriche
- Fornisce un'interfaccia web interattiva per testare e confrontare i risultati
- Mantiene Gold Standard (annotazioni manuali) per garantire la qualità
- Architettura Modulare: Si possono aggiungere nuovi parser per nuovi domini in pochi minuti
- FastAPI Backend: API REST veloce e documentata automaticamente
- Web UI Interattiva: Frontend con Jinja2 per testare i parser in tempo reale
- Containerizzato: Due container Docker (backend + frontend) pronti per il deploy
- Gold Standard: Sistema di riferimento per validare i risultati
- 8 Metriche di Valutazione: Valutazione completa della qualità dell'estrazione
- Type Hints: Codice completamente tipizzato per maggiore robustezza
- Docker >= 20.10
- Docker Compose >= 1.29
- Oppure: Python >= 3.11 (senza Docker)
# Clona la repository
git clone https://github.com/chitvs/web-parser.git
cd web-parser
# Avvia il sistema con Docker Compose
docker-compose up --buildIl sistema sarà disponibile a:
- Frontend: http://localhost:8004
- Backend API: http://localhost:8003
- Documentazione API (Swagger): http://localhost:8003/docs
# Vai nella cartella del backend
cd backend
# Crea un virtual environment
python3.11 -m venv venv
source venv/bin/activate # su Windows: venv\Scripts\activate
# Installa le dipendenze
pip install -r requirements.txt
pip install crawl4ai # Non incluso in requirements.txt per evitare dipendenze pesanti
# Avvia il server FastAPI
python -m uvicorn server:app --reload --port 8003# In un'altro terminale, vai nella cartella del frontend
cd frontend
# Installa le dipendenze
pip install -r requirements.txt
# Avvia il frontend
python src/frontend.py- Apri http://localhost:8004 nel browser
- Sezione 1 - Input:
- Inserisci un URL manualmente, oppure
- Seleziona un URL dalla lista dei Gold Standard
- Sezione 2 - Risultati di Valutazione:
- Visualizza tutte le 8 metriche calcolate
- Sezione 3 - Confronto:
- Confronta l'HTML grezzo con il Markdown estratto
- (Opzionale) Confronta con il Gold Standard
Scarica e parsa una pagina web:
curl "http://localhost:8003/parse?url=https://en.wikipedia.org/wiki/Python_(programming_language)"Risposta:
{
"url": "https://en.wikipedia.org/wiki/Python_(programming_language)",
"domain": "en.wikipedia.org",
"title": "Python (programming language) — Wikipedia",
"html_text": "<!DOCTYPE html>...",
"parsed_text": "# Python (programming language)\n\nPython is a high-level programming language..."
}Parsa un HTML senza scaricare dalla rete (utile per test riproducibili):
curl -X POST "http://localhost:8003/parse" \
-H "Content-Type: application/json" \
-d '{
"url": "https://www.vogue.com/article/example",
"html_text": "<!DOCTYPE html>..."
}'curl "http://localhost:8003/domains"Risposta:
{
"domains": [
"en.wikipedia.org",
"podcasts.apple.com",
"www.vogue.com",
"it.uefa.com"
]
}curl -X POST "http://localhost:8003/evaluate" \
-H "Content-Type: application/json" \
-d '{
"parsed_text": "Python is a high-level language...",
"gold_text": "Python is a high-level programming language..."
}'curl "http://localhost:8003/full_gs_eval?domain=en.wikipedia.org"Il sistema utilizza 8 metriche diverse per valutare la qualità dell'estrazione:
Calcola Precision, Recall e F1 su token unici estratti dal parser vs Gold Standard.
- Precision: Quanti token estratti sono corretti?
- Recall: Quanti token del GS sono stati estratti?
- F1: Media armonica di Precision e Recall
Interpretazione: Più vicino a 1.0, meglio è.
Tokens estratti: {python, language, high-level}
Tokens GS: {python, programming, language, high-level}
Precision = 3/3 = 1.0 (tutti i token sono nel GS)
Recall = 3/4 = 0.75 (manca "programming")
Variante del TLE che tiene conto della frequenza dei token.
- Se una parola appare 3 volte nel GS ma 5 nel parser, la frequenza extra è "rumore"
F1 su coppie di token consecutivi (bigram), non su singoli token.
Vantaggio: Penalizza testi che hanno le parole corrette ma in ordine sbagliato.
Parser: "Python is a language high-level"
GS: "Python is a high-level language"
TLE = OK (stessi token)
SF1 = Basso (ordine diverso)
Rapporto tra lunghezza del testo estratto e lunghezza del Gold Standard.
CR = numero_token_estratti / numero_token_gs
CR ≈ 1.0 → Perfetto (quantità giusta)
CR > 1.0 → Rumore (il parser ha aggiunto troppo)
CR < 1.0 → Omissioni (il parser ha rimosso troppo)
Sovrapposizione del vocabolario (intersezione / unione).
Estratti: {python, language, high, level}
GS: {python, language, programming, high, level}
Intersezione: {python, language, high, level} = 4
Unione: {python, language, high, level, programming} = 5
JAC = 4/5 = 0.8
Longest Common Subsequence - premia sequenze di parole condivise nell'ordine corretto.
Distanza di edit normalizzata (inserimenti + cancellazioni + sostituzioni) / lunghezza GS.
WER = 0.0 → Perfetto
WER = 1.0 → Completamente diverso
WER = 0.1 → 10% di errori
Penalizza token tipici del "boilerplate" che non dovrebbero esserci:
- Parole da menu di navigazione
- Cookie consent
- Footer
- Pubblicità
BP ≈ 1.0 → Nessun boilerplate (ottimale)
BP < 1.0 → Boilerplate rilevato e penalizzato
Sviluppato da Chitarrini Alessandro, Crugliano Matteo e Gaglione Davide come progetto per il corso di Laboratorio di Ingegneria Informatica presso Sapienza Università di Roma.
Anno Accademico: 2025-2026
Docente: Prof. Roberto Navigli