Enhance logging and error handling in the Gradio app, improve model existence checks with detailed logging, and add connectivity testing feature in the submission UI. Update data manager for better model validation and submission processes.

HF_SPACES_DEBUG.md

@@ -0,0 +1,111 @@
+# Hugging Face Spaces Debugging Guide
+
+## Issue: Validation Button Not Working
+
+If the validation button is not responding when deployed to Hugging Face Spaces, follow these debugging steps:
+
+### 1. Run the Debug Script
+
+First, run the comprehensive debugging script to identify the issue:
+
+```bash
+python debug_hf_spaces.py
+```
+
+This will create a `debug.log` file with detailed information about:
+
+- Environment information
+- Network connectivity
+- Module imports
+- Model validator functionality
+- Data manager functionality
+
+### 2. Check Common Issues
+
+#### Network Connectivity
+
+Hugging Face Spaces might have different network policies. The debug script tests:
+
+- Basic HTTP requests
+- Ollama.com connectivity
+- Hugging Face Hub connectivity
+
+#### Timeout Issues
+
+The validation process now includes:
+
+- 30-second timeout for Ollama requests
+- Retry logic with exponential backoff
+- Fallback mechanism for network failures
+
+#### Import Issues
+
+Check if all modules are importing correctly:
+
+- `model_validator`
+- `data_manager`
+- `api_service`
+- UI modules
+
+### 3. Fallback Mechanism
+
+If validation fails due to network issues, the system now provides a fallback:
+
+- Shows a warning message
+- Still allows model submission
+- User can proceed with manual verification
+
+### 4. Manual Testing
+
+You can test individual components:
+
+```bash
+# Test basic connectivity
+python -c "import requests; print(requests.get('https://ollama.com').status_code)"
+
+# Test model validator
+python -c "from model_validator import model_validator; print(model_validator.validate_ollama_model('llama2', '7b'))"
+
+# Test data manager
+python -c "from data_manager import data_manager; print(data_manager.check_model_exists('llama2', '7b'))"
+```
+
+### 5. Environment Variables
+
+Check if these environment variables are set in your Hugging Face Space:
+
+- `HF_TOKEN` (if needed for dataset access)
+- `API_BASE_URL` (for model submission)
+
+### 6. Logs
+
+Check the application logs in Hugging Face Spaces:
+
+- Look for error messages
+- Check for timeout errors
+- Verify import statements
+
+### 7. Quick Fixes
+
+If the issue persists:
+
+1. **Increase timeouts**: The system now uses 30-second timeouts
+2. **Use fallback mode**: The validation will show a warning but allow submission
+3. **Check network policies**: Ensure Ollama.com is accessible from Hugging Face Spaces
+
+### 8. Contact Support
+
+If the issue continues, provide:
+
+- The output from `debug_hf_spaces.py`
+- The contents of `debug.log`
+- Any error messages from Hugging Face Spaces logs
+
+## Files Modified for HF Spaces Compatibility
+
+1. **`model_validator.py`**: Added retry logic and increased timeouts
+2. **`ui_submit_model.py`**: Added fallback mechanism and better error handling
+3. **`data_manager.py`**: Improved error handling for dataset loading
+4. **`app.py`**: Added comprehensive logging and error handling
+5. **`debug_hf_spaces.py`**: Comprehensive debugging script
+6. **`test_hf_spaces.py`**: Basic functionality tests

app.py

@@ -1,50 +1,79 @@
 import logging
 import sys
+from pathlib import Path
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler('app.log')
+    ]
+)
+logger = logging.getLogger(__name__)
+
+try:
+    import gradio as gr
+
+    from config import CONFIG
+    from data_manager import DataManager
+    from ui_evaluation_requests import add_evaluation_requests_tab
+    from ui_leaderboard import add_leaderboard_tab
+    from ui_main import create_clean_app
+    from ui_model_responses import add_model_responses_tab
+    from ui_model_section_scores import add_model_section_scores_tab
+    from ui_submit_model import add_submit_model_tab
+    
+    logger.info("All imports successful")
+except Exception as e:
+    logger.error(f"Import error: {e}")
+    raise
 
 from apscheduler.schedulers.background import BackgroundScheduler
 
-from config import CONFIG
 from data_manager import data_manager
-from ui_main import create_clean_app
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
 
 def main():
+    """Ana uygulama fonksiyonu"""
     try:
