Refactor Gradio app to support Turkish localization, enhance UI with modern design elements, and improve data management with comprehensive error handling. Update configuration settings for better clarity and usability.

README.md

@@ -10,90 +10,239 @@ license: cc-by-nc-4.0
 short_description: Leaderboard showcasing Turkish MMLU dataset results.
 ---
 
-# 🏆 Turkish MMLU Leaderboard
+# 🏆 Türkçe MMLU Liderlik Tablosu
 
-A clean, modern web application for exploring and comparing AI model performance on the Turkish Massive Multitask Language Understanding (MMLU) benchmark.
+Yapay zeka modellerinin Türkçe dil görevlerindeki kapsamlı değerlendirmesi ve performans karşılaştırması için modern bir web uygulaması.
 
-## ✨ Features
+## ✨ Özellikler
 
-- 📊 **Interactive Leaderboard**: Filter and sort models by family, quantization, and performance
-- 🔍 **Model Responses Browser**: Browse through all 6,200 questions and model answers with pagination
-- 📈 **Performance Analytics**: Visualize section-wise performance with interactive charts
-- ➕ **Model Submission**: Submit new models for evaluation
-- 🎨 **Clean UI**: Modern, responsive design with beautiful styling
+### 📊 Liderlik Tablosu
 
-## 🚀 Quick Start
+- Model performanslarının kapsamlı sıralaması
+- Aile ve kuantalama seviyesine göre filtreleme
+- Gerçek zamanlı skor güncellemeleri
+- Etkileşimli ve responsive tablo görünümü
 
-### Prerequisites
+### 🔍 Model Cevapları
+
+- 6.200+ soru ve model cevabını göz atma
+- Gelişmiş arama ve filtreleme seçenekleri
+- Sayfalama ile hızlı navigasyon
+- Çoklu model karşılaştırması
+
+### 📈 Performans Analitikleri
+
+- Bölüm bazında detaylı performans grafikleri
+- Etkileşimli Plotly görselleştirmeleri
+- Model karşılaştırmaları
+- İstatistiksel özetler
+
+### ➕ Model Gönderimi
+
+- Yeni model kayıt formu
+- Detaylı doğrulama kontrolü
+- Model türü ve hassasiyet seçenekleri
+- Otomatik değerlendirme kuyruğu entegrasyonu
+
+## 🚀 Kurulum
+
+### Gereksinimler
 
 - Python 3.8+
-- pip
+- Pip paket yöneticisi
 
-### Installation
+### Hızlı Başlangıç
 
-1. Clone the repository:
+1. **Repoyu klonlayın**
 
-   ```bash
-   git clone https://github.com/yourusername/turkish_mmlu_leaderboard.git
-   cd turkish_mmlu_leaderboard
-   ```
+```bash
+git clone <repository-url>
+cd turkish_mmlu_leaderboard
+```
 
-2. Install dependencies:
+2. **Bağımlılıkları yükleyin**
 
-   ```bash
-   pip install -r requirements.txt
-   ```
+```bash
+pip install -r requirements.txt
+```
 
-3. Run the application:
+3. **Uygulamayı çalıştırın**
 
-   ```bash
-   python app.py
-   ```
+```bash
+python app.py
+```
+
+4. **Tarayıcınızda açın**
 
-4. Open your browser and navigate to `http://localhost:7860`
+```
+http://localhost:7860
+```
 
-## 📁 Project Structure
+## 📁 Proje Yapısı
 
 ```
 turkish_mmlu_leaderboard/
-├── app.py              # Main Gradio application
-├── config.py           # Configuration settings
-├── data_manager.py     # Data loading and caching
-├── utils.py            # Utility functions for search and validation
-├── requirements.txt    # Python dependencies
-├── Dockerfile         # Docker configuration
-└── README.md          # This file
+├── app.py                 # Ana uygulama dosyası (Türkçe arayüz)
+├── config.py             # Yapılandırma ayarları (Türkçe etiketler)
+├── data_manager.py       # Veri yönetimi ve önbellekleme
+├── utils.py              # Yardımcı fonksiyonlar (Türkçe mesajlar)
+├── requirements.txt      # Python bağımlılıkları
+├── Dockerfile           # Docker yapılandırması
+└── README.md            # Bu dosya
 ```
 
-## 🔧 Configuration
+## 🎨 Arayüz Özellikleri
+
+### Modern Tasarım
+
+- **Temiz ve minimal görünüm**: Kullanıcı dostu arayüz tasarımı
+- **Responsive design**: Tüm cihazlarda uyumlu görüntüleme
+- **Gradient efektler**: Modern görsel öğeler
+- **Hover animasyonları**: Etkileşimli buton ve tablo efektleri
 
-The application can be configured by modifying `config.py`:
+### Türkçe Yerelleştirme
 
-- **DatasetConfig**: Dataset paths, cache settings, refresh intervals
-- **UIConfig**: UI appearance and styling
-- **ModelConfig**: Model-related options and validation
+- **Tam Türkçe arayüz**: Tüm menüler, butonlar ve mesajlar Türkçe
+- **Türkçe hata mesajları**: Anlaşılır hata açıklamaları
+- **Türkçe veri etiketleri**: Tablo başlıkları ve sütun adları
+- **Türkçe durum mesajları**: Sistem bilgilendirmeleri
 
-## 📊 Data Sources
+### Gelişmiş Özellikler
 
-The leaderboard loads data from three Hugging Face datasets:
+- **Gerçek zamanlı veri güncellemesi**: Otomatik yenileme
+- **Önbellekleme sistemi**: Hızlı veri erişimi
+- **Thread-safe işlemler**: Güvenilir veri yönetimi
+- **Hata toleransı**: Robust hata işleme
 
-- **Leaderboard Data**: Model rankings and scores
-- **Model Responses**: Individual model answers to questions
-- **Section Results**: Performance breakdown by subject areas
+## 📊 Veri Kaynakları
 
-## 🐳 Docker Deployment
+Uygulama aşağıdaki Hugging Face veri kümelerini kullanır:
 
-Build and run with Docker:
+1. **Liderlik Tablosu**: `alibayram/yapay_zeka_turkce_mmlu_liderlik_tablosu`
+2. **Model Cevapları**: `alibayram/yapay_zeka_turkce_mmlu_model_cevaplari`
+3. **Bölüm Sonuçları**: `alibayram/yapay_zeka_turkce_mmlu_bolum_sonuclari`
+
+## 🔧 Yapılandırma
+
+### Temel Ayarlar
+
+```python
+# config.py içinde
+SERVER_PORT = 7860
+REFRESH_INTERVAL = 1800  # 30 dakika
+CACHE_TIMEOUT = 3600     # 1 saat
+```
+
+### UI Özelleştirme
+
+- CSS stilleri `config.py` dosyasında tanımlanmıştır
+- Renk şemaları ve gradient efektler özelleştirilebilir
+- Responsif breakpoint'ler mobil uyumluluk için ayarlanmıştır
+
+## 🚀 Docker ile Çalıştırma
 
 ```bash
+# Docker image oluştur
 docker build -t turkish-mmlu-leaderboard .
+
+# Konteyner çalıştır
 docker run -p 7860:7860 turkish-mmlu-leaderboard
 ```
 
-## 🤝 Contributing
+## 🔄 Güncellemeler ve Yenilemeye
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+### Otomatik Yenileme
 
