translate tools to english

tools/country_info_tool.py

@@ -10,10 +10,10 @@ import anthropic
 
 class CountryInfoTool(Tool):
     name = "country_info"
-    description = "Récupère des informations contextuelles importantes sur un pays en temps réel : sécurité, événements actuels, fêtes nationales, climat politique, conseils de voyage."
+    description = "Retrieves important contextual information about a country in real-time: security, current events, national holidays, political climate, travel advice."
     inputs = {
-        'country': {'type': 'string', 'description': 'Le nom du pays en français ou en anglais (ex: "France", "États-Unis", "Japon")'},
-        'info_type': {'type': 'string', 'description': 'Type d\'information recherchée: "all", "security", "events", "holidays", "travel", "politics"', 'nullable': True}
+        'country': {'type': 'string', 'description': 'Country name in French or English (e.g., "France", "United States", "Japan")'},
+        'info_type': {'type': 'string', 'description': 'Type of information requested: "all", "security", "events", "holidays", "travel", "politics"', 'nullable': True}
     }
     output_type = "string"
 
@@ -22,7 +22,7 @@ class CountryInfoTool(Tool):
         load_dotenv()
         
         # Initialiser le client Claude (Anthropic)
-        self.claude_client = anthropic.Anthropic(api_key=os.getenv('ANTHROPIC_API_KEY'))
+        self.claude_client = anthropic.Anthropic(api_key=os.getenv('ANTROPIC_KEY'))
         
         # Mapping étendu des pays français vers anglais pour les APIs
         self.country_mapping = {
@@ -104,7 +104,7 @@ class CountryInfoTool(Tool):
             country_normalized = self._normalize_country_name(country)
             
             if not country_normalized:
-                return f"❌ Pays non reconnu: '{country}'. Essayez avec le nom complet (ex: 'France', 'États-Unis', 'Royaume-Uni')"
+                return f"❌ Country not recognized: '{country}'. Try with the full name (e.g., 'France', 'United States', 'United Kingdom')"
             
             # Collecter les informations selon le type demandé
             info_sections = []
@@ -135,11 +135,11 @@ class CountryInfoTool(Tool):
                     info_sections.append(politics_info)
             
             if not info_sections:
-                return f"❌ Aucune information disponible pour {country_normalized} actuellement."
+                return f"❌ No information available for {country_normalized} currently."
             
             # Assembler le rapport final
-            result = f"🌍 **Informations contextuelles pour {country_normalized}**\n"
-            result += f"*Mise à jour: {datetime.now().strftime('%d/%m/%Y %H:%M')}*\n\n"
+            result = f"🌍 **Contextual Information for {country_normalized}**\n"
+            result += f"*Updated: {datetime.now().strftime('%m/%d/%Y %H:%M')}*\n\n"
             result += "\n\n".join(info_sections)
             
             # Ajouter une recommandation finale intelligente si Claude est disponible et qu'on demande toutes les infos
@@ -151,7 +151,7 @@ class CountryInfoTool(Tool):
             return result
             
         except Exception as e:
-            return f"❌ Erreur lors de la récupération des informations: {str(e)}"
+            return f"❌ Error retrieving information: {str(e)}"
 
     def _normalize_country_name(self, country: str) -> Optional[str]:
         """Normalise le nom du pays"""
@@ -265,15 +265,15 @@ class CountryInfoTool(Tool):
             # Analyser les résultats pour déterminer le niveau de sécurité
             security_level, description, recommendation = self._analyze_security_data(country, unique_news, risk_level)
             
-            result = f"🛡️ **Sécurité et Conseils de Voyage**\n"
-            result += f"{security_level} **Niveau déterminé par analyse en temps réel**\n"
+            result = f"🛡️ **Security and Travel Advice**\n"
+            result += f"{security_level} **Level determined by real-time analysis**\n"
             result += f"📋 {description}\n"
-            result += f"🎯 **Recommandation: {recommendation}**"
+            result += f"🎯 **Recommendation: {recommendation}**"
             
             return result
             
         except Exception as e:
-            return f"🛡️ **Sécurité**: Erreur lors de la récupération - {str(e)}"
+            return f"🛡️ **Security**: Error during retrieval - {str(e)}"
 
     def _check_known_risk_countries(self, country: str) -> str:
         """Vérifie si le pays est dans la liste des pays à risque connus"""
@@ -382,8 +382,8 @@ class CountryInfoTool(Tool):
         try:
             if not self.claude_client:
                 return ("⚪", 
-                       "Claude non disponible", 
-                       "❓ Clé API Anthropic requise pour l'analyse de sécurité")
+                       "Claude not available", 
+                       "❓ Anthropic API key required for security analysis")
             
             # Préparer le contenu des actualités pour l'analyse
             news_content = ""
