hilenski

backend/main.py

@@ -87,8 +87,8 @@ def initialize_model():
     try:
         print(f"Initializing model and tokenizer (attempt {model_initialization_attempts})...")
         
-        # Use a better translation model that handles multilingual tasks well
-        model_name = "facebook/nllb-200-distilled-600M"  # Better multilingual translation model
+        # Use a smaller, faster model
+        model_name = "Helsinki-NLP/opus-mt-en-ar"  # Much smaller English-to-Arabic model
         
         # Check for available device - properly detect CPU/GPU
         device = "cpu"  # Default to CPU which is more reliable
@@ -99,15 +99,20 @@ def initialize_model():
         
         # Load the tokenizer with explicit cache directory
         print(f"Loading tokenizer from {model_name}...")
-        tokenizer = AutoTokenizer.from_pretrained(
-            model_name, 
-            cache_dir="/tmp/transformers_cache",
-            use_fast=True  # Use faster tokenizer when possible
-        )
-        if tokenizer is None:
-            print("Failed to load tokenizer")
+        try:
+            tokenizer = AutoTokenizer.from_pretrained(
+                model_name, 
+                cache_dir="/tmp/transformers_cache",
+                use_fast=True,
+                local_files_only=False
+            )
+            if tokenizer is None:
+                print("Failed to load tokenizer")
+                return False
+            print("Tokenizer loaded successfully")
+        except Exception as e:
+            print(f"Error loading tokenizer: {e}")
             return False
-        print("Tokenizer loaded successfully")
         
         # Load the model with explicit device placement
         print(f"Loading model from {model_name}...")
@@ -143,8 +148,7 @@ def initialize_model():
                 return False
                 
             # Test the model with a simple translation to verify it works
-            # NLLB needs language codes in format like "eng_Latn" and "ara_Arab"
-            test_result = translator("hello", src_lang="eng_Latn", tgt_lang="ara_Arab", max_length=128)
+            test_result = translator("hello world", max_length=128)
             print(f"Model test result: {test_result}")
             if not test_result or not isinstance(test_result, list) or len(test_result) == 0:
                 print("Model test failed: Invalid output format")
@@ -194,25 +198,19 @@ Text to translate:
         else:
             # For non-Arabic target languages, use standard approach
             prompt = text
-            
-        # Prepare input with explicit instruction format for better results with NLLB
-        src_lang_code = f"{source_lang}_Latn" if source_lang != "ar" else f"{source_lang}_Arab"
-        tgt_lang_code = f"{target_lang}_Latn" if target_lang != "ar" else f"{target_lang}_Arab"
         
         # Use a more reliable timeout approach with concurrent.futures
         with concurrent.futures.ThreadPoolExecutor() as executor:
             future = executor.submit(
                 lambda: translator(
                     prompt,  # Using our enhanced prompt instead of raw text
-                    src_lang=src_lang_code,
-                    tgt_lang=tgt_lang_code,
                     max_length=768  # Increased max_length to accommodate longer prompt
                 )[0]["translation_text"]
             )
             
             try:
-                # Set a reasonable timeout (15 seconds instead of 10)
-                result = future.result(timeout=15)
+                # Set a reasonable timeout (10 seconds instead of 15)
+                result = future.result(timeout=10)
                 
                 # Post-process the result for Arabic cultural adaptation
                 if target_lang == "ar":
@@ -220,7 +218,7 @@ Text to translate:
                 
                 return result
             except concurrent.futures.TimeoutError:
-                print(f"Model inference timed out after 15 seconds, falling back to online translation")
+                print(f"Model inference timed out after 10 seconds, falling back to online translation")
                 return use_fallback_translation(text, source_lang, target_lang)
             except Exception as e:
                 print(f"Error during model inference: {e}")
@@ -265,7 +263,7 @@ def check_and_reinitialize_model():
             
         # Test the existing model with a simple translation
         test_text = "hello"
-        result = translator(test_text, src_lang="eng_Latn", tgt_lang="fra_Latn", max_length=128)
+        result = translator(test_text, max_length=128)
         
         # If we got a valid result, model is working fine
         if result and isinstance(result, list) and len(result) > 0:
@@ -281,15 +279,30 @@ def check_and_reinitialize_model():
 
 def use_fallback_translation(text, source_lang, target_lang):
     """Use various fallback online translation services."""
-    # List of LibreTranslate servers to try in order
+    print("Using fallback translation...")
+    
+    # Try Google Translate API with a wrapper first (most reliable)
+    try:
+        print("Attempting fallback with Google Translate (no API key)")
+        from googletrans import Translator
+        google_translator = Translator(service_urls=['translate.google.com', 'translate.google.co.kr'])
+        result = google_translator.translate(text, src=source_lang, dest=target_lang)
+        if result and result.text:
+            print("Google Translate successful!")
+            return result.text
+    except Exception as e:
+        print(f"Error with Google Translate fallback: {str(e)}")
+    
+    # List of LibreTranslate servers to try with increased timeout
     libre_servers = [
         "https://translate.terraprint.co/translate",
         "https://libretranslate.de/translate",
         "https://translate.argosopentech.com/translate",
-        "https://translate.fedilab.app/translate"  # Added additional server
+        "https://translate.fedilab.app/translate",
+        "https://trans.zillyhuhn.com/translate"  # Additional server
     ]
     
-    # Try each LibreTranslate server
+    # Try each LibreTranslate server with increased timeout
     for server in libre_servers:
         try:
             print(f"Attempting fallback translation using LibreTranslate: {server}")
@@ -302,30 +315,38 @@ def use_fallback_translation(text, source_lang, target_lang):
                 "target": target_lang
             }
             
-            # Use a shorter timeout for the request (5 seconds instead of 10)
-            response = requests.post(server, json=payload, headers=headers, timeout=5)
+            # Use a longer timeout for the request (8 seconds instead of 5)
+            response = requests.post(server, json=payload, headers=headers, timeout=8)
             
             if response.status_code == 200:
                 result = response.json()
                 if "translatedText" in result:
+                    print(f"LibreTranslate successful using {server}")
                     return result["translatedText"]
         except Exception as e:
             print(f"Error with LibreTranslate {server}: {str(e)}")
             continue
     
-    # If all LibreTranslate servers fail, try Google Translate API with a wrapper
-    # that doesn't need an API key for limited usage
+    # Try MyMemory as another fallback
     try:
-        print("Attempting fallback with Google Translate (no API key)")
-        from googletrans import Translator
-        google_translator = Translator()
-        result = google_translator.translate(text, src=source_lang, dest=target_lang)
-        return result.text
+        print("Attempting fallback with MyMemory Translation API")
+        url = "https://api.mymemory.translated.net/get"
+        params = {
+            "q": text,
+            "langpair": f"{source_lang}|{target_lang}",
+        }
+        response = requests.get(url, params=params, timeout=10)
+        if response.status_code == 200:
+            data = response.json()
+            if data and data.get("responseData") and data["responseData"].get("translatedText"):
+                print("MyMemory translation successful!")
+                return data["responseData"]["translatedText"]
     except Exception as e:
-        print(f"Error with Google Translate fallback: {str(e)}")
+        print(f"Error with MyMemory fallback: {str(e)}")
     
     # Final fallback - return original text with error message
-    return f"[Translation failed] {text}"
+    print("All translation services failed. Returning error message.")
+    return f"[Translation services unavailable] {text}"
 
 # --- Helper Functions ---
 async def extract_text_from_file(file: UploadFile) -> str:

static/script.js

