Update app.py

app.py

@@ -2,20 +2,13 @@ from flask import Flask, request, render_template, jsonify
 import PIL.Image
 from google import genai
 from google.genai import types
-import telebot
+
+
 import os
 from tempfile import NamedTemporaryFile
 import tempfile
-from datetime import datetime
-import logging
-import time
-
 app = Flask(__name__)
 
-# Configuration du logging pour débugger
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
 # Configuration de Gemini
 generation_config = {
   "temperature": 1,
@@ -41,238 +34,22 @@ safety_settings = [
     ),
 ]
 
-# Configuration des tokens et IDs
 GOOGLE_API_KEY = os.environ.get("TOKEN")
-TELEGRAM_BOT_TOKEN = "8180304240:AAGJZ_MJ6eKtbymxkqzjgOJCr6PWb7uas9U"
-TELEGRAM_CHAT_ID = "-4972732072"
+
+#genai.configure(api_key=GOOGLE_API_KEY)
 
 gen = GOOGLE_API_KEY 
 client = genai.Client(api_key=gen)
 
-# Initialisation du bot Telegram avec options avancées
-try:
-    bot = telebot.TeleBot(
-        TELEGRAM_BOT_TOKEN,
-        parse_mode='HTML',
-        disable_web_page_preview=True,
-        timeout=60,  # Timeout plus long
-        num_threads=2  # Utiliser plusieurs threads
-    )
-    logger.info("Bot Telegram initialisé avec succès")
-except Exception as e:
-    logger.error(f"Erreur initialisation bot: {e}")
-    bot = None
-
-def send_image_to_telegram(image_path, caption="", max_retries=3):
-    """Envoie une image vers le groupe Telegram avec pyTelegramBotAPI."""
-    if not bot:
-        return False, "Bot Telegram non initialisé"
-    
-    try:
-        # Vérifications de base
-        if not os.path.exists(image_path):
-            logger.error(f"Le fichier {image_path} n'existe pas")
-            return False, f"Le fichier {image_path} n'existe pas"
-        
-        file_size = os.path.getsize(image_path)
-        if file_size > 50 * 1024 * 1024:  # 50MB limite pour les documents
-            logger.error(f"Fichier trop volumineux: {file_size} bytes")
-            return False, f"Fichier trop volumineux: {file_size} bytes (limite: 50MB)"
-        
-        if file_size == 0:
-            logger.error(f"Fichier vide: {image_path}")
-            return False, f"Fichier vide: {image_path}"
-        
-        logger.info(f"Envoi de l'image: {image_path} (taille: {file_size} bytes)")
-        
-        # Tentatives d'envoi avec retry automatique
-        for attempt in range(max_retries):
-            try:
-                logger.info(f"Tentative {attempt + 1}/{max_retries}")
-                
-                with open(image_path, 'rb') as photo:
-                    # Si le fichier est < 10MB, l'envoyer comme photo
-                    if file_size < 10 * 1024 * 1024:
-                        message = bot.send_photo(
-                            chat_id=TELEGRAM_CHAT_ID,
-                            photo=photo,
-                            caption=caption[:1024] if caption else "",
-                            timeout=120
-                        )
-                    else:
-                        # Sinon l'envoyer comme document
-                        message = bot.send_document(
-                            chat_id=TELEGRAM_CHAT_ID,
-                            document=photo,
-                            caption=caption[:1024] if caption else "",
-                            timeout=120
-                        )
-                
-                logger.info(f"✅ Image envoyée avec succès (Message ID: {message.message_id})")
-                return True, f"Image envoyée avec succès (tentative {attempt + 1})"
-                
-            except telebot.apihelper.ApiTelegramException as e:
-                logger.error(f"Erreur API Telegram (tentative {attempt + 1}): {e}")
-                if attempt == max_retries - 1:  # Dernière tentative
-                    return False, f"Erreur API Telegram après {max_retries} tentatives: {str(e)}"
-                time.sleep(2 ** attempt)  # Backoff exponentiel
-                
-            except Exception as e:
-                logger.error(f"Erreur inattendue (tentative {attempt + 1}): {e}")
-                if attempt == max_retries - 1:
-                    return False, f"Erreur inattendue après {max_retries} tentatives: {str(e)}"
-                time.sleep(2 ** attempt)
-        
-        return False, f"Échec après {max_retries} tentatives"
-        
-    except Exception as e:
-        logger.error(f"Erreur critique lors de l'envoi: {str(e)}")
-        return False, f"Erreur critique: {str(e)}"
-
-def send_message_to_telegram(message, max_retries=3):
-    """Envoie un message texte vers le groupe Telegram."""
-    if not bot:
-        return False, "Bot Telegram non initialisé"
-    
-    try:
-        # Diviser le message s'il est trop long (limite Telegram: 4096 caractères)
-        max_length = 4000  # On garde une marge
-        messages = []
-        
-        if len(message) <= max_length:
-            messages = [message]
-        else:
-            # Diviser le message en chunks
-            for i in range(0, len(message), max_length):
-                chunk = message[i:i + max_length]
-                messages.append(chunk)
-        
-        # Envoyer chaque partie
-        for i, msg_part in enumerate(messages):
-            for attempt in range(max_retries):
-                try:
-                    logger.info(f"Envoi message partie {i + 1}/{len(messages)} (tentative {attempt + 1})")
-                    
-                    sent_message = bot.send_message(
-                        chat_id=TELEGRAM_CHAT_ID,
-                        text=msg_part,
-                        parse_mode='HTML',
-                        timeout=60
-                    )
-                    
-                    logger.info(f"✅ Message partie {i + 1} envoyé (ID: {sent_message.message_id})")
-                    break  # Sortir de la boucle de retry si réussi
-                    
-                except telebot.apihelper.ApiTelegramException as e:
-                    logger.error(f"Erreur API Telegram partie {i + 1} (tentative {attempt + 1}): {e}")
-                    if attempt == max_retries - 1:
-                        return False, f"Erreur API après {max_retries} tentatives: {str(e)}"
-                    time.sleep(2 ** attempt)
-                    
-                except Exception as e:
-                    logger.error(f"Erreur inattendue partie {i + 1} (tentative {attempt + 1}): {e}")
-                    if attempt == max_retries - 1:
-                        return False, f"Erreur inattendue après {max_retries} tentatives: {str(e)}"
-                    time.sleep(2 ** attempt)
-        
-        return True, f"Message envoyé avec succès ({len(messages)} partie(s))"
-        
-    except Exception as e:
-        logger.error(f"Erreur critique envoi message: {str(e)}")
-        return False, f"Erreur critique: {str(e)}"
-
-def test_bot_permissions():
-    """Teste les permissions du bot dans le groupe."""
-    if not bot:
-        return False, "Bot Telegram non initialisé"
-    
-    try:
-        logger.info("Test des permissions du bot...")
-        
-        # Obtenir les informations du chat
-        chat = bot.get_chat(TELEGRAM_CHAT_ID)
-        logger.info(f"Chat trouvé: {chat.title if hasattr(chat, 'title') else 'Chat privé'}")
-        
-        # Obtenir les informations du bot
-        bot_info = bot.get_me()
-        logger.info(f"Bot: @{bot_info.username} ({bot_info.first_name})")
-        
-        # Tester l'envoi d'un message simple
-        test_message = bot.send_message(
-            chat_id=TELEGRAM_CHAT_ID,
-            text="🔧 Test de permissions réussi",
-            timeout=30
-        )
-        
-        return True, f"Bot @{bot_info.username} autorisé dans '{chat.title if hasattr(chat, 'title') else 'le chat'}'"
-        
-    except telebot.apihelper.ApiTelegramException as e:
-        logger.error(f"Erreur API lors du test: {e}")
-        return False, f"Erreur API Telegram: {str(e)}"
-    except Exception as e:
-        logger.error(f"Erreur lors du test des permissions: {str(e)}")
-        return False, f"Erreur: {str(e)}"
-
-def get_bot_status():
-    """Obtient le statut du bot et des connexions."""
-    status = {
-        "bot_initialized": bot is not None,
-        "bot_info": None,
-        "chat_info": None,
-        "api_accessible": False
-    }
-    
-    if bot:
-        try:
-            # Informations du bot
-            bot_info = bot.get_me()
-            status["bot_info"] = {
-                "username": bot_info.username,
-                "first_name": bot_info.first_name,
-                "id": bot_info.id,
-                "is_bot": bot_info.is_bot
-            }
-            status["api_accessible"] = True
-            
-            # Informations du chat
-            try:
-                chat = bot.get_chat(TELEGRAM_CHAT_ID)
-                status["chat_info"] = {
-                    "id": chat.id,
-                    "type": chat.type,
-                    "title": getattr(chat, 'title', 'N/A'),
-                    "member_count": getattr(chat, 'member_count', 'N/A')
-                }
-            except Exception as e:
-                status["chat_error"] = str(e)
-                
-        except Exception as e:
-            status["bot_error"] = str(e)
-    
-    return status
-
-# Routes Flask
-@app.route('/bot_status', methods=['GET'])
-def bot_status():
-    """Route pour obtenir le statut du bot."""
-    return jsonify(get_bot_status())
-
-@app.route('/test_bot_permissions', methods=['GET'])
-def test_bot_permissions_route():
-    """Route pour tester les permissions du bot."""
-    success, message = test_bot_permissions()
-    return jsonify({
-        "success": success,
-        "message": message,
-        "bot_status": get_bot_status()
-    })
 
 @app.route('/', methods=['GET'])
 def svt():
     """Renders the SVT page."""
     return render_template("svt.html")
 
