Upload 12 files

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

GOOGLE_TRANSLATE_README.md

@@ -0,0 +1,120 @@
+# Google Translate Gemma Integration
+
+This document explains the Google Translate Gemma integration in the AI Assistant application.
+
+## Current Status
+
+⚠️ **Google Translate Gemma is currently not available due to dependency compatibility issues.**
+
+The application automatically falls back to using chat completion for translation, which provides good quality translations for most use cases.
+
+## Why Google Translate Gemma is Not Available
+
+The main issues are:
+1. **Transformers Version**: The current transformers version (5.1.0) has compatibility issues with the required `AutoProcessor` class
+2. **TorchVision Compatibility**: There are runtime errors with torchvision that prevent the model from loading
+3. **GPU Requirements**: Google Translate Gemma requires significant GPU memory (16GB+ recommended)
+
+## What Works Instead
+
+The application uses **chat completion with specialized prompts** for translation:
+
+```python
+system_prompt = f"You are a professional translator specializing in translating from {source_language} to {target_language}. Translate the given text accurately while preserving the original meaning and tone. Only provide the translation without any additional explanations."
+```
+
+This approach:
+- ✅ Works with all available models (Llama, Mistral, etc.)
+- ✅ Supports 25+ languages
+- ✅ Provides good quality translations
+- ✅ No special hardware requirements
+
+## How to Use Translation
+
+1. Run the application: `python app.py`
+2. Go to the **Translation** tab
+3. Select a model (any model works for translation)
+4. Choose source and target languages
+5. Enter text and click **Translate**
+
+## Testing
+
+### Test the Fallback Translation
+```bash
+python test_translation_fallback.py
+```
+
+### Test Google Translate Gemma (when available)
+```bash
+python test_google_translate.py
+```
+
+## Future Improvements
+
+To enable Google Translate Gemma:
+
+1. **Update Dependencies**:
+   ```bash
+   pip install transformers>=4.36.0
+   pip install torch torchvision --upgrade
+   ```
+
+2. **Ensure GPU Availability**:
+   - CUDA-compatible GPU
+   - 16GB+ VRAM recommended
+
+3. **Fix Compatibility Issues**:
+   - Wait for transformers/torchvision compatibility fixes
+   - Or use a Docker container with compatible versions
+
+## Supported Languages
+
+The translation feature supports:
+- English
+- Spanish
+- French
+- German
+- Chinese (Simplified & Traditional)
+- Japanese
+- Korean
+- Italian
+- Portuguese
+- Russian
+- Arabic
+- Hindi
+- Dutch
+- Turkish
+- Polish
+- Vietnamese
+- Thai
+- Indonesian
+- Greek
+- Hebrew
+- Czech
+- Swedish
+- Danish
+- Norwegian
+- Finnish
+
+## Troubleshooting
+
+### Translation Not Working
+1. Check your HuggingFace token is set in Settings
+2. Ensure the selected model is available
+3. Try a different model if one fails
+
+### Google Translate Gemma Errors
+These are expected and can be ignored:
+```
+Warning: Google Translate Gemma not available: Could not import module 'AutoProcessor'
+```
+
+The app will continue to work with chat completion translation.
+
+## Contributing
+
+If you'd like to help fix the Google Translate Gemma integration:
+1. Test with different transformers versions
+2. Try Docker containers with specific versions
+3. Investigate alternative approaches
+4. Submit pull requests with fixes

README.md

@@ -1,11 +1,156 @@
----
-title: Aidep
-emoji: 🐨
-colorFrom: yellow
-colorTo: pink
-sdk: gradio
-sdk_version: 6.5.1
-python_version: '3.10'
-app_file: app.py
-pinned: false
----
+---
+title: Aidep
+emoji: 🐨
+colorFrom: yellow
+colorTo: pink
+sdk: gradio
+sdk_version: 6.5.1
+python_version: '3.12'
+app_file: app.py
+pinned: false
+---
+
+# AI Assistant Application - Model Support Update
+
+## Overview
+This update addresses the error: `Model meta-llama/Llama-3.2-3B-Instruct is not supported for task text-generation and provider hyperbolic. Supported task: conversational.`
+
+## Changes Made
+
+### 1. Updated Model Handling Logic
+- Modified `app.py` to check model settings for task support information
+- Updated `text_generation` function to automatically use `chat_completion` for conversational-only models
+- Added proper error handling for unsupported model tasks
+
+### 2. Enhanced Model Configuration
+- Updated `settings/models.json` to include task support information for each model
+- Added `supportedTasks` and `recommendedMethod` fields to model configurations
+- Configured Llama-3.2-3B-Instruct models as conversational-only
+- Configured Hermes models to support both conversational and text-generation tasks
+
+### 3. Improved API Client
+- Enhanced `hf_api.py` with better error handling for task support
+- Added `get_model_task_support` method to check model capabilities
+- Updated `text_generation` method to provide clearer error messages
+
+### 4. Testing
+- Created `test_model_support.py` to verify model support functionality
+- Added comprehensive test coverage for model task support
+
+## How It Works
+
+### Model Task Detection
+The application now checks each model's configuration to determine the appropriate method to use:
+
+1. **Conversational-only models** (like Llama-3.2-3B-Instruct):
+   - Automatically use `chat_completion` method
+   - Provide appropriate error messages if text-generation is attempted
+
+2. **Multi-task models** (like Hermes):
+   - Can use either `chat_completion` or `text_generation`
+   - Default to `chat_completion` for consistency
+
+### Error Handling
+When a model doesn't support a specific task:
+- Clear error messages indicate which tasks are supported
+- Recommendations for alternative methods are provided
+- Graceful fallback to appropriate methods when possible
+
+## Usage
+
+### For End Users
+- No changes needed to existing workflows
+- Conversational models will automatically use the correct API method
+- Text generation tab will work with both conversational and traditional text-generation models
+
+### For Developers
+- Add `supportedTasks` and `recommendedMethod` to new model configurations
+- Use the `get_model_task_support` method to check model capabilities
+- Follow the existing patterns for error handling
+
+## Testing
+Run `python test_model_support.py` to verify model support functionality.
+
+## Future Improvements
+- Add automatic model capability detection from HuggingFace API
+- Implement dynamic task routing based on input content
+- Add support for additional model providers and task types
+
+## Model Validation and Fallback System
+
+### Overview
+The application now includes an automatic model validation and fallback system to handle cases where models are not supported by the available providers.
+
+### Features
+1. **Automatic Model Validation**: Checks if a model is supported before using it
+2. **Fallback Model Suggestions**: Suggests alternative models when a model is not supported
+3. **Automatic Fallback**: Automatically tries fallback models when a model fails
+4. **Error Handling**: Provides clear error messages with model suggestions
+
+### Supported Models
+The application has been updated with a curated list of known working models:
+- meta-llama/Llama-3.2-3B-Instruct
+- microsoft/Phi-3-mini-4k-instruct
+- google/gemma-2-2b-it
+
+### How It Works
+1. When a model is selected, the system validates it before use
+2. If the model is not supported, it automatically tries fallback models
+3. If all fallbacks fail, it provides a list of alternative models
+4. The system handles authentication errors gracefully
+
+### Usage
+- The system works automatically in the background
+- Users will see warnings when fallback models are used
+- Error messages include suggestions for alternative models
+- The models.json file is automatically updated with validated models
+
+## Google Translate Gemma Module
+
+### Overview
+A new module `google_translate.py` has been added to provide translation capabilities using Google's TranslateGemma model. This module supports both text translation and image text extraction with translation.
+
+### Features
+1. **Text Translation**: Translate text between supported languages
+2. **Image Translation**: Extract text from images and translate it
+3. **Easy-to-use API**: Simple class-based interface for translation tasks
+4. **Error Handling**: Comprehensive error handling and logging
+
+### Installation
+The module requires the following dependencies (already added to requirements.txt):
+- transformers>=4.36.0
+- torch>=2.0.0
+- Pillow>=10.0.0
+
+### Usage Example
+
+```python
+from google_translate import GoogleTranslateGemma
+
+# Initialize the translator
+translator = GoogleTranslateGemma()
+
+# Text translation
+translated = translator.translate_text(
+    text="Hello, how are you?",
+    source_lang="en",
+    target_lang="es"
+)
+print(f"Translated: {translated}")
+
+# Image translation
+translated = translator.translate_image(
+    image_url="https://example.com/image-with-text.jpg",
+    source_lang="en",
+    target_lang="fr"
+)
+print(f"Translated from image: {translated}")
+```
+
+### Testing
+Run `python test_google_translate.py` to test the translation functionality.
+
+### Requirements
+- GPU with at least 16GB memory recommended
+- Internet connection for model download and image translation
+- Sufficient disk space for model cache

TRANSLATION_TESTING_INTEGRATION_SUMMARY.md