-        # Zamanlayıcıyı başlat
+        logger.info("Starting Turkish MMLU Leaderboard application...")
+        
+        # Initialize data manager
+        logger.info("Initializing data manager...")
+        data_manager_instance = DataManager()
+        logger.info("Data manager initialized successfully")
+        
+        # Create the main interface
+        logger.info("Creating main interface...")
+        app = create_clean_app()
+        logger.info("Main interface created successfully")
+        
+        # Start the scheduler for data refresh
+        logger.info("Starting background scheduler...")
         scheduler = BackgroundScheduler()
         scheduler.add_job(
-            data_manager.refresh_datasets,
+            data_manager_instance.refresh_datasets,
             'interval',
-            minutes=CONFIG["dataset"].refresh_interval // 60,
-            id='dataset_refresh',
-            replace_existing=True
+            seconds=CONFIG["dataset"].refresh_interval,
+            id='refresh_datasets'
         )
         scheduler.start()
-        logger.info("Zamanlayıcı başlatıldı")
-        
-        # Uygulamayı oluştur ve başlat
-        app = create_clean_app()
+        logger.info("Background scheduler started successfully")
         
-        logger.info("Uygulama başlatılıyor...")
+        # Launch the app
+        logger.info("Launching Gradio app...")
         app.launch(
-            server_name=CONFIG["app"].server_name,
-            server_port=CONFIG["app"].server_port,
-            share=CONFIG["app"].share,
-            debug=CONFIG["app"].debug,
-            show_error=CONFIG["app"].show_error
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            debug=True
         )
         
-    except KeyboardInterrupt:
-        logger.info("Kullanıcı tarafından durduruldu")
     except Exception as e:
-        logger.error(f"Uygulama başlatma hatası: {e}")
-        sys.exit(1)
-    finally:
-        if 'scheduler' in locals():
-            scheduler.shutdown()
-            logger.info("Zamanlayıcı durduruldu")
+        logger.error(f"Application startup failed: {e}")
+        raise
 
 if __name__ == "__main__":
     main()

data_manager.py

@@ -219,64 +219,54 @@ class DataManager:
             logger.error(f"Veri özeti alma hatası: {e}")
             return {"hata": str(e), "mesaj": "Veri özeti alınamadı"}
 
-    def check_model_exists(self, model_name: str, version: str) -> Dict:
-        """Check if a model already exists in the leaderboard dataset (model column is model:version)."""
+    def check_model_exists(self, model_name: str, version: str) -> dict:
+        """Check if a model already exists in the leaderboard"""
         try:
+            logger.info(f"Checking if model exists: {model_name}:{version}")
+            
             df = self.leaderboard_data
             if df.empty:
+                logger.error("Leaderboard data is empty")
+                return {"exists": False, "error": "Leaderboard data is empty"}
+            
+            # Create the combined model:version string
+            model_version = f"{model_name}:{version}"
+            logger.info(f"Looking for model_version: {model_version}")
+            
+            # Check for exact match
+            exact_matches = df[df['model'] == model_version]
+            
+            if not exact_matches.empty:
+                logger.info(f"Found exact match: {model_version}")
+                model_data = exact_matches.iloc[0].to_dict()
                 return {
-                    'exists': False,
-                    'message': 'Liderlik tablosu verisi bulunamadı'
-                }
-            model_name_lower = model_name.lower().strip()
-            version_lower = version.lower().strip()
-            # Split model column into name/version
-            def split_model(m):
-                parts = str(m).split(":", 1)
-                if len(parts) == 2:
-                    return parts[0].strip().lower(), parts[1].strip().lower()
-                return parts[0].strip().lower(), ''
-            # Find exact match
-            matches = df['model'].apply(lambda m: split_model(m) == (model_name_lower, version_lower))
-            if matches.any():
-                model_row = df[matches].iloc[0]
-                return {
-                    'exists': True,
-                    'model_data': model_row.to_dict(),
-                    'status': 'completed',
-                    'basari': model_row.get('basari', 0),
-                    'progress': 1.0,
-                    'message': f"Model {model_name}:{version} zaten liderlik tablosunda mevcut"
-                }
-            # Find similar models (same name, any version)
-            similar_mask = df['model'].apply(lambda m: split_model(m)[0] == model_name_lower)
-            similar_models = df[similar_mask]
-            if not similar_models.empty:
-                similar_info = []
-                for _, row in similar_models.iterrows():
-                    _, v = split_model(row['model'])
-                    similar_info.append({
-                        'version': v,
-                        'status': 'completed',
-                        'basari': row.get('basari', 0),
-                        'progress': 1.0
-                    })
-                return {
-                    'exists': False,
-                    'similar_models': similar_info,
-                    'message': f"Model {model_name} bulundu, farklı versiyonlar mevcut"
+                    "exists": True,
+                    "model_data": model_data,
+                    "similar_models": []
                 }
