Update app.py

app.py

@@ -7,9 +7,14 @@ import os
 from tempfile import NamedTemporaryFile
 import tempfile
 from datetime import datetime
+import logging
 
 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,
@@ -50,43 +55,59 @@ def send_image_to_telegram(image_path, caption=""):
     try:
         # Vérifier que le fichier existe et est lisible
         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"
         
-        # Vérifier la taille du fichier (limite Telegram: 50MB pour les photos)
+        # Vérifier la taille du fichier (limite Telegram: 10MB pour les photos via API)
         file_size = os.path.getsize(image_path)
-        if file_size > 50 * 1024 * 1024:  # 50MB
-            return False, f"Fichier trop volumineux: {file_size} bytes (limite: 50MB)"
+        if file_size > 10 * 1024 * 1024:  # 10MB pour l'API Bot
+            logger.error(f"Fichier trop volumineux: {file_size} bytes")
+            return False, f"Fichier trop volumineux: {file_size} bytes (limite: 10MB)"
+        
+        # Vérifier que le fichier n'est pas vide
+        if file_size == 0:
+            logger.error(f"Fichier vide: {image_path}")
+            return False, f"Fichier vide: {image_path}"
         
-        print(f"Envoi de l'image: {image_path} (taille: {file_size} bytes)")
-        print(f"Chat ID: {TELEGRAM_CHAT_ID}")
-        print(f"Caption: {caption}")
+        logger.info(f"Envoi de l'image: {image_path} (taille: {file_size} bytes)")
+        logger.info(f"Chat ID: {TELEGRAM_CHAT_ID}")
+        logger.info(f"Caption: {caption}")
         
+        # Ouvrir et envoyer le fichier
         with open(image_path, 'rb') as photo:
-            files = {'photo': photo}
+            files = {'photo': ('image.jpg', photo, 'image/jpeg')}
             data = {
                 'chat_id': TELEGRAM_CHAT_ID,
-                'caption': caption[:1024]  # Telegram limite les captions à 1024 caractères
+                'caption': caption[:1024] if caption else ""  # Telegram limite les captions à 1024 caractères
             }
             
-            response = requests.post(url, files=files, data=data, timeout=60)  # Timeout plus long
+            logger.debug(f"Données envoyées: {data}")
+            response = requests.post(url, files=files, data=data, timeout=120)
             
-            print(f"Réponse HTTP: {response.status_code}")
-            print(f"Contenu de la réponse: {response.text}")
+            logger.info(f"Réponse HTTP: {response.status_code}")
+            logger.debug(f"Contenu de la réponse: {response.text}")
             
             if response.status_code == 200:
                 response_json = response.json()
                 if response_json.get('ok'):
+                    logger.info("Image envoyée avec succès")
                     return True, "Image envoyée avec succès"
                 else:
-                    return False, f"Erreur API Telegram: {response_json.get('description', 'Erreur inconnue')}"
+                    error_msg = response_json.get('description', 'Erreur inconnue')
+                    logger.error(f"Erreur API Telegram: {error_msg}")
+                    return False, f"Erreur API Telegram: {error_msg}"
             else:
+                logger.error(f"Erreur HTTP {response.status_code}: {response.text}")
                 return False, f"Erreur HTTP {response.status_code}: {response.text}"
                 
     except requests.exceptions.Timeout:
+        logger.error("Timeout lors de l'envoi vers Telegram")
         return False, "Timeout lors de l'envoi vers Telegram"
     except requests.exceptions.RequestException as e:
+        logger.error(f"Erreur de requête: {str(e)}")
         return False, f"Erreur de requête: {str(e)}"
     except Exception as e:
+        logger.error(f"Erreur inattendue: {str(e)}")
         return False, f"Erreur inattendue: {str(e)}"
 
 def test_bot_permissions():
@@ -97,29 +118,22 @@ def test_bot_permissions():
         data = {'chat_id': TELEGRAM_CHAT_ID}
         response = requests.post(url, data=data, timeout=30)
         
+        logger.info(f"Test permissions - Status: {response.status_code}")
+        logger.debug(f"Test permissions - Response: {response.text}")
+        
         if response.status_code == 200:
             chat_info = response.json()
             if chat_info.get('ok'):