@@ -0,0 +1,108 @@
+# Translation Testing Integration Summary
+
+## Overview
+Successfully integrated comprehensive translation testing functionality from `test_translation.py` into the main AI Assistant application (`app.py`) as a new "Translation Testing" tab.
+
+## What Was Added
+
+### 1. New Translation Testing Functions
+- **`test_translategemma()`**: Tests Google Translate Gemma model directly with fallback to chat completion
+- **`test_chat_completion_translation()`**: Tests translation using chat completion fallback with multiple models
+- **`run_multiple_translation_tests()`**: Runs comprehensive test suite with multiple language pairs
+
+### 2. New Translation Testing Tab
+Added a new "🧪 Translation Testing" tab with the following features:
+
+#### Test Options
+- **Single Test Mode**: Test individual translations with custom text and language codes
+- **Comprehensive Test Mode**: Run predefined test suite with multiple language pairs
+- **Language Code Support**: Full support for ISO language codes (en, es, fr, de-DE, zh-CN, etc.)
+
+#### Test Results Display
+- **Detailed Output**: Shows test results, status, and translation method used
+- **Summary Statistics**: Success rate, total tests, and pass/fail counts
+- **Copy Functionality**: One-click copy of test results to clipboard
+
+### 3. Test Scenarios
+The comprehensive test suite includes:
+- English to Spanish
+- Czech to German
+- French to English
+- Chinese (Simplified) to English
+- Spanish to Japanese
+
+## Technical Implementation
+
+### Integration Approach
+- Merged all testing functions from `test_translation.py` into `app.py`
+- Maintained original testing logic while adapting for Gradio interface
+- Added proper error handling and user feedback
+
+### Error Handling
+- Graceful fallback when Google Translate Gemma is unavailable
+- Clear error messages for missing tokens or model availability issues
+- Comprehensive status reporting for each test
+
+### User Interface
+- Consistent dark theme design matching the rest of the application
+- Intuitive layout with test options on the left, results on the right
+- Real-time feedback during test execution
+
+## Usage Instructions
+
+### Single Test
+1. Navigate to the "🧪 Translation Testing" tab
+2. Enter text to test in the "Test Text" field
+3. Select source and target language codes
+4. Click "🧪 Run Single Test"
+5. View results in the Test Results panel
+
+### Comprehensive Test
+1. Navigate to the "🧪 Translation Testing" tab
+2. Click "📊 Run Comprehensive Tests"
+3. View detailed results and summary statistics
+
+## Benefits
+
+### For Developers
+- Easy validation of translation functionality
+- Quick testing of different language pairs
+- Comprehensive diagnostics for troubleshooting
+
+### For Users
+- Confidence in translation quality
+- Transparency about which models are being used
+- Clear feedback when issues occur
+
+## Future Enhancements
+
+### Potential Improvements
+- Add custom test case creation
+- Export test results to file
+- Performance benchmarking
+- Visual test result charts
+- Automated regression testing
+
+### Additional Test Scenarios
+- More language pairs
+- Domain-specific translations (medical, legal, technical)
+- Long text translation testing
+- Batch translation testing
+
+## Technical Notes
+
+### Dependencies
+- Requires same dependencies as main translation functionality
+- Uses existing HuggingFace API integration
+- Leverages Google Translate Gemma when available
+
+### Performance
+- Tests run sequentially to avoid API rate limits
+- Comprehensive tests may take 1-2 minutes to complete
+- Results are cached during session
+
+## Conclusion
+
+The Translation Testing tab provides a robust solution for validating translation functionality within the AI Assistant application. It offers both quick single tests and comprehensive validation, making it valuable for both development and end-user confidence.
+
+The integration maintains the application's design consistency while adding powerful testing capabilities that help ensure translation quality and reliability.

check_models.py

@@ -1,59 +1,55 @@
-from hf_api import HuggingFaceAPI
-import os
-import json
-from datetime import datetime
-
-from utils import load_settings, save_settings
-
-# Settings paths
-SETTINGS_DIR = os.path.join(os.path.dirname(__file__), 'settings')
-MODELS_SETTINGS_FILE = os.path.join(SETTINGS_DIR, 'models.json')
-FIREBASE_SETTINGS_FILE = os.path.join(SETTINGS_DIR, 'firebase.json')
-APP_SETTINGS_FILE = os.path.join(SETTINGS_DIR, 'app.json')
-
-model_settings = load_settings(MODELS_SETTINGS_FILE)
-HF_TOKEN = model_settings.get('huggingfaceToken', '')
-
-api = HuggingFaceAPI(token=HF_TOKEN) if HF_TOKEN else None
-
-print("Checking available models...")
-print("\n1. Testing text generation models:")
-models = ["meta-llama/Llama-3.2-3B-Instruct", "microsoft/Phi-3-mini-4k-instruct"]
-for model in models:
-    try:
-        result = api.validate_model(model)
-        print(f"   {model}: {'✅ Available' if result['valid'] else '❌ Not available'}")
-    except Exception as e:
-        print(f"   {model}: ❌ Error - {str(e)[:50]}...")
-
-print("\n2. Testing translation models:")
-models = ["Helsinki-NLP/opus-mt-en-de", "Helsinki-NLP/opus-mt-en-fr"]
-for model in models:
-    try:
-        result = api.validate_model(model)
-        print(f"   {model}: {'✅ Available' if result['valid'] else '❌ Not available'}")
-        if not result['valid'] and 'fallback_models' in result:
-            print(f"      Fallbacks: {[m['id'] for m in result['fallback_models'][:2]]}")
-    except Exception as e:
-        print(f"   {model}: ❌ Error - {str(e)[:50]}...")
-
-print("\n3. Testing Google models:")
-models = ["google/madlad400-3b-mt", "google/translategemma-12b-it"]
-for model in models:
-    try:
-        result = api.validate_model(model)
-        print(f"   {model}: {'✅ Available' if result['valid'] else '❌ Not available'}")
-    except Exception as e:
-        print(f"   {model}: ❌ Error - {str(e)[:50]}...")
-
-print("\n4. Testing chat completion with Llama:")
-try:
-    messages = [{"role": "user", "content": "Translate 'Hello world' to French"}]
-    response = api.chat_completion(
-        model="meta-llama/Llama-3.2-3B-Instruct",
-        messages=messages,
-        max_tokens=100
-    )
-    print(f"   ✅ Chat translation works: {response['choices'][0]['message']['content'][:50]}...")
-except Exception as e:
+import os
+from hf_api import HuggingFaceAPI
+from typing import Optional, List, Dict, Any
+from huggingface_hub import InferenceClient, HfApi
+from utils import load_settings
+    
+# Settings paths
+SETTINGS_DIR = os.path.join(os.path.dirname(__file__), 'settings')
+APP_SETTINGS_FILE = os.path.join(SETTINGS_DIR, 'app.json')
+
+# Get HF token from settings
+HF_TOKEN = load_settings(APP_SETTINGS_FILE).get('hf_token')
+api = HuggingFaceAPI(HF_TOKEN)
+
+print("Checking available models...")
+print("\n1. Testing text generation models:")
+models = ["meta-llama/Llama-3.2-3B-Instruct", "microsoft/Phi-3-mini-4k-instruct"]
+for model in models:
+    try:
+        result = api.validate_model(model)
+        print(f"   {model}: {'✅ Available' if result['valid'] else '❌ Not available'}")
+    except Exception as e:
+        print(f"   {model}: ❌ Error - {str(e)[:50]}...")
+
+print("\n2. Testing translation models:")
+models = ["Helsinki-NLP/opus-mt-en-de", "Helsinki-NLP/opus-mt-en-fr"]
+for model in models:
+    try:
+        result = api.validate_model(model)
+        print(f"   {model}: {'✅ Available' if result['valid'] else '❌ Not available'}")
+        if not result['valid'] and 'fallback_models' in result:
+            print(f"      Fallbacks: {[m['id'] for m in result['fallback_models'][:2]]}")
+    except Exception as e:
+        print(f"   {model}: ❌ Error - {str(e)[:50]}...")
+
+print("\n3. Testing Google models:")
+models = ["google/madlad400-3b-mt", "google/translategemma-12b-it"]
+for model in models:
+    try:
+        result = api.validate_model(model)
+        print(f"   {model}: {'✅ Available' if result['valid'] else '❌ Not available'}")
+    except Exception as e:
+        print(f"   {model}: ❌ Error - {str(e)[:50]}...")
+
+print("\n4. Testing chat completion with Llama:")
+try:
+    messages = [{"role": "user", "content": "Translate 'Hello world' to French"}]
+    response = api.chat_completion(
+        model="meta-llama/Llama-3.2-3B-Instruct",
+        messages=messages,
+        max_tokens=100
+    )
+    print(f"   ✅ Chat translation works: {response['choices'][0]['message']['content'][:50]}...")
+except Exception as e:
     print(f"   ❌ Chat translation failed: {str(e)[:50]}...")

google_translate.py

