Update app.py

app.py

@@ -2,14 +2,13 @@ from flask import Flask, request, render_template, jsonify
 import PIL.Image
 from google import genai
 from google.genai import types
-import requests
+import telebot
 import os
 from tempfile import NamedTemporaryFile
 import tempfile
 from datetime import datetime
 import logging
-import socket
-import dns.resolver
+import time
 
 app = Flask(__name__)
 
@@ -50,195 +49,222 @@ TELEGRAM_CHAT_ID = "-4972732072"
 gen = GOOGLE_API_KEY 
 client = genai.Client(api_key=gen)
 
-def test_network_connectivity():
-    """Teste la connectivité réseau de base."""
-    results = {}
-    
-    # Test 1: Ping Google DNS
-    try:
-        socket.create_connection(("8.8.8.8", 53), timeout=5)
-        results['google_dns'] = {"success": True, "message": "Connexion à Google DNS réussie"}
-    except Exception as e:
-        results['google_dns'] = {"success": False, "message": f"Échec connexion Google DNS: {str(e)}"}
-    
-    # Test 2: Résolution DNS de google.com
-    try:
-        socket.gethostbyname("google.com")
-        results['dns_google'] = {"success": True, "message": "Résolution DNS google.com réussie"}
-    except Exception as e:
-        results['dns_google'] = {"success": False, "message": f"Échec résolution DNS google.com: {str(e)}"}
-    
-    # Test 3: Résolution DNS de api.telegram.org
-    try:
-        ip = socket.gethostbyname("api.telegram.org")
-        results['dns_telegram'] = {"success": True, "message": f"Résolution DNS api.telegram.org réussie: {ip}"}
-    except Exception as e:
-        results['dns_telegram'] = {"success": False, "message": f"Échec résolution DNS api.telegram.org: {str(e)}"}
-    
-    # Test 4: Connexion HTTPS à api.telegram.org
-    try:
-        response = requests.get("https://api.telegram.org/", timeout=10)
-        results['https_telegram'] = {"success": True, "message": f"Connexion HTTPS réussie: {response.status_code}"}
-    except Exception as e:
-        results['https_telegram'] = {"success": False, "message": f"Échec connexion HTTPS: {str(e)}"}
-    
-    return results
-
-def send_image_to_telegram_with_fallback(image_path, caption=""):
-    """Envoie une image vers le groupe Telegram avec différentes méthodes."""
-    
-    # Méthode 1: URL standard
-    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendPhoto"
-    result = _try_send_image(url, image_path, caption, "URL standard")
-    if result[0]:
-        return result
-    
-    # Méthode 2: Essayer avec l'IP directe (nécessite de résoudre l'IP d'abord)
-    try:
-        ip = socket.gethostbyname("api.telegram.org")
-        url_ip = f"https://{ip}/bot{TELEGRAM_BOT_TOKEN}/sendPhoto"
-        result = _try_send_image(url_ip, image_path, caption, "IP directe", 
-                                headers={"Host": "api.telegram.org"})
-        if result[0]:
-            return result
-    except Exception as e:
-        logger.error(f"Impossible de résoudre l'IP: {e}")
+# 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é"
     
-    return False, "Toutes les méthodes ont échoué"
-
-def _try_send_image(url, image_path, caption, method_name, headers=None):
-    """Tentative d'envoi d'image avec une méthode spécifique."""
     try:
-        logger.info(f"Tentative d'envoi avec {method_name}: {url}")
-        
+        # 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 > 10 * 1024 * 1024:
-            return False, f"Fichier trop volumineux: {file_size} bytes"
+        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}"
         
-        with open(image_path, 'rb') as photo:
-            files = {'photo': ('image.jpg', photo, 'image/jpeg')}
-            data = {
-                'chat_id': TELEGRAM_CHAT_ID,
-                'caption': caption[:1024] if caption else ""
-            }
-            
-            # Augmenter le timeout et ajouter des headers si nécessaire
-            request_headers = headers or {}
-            response = requests.post(url, files=files, data=data, 
-                                   timeout=30, headers=request_headers)
-            
-            logger.info(f"{method_name} - Réponse HTTP: {response.status_code}")
-            
-            if response.status_code == 200:
-                response_json = response.json()
-                if response_json.get('ok'):
-                    logger.info(f"✅ {method_name} - Envoi réussi")
-                    return True, f"{method_name} - Image envoyée avec succès"
-                else:
-                    error_msg = response_json.get('description', 'Erreur inconnue')
-                    return False, f"{method_name} - Erreur API: {error_msg}"
-            else:
-                return False, f"{method_name} - Erreur HTTP {response.status_code}: {response.text}"
+        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"{method_name} - Erreur: {str(e)}")
-        return False, f"{method_name} - Erreur: {str(e)}"
+        logger.error(f"Erreur critique lors de l'envoi: {str(e)}")
+        return False, f"Erreur critique: {str(e)}"
 
-def send_message_to_telegram_with_fallback(message):
-    """Envoie un message texte avec fallback."""
+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é"
     