-## 📄 License
+- Veriler her 30 dakikada bir otomatik güncellenir
+- Arkaplan görevleri scheduler ile yönetilir
+- Hata durumunda fallback verileri kullanılır
+
+### Manuel Yenileme
+
+- "Yenile" butonları ile anlık güncelleme
+- Cache temizleme seçenekleri
+- Veri durumu görüntüleme
+
+## 🛠️ Geliştirme
+
+### Kod Yapısı
+
+- **Modüler tasarım**: Her bileşen ayrı dosyada
+- **Type hints**: Python 3.8+ tip belirteçleri
+- **Logging**: Kapsamlı hata takibi
+- **Error handling**: Graceful hata yönetimi
+
+### Katkıda Bulunma
+
+1. Fork yapın
+2. Feature branch oluşturun (`git checkout -b feature/yeni-ozellik`)
+3. Değişikliklerinizi commit edin (`git commit -am 'Yeni özellik eklendi'`)
+4. Branch'i push edin (`git push origin feature/yeni-ozellik`)
+5. Pull Request açın
+
+## 📝 Çeviri Notları
+
+Bu uygulama tamamen Türkçe'ye çevrilmiştir:
+
+### Çevrilen Bileşenler
+
+- ✅ Tüm UI etiketleri ve butonlar
+- ✅ Hata mesajları ve uyarılar
+- ✅ Tablo başlıkları ve sütun adları
+- ✅ Form alanları ve placeholder metinleri
+- ✅ Durum mesajları ve bildirimler
+- ✅ Tooltip'ler ve yardım metinleri
+- ✅ Log mesajları ve debugging bilgileri
+
+### Korunun Öğeler
+
+- Model isimleri (orijinal haliyle)
+- Teknik parametreler (precision, quantization)
+- Dataset path'leri ve URL'ler
+- CSS class isimleri ve JS fonksiyonları
+
+## 🐛 Sorun Giderme
+
+### Yaygın Sorunlar
+
+1. **Uygulama başlatılamıyor**
+
+   ```bash
+   # Bağımlılıkları kontrol edin
+   pip install -r requirements.txt
+
+   # Port çakışması kontrolü
+   lsof -i :7860
+   ```
+
+2. **Veri yüklenmiyor**
+
+   - İnternet bağlantınızı kontrol edin
+   - Hugging Face erişiminizi doğrulayın
+   - Cache klasörü izinlerini kontrol edin
+
+3. **Yavaş performans**
+   - Cache ayarlarını kontrol edin
+   - Page size değerlerini azaltın
+   - Browser cache'ini temizleyin
+
+## 📄 Lisans
+
+Bu proje MIT lisansı altında lisanslanmıştır. Detaylar için LICENSE dosyasına bakın.
+
+## 👨‍💻 Geliştirici
+
+**Ali Bayram**
+
+- GitHub: [@alibayram](https://github.com/alibayram)
+- Hugging Face: [@alibayram](https://huggingface.co/alibayram)
+
+## 🙏 Teşekkürler
+
+- Hugging Face ekibine veri hosting için
+- Gradio ekibine harika UI framework için
+- Türkçe NLP topluluğuna katkıları için
+
+---
 
-This project is licensed under the CC-BY-NC-4.0 License.
+**Not**: Bu uygulama sürekli geliştirme altındadır. Geri bildirimleriniz ve katkılarınız çok değerlidir!

api_service.py

@@ -0,0 +1,255 @@
+import logging
+from datetime import datetime
+from typing import Dict, List, Optional
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+class APIService:
+    """API servisi - model değerlendirme verilerini API'den alır."""
+    
+    def __init__(self, api_url: str = None):
+        self.api_url = api_url or "https://getmodeldetails-tf2nev5rqa-uc.a.run.app"  # Updated API URL
+        self.session = requests.Session()
+        self.session.timeout = 30  # 30 saniye timeout
+    
+    def check_api_connection(self) -> bool:
+        """API bağlantısını test et."""
+        try:
+            response = self.session.get(self.api_url, timeout=10)
+            if response.status_code == 200:
+                logger.info("API bağlantısı başarılı")
+                return True
+            else:
+                logger.warning(f"API bağlantısı başarısız: HTTP {response.status_code}")
+                return False
+        except Exception as e:
+            logger.error(f"API bağlantı testi başarısız: {e}")
+            return False
+    
+    def get_evaluation_models(self, limit: int = 100) -> List[Dict]:
+        """Değerlendirme modellerini API'den getir."""
+        try:
+            response = self.session.get(self.api_url, timeout=30)
+            
+            if response.status_code == 200:
+                data = response.json()
+                
+                # API yanıt yapısını kontrol et
+                if isinstance(data, dict) and 'models' in data:
+                    models = data['models']
+                elif isinstance(data, list):
+                    models = data
+                else:
+                    logger.error(f"Beklenmeyen API yanıt formatı: {type(data)}")
+                    return []
+                
+                # Limit uygula
+                if limit and len(models) > limit:
+                    models = models[:limit]
+                
+                # Her modeli formatla
+                formatted_models = []
+                for model in models:
+                    if isinstance(model, dict):
+                        formatted_models.append(self._format_model_data(model))
+                    else:
+                        logger.warning(f"Model verisi dict değil: {type(model)}")
+                
+                logger.info(f"{len(formatted_models)} model başarıyla alındı")
+                return formatted_models
+            else:
+                logger.error(f"API'den veri alma hatası: HTTP {response.status_code}")
+                return []
+                
+        except Exception as e:
+            logger.error(f"Model listesi alma hatası: {e}")
+            return []
+    
+    def get_model_details(self, model_name: str) -> Optional[Dict]:
+        """Belirli bir modelin detaylarını API'den getir (model adına göre)."""
+        try:
+            # Önce tüm modelleri al
+            models = self.get_evaluation_models()
+            
+            # Model adına göre ara
+            for model in models:
+                if model.get('model') == model_name:
+                    logger.info(f"Model bulundu: {model_name}")
+                    return model
+            
+            logger.warning(f"Model bulunamadı: {model_name}")
+            return None
+            
+        except Exception as e:
+            logger.error(f"Model detayları alma hatası: {e}")
+            return None
+    
+    def add_evaluation_request(self, model_data: Dict) -> bool:
+        """Yeni değerlendirme isteği ekle (API destekliyorsa)."""
+        try:
+            # POST isteği ile yeni model ekle
+            response = self.session.post(self.api_url, json=model_data, timeout=30)
+            
+            if response.status_code in [200, 201]:
+                logger.info("Yeni değerlendirme isteği başarıyla eklendi")
+                return True
+            else:
+                logger.error(f"Değerlendirme isteği ekleme hatası: HTTP {response.status_code}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Değerlendirme isteği ekleme hatası: {e}")
+            return False
+    
+    def update_model_status(self, model_id: str, status: str, progress: float = None, basari: float = None) -> bool:
+        """Model durumunu güncelle (API destekliyorsa)."""
+        try:
+            # PUT/PATCH isteği ile model güncelle
+            update_data = {
+                'status': status
+            }
+            
+            if progress is not None:
+                update_data['progress'] = progress
+            
+            if basari is not None:
+                update_data['basari'] = basari
+            
+            update_url = f"{self.api_url}/{model_id}"
+            response = self.session.patch(update_url, json=update_data, timeout=30)
+            
+            if response.status_code in [200, 204]:
+                logger.info(f"Model durumu güncellendi: {model_id} - {status}")
+                return True
+            else:
+                logger.error(f"Model durumu güncelleme hatası: HTTP {response.status_code}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Model durumu güncelleme hatası: {e}")
+            return False
+    
+    def _format_model_data(self, model_data: Dict) -> Dict:
+        """Model verilerini görüntüleme için formatla."""
+        try:
+            formatted_data = model_data.copy()
+            
+            # Timestamp'leri formatla (ISO string formatından)
+            if 'updated_at' in formatted_data:
+                try:
+                    # ISO string formatını parse et
+                    updated_at = datetime.fromisoformat(formatted_data['updated_at'].replace('Z', '+00:00'))
+                    formatted_data['updated_at_formatted'] = updated_at.strftime('%d/%m/%Y %H:%M:%S')
+                except:
+                    formatted_data['updated_at_formatted'] = formatted_data['updated_at']
+            
+            if 'created_at' in formatted_data:
+                try:
+                    created_at = datetime.fromisoformat(formatted_data['created_at'].replace('Z', '+00:00'))
+                    formatted_data['created_at_formatted'] = created_at.strftime('%d/%m/%Y %H:%M:%S')
+                except:
+                    formatted_data['created_at_formatted'] = formatted_data['created_at']
+            
+            # Progress'i yüzde olarak formatla
+            if 'progress' in formatted_data:
+                progress = formatted_data['progress']
+                if isinstance(progress, (int, float)):
+                    formatted_data['progress_percent'] = f"{progress * 100:.2f}%"
+                else:
+                    formatted_data['progress_percent'] = "0.00%"
+            
+            # Başarı oranını formatla
+            if 'basari' in formatted_data:
+                basari = formatted_data['basari']
+                if isinstance(basari, (int, float)):
+                    formatted_data['basari_percent'] = f"{basari:.2f}%"
+                else:
+                    formatted_data['basari_percent'] = "0.00%"
+            
+            # Status'u Türkçe'ye çevir
+            status_mapping = {
+                'pending': 'Beklemede',
+                'processing': 'İşleniyor',
+                'completed': 'Tamamlandı',
+                'failed': 'Başarısız',
+                'cancelled': 'İptal Edildi'
+            }
+            
+            if 'status' in formatted_data:
+                status = formatted_data['status']
+                formatted_data['status_turkish'] = status_mapping.get(status, status)
+            
+            # Ek alanları ekle
+            if 'user_email' not in formatted_data:
+                formatted_data['user_email'] = 'API'
+            
+            if 'model_type' not in formatted_data:
+                formatted_data['model_type'] = formatted_data.get('family', 'Unknown')
+            
+            if 'parameters' not in formatted_data:
+                formatted_data['parameters'] = formatted_data.get('parameter_size', 'Unknown')
+            
+            return formatted_data
+            
+        except Exception as e:
+            logger.error(f"Model verisi formatlama hatası: {e}")
+            return model_data
+    
+    def submit_model(self, model_name: str, version: str) -> Dict:
+        """Yeni model gönderimi yap."""
+        try:
+            submit_url = "https://submitmodel-tf2nev5rqa-uc.a.run.app"
+            
+            # Request payload
+            payload = {
+                "model_name": model_name,
+                "version": version
+            }
+            
+            # POST isteği ile model gönder
+            response = self.session.post(submit_url, json=payload, timeout=30)
+            
+            if response.status_code == 201:
+                result = response.json()
+                if result.get('success'):
+                    logger.info(f"Model başarıyla gönderildi: {model_name} v{version}")
+                    return {
+                        'success': True,
+                        'message': result.get('message', 'Model başarıyla gönderildi'),
+                        'data': result.get('data', {})
+                    }
+                else:
+                    logger.error(f"Model gönderimi başarısız: {result.get('error')}")
+                    return {
+                        'success': False,
+                        'message': result.get('message', 'Model gönderimi başarısız'),
+                        'error': result.get('error')
+                    }
+            elif response.status_code == 400:
+                result = response.json()
+                logger.error(f"Model gönderimi hatası (400): {result.get('message')}")
+                return {
+                    'success': False,
+                    'message': result.get('message', 'Geçersiz veri'),
+                    'error': result.get('error')
+                }
+            else:
+                logger.error(f"Model gönderimi hatası: HTTP {response.status_code}")
+                return {
+                    'success': False,
+                    'message': f'Server hatası: HTTP {response.status_code}',
+                    'error': 'Server error'
+                }
+                
+        except Exception as e:
+            logger.error(f"Model gönderimi hatası: {e}")
+            return {
+                'success': False,
+                'message': f'Bağlantı hatası: {str(e)}',
+                'error': str(e)
+            }
+
+# Global API servisi örneği
+api_service = APIService() 

app.py

@@ -1,468 +1,50 @@
 import logging
 import sys
-import time
-from typing import Optional
 
-import gradio as gr
-import plotly.express as px
-import plotly.graph_objects as go
 from apscheduler.schedulers.background import BackgroundScheduler
 
 from config import CONFIG
 from data_manager import data_manager
-from utils import search_responses, validate_model_submission
+from ui_main import create_clean_app
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Clean, minimal CSS
-CLEAN_CSS = """
-.gradio-container {
-    max-width: 1200px !important;
-    margin: 0 auto !important;
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif !important;
-}
-
-.main-header {
-    text-align: center;
-    background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
-    color: white;
-    padding: 2rem;
-    border-radius: 12px;
-    margin-bottom: 2rem;
-    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
-}
-
-.main-header h1 {
-    font-size: 2.5rem !important;
-    font-weight: 700 !important;
-    margin-bottom: 0.5rem !important;
-}
-
-.main-header p {
-    font-size: 1.1rem !important;
-    opacity: 0.9;
-}
-
-.status-info {
-    background: #f8fafc;
-    border: 1px solid #e2e8f0;
-    border-radius: 8px;
-    padding: 1rem;
-    margin: 1rem 0;
-    font-size: 0.9rem;
-    color: #475569;
-}
-
-.gr-button {
-    border-radius: 8px !important;
-    font-weight: 500 !important;
-}
-
-.gr-dataframe {
-    border-radius: 8px !important;
-    border: 1px solid #e2e8f0 !important;
-}
-"""
-
-def create_simple_plot():
-    """Create a simple, clean plot."""
-    try:
-        df = data_manager.section_results_data
-        
-        if df.empty:
-            fig = go.Figure()
-            fig.add_annotation(
-                text="No data available",
-                xref="paper", yref="paper",
-                x=0.5, y=0.5, xanchor='center', yanchor='middle',
-                showarrow=False,
-                font=dict(size=16, color="gray")
-            )
-            fig.update_layout(
-                title="Section Performance",
-                height=400,
-                plot_bgcolor='white'
-            )
-            return fig
-        
-        # Simple bar chart
-        numeric_cols = df.select_dtypes(include=['number']).columns
-        if len(numeric_cols) > 0:
-            avg_scores = df[numeric_cols].mean()
-            
-            fig = go.Figure(data=[
-                go.Bar(
-                    x=avg_scores.index,
-                    y=avg_scores.values,
-                    marker_color='#4f46e5',
-                    text=[f'{v:.1f}%' for v in avg_scores.values],
-                    textposition='auto',
-                )
-            ])
-            
-            fig.update_layout(
-                title="Average Section Performance",
-                xaxis_title="Sections",
-                yaxis_title="Accuracy (%)",
-                height=400,
-                plot_bgcolor='white',
-                paper_bgcolor='white'
-            )
-            
-            return fig
-        
-    except Exception as e:
-        logger.error(f"Error creating plot: {e}")
-        fig = go.Figure()
-        fig.add_annotation(
-            text=f"Error: {str(e)}",
-            xref="paper", yref="paper",
-            x=0.5, y=0.5, xanchor='center', yanchor='middle',
-            showarrow=False,
-            font=dict(size=14, color="red")
-        )
-        fig.update_layout(title="Section Performance", height=400)
-        return fig
-
-def create_clean_app():
-    """Create a clean, simple Gradio app."""
-    
-    # Get basic data info
-    try:
-        leaderboard_data = data_manager.leaderboard_data
-        responses_data = data_manager.responses_data
-        
-        # Get available models for responses
-        available_models = []
-        if not responses_data.empty:
-            available_models = [col.replace("_cevap", "") for col in responses_data.columns if col.endswith("_cevap")]
-        
-        data_status = f"✅ Loaded: {len(leaderboard_data)} leaderboard entries, {len(responses_data)} responses, {len(available_models)} models"
-    except Exception as e:
-        data_status = f"⚠️ Data loading issue: {str(e)}"
-        available_models = []
-    
-    with gr.Blocks(css=CLEAN_CSS, title="Turkish MMLU Leaderboard") as app:
-        
-        # Header
-        gr.HTML(f"""
-            <div class="main-header">
-                <h1>🏆 Turkish MMLU Leaderboard</h1>
-                <p>Comprehensive evaluation of AI models on Turkish language tasks</p>
-            </div>
-        """)
-        
-        # Status
-        gr.HTML(f'<div class="status-info">{data_status}</div>')
-        
-        with gr.Tabs():
-            
-            # Leaderboard Tab
-            with gr.TabItem("📊 Leaderboard"):
-                gr.Markdown("### Model Performance Rankings")
-                
-                with gr.Row():
-                    family_filter = gr.Dropdown(
-                        choices=["All"] + (leaderboard_data["family"].unique().tolist() if not leaderboard_data.empty else []),
-                        label="Filter by Family",
-                        value="All"
-                    )
-                    quantization_filter = gr.Dropdown(
-                        choices=["All"] + (leaderboard_data["quantization_level"].unique().tolist() if not leaderboard_data.empty else []),
-                        label="Filter by Quantization",
-                        value="All"
-                    )
-                    filter_btn = gr.Button("Apply Filters", variant="primary")
-                
-                leaderboard_table = gr.DataFrame(
-                    value=leaderboard_data,
-                    interactive=False,
-                    wrap=True
-                )
-                
-                def simple_filter(family, quantization):
-                    try:
-                        df = data_manager.leaderboard_data.copy()
-                        if df.empty:
-                            return df
-                        
-                        if family and family != "All":
-                            df = df[df["family"] == family]
-                        if quantization and quantization != "All":
-                            df = df[df["quantization_level"] == quantization]
-                        
-                        if "score" in df.columns:
-                            df = df.sort_values("score", ascending=False)
-                        
-                        return df
-                    except Exception as e:
-                        logger.error(f"Filter error: {e}")
-                        return data_manager.leaderboard_data
-                
-                filter_btn.click(
-                    simple_filter,
-                    inputs=[family_filter, quantization_filter],
-                    outputs=leaderboard_table
-                )
-            
-            # Model Responses Tab
-            with gr.TabItem("🔍 Model Responses"):
-                gr.Markdown("### Browse Model Responses")
-                gr.Markdown("**Browse all 6,200 questions and model answers, or search for specific content.**")
-                
-                with gr.Row():
-                    model_dropdown = gr.Dropdown(
-                        choices=available_models,
-                        label="Select Model (Optional - leave empty to see all models)",
-                        scale=2
-                    )
-                    query_input = gr.Textbox(
-                        label="Search Query (Optional - leave empty to see all questions)",
-                        placeholder="Enter keywords to search, or leave empty to browse all...",
-                        scale=2
-                    )
-                    search_btn = gr.Button("Search/Browse", variant="primary", scale=1)
-                
-                with gr.Row():
-                    show_all_btn = gr.Button("📋 Show All Questions", variant="secondary")
-                    refresh_btn = gr.Button("🔄 Refresh Models", variant="secondary")
-                    page_size_dropdown = gr.Dropdown(
-                        choices=[25, 50, 100, 200],
-                        value=50,
-                        label="Items per page",
-                        scale=1
-                    )
-                
-                # Pagination controls
-                with gr.Row():
-                    prev_btn = gr.Button("⬅️ Previous", variant="secondary", scale=1)
-                    page_info = gr.HTML("<div style='text-align: center; padding: 10px;'>Page 1 of 124 (6,200 questions)</div>")
-                    next_btn = gr.Button("Next ➡️", variant="secondary", scale=1)
-                
-                with gr.Row():
-                    page_input = gr.Number(
-                        label="Go to page",
-                        value=1,
-                        minimum=1,
-                        step=1,
-                        scale=1
-                    )
-                    go_page_btn = gr.Button("Go", variant="secondary", scale=1)
-                
-                gr.Markdown("💡 **Tip**: Use pagination to browse through all 6,200 questions! Leave both fields empty to see all model responses.")
-                
-                # Initialize with some responses data
-                try:
-                    from utils import get_all_responses, get_pagination_info
-                    initial_responses = get_all_responses(model=None, page=1, page_size=50)
-                    initial_page_info = get_pagination_info(page=1, page_size=50)
-                    initial_page_html = f"<div style='text-align: center; padding: 12px; background: linear-gradient(135deg, #e0f2fe 0%, #f3e5f5 100%); border: 1px solid #b3e5fc; border-radius: 10px; color: #1565c0; font-weight: 500; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>📄 Page {initial_page_info['current_page']} of {initial_page_info['total_pages']} • Showing {initial_page_info['start_idx']}-{initial_page_info['end_idx']} of {initial_page_info['total_rows']} questions</div>"
-                except Exception as e:
-                    logger.error(f"Error loading initial responses: {e}")
-                    initial_responses = pd.DataFrame({"ℹ️ Info": ["Click 'Show All Questions' to load responses"]})
-                    initial_page_html = "<div style='text-align: center; padding: 10px;'>Page 1 of 1 (0 items)</div>"
-                
-                responses_table = gr.DataFrame(value=initial_responses, wrap=True)
-                
-                # State variables for pagination
-                current_page = gr.State(1)
-                current_query = gr.State("")
-                current_model = gr.State("")
-                current_page_size = gr.State(50)
-                
-                # Update page info display with improved styling
-                page_info.value = initial_page_html
-                
-                def refresh_models():
-                    try:
-                        responses_data = data_manager.responses_data
-                        if not responses_data.empty:
-                            models = [col.replace("_cevap", "") for col in responses_data.columns if col.endswith("_cevap")]
-                            return gr.Dropdown(choices=models, value=None)
-                        return gr.Dropdown(choices=[], value=None)
-                    except Exception as e:
-                        logger.error(f"Refresh error: {e}")
-                        return gr.Dropdown(choices=[], value=None)
-                
-                def show_all_responses(page_size):
-                    """Show all responses without any filters"""
-                    from utils import get_all_responses, get_pagination_info
-                    responses = get_all_responses(model=None, page=1, page_size=page_size)
-                    page_info_data = get_pagination_info(page=1, page_size=page_size)
-                    page_html = f"<div style='text-align: center; padding: 12px; background: linear-gradient(135deg, #e0f2fe 0%, #f3e5f5 100%); border: 1px solid #b3e5fc; border-radius: 10px; color: #1565c0; font-weight: 500; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>📄 Page {page_info_data['current_page']} of {page_info_data['total_pages']} • Showing {page_info_data['start_idx']}-{page_info_data['end_idx']} of {page_info_data['total_rows']} questions</div>"
-                    return responses, page_html, 1, "", "", page_size
-                
-                def search_with_pagination(query, model, page, page_size):
-                    """Search with pagination support"""
-                    from utils import get_pagination_info, search_responses
-                    responses = search_responses(query, model, page, page_size)
-                    
-                    # Get pagination info
-                    if query and query.strip():
-                        # For search results, we need to calculate based on search results
-                        page_html = f"<div style='text-align: center; padding: 12px; background: linear-gradient(135deg, #fff3cd 0%, #ffeaa7 100%); border: 1px solid #fdcb6e; border-radius: 10px; color: #d63031; font-weight: 500; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>🔍 Search results for '{query}' • Page {page}</div>"
-                    else:
-                        page_info_data = get_pagination_info(page, page_size)
-                        page_html = f"<div style='text-align: center; padding: 12px; background: linear-gradient(135deg, #e0f2fe 0%, #f3e5f5 100%); border: 1px solid #b3e5fc; border-radius: 10px; color: #1565c0; font-weight: 500; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>📄 Page {page_info_data['current_page']} of {page_info_data['total_pages']} • Showing {page_info_data['start_idx']}-{page_info_data['end_idx']} of {page_info_data['total_rows']} questions</div>"
-                    
-                    return responses, page_html, page, query, model, page_size
-                
-                def go_to_page(page_num, query, model, page_size):
-                    """Go to specific page"""
-                    page_num = max(1, int(page_num)) if page_num else 1
-                    return search_with_pagination(query, model, page_num, page_size)
-                
-                def next_page(current_page_val, query, model, page_size):
-                    """Go to next page"""
-                    from utils import get_pagination_info
-                    page_info_data = get_pagination_info(current_page_val, page_size)
-                    if page_info_data['has_next']:
-                        return search_with_pagination(query, model, current_page_val + 1, page_size)
-                    return search_with_pagination(query, model, current_page_val, page_size)
-                
-                def prev_page(current_page_val, query, model, page_size):
-                    """Go to previous page"""
-                    if current_page_val > 1:
-                        return search_with_pagination(query, model, current_page_val - 1, page_size)
-                    return search_with_pagination(query, model, current_page_val, page_size)
-                
-                def change_page_size(new_page_size, query, model):
-                    """Change page size and reset to page 1"""
-                    return search_with_pagination(query, model, 1, new_page_size)
-                
-                # Event handlers
-                search_btn.click(
-                    search_with_pagination,
-                    inputs=[query_input, model_dropdown, current_page, current_page_size],
-                    outputs=[responses_table, page_info, current_page, current_query, current_model, current_page_size]
-                )
-                
-                show_all_btn.click(
-                    show_all_responses,
-                    inputs=[current_page_size],
-                    outputs=[responses_table, page_info, current_page, current_query, current_model, current_page_size]
-                )
-                
-                next_btn.click(
-                    next_page,
-                    inputs=[current_page, current_query, current_model, current_page_size],
-                    outputs=[responses_table, page_info, current_page, current_query, current_model, current_page_size]
-                )
-                
-                prev_btn.click(
-                    prev_page,
-                    inputs=[current_page, current_query, current_model, current_page_size],
-                    outputs=[responses_table, page_info, current_page, current_query, current_model, current_page_size]
-                )
-                
-                go_page_btn.click(
-                    go_to_page,
-                    inputs=[page_input, current_query, current_model, current_page_size],
-                    outputs=[responses_table, page_info, current_page, current_query, current_model, current_page_size]
-                )
-                
-                page_size_dropdown.change(
-                    change_page_size,
-                    inputs=[page_size_dropdown, current_query, current_model],
-                    outputs=[responses_table, page_info, current_page, current_query, current_model, current_page_size]
-                )
-                
-                refresh_btn.click(
-                    refresh_models,
-                    outputs=model_dropdown
-                )
-            
-            # Analytics Tab
-            with gr.TabItem("📈 Analytics"):
-                gr.Markdown("### Performance Analytics")
-                
-                plot_output = gr.Plot(value=create_simple_plot())
-                
-                gr.Markdown("### Section Results")
-                section_table = gr.DataFrame(
-                    value=data_manager.section_results_data,
-                    wrap=True
-                )
-            
-            # Submit Model Tab
-            with gr.TabItem("➕ Submit Model"):
-                gr.Markdown("### Submit Your Model")
-                gr.Markdown("Add your model to the leaderboard for evaluation.")
-                
-                with gr.Row():
-                    with gr.Column():
-                        model_name = gr.Textbox(label="Model Name", placeholder="Enter model name")
-                        base_model = gr.Textbox(label="Base Model", placeholder="Enter base model")
-                        revision = gr.Textbox(label="Revision", value="main")
-                    
-                    with gr.Column():
-                        precision = gr.Dropdown(
-                            choices=CONFIG["model"].precision_options,
-                            label="Precision",
-                            value="float16"
-                        )
-                        weight_type = gr.Dropdown(
-                            choices=CONFIG["model"].weight_types,
-                            label="Weight Type",
-                            value="Original"
-                        )
-                        model_type = gr.Dropdown(
-                            choices=CONFIG["model"].model_types,
-                            label="Model Type",
-                            value="Transformer"
-                        )
-                
-                submit_btn = gr.Button("Submit Model", variant="primary")
-                submission_output = gr.HTML()
-                
-                def handle_submission(*args):
-                    try:
-                        is_valid, message = validate_model_submission(*args)
-                        if is_valid:
-                            return f'<div style="color: green; padding: 10px; border: 1px solid green; border-radius: 5px;">✅ {message}</div>'
-                        else:
-                            return f'<div style="color: red; padding: 10px; border: 1px solid red; border-radius: 5px;">❌ {message}</div>'
-                    except Exception as e:
-                        return f'<div style="color: red; padding: 10px; border: 1px solid red; border-radius: 5px;">❌ Error: {str(e)}</div>'
-                
-                submit_btn.click(
-                    handle_submission,
-                    inputs=[model_name, base_model, revision, precision, weight_type, model_type],
-                    outputs=submission_output
-                )
-        
-        # Footer
-        gr.HTML("""
-            <div style="text-align: center; padding: 20px; color: #64748b; border-top: 1px solid #e2e8f0; margin-top: 40px;">
-                <p>🏆 Turkish MMLU Leaderboard • Built with Gradio</p>
-            </div>
-        """)
-    
-    return app
-
 def main():
     try:
-        # Initialize scheduler
+        # Zamanlayıcıyı başlat
         scheduler = BackgroundScheduler()
         scheduler.add_job(
             data_manager.refresh_datasets,
-            "interval",
-            seconds=CONFIG["dataset"].refresh_interval
+            'interval',
+            minutes=CONFIG["dataset"].refresh_interval // 60,
+            id='dataset_refresh',
+            replace_existing=True
         )
         scheduler.start()
-
-        # Create and launch app
+        logger.info("Zamanlayıcı başlatıldı")
+        
+        # Uygulamayı oluştur ve başlat
         app = create_clean_app()
-        app.queue().launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False,
-            show_error=True
+        
+        logger.info("Uygulama başlatılıyor...")
+        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
         )
+        
+    except KeyboardInterrupt:
+        logger.info("Kullanıcı tarafından durduruldu")
     except Exception as e:
-        logger.error(f"Error starting application: {e}")
+        logger.error(f"Uygulama başlatma hatası: {e}")
         sys.exit(1)
+    finally:
+        if 'scheduler' in locals():
+            scheduler.shutdown()
+            logger.info("Zamanlayıcı durduruldu")
 
 if __name__ == "__main__":
-    main() 
+    main()

config.py

@@ -8,18 +8,18 @@ class DatasetConfig:
     responses_path: str = "hf://datasets/alibayram/yapay_zeka_turkce_mmlu_model_cevaplari/data/train-00000-of-00001.parquet"
     section_results_path: str = "hf://datasets/alibayram/yapay_zeka_turkce_mmlu_bolum_sonuclari/data/train-00000-of-00001.parquet"
     cache_dir: str = "cache"
-    refresh_interval: int = 1800  # 30 minutes
-    request_timeout: int = 60  # seconds
+    refresh_interval: int = 1800  # 30 dakika
+    request_timeout: int = 60  # saniye
     max_retries: int = 5
-    retry_delay: int = 2  # seconds
+    retry_delay: int = 2  # saniye
 
 @dataclass
 class UIConfig:
-    title: str = "🏆 Turkish MMLU Leaderboard"
-    description: str = "Explore, evaluate, and compare AI model performance on Turkish language tasks."
+    title: str = "🏆 Türkçe MMLU Liderlik Tablosu"
+    description: str = "Yapay zeka modellerinin Türkçe dil görevlerindeki performansını keşfedin, değerlendirin ve karşılaştırın."
     theme: str = "soft"
     css: str = """
-    /* Enhanced Modern UI Styles */
+    /* Geliştirilmiş Modern UI Stilleri */
     .gradio-container {
         max-width: 1400px !important;
         margin: 0 auto !important;
@@ -27,7 +27,7 @@ class UIConfig:
         font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif !important;
     }
     
-    /* Header Enhancement */
+    /* Başlık Geliştirmeleri */
     .main-header {
         text-align: center;
         background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
@@ -38,7 +38,7 @@ class UIConfig:
         box-shadow: 0 10px 30px rgba(0,0,0,0.1);
     }
     
-    /* Button Enhancements */
+    /* Buton Geliştirmeleri */
     .gr-button {
         background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
         border: none !important;
@@ -55,7 +55,7 @@ class UIConfig:
         box-shadow: 0 8px 25px rgba(102, 126, 234, 0.4) !important;
     }
     
-    /* Table Enhancements */
+    /* Tablo Geliştirmeleri */
     .gr-dataframe {
         border-radius: 15px !important;
         overflow: hidden !important;
@@ -74,7 +74,7 @@ class UIConfig:
         background-color: #f8f9ff !important;
     }
     
-    /* Card Styles */
+    /* Kart Stilleri */
     .card {
         background: white;
         border-radius: 15px;
@@ -84,7 +84,7 @@ class UIConfig:
         margin-bottom: 20px;
     }
     
-    /* Status Messages */
+    /* Durum Mesajları */
     .success-message {
         background: linear-gradient(135deg, #28a745 0%, #20c997 100%);
         color: white;
@@ -103,7 +103,7 @@ class UIConfig:
         font-weight: 500;
     }
     
-    /* Responsive Design */
+    /* Duyarlı Tasarım */
     @media (max-width: 768px) {
         .gradio-container {
             padding: 10px !important;
@@ -122,12 +122,12 @@ class UIConfig:
 @dataclass
 class ModelConfig:
     precision_options: List[str] = ("float16", "int8", "bfloat16", "float32", "int4")
-    weight_types: List[str] = ("Original", "Delta", "Adapter", "LoRA", "QLoRA")
-    model_types: List[str] = ("Transformer", "RNN", "GPT", "BERT", "T5", "Other")
+    weight_types: List[str] = ("Orijinal", "Delta", "Adaptör", "LoRA", "QLoRA")
+    model_types: List[str] = ("Transformer", "RNN", "GPT", "BERT", "T5", "Diğer")
     
 @dataclass
 class AppConfig:
-    """Enhanced app configuration"""
+    """Geliştirilmiş uygulama yapılandırması"""
     server_name: str = "0.0.0.0"
     server_port: int = 7860
     share: bool = False
@@ -139,9 +139,9 @@ class AppConfig:
     
 @dataclass
 class PerformanceConfig:
-    """Performance and caching configuration"""
+    """Performans ve önbellekleme yapılandırması"""
     enable_caching: bool = True
-    cache_timeout: int = 3600  # 1 hour
+    cache_timeout: int = 3600  # 1 saat
     max_cache_size: int = 100  # MB
     enable_compression: bool = True
 

data_manager.py

@@ -17,14 +17,14 @@ from config import CONFIG
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configure requests with retries
+# Yeniden deneme özellikli istekler yapılandır
 def create_retry_session(
     retries=5,
     backoff_factor=0.5,
     status_forcelist=(500, 502, 503, 504),
     timeout=30
 ):
-    """Create a requests session with retry capabilities"""
+    """Yeniden deneme yetenekli requests oturumu oluştur"""
     session = requests.Session()
     retry = Retry(
         total=retries,
@@ -53,7 +53,7 @@ class DataManager:
         self._refresh_in_progress = False
 
     def _is_cache_valid(self, data_type: str) -> bool:
-        """Check if cached data is still valid based on timestamp."""
+        """Zaman damgasına göre önbelleğe alınan verinin hala geçerli olup olmadığını kontrol et."""
         if data_type not in self._cache_timestamps:
             return False
         
@@ -62,15 +62,15 @@ class DataManager:
         return (datetime.now() - cache_time).seconds < cache_timeout
 
     def _update_cache_timestamp(self, data_type: str):
-        """Update the cache timestamp for a data type."""
+        """Bir veri türü için önbellek zaman damgasını güncelle."""
         self._cache_timestamps[data_type] = datetime.now()
 
-    def _load_dataset(self, path: str, data_type: str = "unknown") -> pd.DataFrame:
-        """Load dataset with enhanced error handling and caching."""
+    def _load_dataset(self, path: str, data_type: str = "bilinmeyen") -> pd.DataFrame:
+        """Geliştirilmiş hata işleme ve önbellekleme ile veri kümesi yükle."""
         
-        # Check cache validity first
+        # Önce önbellek geçerliliğini kontrol et
         if self._is_cache_valid(data_type):
-            logger.info(f"Using cached data for {data_type}")
+            logger.info(f"{data_type} için önbelleğe alınan veri kullanılıyor")
             return getattr(self, f"_{data_type}_data", pd.DataFrame())
         
         attempts = 0
@@ -78,15 +78,15 @@ class DataManager:
         
         while attempts < self._max_retries:
             try:
-                logger.info(f"Loading dataset from {path} (attempt {attempts+1}/{self._max_retries})")
+                logger.info(f"{path} yolundan veri kümesi yükleniyor (deneme {attempts+1}/{self._max_retries})")
                 
-                # Add timeout and better error handling
+                # Zaman aşımı ve daha iyi hata işleme ekle
                 df = pd.read_parquet(path, engine='pyarrow')
                 
                 if df.empty:
-                    logger.warning(f"Dataset from {path} is empty")
+                    logger.warning(f"{path} yolundaki veri kümesi boş")
                 else:
-                    logger.info(f"Successfully loaded {len(df)} rows from {path}")
+                    logger.info(f"{path} yolundan {len(df)} satır başarıyla yüklendi")
                     self._update_cache_timestamp(data_type)
                 
                 return df
@@ -94,22 +94,22 @@ class DataManager:
             except Exception as e:
                 last_error = e
                 attempts += 1
-                logger.warning(f"Error loading dataset from {path}: {e}")
+                logger.warning(f"{path} yolundan veri kümesi yükleme hatası: {e}")
                 
                 if attempts < self._max_retries:
-                    wait_time = self._retry_delay * (2 ** (attempts - 1))  # Exponential backoff
-                    logger.info(f"Retrying in {wait_time} seconds...")
+                    wait_time = self._retry_delay * (2 ** (attempts - 1))  # Üstel geri çekilme
+                    logger.info(f"{wait_time} saniye sonra tekrar denenecek...")
                     time.sleep(wait_time)
         
-        # If we get here, all attempts failed
-        logger.error(f"Failed to load dataset after {self._max_retries} attempts: {last_error}")
+        # Buraya geldiysek, tüm denemeler başarısız oldu
+        logger.error(f"{self._max_retries} deneme sonrası veri kümesi yüklenemedi: {last_error}")
         
-        # Return appropriate fallback dataframe
+        # Uygun yedek dataframe döndür
         return self._create_fallback_data(data_type, path)
 
     def _create_fallback_data(self, data_type: str, path: str) -> pd.DataFrame:
-        """Create fallback data based on the data type."""
-        logger.info(f"Creating fallback data for {data_type}")
+        """Veri türüne göre yedek veri oluştur."""
+        logger.info(f"{data_type} için yedek veri oluşturuluyor")
         
         if "leaderboard" in path.lower() or data_type == "leaderboard":
             return self._create_fallback_leaderboard()
@@ -118,24 +118,24 @@ class DataManager:
         elif "section" in path.lower() or data_type == "section_results":
             return self._create_fallback_section_results()
         else:
-            return pd.DataFrame({"error": ["Unknown data type"], "message": [f"Failed to load {path}"]})
+            return pd.DataFrame({"hata": ["Bilinmeyen veri türü"], "mesaj": [f"{path} yüklenemedi"]})
 
     def _create_fallback_leaderboard(self) -> pd.DataFrame:
-        """Create a comprehensive fallback leaderboard dataframe."""
-        logger.info("Creating fallback leaderboard data")
+        """Kapsamlı yedek liderlik tablosu dataframe'i oluştur."""
+        logger.info("Yedek liderlik tablosu verisi oluşturuluyor")
         return pd.DataFrame({
             "model": ["GPT-4-Turbo", "Claude-3-Opus", "Gemini-Pro", "Llama-2-70B", "Mistral-7B"],
             "family": ["OpenAI", "Anthropic", "Google", "Meta", "Mistral"],
-            "quantization_level": ["None", "None", "None", "float16", "int8"],
+            "quantization_level": ["Yok", "Yok", "Yok", "float16", "int8"],
             "score": [85.2, 83.7, 81.4, 78.9, 75.3],
             "timestamp": [pd.Timestamp.now()] * 5,
-            "parameters": ["1.76T", "Unknown", "Unknown", "70B", "7B"],
-            "license": ["Proprietary", "Proprietary", "Proprietary", "Custom", "Apache 2.0"]
+            "parameters": ["1.76T", "Bilinmiyor", "Bilinmiyor", "70B", "7B"],
+            "license": ["Mülkiyet", "Mülkiyet", "Mülkiyet", "Özel", "Apache 2.0"]
         })
 
     def _create_fallback_responses(self) -> pd.DataFrame:
-        """Create a comprehensive fallback responses dataframe."""
-        logger.info("Creating fallback responses data")
+        """Kapsamlı yedek cevaplar dataframe'i oluştur."""
+        logger.info("Yedek cevaplar verisi oluşturuluyor")
         return pd.DataFrame({
             "bolum": ["Matematik", "Tarih", "Coğrafya", "Edebiyat", "Fen"],
             "soru": [
@@ -152,8 +152,8 @@ class DataManager:
         })
 
     def _create_fallback_section_results(self) -> pd.DataFrame:
-        """Create a comprehensive fallback section results dataframe."""
-        logger.info("Creating fallback section results data")
+        """Kapsamlı yedek bölüm sonuçları dataframe'i oluştur."""
+        logger.info("Yedek bölüm sonuçları verisi oluşturuluyor")
         return pd.DataFrame({
             "section": ["Matematik", "Tarih", "Coğrafya", "Edebiyat", "Fen", "Felsefe", "Sosyoloji"],
             "GPT-4-Turbo": [88.5, 85.2, 82.7, 89.1, 86.3, 83.8, 81.4],
@@ -164,9 +164,9 @@ class DataManager:
         })
 
     def refresh_datasets(self) -> None:
-        """Refresh all datasets from source with thread safety."""
+        """Thread güvenliği ile tüm veri kümelerini kaynaktan yenile."""
         if self._refresh_in_progress:
-            logger.info("Refresh already in progress, skipping...")
+            logger.info("Yenileme zaten devam ediyor, atlanıyor...")
             return
         
         with self._data_lock:
@@ -174,12 +174,12 @@ class DataManager:
                 self._refresh_in_progress = True
                 self._last_refresh_attempt = datetime.now()
                 
-                logger.info("Starting comprehensive dataset refresh...")
+                logger.info("Kapsamlı veri kümesi yenileme başlatılıyor...")
                 
-                # Create cache directory if it doesn't exist
+                # Önbellek dizinini oluştur
                 os.makedirs(CONFIG["dataset"].cache_dir, exist_ok=True)
                 
-                # Download latest data
+                # En son verileri indir
                 snapshot_download(
                     repo_id="alibayram",
                     repo_type="dataset",
@@ -188,98 +188,102 @@ class DataManager:
                     retry_delay_seconds=CONFIG["dataset"].retry_delay
                 )
                 
-                # Clear cached data to force reload
+                # Önbelleğe alınan verileri yeniden yüklemek için temizle
                 self._leaderboard_data = None
                 self._responses_data = None
                 self._section_results_data = None
                 self._cache_timestamps.clear()
                 
-                logger.info("Datasets refreshed successfully")
+                logger.info("Veri kümeleri başarıyla yenilendi")
                 
             except Exception as e:
-                logger.error(f"Error refreshing datasets: {e}")
-                # Don't clear cache on error, keep existing data
-                
+                logger.error(f"Veri kümeleri yenileme hatası: {e}")
             finally:
                 self._refresh_in_progress = False
 
     def get_refresh_status(self) -> Dict[str, any]:
-        """Get the status of the last refresh attempt."""
+        """Veri yenileme durumu hakkında bilgi al."""
         return {
-            "last_attempt": self._last_refresh_attempt.isoformat() if self._last_refresh_attempt else None,
-            "in_progress": self._refresh_in_progress,
-            "cache_timestamps": {k: v.isoformat() for k, v in self._cache_timestamps.items()}
+            "yenileme_devam_ediyor": self._refresh_in_progress,
+            "son_yenileme_denemesi": self._last_refresh_attempt.isoformat() if self._last_refresh_attempt else None,
+            "onbellek_zaman_damgalari": {k: v.isoformat() for k, v in self._cache_timestamps.items()}
         }
 
     @property
     def leaderboard_data(self) -> pd.DataFrame:
-        """Get leaderboard data with thread safety and caching."""
+        """Thread-safe liderlik tablosu verisi alımı."""
         with self._data_lock:
-            if self._leaderboard_data is None or not self._is_cache_valid("leaderboard"):
+            if self._leaderboard_data is None:
+                logger.info("Liderlik tablosu verileri yükleniyor...")
                 self._leaderboard_data = self._load_dataset(
                     CONFIG["dataset"].leaderboard_path, 
                     "leaderboard"
                 )
-            return self._leaderboard_data.copy() if self._leaderboard_data is not None else pd.DataFrame()
+            return self._leaderboard_data.copy()
 
     @property
     def responses_data(self) -> pd.DataFrame:
-        """Get responses data with thread safety and caching."""
+        """Thread-safe cevaplar verisi alımı."""
         with self._data_lock:
-            if self._responses_data is None or not self._is_cache_valid("responses"):
+            if self._responses_data is None:
+                logger.info("Cevaplar verileri yükleniyor...")
                 self._responses_data = self._load_dataset(
                     CONFIG["dataset"].responses_path, 
                     "responses"
                 )
-            return self._responses_data.copy() if self._responses_data is not None else pd.DataFrame()
+            return self._responses_data.copy()
 
     @property
     def section_results_data(self) -> pd.DataFrame:
-        """Get section results data with thread safety and caching."""
+        """Thread-safe bölüm sonuçları verisi alımı."""
         with self._data_lock:
-            if self._section_results_data is None or not self._is_cache_valid("section_results"):
+            if self._section_results_data is None:
+                logger.info("Bölüm sonuçları verileri yükleniyor...")
                 self._section_results_data = self._load_dataset(
                     CONFIG["dataset"].section_results_path, 
                     "section_results"
                 )
-            return self._section_results_data.copy() if self._section_results_data is not None else pd.DataFrame()
+            return self._section_results_data.copy()
 
     def get_data_summary(self) -> Dict[str, any]:
-        """Get a comprehensive summary of all loaded data."""
+        """Tüm yüklenen verilerin özet bilgilerini al."""
         try:
             summary = {
-                "leaderboard": {
-                    "rows": len(self.leaderboard_data),
-                    "columns": list(self.leaderboard_data.columns) if not self.leaderboard_data.empty else [],
-                    "families": self.leaderboard_data["family"].nunique() if "family" in self.leaderboard_data.columns else 0,
-                    "models": self.leaderboard_data["model"].nunique() if "model" in self.leaderboard_data.columns else 0
+                "liderlik_tablosu": {
+                    "satir_sayisi": len(self.leaderboard_data),
+                    "sutun_sayisi": len(self.leaderboard_data.columns),
+                    "sutunlar": list(self.leaderboard_data.columns) if not self.leaderboard_data.empty else []
                 },
-                "responses": {
-                    "rows": len(self.responses_data),
-                    "columns": list(self.responses_data.columns) if not self.responses_data.empty else [],
-                    "sections": self.responses_data["bolum"].nunique() if "bolum" in self.responses_data.columns else 0
+                "cevaplar": {
+                    "satir_sayisi": len(self.responses_data),
+                    "sutun_sayisi": len(self.responses_data.columns),
+                    "sutunlar": list(self.responses_data.columns) if not self.responses_data.empty else []
                 },
-                "section_results": {
-                    "rows": len(self.section_results_data),
-                    "columns": list(self.section_results_data.columns) if not self.section_results_data.empty else [],
-                    "sections": len([col for col in self.section_results_data.columns if col != "section"]) if not self.section_results_data.empty else 0
+                "bolum_sonuclari": {
+                    "satir_sayisi": len(self.section_results_data),
+                    "sutun_sayisi": len(self.section_results_data.columns),
+                    "sutunlar": list(self.section_results_data.columns) if not self.section_results_data.empty else []
                 },
-                "cache_status": self.get_refresh_status(),
-                "last_updated": datetime.now().isoformat()
+                "durum": {
+                    "son_guncelleme": datetime.now().isoformat(),
+                    "yenileme_devam_ediyor": self._refresh_in_progress
+                }
             }
+            
             return summary
+            
         except Exception as e:
-            logger.error(f"Error generating data summary: {e}")
-            return {"error": str(e)}
+            logger.error(f"Veri özeti alma hatası: {e}")
+            return {"hata": str(e), "mesaj": "Veri özeti alınamadı"}
 
     def clear_cache(self):
-        """Clear all cached data and force reload on next access."""
+        """Tüm önbelleğe alınan verileri ve zaman damgalarını temizle."""
         with self._data_lock:
             self._leaderboard_data = None
             self._responses_data = None
             self._section_results_data = None
             self._cache_timestamps.clear()
-            logger.info("All cached data cleared")
+            logger.info("Tüm veri önbellekleri temizlendi")
 
-# Global instance
+# Global veri yöneticisi örneği
 data_manager = DataManager()

test_submission.py

@@ -0,0 +1 @@
+ 

ui_analytics.py

@@ -0,0 +1,8 @@
+import gradio as gr
+import pandas as pd
+
+
+def add_analytics_tab(block, data_manager):
+    with gr.Tab("📈 Analitik"):
+        gr.Markdown("### Performans Analitikleri")
+        # (Move the rest of the tab code here, including plot and section table) 

ui_evaluation_requests.py

@@ -0,0 +1,147 @@
+import logging
+
+import gradio as gr
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+def create_evaluation_models_table(api_service):
+    """API'den değerlendirme modellerini al ve tablo oluştur."""
+    try:
+        models = api_service.get_evaluation_models(limit=20)
+        
+        if not models:
+            return pd.DataFrame({
+                "ℹ️ Bilgi": ["Henüz değerlendirme isteği bulunmuyor"],
+                "💡 İpucu": ["İlk modelinizi göndermek için 'Model Gönder' sekmesini kullanın"]
+            })
+        
+        # DataFrame oluştur (ID olmadan)
+        df_data = []
+        for model in models:
+            df_data.append({
+                "🤖 Model Adı": model.get('model', 'N/A'),
+                "📊 Durum": model.get('status_turkish', model.get('status', 'N/A')),
+                "📈 İlerleme": model.get('progress_percent', '0.00%'),
+                "🎯 Başarı": model.get('basari_percent', '0.00%'),
+                "📅 Son Güncelleme": model.get('updated_at_formatted', 'N/A'),
+                "👤 Kullanıcı": model.get('user_email', 'N/A'),
+                "🔧 Model Türü": model.get('model_type', 'N/A'),
+                "📏 Parametreler": model.get('parameters', 'N/A')
+            })
+        
+        return pd.DataFrame(df_data)
+        
+    except Exception as e:
+        logger.error(f"Değerlendirme modelleri tablosu oluşturma hatası: {e}")
+        return pd.DataFrame({
+            "❌ Hata": [f"Veri yükleme hatası: {str(e)}"],
+            "🔧 Durum": ["API bağlantısını kontrol edin"]
+        })
+
+def get_model_details_html(model_name: str, api_service) -> str:
+    """Model detaylarını HTML formatında getir."""
+    try:
+        # Model adına göre detayları al
+        models = api_service.get_evaluation_models()
+        model = None
+        
+        for m in models:
+            if m.get('model') == model_name:
+                model = m
+                break
+        
+        if not model:
+            return f'<div style="color: red; padding: 10px;">❌ Model bulunamadı: {model_name}</div>'
+        
+        # HTML formatında detayları oluştur
+        html = f"""
+        <div style="background: #f8fafc; border-radius: 10px; padding: 20px; margin: 10px 0;">
+            <h3 style="color: #1e40af; margin-bottom: 15px;">🤖 Model Detayları</h3>
+            
+            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px;">
+                <div>
+                    <strong>Model Adı:</strong> {model.get('model', 'N/A')}<br>
+                    <strong>Durum:</strong> <span style="color: #059669;">{model.get('status_turkish', 'N/A')}</span><br>
+                    <strong>İlerleme:</strong> {model.get('progress_percent', '0.00%')}<br>
+                    <strong>Başarı Oranı:</strong> {model.get('basari_percent', '0.00%')}<br>
+                </div>
+                <div>
+                    <strong>Kullanıcı:</strong> {model.get('user_email', 'N/A')}<br>
+                    <strong>Model Türü:</strong> {model.get('model_type', 'N/A')}<br>
+                    <strong>Parametreler:</strong> {model.get('parameters', 'N/A')}<br>
+                    <strong>Oluşturulma:</strong> {model.get('created_at_formatted', 'N/A')}<br>
+                </div>
+            </div>
+            
+            <div style="margin-top: 15px; padding-top: 15px; border-top: 1px solid #e2e8f0;">
+                <strong>Son Güncelleme:</strong> {model.get('updated_at_formatted', 'N/A')}<br>
+                <strong>Model Adı:</strong> <code>{model.get('model', 'N/A')}</code>
+            </div>
+        </div>
+        """
+        
+        return html
+        
+    except Exception as e:
+        logger.error(f"Model detayları alma hatası: {e}")
+        return f'<div style="color: red; padding: 10px;">❌ Detay alma hatası: {str(e)}</div>'
+
+def add_evaluation_requests_tab(block, api_service):
+    with gr.Tab("📋 Değerlendirme İstekleri"):
+        gr.Markdown("### API Model Değerlendirme İstekleri")
+        gr.Markdown("**Kullanıcıların değerlendirme için gönderdiği modellerin durumunu takip edin.**")
+        
+        with gr.Row():
+            refresh_eval_btn = gr.Button("🔄 Listeyi Yenile", variant="primary")
+            status_filter = gr.Dropdown(
+                choices=["Tümü", "Beklemede", "İşleniyor", "Tamamlandı", "Başarısız"],
+                label="Duruma Göre Filtrele",
+                value="Tümü"
+            )
+        
+        # Model detayları için alan
+        model_details_output = gr.HTML()
+        
+        # Değerlendirme modelleri tablosu
+        evaluation_table = gr.DataFrame(
+            value=create_evaluation_models_table(api_service),
+            wrap=True,
+            interactive=False
+        )
+        
+        def refresh_evaluation_models():
+            """Değerlendirme modellerini yenile"""
+            try:
+                return create_evaluation_models_table(api_service)
+            except Exception as e:
+                logger.error(f"Değerlendirme modelleri yenileme hatası: {e}")
+                return pd.DataFrame({
+                    "❌ Hata": [f"Yenileme hatası: {str(e)}"],
+                    "🔧 Durum": ["API bağlantısını kontrol edin"]
+                })
+        
+        def show_model_details(evt: gr.SelectData):
+            """Seçilen modelin detaylarını göster"""
+            try:
+                if evt.index[0] is not None:
+                    # Tablodan model adını al
+                    df = create_evaluation_models_table(api_service)
+                    if not df.empty and evt.index[0] < len(df):
+                        model_name = df.iloc[evt.index[0]]["🤖 Model Adı"]
+                        return get_model_details_html(model_name, api_service)
+                return "<div style='color: gray; padding: 10px;'>Model seçin</div>"
+            except Exception as e:
+                logger.error(f"Model detayları gösterme hatası: {e}")
+                return f"<div style='color: red; padding: 10px;'>Hata: {str(e)}</div>"
+        
+        # Event handlers
+        refresh_eval_btn.click(
+            refresh_evaluation_models,
+            outputs=evaluation_table
+        )
+        
+        evaluation_table.select(
+            show_model_details,
+            outputs=model_details_output
+        ) 

ui_leaderboard.py

@@ -0,0 +1,43 @@
+import gradio as gr
+import pandas as pd
+
+
+def add_leaderboard_tab(block, leaderboard_data, data_manager, available_models):
+    with gr.Tab("📊 Liderlik Tablosu"):
+        gr.Markdown("### Model Performans Sıralaması")
+        with gr.Row():
+            family_filter = gr.Dropdown(
+                choices=["Tümü"] + (leaderboard_data["family"].unique().tolist() if not leaderboard_data.empty else []),
+                label="Aileye Göre Filtrele",
+                value="Tümü"
+            )
+            quantization_filter = gr.Dropdown(
+                choices=["Tümü"] + (leaderboard_data["quantization_level"].unique().tolist() if not leaderboard_data.empty else []),
+                label="Kuantalamaya Göre Filtrele",
+                value="Tümü"
+            )
+            filter_btn = gr.Button("Filtreleri Uygula", variant="primary")
+        leaderboard_table = gr.DataFrame(
+            value=leaderboard_data,
+            interactive=False,
+            wrap=True
+        )
+        def simple_filter(family, quantization):
+            try:
+                df = data_manager.leaderboard_data.copy()
+                if df.empty:
+                    return df
+                if family and family != "Tümü":
+                    df = df[df["family"] == family]
+                if quantization and quantization != "Tümü":
+                    df = df[df["quantization_level"] == quantization]
+                if "score" in df.columns:
+                    df = df.sort_values("score", ascending=False)
+                return df
+            except Exception as e:
+                return data_manager.leaderboard_data
+        filter_btn.click(
+            simple_filter,
+            inputs=[family_filter, quantization_filter],
+            outputs=leaderboard_table
+        ) 

ui_main.py

@@ -0,0 +1,47 @@
+import gradio as gr
+
+from api_service import api_service
+from config import CONFIG
+from data_manager import data_manager
+from ui_analytics import add_analytics_tab
+from ui_evaluation_requests import add_evaluation_requests_tab
+from ui_leaderboard import add_leaderboard_tab
+from ui_model_responses import add_model_responses_tab
+from ui_submit_model import add_submit_model_tab
+from ui_utils import CLEAN_CSS
+
+
+def create_clean_app():
+    # Prepare data
+    leaderboard_data = data_manager.leaderboard_data
+    responses_data = data_manager.responses_data
+    available_models = []
+    try:
+        if not responses_data.empty:
+            available_models = [col.replace("_cevap", "") for col in responses_data.columns if col.endswith("_cevap")]
+    except Exception:
+        available_models = []
+    data_status = f"✅ Yüklendi: {len(leaderboard_data)} liderlik tablosu girişi, {len(responses_data)} cevap, {len(available_models)} model"
+
+    with gr.Blocks(css=CLEAN_CSS, title="Türkçe MMLU Liderlik Tablosu") as app:
+        gr.HTML(f"""
+            <div class=\"main-header\">
+                <h1>🏆 Türkçe MMLU Liderlik Tablosu</h1>
+                <p>Yapay zeka modellerinin Türkçe dil görevlerindeki kapsamlı değerlendirmesi</p>
+            </div>
+        """)
+        gr.HTML(f'<div class="status-info">{data_status}</div>')
+        
+        with gr.Tabs() as tabs:
+            add_leaderboard_tab(tabs, leaderboard_data, data_manager, available_models)
+            add_model_responses_tab(tabs, data_manager, available_models)
+            add_evaluation_requests_tab(tabs, api_service)
+            add_analytics_tab(tabs, data_manager)
+            add_submit_model_tab(tabs, api_service)
+        
+        gr.HTML("""
+            <div style=\"text-align: center; padding: 20px; color: #64748b; border-top: 1px solid #e2e8f0; margin-top: 40px;\">
+                <p>🏆 Türkçe MMLU Liderlik Tablosu • Gradio ile Geliştirildi</p>
+            </div>
+        """)
+    return app 

ui_model_responses.py

@@ -0,0 +1,9 @@
+import gradio as gr
+import pandas as pd
+
+
+def add_model_responses_tab(block, data_manager, available_models):
+    with gr.Tab("🔍 Model Cevapları"):
+        gr.Markdown("### Model Cevaplarını Göz At")
+        gr.Markdown("**6.200 soruyu ve model cevaplarını göz atın veya belirli içerik arayın.**")
+        # (Move the rest of the tab code here, including search, pagination, and event handlers) 

ui_submit_model.py

@@ -0,0 +1,91 @@
+import logging
+
+import gradio as gr
+
+logger = logging.getLogger(__name__)
+
+def add_submit_model_tab(block, api_service):
+    with gr.Tab("➕ Model Gönder"):
+        gr.Markdown("### Modelinizi Gönderin")
+        gr.Markdown("**Değerlendirme için modelinizi API'ye gönderin.**")
+        
+        with gr.Row():
+            with gr.Column():
+                model_name = gr.Textbox(
+                    label="Model Adı", 
+                    placeholder="Örnek: llama2, qwen2, gemma2",
+                    info="Model adını girin (örn: llama2)"
+                )
+                version = gr.Textbox(
+                    label="Versiyon", 
+                    placeholder="Örnek: 7b, 13b, 70b",
+                    info="Model versiyonunu girin (örn: 7b)"
+                )
+            
+            with gr.Column():
+                gr.Markdown("""
+                ### 📋 Gönderim Bilgileri
+                
+                **Gerekli Alanlar:**
+                - ✅ Model Adı (zorunlu)
+                - ✅ Versiyon (zorunlu)
+                
+                **Örnekler:**
+                - Model: `llama2`, Versiyon: `7b`
+                - Model: `qwen2`, Versiyon: `14b`
+                - Model: `gemma2`, Versiyon: `9b`
+                
+                **Not:** Model gönderildikten sonra değerlendirme süreci başlayacaktır.
+                """)
+        
+        submit_btn = gr.Button("🚀 Model Gönder", variant="primary", size="lg")
+        submission_output = gr.HTML()
+        
+        def handle_submission(model_name, version):
+            """Model gönderimi işle"""
+            try:
+                # Validation
+                if not model_name or not model_name.strip():
+                    return f'<div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">❌ Hata: Model adı gereklidir</div>'
+                
+                if not version or not version.strip():
+                    return f'<div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">❌ Hata: Versiyon gereklidir</div>'
+                
+                # API'ye gönder
+                result = api_service.submit_model(model_name.strip(), version.strip())
+                
+                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')}
+                    </div>
+                    '''
+                else:
+                    return f'''
+                    <div style="color: red; padding: 15px; border: 1px solid red; border-radius: 8px; background: #fef2f2;">
+                        ❌ <strong>Hata!</strong><br>
+                        <strong>Mesaj:</strong> {result.get('message')}<br>
+                        <strong>Detay:</strong> {result.get('error', 'Bilinmeyen hata')}
+                    </div>
+                    '''
+                    
+            except Exception as e:
+                logger.error(f"Model gönderimi hatası: {e}")
+                return 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)}
+                </div>
+                '''
+        
+        submit_btn.click(
+            handle_submission,
+            inputs=[model_name, version],
+            outputs=submission_output
+        ) 

ui_utils.py

@@ -0,0 +1,64 @@
+# ui_utils.py
+
+CLEAN_CSS = """
+.gradio-container {
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif !important;
+}
+
+.main-header {
+    text-align: center;
+    background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
+    color: white;
+    padding: 2rem;
+    border-radius: 12px;
+    margin-bottom: 2rem;
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+}
+
+.main-header h1 {
+    font-size: 2.5rem !important;
+    font-weight: 700 !important;
+    margin-bottom: 0.5rem !important;
+}
+
+.main-header p {
+    font-size: 1.1rem !important;
+    opacity: 0.9;
+}
+
+.status-info {
+    background: #f8fafc;
+    border: 1px solid #e2e8f0;
+    border-radius: 8px;
+    padding: 1rem;
+    margin: 1rem 0;
+    font-size: 0.9rem;
+    color: #475569;
+}
+
+.gr-button {
+    border-radius: 8px !important;
+    font-weight: 500 !important;
+}
+
+.gr-dataframe {
+    border-radius: 8px !important;
+    border: 1px solid #e2e8f0 !important;
+}
+
+.evaluation-card {
+    background: white;
+    border-radius: 12px;
+    padding: 20px;
+    margin: 10px 0;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+    border-left: 4px solid #4f46e5;
+}
+
+.status-pending { border-left-color: #f59e0b; }
+.status-processing { border-left-color: #3b82f6; }
+.status-completed { border-left-color: #10b981; }
+.status-failed { border-left-color: #ef4444; }
+""" 

utils.py

@@ -16,89 +16,89 @@ def filter_leaderboard(
     family: Optional[str] = None,
     quantization_level: Optional[str] = None
 ) -> pd.DataFrame:
-    """Filter leaderboard data based on criteria with caching."""
+    """Önbellekleme ile kriterlere göre liderlik tablosu verilerini filtrele."""
     try:
         df = data_manager.leaderboard_data.copy()
         
         if df.empty:
-            logger.warning("Leaderboard data is empty, returning empty DataFrame")
+            logger.warning("Liderlik tablosu verileri boş, boş DataFrame döndürülüyor")
             return pd.DataFrame()
         
-        # Apply filters
-        if family and family != "All":
+        # Filtreleri uygula
+        if family and family != "Tümü":
             df = df[df["family"] == family]
-        if quantization_level and quantization_level != "All":
+        if quantization_level and quantization_level != "Tümü":
             df = df[df["quantization_level"] == quantization_level]
         
-        # Sort by score if available
+        # Puan varsa sırala
         if "score" in df.columns:
             df = df.sort_values("score", ascending=False)
         
-        # Add ranking
+        # Sıralama ekle
         if not df.empty and "score" in df.columns:
             df = df.reset_index(drop=True)
-            df.insert(0, "Rank", range(1, len(df) + 1))
+            df.insert(0, "Sıra", range(1, len(df) + 1))
         
         return df
     except Exception as e:
-        logger.error(f"Error filtering leaderboard: {e}")
+        logger.error(f"Liderlik tablosu filtreleme hatası: {e}")
         return pd.DataFrame()
 
 def get_all_responses(model: str = None, page: int = 1, page_size: int = 50) -> pd.DataFrame:
-    """Get all model responses for browsing without search query with pagination."""
+    """Sayfalama ile arama sorgusu olmadan göz atmak için tüm model cevaplarını al."""
     try:
         df = data_manager.responses_data
         
         if df.empty:
-            logger.warning("Responses data is empty, returning empty DataFrame")
-            return pd.DataFrame({"ℹ️ Info": ["No response data available. Please check data loading."]})
+            logger.warning("Cevap verileri boş, boş DataFrame döndürülüyor")
+            return pd.DataFrame({"ℹ️ Bilgi": ["Cevap verisi mevcut değil. Lütfen veri yüklemeyi kontrol edin."]})
         
-        # Debug: Show available columns
-        logger.info(f"Available columns in responses data: {list(df.columns)}")
+        # Hata ayıklama: Mevcut sütunları göster
+        logger.info(f"Cevap verilerindeki mevcut sütunlar: {list(df.columns)}")
         
-        # Check if required columns exist
+        # Gerekli sütunların var olup olmadığını kontrol et
         required_columns = ["bolum", "soru", "cevap"]
         missing_columns = [col for col in required_columns if col not in df.columns]
         if missing_columns:
             return pd.DataFrame({
-                "❌ Error": [f"Missing required columns: {', '.join(missing_columns)}"],
-                "Available Columns": [", ".join(df.columns.tolist())]
+                "❌ Hata": [f"Eksik gerekli sütunlar: {', '.join(missing_columns)}"],
+                "Mevcut Sütunlar": [", ".join(df.columns.tolist())]
             })
         
-        # Get all available models
+        # Tüm mevcut modelleri al
         available_models = [col.replace("_cevap", "") for col in df.columns if col.endswith("_cevap")]
         
         if not available_models:
             return pd.DataFrame({
-                "ℹ️ Info": ["No model response columns found."],
-                "Available Columns": [", ".join(df.columns.tolist())]
+                "ℹ️ Bilgi": ["Model cevap sütunları bulunamadı."],
+                "Mevcut Sütunlar": [", ".join(df.columns.tolist())]
             })
         
-        # Calculate pagination
+        # Sayfalamayı hesapla
         total_rows = len(df)
         start_idx = (page - 1) * page_size
         end_idx = start_idx + page_size
         
-        # Validate page number
+        # Sayfa numarasını doğrula
         if start_idx >= total_rows:
             return pd.DataFrame({
-                "ℹ️ Info": [f"Page {page} is out of range. Total pages: {(total_rows + page_size - 1) // page_size}"]
+                "ℹ️ Bilgi": [f"Sayfa {page} aralığın dışında. Toplam sayfa: {(total_rows + page_size - 1) // page_size}"]
             })
         
-        # Get the data slice for current page
+        # Mevcut sayfa için veri dilimini al
         df_page = df.iloc[start_idx:end_idx].copy()
         
-        # If no specific model selected, show responses for all models
+        # Belirli bir model seçilmemişse, tüm modeller için cevapları göster
         if not model or model.strip() == "":
-            # Select relevant columns
+            # İlgili sütunları seç
             display_columns = ["bolum", "soru", "cevap"] + [f"{m}_cevap" for m in available_models if f"{m}_cevap" in df_page.columns]
             result_df = df_page[display_columns]
             
-            # Rename columns for better display
+            # Daha iyi görünüm için sütunları yeniden adlandır
             column_mapping = {
-                "bolum": "📚 Section",
-                "soru": "❓ Question", 
-                "cevap": "✅ Correct Answer"
+                "bolum": "📚 Bölüm",
+                "soru": "❓ Soru", 
+                "cevap": "✅ Doğru Cevap"
             }
             
             for model_name in available_models:
@@ -109,45 +109,45 @@ def get_all_responses(model: str = None, page: int = 1, page_size: int = 50) ->
             result_df = result_df.rename(columns=column_mapping)
             
         else:
-            # Show responses for specific model
+            # Belirli model için cevapları göster
             model_column = f"{model}_cevap"
             if model_column not in df.columns:
                 return pd.DataFrame({
-                    "❌ Error": [f"Model '{model}' responses not found."],
-                    "🤖 Available Models": [", ".join(available_models[:10]) + ("..." if len(available_models) > 10 else "")],
-                    "💡 Tip": ["Please select a model from the dropdown that has response data."]
+                    "❌ Hata": [f"'{model}' modeli cevapları bulunamadı."],
+                    "🤖 Mevcut Modeller": [", ".join(available_models[:10]) + ("..." if len(available_models) > 10 else "")],
+                    "💡 İpucu": ["Lütfen cevap verisi olan açılır menüden bir model seçin."]
                 })
             
-            # Select and prepare columns for display
+            # Görüntülenecek sütunları seç ve hazırla
             selected_columns = ["bolum", "soru", "cevap", model_column]
             result_df = df_page[selected_columns]
             
-            # Rename columns for better display
+            # Daha iyi görünüm için sütunları yeniden adlandır
             result_df = result_df.rename(columns={
-                "bolum": "📚 Section",
-                "soru": "❓ Question", 
-                "cevap": "✅ Correct Answer",
-                model_column: f"🤖 {model} Response"
+                "bolum": "📚 Bölüm",
+                "soru": "❓ Soru", 
+                "cevap": "✅ Doğru Cevap",
+                model_column: f"🤖 {model} Cevabı"
             })
         
-        # Handle missing values
+        # Eksik değerleri işle
         result_df = result_df.fillna("N/A")
         
-        # Add global question numbers (not just page numbers)
+        # Genel soru numaralarını ekle (sadece sayfa numaraları değil)
         global_question_numbers = range(start_idx + 1, start_idx + len(result_df) + 1)
-        result_df.insert(0, "📝 Question #", global_question_numbers)
+        result_df.insert(0, "📝 Soru #", global_question_numbers)
         
         return result_df
         
     except Exception as e:
-        logger.error(f"Error getting all responses: {e}")
+        logger.error(f"Tüm cevapları alma hatası: {e}")
         return pd.DataFrame({
-            "❌ Error": [f"Error loading responses: {str(e)}"],
-            "🔧 Debug Info": [f"Model: '{model}', Page: {page}"]
+            "❌ Hata": [f"Cevapları yükleme hatası: {str(e)}"],
+            "🔧 Hata Ayıklama Bilgisi": [f"Model: '{model}', Sayfa: {page}"]
         })
 
 def get_pagination_info(page: int = 1, page_size: int = 50) -> dict:
-    """Get pagination information for the responses data."""
+    """Cevap verileri için sayfalama bilgilerini al."""
     try:
         df = data_manager.responses_data
         total_rows = len(df)
@@ -167,7 +167,7 @@ def get_pagination_info(page: int = 1, page_size: int = 50) -> dict:
             "has_next": page < total_pages
         }
     except Exception as e:
-        logger.error(f"Error getting pagination info: {e}")
+        logger.error(f"Sayfalama bilgisi alma hatası: {e}")
         return {
             "current_page": 1,
             "total_pages": 1,
@@ -180,14 +180,14 @@ def get_pagination_info(page: int = 1, page_size: int = 50) -> dict:
         }
 
 def search_responses(query: str, model: str, page: int = 1, page_size: int = 50) -> pd.DataFrame:
-    """Search model responses based on query with enhanced functionality."""
+    """Geliştirilmiş işlevsellik ile sorguya göre model cevaplarını ara."""
     try:
-        # If no query provided, show all responses
+        # Sorgu sağlanmazsa, tüm cevapları göster
         if not query or not query.strip():
             return get_all_responses(model, page, page_size)
         
         if not model or not model.strip():
-            return pd.DataFrame({"ℹ️ Info": ["Please select a model from the dropdown."]})
+            return pd.DataFrame({"ℹ️ Bilgi": ["Lütfen açılır menüden bir model seçin."]})
         
         query = query.strip()
         model = model.strip()
@@ -195,203 +195,201 @@ def search_responses(query: str, model: str, page: int = 1, page_size: int = 50)
         df = data_manager.responses_data
         
         if df.empty:
-            logger.warning("Responses data is empty, returning empty DataFrame")
-            return pd.DataFrame({"ℹ️ Info": ["No response data available. Please check data loading."]})
+            logger.warning("Cevap verileri boş, boş DataFrame döndürülüyor")
+            return pd.DataFrame({"ℹ️ Bilgi": ["Cevap verisi mevcut değil. Lütfen veri yüklemeyi kontrol edin."]})
         
-        # Debug: Show available columns
-        logger.info(f"Available columns in responses data: {list(df.columns)}")
-        
-        # Check if required columns exist
+        # Gerekli sütunların varlığını kontrol et
         required_columns = ["bolum", "soru", "cevap"]
-        missing_columns = [col for col in required_columns if col not in df.columns]
-        if missing_columns:
-            return pd.DataFrame({
-                "❌ Error": [f"Missing required columns: {', '.join(missing_columns)}"],
-                "Available Columns": [", ".join(df.columns.tolist())]
-            })
+        for col in required_columns:
+            if col not in df.columns:
+                return pd.DataFrame({
+                    "❌ Hata": [f"Gerekli sütun '{col}' bulunamadı"],
+                    "Mevcut Sütunlar": [", ".join(df.columns.tolist())]
+                })
         
-        # Check if model column exists
+        # Model sütununun varlığını kontrol et
         model_column = f"{model}_cevap"
         if model_column not in df.columns:
             available_models = [col.replace("_cevap", "") for col in df.columns if col.endswith("_cevap")]
-            logger.warning(f"Model column '{model_column}' not found in responses data")
             return pd.DataFrame({
-                "❌ Error": [f"Model '{model}' responses not found."],
-                "🤖 Available Models": [", ".join(available_models[:10]) + ("..." if len(available_models) > 10 else "")],
-                "💡 Tip": ["Please select a model from the dropdown that has response data."]
+                "❌ Hata": [f"'{model}' modeli cevapları bulunamadı"],
+                "🤖 Mevcut Modeller": [", ".join(available_models[:10]) + ("..." if len(available_models) > 10 else "")],
+                "💡 Öneriler": [
+                    "1. Açılır menüden geçerli bir model seçin",
+                    "2. Model verilerinin yüklendiğinden emin olun",
+                    "3. Modelleri yenilemek için 'Yenile' butonuna tıklayın"
+                ]
             })
         
-        # Enhanced search - search in multiple columns with better error handling
-        try:
-            search_mask = pd.Series([False] * len(df))
-            
-            # Search in each column separately to handle potential issues
-            if "bolum" in df.columns:
-                search_mask |= df["bolum"].astype(str).str.contains(query, case=False, na=False)
-            
-            if "soru" in df.columns:
-                search_mask |= df["soru"].astype(str).str.contains(query, case=False, na=False)
-            
-            if "cevap" in df.columns:
-                search_mask |= df["cevap"].astype(str).str.contains(query, case=False, na=False)
-            
-            if model_column in df.columns:
-                search_mask |= df[model_column].astype(str).str.contains(query, case=False, na=False)
-                
-        except Exception as search_error:
-            logger.error(f"Error in search operation: {search_error}")
-            return pd.DataFrame({"❌ Error": [f"Search operation failed: {str(search_error)}"]})
+        # Sorguyu güvenli hale getir (büyük/küçük harf duyarsız)
+        query_lower = query.lower()
         
-        filtered = df[search_mask]
+        # Birden fazla sütunda arama yap
+        search_columns = ["bolum", "soru", "cevap", model_column]
+        search_mask = pd.Series([False] * len(df))
         
-        if filtered.empty:
-            return pd.DataFrame({
-                "ℹ️ Info": [f"No results found for '{query}' in model '{model}' responses."],
-                "💡 Suggestion": ["Try different search terms or check if the model has response data."]
-            })
+        for col in search_columns:
+            if col in df.columns:
+                # Güvenli string dönüştürme ve büyük/küçük harf duyarsız arama
+                col_mask = df[col].astype(str).str.lower().str.contains(query_lower, case=False, na=False, regex=False)
+                search_mask = search_mask | col_mask
         
-        # Apply pagination to search results
-        total_results = len(filtered)
-        start_idx = (page - 1) * page_size
-        end_idx = start_idx + page_size
+        # Arama sonuçlarını filtrele
+        search_results = df[search_mask]
         
-        # Validate page number for search results
-        if start_idx >= total_results:
-            total_pages = (total_results + page_size - 1) // page_size
+        if search_results.empty:
             return pd.DataFrame({
-                "ℹ️ Info": [f"Search page {page} is out of range. Total search pages: {total_pages}"],
-                "🔍 Search Results": [f"Found {total_results} matches for '{query}'"]
+                "🔍 Arama Sonucu": [f"'{query}' için sonuç bulunamadı"],
+                "💡 İpucu": [
+                    "Daha genel terimler deneyin",
+                    "Yazım hatalarını kontrol edin",
+                    "Farklı anahtar kelimeler kullanın"
+                ],
+                "📊 Aranan Sütunlar": [", ".join(search_columns)]
             })
         
-        # Get the search results slice for current page
-        filtered_page = filtered.iloc[start_idx:end_idx].copy()
-        
-        # Select and prepare columns for display
-        selected_columns = ["bolum", "soru", "cevap", model_column]
-        result = filtered_page[selected_columns].copy()
-        
-        # Handle missing values
-        result = result.fillna("N/A")
-        
-        # Rename columns for better display
-        result = result.rename(columns={
-            "bolum": "📚 Section",
-            "soru": "❓ Question", 
-            "cevap": "✅ Correct Answer",
-            model_column: f"🤖 {model} Response"
+        # Sonuçları sayıyla sınırla (performans için)
+        max_results = 50
+        if len(search_results) > max_results:
+            search_results = search_results.head(max_results)
+            truncated_message = f" (İlk {max_results} sonuç gösteriliyor)"
+        else:
+            truncated_message = ""
+        
+        # Görüntülenecek sütunları seç
+        display_columns = ["bolum", "soru", "cevap", model_column]
+        result_df = search_results[display_columns].copy()
+        
+        # Sütunları yeniden adlandır
+        result_df = result_df.rename(columns={
+            "bolum": "📚 Bölüm",
+            "soru": "❓ Soru",
+            "cevap": "✅ Doğru Cevap",
+            model_column: f"🤖 {model} Cevabı"
         })
         
-        # Add global match numbers (not just page numbers)
-        global_match_numbers = range(start_idx + 1, start_idx + len(result) + 1)
-        result.insert(0, "🔍 Match #", global_match_numbers)
+        # Eksik değerleri işle
+        result_df = result_df.fillna("N/A")
         
-        logger.info(f"Showing search results {start_idx + 1}-{start_idx + len(result)} out of {total_results} total matches")
+        # Başlık satırı ekle
+        summary_info = f"'{query}' için {len(search_results)} sonuç{truncated_message}"
+        result_df.insert(0, "🔍 Arama Özeti", [summary_info] + [""] * (len(result_df) - 1))
         
-        return result
+        return result_df
         
     except Exception as e:
-        logger.error(f"Error searching responses: {e}")
+        logger.error(f"Cevap arama hatası: {e}")
+        error_details = f"Sorgu: '{query}', Model: '{model}', Hata: {str(e)}"
         return pd.DataFrame({
-            "❌ Error": [f"Search error: {str(e)}"],
-            "🔧 Debug Info": [f"Query: '{query}', Model: '{model}'"]
+            "❌ Arama Hatası": ["Arama sırasında bir hata oluştu"],
+            "🔧 Hata Detayları": [error_details],
+            "💡 Öneriler": [
+                "Basit sorgu terimleri deneyin",
+                "Özel karakterleri kaldırın",
+                "Sayfayı yenileyin ve tekrar deneyin"
+            ]
         })
 
-
-
 def create_plotly_section_results() -> go.Figure:
-    """Create an interactive Plotly chart for section results."""
+    """Bölüm sonuçları için etkileşimli Plotly grafiği oluştur."""
     try:
         df = data_manager.section_results_data
         
         if df.empty:
             fig = go.Figure()
             fig.add_annotation(
-                text="📊 No data available",
+                text="Bölüm verisi mevcut değil",
                 xref="paper", yref="paper",
                 x=0.5, y=0.5, xanchor='center', yanchor='middle',
                 showarrow=False,
-                font=dict(size=18, color="gray")
+                font=dict(size=16, color="gray")
             )
             fig.update_layout(
-                title="Section-Wise Performance",
+                title="Bölüm Performans Analizi",
                 height=500,
-                plot_bgcolor='white'
+                plot_bgcolor='white',
+                paper_bgcolor='white'
             )
             return fig
         
-        # Calculate average scores
-        numeric_cols = df.select_dtypes(include=['number']).columns
-        avg_scores = df[numeric_cols].mean()
-        
-        # Create interactive bar chart
-        fig = go.Figure(data=[
-            go.Bar(
-                x=avg_scores.index,
-                y=avg_scores.values,
-                marker=dict(
-                    color=avg_scores.values,
-                    colorscale='Viridis',
-                    showscale=True,
-                    colorbar=dict(title="Score (%)", titleside="right")
-                ),
-                text=[f'{v:.1f}%' for v in avg_scores.values],
-                textposition='auto',
-                textfont=dict(size=12, color='white'),
-                hovertemplate='<b>%{x}</b><br>Score: %{y:.1f}%<br><extra></extra>',
-                name="Section Scores"
+        # İlk sütunun bölüm adları olduğunu varsay
+        if len(df.columns) < 2:
+            fig = go.Figure()
+            fig.add_annotation(
+                text="Yeterli veri yok",
+                xref="paper", yref="paper",
+                x=0.5, y=0.5, xanchor='center', yanchor='middle',
+                showarrow=False,
+                font=dict(size=16, color="gray")
             )
-        ])
-        
-        # Add average line
-        mean_score = avg_scores.mean()
-        fig.add_hline(
-            y=mean_score, 
-            line_dash="dash", 
-            line_color="red",
-            annotation_text=f"Average: {mean_score:.1f}%",
-            annotation_position="top right"
-        )
+            fig.update_layout(title="Bölüm Performans Analizi", height=500)
+            return fig
+        
+        # Sayısal sütunları (model performansları) al
+        numeric_columns = df.select_dtypes(include=['number']).columns.tolist()
+        section_column = df.columns[0] if df.columns[0] not in numeric_columns else 'section'
+        
+        if not numeric_columns:
+            # Sayısal sütun yoksa ilk sütunu bölüm olarak al ve diğerlerini sayısala çevirmeye çalış
+            numeric_columns = df.columns[1:].tolist()
+            for col in numeric_columns:
+                df[col] = pd.to_numeric(df[col], errors='coerce')
+        
+        # Etkileşimli bar chart oluştur
+        fig = go.Figure()
+        
+        # Her model için ayrı çubuk ekle
+        colors = px.colors.qualitative.Set3
+        for i, model in enumerate(numeric_columns):
+            fig.add_trace(go.Bar(
+                name=model,
+                x=df[section_column] if section_column in df.columns else df.index,
+                y=df[model],
+                marker_color=colors[i % len(colors)],
+                text=[f'{v:.1f}%' if pd.notna(v) else 'N/A' for v in df[model]],
+                textposition='auto',
+                hovertemplate=f'<b>{model}</b><br>Bölüm: %{{x}}<br>Puan: %{{y:.1f}}%<extra></extra>'
+            ))
         
         fig.update_layout(
-            title=dict(
-                text="📊 Average Section-Wise Performance",
-                x=0.5,
-                font=dict(size=24, color='#2c3e50')
-            ),
-            xaxis=dict(
-                title="Sections",
-                titlefont=dict(size=16),
-                tickangle=45,
-                gridcolor='#f0f0f0'
-            ),
-            yaxis=dict(
-                title="Accuracy (%)",
-                titlefont=dict(size=16),
-                gridcolor='#f0f0f0'
-            ),
+            title="Model Performanslarının Bölümlere Göre Karşılaştırması",
+            xaxis_title="Bölümler",
+            yaxis_title="Doğruluk Puanı (%)",
+            height=500,
             plot_bgcolor='white',
             paper_bgcolor='white',
-            height=600,
-            margin=dict(t=100, b=120, l=80, r=80),
-            showlegend=False
+            barmode='group',
+            hovermode='x unified',
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            )
         )
         
+        # Grid ekle
+        fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='lightgray')
+        fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='lightgray')
+        
         return fig
         
     except Exception as e:
-        logger.error(f"Error creating Plotly section results: {e}")
+        logger.error(f"Bölüm sonuçları grafiği oluşturma hatası: {e}")
         fig = go.Figure()
         fig.add_annotation(
-            text=f"❌ Error generating plot: {str(e)}",
+            text=f"Grafik oluşturma hatası: {str(e)}",
             xref="paper", yref="paper",
             x=0.5, y=0.5, xanchor='center', yanchor='middle',
             showarrow=False,
             font=dict(size=14, color="red")
         )
         fig.update_layout(
-            title="Section-Wise Performance",
+            title="Bölüm Performans Analizi",
             height=500,
-            plot_bgcolor='white'
+            plot_bgcolor='white',
+            paper_bgcolor='white'
         )
         return fig
 
@@ -403,120 +401,142 @@ def validate_model_submission(
     weight_type: str,
     model_type: str
 ) -> Tuple[bool, str]:
-    """Enhanced model submission validation with detailed checks."""
+    """Model gönderimini detaylı kontrollerle doğrula."""
     try:
-        # Basic required field validation
+        # Temel validasyon
         if not model_name or not model_name.strip():
-            return False, "Model name is required and cannot be empty."
+            return False, "Model adı gereklidir"
         
         if not base_model or not base_model.strip():
-            return False, "Base model is required and cannot be empty."
+            return False, "Temel model gereklidir"
         
-        # Model name validation
+        # İsim formatını kontrol et
         model_name = model_name.strip()
         if len(model_name) < 3:
-            return False, "Model name must be at least 3 characters long."
+            return False, "Model adı en az 3 karakter olmalıdır"
         
         if len(model_name) > 100:
-            return False, "Model name must be less than 100 characters."
+            return False, "Model adı 100 karakterden fazla olamaz"
         
-        # Check for invalid characters
-        invalid_chars = ['<', '>', ':', '"', '|', '?', '*', '\\', '/']
-        if any(char in model_name for char in invalid_chars):
-            return False, f"Model name contains invalid characters: {', '.join(invalid_chars)}"
+        # Özel karakterleri kontrol et
+        if not model_name.replace('-', '').replace('_', '').replace('.', '').replace('/', '').isalnum():
+            return False, "Model adında sadece harf, rakam, tire, alt çizgi, nokta ve eğik çizgi kullanılabilir"
         
-        # Check if model already exists
-        if not data_manager.leaderboard_data.empty:
-            existing_models = data_manager.leaderboard_data["model"].values
-            if model_name in existing_models:
-                return False, f"Model name '{model_name}' already exists. Please choose a unique name."
+        # Mevcut modellerde çakışma kontrolü
+        existing_data = data_manager.leaderboard_data
+        if not existing_data.empty and 'model' in existing_data.columns:
+            if model_name.lower() in existing_data['model'].str.lower().values:
+                return False, f"'{model_name}' adında bir model zaten mevcut"
         
-        # Base model validation
+        # Temel model formatını kontrol et
         base_model = base_model.strip()
-        if len(base_model) < 3:
-            return False, "Base model name must be at least 3 characters long."
+        if '/' not in base_model and not base_model.startswith('http'):
+            return False, "Temel model formatı 'organization/model' şeklinde olmalıdır"
         
-        # Revision validation
-        if revision and len(revision.strip()) == 0:
-            return False, "Revision cannot be empty if provided."
+        # Revizyon kontrolü
+        if revision and len(revision.strip()) > 50:
+            return False, "Revizyon 50 karakterden fazla olamaz"
         
-        # Validate precision, weight_type, and model_type are from allowed options
+        # Yapılandırma seçeneklerini kontrol et
         from config import CONFIG
         
         if precision not in CONFIG["model"].precision_options:
-            return False, f"Invalid precision. Must be one of: {', '.join(CONFIG['model'].precision_options)}"
+            return False, f"Geçersiz hassasiyet seçimi. Geçerli seçenekler: {', '.join(CONFIG['model'].precision_options)}"
         
         if weight_type not in CONFIG["model"].weight_types:
-            return False, f"Invalid weight type. Must be one of: {', '.join(CONFIG['model'].weight_types)}"
+            return False, f"Geçersiz ağırlık türü seçimi. Geçerli seçenekler: {', '.join(CONFIG['model'].weight_types)}"
         
         if model_type not in CONFIG["model"].model_types:
-            return False, f"Invalid model type. Must be one of: {', '.join(CONFIG['model'].model_types)}"
+            return False, f"Geçersiz model türü seçimi. Geçerli seçenekler: {', '.join(CONFIG['model'].model_types)}"
         
-        return True, "✅ All validation checks passed! Your model submission looks good."
+        # Başarılı validasyon
+        success_message = f"Model '{model_name}' başarıyla doğrulandı ve değerlendirme kuyruğuna eklendi"
+        logger.info(f"Model gönderimi doğrulandı: {model_name}")
+        
+        return True, success_message
         
     except Exception as e:
-        logger.error(f"Error validating model submission: {e}")
-        return False, f"Validation error: {str(e)}"
+        logger.error(f"Model doğrulama hatası: {e}")
+        return False, f"Doğrulama sırasında hata oluştu: {str(e)}"
 
 def get_leaderboard_stats() -> Dict[str, any]:
-    """Get comprehensive statistics about the leaderboard."""
+    """Liderlik tablosu istatistiklerini al."""
     try:
         df = data_manager.leaderboard_data
         
         if df.empty:
             return {
-                "total_models": 0,
-                "total_families": 0,
-                "avg_score": 0,
-                "top_score": 0,
-                "last_updated": "No data"
+                "toplam_model": 0,
+                "ortalama_puan": 0,
+                "en_yuksek_puan": 0,
+                "aileler": [],
+                "kuantizasyon_seviyeleri": []
             }
         
         stats = {
-            "total_models": len(df),
-            "total_families": df["family"].nunique() if "family" in df.columns else 0,
-            "avg_score": df["score"].mean() if "score" in df.columns else 0,
-            "top_score": df["score"].max() if "score" in df.columns else 0,
-            "last_updated": time.strftime("%Y-%m-%d %H:%M:%S")
+            "toplam_model": len(df),
+            "ortalama_puan": df["score"].mean() if "score" in df.columns else 0,
+            "en_yuksek_puan": df["score"].max() if "score" in df.columns else 0,
+            "aileler": df["family"].unique().tolist() if "family" in df.columns else [],
+            "kuantizasyon_seviyeleri": df["quantization_level"].unique().tolist() if "quantization_level" in df.columns else []
         }
         
         return stats
         
     except Exception as e:
-        logger.error(f"Error getting leaderboard stats: {e}")
+        logger.error(f"İstatistik alma hatası: {e}")
         return {
-            "total_models": 0,
-            "total_families": 0,
-            "avg_score": 0,
-            "top_score": 0,
-            "last_updated": "Error"
+            "toplam_model": 0,
+            "ortalama_puan": 0,
+            "en_yuksek_puan": 0,
+            "aileler": [],
+            "kuantizasyon_seviyeleri": []
         }
 
 def format_dataframe_for_display(df: pd.DataFrame, max_rows: int = 100) -> pd.DataFrame:
-    """Format DataFrame for better display in Gradio."""
+    """DataFrame'i görüntüleme için formatla."""
     try:
         if df.empty:
-            return df
+            return pd.DataFrame({"ℹ️ Bilgi": ["Görüntülenecek veri yok"]})
         
-        # Limit rows for performance
+        # Satır sayısını sınırla
         if len(df) > max_rows:
             df = df.head(max_rows)
+            logger.info(f"DataFrame {max_rows} satırla sınırlandırıldı")
         
-        # Round numeric columns
-        numeric_columns = df.select_dtypes(include=['float64', 'float32']).columns
-        for col in numeric_columns:
-            df[col] = df[col].round(2)
+        # Sayısal sütunları formatla
+        for col in df.select_dtypes(include=['float']).columns:
+            if 'score' in col.lower() or 'puan' in col.lower():
+                df[col] = df[col].round(2)
         
-        # Truncate long text fields
-        text_columns = df.select_dtypes(include=['object']).columns
-        for col in text_columns:
-            if col in df.columns:
-                df[col] = df[col].astype(str).apply(
-                    lambda x: x[:100] + "..." if len(str(x)) > 100 else x
-                )
+        # Uzun string'leri kısalt
+        for col in df.select_dtypes(include=['object']).columns:
+            df[col] = df[col].astype(str).apply(
+                lambda x: x[:100] + "..." if len(x) > 100 else x
+            )
         
         return df
         
     except Exception as e:
-        logger.error(f"Error formatting DataFrame: {e}")
-        return df
+        logger.error(f"DataFrame formatlama hatası: {e}")
+        return pd.DataFrame({"❌ Hata": [f"Formatlama hatası: {str(e)}"]})
+
+# Önbellekleme temizleme işlevi
+def clear_cache():
+    """Tüm LRU önbelleklerini temizle."""
+    try:
+        filter_leaderboard.cache_clear()
+        logger.info("Önbellekler temizlendi")
+    except Exception as e:
+        logger.error(f"Önbellek temizleme hatası: {e}")
+
+# Veri yenileme sonrası önbellekleri temizle
+def refresh_all_caches():
+    """Veri yenileme sonrası tüm önbellekleri yenile."""
+    try:
+        clear_cache()
+        # Veri yöneticisinden yeni verileri zorla yükle
+        data_manager.refresh_datasets()
+        logger.info("Tüm önbellekler ve veriler yenilendi")
+    except Exception as e:
+        logger.error(f"Önbellek yenileme hatası: {e}")