+    
 methodologie_svt = {
+    
     "Restitution organisée des connaissances": """
 **Restitution organisée des connaissances (ROC)**
 
@@ -301,6 +78,8 @@ methodologie_svt = {
 *   L'exercice est pondéré sur 7 à 8 points.
 """,
     "Exploitation du document": """
+
+    
 **Exploitation de documents (ED)**
 
 **Objectif:** Trouver le lien entre les informations présentées par un des documents et les connaissances d'un segment de connaissances (partie du programme) en vue de la résolution d'un problème scientifique.
@@ -325,6 +104,7 @@ methodologie_svt = {
 *   La tâche 4 (CP4) est spécifique à cet exercice.
 *   Mentionner le document traité (ex: Document 1).
 
+
 réponse attendu uniquement en langue française.
 """,
     "Synthèse": """
@@ -354,159 +134,46 @@ réponse attendu uniquement en langue française.
 """
 }
 
+
 @app.route('/svt_submit', methods=['POST'])
 def svt_submit():
     """Handles the submission of SVT exercises."""
     option = request.form.get('option')
     images = request.files.getlist('images')
 
-    logger.info(f"Traitement d'un exercice SVT: {option}")
-    logger.info(f"Nombre d'images reçues: {len(images)}")
-
     content = [f"J'aimerais que tu traites entièrement cet exercice en respectant scrupuleusement la méthodologie d'SVT suivante :\n\n{methodologie_svt[option]}\n\nLe type d'exercice selon la méthodologie est : {option}. Voici les images de l'exercice:"]
     temp_files = []
