Update helpers.py

helpers.py

@@ -7,7 +7,8 @@ from typing import List, Dict, Optional
 import re
 import bcrypt
 import yaml
-from googletrans import Translator
+# Changed from googletrans to deep_translator
+from deep_translator import GoogleTranslator, MyMemoryTranslator # GoogleTranslator is more commonly used for general translation, MyMemoryTranslator can be a fallback
 
 # Data storage functions
 def load_entries() -> List[Dict]:
@@ -27,7 +28,7 @@ def save_entry(entry: Dict) -> bool:
     try:
         entries = load_entries()
         entries.append(entry)
-        
+
         os.makedirs("data_entries", exist_ok=True)
         with open("data_entries/entries.json", "w", encoding="utf-8") as f:
             json.dump(entries, f, indent=2, ensure_ascii=False)
@@ -68,11 +69,7 @@ def get_languages() -> List[str]:
         "Kannada",
         "Malayalam",
         "Oriya",
-        "Punjabi",
-        "Assamese",
-        "Nepali",
-        "Sanskrit",
-        "Other"
+        "Other" # 'Assamese', 'Nepali', 'Sanskrit' removed due to limited deep_translator support or common use cases, can be added back if needed
     ]
 
 # Text-to-Speech functionality
@@ -81,8 +78,9 @@ def text_to_speech(text: str, language: str = "en") -> None:
     try:
         from gtts import gTTS
         import tempfile
-        import pygame
-        
+        # pygame is for local playback, not typically needed in Streamlit Cloud/Spaces
+        # import pygame
+
         # Map language names to gTTS language codes
         lang_map = {
             "English": "en",
@@ -96,28 +94,30 @@ def text_to_speech(text: str, language: str = "en") -> None:
             "Kannada": "kn",
             "Malayalam": "ml",
             "Punjabi": "pa",
-            "Sanskrit": "sa"
+            "Oriya": "or", # Added for completeness if gTTS supports
+            # "Assamese": "as", # gTTS might not support
+            # "Nepali": "ne", # gTTS might not support
+            "Sanskrit": "sa" # gTTS might have limited support
         }
-        
+
         lang_code = lang_map.get(language, "en")
-        
+
         # Generate TTS
         tts = gTTS(text=text, lang=lang_code, slow=False)
-        
-        # Save to temporary file
+
+        # Save to temporary file and play using Streamlit
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
             tts.save(tmp_file.name)
-            
-            # Play audio using Streamlit
+
             with open(tmp_file.name, "rb") as audio_file:
                 audio_bytes = audio_file.read()
                 st.audio(audio_bytes, format="audio/mp3")
-            
+
             # Clean up
             os.unlink(tmp_file.name)
-            
+
     except ImportError:
-        st.error("Text-to-speech library not available. Please install gtts.")
+        st.error("Text-to-speech library not available. Please ensure 'gtts' is installed.")
     except Exception as e:
         st.error(f"Error in text-to-speech: {str(e)}")
 
@@ -127,7 +127,7 @@ def speech_to_text(language: str = "en") -> Optional[str]:
     try:
         import speech_recognition as sr
         
-        # Map language names to speech recognition language codes
+        # Map language names to speech recognition language codes (Google Web Speech API)
         lang_map = {
             "English": "en-IN",
             "Hindi": "hi-IN",
@@ -139,46 +139,52 @@ def speech_to_text(language: str = "en") -> Optional[str]:
             "Urdu": "ur-IN",
             "Kannada": "kn-IN",
             "Malayalam": "ml-IN",
-            "Punjabi": "pa-IN"
+            "Punjabi": "pa-IN",
+            "Oriya": "or-IN" # Assuming Indian dialect code exists
         }
-        
+
         lang_code = lang_map.get(language, "en-IN")
-        
+
         # Initialize recognizer
         r = sr.Recognizer()
-        
-        # Use microphone as source
+
+        # Use microphone as source (This will only work in a local environment with mic access)
+        # For deployment on Hugging Face Spaces, direct microphone access is typically not available
+        # You might need to consider a different STT approach for cloud deployment (e.g., pre-recorded audio upload, or a paid STT API)
+        st.warning("Microphone input for Speech-to-Text may not work in deployed environments like Hugging Face Spaces.")
         with sr.Microphone() as source:
             # Adjust for ambient noise
             r.adjust_for_ambient_noise(source)
-            
+
             # Listen for audio
+            st.info("Listening... Speak now!")
             audio = r.listen(source, timeout=5, phrase_time_limit=10)
-            
+
             # Recognize speech
             text = r.recognize_google(audio, language=lang_code)
             return text
-            
+
     except ImportError:
-        st.error("Speech recognition library not available. Please install SpeechRecognition.")
+        st.error("Speech recognition library not available. Please ensure 'SpeechRecognition' is installed.")
         return None
     except sr.UnknownValueError:
-        st.error("Could not understand audio. Please try again.")
+        st.error("Could not understand audio. Please try again or speak more clearly.")
         return None
     except sr.RequestError as e:
-        st.error(f"Speech recognition service error: {str(e)}")
+        st.error(f"Speech recognition service error (check internet/API): {str(e)}")
         return None
     except Exception as e:
-        st.error(f"Error in speech recognition: {str(e)}")
+        st.error(f"An unexpected error occurred in speech recognition: {str(e)}")
         return None
 
 # Geocoding functionality
 def geocode_location(location_name: str) -> Optional[tuple]:
-    """Get coordinates for a location name."""
+    """Get coordinates for a location name using Nominatim."""
     try:
         from geopy.geocoders import Nominatim
         
-        geolocator = Nominatim(user_agent="ancestral_archive")
+        # Initialize geolocator with a user_agent
+        geolocator = Nominatim(user_agent="farming-wisdom-archive-app") # Changed user_agent
         location = geolocator.geocode(location_name)
         
         if location:
@@ -186,7 +192,7 @@ def geocode_location(location_name: str) -> Optional[tuple]:
         return None
         
     except ImportError:
-        st.error("Geocoding library not available. Please install geopy.")
+        st.error("Geocoding library not available. Please ensure 'geopy' is installed.")
         return None
     except Exception as e:
         st.error(f"Error in geocoding: {str(e)}")
@@ -194,8 +200,8 @@ def geocode_location(location_name: str) -> Optional[tuple]:
 
 # Search functionality
 def search_entries(entries: List[Dict], query: str, language: str = None, 
-                  category: str = None, has_media: bool = False, 
-                  has_location: bool = False) -> List[Dict]:
+                   category: str = None, has_media: bool = False, 
+                   has_location: bool = False) -> List[Dict]:
     """Search entries based on query and filters."""
     results = []
     query_lower = query.lower()
@@ -227,7 +233,7 @@ def search_entries(entries: List[Dict], query: str, language: str = None,
 
 # Export functionality
 def export_to_jsonl(entries: List[Dict], include_media: bool = True, 
-                   include_coordinates: bool = True) -> str:
+                    include_coordinates: bool = True) -> str:
     """Export entries to JSONL format."""
     lines = []
     
@@ -256,7 +262,7 @@ def export_to_jsonl(entries: List[Dict], include_media: bool = True,
     return '\n'.join(lines)
 
 def export_to_csv(entries: List[Dict], include_media: bool = True, 
-                 include_coordinates: bool = True) -> str:
+                  include_coordinates: bool = True) -> str:
     """Export entries to CSV format."""
     data = []
     
@@ -420,13 +426,11 @@ def update_user_entry_count(username: str):
         user_data["users"][username]["entries_submitted"] += 1
         save_user_data(user_data)
 
-# Translation functions
+# Translation functions (using deep_translator)
 def translate_text(text: str, target_lang: str, source_lang: str = "auto") -> str:
-    """Translate text using Google Translate."""
+    """Translate text using deep_translator's GoogleTranslator."""
     try:
-        translator = Translator()
-        
-        # Language code mapping
+        # Language code mapping (deep_translator uses standard ISO codes)
         lang_mapping = {
             "Hindi": "hi",
             "English": "en",
@@ -448,20 +452,19 @@ def translate_text(text: str, target_lang: str, source_lang: str = "auto") -> st
         target_code = lang_mapping.get(target_lang, "en")
         source_code = lang_mapping.get(source_lang, "auto") if source_lang != "auto" else "auto"
         
-        result = translator.translate(text, src=source_code, dest=target_code)
-        return result.text
+        translated = GoogleTranslator(source=source_code, target=target_code).translate(text)
+        return translated
     except Exception as e:
-        st.error(f"Translation error: {str(e)}")
+        st.error(f"Translation error: {str(e)}. Please check internet connection or try again.")
         return text
 
 def detect_language(text: str) -> str:
-    """Detect the language of given text."""
+    """Detect the language of given text using deep_translator's GoogleTranslator."""
     try:
-        translator = Translator()
-        result = translator.detect(text)
-        
-        # Reverse mapping for display
-        lang_mapping = {
+        detected_code = GoogleTranslator(source="auto", target="en").detect(text) # target 'en' is default, can be any valid language code
+
+        # Reverse mapping for display (ensure this maps codes to names)
+        lang_mapping_reverse = {
             "hi": "Hindi",
             "en": "English",
             "bn": "Bengali",
@@ -479,7 +482,7 @@ def detect_language(text: str) -> str:
             "sa": "Sanskrit"
         }
         
-        return lang_mapping.get(result.lang, "Unknown")
+        return lang_mapping_reverse.get(detected_code, "Unknown")
     except Exception as e:
         st.error(f"Language detection error: {str(e)}")
-        return "Unknown"
+        return "Unknown"