@@ -1,289 +1,289 @@
-
-# Defer torch import to avoid CUDA initialization issues
-# torch will be imported when needed in the _load_model method
-from typing import List, Dict, Union, Optional
-import logging
-from PIL import Image
-import requests
-import os
-import tempfile
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-class GoogleTranslateGemma:
-    """
-    Google Translate Gemma model wrapper for text and image translation.
-    
-    This class provides an interface to the Google TranslateGemma model for:
-    - Text translation between languages
-    - Text extraction and translation from images
-    """
-    
-    def __init__(self, model_id: str = "google/translategemma-12b-it"):
-        """
-        Initialize the Google Translate Gemma model.
-        
-        Args:
-            model_id (str): The model identifier from Hugging Face
-        """
-        self.model_id = model_id
-        self.model = None
-        self.processor = None
-        self.device = None  # Will be set when torch is imported
-        self._load_model()
-    
-    def _load_model(self):
-        """Load the model using direct approach."""
-        try:
-            # Import torch here to avoid CUDA initialization issues
-            import torch
-            from transformers import AutoModelForImageTextToText, AutoProcessor
-            
-            logger.info(f"Loading model: {self.model_id}")
-            self.processor = AutoProcessor.from_pretrained(self.model_id)
-            self.model = AutoModelForImageTextToText.from_pretrained(
-                self.model_id, 
-                device_map="auto"
-            )
-            self.device = self.model.device
-            logger.info(f"Model loaded successfully on device: {self.device}")
-        except Exception as e:
-            logger.error(f"Failed to load model: {str(e)}")
-            raise
-    
-    def translate_text(
-        self, 
-        text: str, 
-        source_lang: str, 
-        target_lang: str,
-        max_new_tokens: int = 200
-    ) -> str:
-        """
-        Translate text from source language to target language.
-        
-        Args:
-            text (str): The text to translate
-            source_lang (str): Source language code (e.g., 'cs' for Czech)
-            target_lang (str): Target language code (e.g., 'de-DE' for German)
-            max_new_tokens (int): Maximum number of tokens to generate
-            
-        Returns:
-            str: The translated text
-        """
-        messages = [
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "source_lang_code": source_lang,
-                        "target_lang_code": target_lang,
-                        "text": text,
-                    }
-                ],
-            }
-        ]
-        
-        try:
-            # Import torch here if not already imported
-            import torch
-            
-            # Use direct model approach
-            inputs = self.processor.apply_chat_template(
-                messages, 
-                tokenize=True, 
-                add_generation_prompt=True, 
-                return_dict=True, 
-                return_tensors="pt"
-            ).to(self.device, dtype=torch.bfloat16)
-            
-            input_len = len(inputs['input_ids'][0])
-            
-            with torch.inference_mode():
-                generation = self.model.generate(**inputs, max_new_tokens=max_new_tokens)
-            
-            generation = generation[0][input_len:]
-            decoded = self.processor.decode(generation, skip_special_tokens=True)
-            return decoded
-        except Exception as e:
-            logger.error(f"Translation failed: {str(e)}")
-            raise
-    
-    def translate_image(
-        self, 
-        image_input: Union[str, Image.Image], 
-        source_lang: str, 
-        target_lang: str,
-        max_new_tokens: int = 200
-    ) -> str:
-        """
-        Extract text from an image and translate it to the target language.
-        
-        Args:
-            image_input (Union[str, Image.Image]): URL or PIL Image object containing text
-            source_lang (str): Source language code (e.g., 'cs' for Czech)
-            target_lang (str): Target language code (e.g., 'de-DE' for German)
-            max_new_tokens (int): Maximum number of tokens to generate
-            
-        Returns:
-            str: The extracted and translated text
-        """
-        # Handle local image files
-        if isinstance(image_input, str) and os.path.exists(image_input):
-            # It's a local file path
-            image = Image.open(image_input)
-            messages = [
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "image",
-                            "source_lang_code": source_lang,
-                            "target_lang_code": target_lang,
-                            "image": image,
-                        },
-                    ],
-                }
-            ]
-            return self._translate_with_messages(messages, max_new_tokens)
-        
-        # Handle PIL Image objects
-        elif isinstance(image_input, Image.Image):
-            messages = [
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "image",
-                            "source_lang_code": source_lang,
-                            "target_lang_code": target_lang,
-                            "image": image_input,
-                        },
-                    ],
-                }
-            ]
-            return self._translate_with_messages(messages, max_new_tokens)
-        
-        # Handle URLs
-        else:
-            messages = [
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "image",
-                            "source_lang_code": source_lang,
-                            "target_lang_code": target_lang,
-                            "url": image_input,
-                        },
-                    ],
-                }
-            ]
-            return self._translate_with_messages(messages, max_new_tokens)
-    
-    def _translate_with_messages(self, messages: List[Dict], max_new_tokens: int = 200) -> str:
-        """
-        Helper method to translate using messages with direct model.
-        
-        Args:
-            messages (List[Dict]): Formatted messages for the model
-            max_new_tokens (int): Maximum number of tokens to generate
-            
-        Returns:
-            str: The translated text
-        """
-        try:
-            # Import torch here if not already imported
-            import torch
-            
-            # Use direct model approach
-            inputs = self.processor.apply_chat_template(
-                messages, 
-                tokenize=True, 
-                add_generation_prompt=True, 
-                return_dict=True, 
-                return_tensors="pt"
-            ).to(self.device, dtype=torch.bfloat16)
-            
-            input_len = len(inputs['input_ids'][0])
-            
-            with torch.inference_mode():
-                generation = self.model.generate(**inputs, max_new_tokens=max_new_tokens)
-            
-            generation = generation[0][input_len:]
-            decoded = self.processor.decode(generation, skip_special_tokens=True)
-            return decoded
-        except Exception as e:
-            logger.error(f"Translation failed: {str(e)}")
-            raise
-    
-    
-
-
-# Example usage and testing functions
-def test_text_translation():
-    """Test text translation functionality."""
-    print("Testing text translation...")
-    
-    translator = GoogleTranslateGemma()
-    
-    # Example: Czech to German
-    source_text = "V nejhorším případě i k prasknutí čočky."
-    source_lang = "cs"
-    target_lang = "de-DE"
-    
-    try:
-        translated = translator.translate_text(
-            text=source_text,
-            source_lang=source_lang,
-            target_lang=target_lang
-        )
-        print(f"Source ({source_lang}): {source_text}")
-        print(f"Target ({target_lang}): {translated}")
-        print("-" * 50)
-    except Exception as e:
-        print(f"Text translation test failed: {str(e)}")
-
-
-def test_image_translation():
-    """Test image translation functionality."""
-    print("Testing image translation...")
-    
-    translator = GoogleTranslateGemma()
-    
-    # Example: Czech traffic sign to German
-    image_url = "https://c7.alamy.com/comp/2YAX36N/traffic-signs-in-czech-republic-pedestrian-zone-2YAX36N.jpg"
-    source_lang = "cs"
-    target_lang = "de-DE"
-    
-    try:
-        translated = translator.translate_image(
-            image_url=image_url,
-            source_lang=source_lang,
-            target_lang=target_lang
-        )
-        print(f"Image URL: {image_url}")
-        print(f"Source ({source_lang}): [Text extracted from image]")
-        print(f"Target ({target_lang}): {translated}")
-        print("-" * 50)
-    except Exception as e:
-        print(f"Image translation test failed: {str(e)}")
-
-
-def main():
-    """Main function to run example translations."""
-    print("Google Translate Gemma Module")
-    print("=" * 50)
-    
-    # Run tests
-    test_text_translation()
-    test_image_translation()
-    
-    print("Example completed!")
-
-
-if __name__ == "__main__":
+
+# Defer torch import to avoid CUDA initialization issues
+# torch will be imported when needed in the _load_model method
+from typing import List, Dict, Union, Optional
+import logging
+from PIL import Image
+import requests
+import os
+import tempfile
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class GoogleTranslateGemma:
+    """
+    Google Translate Gemma model wrapper for text and image translation.
+    
+    This class provides an interface to the Google TranslateGemma model for:
+    - Text translation between languages
+    - Text extraction and translation from images
+    """
+    
+    def __init__(self, model_id: str = "google/translategemma-12b-it"):
+        """
+        Initialize the Google Translate Gemma model.
+        
+        Args:
+            model_id (str): The model identifier from Hugging Face
+        """
+        self.model_id = model_id
+        self.model = None
+        self.processor = None
+        self.device = None  # Will be set when torch is imported
+        self._load_model()
+    
+    def _load_model(self):
+        """Load the model using direct approach."""
+        try:
+            # Import torch here to avoid CUDA initialization issues
+            import torch
+            from transformers import AutoModelForImageTextToText, AutoProcessor
+            
+            logger.info(f"Loading model: {self.model_id}")
+            self.processor = AutoProcessor.from_pretrained(self.model_id)
+            self.model = AutoModelForImageTextToText.from_pretrained(
+                self.model_id, 
+                device_map="auto"
+            )
+            self.device = self.model.device
+            logger.info(f"Model loaded successfully on device: {self.device}")
+        except Exception as e:
+            logger.error(f"Failed to load model: {str(e)}")
+            raise
+    
+    def translate_text(
+        self, 
+        text: str, 
+        source_lang: str, 
+        target_lang: str,
+        max_new_tokens: int = 200
+    ) -> str:
+        """
+        Translate text from source language to target language.
+        
+        Args:
+            text (str): The text to translate
+            source_lang (str): Source language code (e.g., 'cs' for Czech)
+            target_lang (str): Target language code (e.g., 'de-DE' for German)
+            max_new_tokens (int): Maximum number of tokens to generate
+            
+        Returns:
+            str: The translated text
+        """
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "source_lang_code": source_lang,
+                        "target_lang_code": target_lang,
+                        "text": text,
+                    }
+                ],
+            }
+        ]
+        
+        try:
+            # Import torch here if not already imported
+            import torch
+            
+            # Use direct model approach
+            inputs = self.processor.apply_chat_template(
+                messages, 
+                tokenize=True, 
+                add_generation_prompt=True, 
+                return_dict=True, 
+                return_tensors="pt"
+            ).to(self.device, dtype=torch.bfloat16)
+            
+            input_len = len(inputs['input_ids'][0])
+            
+            with torch.inference_mode():
+                generation = self.model.generate(**inputs, max_new_tokens=max_new_tokens)
+            
+            generation = generation[0][input_len:]
+            decoded = self.processor.decode(generation, skip_special_tokens=True)
+            return decoded
+        except Exception as e:
+            logger.error(f"Translation failed: {str(e)}")
+            raise
+    
+    def translate_image(
+        self, 
+        image_input: Union[str, Image.Image], 
+        source_lang: str, 
+        target_lang: str,
+        max_new_tokens: int = 200
+    ) -> str:
+        """
+        Extract text from an image and translate it to the target language.
+        
+        Args:
+            image_input (Union[str, Image.Image]): URL or PIL Image object containing text
+            source_lang (str): Source language code (e.g., 'cs' for Czech)
+            target_lang (str): Target language code (e.g., 'de-DE' for German)
+            max_new_tokens (int): Maximum number of tokens to generate
+            
+        Returns:
+            str: The extracted and translated text
+        """
+        # Handle local image files
+        if isinstance(image_input, str) and os.path.exists(image_input):
+            # It's a local file path
+            image = Image.open(image_input)
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "image",
+                            "source_lang_code": source_lang,
+                            "target_lang_code": target_lang,
+                            "image": image,
+                        },
+                    ],
+                }
+            ]
+            return self._translate_with_messages(messages, max_new_tokens)
+        
+        # Handle PIL Image objects
+        elif isinstance(image_input, Image.Image):
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "image",
+                            "source_lang_code": source_lang,
+                            "target_lang_code": target_lang,
+                            "image": image_input,
+                        },
+                    ],
+                }
+            ]
+            return self._translate_with_messages(messages, max_new_tokens)
+        
+        # Handle URLs
+        else:
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "image",
+                            "source_lang_code": source_lang,
+                            "target_lang_code": target_lang,
+                            "url": image_input,
+                        },
+                    ],
+                }
+            ]
+            return self._translate_with_messages(messages, max_new_tokens)
+    
+    def _translate_with_messages(self, messages: List[Dict], max_new_tokens: int = 200) -> str:
+        """
+        Helper method to translate using messages with direct model.
+        
+        Args:
+            messages (List[Dict]): Formatted messages for the model
+            max_new_tokens (int): Maximum number of tokens to generate
+            
+        Returns:
+            str: The translated text
+        """
+        try:
+            # Import torch here if not already imported
+            import torch
+            
+            # Use direct model approach
+            inputs = self.processor.apply_chat_template(
+                messages, 
+                tokenize=True, 
+                add_generation_prompt=True, 
+                return_dict=True, 
+                return_tensors="pt"
+            ).to(self.device, dtype=torch.bfloat16)
+            
+            input_len = len(inputs['input_ids'][0])
+            
+            with torch.inference_mode():
+                generation = self.model.generate(**inputs, max_new_tokens=max_new_tokens)
+            
+            generation = generation[0][input_len:]
+            decoded = self.processor.decode(generation, skip_special_tokens=True)
+            return decoded
+        except Exception as e:
+            logger.error(f"Translation failed: {str(e)}")
+            raise
+    
+    
+
+
+# Example usage and testing functions
+def test_text_translation():
+    """Test text translation functionality."""
+    print("Testing text translation...")
+    
+    translator = GoogleTranslateGemma()
+    
+    # Example: Czech to German
+    source_text = "V nejhorším případě i k prasknutí čočky."
+    source_lang = "cs"
+    target_lang = "de-DE"
+    
+    try:
+        translated = translator.translate_text(
+            text=source_text,
+            source_lang=source_lang,
+            target_lang=target_lang
+        )
+        print(f"Source ({source_lang}): {source_text}")
+        print(f"Target ({target_lang}): {translated}")
+        print("-" * 50)
+    except Exception as e:
+        print(f"Text translation test failed: {str(e)}")
+
+
+def test_image_translation():
+    """Test image translation functionality."""
+    print("Testing image translation...")
+    
+    translator = GoogleTranslateGemma()
+    
+    # Example: Czech traffic sign to German
+    image_url = "https://c7.alamy.com/comp/2YAX36N/traffic-signs-in-czech-republic-pedestrian-zone-2YAX36N.jpg"
+    source_lang = "cs"
+    target_lang = "de-DE"
+    
+    try:
+        translated = translator.translate_image(
+            image_url=image_url,
+            source_lang=source_lang,
+            target_lang=target_lang
+        )
+        print(f"Image URL: {image_url}")
+        print(f"Source ({source_lang}): [Text extracted from image]")
+        print(f"Target ({target_lang}): {translated}")
+        print("-" * 50)
+    except Exception as e:
+        print(f"Image translation test failed: {str(e)}")
+
+
+def main():
+    """Main function to run example translations."""
+    print("Google Translate Gemma Module")
+    print("=" * 50)
+    
+    # Run tests
+    test_text_translation()
+    test_image_translation()
+    
+    print("Example completed!")
+
+
+if __name__ == "__main__":
     main()