@@ -397,16 +397,16 @@ class CountryInfoTool(Tool):
             if not news_content.strip():
                 if risk_level == "HIGH_RISK":
                     return ("🔴", 
-                           f"Pays à très haut risque - conflit actif ou guerre",
-                           "🚫 CHANGEZ DE DESTINATION - Zone de conflit active")
+                           f"Very high risk country - active conflict or war",
+                           "🚫 CHANGE DESTINATION - Active conflict zone")
                 elif risk_level == "MODERATE_RISK":
                     return ("🟡", 
-                           f"Pays à risque modéré - instabilité politique",
-                           "⚠️ Voyage possible avec précautions renforcées")
+                           f"Moderate risk country - political instability",
+                           "⚠️ Travel possible with enhanced precautions")
                 else:
                     return ("🟢", 
-                           f"Aucune actualité de sécurité récente trouvée",
-                           "✅ Destination considérée comme sûre")
+                           f"No recent security news found",
+                           "✅ Destination considered safe")
             
             # Utiliser Claude pour analyser
             analysis = self._llm_security_analysis(country, news_content, risk_level)
@@ -415,11 +415,11 @@ class CountryInfoTool(Tool):
                 return analysis
             else:
                 return ("⚪", 
-                       "Erreur d'analyse Claude", 
-                       "❓ Impossible d'analyser la sécurité actuellement")
+                       "Claude analysis error", 
+                       "❓ Unable to analyze security currently")
                        
         except Exception:
-            return ("⚪", "Analyse impossible", "❓ Consultez les sources officielles")
+            return ("⚪", "Analysis impossible", "❓ Consult official sources")
 
     def _llm_security_analysis(self, country: str, news_content: str, risk_level: str = "UNKNOWN") -> Optional[tuple]:
         """Utilise Claude pour analyser la sécurité du pays"""
@@ -427,38 +427,38 @@ class CountryInfoTool(Tool):
             if not self.claude_client:
                 return None
                 
-            prompt = f"""Analysez les actualités récentes suivantes concernant {country} et déterminez le niveau de sécurité pour un voyageur :
+            prompt = f"""Analyze the following recent news about {country} and determine the security level for a traveler:
 
-NIVEAU DE RISQUE CONNU : {risk_level}
-- HIGH_RISK = Pays en guerre active ou conflit majeur
-- MODERATE_RISK = Pays avec instabilité politique significative  
-- TENSION = Pays avec tensions géopolitiques
-- UNKNOWN = Pas de classification spéciale
+KNOWN RISK LEVEL: {risk_level}
+- HIGH_RISK = Country in active war or major conflict
+- MODERATE_RISK = Country with significant political instability  
+- TENSION = Country with geopolitical tensions
+- UNKNOWN = No special classification
 
-ACTUALITÉS RÉCENTES :
+RECENT NEWS:
 {news_content}
 
-INSTRUCTIONS CRITIQUES :
-1. Si NIVEAU DE RISQUE = HIGH_RISK, vous DEVEZ recommander CHANGEZ_DE_DESTINATION sauf preuve claire d'amélioration
-2. Pour l'Ukraine, Palestine, Afghanistan, Syrie, Yémen : TOUJOURS ROUGE/CHANGEZ_DE_DESTINATION
-3. Analysez le niveau de risque pour un touriste/voyageur civil
-4. Soyez TRÈS STRICT - la sécurité des voyageurs est prioritaire
+CRITICAL INSTRUCTIONS:
+1. If RISK LEVEL = HIGH_RISK, you MUST recommend CHANGE_DESTINATION unless clear evidence of improvement
+2. For Ukraine, Palestine, Afghanistan, Syria, Yemen: ALWAYS RED/CHANGE_DESTINATION
+3. Analyze risk level for a civilian tourist/traveler
+4. Be VERY STRICT - traveler safety is priority
 
