Update app.py

app.py

@@ -8,6 +8,8 @@ from tempfile import NamedTemporaryFile
 import tempfile
 from datetime import datetime
 import logging
+import socket
+import dns.resolver
 
 app = Flask(__name__)
 
@@ -48,67 +50,155 @@ TELEGRAM_CHAT_ID = "-4972732072"
 gen = GOOGLE_API_KEY 
 client = genai.Client(api_key=gen)
 
-def send_image_to_telegram(image_path, caption=""):
-    """Envoie une image vers le groupe Telegram avec meilleure gestion d'erreurs."""
+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:
-        # Vérifier que le fichier existe et est lisible
+        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}")
+    
+    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}")
+        
         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: 10MB pour les photos via API)
         file_size = os.path.getsize(image_path)
-        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)"
+        if file_size > 10 * 1024 * 1024:
+            return False, f"Fichier trop volumineux: {file_size} bytes"
         
-        # 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}"
         
-        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': ('image.jpg', photo, 'image/jpeg')}
             data = {
                 'chat_id': TELEGRAM_CHAT_ID,
-                'caption': caption[:1024] if caption else ""  # Telegram limite les captions à 1024 caractères
+                'caption': caption[:1024] if caption else ""
             }
             
-            logger.debug(f"Données envoyées: {data}")
-            response = requests.post(url, files=files, data=data, timeout=120)
+            # 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"Réponse HTTP: {response.status_code}")
-            logger.debug(f"Contenu de la réponse: {response.text}")
+            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("Image envoyée avec succès")
-                    return True, "Image envoyée avec succès"
+                    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')
-                    logger.error(f"Erreur API Telegram: {error_msg}")
-                    return False, f"Erreur API Telegram: {error_msg}"
+                    return False, f"{method_name} - Erreur API: {error_msg}"
             else:
-                logger.error(f"Erreur HTTP {response.status_code}: {response.text}")
-                return False, f"Erreur HTTP {response.status_code}: {response.text}"
+                return False, f"{method_name} - 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)}"
+        logger.error(f"{method_name} - Erreur: {str(e)}")
+        return False, f"{method_name} - Erreur: {str(e)}"
+
+def send_message_to_telegram_with_fallback(message):
+    """Envoie un message texte avec fallback."""
+    
+    # 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'
+        }
+        
+        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')}"
+        else:
+            return False, f"{method_name} - Erreur HTTP: {response.status_code}"
+            
+    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
 
 def test_bot_permissions():
     """Teste les permissions du bot dans le groupe."""
@@ -134,33 +224,14 @@ def test_bot_permissions():
         logger.error(f"Erreur test permissions: {str(e)}")
         return False, f"Erreur: {str(e)}"
 
-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"
-    
-    try:
-        data = {
-            'chat_id': TELEGRAM_CHAT_ID,
-            'text': message,
-            'parse_mode': 'HTML'
-        }
-        
-        response = requests.post(url, data=data, timeout=30)
-        
-        if response.status_code == 200:
-            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 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)
 
-# Nouvelle route pour tester les permissions
+# Route pour tester les permissions
 @app.route('/test_bot_permissions', methods=['GET'])
 def test_bot_permissions_route():
     """Route pour tester les permissions du bot."""
@@ -403,6 +474,9 @@ 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__':