Upload 1.py with huggingface_hub

1.py

@@ -0,0 +1,1487 @@
+# bot_concours_unified.py - Bot de concours unifié et optimisé
+# Version complète avec toutes les optimisations
+
+import asyncio
+import aiohttp
+from playwright.async_api import async_playwright, Page
+from bs4 import BeautifulSoup
+import requests
+import tweepy
+import pandas as pd
+import time
+import re
+from datetime import datetime, timedelta
+from huggingface_hub import InferenceClient
+import os
+import sys
+import random
+# import google.generativeai as genai  # Supprimé - utilisation d'alternatives locales
+import sqlite3
+import logging
+import imaplib
+import email
+import smtplib
+from email.mime.text import MIMEText
+import schedule
+import hashlib
+import json
+import threading
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import List, Dict, Optional, Tuple
+from urllib.parse import urljoin, urlparse
+
+# =====================================================
+# CONFIGURATION ET DATACLASSES
+# =====================================================
+
+@dataclass
+class PersonalInfo:
+    prenom: str = "Valentin"
+    nom: str = "Cora"
+    email: str = "valouassol@outlook.com"
+    email_derivee: str = "valouassol+concours@outlook.com"
+    telephone: str = "+41791234567"
+    adresse: str = "Av Chantemerle 9"
+    code_postal: str = "1009"
+    ville: str = "Pully"
+    pays: str = "Suisse"
+
+@dataclass
+class APIConfig:
+    hf_token: Optional[str] = None
+    x_token: Optional[str] = None
+    google_api_key: Optional[str] = None
+    google_cx: Optional[str] = None
+    gemini_key: Optional[str] = None
+    email_app_password: Optional[str] = None
+    telegram_bot_token: Optional[str] = None
+    telegram_chat_id: Optional[str] = None
+
+    @classmethod
+    def from_env(cls):
+        return cls(
+            hf_token=os.getenv("HF_TOKEN"),
+            x_token=os.getenv("X_TOKEN"),
+            google_api_key=os.getenv("GOOGLE_API_KEY"),
+            google_cx=os.getenv("GOOGLE_CX"),
+            gemini_key=os.getenv("GEMINI_KEY"),
+            email_app_password=os.getenv("EMAIL_APP_PASSWORD"),
+            telegram_bot_token=os.getenv("TELEGRAM_BOT_TOKEN"),
+            telegram_chat_id=os.getenv("TELEGRAM_CHAT_ID")
+        )
+
+@dataclass
+class Contest:
+    title: str
+    url: str
+    description: str
+    source: str
+    deadline: Optional[str] = None
+    prize: Optional[str] = None
+    difficulty_score: int = 0
+
+@dataclass
+class FormField:
+    selector: str
+    field_type: str
+    label: str
+    required: bool
+    current_value: str = ""
+    ai_context: str = ""
+
+@dataclass
+class FormAnalysis:
+    fields: List[FormField]
+    complexity_score: int
+    estimated_success_rate: float
+    requires_captcha: bool
+    requires_social_media: bool
+    form_url: str
+
+# =====================================================
+# CONFIGURATION GLOBALE
+# =====================================================
+
+# Configuration
+PERSONAL_INFO = PersonalInfo()
+API_CONFIG = APIConfig.from_env()
+
+# Sites suisses à scraper
+SITES_CH = [
+    'https://www.concours.ch/concours/tous',
+    'https://www.jeu-concours.biz/concours-pays_suisse.html',
+    'https://www.loisirs.ch/concours/',
+    'https://www.radin.ch/',
+    'https://win4win.ch/fr/',
+    'https://www.concours-suisse.ch/',
+    'https://corporate.migros.ch/fr/concours',
+    'https://www.20min.ch/fr/concours-et-jeux',
+    'https://dein-gewinnspiel.ch/en',
+    'https://www.myswitzerland.com/fr/planification/vie-pratique/concours/'
+]
+
+# Proxies et User Agents
+PROXY_LIST = ["http://20.206.106.192:80", "http://51.15.242.202:8888"]
+USER_AGENTS = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+]
+
+# Logging setup
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('concours_bot.log'),
+        logging.StreamHandler()
+    ]
+)
+
+# =====================================================
+# GESTIONNAIRE DE BASE DE DONNÉES
+# =====================================================
+
+class DatabaseManager:
+    def __init__(self, db_path: str = 'concours_optimized.sqlite'):
+        self.db_path = db_path
+        self.local = threading.local()
+        self._init_db()
+    
+    def _get_connection(self):
+        if not hasattr(self.local, 'conn'):
+            self.local.conn = sqlite3.connect(self.db_path)
+            self.local.conn.row_factory = sqlite3.Row
+        return self.local.conn
+    
+    @contextmanager
+    def transaction(self):
+        conn = self._get_connection()
+        try:
+            yield conn
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+    
+    def _init_db(self):
+        with self.transaction() as conn:
+            conn.execute('''
+                CREATE TABLE IF NOT EXISTS participations (
+                    url TEXT PRIMARY KEY,
+                    title TEXT,
+                    source TEXT,
+                    status TEXT,
+                    difficulty_score INTEGER,
+                    success_rate REAL,
+                    date TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            ''')
+            conn.execute('''
+                CREATE TABLE IF NOT EXISTS victories (
+                    email_id TEXT PRIMARY KEY,
+                    date TEXT,
+                    lot TEXT,
+                    source TEXT,
+                    confirmed BOOLEAN DEFAULT FALSE,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            ''')
+            conn.execute('''
+                CREATE TABLE IF NOT EXISTS contest_cache (
+                    url TEXT PRIMARY KEY,
+                    content TEXT,
+                    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            ''')
+            # Index pour performances
+            conn.execute('CREATE INDEX IF NOT EXISTS idx_participations_date ON participations(date)')
+            conn.execute('CREATE INDEX IF NOT EXISTS idx_cache_timestamp ON contest_cache(timestamp)')
+    
+    def add_participation(self, contest: Contest, status: str = 'pending', success_rate: float = 0.0):
+        with self.transaction() as conn:
+            conn.execute('''
+                INSERT OR REPLACE INTO participations 
+                (url, title, source, status, difficulty_score, success_rate, date) 
+                VALUES (?, ?, ?, ?, ?, ?, date('now'))
+            ''', (contest.url, contest.title, contest.source, status, contest.difficulty_score, success_rate))
+    
+    def participation_exists(self, url: str) -> bool:
+        conn = self._get_connection()
+        result = conn.execute("SELECT 1 FROM participations WHERE url = ?", (url,)).fetchone()
+        return result is not None
+    
+    def add_victory(self, email_id: str, lot: str, source: str):
+        with self.transaction() as conn:
+            conn.execute('''
+                INSERT OR IGNORE INTO victories (email_id, date, lot, source) 
+                VALUES (?, date('now'), ?, ?)
+            ''', (email_id, lot, source))
+    
+    def get_stats(self) -> Dict:
+        conn = self._get_connection()
+        stats = {}
+        
+        # Statistiques de participations
+        stats['total_participations'] = conn.execute("SELECT COUNT(*) FROM participations").fetchone()[0]
+        stats['successful_participations'] = conn.execute("SELECT COUNT(*) FROM participations WHERE status='success'").fetchone()[0]
+        stats['total_victories'] = conn.execute("SELECT COUNT(*) FROM victories").fetchone()[0]
+        
+        # Participations par source
+        source_stats = conn.execute('''
+            SELECT source, COUNT(*) as count 
+            FROM participations 
+            GROUP BY source 
+            ORDER BY count DESC
+        ''').fetchall()
+        stats['by_source'] = {row[0]: row[1] for row in source_stats}
+        
+        return stats
+
+# =====================================================
+# MOTEUR IA AMÉLIORÉ
+# =====================================================
+
+class AIEngine:
+    def __init__(self, api_config: APIConfig):
+        self.api_config = api_config
+        self.cache = {}
+    
+    def generate_response(self, question: str, context: str = "", response_type: str = "qa") -> str:
+        """Génère une réponse IA avec fallback entre Gemini et HuggingFace"""
+        cache_key = hashlib.md5(f"{question}{context}{response_type}".encode()).hexdigest()
+        
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+        
+        response = self._try_gemini(question, context, response_type)
+        if not response:
+            response = self._try_huggingface(question, context, response_type)
+        
+        if not response:
+            response = self._generate_fallback_response(question, response_type)
+        
+        # Cache la réponse
+        self.cache[cache_key] = response
+        return response
+    
+    def _try_gemini(self, question: str, context: str, response_type: str) -> Optional[str]:
+        # Gemini supprimé - utilisation d'alternatives locales uniquement
+        return None
+    
+    def _try_huggingface(self, question: str, context: str, response_type: str) -> Optional[str]:
+        if not self.api_config.hf_token:
+            return None
+        
+        try:
+            client = InferenceClient(token=self.api_config.hf_token)
+            
+            if response_type == "qa" and context:
+                result = client.question_answering(
+                    question=question, 
+                    context=context, 
+                    model="distilbert-base-cased-distilled-squad"
+                )
+                return result.answer
+            else:
+                prompt = f"Question: {question}\nContexte: {context}\nRéponse:"
+                result = client.text_generation(
+                    prompt, 
+                    model="gpt2", 
+                    max_new_tokens=100, 
+                    temperature=0.7
+                )
+                return result[0]['generated_text'].split('Réponse:')[-1].strip()
+                
+        except Exception as e:
+            logging.warning(f"HuggingFace API error: {e}")
+            return None
+    
+    def _generate_fallback_response(self, question: str, response_type: str) -> str:
+        """Système de réponses intelligentes sans API"""
+        question_lower = question.lower()
+        
+        if response_type == "motivation":
+            # Réponses de motivation personnalisées selon le contexte
+            if any(word in question_lower for word in ["voyage", "vacances", "séjour"]):
+                return random.choice([
+                    "J'adore voyager et découvrir de nouveaux horizons. Ce prix serait une opportunité fantastique pour moi de vivre une expérience inoubliable.",
+                    "Voyager est ma passion et ce concours représente le voyage de mes rêves. J'espère avoir la chance de le remporter.",
+                    "En tant que passionné de voyages, ce prix m'offrirait l'occasion parfaite de découvrir de nouveaux paysages et cultures."
+                ])
+            elif any(word in question_lower for word in ["produit", "cosmétique", "beauté"]):
+                return random.choice([
+                    "Je suis toujours à la recherche de nouveaux produits de qualité et j'aimerais beaucoup tester cette gamme.",
+                    "Ces produits m'intéressent énormément et je serais ravi de pouvoir les découvrir.",
+                    "J'ai entendu beaucoup de bien de cette marque et j'aimerais avoir l'opportunité de l'essayer."
+                ])
+            elif any(word in question_lower for word in ["technologie", "smartphone", "ordinateur"]):
+                return random.choice([
+                    "En tant que passionné de technologie, ce prix m'intéresse beaucoup et m'aiderait dans mes projets.",
+                    "J'ai besoin de ce type d'équipement pour mes études et ce serait formidable de le gagner.",
+                    "La technologie fait partie de ma vie quotidienne et ce prix serait très utile."
+                ])
+            else:
+                return random.choice([
+                    "Je participe avec enthousiasme à ce concours car le prix m'intéresse vraiment et correspond à mes besoins.",
+                    "Ce concours m'attire particulièrement et je serais très heureux de remporter ce magnifique prix.",
+                    "J'espère avoir la chance de gagner car ce prix me ferait énormément plaisir.",
+                    "Je suis motivé à participer car cette opportunité pourrait vraiment changer ma journée."
+                ])
+        
+        elif response_type == "quiz":
+            # Système de réponses intelligentes pour les quiz
+            if "suisse" in question_lower:
+                if "capitale" in question_lower:
+                    return "Berne"
+                elif "langue" in question_lower:
+                    return "Français, Allemand, Italien, Romanche"
+                elif "monnaie" in question_lower:
+                    return "Franc suisse"
+                elif "population" in question_lower:
+                    return "8.7 millions"
+            
+            if "couleur" in question_lower:
+                return random.choice(["Rouge", "Bleu", "Vert", "Jaune"])
+            
+            if any(word in question_lower for word in ["combien", "nombre", "quantité"]):
+                return random.choice(["3", "5", "10", "12", "20"])
+            
+            if any(word in question_lower for word in ["année", "date", "quand"]):
+                return random.choice(["2024", "2023", "2025"])
+            
+            # Réponses par défaut pour quiz
+            return random.choice(["A", "B", "C", "Oui", "Non", "Vrai", "Faux"])
+        
+        # Autres types de réponses
+        response_mapping = {
+            "age": random.choice(["25", "28", "30", "32"]),
+            "profession": random.choice(["Étudiant", "Employé", "Consultant"]),
+            "ville": "Pully",
+            "pays": "Suisse",
+            "default": "Merci"
+        }
+        
+        return response_mapping.get(response_type, response_mapping["default"])
+
+# =====================================================
+# SCRAPER INTELLIGENT
+# =====================================================
+
+class IntelligentScraper:
+    def __init__(self, db_manager: DatabaseManager, cache_duration_hours: int = 6):
+        self.db = db_manager
+        self.cache_duration = timedelta(hours=cache_duration_hours)
+        self.session = None
+        self.field_patterns = {
+            'prenom': r'prenom|prénom|first.*name|nom.*prenom',
+            'nom': r'nom(?!.*prenom)|last.*name|family.*name|surname',
+            'email': r'email|e-mail|courriel',
+            'telephone': r'tel|phone|telephone|téléphone',
+            'adresse': r'adresse|address|rue|street',
+            'code_postal': r'code.postal|zip|postal',
+            'ville': r'ville|city|localité',
+            'pays': r'pays|country|nation',
+            'motivation': r'motivation|pourquoi|why|reason|raison',
+            'quiz': r'question|quiz|réponse|answer'
+        }
+    
+    async def __aenter__(self):
+        connector = aiohttp.TCPConnector(limit=10, limit_per_host=3)
+        timeout = aiohttp.ClientTimeout(total=30, connect=10)
+        self.session = aiohttp.ClientSession(
+            connector=connector,
+            timeout=timeout,
+            headers={'User-Agent': random.choice(USER_AGENTS)}
+        )
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.session:
+            await self.session.close()
+    
+    async def scrape_all_sources(self) -> List[Contest]:
+        """Scrape tous les sites et sources"""
+        all_contests = []
+        
+        # Scraper les sites web
+        web_contests = await self._scrape_websites()
+        all_contests.extend(web_contests)
+        
+        # Scraper Google Search
+        google_contests = await self._scrape_google_search()
+        all_contests.extend(google_contests)
+        
+        # Scraper Twitter/X
+        twitter_contests = await self._scrape_twitter()
+        all_contests.extend(twitter_contests)
+        
+        # Filtrer les doublons et concours déjà traités
+        unique_contests = self._filter_unique_contests(all_contests)
+        
+        logging.info(f"Total contests found: {len(all_contests)}, unique new: {len(unique_contests)}")
+        return unique_contests
+    
+    async def _scrape_websites(self) -> List[Contest]:
+        """Scrape les sites web en parallèle"""
+        batch_size = 3
+        all_contests = []
+        
+        for i in range(0, len(SITES_CH), batch_size):
+            batch = SITES_CH[i:i + batch_size]
+            tasks = [self._scrape_single_site(site) for site in batch]
+            
+            batch_results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            for result in batch_results:
+                if isinstance(result, list):
+                    all_contests.extend(result)
+                elif isinstance(result, Exception):
+                    logging.error(f"Batch scraping error: {result}")
+            
+            await asyncio.sleep(2)  # Pause entre batches
+        
+        return all_contests
+    
+    async def _scrape_single_site(self, url: str) -> List[Contest]:
+        """Scrape un site web spécifique"""
+        try:
+            content = await self._fetch_with_retry(url)
+            if not content:
+                return []
+            
+            soup = BeautifulSoup(content, 'html.parser')
+            contests = self._extract_contests_from_soup(soup, url)
+            
+            logging.info(f"Found {len(contests)} contests on {url}")
+            return contests
+            
+        except Exception as e:
+            logging.error(f"Error scraping {url}: {e}")
+            return []
+    
+    async def _fetch_with_retry(self, url: str, max_retries: int = 3) -> Optional[str]:
+        """Fetch avec retry et gestion d'erreurs"""
+        for attempt in range(max_retries):
+            try:
+                proxy = random.choice(PROXY_LIST) if PROXY_LIST else None
+                async with self.session.get(url, proxy=proxy) as response:
+                    if response.status == 200:
+                        return await response.text()
+                    elif response.status == 429:
+                        wait_time = 2 ** attempt * 5
+                        logging.warning(f"Rate limited on {url}, waiting {wait_time}s")
+                        await asyncio.sleep(wait_time)
+                    else:
+                        logging.warning(f"HTTP {response.status} for {url}")
+                        
+            except Exception as e:
+                logging.error(f"Attempt {attempt+1} failed for {url}: {e}")
+                if attempt < max_retries - 1:
+                    await asyncio.sleep(2 ** attempt)
+        
+        return None
+    
+    def _extract_contests_from_soup(self, soup: BeautifulSoup, base_url: str) -> List[Contest]:
+        """Extrait les concours d'une page HTML"""
+        contests = []
+        
+        # Sélecteurs pour différents types de conteneurs
+        selectors = [
+            '.contest', '.concours', '.jeu', '.competition', '.giveaway',
+            '[data-contest]', '[data-concours]', '.prize', '.lot',
+            'article[class*="concours"]', '.entry', '.participate'
+        ]
+        
+        containers = []
+        for selector in selectors:
+            containers.extend(soup.select(selector))
+        
+        # Fallback: chercher des liens avec mots-clés
+        if not containers:
+            containers = soup.find_all('a', href=re.compile(r'concours|jeu|contest|participate', re.I))
+        
+        for container in containers[:20]:  # Limiter pour éviter le spam
+            try:
+                contest = self._parse_contest_container(container, base_url)
+                if contest and self._is_valid_contest(contest):
+                    contests.append(contest)
+            except Exception as e:
+                logging.debug(f"Error parsing container: {e}")
+        
+        return contests
+    
+    def _parse_contest_container(self, container, base_url: str) -> Optional[Contest]:
+        """Parse un conteneur de concours"""
+        # Extraire le titre
+        title_selectors = ['h1', 'h2', 'h3', '.title', '.titre', '.contest-title']
+        title = ""
+        for selector in title_selectors:
+            title_elem = container.select_one(selector)
+            if title_elem:
+                title = title_elem.get_text(strip=True)
+                break
+        
+        if not title:
+            title = container.get_text(strip=True)[:100]
+        
+        # Extraire le lien
+        url = ""
+        link_elem = container if container.name == 'a' else container.find('a')
+        if link_elem and link_elem.get('href'):
+            url = urljoin(base_url, link_elem['href'])
+        
+        # Extraire la description
+        description = container.get_text(strip=True)[:500]
+        
+        # Extraire deadline et prix
+        deadline = self._extract_deadline(description)
+        prize = self._extract_prize(description)
+        
+        if not title or not url:
+            return None
+        
+        return Contest(
+            title=title[:200],
+            url=url,
+            description=description,
+            source=base_url,
+            deadline=deadline,
+            prize=prize,
+            difficulty_score=self._estimate_difficulty(description)
+        )
+    
+    def _extract_deadline(self, text: str) -> Optional[str]:
+        """Extrait la date limite du texte"""
+        patterns = [
+            r"jusqu[\'']?au (\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})",
+            r"avant le (\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})",
+            r"fin le (\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})"
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, text, re.I)
+            if match:
+                return match.group(1)
+        return None
+    
+    def _extract_prize(self, text: str) -> Optional[str]:
+        """Extrait le prix du texte"""
+        patterns = [
+            r"gagne[rz]?\s+([^.!?]{1,50})",
+            r"prix[:\s]+([^.!?]{1,50})",
+            r"lot[:\s]+([^.!?]{1,50})",
+            r"(\d+\s*CHF|\d+\s*euros?|\d+\s*francs?)"
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, text, re.I)
+            if match:
+                return match.group(1).strip()
+        return None
+    
+    def _estimate_difficulty(self, description: str) -> int:
+        """Estime la difficulté de participation (0-10)"""
+        difficulty = 0
+        
+        if re.search(r'justifi|motivation|pourquoi|essay', description, re.I):
+            difficulty += 3
+        if re.search(r'photo|image|créat', description, re.I):
+            difficulty += 2
+        if re.search(r'quiz|question|répond', description, re.I):
+            difficulty += 1
+        if re.search(r'partag|social|facebook|twitter', description, re.I):
+            difficulty += 1
+        if re.search(r'inscription|compte|profil', description, re.I):
+            difficulty += 1
+        
+        return min(difficulty, 10)
+    
+    def _is_valid_contest(self, contest: Contest) -> bool:
+        """Valide qu'un concours est légitime"""
+        swiss_indicators = [
+            'suisse', 'switzerland', 'ch', 'romandie', 'genève', 'lausanne',
+            'zurich', 'bern', 'ouvert en suisse', 'résidents suisses'
+        ]
+        
+        full_text = (contest.title + " " + contest.description).lower()
+        has_swiss_access = any(indicator in full_text for indicator in swiss_indicators)
+        
+        excluded_terms = [
+            'payant', 'payment', 'carte bancaire', 'spam', 'phishing',
+            'adult', 'casino', 'bitcoin', 'crypto', 'investment'
+        ]
+        
+        has_excluded = any(term in full_text for term in excluded_terms)
+        valid_url = contest.url.startswith(('http://', 'https://'))
+        
+        return has_swiss_access and not has_excluded and valid_url
+    
+    async def _scrape_google_search(self) -> List[Contest]:
+        """Scrape via Google Custom Search API"""
+        if not API_CONFIG.google_api_key or not API_CONFIG.google_cx:
+            return []
+        
+        try:
+            query = "concours gratuit Suisse 2025 site:.ch"
+            response = requests.get(
+                "https://www.googleapis.com/customsearch/v1",
+                params={
+                    "key": API_CONFIG.google_api_key,
+                    "cx": API_CONFIG.google_cx,
+                    "q": query,
+                    "num": 10
+                },
+                timeout=10
+            )
+            
+            results = response.json().get('items', [])
+            contests = []
+            
+            for res in results:
+                title = res.get('title', '')
+                url = res.get('link', '')
+                description = res.get('snippet', '')
+                
+                contest = Contest(
+                    title=title,
+                    url=url,
+                    description=description,
+                    source='Google Search',
+                    difficulty_score=self._estimate_difficulty(description)
+                )
+                
+                if self._is_valid_contest(contest):
+                    contests.append(contest)
+            
+            logging.info(f"Found {len(contests)} contests via Google Search")
+            return contests
+            
+        except Exception as e:
+            logging.error(f"Google Search API error: {e}")
+            return []
+    
+    async def _scrape_twitter(self) -> List[Contest]:
+        """Scrape Twitter/X pour les concours"""
+        if not API_CONFIG.x_token:
+            return []
+        
+        try:
+            client = tweepy.Client(bearer_token=API_CONFIG.x_token)
+            tweets = client.search_recent_tweets(
+                query="concours gratuit Suisse lang:fr", 
+                max_results=10
+            )
+            
+            contests = []
+            if tweets.data:
+                for tweet in tweets.data:
+                    if self._is_swiss_accessible(tweet.text):
+                        contest = Contest(
+                            title=tweet.text[:50] + "...",
+                            url=f"https://x.com/i/status/{tweet.id}",
+                            description=tweet.text,
+                            source='Twitter/X',
+                            difficulty_score=5  # Score moyen pour les tweets
+                        )
+                        contests.append(contest)
+            
+            logging.info(f"Found {len(contests)} contests on Twitter/X")
+            return contests
+            
+        except Exception as e:
+            logging.error(f"Twitter/X API error: {e}")
+            return []
+    
+    def _is_swiss_accessible(self, text: str) -> bool:
+        """Vérifie si accessible depuis la Suisse"""
+        swiss_pattern = r"(suisse|ch|romandie|ouvert\s+a\s+la\s+suisse|geneve|lausanne)"
+        return bool(re.search(swiss_pattern, text.lower(), re.IGNORECASE))
+    
+    def _filter_unique_contests(self, contests: List[Contest]) -> List[Contest]:
+        """Filtre les concours uniques et non déjà traités"""
+        unique_contests = []
+        seen_urls = set()
+        
+        for contest in contests:
+            if contest.url not in seen_urls and not self.db.participation_exists(contest.url):
+                unique_contests.append(contest)
+                seen_urls.add(contest.url)
+        
+        return unique_contests
+
+# =====================================================
+# SYSTÈME DE PARTICIPATION INTELLIGENT
+# =====================================================
+
+class SmartParticipator:
+    def __init__(self, db_manager: DatabaseManager, ai_engine: AIEngine):
+        self.db = db_manager
+        self.ai = ai_engine
+        self.personal_info = PERSONAL_INFO
+        
+        self.field_patterns = {
+            'prenom': [r'prenom|prénom|first.*name'],
+            'nom': [r'nom(?!.*prenom)|last.*name|family.*name'],
+            'email': [r'email|e-mail|courriel'],
+            'telephone': [r'tel|phone|telephone|téléphone'],
+            'adresse': [r'adresse|address|rue|street'],
+            'code_postal': [r'code.postal|zip|postal'],
+            'ville': [r'ville|city|localité'],
+            'pays': [r'pays|country|nation'],
+            'motivation': [r'motivation|pourquoi|why|reason'],
+            'quiz': [r'question|quiz|réponse|answer']
+        }
+    
+    async def participate_in_contest(self, contest: Contest) -> bool:
+        """Participe à un concours de manière intelligente"""
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(
+                headless=True,
+                args=['--no-sandbox', '--disable-blink-features=AutomationControlled']
+            )
+            
+            context = await browser.new_context(
+                user_agent=random.choice(USER_AGENTS),
+                viewport={'width': 1920, 'height': 1080}
+            )
+            
+            page = await context.new_page()
+            
+            try:
+                # Analyser le formulaire
+                analysis = await self._analyze_form(page, contest.url)
+                
+                if analysis.estimated_success_rate < 0.3:
+                    logging.warning(f"Low success rate for {contest.url}: {analysis.estimated_success_rate}")
+                    self.db.add_participation(contest, 'skipped_low_success', analysis.estimated_success_rate)
+                    return False
+                
+                if analysis.requires_captcha:
+                    logging.warning(f"CAPTCHA detected for {contest.url}, skipping")
+                    self.db.add_participation(contest, 'skipped_captcha', analysis.estimated_success_rate)
+                    return False
+                
+                # Remplir et soumettre le formulaire
+                success = await self._fill_and_submit_form(page, analysis, contest)
+                
+                status = 'success' if success else 'failed'
+                self.db.add_participation(contest, status, analysis.estimated_success_rate)
+                
+                logging.info(f"Participation {'successful' if success else 'failed'} for {contest.title}")
+                return success
+                
+            except Exception as e:
+                logging.error(f"Participation error for {contest.url}: {e}")
+                self.db.add_participation(contest, 'error', 0.0)
+                return False
+                
+            finally:
+                await browser.close()
+    
+    async def _analyze_form(self, page: Page, url: str) -> FormAnalysis:
+        """Analyse un formulaire de concours"""
+        try:
+            await page.goto(url, wait_until='networkidle', timeout=15000)
+            
+            # Détecter les champs
+            fields = await self._detect_form_fields(page)
+            
+            # Calculer la complexité
+            complexity = sum(self._calculate_field_complexity(field) for field in fields)
+            
+            # Détecter les éléments bloquants
+            has_captcha = await self._detect_captcha(page)
+            has_social_requirements = await self._detect_social_requirements(page)
+            
+            # Estimer le taux de succès
+            success_rate = self._estimate_success_rate(fields, complexity, has_captcha)
+            
+            return FormAnalysis(
+                fields=fields,
+                complexity_score=complexity,
+                estimated_success_rate=success_rate,
+                requires_captcha=has_captcha,
+                requires_social_media=has_social_requirements,
+                form_url=url
+            )
+            
+        except Exception as e:
+            logging.error(f"Form analysis error: {e}")
+            return FormAnalysis([], 10, 0.0, True, True, url)
+    
+    async def _detect_form_fields(self, page: Page) -> List[FormField]:
+        """Détecte tous les champs de formulaire"""
+        fields = []
+        
+        selectors = [
+            'input[type="text"]', 'input[type="email"]', 'input[type="tel"]',
+            'input[type="number"]', 'input:not([type])', 'textarea', 'select'
+        ]
+        
+        for selector in selectors:
+            elements = await page.query_selector_all(selector)
+            
+            for element in elements:
+                try:
+                    field = await self._analyze_single_field(element, page)
+                    if field:
+                        fields.append(field)
+                except Exception:
+                    continue
+        
+        return fields
+    
+    async def _analyze_single_field(self, element, page: Page) -> Optional[FormField]:
+        """Analyse un champ individuel"""
+        try:
+            tag_name = await element.evaluate('el => el.tagName.toLowerCase()')
+            field_type = await element.evaluate('el => el.type || el.tagName.toLowerCase()')
+            name = await element.evaluate('el => el.name || el.id || ""')
+            placeholder = await element.evaluate('el => el.placeholder || ""')
+            required = await element.evaluate('el => el.required')
+            
+            # Trouver le label
+            label_text = await self._find_field_label(element, page)
+            
+            # Créer un sélecteur unique
+            selector = await self._create_unique_selector(element)
+            
+            return FormField(
+                selector=selector,
+                field_type=field_type,
+                label=label_text,
+                required=required,
+                ai_context=f"Name: {name}, Placeholder: {placeholder}, Label: {label_text}"
+            )
+            
+        except Exception:
+            return None
+    
+    async def _find_field_label(self, element, page: Page) -> str:
+        """Trouve le label associé à un champ"""
+        try:
+            # Méthode 1: label[for]
+            element_id = await element.evaluate('el => el.id')
+            if element_id:
+                label = await page.query_selector(f'label[for="{element_id}"]')
+                if label:
+                    return await label.inner_text()
+            
+            # Méthode 2: parent label
+            parent_label = await element.evaluate('''
+                el => {
+                    let parent = el.parentElement;
+                    while (parent && parent.tagName !== 'BODY') {
+                        if (parent.tagName === 'LABEL') {
+                            return parent.innerText;
+                        }
+                        parent = parent.parentElement;
+                    }
+                    return '';
+                }
+            ''')
+            
+            if parent_label:
+                return parent_label.strip()
+            
+            # Méthode 3: texte précédent
+            prev_text = await element.evaluate('''
+                el => {
+                    const prev = el.previousElementSibling;
+                    return prev ? prev.innerText : '';
+                }
+            ''')
+            
+            return prev_text.strip()
+            
+        except Exception:
+            return ""
+    
+    async def _create_unique_selector(self, element) -> str:
+        """Crée un sélecteur CSS unique"""
+        # Priorité: ID > Name > Class > Position
+        element_id = await element.evaluate('el => el.id')
+        if element_id:
+            return f'#{element_id}'
+        
+        name = await element.evaluate('el => el.name')
+        if name:
+            return f'[name="{name}"]'
+        
+        class_name = await element.evaluate('el => el.className')
+        tag_name = await element.evaluate('el => el.tagName.toLowerCase()')
+        
+        if class_name:
+            return f'{tag_name}.{class_name.split()[0]}'
+        
+        # Fallback
+        return f'{tag_name}:nth-of-type(1)'
+    
+    def _calculate_field_complexity(self, field: FormField) -> int:
+        """Calcule la complexité d'un champ"""
+        complexity = 1
+        
+        if field.field_type == 'textarea':
+            complexity += 3
+        elif field.field_type == 'select':
+            complexity += 2
+        elif field.required:
+            complexity += 1
+        
+        if re.search(r'motivation|justifi|pourquoi', field.label, re.I):
+            complexity += 3
+        elif re.search(r'quiz|question', field.label, re.I):
+            complexity += 2
+        
+        return complexity
+    
+    async def _detect_captcha(self, page: Page) -> bool:
+        """Détecte la présence de CAPTCHA"""
+        captcha_selectors = [
+            '.g-recaptcha', '.h-captcha', '#captcha', '.captcha',
+            'iframe[src*="recaptcha"]', 'iframe[src*="hcaptcha"]'
+        ]
+        
+        for selector in captcha_selectors:
+            element = await page.query_selector(selector)
+            if element:
+                return True
+        
+        return False
+    
+    async def _detect_social_requirements(self, page: Page) -> bool:
+        """Détecte les exigences de réseaux sociaux"""
+        content = await page.content()
+        social_patterns = [
+            r'follow.*us', r'partag.*facebook', r'retweet',
+            r'like.*page', r'subscribe.*channel'
+        ]
+        
+        for pattern in social_patterns:
+            if re.search(pattern, content, re.I):
+                return True
+        
+        return False
+    
+    def _estimate_success_rate(self, fields: List[FormField], complexity: int, has_captcha: bool) -> float:
+        """Estime le taux de succès"""
+        base_rate = 0.8
+        
+        if has_captcha:
+            base_rate *= 0.1
+        
+        if complexity > 15:
+            base_rate *= 0.4
+        elif complexity > 10:
+            base_rate *= 0.6
+        elif complexity > 5:
+            base_rate *= 0.8
+        
+        required_fields = [f for f in fields if f.required]
+        if len(required_fields) <= 3:
+            base_rate *= 1.1
+        
+        return min(base_rate, 1.0)
+    
+    async def _fill_and_submit_form(self, page: Page, analysis: FormAnalysis, contest: Contest) -> bool:
+        """Remplit et soumet le formulaire"""
+        try:
+            filled_fields = 0
+            
+            for field in analysis.fields:
+                try:
+                    # Attendre l'élément
+                    await page.wait_for_selector(field.selector, timeout=3000)
+                    element = await page.query_selector(field.selector)
+                    
+                    if not element:
+                        continue
+                    
+                    # Générer la valeur
+                    value = await self._generate_field_value(field, contest, page)
+                    if not value:
+                        continue
+                    
+                    # Remplir selon le type
+                    if field.field_type == 'select':
+                        await self._fill_select_field(element, value, page)
+                    else:
+                        await element.fill(value)
+                    
+                    filled_fields += 1
+                    await asyncio.sleep(random.uniform(0.3, 0.8))
+                    
+                except Exception as e:
+                    logging.debug(f"Error filling field {field.selector}: {e}")
+                    continue
+            
+            # Soumettre le formulaire
+            submit_success = await self._submit_form(page)
+            
+            logging.info(f"Filled {filled_fields}/{len(analysis.fields)} fields, submitted: {submit_success}")
+            return filled_fields > 0 and submit_success
+            
+        except Exception as e:
+            logging.error(f"Form filling error: {e}")
+            return False
+    
+    async def _generate_field_value(self, field: FormField, contest: Contest, page: Page) -> Optional[str]:
+        """Génère une valeur pour un champ"""
+        # Identifier le type de champ
+        field_type = self._identify_field_type(field)
+        
+        # Mapping des valeurs personnelles
+        personal_mapping = {
+            'prenom': self.personal_info.prenom,
+            'nom': self.personal_info.nom,
+            'email': self.personal_info.email_derivee,
+            'telephone': self.personal_info.telephone,
+            'adresse': self.personal_info.adresse,
+            'code_postal': self.personal_info.code_postal,
+            'ville': self.personal_info.ville,
+            'pays': self.personal_info.pays
+        }
+        
+        if field_type in personal_mapping:
+            return personal_mapping[field_type]
+        
+        # Cas spéciaux nécessitant l'IA
+        if field_type == 'motivation':
+            return self.ai.generate_response(
+                field.label, 
+                contest.description, 
+                "motivation"
+            )
+        elif field_type == 'quiz':
+            return self.ai.generate_response(
+                field.label, 
+                contest.description, 
+                "quiz"
+            )
+        
+        # Valeurs par défaut
+        default_values = {
+            'age': '25',
+            'genre': 'Monsieur',
+            'profession': 'Étudiant'
+        }
+        
+        for key, value in default_values.items():
+            if key in field.label.lower():
+                return value
+        
+        return None
+    
+    def _identify_field_type(self, field: FormField) -> str:
+        """Identifie le type de champ"""
+        combined_text = f"{field.ai_context} {field.label}".lower()
+        
+        for field_type, patterns in self.field_patterns.items():
+            for pattern in patterns:
+                if re.search(pattern, combined_text, re.I):
+                    return field_type
+        
+        return 'unknown'
+    
+    async def _fill_select_field(self, element, value: str, page: Page):
+        """Remplit un champ select"""
+        try:
+            options = await element.query_selector_all('option')
+            
+            for option in options:
+                option_text = await option.inner_text()
+                option_value = await option.get_attribute('value')
+                
+                if (value.lower() in option_text.lower() or 
+                    value.lower() in (option_value or "").lower()):
+                    await element.select_option(value=option_value)
+                    return
+            
+            # Fallback: sélectionner la première option valide
+            if options and len(options) > 1:
+                first_option = await options[1].get_attribute('value')
+                await element.select_option(value=first_option)
+                
+        except Exception as e:
+            logging.debug(f"Select field error: {e}")
+    
+    async def _submit_form(self, page: Page) -> bool:
+        """Soumet le formulaire"""
+        submit_selectors = [
+            'input[type="submit"]',
+            'button[type="submit"]',
+            'button:has-text("Participer")',
+            'button:has-text("Envoyer")',
+            'button:has-text("Valider")',
+            '.submit-btn',
+            '.participate-btn'
+        ]
+        
+        for selector in submit_selectors:
+            try:
+                element = await page.query_selector(selector)
+                if element:
+                    is_visible = await element.is_visible()
+                    is_enabled = await element.is_enabled()
+                    
+                    if is_visible and is_enabled:
+                        await element.click()
+                        await page.wait_for_timeout(3000)
+                        return True
+                        
+            except Exception:
+                continue
+        
+        return False
+
+# =====================================================
+# GESTIONNAIRE D'EMAILS ET ALERTES
+# =====================================================
+
+class EmailManager:
+    def __init__(self, api_config: APIConfig, ai_engine: AIEngine, db_manager: DatabaseManager):
+        self.api_config = api_config
+        self.ai = ai_engine
+        self.db = db_manager
+        self.personal_info = PERSONAL_INFO
+    
+    def check_and_analyze_emails(self):
+        """Vérifie et analyse les emails pour détecter les victoires"""
+        if not self.api_config.email_app_password:
+            logging.warning("Email app password not configured")
+            return
+        
+        try:
+            mail = imaplib.IMAP4_SSL('outlook.office365.com')
+            mail.login(self.personal_info.email, self.api_config.email_app_password)
+            mail.select('inbox')
+            
+            # Chercher les emails récents
+            since_date = (datetime.now() - timedelta(days=7)).strftime('%d-%b-%Y')
+            status, messages = mail.search(None, f'(SINCE "{since_date}")')
+            
+            victories = []
+            email_count = 0
+            
+            for num in messages[0].split()[-20:]:  # Limiter aux 20 derniers
+                try:
+                    email_count += 1
+                    _, msg = mail.fetch(num, '(RFC822)')
+                    email_msg = email.message_from_bytes(msg[0][1])
+                    
+                    subject = email_msg['Subject'] or ""
+                    from_addr = email_msg['From'] or ""
+                    
+                    # Extraire le corps de l'email
+                    body = self._extract_email_body(email_msg)
+                    
+                    # Analyser avec l'IA
+                    analysis = self.ai.generate_response(
+                        f"Cet email indique-t-il une victoire dans un concours ? Sujet: {subject}",
+                        body[:1000],
+                        "quiz"
+                    )
+                    
+                    if 'oui' in analysis.lower() or 'gagne' in analysis.lower():
+                        prize = self._extract_prize_from_email(body, subject)
+                        victories.append({
+                            'email_id': num.decode(),
+                            'date': datetime.now().strftime('%Y-%m-%d'),
+                            'prize': prize,
+                            'source': from_addr,
+                            'subject': subject
+                        })
+                        
+                        # Enregistrer en base
+                        self.db.add_victory(num.decode(), prize, from_addr)
+                        
+                        # Envoyer alerte
+                        self._send_victory_alert(prize, from_addr, subject)
+                        
+                        logging.info(f"Victory detected: {prize} from {from_addr}")
+                
+                except Exception as e:
+                    logging.error(f"Error processing email {num}: {e}")
+                    continue
+            
+            mail.logout()
+            logging.info(f"Processed {email_count} emails, found {len(victories)} victories")
+            
+        except Exception as e:
+            logging.error(f"Email checking error: {e}")
+    
+    def _extract_email_body(self, email_msg) -> str:
+        """Extrait le corps de l'email"""
+        body = ""
+        
+        if email_msg.is_multipart():
+            for part in email_msg.walk():
+                if part.get_content_type() == 'text/plain':
+                    try:
+                        body = part.get_payload(decode=True).decode('utf-8', errors='ignore')
+                        break
+                    except:
+                        continue
+        else:
+            try:
+                body = email_msg.get_payload(decode=True).decode('utf-8', errors='ignore')
+            except:
+                body = str(email_msg.get_payload())
+        
+        return body
+    
+    def _extract_prize_from_email(self, body: str, subject: str) -> str:
+        """Extrait le prix gagné de l'email"""
+        text = f"{subject} {body}"
+        
+        prize_patterns = [
+            r"vous avez gagné\s+([^.!?\n]{1,100})",
+            r"prix[:\s]+([^.!?\n]{1,100})",
+            r"lot[:\s]+([^.!?\n]{1,100})",
+            r"remporté\s+([^.!?\n]{1,100})",
+            r"(\d+\s*CHF|\d+\s*euros?|\d+\s*francs?)"
+        ]
+        
+        for pattern in prize_patterns:
+            match = re.search(pattern, text, re.I)
+            if match:
+                return match.group(1).strip()
+        
+        return "Prix non spécifié"
+    
+    def _send_victory_alert(self, prize: str, source: str, subject: str):
+        """Envoie une alerte de victoire"""
+        if not self.api_config.telegram_bot_token or not self.api_config.telegram_chat_id:
+            return
+        
+        message = f"""
+🎉 **VICTOIRE DÉTECTÉE !**
+
+🏆 **Prix**: {prize}
+📧 **Source**: {source}
+📋 **Sujet**: {subject}
+📅 **Date**: {datetime.now().strftime('%d/%m/%Y %H:%M')}
+
+Félicitations ! 🎊
+        """
+        
+        try:
+            url = f"https://api.telegram.org/bot{self.api_config.telegram_bot_token}/sendMessage"
+            payload = {
+                'chat_id': self.api_config.telegram_chat_id,
+                'text': message,
+                'parse_mode': 'Markdown'
+            }
+            
+            response = requests.post(url, json=payload, timeout=10)
+            if response.status_code == 200:
+                logging.info("Victory alert sent successfully")
+            else:
+                logging.error(f"Telegram alert failed: {response.text}")
+                
+        except Exception as e:
+            logging.error(f"Telegram alert error: {e}")
+
+# =====================================================
+# SYSTÈME DE MONITORING ET STATISTIQUES
+# =====================================================
+
+class MonitoringSystem:
+    def __init__(self, db_manager: DatabaseManager):
+        self.db = db_manager
+    
+    def generate_daily_report(self) -> str:
+        """Génère un rapport quotidien"""
+        stats = self.db.get_stats()
+        
+        # Statistiques du jour
+        today = datetime.now().strftime('%Y-%m-%d')
+        conn = self.db._get_connection()
+        
+        today_participations = conn.execute(
+            "SELECT COUNT(*) FROM participations WHERE date = ?", (today,)
+        ).fetchone()[0]
+        
+        today_successes = conn.execute(
+            "SELECT COUNT(*) FROM participations WHERE date = ? AND status = 'success'", (today,)
+        ).fetchone()[0]
+        
+        success_rate = (today_successes / max(today_participations, 1)) * 100
+        
+        report = f"""
+📊 **RAPPORT QUOTIDIEN - {today}**
+
+🎯 **Aujourd'hui**:
+   • Participations: {today_participations}
+   • Succès: {today_successes}
+   • Taux de succès: {success_rate:.1f}%
+
+📈 **Total**:
+   • Participations totales: {stats['total_participations']}
+   • Participations réussies: {stats['successful_participations']}
+   • Victoires détectées: {stats['total_victories']}
+
+🌐 **Par source**:
+"""
+        
+        for source, count in stats['by_source'].items():
+            report += f"   • {source}: {count}\n"
+        
+        return report
+    
+    def send_daily_report(self):
+        """Envoie le rapport quotidien"""
+        if not API_CONFIG.telegram_bot_token or not API_CONFIG.telegram_chat_id:
+            return
+        
+        report = self.generate_daily_report()
+        
+        try:
+            url = f"https://api.telegram.org/bot{API_CONFIG.telegram_bot_token}/sendMessage"
+            payload = {
+                'chat_id': API_CONFIG.telegram_chat_id,
+                'text': report,
+                'parse_mode': 'Markdown'
+            }
+            
+            response = requests.post(url, json=payload, timeout=10)
+            if response.status_code == 200:
+                logging.info("Daily report sent successfully")
+            else:
+                logging.error(f"Daily report failed: {response.text}")
+                
+        except Exception as e:
+            logging.error(f"Daily report error: {e}")
+
+# =====================================================
+# ORCHESTRATEUR PRINCIPAL
+# =====================================================
+
+class ContestBotOrchestrator:
+    def __init__(self):
+        self.db = DatabaseManager()
+        self.ai = AIEngine(API_CONFIG)
+        self.scraper = None  # Initialisé dans le contexte async
+        self.participator = SmartParticipator(self.db, self.ai)
+        self.email_manager = EmailManager(API_CONFIG, self.ai, self.db)
+        self.monitor = MonitoringSystem(self.db)
+    
+    async def run_full_cycle(self):
+        """Execute un cycle complet de scraping et participation"""
+        logging.info("Starting full contest bot cycle")
+        
+        try:
+            # 1. Scraping des concours
+            async with IntelligentScraper(self.db) as scraper:
+                self.scraper = scraper
+                contests = await scraper.scrape_all_sources()
+            
+            if not contests:
+                logging.info("No new contests found")
+                return
+            
+            # 2. Trier par score de difficulté (plus faciles en premier)
+            contests.sort(key=lambda x: x.difficulty_score)
+            
+            # 3. Participer aux concours (limiter à 20 par jour)
+            participation_count = 0
+            max_daily_participations = 20
+            
+            for contest in contests[:max_daily_participations]:
+                try:
+                    # Pause entre participations pour éviter la détection
+                    if participation_count > 0:
+                        wait_time = random.uniform(30, 120)  # 30s à 2min
+                        logging.info(f"Waiting {wait_time:.0f}s before next participation")
+                        await asyncio.sleep(wait_time)
+                    
+                    success = await self.participator.participate_in_contest(contest)
+                    participation_count += 1
+                    
+                    if success:
+                        logging.info(f"✅ Successfully participated in: {contest.title}")
+                    else:
+                        logging.warning(f"❌ Failed to participate in: {contest.title}")
+                    
+                    # Pause plus longue après succès
+                    if success:
+                        await asyncio.sleep(random.uniform(60, 180))
+                    
+                except Exception as e:
+                    logging.error(f"Error participating in {contest.title}: {e}")
+                    continue
+            
+            logging.info(f"Participation cycle completed: {participation_count} attempts")
+            
+        except Exception as e:
+            logging.error(f"Full cycle error: {e}")
+    
+    def run_email_check(self):
+        """Vérifie les emails pour les victoires"""
+        try:
+            logging.info("Checking emails for victories")
+            self.email_manager.check_and_analyze_emails()
+        except Exception as e:
+            logging.error(f"Email check error: {e}")
+    
+    def run_daily_report(self):
+        """Génère et envoie le rapport quotidien"""
+        try:
+            logging.info("Generating daily report")
+            self.monitor.send_daily_report()
+        except Exception as e:
+            logging.error(f"Daily report error: {e}")
+
+# =====================================================
+# SCHEDULER ET POINT D'ENTRÉE
+# =====================================================
+
+def run_bot_cycle():
+    """Point d'entrée pour le scheduler"""
+    bot = ContestBotOrchestrator()
+    
+    # Cycle principal
+    asyncio.run(bot.run_full_cycle())
+    
+    # Vérification des emails
+    bot.run_email_check()
+
+def run_daily_report():
+    """Point d'entrée pour le rapport quotidien"""
+    bot = ContestBotOrchestrator()
+    bot.run_daily_report()
+
+def main():
+    """Fonction principale avec scheduler"""
+    logging.info("Starting Contest Bot with scheduler")
+    
+    # Programmer les tâches
+    schedule.every().day.at("08:00").do(run_bot_cycle)
+    schedule.every().day.at("14:00").do(run_bot_cycle)  # Deux fois par jour
+    schedule.every().day.at("20:00").do(run_daily_report)
+    
+    # Exécution immédiate pour test
+    if len(sys.argv) > 1 and sys.argv[1] == "--run-now":
+        logging.info("Running immediate cycle")
+        run_bot_cycle()
+        return
+    
+    # Boucle principale du scheduler
+    logging.info("Scheduler started. Waiting for scheduled tasks...")
+    
+    while True:
+        try:
+            schedule.run_pending()
+            time.sleep(60)  # Vérifier chaque minute
+        except KeyboardInterrupt:
+            logging.info("Bot stopped by user")
+            break
+        except Exception as e:
+            logging.error(f"Scheduler error: {e}")
+            time.sleep(300)  # Attendre 5 minutes en cas d'erreur
+
+if __name__ == "__main__":
+    main()