+            
+            # Check for similar models (same base model, different versions)
+            similar_models = []
+            for _, row in df.iterrows():
+                if ':' in str(row['model']):
+                    parts = str(row['model']).split(':', 1)
+                    if len(parts) == 2 and parts[0] == model_name:
+                        similar_models.append({
+                            'version': parts[1],
+                            'status': row.get('status', 'Bilinmiyor'),
+                            'basari': row.get('basari', 0)
+                        })
+            
+            logger.info(f"Found {len(similar_models)} similar models")
+            
             return {
-                'exists': False,
-                'message': f"Model {model_name}:{version} liderlik tablosunda bulunamadı"
+                "exists": False,
+                "similar_models": similar_models
             }
+            
         except Exception as e:
-            logger.error(f"Model kontrol hatası: {e}")
-            return {
-                'exists': False,
-                'error': str(e),
-                'message': f"Model kontrolü sırasında hata oluştu: {str(e)}"
-            }
+            logger.error(f"Error checking model existence: {e}")
+            return {"exists": False, "error": str(e)}
 
     def clear_cache(self):
         """Tüm önbelleğe alınan verileri ve zaman damgalarını temizle."""

debug_hf_spaces.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+Comprehensive debugging script for Hugging Face Spaces deployment
+"""
+
+import logging
+import sys
+import time
+import traceback
+from pathlib import Path
+
+import requests
+
+# Set up comprehensive logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler('debug.log')
+    ]
+)
+logger = logging.getLogger(__name__)
+
+def log_environment_info():
+    """Log environment information"""
+    logger.info("=== ENVIRONMENT INFORMATION ===")
+    logger.info(f"Python version: {sys.version}")
+    logger.info(f"Platform: {sys.platform}")
+    
+    try:
+        import gradio as gr
+        logger.info(f"Gradio version: {gr.__version__}")
+    except Exception as e:
+        logger.error(f"Gradio import failed: {e}")
+    
+    try:
+        import pandas as pd
+        logger.info(f"Pandas version: {pd.__version__}")
+    except Exception as e:
+        logger.error(f"Pandas import failed: {e}")
+    
+    try:
+        import requests
+        logger.info(f"Requests version: {requests.__version__}")
+    except Exception as e:
+        logger.error(f"Requests import failed: {e}")
+
+def test_basic_requests():
+    """Test basic requests functionality"""
+    logger.info("=== TESTING BASIC REQUESTS ===")
+    
+    test_urls = [
+        "https://httpbin.org/get",
+        "https://ollama.com",
+        "https://huggingface.co"
+    ]
+    
+    for url in test_urls:
+        try:
+            logger.info(f"Testing {url}")
+            response = requests.get(url, timeout=30)
+            logger.info(f"✅ {url} - Status: {response.status_code}")
+            logger.info(f"   Content length: {len(response.text)}")
+        except requests.exceptions.Timeout:
+            logger.error(f"❌ {url} - Timeout")
+        except requests.exceptions.ConnectionError as e:
+            logger.error(f"❌ {url} - Connection error: {e}")
+        except Exception as e:
+            logger.error(f"❌ {url} - Error: {e}")
+
+def test_model_validator_import():
+    """Test model validator import and basic functionality"""
+    logger.info("=== TESTING MODEL VALIDATOR ===")
+    
+    try:
+        from model_validator import model_validator
+        logger.info("✅ Model validator imported successfully")
+        
+        # Test basic functionality
+        logger.info("Testing model validator with simple request...")
+        result = model_validator.validate_ollama_model("llama2", "7b")
+        logger.info(f"✅ Model validation result: {result}")
+        
+    except ImportError as e:
+        logger.error(f"❌ Import error: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+    except Exception as e:
+        logger.error(f"❌ Model validator error: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+
+def test_data_manager_import():
+    """Test data manager import and basic functionality"""
+    logger.info("=== TESTING DATA MANAGER ===")
+    
+    try:
+        from data_manager import data_manager
+        logger.info("✅ Data manager imported successfully")
+        
+        # Test basic functionality
+        logger.info("Testing data manager with simple request...")
+        result = data_manager.check_model_exists("llama2", "7b")
+        logger.info(f"✅ Data manager result: {result}")
+        
+    except ImportError as e:
+        logger.error(f"❌ Import error: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+    except Exception as e:
+        logger.error(f"❌ Data manager error: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+
+def test_gradio_interface():
+    """Test Gradio interface creation"""
+    logger.info("=== TESTING GRADIO INTERFACE ===")
+    
+    try:
+        import gradio as gr
+        logger.info("✅ Gradio imported successfully")
+        
+        # Test basic interface creation
+        with gr.Blocks() as demo:
+            gr.Textbox(label="Test")
+            gr.Button("Test")
+        
+        logger.info("✅ Basic Gradio interface created successfully")
+        
+    except Exception as e:
+        logger.error(f"❌ Gradio interface error: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+
+def test_ui_imports():
+    """Test UI module imports"""
+    logger.info("=== TESTING UI IMPORTS ===")
+    
+    ui_modules = [
+        "ui_main",
+        "ui_leaderboard", 
+        "ui_submit_model",
+        "ui_evaluation_requests",
+        "ui_model_responses",
+        "ui_model_section_scores"
+    ]
+    
+    for module_name in ui_modules:
+        try:
+            module = __import__(module_name)
+            logger.info(f"✅ {module_name} imported successfully")
+        except Exception as e:
+            logger.error(f"❌ {module_name} import failed: {e}")
+            logger.error(f"Traceback: {traceback.format_exc()}")
+
+def test_full_app_startup():
+    """Test full app startup"""
+    logger.info("=== TESTING FULL APP STARTUP ===")
+    
+    try:
+        # Test main app import
+        from app import main
+        logger.info("✅ Main app imported successfully")
+        
+        # Test data manager initialization
+        from data_manager import DataManager
+        dm = DataManager()
+        logger.info("✅ Data manager initialized successfully")
+        
+        # Test model validator initialization
+        from model_validator import OllamaModelValidator
+        validator = OllamaModelValidator()
+        logger.info("✅ Model validator initialized successfully")
+        
+    except Exception as e:
+        logger.error(f"❌ Full app startup error: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+
+def main():
+    """Run all debugging tests"""
+    logger.info("Starting comprehensive Hugging Face Spaces debugging...")
+    
+    log_environment_info()
+    time.sleep(1)
+    
+    test_basic_requests()
+    time.sleep(1)
+    
+    test_model_validator_import()
+    time.sleep(1)
+    
+    test_data_manager_import()
+    time.sleep(1)
+    
+    test_gradio_interface()
+    time.sleep(1)
+    
+    test_ui_imports()
+    time.sleep(1)
+    
+    test_full_app_startup()
+    
+    logger.info("=== DEBUGGING COMPLETED ===")
+    logger.info("Check the debug.log file for detailed information")
+
+if __name__ == "__main__":
+    main() 

model_validator.py

@@ -17,28 +17,45 @@ class OllamaModelValidator:
             "User-Agent": "Turkish-MMLU-Benchmark/1.0",
             "Accept": "text/html",
         })
-        self.session.timeout = 10
+        self.session.timeout = 30  # Increased timeout for HF Spaces
     
     def fetch_model_html(self, model_name: str, version: str = None) -> str:
         """Fetch model HTML from Ollama library"""
-        try:
-            path = f"/library/{model_name}"
-            if version:
-                path += f":{version}"
-            
-            url = f"{self.base_url}{path}"
-            logger.info(f"Fetching model HTML from: {url}")
-            
-            response = self.session.get(url)
-            
-            if response.status_code == 200:
-                return response.text
-            else:
-                raise Exception(f"Failed to fetch model page: {response.status_code}")
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                path = f"/library/{model_name}"
+                if version:
+                    path += f":{version}"
                 
-        except Exception as e:
-            logger.error(f"Error fetching model HTML: {e}")
-            raise
+                url = f"{self.base_url}{path}"
+                logger.info(f"Fetching model HTML from: {url} (attempt {attempt + 1}/{max_retries})")
+                
+                response = self.session.get(url)
+                
+                if response.status_code == 200:
+                    logger.info(f"Successfully fetched HTML from {url}")
+                    return response.text
+                elif response.status_code == 404:
+                    logger.warning(f"Model not found: {url}")
+                    raise Exception(f"Model not found: {model_name}:{version}")
+                else:
+                    logger.warning(f"HTTP {response.status_code} for {url}")
+                    raise Exception(f"Failed to fetch model page: {response.status_code}")
+                    
+            except requests.exceptions.Timeout:
+                logger.warning(f"Timeout on attempt {attempt + 1} for {url}")
+                if attempt == max_retries - 1:
+                    raise Exception(f"Request timeout after {max_retries} attempts")
+                continue
+            except requests.exceptions.ConnectionError as e:
+                logger.warning(f"Connection error on attempt {attempt + 1}: {e}")
+                if attempt == max_retries - 1:
+                    raise Exception(f"Connection failed after {max_retries} attempts: {e}")
+                continue
+            except Exception as e:
+                logger.error(f"Error fetching model HTML: {e}")
+                raise
     
     def parse_model_html(self, html: str) -> Dict:
         """Parse model HTML to extract parameter size and available tags"""

test_hf_spaces.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""
+Test script for debugging Hugging Face Spaces deployment issues
+"""
+
+import logging
+import time
+
+import requests
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def test_basic_connectivity():
+    """Test basic internet connectivity"""
+    logger.info("Testing basic connectivity...")
+    
+    test_urls = [
+        "https://ollama.com",
+        "https://huggingface.co",
+        "https://google.com"
+    ]
+    
+    for url in test_urls:
+        try:
+            logger.info(f"Testing connection to {url}")
+            response = requests.get(url, timeout=10)
+            logger.info(f"✅ {url} - Status: {response.status_code}")
+        except Exception as e:
+            logger.error(f"❌ {url} - Error: {e}")
+
+def test_ollama_scraping():
+    """Test Ollama website scraping"""
+    logger.info("Testing Ollama scraping...")
+    
+    try:
+        # Test basic page fetch
+        url = "https://ollama.com/library/llama2"
+        logger.info(f"Fetching {url}")
+        
+        session = requests.Session()
+        session.headers.update({
+            "User-Agent": "Turkish-MMLU-Benchmark/1.0",
+            "Accept": "text/html",
+        })
+        session.timeout = 30
+        
+        response = session.get(url)
+        logger.info(f"✅ Ollama page fetch - Status: {response.status_code}")
+        logger.info(f"Content length: {len(response.text)} characters")
+        
+        # Check if content contains expected elements
+        if "llama2" in response.text.lower():
+            logger.info("✅ Content contains expected model name")
+        else:
+            logger.warning("⚠️ Content doesn't contain expected model name")
+            
+    except Exception as e:
+        logger.error(f"❌ Ollama scraping test failed: {e}")
+
+def test_model_validator():
+    """Test the model validator"""
+    logger.info("Testing model validator...")
+    
+    try:
+        from model_validator import OllamaModelValidator
+        
+        validator = OllamaModelValidator()
+        
+        # Test with a known model
+        result = validator.validate_ollama_model("llama2", "7b")
+        
+        logger.info(f"✅ Model validation result: {result.get('valid', False)}")
+        if result.get('valid'):
+            logger.info(f"Parameter size: {result.get('parameter_size')}")
+            logger.info(f"RAM requirements: {result.get('ram_requirements')}")
+        else:
+            logger.info(f"Validation error: {result.get('error')}")
+            
+    except Exception as e:
+        logger.error(f"❌ Model validator test failed: {e}")
+
+def test_data_manager():
+    """Test the data manager"""
+    logger.info("Testing data manager...")
+    
+    try:
+        from data_manager import DataManager
+        
+        dm = DataManager()
+        
+        # Test leaderboard data
+        leaderboard = dm.leaderboard_data
+        logger.info(f"✅ Leaderboard data loaded - {len(leaderboard)} rows")
+        
+        # Test model existence check
+        result = dm.check_model_exists("llama2", "7b")
+        logger.info(f"✅ Model existence check: {result}")
+        
+    except Exception as e:
+        logger.error(f"❌ Data manager test failed: {e}")
+
+if __name__ == "__main__":
+    logger.info("Starting Hugging Face Spaces compatibility tests...")
+    
+    test_basic_connectivity()
+    time.sleep(1)
+    
+    test_ollama_scraping()
+    time.sleep(1)
+    
+    test_model_validator()
+    time.sleep(1)
+    
+    test_data_manager()
+    
+    logger.info("All tests completed!") 

