Programació del WebScraping

# ============================================
# SCRAPER RECURSIU AMB BEAUTIFULSOUP
# Autor: Tarik Aberdane
# Versió: 3.0 (amb millores de robustesa)
# ============================================

import requests
from bs4 import BeautifulSoup
from collections import deque
import time
import json
import hashlib
import random
from urllib.parse import urljoin, urlparse

class WebScraper:
    def __init__(self, base_url, delay=0.5, timeout=10):
        self.base_url = base_url
        self.visited = set()          # Cache d'URLs visitades
        self.queue = deque([base_url]) # Cua de treball
        self.delay = delay
        self.timeout = timeout
        self.data = []                # Dades extretes
        self.content_hash = set()     # Evitar duplicats per contingut
        
    def extract_content(self, soup, url):
        """Extreu el contingut net de la pàgina evitant brossa HTML"""
        content = {
            "url": url,
            "titol": "",
            "contingut": [],
            "data_scraped": time.strftime("%Y-%m-%d %H:%M:%S")
        }
        
        # Extracció del títol (h1 principal)
        title_tag = soup.find('h1')
        if title_tag:
            content["titol"] = title_tag.get_text(strip=True)
        else:
            # Fallback: títol de la pàgina
            title_tag = soup.find('title')
            if title_tag:
                content["titol"] = title_tag.get_text(strip=True)
        
        # Extracció de contingut: h1, h2, h3, p, li
        for tag in soup.find_all(['h1', 'h2', 'h3', 'p', 'li']):
            text = tag.get_text(strip=True)
            if text and len(text) > 10:  # Ignorar text massa curt
                # Evitar contingut repetitiu (menús, etc.)
                if not any(skip in text.lower() for skip in ['menu', 'cerca', 'search', 'login']):
                    content["contingut"].append({
                        "tipus": tag.name,
                        "text": text
                    })
        
        return content if content["contingut"] else None
    
    def get_internal_links(self, soup, current_url):
        """Troba tots els enllaços interns de la pàgina"""
        links = []
        for a in soup.find_all('a', href=True):
            href = a['href']
            full_url = urljoin(current_url, href)
            # Només enllaços interns (mateix domini)
            if urlparse(full_url).netloc == urlparse(self.base_url).netloc:
                # Eliminar fragments (#) i paràmetres innecessaris
                clean_url = full_url.split('#')[0].split('?')[0]
                if clean_url not in self.visited:
                    links.append(clean_url)
        return links
    
    def request_with_retry(self, url, max_retries=3):
        """Realitza una petició HTTP amb reintents automàtics"""
        for attempt in range(max_retries):
            try:
                # Jitter aleatori per evitar patrons recognoscibles
                time.sleep(self.delay + random.uniform(0.1, 0.3))
                
                response = requests.get(
                    url, 
                    timeout=self.timeout,
                    headers={'User-Agent': 'Mozilla/5.0 (compatible; TarikBot/1.0)'}
                )
                
                if response.status_code == 200:
                    return response
                elif response.status_code in [404, 403, 500]:
                    print(f"⚠️ Error HTTP {response.status_code} a {url}")
                    return None
                else:
                    print(f"⚠️ Codi inesperat {response.status_code} a {url}")
                    return None
                    
            except requests.exceptions.Timeout:
                print(f"⏰ Timeout a {url} (intent {attempt+1}/{max_retries})")
                if attempt == max_retries - 1:
                    return None
            except requests.exceptions.ConnectionError:
                print(f"🔌 Error de connexió a {url}")
                return None
            except Exception as e:
                print(f"❌ Error inesperat a {url}: {e}")
                return None
        
        return None
    
    def scrape(self):
        """Executa el scraping recursiu"""
        print(f"🚀 Iniciant scraping de {self.base_url}")
        
        while self.queue:
            current_url = self.queue.popleft()
            
            if current_url in self.visited:
                continue
                
            response = self.request_with_retry(current_url)
            if not response:
                continue
                
            soup = BeautifulSoup(response.text, 'html.parser')
            
            # Extreure contingut
            content = self.extract_content(soup, current_url)
            if content:
                # Evitar duplicats per hash de contingut
                content_hash = hashlib.md5(str(content["contingut"]).encode()).hexdigest()
                if content_hash not in self.content_hash:
                    self.content_hash.add(content_hash)
                    self.data.append(content)
                    print(f"✅ Extret: {content['titol'][:50]}...")
            
            # Afegir nous enllaços a la cua
            new_links = self.get_internal_links(soup, current_url)
            for link in new_links:
                if link not in self.visited and link not in self.queue:
                    self.queue.append(link)
                    
            self.visited.add(current_url)
        
        print(f"🏁 Scraping finalitzat! {len(self.data)} pàgines processades")
        return self.data
    
    def save_to_json(self, filename="dades_tarik_total.json"):
        """Guarda les dades en JSON amb metadades"""
        output = {
            "metadata": {
                "version": "3.0",
                "data_scraped": time.strftime("%Y-%m-%d %H:%M:%S"),
                "total_pagines": len(self.data),
                "base_url": self.base_url
            },
            "contingut": self.data
        }
        
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(output, f, ensure_ascii=False, indent=2)
        
        print(f"💾 Dades guardades a {filename}")
        return filename
                    