@@ -1,235 +1,217 @@
-document.addEventListener('DOMContentLoaded', () => {
-    console.log("Translation app initialized");
+// Wait for the DOM to be fully loaded before attaching event handlers
+document.addEventListener('DOMContentLoaded', function() {
+    console.log('DOM fully loaded, initializing translation app');
     
-    // Get form elements - only get the base forms on page load
-    const textForm = document.getElementById('text-translation-form');
-    const docForm = document.getElementById('doc-translation-form');
+    // Get form elements
+    const textTranslationForm = document.getElementById('text-translation-form');
+    const docTranslationForm = document.getElementById('doc-translation-form');
     
-    // Simple function to show errors
-    function showError(message) {
-        const errorDiv = document.getElementById('error-message');
-        if (errorDiv) {
-            errorDiv.textContent = "Error: " + message;
-            errorDiv.style.display = 'block';
-            console.error("Error:", message);
-        } else {
-            alert("Error: " + message);
-            console.error("Error div not found. Error:", message);
-        }
+    // Set up text translation form
+    if (textTranslationForm) {
+        console.log('Text translation form found');
+        textTranslationForm.onsubmit = handleTextTranslation;
+    } else {
+        console.error('Text translation form not found!');
     }
     
-    // Simple function to show debug information
-    function showDebug(message) {
-        console.log("DEBUG:", message);
-        const debugDiv = document.getElementById('debug-info');
-        if (debugDiv) {
-            debugDiv.textContent = typeof message === 'string' ? message : JSON.stringify(message, null, 2);
-            debugDiv.style.display = 'block';
-        }
+    // Set up document translation form
+    if (docTranslationForm) {
+        console.log('Document translation form found');
+        docTranslationForm.onsubmit = handleDocTranslation;
+    } else {
+        console.error('Document translation form not found!');
     }
     
-    // Clear all feedback elements
-    function clearFeedback() {
-        const elements = ['error-message', 'debug-info', 'text-result'];
-        elements.forEach(id => {
-            const el = document.getElementById(id);
-            if (el) {
-                el.style.display = 'none';
-                if (id !== 'text-result') el.textContent = '';
+    // Function to handle text translation
+    function handleTextTranslation(event) {
+        event.preventDefault();
+        console.log('Text translation form submitted');
+        
+        // Clear previous results and errors
+        hideElement('text-result');
+        hideElement('error-message');
+        hideElement('debug-info');
+        
+        // Get form elements
+        const textInputElement = document.getElementById('text-input');
+        const sourceLangElement = document.getElementById('source-lang-text');
+        const targetLangElement = document.getElementById('target-lang-text');
+        const loadingElement = document.getElementById('text-loading');
+        const debugElement = document.getElementById('debug-info');
+        
+        // Debug which elements were found
+        let debug = 'Found elements: ';
+        debug += textInputElement ? 'text-input ✓ ' : 'text-input ✗ ';
+        debug += sourceLangElement ? 'source-lang-text ✓ ' : 'source-lang-text ✗ ';
+        debug += targetLangElement ? 'target-lang-text ✓ ' : 'target-lang-text ✗ ';
+        console.log(debug);
+        
+        // Show debug info
+        if (debugElement) {
+            debugElement.textContent = debug;
+            debugElement.style.display = 'block';
+        }
+        
+        // Check for missing elements
+        if (!textInputElement || !sourceLangElement || !targetLangElement) {
+            showError('One or more form elements are missing');
+            return;
+        }
+        
+        // Get text input
+        const textInput = textInputElement.value ? textInputElement.value.trim() : '';
+        if (!textInput) {
+            showError('Please enter text to translate');
+            return;
+        }
+        
+        // Get language selections
+        const sourceLang = sourceLangElement.value;
+        const targetLang = targetLangElement.value;
+        
+        // Show loading indicator
+        if (loadingElement) {
+            loadingElement.style.display = 'block';
+        }
+        
+        // Create request payload
+        const payload = {
+            text: textInput,
+            source_lang: sourceLang, 
+            target_lang: targetLang
+        };
+        
+        // Make the API request
+        fetch('/translate/text', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload)
+        })
+        .then(function(response) {
+            if (!response.ok) {
+                throw new Error(`Server returned ${response.status}: ${response.statusText}`);
+            }
+            return response.text();
+        })
+        .then(function(responseText) {
+            // Show response in debug
+            if (debugElement) {
+                debugElement.textContent += '\n\nResponse: ' + responseText;
             }
-        });
-    }
-    
-    // Add text form submission handler
-    if (textForm) {
-        textForm.addEventListener('submit', function(e) {
-            e.preventDefault();
-            clearFeedback();
             
+            let data;
             try {
-                // Find form elements when needed, not earlier
-                const textInput = document.getElementById('text-input');
-                const sourceLang = document.getElementById('source-lang-text');
-                const targetLang = document.getElementById('target-lang-text');
-                const textLoading = document.getElementById('text-loading');
-                
-                // Debug which elements were found/not found
-                const foundElements = {
-                    textInput: !!textInput,
-                    sourceLang: !!sourceLang,
-                    targetLang: !!targetLang,
-                    textLoading: !!textLoading
-                };
-                showDebug("Found elements: " + JSON.stringify(foundElements));
-                
-                // Check if elements exist
-                if (!textInput || !sourceLang || !targetLang) {
-                    showError("Required form elements not found");
-                    return;
-                }
-                
-                // Get values safely
-                const text = textInput.value ? textInput.value.trim() : '';
-                if (!text) {
-                    showError("Please enter text to translate");
-                    return;
-                }
-                
-                // Show loading state if element exists
-                if (textLoading) textLoading.style.display = 'block';
-                
-                // Prepare request data
-                const requestData = {
-                    text: text,
-                    source_lang: sourceLang.value,
-                    target_lang: targetLang.value
-                };
-                
-                // Debug the request data
-                showDebug("Sending request: " + JSON.stringify(requestData));
-                
-                // Use simple promise then/catch for better browser compatibility
-                fetch('/translate/text', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json'
-                    },
-                    body: JSON.stringify(requestData)
-                })
-                .then(response => {
-                    // First check if response is ok
-                    if (!response.ok) {
-                        throw new Error('Server returned ' + response.status);
-                    }
-                    return response.text();
-                })
-                .then(responseText => {
-                    // Parse the response text
-                    showDebug("Got response: " + responseText);
-                    
-                    let data;
-                    try {
-                        data = JSON.parse(responseText);
-                    } catch (err) {
-                        throw new Error('Invalid JSON response');
-                    }
-                    
-                    // Check for translation result
-                    if (data && data.translated_text) {
-                        // Display the result
-                        const resultBox = document.getElementById('text-result');
-                        const outputEl = document.getElementById('text-output');
-                        
-                        if (resultBox && outputEl) {
-                            outputEl.textContent = data.translated_text;
-                            resultBox.style.display = 'block';
-                        } else {
-                            throw new Error('Result display elements not found');
-                        }
-                    } else {
-                        throw new Error(data.error || 'No translation result returned');
-                    }
-                })
-                .catch(error => {
-                    showError(error.message || "Translation failed");
-                    console.error("Translation error:", error);
-                })
-                .finally(() => {
-                    // Hide loading indicator
-                    if (textLoading) textLoading.style.display = 'none';
-                });
-                
+                data = JSON.parse(responseText);
             } catch (error) {
-                showError(error.message || "An unexpected error occurred");
-                console.error("General error:", error);
-                
-                // Ensure loading indicator is hidden
-                const textLoading = document.getElementById('text-loading');
-                if (textLoading) textLoading.style.display = 'none';
+                throw new Error('Invalid JSON response from server');
+            }
+            
+            if (!data.translated_text && !data.success) {
+                throw new Error(data.error || 'No translation returned');
+            }
+            
+            // Show the result
+            const resultBox = document.getElementById('text-result');
+            const outputElement = document.getElementById('text-output');
+            if (resultBox && outputElement) {
+                outputElement.textContent = data.translated_text;
+                resultBox.style.display = 'block';
+            }
+        })
+        .catch(function(error) {
+            showError(error.message);
+            console.error('Translation error:', error);
+        })
+        .finally(function() {
+            // Hide loading indicator
+            if (loadingElement) {
+                loadingElement.style.display = 'none';
             }
         });
-    } else {
-        console.error("Text translation form not found!");
     }
-
-    // Document translation handler with similar approach
-    if (docForm) {
-        docForm.addEventListener('submit', function(e) {
-            e.preventDefault();
-            clearFeedback();
+    
+    // Function to handle document translation
+    function handleDocTranslation(event) {
+        event.preventDefault();
+        console.log('Document translation form submitted');
+        
+        // Clear previous results and errors
+        hideElement('doc-result');
+        hideElement('error-message');
+        
+        // Get form elements
+        const fileInput = document.getElementById('doc-input');
+        const loadingIndicator = document.getElementById('doc-loading');
+        
+        if (!fileInput || !fileInput.files || fileInput.files.length === 0) {
+            showError('Please select a document to upload');
+            return;
+        }
+        
+        // Show loading indicator
+        if (loadingIndicator) {
+            loadingIndicator.style.display = 'block';
+        }
+        
+        // Create form data
+        const formData = new FormData(docTranslationForm);
+        
+        // Make API request
+        fetch('/translate/document', {
+            method: 'POST',
+            body: formData
+        })
+        .then(function(response) {
+            if (!response.ok) {
+                throw new Error(`Server returned ${response.status}`);
+            }
+            return response.json();
+        })
+        .then(function(data) {
+            if (!data.translated_text) {
+                throw new Error('No translation returned');
+            }
             
-            try {
-                const fileInput = document.getElementById('doc-input');
-                const loadingIndicator = document.getElementById('doc-loading');
-                
-                if (!fileInput || !fileInput.files || fileInput.files.length === 0) {
-                    showError("Please select a document to upload");
-                    return;
-                }
-                
-                if (loadingIndicator) loadingIndicator.style.display = 'block';
-                
-                // Create form data
-                const formData = new FormData(docForm);
-                
-                fetch('/translate/document', {
-                    method: 'POST',
-                    body: formData
-                })
-                .then(response => {
-                    if (!response.ok) throw new Error('Server returned ' + response.status);
-                    return response.text();
-                })
-                .then(responseText => {
-                    showDebug("Document response: " + responseText);
-                    
-                    let data;
-                    try {
-                        data = JSON.parse(responseText);
-                    } catch (err) {
-                        throw new Error('Invalid JSON response');
-                    }
-                    
-                    if (!data || !data.translated_text) {
-                        throw new Error('No translation returned');
-                    }
-                    
-                    // Display result
-                    const resultBox = document.getElementById('doc-result');
-                    const outputEl = document.getElementById('doc-output');
-                    const filenameEl = document.getElementById('doc-filename');
-                    const sourceLangEl = document.getElementById('doc-source-lang');
-                    
-                    if (resultBox && outputEl) {
-                        if (filenameEl) filenameEl.textContent = data.original_filename || 'N/A';
-                        if (sourceLangEl) sourceLangEl.textContent = data.detected_source_lang || 'N/A';
-                        outputEl.textContent = data.translated_text;
-                        resultBox.style.display = 'block';
-                    } else {
-                        throw new Error('Result display elements not found');
-                    }
-                })
-                .catch(error => {
-                    showError(error.message || "Document translation failed");
-                })
-                .finally(() => {
-                    if (loadingIndicator) loadingIndicator.style.display = 'none';
-                    const button = docForm.querySelector('button');
-                    if (button) {
-                        button.disabled = false;
-                        button.textContent = 'Translate Document';
-                    }
-                });
-                
-            } catch (error) {
-                showError(error.message || "An unexpected error occurred");
-                console.error("Document error:", error);
-                
-                const loadingIndicator = document.getElementById('doc-loading');
-                if (loadingIndicator) loadingIndicator.style.display = 'none';
+            // Display result
+            const resultBox = document.getElementById('doc-result');
+            const outputEl = document.getElementById('doc-output');
+            const filenameEl = document.getElementById('doc-filename');
+            const sourceLangEl = document.getElementById('doc-source-lang');
+            
+            if (resultBox && outputEl) {
+                if (filenameEl) filenameEl.textContent = data.original_filename || 'N/A';
+                if (sourceLangEl) sourceLangEl.textContent = data.detected_source_lang || 'N/A';
+                outputEl.textContent = data.translated_text;
+                resultBox.style.display = 'block';
+            }
+        })
+        .catch(function(error) {
+            showError(error.message);
+        })
+        .finally(function() {
+            if (loadingIndicator) {
+                loadingIndicator.style.display = 'none';
             }
         });
-    } else {
-        console.error("Document translation form not found!");
+    }
+    
+    // Helper function to show errors
+    function showError(message) {
+        const errorDiv = document.getElementById('error-message');
+        if (errorDiv) {
+            errorDiv.textContent = 'Error: ' + message;
+            errorDiv.style.display = 'block';
+        }
+        console.error('Error:', message);
+    }
+    
+    // Helper function to hide elements
+    function hideElement(id) {
+        const element = document.getElementById(id);
+        if (element) {
+            element.style.display = 'none';
+        }
     }
 });