ui_submit_model.py

@@ -45,31 +45,58 @@ def add_submit_model_tab(block, api_service):
         with gr.Row():
             validate_btn = gr.Button("🔍 Model Doğrula", variant="secondary", size="lg")
             submit_btn = gr.Button("🚀 Model Gönder", variant="primary", size="lg", interactive=False)
+            debug_btn = gr.Button("🔧 Bağlantı Testi", variant="secondary", size="sm")
         
         validation_output = gr.HTML()
         submission_output = gr.HTML()
+        debug_output = gr.Textbox(label="Bağlantı Durumu", interactive=False)
         
         # Store validation result
         validation_result = gr.State(None)
         
+        def test_connectivity():
+            """Test basic connectivity for debugging"""
+            try:
+                import requests
+                response = requests.get("https://ollama.com", timeout=10)
+                if response.status_code == 200:
+                    return "✅ Ollama.com erişilebilir"
+                else:
+                    return f"❌ Ollama.com HTTP {response.status_code}"
+            except Exception as e:
+                return f"❌ Ollama.com erişilemiyor: {str(e)}"
+        
         def handle_validation(model_name, version):
             """Model doğrulama işlemi"""
             try:
+                logger.info(f"Validation started for model: {model_name}:{version}")
+                
                 # Validation
                 if not model_name or not model_name.strip():