hf_api.py

@@ -1,522 +1,522 @@
-"""
-Hugging Face API Client
-Provides methods for interacting with HuggingFace Inference API
-"""
-import os
-import requests
-from typing import Optional, List, Dict, Any
-from huggingface_hub import InferenceClient, HfApi
-from utils import load_settings
-
-# Settings paths
-SETTINGS_DIR = os.path.join(os.path.dirname(__file__), 'settings')
-APP_SETTINGS_FILE = os.path.join(SETTINGS_DIR, 'app.json')
-
-# Get HF token from settings
-HF_TOKEN = load_settings(APP_SETTINGS_FILE).get('hf_token')
-API_BASE = "https://api-inference.huggingface.co"
-
-
-class HuggingFaceAPI:
-    def __init__(self, token: str = HF_TOKEN):
-        self.token = token
-        self.headers = {
-            "Authorization": f"Bearer {token}",
-            "Content-Type": "application/json"
-        }
-        self.client = InferenceClient(token=token)
-        self.hf_api = HfApi(token=token)
-
-    def model_info(self, model_id: str):
-        """Get model info using HfApi (compatible with hf.py)"""
-        return self.hf_api.model_info(model_id)
-
-    def list_models(self, **kwargs):
-        """List models using HfApi (compatible with hf.py)"""
-        return self.hf_api.list_models(**kwargs)
-
-    def chat_completion(
-        self,
-        model: str,
-        messages: List[Dict[str, str]],
-        max_tokens: int = 500,
-        temperature: float = 0.7,
-        stream: bool = False
-    ) -> Dict[str, Any]:
-        """
-        Send a chat completion request to HuggingFace API using huggingface_hub.
-        
-        Args:
-            model: Model ID (e.g., "meta-llama/Llama-3.2-3B-Instruct")
-            messages: List of message dicts with 'role' and 'content'
-            max_tokens: Maximum tokens to generate
-            temperature: Sampling temperature (0.0 - 1.0)
-            stream: Whether to stream the response
-        
-        Returns:
-            API response as dict
-        """
-        # Validate model before use
-        validation_result = self.validate_model(model)
-        if not validation_result["valid"]:
-            # Try fallback models
-            fallback_models = validation_result.get("fallback_models", [])
-            if fallback_models:
-                # Use the first fallback model
-                fallback_model = fallback_models[0]["id"]
-                print(f"Warning: Model {model} not supported. Using fallback model {fallback_model}")
-                model = fallback_model
-            else:
-                raise ValueError(f"Model {model} is not supported and no fallback models available. "
-                               f"Error: {validation_result.get('error', 'Unknown error')}")
-
-        try:
-            response = self.client.chat_completion(
-                model=model,
-                messages=messages,
-                max_tokens=max_tokens,
-                temperature=temperature,
-                stream=stream
-            )
-        except Exception as e:
-            error_str = str(e).lower()
-            if "model_not_supported" in error_str or "not supported by any provider" in error_str:
-                # Try fallback models
-                fallback_models = self._find_fallback_models(model)
-                if fallback_models:
-                    # Try each fallback model
-                    for fallback in fallback_models[:3]:
-                        try:
-                            print(f"Trying fallback model: {fallback['id']}")
-                            response = self.client.chat_completion(
-                                model=fallback['id'],
-                                messages=messages,
-                                max_tokens=max_tokens,
-                                temperature=temperature,
-                                stream=stream
-                            )
-                            return response
-                        except:
-                            continue
-                    
-                    raise ValueError(f"Model {model} is not supported and all fallback models failed. "
-                                   f"Try one of these: {', '.join([m['id'] for m in fallback_models[:3]])}")
-                else:
-                    raise ValueError(f"Model {model} is not supported and no fallback models available.")
-            else:
-                raise e
-        
-        # Convert to dict format
-        return {
-            "choices": [{
-                "message": {
-                    "role": "assistant",
-                    "content": response.choices[0].message.content
-                },
-                "finish_reason": response.choices[0].finish_reason
-            }],
-            "model": model,
-            "usage": {
-                "prompt_tokens": getattr(response.usage, "prompt_tokens", 0),
-                "completion_tokens": getattr(response.usage, "completion_tokens", 0),
-                "total_tokens": getattr(response.usage, "total_tokens", 0)
-            } if response.usage else None
-        }
-
-    def validate_model(self, model_id: str) -> Dict[str, Any]:
-        """
-        Validate if a model is supported and available.
-        
-        Args:
-            model_id: Model ID to validate
-            
-        Returns:
-            Validation result with status and fallback suggestions
-        """
-        try:
-            # Try to get model info
-            model_info = self.hf_api.model_info(model_id)
-            
-            # Check if model has inference API enabled
-            if hasattr(model_info, 'inference') and not model_info.inference:
-                # Try to find alternative models
-                fallback_models = self._find_fallback_models(model_id)
-                return {
-                    "valid": False,
-                    "error": f"Model {model_id} does not have inference API enabled",
-                    "fallback_models": fallback_models,
-                    "model_info": model_info
-                }
-            
-            return {
-                "valid": True,
-                "model_info": model_info
-            }
-        except Exception as e:
-            # Check if it's an auth error
-            error_str = str(e).lower()
-            if "401" in error_str or "unauthorized" in error_str or "invalid username or password" in error_str:
-                # Auth error - model might be valid but we can't check
-                return {
-                    "valid": True,  # Assume valid since we can't verify due to auth
-                    "warning": "Unable to verify model due to authentication. Assuming model is valid.",
-                    "auth_error": True
-                }
-            
-            # Model not found or not supported
-            fallback_models = self._find_fallback_models(model_id)
-            return {
-                "valid": False,
-                "error": str(e),
-                "fallback_models": fallback_models
-            }
-
-    def _find_fallback_models(self, model_id: str) -> List[Dict[str, str]]:
-        """
-        Find fallback models similar to the requested model.
-        
-        Args:
-            model_id: Original model ID
-            
-        Returns:
-            List of fallback model suggestions
-        """
-        # Extract model name parts
-        model_parts = model_id.lower().split('/')
-        if len(model_parts) > 1:
-            model_name = model_parts[-1]
-        else:
-            model_name = model_id.lower()
-            
-        # Remove version numbers and common prefixes
-        clean_name = model_name.replace('-3b', '').replace('-8b', '').replace('-70b', '')
-        clean_name = clean_name.replace('llama', '').replace('hermes', '').strip('-')
-        
-        # Search for similar models
-        try:
-            # Search for models with similar names
-            similar_models = self.hf_api.list_models(
-                search=model_name,
-                sort="downloads",
-                direction=-1,
-                limit=5
-            )
-            
-            # Filter for text generation models
-            fallbacks = []
-            for model in similar_models:
-                if (hasattr(model, 'pipeline_tag') and 
-                    model.pipeline_tag in ['text-generation', 'conversational', 'translation']):
-                    fallbacks.append({
-                        "id": model.modelId,
-                        "name": getattr(model, 'author', '') + '/' + model.modelId.split('/')[-1],
-                        "downloads": getattr(model, 'downloads', 0)
-                    })
-                    
-            return fallbacks[:5]  # Return top 5 fallbacks
-        except:
-            # If search fails, return some common models including translation models
-            return [
-                {"id": "meta-llama/Llama-3.2-3B-Instruct", "name": "Llama 3.2 3B", "downloads": 0},
-                {"id": "microsoft/Phi-3-mini-4k-instruct", "name": "Phi-3 Mini", "downloads": 0},
-                {"id": "google/gemma-2-2b-it", "name": "Gemma 2 2B", "downloads": 0},
-                {"id": "Helsinki-NLP/opus-mt-en-es", "name": "English-Spanish Translator", "downloads": 0},
-                {"id": "Helsinki-NLP/opus-mt-en-fr", "name": "English-French Translator", "downloads": 0}
-            ]
-
-    def get_model_task_support(self, model: str) -> Dict[str, Any]:
-        """
-        Get information about what tasks a model supports.
-        
-        Args:
-            model: Model ID
-            
-        Returns:
-            Model task support information
-        """
-        # Known conversational-only models
-        conversational_only_models = [
-            "meta-llama/Llama-3.2-3B-Instruct",
-            "meta-llama/Llama-3.1-8B-Instruct",
-            "meta-llama/Llama-3.1-70B-Instruct"
-        ]
-        
-        if model in conversational_only_models:
-            return {
-                "supports_text_generation": False,
-                "supports_conversational": True,
-                "recommended_method": "chat_completion"
-            }
-        else:
-            return {
-                "supports_text_generation": True,
-                "supports_conversational": True,
-                "recommended_method": "text_generation_or_chat_completion"
-            }
-
-    def text_generation(
-        self,
-        model: str,
-        prompt: str,
-        max_new_tokens: int = 250,
-        temperature: float = 0.7,
-        top_p: float = 0.95,
-        do_sample: bool = True
-    ) -> Dict[str, Any]:
-        """
-        Send a text generation request to HuggingFace API.
-        
-        Args:
-            model: Model ID
-            prompt: Text prompt to complete
-            max_new_tokens: Maximum new tokens to generate
-            temperature: Sampling temperature
-            top_p: Nucleus sampling parameter
-            do_sample: Whether to use sampling
-        
-        Returns:
-            API response as dict
-        """
-        # Validate model before use
-        validation_result = self.validate_model(model)
-        if not validation_result["valid"]:
-            # Try fallback models
-            fallback_models = validation_result.get("fallback_models", [])
-            if fallback_models:
-                # Use the first fallback model
-                fallback_model = fallback_models[0]["id"]
-                print(f"Warning: Model {model} not supported. Using fallback model {fallback_model}")
-                model = fallback_model
-            else:
-                raise ValueError(f"Model {model} is not supported and no fallback models available. "
-                               f"Error: {validation_result.get('error', 'Unknown error')}")
-
-        try:
-            response = self.client.text_generation(
-                model=model,
-                prompt=prompt,
-                max_new_tokens=max_new_tokens,
-                temperature=temperature,
-                top_p=top_p,
-                do_sample=do_sample
-            )
-            return {"generated_text": response}
-        except Exception as e:
-            # Check if the error is related to unsupported task
-            error_str = str(e).lower()
-            if "not supported for task text-generation" in error_str:
-                raise ValueError(f"Model {model} is not supported for text-generation task. "
-                               f"This model only supports conversational tasks. "
-                               f"Please use chat_completion method instead.")
-            elif "model_not_supported" in error_str or "not supported by any provider" in error_str:
-                # Try fallback models
-                fallback_models = self._find_fallback_models(model)
-                if fallback_models:
-                    # Try each fallback model
-                    for fallback in fallback_models[:3]:
-                        try:
-                            print(f"Trying fallback model: {fallback['id']}")
-                            response = self.client.text_generation(
-                                model=fallback['id'],
-                                prompt=prompt,
-                                max_new_tokens=max_new_tokens,
-                                temperature=temperature,
-                                top_p=top_p,
-                                do_sample=do_sample
-                            )
-                            return {"generated_text": response}
-                        except:
-                            continue
-                    
-                    raise ValueError(f"Model {model} is not supported and all fallback models failed. "
-                                   f"Try one of these: {', '.join([m['id'] for m in fallback_models[:3]])}")
-                else:
-                    raise ValueError(f"Model {model} is not supported and no fallback models available.")
-            else:
-                raise e
-
-    def get_model_info(self, model: str) -> Dict[str, Any]:
-        """
-        Get model information from HuggingFace Hub.
-        
-        Args:
-            model: Model ID
-        
-        Returns:
-            Model metadata dict
-        """
-        url = f"https://huggingface.co/api/models/{model}"
-        response = requests.get(url, headers=self.headers)
-        response.raise_for_status()
-        return response.json()
-
-    def search_models(
-        self,
-        query: str,
-        task: str = "text-generation",
-        limit: int = 10
-    ) -> List[Dict[str, Any]]:
-        """
-        Search for models on HuggingFace Hub.
-        
-        Args:
-            query: Search query
-            task: Filter by task (e.g., "text-generation", "text-classification")
-            limit: Maximum number of results
-        
-        Returns:
-            List of model metadata dicts
-        """
-        url = "https://huggingface.co/api/models"
-        params = {
-            "search": query,
-            "pipeline_tag": task,
-            "limit": limit,
-            "sort": "downloads",
-            "direction": -1
-        }
-        
-        response = requests.get(url, headers=self.headers, params=params)
-        response.raise_for_status()
-        return response.json()
-
-    def image_generation(
-        self,
-        model: str,
-        prompt: str,
-        negative_prompt: Optional[str] = None,
-        num_inference_steps: int = 50
-    ) -> bytes:
-        """
-        Generate an image using a diffusion model.
-        
-        Args:
-            model: Model ID (e.g., "stabilityai/stable-diffusion-xl-base-1.0")
-            prompt: Text prompt for image generation
-            negative_prompt: Negative prompt (what to avoid)
-            num_inference_steps: Number of denoising steps
-        
-        Returns:
-            Image bytes
-        """
-        url = f"{API_BASE}/models/{model}"
-        
-        payload = {
-            "inputs": prompt,
-            "parameters": {
-                "num_inference_steps": num_inference_steps
-            }
-        }
-        
-        if negative_prompt:
-            payload["parameters"]["negative_prompt"] = negative_prompt
-        
-        response = requests.post(url, headers=self.headers, json=payload)
-        response.raise_for_status()
-        return response.content
-
-    def embedding(
-        self,
-        model: str,
-        texts: List[str]
-    ) -> List[List[float]]:
-        """
-        Get embeddings for texts.
-        
-        Args:
-            model: Model ID (e.g., "sentence-transformers/all-MiniLM-L6-v2")
-            texts: List of texts to embed
-        
-        Returns:
-            List of embedding vectors
-        """
-        url = f"{API_BASE}/models/{model}"
-        
-        payload = {
-            "inputs": texts
-        }
-        
-        response = requests.post(url, headers=self.headers, json=payload)
-        response.raise_for_status()
-        return response.json()
-
-    def summarization(
-        self,
-        model: str,
-        text: str,
-        max_length: int = 150,
-        min_length: int = 30
-    ) -> Dict[str, Any]:
-        """
-        Summarize text using a summarization model.
-        
-        Args:
-            model: Model ID (e.g., "facebook/bart-large-cnn")
-            text: Text to summarize
-            max_length: Maximum summary length
-            min_length: Minimum summary length
-        
-        Returns:
-            API response with summary
-        """
-        url = f"{API_BASE}/models/{model}"
-        
-        payload = {
-            "inputs": text,
-            "parameters": {
-                "max_length": max_length,
-                "min_length": min_length
-            }
-        }
-        
-        response = requests.post(url, headers=self.headers, json=payload)
-        response.raise_for_status()
-        return response.json()
-
-    def translation(
-        self,
-        model: str,
-        text: str
-    ) -> Dict[str, Any]:
-        url = f"{API_BASE}/models/{model}"
-        
-        payload = {
-            "inputs": text
-        }
-        
-        response = requests.post(url, headers=self.headers, json=payload)
-        response.raise_for_status()
-        return response.json()
-
-    def question_answering(
-        self,
-        model: str,
-        question: str,
-        context: str
-    ) -> Dict[str, Any]:
-        """
-        Answer a question based on context.
-        
-        Args:
-            model: Model ID (e.g., "deepset/roberta-base-squad2")
-            question: The question to answer
-            context: Context containing the answer
-        
-        Returns:
-            API response with answer
-        """
-        url = f"{API_BASE}/models/{model}"
-        
-        payload = {
-            "inputs": {
-                "question": question,
-                "context": context
-            }
-        }
-        
-        response = requests.post(url, headers=self.headers, json=payload)
-        response.raise_for_status()
-        return response.json()
-
-
-
+"""
+Hugging Face API Client
+Provides methods for interacting with HuggingFace Inference API
+"""
+import os
+import requests
+from typing import Optional, List, Dict, Any
+from huggingface_hub import InferenceClient, HfApi
+from utils import load_settings
+
+# Settings paths
+SETTINGS_DIR = os.path.join(os.path.dirname(__file__), 'settings')
+APP_SETTINGS_FILE = os.path.join(SETTINGS_DIR, 'app.json')
+
+# Get HF token from settings
+HF_TOKEN = load_settings(APP_SETTINGS_FILE).get('hf_token')
+API_BASE = "https://api-inference.huggingface.co"
+
+
+class HuggingFaceAPI:
+    def __init__(self, token: str = HF_TOKEN):
+        self.token = token
+        self.headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+        self.client = InferenceClient(token=token)
+        self.hf_api = HfApi(token=token)
+
+    def model_info(self, model_id: str):
+        """Get model info using HfApi (compatible with hf.py)"""
+        return self.hf_api.model_info(model_id)
+
+    def list_models(self, **kwargs):
+        """List models using HfApi (compatible with hf.py)"""
+        return self.hf_api.list_models(**kwargs)
+
+    def chat_completion(
+        self,
+        model: str,
+        messages: List[Dict[str, str]],
+        max_tokens: int = 500,
+        temperature: float = 0.7,
+        stream: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Send a chat completion request to HuggingFace API using huggingface_hub.
+        
+        Args:
+            model: Model ID (e.g., "meta-llama/Llama-3.2-3B-Instruct")
+            messages: List of message dicts with 'role' and 'content'
+            max_tokens: Maximum tokens to generate
+            temperature: Sampling temperature (0.0 - 1.0)
+            stream: Whether to stream the response
+        
+        Returns:
+            API response as dict
+        """
+        # Validate model before use
+        validation_result = self.validate_model(model)
+        if not validation_result["valid"]:
+            # Try fallback models
+            fallback_models = validation_result.get("fallback_models", [])
+            if fallback_models:
+                # Use the first fallback model
+                fallback_model = fallback_models[0]["id"]
+                print(f"Warning: Model {model} not supported. Using fallback model {fallback_model}")
+                model = fallback_model
+            else:
+                raise ValueError(f"Model {model} is not supported and no fallback models available. "
+                               f"Error: {validation_result.get('error', 'Unknown error')}")
+
+        try:
+            response = self.client.chat_completion(
+                model=model,
+                messages=messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                stream=stream
+            )
+        except Exception as e:
+            error_str = str(e).lower()
+            if "model_not_supported" in error_str or "not supported by any provider" in error_str:
+                # Try fallback models
+                fallback_models = self._find_fallback_models(model)
+                if fallback_models:
+                    # Try each fallback model
+                    for fallback in fallback_models[:3]:
+                        try:
+                            print(f"Trying fallback model: {fallback['id']}")
+                            response = self.client.chat_completion(
+                                model=fallback['id'],
+                                messages=messages,
+                                max_tokens=max_tokens,
+                                temperature=temperature,
+                                stream=stream
+                            )
+                            return response
+                        except:
+                            continue
+                    
+                    raise ValueError(f"Model {model} is not supported and all fallback models failed. "
+                                   f"Try one of these: {', '.join([m['id'] for m in fallback_models[:3]])}")
+                else:
+                    raise ValueError(f"Model {model} is not supported and no fallback models available.")
+            else:
+                raise e
+        
+        # Convert to dict format
+        return {
+            "choices": [{
+                "message": {
+                    "role": "assistant",
+                    "content": response.choices[0].message.content
+                },
+                "finish_reason": response.choices[0].finish_reason
+            }],
+            "model": model,
+            "usage": {
+                "prompt_tokens": getattr(response.usage, "prompt_tokens", 0),
+                "completion_tokens": getattr(response.usage, "completion_tokens", 0),
+                "total_tokens": getattr(response.usage, "total_tokens", 0)
+            } if response.usage else None
+        }
+
+    def validate_model(self, model_id: str) -> Dict[str, Any]:
+        """
+        Validate if a model is supported and available.
+        
+        Args:
+            model_id: Model ID to validate
+            
+        Returns:
+            Validation result with status and fallback suggestions
+        """
+        try:
+            # Try to get model info
+            model_info = self.hf_api.model_info(model_id)
+            
+            # Check if model has inference API enabled
+            if hasattr(model_info, 'inference') and not model_info.inference:
+                # Try to find alternative models
+                fallback_models = self._find_fallback_models(model_id)
+                return {
+                    "valid": False,
+                    "error": f"Model {model_id} does not have inference API enabled",
+                    "fallback_models": fallback_models,
+                    "model_info": model_info
+                }
+            
+            return {
+                "valid": True,
+                "model_info": model_info
+            }
+        except Exception as e:
+            # Check if it's an auth error
+            error_str = str(e).lower()
+            if "401" in error_str or "unauthorized" in error_str or "invalid username or password" in error_str:
+                # Auth error - model might be valid but we can't check
+                return {
+                    "valid": True,  # Assume valid since we can't verify due to auth
+                    "warning": "Unable to verify model due to authentication. Assuming model is valid.",
+                    "auth_error": True
+                }
+            
+            # Model not found or not supported
+            fallback_models = self._find_fallback_models(model_id)
+            return {
+                "valid": False,
+                "error": str(e),
+                "fallback_models": fallback_models
+            }
+
+    def _find_fallback_models(self, model_id: str) -> List[Dict[str, str]]:
+        """
+        Find fallback models similar to the requested model.
+        
+        Args:
+            model_id: Original model ID
+            
+        Returns:
+            List of fallback model suggestions
+        """
+        # Extract model name parts
+        model_parts = model_id.lower().split('/')
+        if len(model_parts) > 1:
+            model_name = model_parts[-1]
+        else:
+            model_name = model_id.lower()
+            
+        # Remove version numbers and common prefixes
+        clean_name = model_name.replace('-3b', '').replace('-8b', '').replace('-70b', '')
+        clean_name = clean_name.replace('llama', '').replace('hermes', '').strip('-')
+        
+        # Search for similar models
+        try:
+            # Search for models with similar names
+            similar_models = self.hf_api.list_models(
+                search=model_name,
+                sort="downloads",
+                direction=-1,
+                limit=5
+            )
+            
+            # Filter for text generation models
+            fallbacks = []
+            for model in similar_models:
+                if (hasattr(model, 'pipeline_tag') and 
+                    model.pipeline_tag in ['text-generation', 'conversational', 'translation']):
+                    fallbacks.append({
+                        "id": model.modelId,
+                        "name": getattr(model, 'author', '') + '/' + model.modelId.split('/')[-1],
+                        "downloads": getattr(model, 'downloads', 0)
+                    })
+                    
+            return fallbacks[:5]  # Return top 5 fallbacks
+        except:
+            # If search fails, return some common models including translation models
+            return [
+                {"id": "meta-llama/Llama-3.2-3B-Instruct", "name": "Llama 3.2 3B", "downloads": 0},
+                {"id": "microsoft/Phi-3-mini-4k-instruct", "name": "Phi-3 Mini", "downloads": 0},
+                {"id": "google/gemma-2-2b-it", "name": "Gemma 2 2B", "downloads": 0},
+                {"id": "Helsinki-NLP/opus-mt-en-es", "name": "English-Spanish Translator", "downloads": 0},
+                {"id": "Helsinki-NLP/opus-mt-en-fr", "name": "English-French Translator", "downloads": 0}
+            ]
+
+    def get_model_task_support(self, model: str) -> Dict[str, Any]:
+        """
+        Get information about what tasks a model supports.
+        
+        Args:
+            model: Model ID
+            
+        Returns:
+            Model task support information
+        """
+        # Known conversational-only models
+        conversational_only_models = [
+            "meta-llama/Llama-3.2-3B-Instruct",
+            "meta-llama/Llama-3.1-8B-Instruct",
+            "meta-llama/Llama-3.1-70B-Instruct"
+        ]
+        
+        if model in conversational_only_models:
+            return {
+                "supports_text_generation": False,
+                "supports_conversational": True,
+                "recommended_method": "chat_completion"
+            }
+        else:
+            return {
+                "supports_text_generation": True,
+                "supports_conversational": True,
+                "recommended_method": "text_generation_or_chat_completion"
+            }
+
+    def text_generation(
+        self,
+        model: str,
+        prompt: str,
+        max_new_tokens: int = 250,
+        temperature: float = 0.7,
+        top_p: float = 0.95,
+        do_sample: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Send a text generation request to HuggingFace API.
+        
+        Args:
+            model: Model ID
+            prompt: Text prompt to complete
+            max_new_tokens: Maximum new tokens to generate
+            temperature: Sampling temperature
+            top_p: Nucleus sampling parameter
+            do_sample: Whether to use sampling
+        
+        Returns:
+            API response as dict
+        """
+        # Validate model before use
+        validation_result = self.validate_model(model)
+        if not validation_result["valid"]:
+            # Try fallback models
+            fallback_models = validation_result.get("fallback_models", [])
+            if fallback_models:
+                # Use the first fallback model
+                fallback_model = fallback_models[0]["id"]
+                print(f"Warning: Model {model} not supported. Using fallback model {fallback_model}")
+                model = fallback_model
+            else:
+                raise ValueError(f"Model {model} is not supported and no fallback models available. "
+                               f"Error: {validation_result.get('error', 'Unknown error')}")
+
+        try:
+            response = self.client.text_generation(
+                model=model,
+                prompt=prompt,
+                max_new_tokens=max_new_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                do_sample=do_sample
+            )
+            return {"generated_text": response}
+        except Exception as e:
+            # Check if the error is related to unsupported task
+            error_str = str(e).lower()
+            if "not supported for task text-generation" in error_str:
+                raise ValueError(f"Model {model} is not supported for text-generation task. "
+                               f"This model only supports conversational tasks. "
+                               f"Please use chat_completion method instead.")
+            elif "model_not_supported" in error_str or "not supported by any provider" in error_str:
+                # Try fallback models
+                fallback_models = self._find_fallback_models(model)
+                if fallback_models:
+                    # Try each fallback model
+                    for fallback in fallback_models[:3]:
+                        try:
+                            print(f"Trying fallback model: {fallback['id']}")
+                            response = self.client.text_generation(
+                                model=fallback['id'],
+                                prompt=prompt,
+                                max_new_tokens=max_new_tokens,
+                                temperature=temperature,
+                                top_p=top_p,
+                                do_sample=do_sample
+                            )
+                            return {"generated_text": response}
+                        except:
+                            continue
+                    
+                    raise ValueError(f"Model {model} is not supported and all fallback models failed. "
+                                   f"Try one of these: {', '.join([m['id'] for m in fallback_models[:3]])}")
+                else:
+                    raise ValueError(f"Model {model} is not supported and no fallback models available.")
+            else:
+                raise e
+
+    def get_model_info(self, model: str) -> Dict[str, Any]:
+        """
+        Get model information from HuggingFace Hub.
+        
+        Args:
+            model: Model ID
+        
+        Returns:
+            Model metadata dict
+        """
+        url = f"https://huggingface.co/api/models/{model}"
+        response = requests.get(url, headers=self.headers)
+        response.raise_for_status()
+        return response.json()
+
+    def search_models(
+        self,
+        query: str,
+        task: str = "text-generation",
+        limit: int = 10
+    ) -> List[Dict[str, Any]]:
+        """
+        Search for models on HuggingFace Hub.
+        
+        Args:
+            query: Search query
+            task: Filter by task (e.g., "text-generation", "text-classification")
+            limit: Maximum number of results
+        
+        Returns:
+            List of model metadata dicts
+        """
+        url = "https://huggingface.co/api/models"
+        params = {
+            "search": query,
+            "pipeline_tag": task,
+            "limit": limit,
+            "sort": "downloads",
+            "direction": -1
+        }
+        
+        response = requests.get(url, headers=self.headers, params=params)
+        response.raise_for_status()
+        return response.json()
+
+    def image_generation(
+        self,
+        model: str,
+        prompt: str,
+        negative_prompt: Optional[str] = None,
+        num_inference_steps: int = 50
+    ) -> bytes:
+        """
+        Generate an image using a diffusion model.
+        
+        Args:
+            model: Model ID (e.g., "stabilityai/stable-diffusion-xl-base-1.0")
+            prompt: Text prompt for image generation
+            negative_prompt: Negative prompt (what to avoid)
+            num_inference_steps: Number of denoising steps
+        
+        Returns:
+            Image bytes
+        """
+        url = f"{API_BASE}/models/{model}"
+        
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "num_inference_steps": num_inference_steps
+            }
+        }
+        
+        if negative_prompt:
+            payload["parameters"]["negative_prompt"] = negative_prompt
+        
+        response = requests.post(url, headers=self.headers, json=payload)
+        response.raise_for_status()
+        return response.content
+
+    def embedding(
+        self,
+        model: str,
+        texts: List[str]
+    ) -> List[List[float]]:
+        """
+        Get embeddings for texts.
+        
+        Args:
+            model: Model ID (e.g., "sentence-transformers/all-MiniLM-L6-v2")
+            texts: List of texts to embed
+        
+        Returns:
+            List of embedding vectors
+        """
+        url = f"{API_BASE}/models/{model}"
+        
+        payload = {
+            "inputs": texts
+        }
+        
+        response = requests.post(url, headers=self.headers, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    def summarization(
+        self,
+        model: str,
+        text: str,
+        max_length: int = 150,
+        min_length: int = 30
+    ) -> Dict[str, Any]:
+        """
+        Summarize text using a summarization model.
+        
+        Args:
+            model: Model ID (e.g., "facebook/bart-large-cnn")
+            text: Text to summarize
+            max_length: Maximum summary length
+            min_length: Minimum summary length
+        
+        Returns:
+            API response with summary
+        """
+        url = f"{API_BASE}/models/{model}"
+        
+        payload = {
+            "inputs": text,
+            "parameters": {
+                "max_length": max_length,
+                "min_length": min_length
+            }
+        }
+        
+        response = requests.post(url, headers=self.headers, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    def translation(
+        self,
+        model: str,
+        text: str
+    ) -> Dict[str, Any]:
+        url = f"{API_BASE}/models/{model}"
+        
+        payload = {
+            "inputs": text
+        }
+        
+        response = requests.post(url, headers=self.headers, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    def question_answering(
+        self,
+        model: str,
+        question: str,
+        context: str
+    ) -> Dict[str, Any]:
+        """
+        Answer a question based on context.
+        
+        Args:
+            model: Model ID (e.g., "deepset/roberta-base-squad2")
+            question: The question to answer
+            context: Context containing the answer
+        
+        Returns:
+            API response with answer
+        """
+        url = f"{API_BASE}/models/{model}"
+        
+        payload = {
+            "inputs": {
+                "question": question,
+                "context": context
+            }
+        }
+        
+        response = requests.post(url, headers=self.headers, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+
+

requirements.txt

@@ -1,13 +1,11 @@
-Pillow>=10.0.0
-torch
-torchvision
-spaces
-transformers>=4.36.0
-
-bitsandbytes==0.49.1
-sentencepiece==0.2.1
-protobuf==6.33.5
-
-gradio>=4.0.0
-requests==2.32.5
-huggingface-hub
+
+transformers>=4.36.0
+torch>=2.0.0
+bitsandbytes==0.49.1
+sentencepiece==0.2.1
+protobuf==6.33.5
+Pillow>=10.0.0
+
+gradio>=4.0.0
+requests==2.32.5
+huggingface-hub==1.4.1

test_translation.py

@@ -0,0 +1,293 @@
+"""
+Test script for translation functionality with Google TranslateGemma model
+"""
+from hf_api import HuggingFaceAPI
+from utils import load_settings
+import os
+import sys
+
+# Import Google Translate Gemma if available
+try:
+    from google_translate import GoogleTranslateGemma
+    GOOGLE_TRANSLATE_AVAILABLE = True
+except ImportError as e:
+    print(f"Warning: Google Translate Gemma not available: {str(e)}")
+    GOOGLE_TRANSLATE_AVAILABLE = False
+
+# Test translation with Google TranslateGemma
+def test_translategemma(text, source_lang, target_lang):
+    """Test translation using Google Translate Gemma model"""
+    if not GOOGLE_TRANSLATE_AVAILABLE:
+        print("❌ Google Translate Gemma is not available")
+        print("   Falling back to chat completion translation")
+        return test_chat_completion_translation(text, source_lang, target_lang)
+    
+    try:
+        print(f"🧪 Testing Google Translate Gemma")
+        print("-" * 50)
+        
+        # Initialize the translator
+        translator = GoogleTranslateGemma()
+        
+        print(f"\n📝 Translating from {source_lang} to {target_lang}")
+        print(f"Original: {text}")
+        
+        # Perform translation
+        translation = translator.translate_text(
+            text=text,
+            source_lang=source_lang,
+            target_lang=target_lang
+        )
+        
+        print(f"✅ Translation: {translation}")
+        
+    except Exception as e:
+        print(f"❌ Google Translate Gemma failed: {str(e)}")
+        print("   Falling back to chat completion translation")
+        return test_chat_completion_translation(text, source_lang, target_lang)
+    
+    print("\n" + "=" * 50)
+    print("🎉 Google Translate Gemma testing complete!")
+
+def test_chat_completion_translation(text, source_lang, target_lang):
+    """Test translation using chat completion fallback"""
+    # Load API token
+    settings_dir = os.path.join(os.path.dirname(__file__), 'settings')
+    models_settings_file = os.path.join(settings_dir, 'models.json')
+    settings = load_settings(models_settings_file)
+    token = settings.get('huggingfaceToken')
+    
+    if not token:
+        print("❌ No HuggingFace token found. Please set your token first.")
+        print("   You can set it in the app's Settings tab")
+        return
+    
+    # Initialize API
+    api = HuggingFaceAPI(token=token)
+    
+    # Test models in order of preference
+    models_to_test = [
+        "google/translategemma-12b-it",
+        "meta-llama/Llama-3.2-3B-Instruct",
+        "microsoft/Phi-3-mini-4k-instruct",
+        "google/gemma-2-2b-it"
+    ]
+    
+    print(f"🧪 Testing translation with chat completion")
+    print("-" * 50)
+    
+    for model_id in models_to_test:
+        print(f"\n📝 Testing with model: {model_id}")
+        print(f"Original: {text}")
+        
+        try:
+            # Use the same translation logic as in app.py
+            if "translategemma" in model_id.lower() and not GOOGLE_TRANSLATE_AVAILABLE:
+                print("   ⚠️  Google Translate Gemma not available, skipping...")
+                continue
+            
+            # Dynamic system prompt based on target and source language
+            source_info = f" from {source_lang}" if source_lang != "Auto-detect" else ""
+            system_prompt = f"You are a professional translator specializing in translating{source_info} to {target_lang}. Translate the given text accurately while preserving the original meaning and tone. Only provide the translation without any additional explanations."
+            prompt = f"Translate the following text{source_info} to {target_lang}: {text}"
+            
+            messages = [
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ]
+            
+            response = api.chat_completion(
+                model=model_id,
+                messages=messages,
+                max_tokens=1024,
+                temperature=0.3
+            )
+            
+            translation = response["choices"][0]["message"]["content"].strip()
+            print(f"✅ Translation: {translation}")
+            print(f"   ✅ Success with {model_id}!")
+            return translation  # Return first successful translation
+            
+        except Exception as e:
+            print(f"   ❌ Error with {model_id}: {str(e)}")
+            continue
+    
+    print("\n❌ All models failed. Please check your token and model availability.")
+    return None
+
+def test_multiple_translations():
+    """Test multiple translation scenarios"""
+    print("\n🌍 Testing Multiple Translation Scenarios")
+    print("=" * 60)
+    
+    test_cases = [
+        {
+            "text": "Hello, how are you today?",
+            "source": "English",
+            "target": "Spanish",
+            "description": "English to Spanish"
+        },
+        {
+            "text": "V nejhorším případě i k prasknutí čočky.",
+            "source": "Czech",
+            "target": "German",
+            "description": "Czech to German"
+        },
+        {
+            "text": "Bonjour, comment allez-vous?",
+            "source": "French",
+            "target": "English",
+            "description": "French to English"
+        },
+        {
+            "text": "这是一个测试。",
+            "source": "Chinese (Simplified)",
+            "target": "English",
+            "description": "Chinese to English"
+        },
+        {
+            "text": "¡Hola! ¿Cómo estás?",
+            "source": "Spanish",
+            "target": "Japanese",
+            "description": "Spanish to Japanese"
+        }
+    ]
+    
+    results = []
+    
+    for i, case in enumerate(test_cases, 1):
+        print(f"\n📝 Test {i}: {case['description']}")
+        print(f"   Source ({case['source']}): {case['text']}")
+        
+        # Map language names to codes
+        lang_code_map = {
+            "English": "en",
+            "Spanish": "es",
+            "French": "fr",
+            "German": "de-DE",
+            "Chinese (Simplified)": "zh-CN",
+            "Chinese (Traditional)": "zh-TW",
+            "Japanese": "ja",
+            "Korean": "ko",
+            "Italian": "it",
+            "Portuguese": "pt",
+            "Russian": "ru",
+            "Arabic": "ar",
+            "Hindi": "hi",
+            "Dutch": "nl",
+            "Turkish": "tr",
+            "Polish": "pl",
+            "Vietnamese": "vi",
+            "Thai": "th",
+            "Indonesian": "id",
+            "Greek": "el",
+            "Hebrew": "he",
+            "Czech": "cs",
+            "Swedish": "sv",
+            "Danish": "da",
+            "Norwegian": "no",
+            "Finnish": "fi"
+        }
+        
+        source_code = lang_code_map.get(case['source'], 'en')
+        target_code = lang_code_map.get(case['target'], 'en')
+        
+        translation = test_translategemma(
+            text=case['text'],
+            source_lang=source_code,
+            target_lang=target_code
+        )
+        
+        if translation:
+            print(f"   Target ({case['target']}): {translation}")
+            results.append({
+                'case': case['description'],
+                'original': case['text'],
+                'translation': translation,
+                'success': True
+            })
+        else:
+            results.append({
+                'case': case['description'],
+                'original': case['text'],
+                'translation': None,
+                'success': False
+            })
+    
+    # Summary
+    print("\n" + "=" * 60)
+    print("📊 Test Summary")
+    print("-" * 60)
+    
+    successful = sum(1 for r in results if r['success'])
+    total = len(results)
+    
+    print(f"Total tests: {total}")
+    print(f"Successful: {successful}")
+    print(f"Failed: {total - successful}")
+    print(f"Success rate: {successful/total*100:.1f}%")
+    
+    if successful < total:
+        print("\n❌ Some tests failed. Check your HuggingFace token and model availability.")
+    else:
+        print("\n✅ All tests passed successfully!")
+    
+    return results
+
+if __name__ == "__main__":
+    import sys
+    
+    print("🌐 Translation Test Suite")
+    print("=" * 60)
+    print()
+    
+    # Check if command line arguments were provided
+    if len(sys.argv) > 1:
+        # Run single test with provided arguments
+        if len(sys.argv) >= 4:
+            text = sys.argv[1]
+            source_lang = sys.argv[2]
+            target_lang = sys.argv[3]
+            print(f"Running single test:")
+            print(f"  Text: {text}")
+            print(f"  Source: {source_lang}")
+            print(f"  Target: {target_lang}")
+            print()
+            test_translategemma(text, source_lang, target_lang)
+        else:
+            print("Usage: python test_translation.py <text> <source_lang> <target_lang>")
+            print("Example: python test_translation.py \"Hello world\" en es")
+    else:
+        # Run comprehensive test suite
+        print("Running comprehensive translation tests...")
+        print()
+        
+        # First, test a simple case
+        print("\n" + "=" * 60)
+        print("🧪 Quick Test")
+        test_translategemma(
+            text="Hello, world!",
+            source_lang="en",
+            target_lang="es"
+        )
+        
+        # Then run multiple tests
+        test_multiple_translations()
+        
+        print("\n" + "=" * 60)
+        print("🎉 All tests completed!")
+        print()
+        print("To test a specific translation:")
+        print("  python test_translation.py \"Your text here\" source_lang target_lang")
+        print()
+        print("To test in the app:")
+        print("  1. Run: python app.py")
+        print("  2. Go to Translation tab")
+        print("  3. Set your HuggingFace token in Settings")
+        print("  4. Try translating text")

utils.py

@@ -1,23 +1,23 @@
-"""
-Utility functions shared across the application
-"""
-import os
-import json
-
-
-def load_settings(file_path):
-    """Load settings from a JSON file"""
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    except FileNotFoundError:
-        return {}
-    except json.JSONDecodeError:
-        return {}
-
-
-def save_settings(file_path, data):
-    """Save settings to a JSON file"""
-    os.makedirs(os.path.dirname(file_path), exist_ok=True)
-    with open(file_path, 'w', encoding='utf-8') as f:
+"""
+Utility functions shared across the application
+"""
+import os
+import json
+
+
+def load_settings(file_path):
+    """Load settings from a JSON file"""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return {}
+    except json.JSONDecodeError:
+        return {}
+
+
+def save_settings(file_path, data):
+    """Save settings to a JSON file"""
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+    with open(file_path, 'w', encoding='utf-8') as f:
         json.dump(data, f, indent=2, ensure_ascii=False)