-                return True, f"Bot autorisé dans le chat: {chat_info['result']['title']}"
+                return True, f"Bot autorisé dans le chat: {chat_info['result'].get('title', 'Chat sans titre')}"
             else:
                 return False, f"Erreur API: {chat_info.get('description')}"
         else:
-            return False, f"Erreur HTTP: {response.status_code}"
+            return False, f"Erreur HTTP: {response.status_code} - {response.text}"
             
     except Exception as e:
+        logger.error(f"Erreur test permissions: {str(e)}")
         return False, f"Erreur: {str(e)}"
 
-# Nouvelle route pour tester les permissions
-@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
-    })
-
-
 def send_message_to_telegram(message):
     """Envoie un message texte vers le groupe Telegram."""
     url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
@@ -134,13 +148,28 @@ def send_message_to_telegram(message):
         response = requests.post(url, data=data, timeout=30)
         
         if response.status_code == 200:
-            return True, "Message envoyé avec succès"
+            response_json = response.json()
+            if response_json.get('ok'):
+                return True, "Message envoyé avec succès"
+            else:
+                return False, f"Erreur API: {response_json.get('description')}"
         else:
             return False, f"Erreur Telegram: {response.status_code} - {response.text}"
             
     except Exception as e:
+        logger.error(f"Erreur envoi message: {str(e)}")
         return False, f"Erreur lors de l'envoi: {str(e)}"
 
+# Nouvelle route pour tester les permissions
+@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
+    })
+
 @app.route('/', methods=['GET'])
 def svt():
     """Renders the SVT page."""
@@ -234,31 +263,73 @@ def svt_submit():
     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 des permissions avant envoi
+        perm_success, perm_message = test_bot_permissions()
+        logger.info(f"Test permissions: {perm_success} - {perm_message}")
+
         # Traitement des images
         for i, image in enumerate(images):
-            if image:
-                with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(image.filename)[1]) as temp_file:
+            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
                     image.save(temp_file.name)
                     temp_files.append(temp_file.name)
-                    content.append(PIL.Image.open(temp_file.name))
-                    
-                    # 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(images)}"
                     
-                    success, message = send_image_to_telegram(temp_file.name, caption)
-                    telegram_results.append({
-                        'image': f"Image {i+1}",
-                        'success': success,
-                        'message': message
-                    })
+                    # 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...")
         response = client.models.generate_content(
             model="gemini-2.5-flash",
             contents=[content],
@@ -268,17 +339,21 @@ def svt_submit():
         )
         
         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[:4000]}..."  # Limité à 4000 caractères
-        send_message_to_telegram(telegram_message)
+        telegram_message = f"🤖 <b>Réponse générée</b>\n\n📝 <b>Type:</b> {option}\n\n{answer[:3500]}..."
+        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
+            "telegram_status": telegram_results,
+            "bot_permissions": {"success": perm_success, "message": perm_message}
         })
 
     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)
         
@@ -292,9 +367,11 @@ def svt_submit():
         # Nettoyage des fichiers temporaires
         for temp_file in temp_files:
             try:
-                os.unlink(temp_file)
+                if os.path.exists(temp_file):
+                    os.unlink(temp_file)
+                    logger.info(f"Fichier temporaire supprimé: {temp_file}")
             except Exception as e:
-                print(f"Error deleting temporary file {temp_file}: {e}")
+                logger.error(f"Erreur lors de la suppression du fichier {temp_file}: {e}")
 
 @app.route('/test_telegram', methods=['GET'])
 def test_telegram():
@@ -305,5 +382,28 @@ def test_telegram():
         "message": message
     })
 
+@app.route('/debug_telegram', methods=['GET'])
+def debug_telegram():
+    """Route pour débugger les problèmes Telegram."""
+    results = {}
+    
+    # Test 1: Permissions du bot
+    perm_success, perm_message = test_bot_permissions()
+    results['permissions'] = {"success": perm_success, "message": perm_message}
+    
+    # Test 2: Envoi d'un message simple
+    msg_success, msg_message = send_message_to_telegram("🔧 Test de débogage")
+    results['message_test'] = {"success": msg_success, "message": msg_message}
+    
+    # Test 3: 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)