+                    logger.warning("Model name is empty")
                     return (
                         f'<div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">❌ Hata: Model adı gereklidir</div>',
                         None
                     )
                 
                 if not version or not version.strip():
+                    logger.warning("Version is empty")
                     return (
                         f'<div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">❌ Hata: Versiyon gereklidir</div>',
                         None
                     )
                 
+                logger.info("Checking if model exists in leaderboard dataset...")
                 # Check if model already exists in the leaderboard dataset
-                model_check = data_manager.check_model_exists(model_name.strip(), version.strip())
+                try:
+                    model_check = data_manager.check_model_exists(model_name.strip(), version.strip())
+                    logger.info(f"Model check result: {model_check.get('exists', False)}")
+                except Exception as e:
+                    logger.error(f"Error checking model existence: {e}")
+                    return (
+                        f'<div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">❌ <strong>Veri Kontrol Hatası!</strong><br><strong>Hata:</strong> {str(e)}</div>',
+                        None
+                    )
                 
                 if model_check['exists']:
                     # Model already exists
@@ -82,6 +109,7 @@ def add_submit_model_tab(block, api_service):
                     basari_percent = f"{basari:.2f}%" if isinstance(basari, (int, float)) else "0.00%"
                     progress_percent = f"{progress * 100:.2f}%" if isinstance(progress, (int, float)) else "0.00%"
                     
