Data Normalization

# Pipeline de normalisation de données complet
import re
import unicodedata
from datetime import datetime
from typing import Any, Optional
from dataclasses import dataclass
import dateparser

@dataclass
class NormalizedProduct:
    name: str
    price: float
    currency: str
    availability: bool
    scraped_at: datetime

class DataNormalizer:
    """Normalisateur de données e-commerce"""
    
    # Patterns de prix par locale
    PRICE_PATTERNS = [
        (r'([ds]+[,.]?d*)s*€', 'EUR'),
        (r'$([d,]+.?d*)', 'USD'),
        (r'£([d,]+.?d*)', 'GBP'),
    ]
    
    def normalize_text(self, text: str) -> str:
        """Nettoie et normalise du texte brut"""
        if not text:
            return ""
        
        # Supprimer les balises HTML résiduelles
        text = re.sub(r'<[^>]+>', '', text)
        
        # Normalisation Unicode (NFC)
        text = unicodedata.normalize('NFC', text)
        
        # Collapse des espaces multiples
        text = re.sub(r's+', ' ', text)
        
        # Trim
        return text.strip()
    
    def normalize_price(self, price_str: str) -> tuple[float, str]:
        """Extrait et normalise un prix avec sa devise"""
        if not price_str:
            return 0.0, 'EUR'
        
        for pattern, currency in self.PRICE_PATTERNS:
            match = re.search(pattern, price_str)
            if match:
                # Nettoyer le nombre
                num_str = match.group(1)
                num_str = num_str.replace(' ', '').replace(',', '.')
                # Gérer le cas "1.299.99" → "1299.99"
                parts = num_str.split('.')
                if len(parts) > 2:
                    num_str = ''.join(parts[:-1]) + '.' + parts[-1]
                return float(num_str), currency
        
        return 0.0, 'EUR'
    
    def normalize_date(self, date_str: str, locale: str = 'fr') -> Optional[datetime]:
        """Parse une date dans divers formats"""
        if not date_str:
            return None
        
        # Utiliser dateparser pour le parsing intelligent
        settings = {
            'PREFER_DAY_OF_MONTH': 'first',
            'PREFER_DATES_FROM': 'past',
            'TIMEZONE': 'Europe/Paris',
            'RETURN_AS_TIMEZONE_AWARE': True
        }
        
        return dateparser.parse(date_str, settings=settings)
    
    def normalize_availability(self, text: str) -> bool:
        """Détecte la disponibilité depuis du texte"""
        text_lower = text.lower()
        
        available_keywords = ['en stock', 'disponible', 'in stock', 'available']
        unavailable_keywords = ['rupture', 'épuisé', 'out of stock', 'indisponible']
        
        if any(kw in text_lower for kw in available_keywords):
            return True
        if any(kw in text_lower for kw in unavailable_keywords):
            return False
        
        return True  # Default
    
    def normalize_product(self, raw_data: dict) -> NormalizedProduct:
        """Normalise un produit complet"""
        price, currency = self.normalize_price(raw_data.get('price', ''))
        
        return NormalizedProduct(
            name=self.normalize_text(raw_data.get('name', '')),
            price=price,
            currency=currency,
            availability=self.normalize_availability(raw_data.get('availability', '')),
            scraped_at=datetime.utcnow()
        )