-Répondez UNIQUEMENT au format JSON suivant :
+Respond ONLY in the following JSON format:
 
 {{
-    "niveau": "ROUGE|JAUNE|VERT",
-    "description": "Description courte de la situation (max 100 caractères)",
-    "recommandation": "CHANGEZ_DE_DESTINATION|PRECAUTIONS_RENFORCEES|DESTINATION_SURE",
-    "justification": "Explication de votre décision (max 200 caractères)"
+    "level": "RED|YELLOW|GREEN",
+    "description": "Short situation description (max 100 characters)",
+    "recommendation": "CHANGE_DESTINATION|ENHANCED_PRECAUTIONS|SAFE_DESTINATION",
+    "justification": "Explanation of your decision (max 200 characters)"
 }}
 
-Critères STRICTS :
-- ROUGE/CHANGEZ_DE_DESTINATION : guerre active, conflit armé, terrorisme actif, coup d'état, violence généralisée, zones de combat
-- JAUNE/PRECAUTIONS_RENFORCEES : manifestations violentes, criminalité très élevée, instabilité politique, tensions ethniques
-- VERT/DESTINATION_SURE : pas de risques majeurs pour les civils
+STRICT Criteria:
+- RED/CHANGE_DESTINATION: active war, armed conflict, active terrorism, coup, widespread violence, combat zones
+- YELLOW/ENHANCED_PRECAUTIONS: violent protests, very high crime, political instability, ethnic tensions
+- GREEN/SAFE_DESTINATION: no major risks for civilians
 