+                    logger.info(f"Model already exists: {model_name}:{version}")
                     return (
                         f'''
                         <div style="color: orange; padding: 15px; border: 1px solid orange; border-radius: 8px; background: #fffbeb;">
@@ -97,8 +125,25 @@ def add_submit_model_tab(block, api_service):
                         None
                     )
                 
+                logger.info("Validating with Ollama...")
                 # Validate with Ollama
-                validation = model_validator.validate_ollama_model(model_name.strip(), version.strip())
+                try:
+                    validation = model_validator.validate_ollama_model(model_name.strip(), version.strip())
+                    logger.info(f"Ollama validation result: {validation.get('valid', False)}")
+                except Exception as e:
+                    logger.error(f"Error validating with Ollama: {e}")
+                    # In Hugging Face Spaces, we might have network issues, so provide a fallback
+                    return (
+                        f'''
+                        <div style="color: orange; padding: 15px; border: 1px solid orange; border-radius: 8px; background: #fffbeb;">
+                            ⚠️ <strong>Ollama Doğrulama Başarısız!</strong><br>
+                            <strong>Hata:</strong> {str(e)}<br><br>
+                            <strong>Not:</strong> Doğrulama başarısız oldu, ancak model gönderimi denenebilir. 
+                            Model adı ve versiyonun doğru olduğundan emin olun.
+                        </div>
+                        ''',
+                        {"valid": True, "fallback": True, "model": model_name.strip(), "version": version.strip()}
+                    )
                 
                 if validation['valid']:
                     # Format validation details
@@ -141,6 +186,7 @@ def add_submit_model_tab(block, api_service):
                     </div>
                     '''
                     
+                    logger.info(f"Validation successful for {model_name}:{version}")
                     return html_output, validation
                 else:
                     error_msg = validation.get('error', 'Bilinmeyen hata')
@@ -154,6 +200,7 @@ def add_submit_model_tab(block, api_service):
                             tags_info += f"<br><strong>Önerilen versiyon:</strong> {suggested_version}"
                         tags_info += "<br><strong>Önerilen:</strong> Yukarıdaki versiyonlardan birini kullanın."
                     
+                    logger.warning(f"Validation failed for {model_name}:{version} - {error_msg}")
                     return (
                         f'''
                         <div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">
@@ -170,115 +217,106 @@ def add_submit_model_tab(block, api_service):
                     f'''
                     <div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">
                         ❌ <strong>Sistem Hatası!</strong><br>
-                        <strong>Hata:</strong> {str(e)}
+                        <strong>Hata:</strong> {str(e)}<br><br>
+                        <strong>Not:</strong> Lütfen sayfayı yenileyin ve tekrar deneyin.
                     </div>
                     ''',
                     None
                 )
         
-        def update_submit_button(validation_data):
-            """Update submit button state based on validation result"""
-            if validation_data and validation_data.get('valid', False) and validation_data.get('can_load', False):
+        def update_submit_button(validation_result):
+            """Submit butonunun durumunu güncelle"""
+            if validation_result is None:
+                return gr.Button(interactive=False)
+            
+            # Check if validation passed (including fallback)
+            if validation_result.get('valid', False):
                 return gr.Button(interactive=True)
             else:
                 return gr.Button(interactive=False)
         
         def handle_submission(model_name, version, validation_data):
-            """Model gönderimi işle"""
+            """Model gönderimi işlemi"""
             try:
-                # Check if validation was successful
-                if not validation_data:
-                    return (
-                        f'<div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">❌ Hata: Önce modeli doğrulayın</div>',
-                        model_name, version
-                    )
+                logger.info(f"Model submission started for: {model_name}:{version}")
                 
-                # Check if model can be loaded (using 20GB limit)
-                if not validation_data.get('can_load', False):
+                if not validation_data or not validation_data.get('valid', False):
                     return (
                         f'''
                         <div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">
-                            ❌ <strong>Model Çok Büyük!</strong><br>
-                            <strong>Hata:</strong> Model {validation_data['model']}:{validation_data['version']} 20GB'dan fazla RAM gerektiriyor<br>
-                            <strong>Parametre Boyutu:</strong> {validation_data['parameter_size']}B<br>
-                            <strong>RAM Gereksinimleri:</strong><br>
-                            • 16-bit: {validation_data['ram_requirements']['16-bit']}GB<br>
-                            • 8-bit: {validation_data['ram_requirements']['8-bit']}GB<br>
-                            • 4-bit: {validation_data['ram_requirements']['4-bit']}GB<br>
-                            <strong>Önerilen:</strong> Daha küçük bir model veya farklı quantization seçin
+                            ❌ <strong>Gönderim Hatası!</strong><br>
+                            <strong>Hata:</strong> Model doğrulanmamış. Lütfen önce modeli doğrulayın.
                         </div>
                         ''',
-                        model_name, version
+                        model_name, version  # Keep the fields for user to modify
                     )
                 
-                # Check if model already exists in leaderboard before submitting
-                model_check = data_manager.check_model_exists(model_name.strip(), version.strip())
-                evaluation_info = ""
-                
-                if model_check['exists']:
-                    existing_model = model_check['model_data']
-                    basari = existing_model.get('basari', 0)
-                    basari_percent = f"{basari:.2f}%" if isinstance(basari, (int, float)) else "0.00%"
-                    evaluation_info = f"<br><br>⚠️ <strong>Değerlendirme Bilgisi:</strong> Bu model zaten değerlendirilmiş (Başarı: {basari_percent})"
-                elif 'similar_models' in model_check:
-                    similar_models = model_check['similar_models']
-                    evaluation_info = f"<br><br>ℹ️ <strong>Benzer Modeller:</strong> "
-                    for similar in similar_models[:2]:
-                        basari_similar = f"{similar['basari']:.2f}%" if isinstance(similar['basari'], (int, float)) else "0.00%"
-                        evaluation_info += f"{similar['version']} (Başarı: {basari_similar}), "
-                    evaluation_info = evaluation_info.rstrip(", ")
-                
-                # API'ye gönder
-                result = api_service.submit_model(model_name.strip(), version.strip())
+                # Check if this is a fallback validation (no parameter_size)
+                if validation_data.get('fallback', False):
+                    # For fallback cases, we don't have parameter_size, so we'll use default values
+                    parameter_size = 7  # Default to 7B
+                    logger.info(f"Using fallback parameter size: {parameter_size}B")
+                else:
+                    # Get parameter size from validation
+                    parameter_size = validation_data.get('parameter_size')
+                    if not parameter_size:
+                        return (
+                            f'''
+                            <div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">
+                                ❌ <strong>Gönderim Hatası!</strong><br>
+                                <strong>Hata:</strong> Model parametre boyutu belirlenemedi. Lütfen modeli tekrar doğrulayın.
+                            </div>
+                            ''',
+                            model_name, version  # Keep the fields for user to modify
+                        )
+                    logger.info(f"Using validated parameter size: {parameter_size}B")
                 
-                if result.get('success'):
-                    data = result.get('data', {})
-                    return (
-                        f'''
-                        <div style="color: green; padding: 15px; border: 1px solid green; border-radius: 8px; background: #f0fdf4;">
-                            ✅ <strong>Başarılı!</strong><br>
-                            <strong>Mesaj:</strong> {result.get('message')}<br>
-                            <strong>Model:</strong> {data.get('model', model_name)}<br>
-                            <strong>Versiyon:</strong> {data.get('version', version)}<br>
-                            <strong>Durum:</strong> {data.get('status', 'Beklemede')}<br>
-                            <strong>Oluşturulma:</strong> {data.get('created_at', 'Şimdi')}<br><br>
-                            <strong>Doğrulama Bilgileri:</strong><br>
-                            • Parametre Boyutu: {validation_data['parameter_size']}B<br>
-                            • Önerilen Quantization: {validation_data.get('recommended_quantization', 'Yok')}{evaluation_info}
-                        </div>
-                        ''',
-                        "", ""  # Clear model name and version fields
+                # Submit to API
+                try:
+                    result = api_service.submit_model(
+                        model_name=model_name.strip(),
+                        version=version.strip()
                     )
-                else:
-                    # Check for specific error types
-                    error_message = result.get('message', 'Bilinmeyen hata')
-                    error_detail = result.get('error', 'Server error')
                     
-                    # Handle HTTP 409 - Model already submitted
-                    if "409" in error_message or "409" in error_detail:
+                    if result.get('success'):
+                        logger.info(f"Model submitted successfully: {model_name}:{version}")
                         return (
                             f'''
-                            <div style="color: orange; padding: 15px; border: 1px solid orange; border-radius: 8px; background: #fffbeb;">
-                                ⚠️ <strong>Model Zaten Gönderilmiş!</strong><br><br>
+                            <div style="color: green; padding: 15px; border: 1px solid green; border-radius: 8px; background: #f0fdf4;">
+                                ✅ <strong>Model Başarıyla Gönderildi!</strong><br><br>
                                 <strong>Model:</strong> {model_name}<br>
-                                <strong>Versiyon:</strong> {version}<br><br>
-                                <strong>Not:</strong> Bu model daha önce sisteme gönderilmiş ve değerlendirme kuyruğunda bulunmaktadır.<br>
-                                Lütfen farklı bir model veya versiyon deneyin.
+                                <strong>Versiyon:</strong> {version}<br>
+                                <strong>Parametre Boyutu:</strong> {parameter_size}B<br><br>
+                                <strong>Mesaj:</strong> {result.get('message', 'Model değerlendirme kuyruğuna eklendi.')}
                             </div>
                             ''',
-                            model_name, version  # Keep the fields for user to modify
+                            "", ""  # Clear model name and version fields
                         )
                     else:
+                        error_msg = result.get('error', 'Bilinmeyen hata')
+                        logger.error(f"API submission failed: {error_msg}")
                         return (
                             f'''
                             <div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">
-                                ❌ <strong>Hata!</strong><br>
-                                <strong>Mesaj:</strong> {error_message}<br>
-                                <strong>Detay:</strong> {error_detail}
+                                ❌ <strong>API Gönderim Hatası!</strong><br>
+                                <strong>Hata:</strong> {error_msg}
                             </div>
                             ''',
                             model_name, version  # Keep the fields for user to modify
                         )
+                        
+                except Exception as e:
+                    logger.error(f"API submission exception: {e}")
+                    return (
+                        f'''
+                        <div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">
+                            ❌ <strong>API Bağlantı Hatası!</strong><br>
+                            <strong>Hata:</strong> {str(e)}<br><br>
+                            <strong>Not:</strong> API sunucusuna bağlanılamıyor. Lütfen daha sonra tekrar deneyin.
+                        </div>
+                        ''',
+                        model_name, version  # Keep the fields for user to modify
+                    )
                     
             except Exception as e:
                 logger.error(f"Model gönderimi hatası: {e}")
@@ -286,7 +324,8 @@ def add_submit_model_tab(block, api_service):
                     f'''
                     <div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">
                         ❌ <strong>Sistem Hatası!</strong><br>
-                        <strong>Hata:</strong> {str(e)}
+                        <strong>Hata:</strong> {str(e)}<br><br>
+                        <strong>Not:</strong> Lütfen sayfayı yenileyin ve tekrar deneyin.
                     </div>
                     ''',
                     model_name, version  # Keep the fields for user to modify
@@ -299,6 +338,13 @@ def add_submit_model_tab(block, api_service):
             outputs=[validation_output, validation_result]
         )
         
+        # Connect debug button
+        debug_btn.click(
+            test_connectivity,
+            inputs=[],
+            outputs=[debug_output]
+        )
+        
         # Update submit button state when validation result changes
         validation_result.change(
             update_submit_button,