Fix translation: add OS detection, better error handling and logging

app.py

@@ -84,10 +84,13 @@ class DetailedBackend(Backend):
                         translated_prompt = translator_client.generate_content(prompt)
                         translation_time = (time.time() - translation_start) * 1000
                         was_translated = True
-                        print(f"   ✅ Translated to English ({translation_time:.1f}ms)")
+                        print(f"   ✅ Translated to English ({translation_time:.1f}ms): '{translated_prompt[:100]}...'")
                     except Exception as e:
-                        print(f"⚠️  Translation failed: {e}. Proceeding with original text.")
+                        error_msg = str(e)
+                        print(f"⚠️  Translation failed: {error_msg}")
+                        print(f"   Proceeding with original text (may cause classification issues).")
                         # Continue with original - classifier may still work
+                        translated_prompt = prompt
                 
                 # Classify with ModernBERT (always on English/translated text)
                 ai_response = self.attack_detector.generate_content(translated_prompt)

backend.py

@@ -168,8 +168,11 @@ class Backend:
                 translation_time = (time.time() - translation_start) * 1000
                 print(f"   ✅ Translated to English ({translation_time:.1f}ms): '{translated_prompt[:100]}...'")
             except Exception as e:
-                print(f"⚠️  Translation failed: {e}. Proceeding with original text (may cause classification issues).")
+                error_msg = str(e)
+                print(f"⚠️  Translation failed: {error_msg}")
+                print(f"   Proceeding with original text (may cause classification issues).")
                 # Continue with original prompt - the classifier might still work or fail gracefully
+                translated_prompt = prompt
 
         try:
             # Measure classification latency (always use ModernBERT on translated/English text)

llm_clients/qwen_translator.py

@@ -1,5 +1,6 @@
 from typing import Generator, Any, Dict
 import os
+import sys
 import subprocess
 import tempfile
 import zipfile
@@ -49,6 +50,14 @@ class QwenTranslatorClient(LlmClient):
     @classmethod
     def _download_binary(cls) -> str:
         """Download and extract the pre-built llama.cpp binary from GitHub releases."""
+        # Check OS - the Ubuntu binary only works on Linux
+        if sys.platform == "win32":
+            raise RuntimeError(
+                "Translation with llama.cpp binary is not supported on Windows. "
+                "The pre-built binary is for Linux only. "
+                "Please use this feature on Linux or Hugging Face Spaces."
+            )
+        
         if cls._binary_path and os.path.exists(cls._binary_path):
             return cls._binary_path
         
@@ -81,13 +90,24 @@ class QwenTranslatorClient(LlmClient):
         
         try:
             print(f"   Downloading from: {zip_url}")
-            urllib.request.urlretrieve(zip_url, zip_path)
-            print(f"   ✅ Downloaded to: {zip_path}")
+            # Use a more robust download method
+            try:
+                urllib.request.urlretrieve(zip_url, str(zip_path))
+            except Exception as download_error:
+                raise RuntimeError(f"Failed to download binary from {zip_url}: {download_error}") from download_error
+            
+            if not zip_path.exists():
+                raise RuntimeError(f"Downloaded file not found at {zip_path}")
+            
+            print(f"   ✅ Downloaded to: {zip_path} ({zip_path.stat().st_size / 1024 / 1024:.1f} MB)")
             
             # Extract the zip file
             print(f"   📦 Extracting zip file...")
-            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-                zip_ref.extractall(binary_dir)
+            try:
+                with zipfile.ZipFile(str(zip_path), 'r') as zip_ref:
+                    zip_ref.extractall(str(binary_dir))
+            except Exception as extract_error:
+                raise RuntimeError(f"Failed to extract zip file {zip_path}: {extract_error}") from extract_error
             
             # Find the binary in the extracted files
             # The binary might be called 'main', 'llama-cli', or 'llama'
@@ -110,26 +130,34 @@ class QwenTranslatorClient(LlmClient):
             
             # Also search recursively for any executable file matching our names
             if found_binary is None:
-                for root, dirs, files in os.walk(binary_dir):
+                for root, dirs, files in os.walk(str(binary_dir)):
                     for file in files:
                         if file in possible_binary_names or file.startswith("llama"):
                             candidate = Path(root) / file
                             # Check if it's executable (or at least a regular file)
-                            if candidate.is_file() and os.access(candidate, os.X_OK):
+                            if candidate.is_file():
                                 found_binary = candidate
                                 break
                     if found_binary:
                         break
             
             if found_binary is None:
+                # List what we found for debugging
+                found_files = []
+                for root, dirs, files in os.walk(str(binary_dir)):
+                    for file in files:
+                        found_files.append(str(Path(root) / file))
                 raise RuntimeError(
                     f"Could not find llama.cpp binary in extracted zip. "
                     f"Searched for: {possible_binary_names}. "
-                    f"Please check the zip file structure."
+                    f"Found files: {found_files[:10]}"
                 )
             
-            # Make it executable
-            os.chmod(found_binary, 0o755)
+            # Make it executable (Linux/Unix only)
+            try:
+                os.chmod(found_binary, 0o755)
+            except Exception as chmod_error:
+                print(f"   ⚠️  Warning: Could not set executable permissions: {chmod_error}")
             
             # Move to expected location if needed (use 'main' as standard name)
             if found_binary != binary_path:
@@ -140,16 +168,29 @@ class QwenTranslatorClient(LlmClient):
             cls._binary_path = str(binary_path)
             print(f"   ✅ Binary extracted and ready at: {cls._binary_path}")
             
+            # Verify binary is executable
+            if not os.access(cls._binary_path, os.X_OK):
+                print(f"   ⚠️  Warning: Binary may not be executable. Attempting to fix...")
+                try:
+                    os.chmod(cls._binary_path, 0o755)
+                except Exception:
+                    pass
+            
             # Clean up zip file
-            zip_path.unlink()
+            try:
+                zip_path.unlink()
+            except Exception:
+                pass  # Ignore cleanup errors
             
             return cls._binary_path
             
         except Exception as e:
-            raise RuntimeError(
+            error_msg = (
                 f"Failed to download/extract llama.cpp binary from {zip_url}. "
                 f"Error: {e}"
-            ) from e
+            )
+            print(f"   ❌ {error_msg}")
+            raise RuntimeError(error_msg) from e
 
     def _download_model_if_needed(self) -> str:
         """Download GGUF model file from HuggingFace if not already cached."""
@@ -234,17 +275,32 @@ class QwenTranslatorClient(LlmClient):
         try:
             # Run the binary and capture output
             print(f"   🔄 Running translation with llama.cpp binary...")
+            print(f"   Command: {' '.join(cmd[:3])}... (model: {os.path.basename(model_path)})")
+            
             result = subprocess.run(
                 cmd,
                 capture_output=True,
                 text=True,
                 timeout=60,  # 60 second timeout
-                check=True
+                check=False  # Don't raise on non-zero exit, we'll check manually
             )
             
+            # Check if command succeeded
+            if result.returncode != 0:
+                error_msg = f"llama.cpp binary exited with code {result.returncode}"
+                if result.stderr:
+                    error_msg += f"\nStderr: {result.stderr[:500]}"
+                if result.stdout:
+                    error_msg += f"\nStdout: {result.stdout[:500]}"
+                print(f"   ❌ {error_msg}")
+                raise RuntimeError(error_msg)
+            
             # Parse the output
             output = result.stdout.strip()
             
+            if not output:
+                raise RuntimeError("llama.cpp binary returned empty output")
+            
             # The output might include the prompt, so we need to extract just the generated part
             # Look for the assistant response after the prompt
             if "<|im_start|>assistant" in output:
@@ -254,16 +310,27 @@ class QwenTranslatorClient(LlmClient):
             # Remove any remaining chat format tokens
             translated_text = output.replace("<|im_start|>", "").replace("<|im_end|>", "").strip()
             
+            if not translated_text:
+                raise RuntimeError("Translation output is empty after parsing")
+            
+            print(f"   ✅ Translation completed: '{translated_text[:100]}...'")
+            
         except subprocess.TimeoutExpired:
-            raise RuntimeError("Translation timed out after 60 seconds")
+            error_msg = "Translation timed out after 60 seconds"
+            print(f"   ❌ {error_msg}")
+            raise RuntimeError(error_msg)
         except subprocess.CalledProcessError as e:
             error_output = e.stderr if e.stderr else e.stdout
-            raise RuntimeError(
+            error_msg = (
                 f"Translation failed with llama.cpp binary. "
-                f"Exit code: {e.returncode}, Error: {error_output}"
-            ) from e
+                f"Exit code: {e.returncode}, Error: {error_output[:500]}"
+            )
+            print(f"   ❌ {error_msg}")
+            raise RuntimeError(error_msg) from e
         except Exception as e:
-            raise RuntimeError(f"Translation generation failed: {e}") from e
+            error_msg = f"Translation generation failed: {e}"
+            print(f"   ❌ {error_msg}")
+            raise RuntimeError(error_msg) from e
         
         # Clean up the response
         translated_text = translated_text.strip()