-    # Méthode 1: URL standard
-    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
-    result = _try_send_message(url, message, "URL standard")
-    if result[0]:
-        return result
-    
-    # Méthode 2: IP directe
-    try:
-        ip = socket.gethostbyname("api.telegram.org")
-        url_ip = f"https://{ip}/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
-        result = _try_send_message(url_ip, message, "IP directe", 
-                                 headers={"Host": "api.telegram.org"})
-        if result[0]:
-            return result
-    except Exception as e:
-        logger.error(f"Impossible de résoudre l'IP: {e}")
-    
-    return False, "Toutes les méthodes ont échoué"
-
-def _try_send_message(url, message, method_name, headers=None):
-    """Tentative d'envoi de message avec une méthode spécifique."""
     try:
-        data = {
-            'chat_id': TELEGRAM_CHAT_ID,
-            'text': message,
-            'parse_mode': 'HTML'
-        }
+        # Diviser le message s'il est trop long (limite Telegram: 4096 caractères)
+        max_length = 4000  # On garde une marge
+        messages = []
         
-        request_headers = headers or {}
-        response = requests.post(url, data=data, timeout=30, headers=request_headers)
-        
-        if response.status_code == 200:
-            response_json = response.json()
-            if response_json.get('ok'):
-                return True, f"{method_name} - Message envoyé avec succès"
-            else:
-                return False, f"{method_name} - Erreur API: {response_json.get('description')}"
+        if len(message) <= max_length:
+            messages = [message]
         else:
-            return False, f"{method_name} - Erreur HTTP: {response.status_code}"
-            
+            # 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:
-        return False, f"{method_name} - Erreur: {str(e)}"
-
-# Remplacer les anciennes fonctions par les nouvelles
-send_image_to_telegram = send_image_to_telegram_with_fallback
-send_message_to_telegram = send_message_to_telegram_with_fallback
+        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."""
-    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/getChat"
+    if not bot:
+        return False, "Bot Telegram non initialisé"
     
     try:
-        data = {'chat_id': TELEGRAM_CHAT_ID}
-        response = requests.post(url, data=data, timeout=30)
+        logger.info("Test des permissions du bot...")
         
-        logger.info(f"Test permissions - Status: {response.status_code}")
-        logger.debug(f"Test permissions - Response: {response.text}")
+        # 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é'}")
         
-        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'].get('title', 'Chat sans titre')}"
-            else:
-                return False, f"Erreur API: {chat_info.get('description')}"
-        else:
-            return False, f"Erreur HTTP: {response.status_code} - {response.text}"
-            
+        # 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 test permissions: {str(e)}")
+        logger.error(f"Erreur lors du test des permissions: {str(e)}")
         return False, f"Erreur: {str(e)}"
 
-# Nouvelle route pour diagnostiquer les problèmes réseau
-@app.route('/network_test', methods=['GET'])
-def network_test():
-    """Route pour tester la connectivité réseau."""
-    results = test_network_connectivity()
-    return jsonify(results)
+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())
 
-# 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
+        "message": message,
+        "bot_status": get_bot_status()
     })
 
 @app.route('/', methods=['GET'])
@@ -342,9 +368,9 @@ def svt_submit():
     telegram_results = []
 
     try:
-        # Test des permissions avant envoi
-        perm_success, perm_message = test_bot_permissions()
-        logger.info(f"Test permissions: {perm_success} - {perm_message}")
+        # 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):
@@ -413,14 +439,15 @@ def svt_submit():
         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[:3500]}..."
+        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_permissions": {"success": perm_success, "message": perm_message}
+            "bot_status": bot_status,
+            "response_sent": {"success": msg_success, "message": msg_message}
         })
 
     except Exception as e:
@@ -431,7 +458,8 @@ def svt_submit():
         return jsonify({
             "error": "Erreur lors du traitement",
             "details": str(e),
-            "telegram_status": telegram_results
+            "telegram_status": telegram_results,
+            "bot_status": get_bot_status()
         }), 500
         
     finally:
@@ -447,10 +475,11 @@ def svt_submit():
 @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")
+    success, message = send_message_to_telegram("🧪 Test de connexion du bot SVT avec pyTelegramBotAPI")
     return jsonify({
         "success": success,
-        "message": message
+        "message": message,
+        "bot_status": get_bot_status()
     })
 
 @app.route('/debug_telegram', methods=['GET'])
@@ -458,15 +487,18 @@ def debug_telegram():
     """Route pour débugger les problèmes Telegram."""
     results = {}
     
-    # Test 1: Permissions du bot
+    # 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 2: Envoi d'un message simple
-    msg_success, msg_message = send_message_to_telegram("🔧 Test de débogage")
+    # 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 3: Vérification des variables d'environnement
+    # Test 4: Vérification des variables d'environnement
     results['config'] = {
         "bot_token_set": bool(TELEGRAM_BOT_TOKEN),
         "chat_id_set": bool(TELEGRAM_CHAT_ID),
@@ -474,9 +506,6 @@ def debug_telegram():
         "chat_id_format": TELEGRAM_CHAT_ID.startswith("-") if TELEGRAM_CHAT_ID else False
     }
     
-    # Test 4: Diagnostic réseau
-    results['network'] = test_network_connectivity()
-    
     return jsonify(results)
 
 if __name__ == '__main__':