# Funció amb reintents i jitter aleatori
import random

def request_with_retry(url, max_retries=3, timeout=10):
    """Realitza una petició HTTP amb reintents automàtics"""
    for attempt in range(max_retries):
        try:
            # Jitter aleatori per evitar patrons
            time.sleep(self.delay + random.uniform(0.1, 0.3))
            
            response = requests.get(
                url, 
                timeout=timeout,
                headers={'User-Agent': 'Mozilla/5.0 (compatible; TarikBot/1.0)'}
            )
            
            if response.status_code == 200:
                return response
            elif response.status_code in [404, 403, 500]:
                print(f"⚠️ Error HTTP {response.status_code} a {url}")
                return None
            else:
                print(f"⚠️ Codi inesperat {response.status_code} a {url}")
                return None
                
        except requests.exceptions.Timeout:
            print(f"⏰ Timeout a {url} (intent {attempt+1}/{max_retries})")
            if attempt == max_retries - 1:
                return None
        except requests.exceptions.ConnectionError:
            print(f"🔌 Error de connexió a {url}")
            return None
        except Exception as e:
            print(f"❌ Error inesperat a {url}: {e}")
            return None
    
    return None

# Delay ètic amb jitter
time.sleep(self.delay + random.uniform(0.1, 0.3))
                    

# Exemple de conversa amb IA per depurar un error

[USUARI]
El meu scraper es queda penjat quan troba una pàgina que triga massa a respondre. Com ho puc solucionar?

[IA]
Afegeix un timeout a la petició requests i gestiona l'excepció TimeoutError:

response = requests.get(url, timeout=10)
try:
    response = requests.get(url, timeout=10)
except requests.exceptions.Timeout:
    print(f"Timeout a {url}, saltant...")
    continue

També pots afegir reintents automàtics per a pàgines que fallen temporalment.

# Després de la correcció, vaig implementar el sistema de reintents amb retry
                    

# XatBot Talent 2026 - WebScraper

## 🚀 Descripció
Scraper recursiu desenvolupat en Python per extreure contingut del WordPress personal i convertir-lo en una base de dades JSON per al XatBot.

## 🛠️ Tecnologies utilitzades
- Python 3.10+
- BeautifulSoup4
- Requests
- JSON (estructura de dades)

## 📁 Estructura del projecte
- `scraper.py` - Script principal de scraping
- `dades_tarik_total.json` - Base de dades generada
- `README.md` - Documentació del projecte
- `CHANGELOG.md` - Historial de versions

## 🔧 Instal·lació
```bash
pip install beautifulsoup4 requests
python scraper.py