-PRIORITÉ ABSOLUE : Protéger les voyageurs - en cas de doute, choisissez le niveau de sécurité le plus strict."""
+ABSOLUTE PRIORITY: Protect travelers - when in doubt, choose the strictest security level."""
 
             response = self.claude_client.messages.create(
                 model="claude-3-opus-20240229",
@@ -474,21 +474,21 @@ PRIORITÉ ABSOLUE : Protéger les voyageurs - en cas de doute, choisissez le niv
             # Parser la réponse JSON
             try:
                 result = json.loads(result_text)
-                niveau = result.get('niveau', 'VERT')
-                description = result.get('description', 'Analyse effectuée')
-                recommandation = result.get('recommandation', 'DESTINATION_SURE')
+                level = result.get('level', 'GREEN')
+                description = result.get('description', 'Analysis completed')
+                recommendation = result.get('recommendation', 'SAFE_DESTINATION')
                 justification = result.get('justification', '')
                 
                 # Convertir en format attendu
-                if niveau == 'ROUGE':
+                if level == 'RED':
                     emoji = "🔴"
-                    advice = "🚫 CHANGEZ DE DESTINATION - " + justification
-                elif niveau == 'JAUNE':
+                    advice = "🚫 CHANGE DESTINATION - " + justification
+                elif level == 'YELLOW':
                     emoji = "🟡"
-                    advice = "⚠️ Voyage possible avec précautions renforcées - " + justification
+                    advice = "⚠️ Travel possible with enhanced precautions - " + justification
                 else:
                     emoji = "🟢"
-                    advice = "✅ Destination considérée comme sûre - " + justification
+                    advice = "✅ Destination considered safe - " + justification
                 
                 return (emoji, description, advice)
                 
@@ -501,24 +501,24 @@ PRIORITÉ ABSOLUE : Protéger les voyageurs - en cas de doute, choisissez le niv
 
 
     def _get_current_events_info(self, country: str) -> str:
-        """Récupère les événements actuels via recherche web"""
+        """Retrieves current events via web search"""
         try:
-            # Rechercher les événements récents
+            # Search for recent events
             events_keywords = f"{country} current events news today recent"
             events_data = self._search_current_events(events_keywords)
             
             if not events_data:
-                return f"📅 **Événements**: Aucun événement majeur détecté pour {country}"
+                return f"📅 **Events**: No major events detected for {country}"
             
-            result = f"📅 **Événements et Contexte Actuel**\n"
+            result = f"📅 **Current Events and Context**\n"
             for i, event in enumerate(events_data[:5], 1):
-                title = event.get('title', 'Événement non spécifié')
+                title = event.get('title', 'Event not specified')
                 result += f"• {title}\n"
             
             return result.rstrip()
             
         except Exception:
-            return "📅 **Événements**: Erreur lors de la récupération"
+            return "📅 **Events**: Error during retrieval"
 
     def _search_current_events(self, keywords: str) -> list:
         """Recherche d'événements actuels"""
@@ -547,29 +547,29 @@ PRIORITÉ ABSOLUE : Protéger les voyageurs - en cas de doute, choisissez le niv
             return []
 
     def _get_holidays_info(self, country: str) -> str:
-        """Récupère les fêtes nationales via API"""
+        """Retrieves national holidays via API"""
         try:
             country_code = self.country_codes.get(country, '')
             
-            # Si pas de code dans notre mapping, essayer de le récupérer via API
+            # If no code in our mapping, try to get it via API
             if not country_code:
                 country_code = self._get_country_code_from_api(country)
             
             if not country_code:
-                return f"🎉 **Fêtes**: Code pays non trouvé pour {country}"
+                return f"🎉 **Holidays**: Country code not found for {country}"
             
-            # Utiliser l'API Calendarific ou similaire
+            # Use Calendarific API or similar
             holidays_data = self._fetch_holidays_api(country_code)
             
             if not holidays_data:
-                return f"🎉 **Fêtes**: Informations non disponibles pour {country}"
+                return f"🎉 **Holidays**: Information not available for {country}"
             
             current_month = datetime.now().month
             current_year = datetime.now().year
             
-            result = f"🎉 **Fêtes et Événements Saisonniers**\n"
+            result = f"🎉 **Holidays and Seasonal Events**\n"
             
-            # Filtrer les fêtes du mois actuel et des prochains mois
+            # Filter holidays from current month and upcoming months
             upcoming_holidays = []
             for holiday in holidays_data:
                 try:
@@ -580,18 +580,18 @@ PRIORITÉ ABSOLUE : Protéger les voyageurs - en cas de doute, choisissez le niv
                     continue
             
             if upcoming_holidays:
-                result += f"**Prochaines fêtes:**\n"
+                result += f"**Upcoming holidays:**\n"
                 for holiday in upcoming_holidays[:5]:
-                    name = holiday.get('name', 'Fête inconnue')
+                    name = holiday.get('name', 'Unknown holiday')
                     date = holiday.get('date', '')
                     result += f"• {name} ({date})\n"
             else:
-                result += f"**Aucune fête majeure prévue dans les prochains mois**\n"
+                result += f"**No major holidays scheduled in the coming months**\n"
             
             return result.rstrip()
             
         except Exception:
-            return "🎉 **Fêtes**: Erreur lors de la récupération"
+            return "🎉 **Holidays**: Error during retrieval"
 
     def _fetch_holidays_api(self, country_code: str) -> list:
         """Récupère les fêtes via API publique"""
@@ -610,9 +610,9 @@ PRIORITÉ ABSOLUE : Protéger les voyageurs - en cas de doute, choisissez le niv
             return []
 
     def _get_travel_info(self, country: str) -> str:
-        """Récupère les informations de voyage via API REST Countries"""
+        """Retrieves travel information via REST Countries API"""
         try:
-            # Utiliser l'API REST Countries
+            # Use REST Countries API
             url = f"https://restcountries.com/v3.1/name/{country}"
             response = requests.get(url, timeout=10)
             
@@ -621,40 +621,40 @@ PRIORITÉ ABSOLUE : Protéger les voyageurs - en cas de doute, choisissez le niv
                 if data:
                     country_data = data[0]
                     
-                    # Extraire les informations
+                    # Extract information
                     currencies = country_data.get('currencies', {})
                     languages = country_data.get('languages', {})
-                    region = country_data.get('region', 'Inconnu')
+                    region = country_data.get('region', 'Unknown')
                     
-                    currency_name = list(currencies.keys())[0] if currencies else 'Inconnue'
-                    language_list = list(languages.values()) if languages else ['Inconnue']
+                    currency_name = list(currencies.keys())[0] if currencies else 'Unknown'
+                    language_list = list(languages.values()) if languages else ['Unknown']
                     
-                    result = f"✈️ **Informations Pratiques de Voyage**\n"
-                    result += f"💰 Monnaie: {currency_name}\n"
-                    result += f"🗣️ Langues: {', '.join(language_list[:3])}\n"
-                    result += f"🌍 Région: {region}\n"
-                    result += f"📋 Vérifiez les exigences visa sur le site officiel du pays"
+                    result = f"✈️ **Practical Travel Information**\n"
+                    result += f"💰 Currency: {currency_name}\n"
+                    result += f"🗣️ Languages: {', '.join(language_list[:3])}\n"
+                    result += f"🌍 Region: {region}\n"
+                    result += f"📋 Check visa requirements on the country's official website"
                     
                     return result
             
-            return f"✈️ **Voyage**: Informations non disponibles pour {country}"
+            return f"✈️ **Travel**: Information not available for {country}"
             
         except Exception:
-            return "✈️ **Voyage**: Erreur lors de la récupération"
+            return "✈️ **Travel**: Error during retrieval"
 
     def _get_political_info(self, country: str) -> str:
-        """Récupère le contexte politique via recherche d'actualités"""
+        """Retrieves political context via news search"""
         try:
-            # Rechercher des actualités politiques récentes
+            # Search for recent political news
             political_keywords = f"{country} politics government election democracy"
             political_data = self._search_political_news(political_keywords)
             
             if not political_data:
-                return f"🏛️ **Politique**: Situation stable pour {country}"
+                return f"🏛️ **Politics**: Stable situation for {country}"
             
-            result = f"🏛️ **Contexte Politique**\n"
+            result = f"🏛️ **Political Context**\n"
             
-            # Analyser les actualités politiques
+            # Analyze political news
             for article in political_data[:3]:
                 title = article.get('title', '')
                 if title:
@@ -663,7 +663,7 @@ PRIORITÉ ABSOLUE : Protéger les voyageurs - en cas de doute, choisissez le niv
             return result.rstrip()
             
         except Exception:
-            return "🏛️ **Politique**: Erreur lors de la récupération"
+            return "🏛️ **Politics**: Error during retrieval"
 
     def _search_political_news(self, keywords: str) -> list:
         """Recherche d'actualités politiques"""
@@ -691,34 +691,34 @@ PRIORITÉ ABSOLUE : Protéger les voyageurs - en cas de doute, choisissez le niv
             return []
 
     def _get_llm_final_recommendation(self, country: str, full_report: str) -> Optional[str]:
-        """Utilise Claude pour générer une recommandation finale intelligente"""
+        """Uses Claude to generate an intelligent final recommendation"""
         try:
             if not self.claude_client:
                 return None
                 
-            prompt = f"""Analysez ce rapport complet sur {country} et donnez une recommandation finale concise pour un voyageur français :
+            prompt = f"""Analyze this complete report about {country} and provide a concise final recommendation for a traveler:
 
-RAPPORT COMPLET :
+COMPLETE REPORT:
 {full_report}
 
-Votre tâche :
-1. Synthétisez les informations les plus importantes
-2. Donnez une recommandation claire et actionnable
-3. Répondez en français, maximum 200 mots
-4. Utilisez un ton professionnel mais accessible
-5. Si des risques existent, soyez explicite sur les précautions
+Your task:
+1. Synthesize the most important information
+2. Give a clear and actionable recommendation
+3. Respond in English, maximum 200 words
+4. Use a professional but accessible tone
+5. If risks exist, be explicit about precautions
 
-Format de réponse souhaité :
-🎯 **RECOMMANDATION FINALE**
-[Votre analyse synthétique et recommandation]
+Desired response format:
+🎯 **FINAL RECOMMENDATION**
+[Your synthetic analysis and recommendation]
 
-Si la destination est dangereuse, utilisez clairement "CHANGEZ DE DESTINATION" dans votre réponse."""
+If the destination is dangerous, clearly use "CHANGE DESTINATION" in your response."""
 
             response = self.claude_client.messages.create(
                 model="claude-3-opus-20240229",
                 max_tokens=250,
                 temperature=0.2,
-                system="Vous êtes un conseiller en voyage expert. Donnez des recommandations claires et pratiques.",
+                system="You are an expert travel advisor. Provide clear and practical recommendations.",
                 messages=[
                     {"role": "user", "content": prompt}
                 ]

tools/weather_tool.py

@@ -29,7 +29,7 @@ class WeatherTool(Tool):
         
         # Initialiser le client Claude pour les recommandations intelligentes
         try:
-            self.claude_client = anthropic.Anthropic(api_key=os.getenv('ANTHROPIC_API_KEY'))
+            self.claude_client = anthropic.Anthropic(api_key=os.getenv('ANTROPIC_KEY'))
         except:
             self.claude_client = None