-    telegram_results = []
 
     try:
-        # Test du statut du bot avant traitement
-        bot_status = get_bot_status()
-        logger.info(f"Statut du bot: {bot_status}")
-
-        # Traitement des images
-        for i, image in enumerate(images):
-            if image and image.filename:
-                logger.info(f"Traitement de l'image {i+1}: {image.filename}")
-                
-                # Créer un fichier temporaire avec l'extension correcte
-                file_extension = os.path.splitext(image.filename)[1].lower()
-                if not file_extension:
-                    file_extension = '.jpg'  # Extension par défaut
-                
-                with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
-                    # Sauvegarder l'image
+        for image in images:
+            if image:
+                with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(image.filename)[1]) as temp_file:
                     image.save(temp_file.name)
                     temp_files.append(temp_file.name)
-                    
-                    # Vérifier que l'image a été sauvegardée correctement
-                    if os.path.getsize(temp_file.name) > 0:
-                        logger.info(f"Image sauvegardée: {temp_file.name} ({os.path.getsize(temp_file.name)} bytes)")
-                        
-                        # Ajouter l'image au contenu pour Gemini
-                        try:
-                            pil_image = PIL.Image.open(temp_file.name)
-                            content.append(pil_image)
-                            logger.info(f"Image ajoutée au contenu Gemini: {pil_image.size}")
-                        except Exception as e:
-                            logger.error(f"Erreur lors de l'ouverture de l'image pour Gemini: {e}")
-                        
-                        # Envoi de l'image vers Telegram
-                        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                        caption = f"📚 Exercice SVT - {option}\n🕐 {timestamp}\n📄 Image {i+1}/{len([img for img in images if img.filename])}"
-                        
-                        logger.info(f"Tentative d'envoi vers Telegram: {temp_file.name}")
-                        success, message = send_image_to_telegram(temp_file.name, caption)
-                        telegram_results.append({
-                            'image': f"Image {i+1} - {image.filename}",
-                            'success': success,
-                            'message': message
-                        })
-                        
-                        if success:
-                            logger.info(f"✅ Image {i+1} envoyée avec succès")
-                        else:
-                            logger.error(f"❌ Échec envoi image {i+1}: {message}")
-                    else:
-                        logger.error(f"Fichier temporaire vide pour l'image {i+1}")
-                        telegram_results.append({
-                            'image': f"Image {i+1} - {image.filename}",
-                            'success': False,
-                            'message': "Fichier temporaire vide"
-                        })
-
-        logger.info(f"Résultats Telegram: {telegram_results}")
-
-        # Génération de la réponse avec Gemini
-        logger.info("Génération de la réponse avec Gemini...")
+                    content.append(PIL.Image.open(temp_file.name))
+
+        #model = genai.GenerativeModel(model_name="models/gemini-2.5-flash-preview-04-17", safety_settings=safety_settings)
+        #response = model.generate_content(content, request_options={"timeout": 600})
+
         response = client.models.generate_content(
             model="gemini-2.5-flash",
             contents=[content],
-            config=types.GenerateContentConfig(
-                safety_settings=safety_settings,
-            )
+                        config=types.GenerateContentConfig(
+        safety_settings=safety_settings,
+
+    )
         )
