import os from typing import Dict, List, Optional from google.cloud import translate_v2 as translate from functools import lru_cache import json from dotenv import load_dotenv # Load environment variables from .env file load_dotenv() class TranslationService: """ Translation service using Google Cloud Translation API Supports English (default) and Korean languages """ def __init__(self): """Initialize Google Cloud Translation client""" # Load and verify Google Cloud credentials from environment credentials_path = os.getenv("GOOGLE_APPLICATION_CREDENTIALS") if credentials_path: print(f"Using Google Cloud credentials file: {credentials_path}") # Check if file exists if not os.path.exists(credentials_path): print(f"Warning: Credentials file not found at: {credentials_path}") print("Translations will be disabled.") self.client = None self.supported_languages = ['en', 'ko'] self.default_language = 'en' return else: print("Warning: GOOGLE_APPLICATION_CREDENTIALS not set in environment") print("Translations will be disabled. Set this variable in .env file to enable.") self.client = None self.supported_languages = ['en', 'ko'] self.default_language = 'en' return # Try to initialize the translation client try: self.client = translate.Client() self.supported_languages = ['en', 'ko'] # English and Korean self.default_language = 'en' print("Translation service initialized successfully") # Test the connection with a simple translation try: test_result = self.client.translate("Hello", target_language='ko') translated = test_result['translatedText'] print(f"Translation API test successful") except Exception as test_error: print(f"Warning: Translation API test failed: {test_error}") print("Translation service may not work correctly.") except Exception as e: print(f"Translation service initialization failed: {e}") print("Translations will be disabled.") print("\nTroubleshooting steps:") print("1. Check that GOOGLE_APPLICATION_CREDENTIALS is set in .env") print("2. Verify the credentials file exists and is valid JSON") print("3. Ensure Cloud Translation API is enabled in your GCP project") print("4. Verify the service account has 'Cloud Translation API User' role") self.client = None def is_translation_enabled(self) -> bool: """Check if translation service is available""" return self.client is not None @lru_cache(maxsize=1000) def translate_text(self, text: str, target_language: str, source_language: str = 'en') -> str: """ Translate text to target language Args: text: Text to translate target_language: Target language code ('en' or 'ko') source_language: Source language code (default: 'en') Returns: Translated text or original text if translation fails """ if not self.is_translation_enabled(): return text # If target language is same as source, return original if target_language == source_language: return text # Validate language codes if target_language not in self.supported_languages: print(f"Unsupported target language: {target_language}, defaulting to {self.default_language}") return text if not text or not text.strip(): return text try: result = self.client.translate( text, target_language=target_language, source_language=source_language, format_='text' ) return result['translatedText'] except Exception as e: print(f"Translation error: {e}") return text def translate_list(self, texts: List[str], target_language: str, source_language: str = 'en') -> List[str]: """ Translate a list of texts Args: texts: List of texts to translate target_language: Target language code source_language: Source language code Returns: List of translated texts """ if not self.is_translation_enabled(): return texts if target_language == source_language: return texts translated_texts = [] for text in texts: translated = self.translate_text(text, target_language, source_language) translated_texts.append(translated) return translated_texts def translate_dict(self, data: Dict, target_language: str, fields_to_translate: List[str], source_language: str = 'en') -> Dict: """ Translate specific fields in a dictionary Args: data: Dictionary containing data target_language: Target language code fields_to_translate: List of field names to translate source_language: Source language code Returns: Dictionary with translated fields """ if not self.is_translation_enabled(): return data if target_language == source_language: return data translated_data = data.copy() for field in fields_to_translate: if field in translated_data and isinstance(translated_data[field], str): translated_data[field] = self.translate_text( translated_data[field], target_language, source_language ) return translated_data def translate_meal(self, meal_data: Dict, target_language: str) -> Dict: """ Translate meal data including name, description, and ingredients Args: meal_data: Meal dictionary target_language: Target language code Returns: Translated meal dictionary """ if not self.is_translation_enabled() or target_language == 'en': return meal_data translated_meal = meal_data.copy() # Translate meal name if 'meal_name' in translated_meal: translated_meal['meal_name'] = self.translate_text( translated_meal['meal_name'], target_language ) # Translate description if 'description' in translated_meal: translated_meal['description'] = self.translate_text( translated_meal['description'], target_language ) # Translate category if 'category' in translated_meal: translated_meal['category'] = self.translate_text( translated_meal['category'], target_language ) # Translate sub_category if 'sub_category' in translated_meal: translated_meal['sub_category'] = self.translate_text( translated_meal['sub_category'], target_language ) # Translate ingredients if 'ingredients' in translated_meal and isinstance(translated_meal['ingredients'], list): translated_ingredients = [] for ingredient in translated_meal['ingredients']: if isinstance(ingredient, dict): translated_ing = ingredient.copy() if 'name' in translated_ing: translated_ing['name'] = self.translate_text( translated_ing['name'], target_language ) if 'quantity' in translated_ing: translated_ing['quantity'] = self.translate_text( translated_ing['quantity'], target_language ) translated_ingredients.append(translated_ing) else: translated_ingredients.append(ingredient) translated_meal['ingredients'] = translated_ingredients return translated_meal def translate_meal_plan_response(self, meal_plan: Dict, target_language: str) -> Dict: """ Translate entire meal plan response with new structure Args: meal_plan: Meal plan dictionary target_language: Target language code Returns: Translated meal plan dictionary """ if not self.is_translation_enabled() or target_language == 'en': return meal_plan translated_plan = meal_plan.copy() # Define meal categories and sub-categories meal_categories = ['breakfast_options', 'lunch_options', 'dinner_options'] sub_categories = ['protein_packed', 'light_fresh', 'healthy_comforting'] # Translate sub-category names in the keys if needed # (Note: Keys remain the same, but we translate display names in the meal data) for category in meal_categories: if category in translated_plan: for sub_cat in sub_categories: if sub_cat in translated_plan[category]: # Translate each meal in the sub-category translated_meals = [] for meal in translated_plan[category][sub_cat]: translated_meal = self.translate_meal(meal, target_language) # Also translate sub_category field in the meal if 'sub_category' in translated_meal: translated_meal['sub_category'] = self.translate_text( translated_meal['sub_category'], target_language ) translated_meals.append(translated_meal) translated_plan[category][sub_cat] = translated_meals # Translate any other text fields if 'meal_calorie_distribution' in translated_plan: # This is a dict with numbers, no translation needed for keys pass return translated_plan def translate_food_scan_response(self, scan_result: Dict, target_language: str) -> Dict: """ Translate food scan response Args: scan_result: Food scan result dictionary target_language: Target language code Returns: Translated food scan result """ if not self.is_translation_enabled() or target_language == 'en': return scan_result translated_result = scan_result.copy() # Translate identified ingredients if 'identified_ingredients' in translated_result: translated_result['identified_ingredients'] = self.translate_list( translated_result['identified_ingredients'], target_language ) # Translate harmful ingredients if 'harmful_ingredients' in translated_result: translated_harmful = [] for item in translated_result['harmful_ingredients']: if isinstance(item, dict): translated_item = item.copy() if 'name' in translated_item: translated_item['name'] = self.translate_text( translated_item['name'], target_language ) if 'reason' in translated_item: translated_item['reason'] = self.translate_text( translated_item['reason'], target_language ) translated_harmful.append(translated_item) translated_result['harmful_ingredients'] = translated_harmful # Translate low priority ingredients if 'safe_ingredients' in translated_result: translated_low = [] for item in translated_result['safe_ingredients']: if isinstance(item, dict): translated_item = item.copy() if 'name' in translated_item: translated_item['name'] = self.translate_text( translated_item['name'], target_language ) if 'reason' in translated_item: translated_item['reason'] = self.translate_text( translated_item['reason'], target_language ) translated_low.append(translated_item) translated_result['safe_ingredients'] = translated_low # Translate safe ingredients if 'neutral_ingredients' in translated_result: translated_safe = [] for item in translated_result['neutral_ingredients']: if isinstance(item, dict): translated_item = item.copy() if 'name' in translated_item: translated_item['name'] = self.translate_text( translated_item['name'], target_language ) translated_safe.append(translated_item) translated_result['neutral_ingredients'] = translated_safe # Translate messages if 'warning_message' in translated_result: translated_result['warning_message'] = self.translate_text( translated_result['warning_message'], target_language ) if 'safe_message' in translated_result: translated_result['safe_message'] = self.translate_text( translated_result['safe_message'], target_language ) if 'neutral_message' in translated_result: translated_result['neutral_message'] = self.translate_text( translated_result['neutral_message'], target_language ) if 'food_types' in translated_result: translated_types = [] for item in translated_result['food_types']: if isinstance(item, dict): translated_item = item.copy() if 'title' in translated_item: translated_item['title'] = self.translate_text( translated_item['title'], target_language ) if 'description' in translated_item: translated_item['description'] = self.translate_text( translated_item['description'], target_language ) translated_types.append(translated_item) else: translated_types.append(item) translated_result['food_types'] = translated_types return translated_result def get_language_name(self, language_code: str) -> str: """Get language name from code""" language_names = { 'en': 'English', 'ko': '한국어 (Korean)' } return language_names.get(language_code, language_code) # Global translation service instance translation_service = TranslationService()