-        
+            
         answer = response.candidates[0].content.parts[0].text
-        logger.info("Réponse générée avec succès")
-        
-        # Envoi de la réponse vers Telegram
-        telegram_message = f"🤖 <b>Réponse générée</b>\n\n📝 <b>Type:</b> {option}\n\n{answer}"
-        msg_success, msg_message = send_message_to_telegram(telegram_message)
-        logger.info(f"Envoi réponse Telegram: {msg_success} - {msg_message}")
-        
-        return jsonify({
-            "response": answer,
-            "telegram_status": telegram_results,
-            "bot_status": bot_status,
-            "response_sent": {"success": msg_success, "message": msg_message}
-        })
+         
+
+        return jsonify({"response": response.text})
 
     except Exception as e:
-        logger.error(f"Erreur lors du traitement: {str(e)}")
-        error_message = f"❌ <b>Erreur lors du traitement</b>\n\n🔍 <b>Type:</b> {option}\n💥 <b>Erreur:</b> {str(e)}"
-        send_message_to_telegram(error_message)
-        
-        return jsonify({
-            "error": "Erreur lors du traitement",
-            "details": str(e),
-            "telegram_status": telegram_results,
-            "bot_status": get_bot_status()
-        }), 500
-        
+        return jsonify({"error": "erreur"}), 500
     finally:
-        # Nettoyage des fichiers temporaires
         for temp_file in temp_files:
             try:
-                if os.path.exists(temp_file):
-                    os.unlink(temp_file)
-                    logger.info(f"Fichier temporaire supprimé: {temp_file}")
+                os.unlink(temp_file)
             except Exception as e:
-                logger.error(f"Erreur lors de la suppression du fichier {temp_file}: {e}")
-
-@app.route('/test_telegram', methods=['GET'])
-def test_telegram():
-    """Route pour tester la connexion Telegram."""
-    success, message = send_message_to_telegram("🧪 Test de connexion du bot SVT avec pyTelegramBotAPI")
-    return jsonify({
-        "success": success,
-        "message": message,
-        "bot_status": get_bot_status()
-    })
-
-@app.route('/debug_telegram', methods=['GET'])
-def debug_telegram():
-    """Route pour débugger les problèmes Telegram."""
-    results = {}
-    
-    # Test 1: Statut du bot
-    results['bot_status'] = get_bot_status()
-    
-    # Test 2: Permissions du bot
-    perm_success, perm_message = test_bot_permissions()
-    results['permissions'] = {"success": perm_success, "message": perm_message}
-    
-    # Test 3: Envoi d'un message simple
-    msg_success, msg_message = send_message_to_telegram("🔧 Test de débogage avec pyTelegramBotAPI")
-    results['message_test'] = {"success": msg_success, "message": msg_message}
-    
-    # Test 4: Vérification des variables d'environnement
-    results['config'] = {
-        "bot_token_set": bool(TELEGRAM_BOT_TOKEN),
-        "chat_id_set": bool(TELEGRAM_CHAT_ID),
-        "bot_token_format": TELEGRAM_BOT_TOKEN.startswith("8180304240:") if TELEGRAM_BOT_TOKEN else False,
-        "chat_id_format": TELEGRAM_CHAT_ID.startswith("-") if TELEGRAM_CHAT_ID else False
-    }
-    
-    return jsonify(results)
-
-if __name__ == '__main__':
-    app.run(debug=True)
+                print(f"Error deleting temporary file {temp_file}: {e}")