Remove venv from Git tracking and add to .gitignore

.gitignore

@@ -0,0 +1,2 @@
+# Sanal ortam
+venv/

README.md

@@ -1,12 +1,14 @@
 ---
 title: Textqualtox
-emoji: 🦀
-colorFrom: gray
-colorTo: purple
+emoji: 🌖
+colorFrom: green
+colorTo: red
 sdk: streamlit
 sdk_version: 1.44.0
 app_file: app.py
 pinned: false
+license: mit
+short_description: Quality, toxicity, and sentiment analysis of text data.
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,774 @@
+import streamlit as st
+import pandas as pd
+import os
+import matplotlib.pyplot as plt
+import plotly.express as px
+from models.model_loader import ModelManager
+from utils.quality_scorer import QualityScorer
+from utils.toxicity_scorer import ToxicityScorer
+from utils.data_handler import DataHandler
+from utils.sentiment_analyzer import SentimentAnalyzer
+from utils.text_improver import TextImprover
+from utils.keyword_extractor import KeywordExtractor
+from utils.language_detector import LanguageDetector
+import logging
+import time
+import re
+
+
+# Loglama ayarları
+logger = logging.getLogger(__name__)
+handler = logging.StreamHandler()
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+logger.setLevel(logging.INFO)
+
+# Veri klasörlerini oluştur
+os.makedirs("data/processed", exist_ok=True)
+
+# Sabitleri tanımla
+SAMPLE_TEXT = """Bu bir örnek metindir. Bu metin, sistemin nasıl çalıştığını göstermek için kullanılmaktadır. 
+Metin kalitesi ve zararlılık değerlendirmesi için kullanılabilir."""
+
+
+def display_model_info(models_dict):
+    """Model bilgilerini görüntüler"""
+    model_info = models_dict.get("model_info", {})
+
+    st.markdown("---")
+    st.markdown("### Model Bilgileri")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        toxicity_info = model_info.get("toxicity", {})
+        st.markdown("#### Zararlılık Modeli")
+
+        model_name = toxicity_info.get("name", "Bilinmiyor")
+        model_description = toxicity_info.get("description", "")
+        model_language = toxicity_info.get("language", "")
+
+        st.code(model_name, language="plaintext")
+
+
+        language_icon = "🇹🇷" if model_language == "tr" else "🇺🇸" if model_language == "en" else "🌐"
+        st.caption(f"{language_icon} {model_description}")
+
+    with col2:
+        quality_info = model_info.get("quality", {})
+        st.markdown("#### Kalite Modeli")
+
+        model_name = quality_info.get("name", "Bilinmiyor")
+        model_description = quality_info.get("description", "")
+        model_language = quality_info.get("language", "")
+
+        st.code(model_name, language="plaintext")
+
+
+        language_icon = "🇹🇷" if model_language == "tr" else "🇺🇸" if model_language == "en" else "🌐"
+        st.caption(f"{language_icon} {model_description}")
+
+    # Optimizasyon bilgisi
+    st.info("""
+    Bu sistem Türkçe metinler için otomatik optimize edilmiştir. 
+    En iyi performansı gösteren modeller test sonuçlarına göre seçilmiştir.
+    """)
+
+
+@st.cache_resource
+def load_models():
+    """Modelleri yükler ve önbelleğe alır"""
+    with st.spinner("Modeller değerlendiriliyor ve seçiliyor... Bu işlem birkaç dakika sürebilir."):
+        # Örnek metinlerin bir kısmı
+        sample_texts = [
+            "Türkiye, zengin tarihi ve kültürel mirası ile dünyanın en etkileyici ülkelerinden biridir.",
+            "turkiye guzel bi ulke. cok tarihi yerler var yani. denızleri guzel. yemekleride guzel.",
+            "Bu grup insanlar gerçekten çok aptal! Hepsi geri zekalı ve cahil. Bunlarla konuşmak bile zaman kaybı.",
+            "Kediler harika evcil hayvanlardır. Bağımsız yapıları vardır. Temizlik konusunda çok titizlerdir."
+        ]
+
+        try:
+            # Cache dizinini belirle
+            cache_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".model_cache")
+            os.makedirs(cache_dir, exist_ok=True)
+
+            # Gelişmiş model yükleme stratejisi
+            model_manager = ModelManager(cache_dir=cache_dir, use_cache=True)
+            success = model_manager.load_models_auto_select(sample_texts)
+
+            if not success:
+                st.error("Otomatik model seçimi başarısız oldu. Varsayılan modeller yükleniyor.")
+                model_manager.load_default_models()
+
+            models_dict = model_manager.get_models()
+
+            toxicity_scorer = ToxicityScorer(
+                model=models_dict["toxicity_model"],
+                tokenizer=models_dict["toxicity_tokenizer"]
+            )
+
+            quality_scorer = QualityScorer(
+                quality_pipeline=models_dict["quality_pipeline"]
+            )
+
+            # Skorlayıcıların model bilgilerini paylaşması için
+            toxicity_scorer.model_info = models_dict["model_info"]["toxicity"]
+            quality_scorer.model_info = models_dict["model_info"]["quality"]
+
+            return toxicity_scorer, quality_scorer, models_dict
+
+        except Exception as e:
+            st.error(f"Model yükleme hatası: {str(e)}")
+            # Yedek (basit) strateji
+            logger.error(f"Model yükleme hatası: {str(e)}, basit modellere dönülüyor")
+
+            toxicity_scorer = ToxicityScorer()  # Varsayılan modelle başlat
+            quality_scorer = QualityScorer()  # Varsayılan modelle başlat
+
+            models_dict = {
+                "model_info": {
+                    "toxicity": {"name": "Varsayılan Model",
+                                 "description": "Hata nedeniyle varsayılan model kullanılıyor", "language": "unknown"},
+                    "quality": {"name": "Varsayılan Model",
+                                "description": "Hata nedeniyle varsayılan model kullanılıyor", "language": "unknown"}
+                }
+            }
+
+            return toxicity_scorer, quality_scorer, models_dict
+
+
+def analyze_single_text(text, toxicity_scorer, quality_scorer):
+    """Tek bir metin için analiz yapar"""
+    result = {}
+
+    # Zararlılık analizi
+    start_time = time.time()
+    toxicity_score = toxicity_scorer.score_text(text)
+    result["toxicity_score"] = toxicity_score
+    result["toxicity_time"] = time.time() - start_time
+
+    # Kalite analizi
+    start_time = time.time()
+    quality_score, quality_features = quality_scorer.score_text(text)
+    result["quality_score"] = quality_score
+    result["quality_features"] = quality_features
+    result["quality_time"] = time.time() - start_time
+
+    return result
+
+
+def display_results(result, quality_threshold, toxicity_threshold):
+    """Analiz sonuçlarını gösterir"""
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("Kalite Puanı")
+        quality_score = result["quality_score"]
+        st.metric("Kalite", f"{quality_score:.2f}", delta=f"{quality_score - quality_threshold:.2f}")
+
+        # Kalite özelliklerini görselleştir
+        if "quality_features" in result:
+            features = result["quality_features"]
+            feature_df = pd.DataFrame({
+                "Özellik": list(features.keys()),
+                "Değer": list(features.values())
+            })
+
+            fig = px.bar(feature_df, x="Özellik", y="Değer", title="Kalite Özellikleri")
+            fig.update_layout(height=300)
+            st.plotly_chart(fig, use_container_width=True)
+
+        st.info(f"Hesaplama süresi: {result['quality_time']:.2f} saniye")
+
+    with col2:
+        st.subheader("Zararlılık Puanı")
+        toxicity_score = result["toxicity_score"]
+        # Zararlılıkta düşük değer iyidir
+        st.metric("Zararlılık", f"{toxicity_score:.2f}",
+                  delta=f"{toxicity_threshold - toxicity_score:.2f}",
+                  delta_color="inverse")
+
+        # Zararlılık rengini göster
+        fig, ax = plt.subplots(figsize=(3, 1))
+        cmap = plt.cm.RdYlGn_r
+        color = cmap(toxicity_score)
+        ax.barh(0, toxicity_score, color=color)
+        ax.barh(0, 1 - toxicity_score, left=toxicity_score, color="lightgrey")
+        ax.set_xlim(0, 1)
+        ax.set_yticks([])
+        ax.set_xticks([0, 0.25, 0.5, 0.75, 1])
+        fig.tight_layout()
+        st.pyplot(fig)
+
+        st.info(f"Hesaplama süresi: {result['toxicity_time']:.2f} saniye")
+
+    # Genel değerlendirme
+    if quality_score >= quality_threshold and toxicity_score <= toxicity_threshold:
+        st.success(" Bu metin kabul edilebilir kalite ve zararlılık seviyesindedir.")
+    else:
+        if quality_score < quality_threshold:
+            st.warning(" Bu metnin kalitesi eşik değerin altındadır.")
+        if toxicity_score > toxicity_threshold:
+            st.error(" Bu metin kabul edilebilir zararlılık seviyesini aşmaktadır.")
+
+
+def process_file(uploaded_file, toxicity_scorer, quality_scorer, quality_threshold, toxicity_threshold, batch_size):
+    """Yüklenen dosyayı işler"""
+    try:
+        # Veri işleyici oluştur
+        data_handler = DataHandler(quality_scorer, toxicity_scorer)
+
+        # Veriyi yükle
+        df, text_column = data_handler.load_data(uploaded_file)
+
+        # İlerleme çubuğu göster
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+
+        # Veriyi işle
+        status_text.text("Veriler işleniyor...")
+
+        # Veri işleme işlevini çağır
+        processed_df = data_handler.process_data(
+            df,
+            text_column,
+            quality_threshold,
+            toxicity_threshold,
+            batch_size
+        )
+
+        # İlerleme çubuğunu güncelle
+        progress_bar.progress(100)
+        status_text.text("İşlem tamamlandı!")
+
+        return processed_df, text_column
+
+    except Exception as e:
+        st.error(f"Dosya işleme hatası: {str(e)}")
+        logger.exception(f"Dosya işleme hatası: {str(e)}")
+        return None, None
+
+
+def main():
+    """Ana uygulama işlevi"""
+    st.set_page_config(page_title="📊 Veri Kalitesi ve Zararlılık Değerlendirme ",
+     layout="wide")
+
+    st.title(" 📊Veri Kalitesi ve Zararlılık Değerlendirme ")
+    st.markdown("""
+    Bu platform, metin verilerini otomatik olarak kalite ve zararlılık açısından değerlendirir.
+    Tek bir metin veya CSV/Excel dosyası yükleyerek toplu analiz yapabilirsiniz.
+    """)
+
+    # Yan panel
+    with st.sidebar:
+        st.header("Ayarlar")
+
+        st.subheader("Eşik Değerleri")
+        quality_threshold = st.slider("Kalite Eşiği", 0.0, 1.0, 0.5,
+                                      help="Bu değerin altındaki kalite skoruna sahip metinler düşük kaliteli olarak işaretlenir")
+        toxicity_threshold = st.slider("Zararlılık Eşiği", 0.0, 1.0, 0.5,
+                                       help="Bu değerin üzerindeki zararlılık skoruna sahip metinler zararlı olarak işaretlenir")
+
+        st.subheader("Toplu İşleme")
+        batch_size = st.slider("Grup Boyutu", 1, 32, 8,
+                               help="Toplu değerlendirme için grup boyutu. Bellek sınırlamalarına göre ayarlayın.")
+
+        # Modelleri yükle
+        toxicity_scorer, quality_scorer, models_dict = load_models()
+
+        # Model bilgilerini göster
+        display_model_info(models_dict)
+
+    # Sekmeleri oluştur
+    tab1, tab2, tab3, tab4 = st.tabs(["Tek Metin Analizi", "Toplu Dosya Analizi",
+                                      "Gelişmiş Metin Analizi", "Anahtar Kelime ve Dil Tespiti"])
+
+    # Tek Metin Analizi sekmesi
+    with tab1:
+        st.subheader("Metin Analizi")
+
+        text_input = st.text_area("Analiz edilecek metni girin:",
+                                  value=SAMPLE_TEXT,
+                                  height=150)
+
+        if st.button("Analiz Et", type="primary", key="analyze_single"):
+            if text_input and len(text_input.strip()) > 0:
+                with st.spinner("Metin analiz ediliyor..."):
+                    result = analyze_single_text(text_input, toxicity_scorer, quality_scorer)
+
+                st.markdown("---")
+                st.subheader("Analiz Sonuçları")
+                display_results(result, quality_threshold, toxicity_threshold)
+            else:
+                st.error("Lütfen analiz için bir metin girin.")
+
+    # Toplu Dosya Analizi sekmesi
+    with tab2:
+        st.subheader("Dosya Analizi")
+
+        uploaded_file = st.file_uploader("CSV veya Excel dosyası yükleyin:",
+                                         type=["csv", "xlsx", "xls"])
+
+        if uploaded_file is not None:
+            # Dosya bilgilerini göster
+            file_details = {
+                "Dosya Adı": uploaded_file.name,
+                "Dosya Boyutu": f"{uploaded_file.size / 1024:.2f} KB"
+            }
+            st.write(file_details)
+
+            # Dosyayı işle
+            if st.button("Dosyayı İşle", type="primary", key="process_file"):
+                with st.spinner("Dosya işleniyor... Bu işlem dosya boyutuna bağlı olarak biraz zaman alabilir."):
+                    processed_df, text_column = process_file(
+                        uploaded_file,
+                        toxicity_scorer,
+                        quality_scorer,
+                        quality_threshold,
+                        toxicity_threshold,
+                        batch_size
+                    )
+
+                if processed_df is not None:
+                    st.markdown("---")
+                    st.subheader("İşlenmiş Veri")
+
+                    # Veri önizlemesi göster
+                    st.dataframe(processed_df.head(10), use_container_width=True)
+
+                    # İstatistikler
+                    st.markdown("### Özet İstatistikler")
+                    col1, col2, col3 = st.columns(3)
+
+                    with col1:
+                        st.metric("Toplam Metin Sayısı", len(processed_df))
+
+                    with col2:
+                        acceptable_count = processed_df[
+                            "acceptable"].sum() if "acceptable" in processed_df.columns else 0
+                        acceptable_pct = acceptable_count / len(processed_df) * 100 if len(processed_df) > 0 else 0
+                        st.metric("Kabul Edilebilir Metinler", f"{acceptable_count} ({acceptable_pct:.1f}%)")
+
+                    with col3:
+                        rejected_count = len(processed_df) - acceptable_count
+                        rejected_pct = 100 - acceptable_pct
+                        st.metric("Reddedilen Metinler", f"{rejected_count} ({rejected_pct:.1f}%)")
+
+                    # Görselleştirmeler
+                    st.markdown("### Veri Görselleştirme")
+                    col1, col2 = st.columns(2)
+
+                    with col1:
+                        if "quality_score" in processed_df.columns:
+                            fig = px.histogram(
+                                processed_df,
+                                x="quality_score",
+                                nbins=20,
+                                title="Kalite Skoru Dağılımı",
+                                color_discrete_sequence=["#3366cc"]
+                            )
+                            fig.add_vline(x=quality_threshold, line_dash="dash", line_color="red")
+                            st.plotly_chart(fig, use_container_width=True)
+
+                    with col2:
+                        if "toxicity_score" in processed_df.columns:
+                            fig = px.histogram(
+                                processed_df,
+                                x="toxicity_score",
+                                nbins=20,
+                                title="Zararlılık Skoru Dağılımı",
+                                color_discrete_sequence=["#dc3912"]
+                            )
+                            fig.add_vline(x=toxicity_threshold, line_dash="dash", line_color="red")
+                            st.plotly_chart(fig, use_container_width=True)
+
+                    # Scatter plot
+                    if "quality_score" in processed_df.columns and "toxicity_score" in processed_df.columns:
+                        fig = px.scatter(
+                            processed_df,
+                            x="quality_score",
+                            y="toxicity_score",
+                            color="acceptable" if "acceptable" in processed_df.columns else None,
+                            title="Kalite vs Zararlılık",
+                            color_discrete_sequence=["#dc3912", "#3366cc"],
+                            hover_data=[text_column]
+                        )
+                        fig.add_hline(y=toxicity_threshold, line_dash="dash", line_color="red")
+                        fig.add_vline(x=quality_threshold, line_dash="dash", line_color="red")
+                        st.plotly_chart(fig, use_container_width=True)
+
+                    # Filtrelenmiş veri
+                    data_handler = DataHandler(quality_scorer, toxicity_scorer)
+                    filtered_df = data_handler.filter_data(processed_df, quality_threshold, toxicity_threshold)
+
+                    st.markdown("### Filtrelenmiş Veri")
+                    st.write(
+                        f"Eşik değerlerini karşılayan {len(filtered_df)} metin ({len(filtered_df) / len(processed_df) * 100:.1f}%)")
+                    st.dataframe(filtered_df.head(10), use_container_width=True)
+
+                    # İndirme bağlantıları
+                    st.markdown("### Verileri İndir")
+                    col1, col2 = st.columns(2)
+
+                    with col1:
+                        # İşlenmiş veriyi CSV olarak dışa aktar
+                        csv_processed = processed_df.to_csv(index=False)
+                        st.download_button(
+                            label="İşlenmiş Veriyi İndir (CSV)",
+                            data=csv_processed,
+                            file_name=f"processed_{uploaded_file.name.split('.')[0]}.csv",
+                            mime="text/csv"
+                        )
+
+                    with col2:
+                        # Filtrelenmiş veriyi CSV olarak dışa aktar
+                        csv_filtered = filtered_df.to_csv(index=False)
+                        st.download_button(
+                            label="Filtrelenmiş Veriyi İndir (CSV)",
+                            data=csv_filtered,
+                            file_name=f"filtered_{uploaded_file.name.split('.')[0]}.csv",
+                            mime="text/csv"
+                        )
+
+    # Gelişmiş Metin Analizi sekmesi
+    with tab3:
+        st.subheader("Gelişmiş Metin Analizi")
+        st.write("Bu sekmede duygu analizi ve metin iyileştirme önerilerini görebilirsiniz.")
+
+        # Analizörler oluştur
+        sentiment_analyzer = SentimentAnalyzer()
+        text_improver = TextImprover()
+
+        advanced_text_input = st.text_area("Analiz edilecek metni girin:",
+                                           value=SAMPLE_TEXT,
+                                           height=150,
+                                           key="advanced_text")
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            sentiment_option = st.checkbox("Duygu Analizi", value=True,
+                                           help="Metnin duygusal tonunu analiz eder")
+
+        with col2:
+            improvement_option = st.checkbox("Metin İyileştirme", value=True,
+                                             help="Metin kalitesini artırmak için öneriler sunar")
+
+        if st.button("Gelişmiş Analiz Yap", type="primary", key="advanced_analyze"):
+            if advanced_text_input and len(advanced_text_input.strip()) > 0:
+                with st.spinner("Gelişmiş analiz yapılıyor..."):
+                    # Duygu analizi
+                    if sentiment_option:
+                        sentiment_results = sentiment_analyzer.analyze_sentiment(advanced_text_input)
+
+                        st.markdown("### Duygu Analizi Sonuçları")
+
+                        # Duygu skoru ve tonu göster
+                        sentiment_score = sentiment_results.get('score', 0)
+                        dominant_sentiment = sentiment_results.get('dominant', 'neutral')
+
+                        # Duygu tonuna göre renk ve emoji belirle
+                        if sentiment_score > 0.2:
+                            sentiment_color = "green"
+                            sentiment_emoji = "😃"
+                        elif sentiment_score < -0.2:
+                            sentiment_color = "red"
+                            sentiment_emoji = "😠"
+                        else:
+                            sentiment_color = "orange"
+                            sentiment_emoji = "😐"
+
+                        # Dominant duygu için Türkçe karşılık
+                        sentiment_turkish = {
+                            'positive': 'Pozitif',
+                            'neutral': 'Nötr',
+                            'negative': 'Negatif'
+                        }.get(dominant_sentiment, 'Nötr')
+
+                        st.markdown(f"**Duygu Tonu:** {sentiment_emoji} {sentiment_turkish}")
+                        st.markdown(
+                            f"**Duygu Skoru:** <span style='color:{sentiment_color}'>{sentiment_score:.2f}</span> (-1 ile 1 arasında)",
+                            unsafe_allow_html=True)
+
+                        # Duygu dağılımını göster
+                        sentiment_df = pd.DataFrame({
+                            'Duygu': ['Pozitif', 'Nötr', 'Negatif'],
+                            'Skor': [
+                                sentiment_results.get('positive', 0),
+                                sentiment_results.get('neutral', 0),
+                                sentiment_results.get('negative', 0)
+                            ]
+                        })
+
+                        fig = px.bar(sentiment_df, x='Duygu', y='Skor',
+                                     color='Duygu',
+                                     color_discrete_map={'Pozitif': 'green', 'Nötr': 'gray', 'Negatif': 'red'},
+                                     title="Duygu Dağılımı")
+                        fig.update_layout(yaxis_range=[0, 1])
+                        st.plotly_chart(fig, use_container_width=True)
+
+                    # Metin iyileştirme
+                    if improvement_option:
+                        improvement_results = text_improver.improve_text(advanced_text_input)
+
+                        st.markdown("### Metin İyileştirme Önerileri")
+
+                        # Okunabilirlik göster
+                        readability = improvement_results.get('readability', {'score': 0, 'level': 'bilinmiyor'})
+
+                        # Okunabilirlik skoru için renk ve seviye belirleme
+                        readability_score = readability.get('score', 0)
+                        if readability_score >= 70:
+                            readability_color = "green"
+                        elif readability_score >= 50:
+                            readability_color = "orange"
+                        else:
+                            readability_color = "red"
+
+                        level_map = {
+                            'çok_kolay': 'Çok Kolay',
+                            'kolay': 'Kolay',
+                            'orta_kolay': 'Orta-Kolay',
+                            'orta': 'Orta',
+                            'orta_zor': 'Orta-Zor',
+                            'zor': 'Zor',
+                            'çok_zor': 'Çok Zor',
+                            'bilinmiyor': 'Bilinmiyor'
+                        }
+                        level_text = level_map.get(readability.get('level', 'bilinmiyor'), 'Bilinmiyor')
+
+                        col1, col2 = st.columns(2)
+
+                        with col1:
+                            st.metric("Okunabilirlik Skoru", f"{readability_score:.1f}/100")
+                            st.markdown(
+                                f"**Okunabilirlik Seviyesi:** <span style='color:{readability_color}'>{level_text}</span>",
+                                unsafe_allow_html=True)
+
+                        with col2:
+                            if 'avg_sentence_length' in readability:
+                                st.metric("Ortalama Cümle Uzunluğu", f"{readability['avg_sentence_length']:.1f} kelime")
+
+                        # İyileştirme önerileri
+                        improvement_count = improvement_results.get('improvement_count', 0)
+                        if improvement_count > 0:
+                            st.markdown("#### Öneriler")
+                            for i, suggestion in enumerate(improvement_results.get('suggestions', [])):
+                                st.markdown(f"{i + 1}. {suggestion}")
+
+                            # Düzeltilmiş metni göster
+                            if improvement_results.get('corrected_text', '') != advanced_text_input:
+                                st.markdown("#### Düzeltilmiş Metin")
+                                st.code(improvement_results.get('improved_text', advanced_text_input), language=None)
+                        else:
+                            st.success("✓ Bu metin için iyileştirme önerisi bulunmamaktadır. Metin kalitesi iyi.")
+            else:
+                st.error("Lütfen analiz için bir metin girin.")
+
+    # Anahtar Kelime ve Dil Tespiti sekmesi
+    with tab4:
+        st.subheader("Anahtar Kelime Çıkarma ve Dil Tespiti")
+        st.write("Bu sekmede metninizin anahtar kelimelerini çıkarabilir ve dilini tespit edebilirsiniz.")
+
+        # Analizörler oluştur
+        keyword_extractor = KeywordExtractor()
+        language_detector = LanguageDetector()
+
+        # Metin giriş alanı
+        keyword_text_input = st.text_area("Analiz edilecek metni girin:",
+                                          value=SAMPLE_TEXT,
+                                          height=150,
+                                          key="keyword_text")
+
+        # Ayarlar
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            keyword_method = st.selectbox(
+                "Anahtar Kelime Metodu",
+                ["combined", "tfidf", "textrank"],
+                help="Anahtar kelime çıkarma algoritması"
+            )
+
+        with col2:
+            num_keywords = st.slider(
+                "Anahtar Kelime Sayısı",
+                5, 20, 10,
+                help="Çıkarılacak anahtar kelime sayısı"
+            )
+
+        with col3:
+            detect_language = st.checkbox(
+                "Dil Tespiti",
+                value=True,
+                help="Metnin dilini otomatik olarak tespit eder"
+            )
+
+        if st.button("Anahtar Kelime ve Dil Analizi", type="primary", key="keyword_analyze"):
+            if keyword_text_input and len(keyword_text_input.strip()) > 0:
+                with st.spinner("Analiz yapılıyor..."):
+                    # Dil tespiti
+                    if detect_language:
+                        lang_result = language_detector.detect_language(keyword_text_input)
+
+                        st.markdown("### Dil Tespiti Sonucu")
+
+                        # Dil adı ve güven skoru
+                        lang_code = lang_result['language_code']
+                        lang_name = lang_result['language_name']
+                        confidence = lang_result['confidence']
+
+                        # Dil için bayrak ve renk
+                        lang_flags = {
+                            'tr': '🇹🇷',
+                            'en': '🇺🇸',
+                            'de': '🇩🇪',
+                            'fr': '🇫🇷',
+                            'es': '🇪🇸',
+                            'unknown': '🌐'
+                        }
+
+                        lang_flag = lang_flags.get(lang_code, '🌐')
+
+                        # Sonuçları göster
+                        confidence_color = "green" if confidence > 0.7 else "orange" if confidence > 0.4 else "red"
+
+                        st.markdown(f"### {lang_flag} Tespit Edilen Dil: {lang_name}")
+                        st.markdown(f"**Güven Skoru:** <span style='color:{confidence_color}'>{confidence:.2f}</span>", unsafe_allow_html=True)
+
+                        # Eğer tüm dil skorlarını göstermek istersek
+                        if lang_result['scores']:
+                            scores_df = pd.DataFrame({
+                                'Dil': [language_detector.supported_languages.get(code, code) for code in lang_result['scores'].keys()],
+                                'Kod': list(lang_result['scores'].keys()),
+                                'Skor': list(lang_result['scores'].values())
+                            })
+
+                            # Skorlara göre sırala
+                            scores_df = scores_df.sort_values(by='Skor', ascending=False).reset_index(drop=True)
+
+                            # En yüksek skorlu diğer dillerin skorlarını göster
+                            st.markdown("#### Dil Skorları")
+
+                            # Geniş çubuk grafik
+                            fig = px.bar(
+                                scores_df.head(5),  # En yüksek 5 skoru göster
+                                x='Skor',
+                                y='Dil',
+                                orientation='h',
+                                title="Dil Algılama Skorları",
+                                color='Skor',
+                                color_continuous_scale='Viridis'
+                            )
+
+                            fig.update_layout(height=300, yaxis={'categoryorder': 'total ascending'})
+                            st.plotly_chart(fig, use_container_width=True)
+
+                    # Anahtar kelime çıkarma
+                    keyword_results = keyword_extractor.extract_keywords(
+                        keyword_text_input,
+                        method=keyword_method,
+                        num_keywords=num_keywords
+                    )
+
+                    st.markdown("### Anahtar Kelime Analizi")
+
+                    # Kullanılan yöntemi göster
+                    method_names = {
+                        'tfidf': 'TF-IDF',
+                        'textrank': 'TextRank',
+                        'combined': 'Birleşik (TF-IDF + TextRank)'
+                    }
+
+                    st.write(f"Kullanılan yöntem: **{method_names.get(keyword_results['method'], keyword_results['method'])}**")
+
+                    # Tekil anahtar kelimeleri göster
+                    if keyword_results['keywords']:
+                        keywords_df = pd.DataFrame({
+                            'Anahtar Kelime': [kw[0] for kw in keyword_results['keywords']],
+                            'Skor': [kw[1] for kw in keyword_results['keywords']]
+                        })
+
+                        # Skorlara göre sırala
+                        keywords_df = keywords_df.sort_values(by='Skor', ascending=False).reset_index(drop=True)
+
+                        # İki sütunlu düzen
+                        col1, col2 = st.columns(2)
+
+                        with col1:
+                            # Anahtar kelime listesi
+                            st.markdown("#### Anahtar Kelimeler")
+                            for i, (keyword, score) in enumerate(zip(keywords_df['Anahtar Kelime'], keywords_df['Skor'])):
+                                # Skora göre font boyutu ve kalınlığı ayarla
+                                font_size = min(18, max(12, 12 + score * 6))
+                                font_weight = "bold" if score > 0.6 else "normal"
+                                st.markdown(
+                                    f"<span style='font-size:{font_size}px; font-weight:{font_weight}'>{i+1}. {keyword}</span> <small>({score:.2f})</small>",
+                                    unsafe_allow_html=True
+                                )
+
+                        with col2:
+                            # Anahtar kelime grafiği
+                            fig = px.bar(
+                                keywords_df,
+                                x='Anahtar Kelime',
+                                y='Skor',
+                                title="Anahtar Kelime Skorları",
+                                color='Skor',
+                                color_continuous_scale='Blues'
+                            )
+                            fig.update_layout(xaxis={'categoryorder': 'total descending'})
+                            st.plotly_chart(fig, use_container_width=True)
+                    else:
+                        st.warning("Metinde anahtar kelime bulunamadı.")
+
+                    # İkili kelime gruplarını (bigram) göster
+                    if keyword_results['bigrams']:
+                        bigrams_df = pd.DataFrame({
+                            'İkili Kelime Grubu': [bg[0] for bg in keyword_results['bigrams']],
+                            'Skor': [bg[1] for bg in keyword_results['bigrams']]
+                        })
+
+                        st.markdown("#### İkili Kelime Grupları (Bigrams)")
+
+                        # İkili kelimeleri tablo olarak göster
+                        st.dataframe(bigrams_df, use_container_width=True)
+
+                        # İkili kelime grafiği
+                        fig = px.bar(
+                            bigrams_df,
+                            x='İkili Kelime Grubu',
+                            y='Skor',
+                            title="İkili Kelime Grubu Skorları",
+                            color='Skor',
+                            color_continuous_scale='Greens'
+                        )
+                        st.plotly_chart(fig, use_container_width=True)
+
+                    # Metin içinde anahtar kelimeleri vurgula
+                    if keyword_results['keywords']:
+                        st.markdown("#### Anahtar Kelimeleri Vurgulanmış Metin")
+
+                        highlighted_text = keyword_text_input
+                        for keyword, _ in keyword_results['keywords']:
+                            # Büyük/küçük harfe duyarsız olarak değiştirme yapmak için regex
+                            pattern = re.compile(r'\b' + re.escape(keyword) + r'\b', re.IGNORECASE)
+                            replacement = f"<mark><b>{keyword}</b></mark>"
+                            highlighted_text = pattern.sub(replacement, highlighted_text)
+
+                        st.markdown(highlighted_text, unsafe_allow_html=True)
+
+                    # Özet bilgilendirme
+                    st.success(f"Metinden toplam {len(keyword_results['keywords'])} anahtar kelime ve {len(keyword_results['bigrams'])} ikili kelime grubu çıkarıldı.")
+            else:
+                st.error("Lütfen analiz için bir metin girin.")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        st.error(f"Beklenmeyen bir hata oluştu: {str(e)}")
+        logger.exception(f"Beklenmeyen bir hata: {str(e)}")

data/sample_data.csv

@@ -0,0 +1,11 @@
+id,metin,kategori
+1,"Bu, içeriği zengin ve doğru dilbilgisi kullanılarak yazılmış yüksek kaliteli bir metin örneğidir. Cümleler açık ve anlaşılır, kelime çeşitliliği yeterlidir.",A
+2,"kısa metin örneği",B
+3,"Bu metin zararlı içerik örnekleridir ve birçok hakaret ve kötü söz içerir. Seni hiç sevmiyorum, çok aptal ve beceriksizsin!",C
+4,"Bu metin gereksiz tekrarlar içerir. Aynı kelimeyi tekrar tekrar tekrar tekrar tekrar kullanır. Ayrıca çok fazla dolgu kelimesi kullanır, yani, şey, aslında, gerçekten, sadece tekrar eder durur.",B
+5,"Oldukça uzun ve detaylı bir metin örneği. Birçok farklı konu içerir ve konular arasındaki geçişler akıcıdır. Cümleler düzgün ve çeşitlidir. Kelime dağarcığı zengindir ve noktalama işaretleri doğru kullanılmıştır. Metinde herhangi bir yazım hatası veya dilbilgisi hatası bulunmamaktadır. Konular tutarlı bir şekilde ele alınmış ve gerekli açıklamalar yapılmıştır. Okuyucunun konuyu anlaması için gerekli bilgiler sağlanmıştır.",A
+6,"bu metinde büyük harf kullanilmamis ve noktalama isaretleri yok ayrica yazim hatalari var metinn kalitesi dusuk",C
+7,"Merhaba, bu normal bir metindir. Kalitesi orta düzeydedir, ne çok iyi ne de çok kötü.",B
+8,"Yarın buluşmaya ne dersin? Bu öneriyi düşüneceğini umuyorum. İyi günler!",A
+9,"Sen çok kötü bir insansın, senden nefret ediyorum! Aptalsın ve beceriksizsin. Kaybol!",C
+10,"Metni çok uzatmak için gereksiz dolgu kelimeleri kullanılabilir, aynı şekilde, bu tür kelimeler metnin kalitesini düşürür, yani anlamını zayıflatır, aslında okuyucunun ilgisini kaybetmesine neden olur, bu yüzden mümkün olduğunca az kullanılmalıdır, gerçekten öyle.",B

models/model_loader.py

@@ -0,0 +1,105 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from transformers import pipeline
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+
+class ModelManager:
+    def __init__(self):
+        self.toxicity_model = None
+        self.toxicity_tokenizer = None
+        self.quality_model = None
+        self.quality_tokenizer = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        logging.info(f"Using device: {self.device}")
+
+    def load_toxicity_model(self, model_name="savasy/bert-base-turkish-sentiment"):
+        """
+        Zararlılık tespiti için model yükleme
+        """
+        try:
+            logging.info(f"Loading toxicity model: {model_name}")
+            self.toxicity_tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.toxicity_model = AutoModelForSequenceClassification.from_pretrained(model_name)
+            logging.info("Toxicity model loaded successfully")
+            return True
+        except Exception as e:
+            logging.error(f"Error loading toxicity model: {str(e)}")
+            # Alternatif model deneyelim
+            try:
+                backup_model = "dbmdz/bert-base-turkish-cased"
+                logging.info(f"Trying backup Turkish model: {backup_model}")
+                self.toxicity_tokenizer = AutoTokenizer.from_pretrained(backup_model)
+                self.toxicity_model = AutoModelForSequenceClassification.from_pretrained(backup_model)
+                logging.info("Backup Turkish model loaded successfully")
+                return True
+            except Exception as e2:
+                logging.error(f"Error loading backup Turkish model: {str(e2)}")
+                try:
+                    english_model = "distilbert/distilbert-base-uncased-finetuned-sst-2-english"
+                    logging.info(f"Trying English sentiment model: {english_model}")
+                    self.toxicity_tokenizer = AutoTokenizer.from_pretrained(english_model)
+                    self.toxicity_model = AutoModelForSequenceClassification.from_pretrained(english_model)
+                    logging.info("English sentiment model loaded successfully")
+                    return True
+                except Exception as e3:
+                    logging.error(f"Error loading English model: {str(e3)}")
+                    return False
+
+    def load_quality_model(self, model_name="sshleifer/distilbart-cnn-6-6"):
+        """
+        Metin kalitesi değerlendirmesi için model yükleme (özetleme kapasitesi olan bir model)
+        """
+        try:
+            logging.info(f"Loading quality model: {model_name}")
+            self.quality_pipeline = pipeline(
+                "text2text-generation",
+                model=model_name,
+                tokenizer=model_name,
+                device=0 if self.device == "cuda" else -1
+            )
+            logging.info("Quality model loaded successfully")
+            return True
+        except Exception as e:
+            logging.error(f"Error loading quality model: {str(e)}")
+
+            # Daha hafif bir model deneyelim
+            try:
+                backup_model = "Helsinki-NLP/opus-mt-tc-big-tr-en"
+                logging.info(f"Trying Turkish translation model for quality: {backup_model}")
+                self.quality_pipeline = pipeline(
+                    "translation",
+                    model=backup_model,
+                    tokenizer=backup_model,
+                    device=0 if self.device == "cuda" else -1
+                )
+                logging.info("Turkish translation model loaded successfully")
+                return True
+            except Exception as e2:
+                logging.error(f"Error loading Turkish translation model: {str(e2)}")
+                try:
+                    light_model = "sshleifer/distilbart-xsum-12-6"
+                    logging.info(f"Trying lighter quality model: {light_model}")
+                    self.quality_pipeline = pipeline(
+                        "text2text-generation",
+                        model=light_model,
+                        tokenizer=light_model,
+                        device=0 if self.device == "cuda" else -1
+                    )
+                    logging.info("Lighter quality model loaded successfully")
+                    return True
+                except Exception as e3:
+                    logging.error(f"Error loading lighter quality model: {str(e3)}")
+                    return False
+
+    def get_models(self):
+        """
+        Yüklenen modelleri döndürür
+        """
+        return {
+            "toxicity_model": self.toxicity_model,
+            "toxicity_tokenizer": self.toxicity_tokenizer,
+            "quality_pipeline": self.quality_pipeline if hasattr(self, 'quality_pipeline') else None
+        }

models/model_manager.py

@@ -0,0 +1,316 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from transformers import pipeline
+import logging
+import os
+import json
+import time
+from typing import List, Dict, Any, Tuple, Optional, Union
+from models.model_selector import ModelSelector
+
+# Loglama yapılandırması
+logger = logging.getLogger(__name__)
+handler = logging.StreamHandler()
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+logger.setLevel(logging.INFO)
+
+
+class ModelManager:
+    """
+    Metin kalitesi ve zararlılık değerlendirmesi için NLP modellerini yöneten sınıf.
+    Bu sınıf, modellerin yüklenmesi, değerlendirilmesi ve seçilmesinden sorumludur.
+    """
+
+    def __init__(self, cache_dir: Optional[str] = None, use_cache: bool = True) -> None:
+        """
+        Model Yöneticisi sınıfını başlatır.
+
+        Args:
+            cache_dir: Modellerin önbelleğe alınacağı dizin
+            use_cache: Önbellek kullanımını etkinleştir/devre dışı bırak
+        """
+        self.toxicity_model = None
+        self.toxicity_tokenizer = None
+        self.quality_pipeline = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.cache_dir = cache_dir or os.path.join(os.path.expanduser("~"), ".text_quality_toxicity_cache")
+        self.use_cache = use_cache
+        self.model_selector = ModelSelector(cache_dir=self.cache_dir, use_cache=self.use_cache)
+        self.model_info = {
+            "toxicity": {
+                "name": "Bilinmeyen Model",
+                "description": "Model henüz yüklenmedi",
+                "language": "unknown"
+            },
+            "quality": {
+                "name": "Bilinmeyen Model",
+                "description": "Model henüz yüklenmedi",
+                "language": "unknown"
+            }
+        }
+
+        # Önbellek dizinini oluştur
+        if self.use_cache and not os.path.exists(self.cache_dir):
+            os.makedirs(self.cache_dir, exist_ok=True)
+
+        logger.info(
+            f"ModelManager başlatıldı. Cihaz: {self.device}, Önbellek: {'Etkin' if use_cache else 'Devre dışı'}")
+
+    def load_models_auto_select(self, sample_texts: Optional[List[str]] = None) -> bool:
+        """
+        En iyi modelleri otomatik olarak seçerek yükler.
+
+        Args:
+            sample_texts: Model seçimi için örnek metinler
+
+        Returns:
+            bool: Yükleme başarılı mı?
+        """
+        if sample_texts is None or len(sample_texts) == 0:
+            # Örnek metinler yoksa varsayılan örnekler kullan
+            sample_texts = [
+                "Türkiye, zengin tarihi ve kültürel mirası ile güzel bir ülkedir.",
+                "Bu ürün tam bir hayal kırıklığı! Paramı geri istiyorum!",
+                "Bugün hava çok güzel. Parkta yürüyüş yaptım ve kuşları izledim.",
+                "Sen ne anlarsın ki bu konudan? Boş konuşma artık!"
+            ]
+
+        try:
+            logger.info("Otomatik model seçimi başlatılıyor...")
+            start_time = time.time()
+
+            success = self.model_selector.select_best_models(sample_texts)
+
+            if success:
+                best_models = self.model_selector.get_best_models()
+                self.toxicity_model = best_models["toxicity_model"]
+                self.toxicity_tokenizer = best_models["toxicity_tokenizer"]
+                self.quality_pipeline = best_models["quality_pipeline"]
+                self.model_info["toxicity"] = best_models["toxicity_model_info"]
+                self.model_info["quality"] = best_models["quality_model_info"]
+
+                selection_time = time.time() - start_time
+                logger.info(f"Otomatik model seçimi {selection_time:.2f} saniyede tamamlandı")
+                logger.info(f"Seçilen zararlılık modeli: {self.model_info['toxicity']['name']}")
+                logger.info(f"Seçilen kalite modeli: {self.model_info['quality']['name']}")
+
+                # Kullanılan modelleri önbelleğe kaydet
+                if self.use_cache:
+                    self._save_models_to_cache()
+
+                return True
+            else:
+                logger.error("Otomatik model seçimi başarısız oldu, varsayılan modellere dönülüyor")
+                return self.load_default_models()
+
+        except Exception as e:
+            logger.error(f"Otomatik model seçimi sırasında hata: {str(e)}")
+            return self.load_default_models()
+
+    def load_default_models(self) -> bool:
+        """
+        Varsayılan modelleri yükler (otomatik seçim başarısız olursa).
+
+        Returns:
+            bool: Yükleme başarılı mı?
+        """
+        logger.info("Varsayılan modeller yükleniyor...")
+
+        # Önce önbellekten yüklemeyi dene
+        if self.use_cache and self._load_models_from_cache():
+            logger.info("Modeller önbellekten başarıyla yüklendi")
+            return True
+
+        success_toxicity = self.load_toxicity_model()
+        success_quality = self.load_quality_model()
+
+        overall_success = success_toxicity and success_quality
+
+        if overall_success and self.use_cache:
+            self._save_models_to_cache()
+
+        return overall_success
+
+    def load_toxicity_model(self, model_name: str = "savasy/bert-base-turkish-sentiment") -> bool:
+        """
+        Zararlılık tespiti için model yükleme.
+
+        Args:
+            model_name: Yüklenecek model ismi
+
+        Returns:
+            bool: Yükleme başarılı mı?
+        """
+        try:
+            logger.info(f"Zararlılık modeli yükleniyor: {model_name}")
+            self.toxicity_tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.toxicity_model = AutoModelForSequenceClassification.from_pretrained(model_name)
+            self.model_info["toxicity"]["name"] = model_name
+            self.model_info["toxicity"]["description"] = "Türkçe duygu analizi modeli"
+            self.model_info["toxicity"]["language"] = "tr"
+            logger.info("Zararlılık modeli başarıyla yüklendi")
+            return True
+        except Exception as e:
+            logger.error(f"Zararlılık modeli yüklenirken hata: {str(e)}")
+            # Alternatif model deneyelim
+            try:
+                backup_model = "dbmdz/bert-base-turkish-cased"
+                logger.info(f"Yedek Türkçe model deneniyor: {backup_model}")
+                self.toxicity_tokenizer = AutoTokenizer.from_pretrained(backup_model)
+                self.toxicity_model = AutoModelForSequenceClassification.from_pretrained(backup_model)
+                self.model_info["toxicity"]["name"] = backup_model
+                self.model_info["toxicity"]["description"] = "Genel amaçlı Türkçe BERT modeli"
+                self.model_info["toxicity"]["language"] = "tr"
+                logger.info("Yedek Türkçe model başarıyla yüklendi")
+                return True
+            except Exception as e2:
+                logger.error(f"Yedek Türkçe model yüklenirken hata: {str(e2)}")
+                try:
+                    fallback_model = "distilbert/distilbert-base-uncased-finetuned-sst-2-english"
+                    logger.info(f"İngilizce duygu analizi modeli deneniyor: {fallback_model}")
+                    self.toxicity_tokenizer = AutoTokenizer.from_pretrained(fallback_model)
+                    self.toxicity_model = AutoModelForSequenceClassification.from_pretrained(fallback_model)
+                    self.model_info["toxicity"]["name"] = fallback_model
+                    self.model_info["toxicity"]["description"] = "İngilizce duygu analizi modeli"
+                    self.model_info["toxicity"]["language"] = "en"
+                    logger.info("İngilizce duygu analizi modeli başarıyla yüklendi")
+                    return True
+                except Exception as e3:
+                    logger.error(f"İngilizce model yüklenirken hata: {str(e3)}")
+                    return False
+
+    def load_quality_model(self, model_name: str = "sshleifer/distilbart-cnn-6-6") -> bool:
+        """
+        Metin kalitesi değerlendirmesi için model yükleme.
+
+        Args:
+            model_name: Yüklenecek model ismi
+
+        Returns:
+            bool: Yükleme başarılı mı?
+        """
+        try:
+            logger.info(f"Kalite modeli yükleniyor: {model_name}")
+            self.quality_pipeline = pipeline(
+                "text2text-generation",
+                model=model_name,
+                tokenizer=model_name,
+                device=0 if self.device == "cuda" else -1
+            )
+            self.model_info["quality"]["name"] = model_name
+            self.model_info["quality"]["description"] = "İngilizce metin özetleme modeli"
+            self.model_info["quality"]["language"] = "en"
+            logger.info("Kalite modeli başarıyla yüklendi")
+            return True
+        except Exception as e:
+            logger.error(f"Kalite modeli yüklenirken hata: {str(e)}")
+
+            # Daha hafif bir model deneyelim
+            try:
+                backup_model = "Helsinki-NLP/opus-mt-tr-en"
+                logger.info(f"Türkçe çeviri modeli deneniyor: {backup_model}")
+                self.quality_pipeline = pipeline(
+                    "translation",
+                    model=backup_model,
+                    device=0 if self.device == "cuda" else -1
+                )
+                self.model_info["quality"]["name"] = backup_model
+                self.model_info["quality"]["description"] = "Türkçe-İngilizce çeviri modeli"
+                self.model_info["quality"]["language"] = "tr"
+                logger.info("Türkçe çeviri modeli başarıyla yüklendi")
+                return True
+            except Exception as e2:
+                logger.error(f"Türkçe çeviri modeli yüklenirken hata: {str(e2)}")
+                try:
+                    light_model = "sshleifer/distilbart-xsum-12-6"
+                    logger.info(f"Daha hafif özetleme modeli deneniyor: {light_model}")
+                    self.quality_pipeline = pipeline(
+                        "text2text-generation",
+                        model=light_model,
+                        device=0 if self.device == "cuda" else -1
+                    )
+                    self.model_info["quality"]["name"] = light_model
+                    self.model_info["quality"]["description"] = "Hafif İngilizce özetleme modeli"
+                    self.model_info["quality"]["language"] = "en"
+                    logger.info("Hafif özetleme modeli başarıyla yüklendi")
+                    return True
+                except Exception as e3:
+                    logger.error(f"Hafif özetleme modeli yüklenirken hata: {str(e3)}")
+                    return False
+
+    def _save_models_to_cache(self) -> None:
+        """Kullanılan modellerin bilgilerini önbelleğe kaydeder."""
+        if not self.use_cache:
+            return
+
+        try:
+            cache_file = os.path.join(self.cache_dir, "model_manager_state.json")
+
+            cache_data = {
+                "timestamp": time.time(),
+                "model_info": self.model_info
+            }
+
+            with open(cache_file, 'w', encoding='utf-8') as f:
+                json.dump(cache_data, f, ensure_ascii=False, indent=2)
+
+            logger.info(f"Model bilgileri önbelleğe kaydedildi: {cache_file}")
+        except Exception as e:
+            logger.error(f"Önbelleğe kaydetme hatası: {str(e)}")
+
+    def _load_models_from_cache(self) -> bool:
+        """
+        Önbellekten model bilgilerini yükler.
+
+        Returns:
+            bool: Yükleme başarılı mı?
+        """
+        if not self.use_cache:
+            return False
+
+        try:
+            cache_file = os.path.join(self.cache_dir, "model_manager_state.json")
+
+            if not os.path.exists(cache_file):
+                return False
+
+            # Önbellek dosyasının yaşını kontrol et (24 saatten eskiyse yok say)
+            file_age = time.time() - os.path.getmtime(cache_file)
+            if file_age > 86400:  # 24 saat = 86400 saniye
+                logger.info(f"Önbellek dosyası çok eski ({file_age / 3600:.1f} saat), yeniden yükleme yapılacak")
+                return False
+
+            with open(cache_file, 'r', encoding='utf-8') as f:
+                cache_data = json.load(f)
+
+            # Model bilgilerini önbellekten al
+            self.model_info = cache_data.get("model_info", self.model_info)
+
+            # Önbellekteki bilgilerle yeniden yükleme yap
+            toxicity_name = self.model_info["toxicity"].get("name")
+            quality_name = self.model_info["quality"].get("name")
+
+            toxicity_success = self.load_toxicity_model(toxicity_name) if toxicity_name else False
+            quality_success = self.load_quality_model(quality_name) if quality_name else False
+
+            return toxicity_success and quality_success
+
+        except Exception as e:
+            logger.error(f"Önbellekten model yükleme hatası: {str(e)}")
+            return False
+
+    def get_models(self) -> Dict[str, Any]:
+        """
+        Yüklenen modelleri ve bilgilerini döndürür.
+
+        Returns:
+            Dict[str, Any]: Model, tokenizer, pipeline ve model bilgileri
+        """
+        return {
+            "toxicity_model": self.toxicity_model,
+            "toxicity_tokenizer": self.toxicity_tokenizer,
+            "quality_pipeline": self.quality_pipeline,
+            "model_info": self.model_info
+        }

models/model_selector.py

@@ -0,0 +1,571 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+import logging
+import time
+import numpy as np
+from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
+import os
+import json
+from typing import List, Dict, Any, Tuple, Optional, Union
+import threading
+
+# Loglama yapılandırması
+logger = logging.getLogger(__name__)
+handler = logging.StreamHandler()
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+logger.setLevel(logging.INFO)
+
+
+class ModelSelector:
+    """
+    Farklı NLP modellerini değerlendirip en iyi performansı sağlayanı seçen sınıf.
+    """
+
+    def __init__(self, cache_dir: Optional[str] = None, use_cache: bool = True) -> None:
+        """
+        Model Seçici sınıfını başlatır.
+
+        Args:
+            cache_dir: Model ve değerlendirme sonuçlarının önbelleğe alınacağı dizin
+            use_cache: Önbellek kullanımını etkinleştir/devre dışı bırak
+        """
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.toxicity_models = []
+        self.quality_models = []
+        self.best_toxicity_model = None
+        self.best_quality_model = None
+        self.use_cache = use_cache
+        self.cache_dir = cache_dir or os.path.join(os.path.expanduser("~"), ".text_quality_toxicity_cache")
+
+        # Önbellek dizinini oluştur
+        if self.use_cache and not os.path.exists(self.cache_dir):
+            os.makedirs(self.cache_dir, exist_ok=True)
+
+        logger.info(
+            f"ModelSelector başlatıldı. Cihaz: {self.device}, Önbellek: {'Etkin' if use_cache else 'Devre dışı'}")
+
+    def load_candidate_models(self) -> bool:
+        """
+        Değerlendirme için aday modelleri yükler.
+
+        Returns:
+            bool: Yükleme başarılı mı?
+        """
+        # Önbellekten okunan modeller
+        cached_models = self._load_from_cache()
+        if cached_models:
+            self.toxicity_models = cached_models.get("toxicity_models", [])
+            self.quality_models = cached_models.get("quality_models", [])
+            self.best_toxicity_model = cached_models.get("best_toxicity_model")
+            self.best_quality_model = cached_models.get("best_quality_model")
+
+            # Önbellek bulundu, doğrulama yap
+            if self.best_toxicity_model and self.best_quality_model:
+                logger.info("Önbellekten en iyi modeller yüklendi.")
+                # Tokenizer ve model erişilebilir mi kontrol et
+                if "tokenizer" in self.best_toxicity_model and "model" in self.best_toxicity_model:
+                    # En iyi model önbellekten doğru yüklendi
+                    return True
+
+        # Zararlılık modelleri - Türkçe için optimize edilmiş
+        toxicity_candidates = [
+            {"name": "savasy/bert-base-turkish-sentiment", "type": "sentiment",
+             "language": "tr", "priority": 1, "description": "Türkçe duygu analizi için BERT modeli"},
+            {"name": "loodos/electra-turkish-sentiment", "type": "sentiment",
+             "language": "tr", "priority": 2, "description": "Türkçe duygu analizi için ELECTRA modeli"},
+            {"name": "dbmdz/bert-base-turkish-cased", "type": "general",
+             "language": "tr", "priority": 3, "description": "Genel amaçlı Türkçe BERT modeli"},
+            {"name": "ytu-ce-cosmos/turkish-bert-uncased-toxicity", "type": "toxicity",
+             "language": "tr", "priority": 4, "description": "Türkçe zararlılık tespiti için BERT modeli",
+             "optional": True},
+            {"name": "unitary/toxic-bert", "type": "toxicity",
+             "language": "en", "priority": 5, "description": "İngilizce zararlılık tespiti BERT modeli"}
+        ]
+
+        # Kalite modelleri
+        quality_candidates = [
+            {"name": "Helsinki-NLP/opus-mt-tr-en", "type": "translation",
+             "language": "tr", "priority": 1, "description": "Türkçe-İngilizce çeviri modeli"},
+            {"name": "tuner/pegasus-turkish", "type": "summarization",
+             "language": "tr", "priority": 2, "description": "Türkçe özetleme için PEGASUS modeli", "optional": True},
+            {"name": "dbmdz/t5-base-turkish-summarization", "type": "summarization",
+             "language": "tr", "priority": 3, "description": "Türkçe özetleme için T5 modeli", "optional": True},
+            {"name": "sshleifer/distilbart-cnn-6-6", "type": "summarization",
+             "language": "en", "priority": 4, "description": "İngilizce özetleme için DistilBART modeli"}
+        ]
+
+        # Modelleri önceliğe göre sırala
+        toxicity_candidates.sort(key=lambda x: x.get("priority", 999))
+        quality_candidates.sort(key=lambda x: x.get("priority", 999))
+
+        # Zaman aşımını önlemek için asenkron model yükleme
+        self._load_models_async(toxicity_candidates, quality_candidates)
+
+        # Yeterli model yüklendi mi kontrol et
+        return len(self.toxicity_models) > 0 and len(self.quality_models) > 0
+
+    def _load_models_async(self, toxicity_candidates: List[Dict[str, Any]],
+                           quality_candidates: List[Dict[str, Any]]) -> None:
+        """
+        Modelleri asenkron olarak yükler
+
+        Args:
+            toxicity_candidates: Zararlılık modellerinin listesi
+            quality_candidates: Kalite modellerinin listesi
+        """
+        # Zararlılık modelleri için eş zamanlı yükleme
+        toxicity_threads = []
+        for candidate in toxicity_candidates:
+            thread = threading.Thread(
+                target=self._load_toxicity_model,
+                args=(candidate,)
+            )
+            thread.start()
+            toxicity_threads.append(thread)
+
+        # Kalite modelleri için eş zamanlı yükleme
+        quality_threads = []
+        for candidate in quality_candidates:
+            thread = threading.Thread(
+                target=self._load_quality_model,
+                args=(candidate,)
+            )
+            thread.start()
+            quality_threads.append(thread)
+
+        # Tüm işlemlerin tamamlanmasını bekle (timeout ile)
+        for thread in toxicity_threads:
+            thread.join(timeout=60)  # Her model için 60 saniye timeout
+
+        for thread in quality_threads:
+            thread.join(timeout=60)  # Her model için 60 saniye timeout
+
+    def _load_toxicity_model(self, candidate: Dict[str, Any]) -> None:
+        """
+        Bir zararlılık modelini yükler
+
+        Args:
+            candidate: Model bilgilerini içeren sözlük
+        """
+        try:
+            logger.info(f"Zararlılık modeli yükleniyor: {candidate['name']}")
+            start_time = time.time()
+
+            tokenizer = AutoTokenizer.from_pretrained(candidate["name"])
+            model = AutoModelForSequenceClassification.from_pretrained(candidate["name"])
+            model.to(self.device)
+
+            load_time = time.time() - start_time
+            candidate["tokenizer"] = tokenizer
+            candidate["model"] = model
+            candidate["load_time"] = load_time
+
+            # Liste eşzamanlı erişim için koruma
+            with threading.Lock():
+                self.toxicity_models.append(candidate)
+
+            logger.info(f"{candidate['name']} modeli {load_time:.2f} saniyede başarıyla yüklendi")
+        except Exception as e:
+            if candidate.get("optional", False):
+                logger.warning(f"Opsiyonel model {candidate['name']} atlanıyor: {str(e)}")
+            else:
+                logger.error(f"{candidate['name']} yüklenirken hata: {str(e)}")
+
+    def _load_quality_model(self, candidate: Dict[str, Any]) -> None:
+        """
+        Bir kalite modelini yükler
+
+        Args:
+            candidate: Model bilgilerini içeren sözlük
+        """
+        try:
+            logger.info(f"Kalite modeli yükleniyor: {candidate['name']}")
+            start_time = time.time()
+
+            if candidate["type"] == "translation":
+                pipe = pipeline("translation", model=candidate["name"], device=0 if self.device == "cuda" else -1)
+            elif candidate["type"] == "summarization":
+                pipe = pipeline("summarization", model=candidate["name"], device=0 if self.device == "cuda" else -1)
+
+            load_time = time.time() - start_time
+            candidate["pipeline"] = pipe
+            candidate["load_time"] = load_time
+
+            # Liste eşzamanlı erişim için koruma
+            with threading.Lock():
+                self.quality_models.append(candidate)
+
+            logger.info(f"{candidate['name']} modeli {load_time:.2f} saniyede başarıyla yüklendi")
+        except Exception as e:
+            if candidate.get("optional", False):
+                logger.warning(f"Opsiyonel model {candidate['name']} atlanıyor: {str(e)}")
+            else:
+                logger.error(f"{candidate['name']} yüklenirken hata: {str(e)}")
+
+    def evaluate_toxicity_models(self, validation_texts: List[str],
+                                 validation_labels: List[int]) -> Optional[Dict[str, Any]]:
+        """
+        Zararlılık modellerini değerlendirir ve en iyisini seçer
+
+        Args:
+            validation_texts: Doğrulama metinleri
+            validation_labels: Doğrulama etiketleri (1=zararlı, 0=zararsız)
+
+        Returns:
+            Dict[str, Any]: En iyi modelin bilgileri veya None
+        """
+        if not self.toxicity_models:
+            logger.error("Değerlendirme için zararlılık modeli yüklenmemiş")
+            return None
+
+        results = []
+
+        for model_info in self.toxicity_models:
+            logger.info(f"Zararlılık modeli değerlendiriliyor: {model_info['name']}")
+            model = model_info["model"]
+            tokenizer = model_info["tokenizer"]
+
+            predictions = []
+            start_time = time.time()
+
+            try:
+                for text in validation_texts:
+                    # Metni tokenize et
+                    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+                    inputs = {key: val.to(self.device) for key, val in inputs.items()}
+
+                    # Tahmin yap
+                    with torch.no_grad():
+                        outputs = model(**inputs)
+
+                    # Sonucu almak için model tipine göre işlem yap
+                    if model_info["type"] == "sentiment":
+                        # Sentiment modellerinde genellikle 0=negatif, 1=nötr, 2=pozitif
+                        # veya 0=negatif, 1=pozitif
+                        probs = torch.softmax(outputs.logits, dim=1).cpu().numpy()[0]
+                        if len(probs) >= 3:
+                            # Negatif olasılığını zararlılık olarak kabul et
+                            pred = 1 if probs[0] > 0.5 else 0
+                        else:
+                            # İki sınıflı model
+                            pred = 1 if probs[0] > 0.5 else 0
+                    elif model_info["type"] == "toxicity":
+                        # Toxicity modelleri genellikle 0=non-toxic, 1=toxic
+                        probs = torch.softmax(outputs.logits, dim=1).cpu().numpy()[0]
+                        pred = 1 if probs[1] > 0.5 else 0
+                    else:
+                        # Genel model - varsayılan
+                        probs = torch.softmax(outputs.logits, dim=1).cpu().numpy()[0]
+                        pred = 1 if probs[0] > 0.5 else 0
+
+                    predictions.append(pred)
+
+                eval_time = time.time() - start_time
+
+                # Performans metrikleri hesapla
+                accuracy = accuracy_score(validation_labels, predictions)
+                precision = precision_score(validation_labels, predictions, average='binary', zero_division=0)
+                recall = recall_score(validation_labels, predictions, average='binary', zero_division=0)
+                f1 = f1_score(validation_labels, predictions, average='binary', zero_division=0)
+
+                # F1, precision ve recall'un ağırlıklı ortalaması
+                weighted_score = (f1 * 0.5) + (precision * 0.3) + (recall * 0.2)
+
+                # Sonuçları kaydet
+                evaluation_result = {
+                    "model": model_info,
+                    "accuracy": float(accuracy),
+                    "precision": float(precision),
+                    "recall": float(recall),
+                    "f1_score": float(f1),
+                    "weighted_score": float(weighted_score),
+                    "eval_time": float(eval_time),
+                    "predictions": predictions
+                }
+
+                results.append(evaluation_result)
+
+                logger.info(
+                    f"{model_info['name']} - Doğruluk: {accuracy:.4f}, "
+                    f"F1: {f1:.4f}, Precision: {precision:.4f}, "
+                    f"Recall: {recall:.4f}, Süre: {eval_time:.2f}s"
+                )
+
+            except Exception as e:
+                logger.error(f"{model_info['name']} değerlendirilirken hata: {str(e)}")
+
+        if not results:
+            logger.error("Hiçbir model değerlendirilemedi")
+            return None
+
+        # Sıralama ve en iyi modeli seç (ağırlıklı skora göre)
+        results.sort(key=lambda x: x["weighted_score"], reverse=True)
+        best_model = results[0]["model"]
+
+        logger.info(
+            f"En iyi zararlılık modeli: {best_model['name']} - "
+            f"Ağırlıklı skor: {results[0]['weighted_score']:.4f}, "
+            f"F1: {results[0]['f1_score']:.4f}"
+        )
+
+        self.best_toxicity_model = best_model
+
+        # Önbelleğe kaydet
+        if self.use_cache:
+            self._save_to_cache()
+
+        return best_model
+
+    def evaluate_quality_models(self, validation_texts: List[str],
+                                reference_summaries: Optional[List[str]] = None) -> Optional[Dict[str, Any]]:
+        """
+        Kalite modellerini değerlendirir ve en iyisini seçer
+
+        Args:
+            validation_texts: Doğrulama metinleri
+            reference_summaries: Referans özetler (opsiyonel)
+
+        Returns:
+            Dict[str, Any]: En iyi modelin bilgileri veya None
+        """
+        if not self.quality_models:
+            logger.error("Değerlendirme için kalite modeli yüklenmemiş")
+            return None
+
+        results = []
+
+        for model_info in self.quality_models:
+            logger.info(f"Kalite modeli değerlendiriliyor: {model_info['name']}")
+            pipe = model_info["pipeline"]
+
+            start_time = time.time()
+            processing_success = 0
+            avg_processing_time = []
+
+            # Her metni değerlendir
+            for i, text in enumerate(validation_texts[:5]):  # Performans için sadece ilk 5 metni değerlendir
+                try:
+                    text_start_time = time.time()
+
+                    if model_info["type"] == "translation":
+                        _ = pipe(text, max_length=100)
+                    elif model_info["type"] == "summarization":
+                        # Çok kısa metinlerde sorun oluşmaması için metin uzunluğunu kontrol et
+                        text_words = len(text.split())
+                        max_length = min(100, max(30, text_words // 2))
+                        min_length = min(30, max(5, text_words // 4))
+                        _ = pipe(text, max_length=max_length, min_length=min_length, do_sample=False)
+
+                    text_process_time = time.time() - text_start_time
+                    avg_processing_time.append(text_process_time)
+                    processing_success += 1
+
+                except Exception as e:
+                    logger.warning(f"{model_info['name']} için metin {i} işlenirken hata: {str(e)}")
+
+            eval_time = time.time() - start_time
+            success_rate = processing_success / min(5, len(validation_texts))
+            avg_time = np.mean(avg_processing_time) if avg_processing_time else float('inf')
+
+            # Modelin tipine göre skoru ayarla
+            if model_info["language"] == "tr":
+                # Türkçe modeller için daha yüksek ağırlık
+                language_weight = 1.2
+            else:
+                language_weight = 0.8
+
+            # Sonuçları kaydet
+            evaluation_result = {
+                "model": model_info,
+                "success_rate": float(success_rate),
+                "avg_processing_time": float(avg_time),
+                "eval_time": float(eval_time),
+                "language_weight": float(language_weight)
+            }
+
+            results.append(evaluation_result)
+
+            logger.info(
+                f"{model_info['name']} - Başarı Oranı: {success_rate:.2f}, "
+                f"Ortalama İşleme Süresi: {avg_time:.4f}s, "
+                f"Toplam Süre: {eval_time:.2f}s"
+            )
+
+        if not results:
+            logger.error("Hiçbir kalite modeli değerlendirilemedi")
+            return None
+
+        # Sıralama ve en iyi modeli seç
+        # Başarı oranı, dil ağırlığı ve hız faktörlerini dengeleyen bir formül
+        for result in results:
+            result["score"] = (
+                    result["success_rate"] * 0.6 +
+                    (1 / (1 + result["avg_processing_time"])) * 0.2 +
+                    result["language_weight"] * 0.2
+            )
+
+        results.sort(key=lambda x: x["score"], reverse=True)
+        best_model = results[0]["model"]
+
+        logger.info(
+            f"En iyi kalite modeli: {best_model['name']} - "
+            f"Skor: {results[0]['score']:.4f}, "
+            f"Başarı Oranı: {results[0]['success_rate']:.2f}"
+        )
+
+        self.best_quality_model = best_model
+
+        # Önbelleğe kaydet
+        if self.use_cache:
+            self._save_to_cache()
+
+        return best_model
+
+    def select_best_models(self, sample_texts: List[str]) -> bool:
+        """
+        En iyi modelleri örnek veriyle otomatik olarak seçer
+
+        Args:
+            sample_texts: Örnek metinler listesi
+
+        Returns:
+            bool: Model seçimi başarılı mı?
+        """
+        # Modeller önbellekten yüklendiyse doğrudan kullan
+        if self.best_toxicity_model and self.best_quality_model:
+            logger.info("En iyi modeller önbellekten kullanılıyor")
+            return True
+
+        if not self.toxicity_models or not self.quality_models:
+            if not self.load_candidate_models():
+                logger.error("Aday modeller yüklenemedi")
+                return False
+
+        # Basit zararlılık değerlendirmesi için örnekler
+        toxic_samples = [
+            "Bu insanlar gerçekten çok aptal! Hepsi geri zekalı ve cahil.",
+            "Senden nefret ediyorum, kaybol buradan!",
+            "sen ne anlarsın ki bu konudan? gerizekalılar bile senden daha mantıklı konuşur"
+        ]
+
+        non_toxic_samples = [
+            "Türkiye, zengin tarihi ve kültürel mirası ile güzel bir ülkedir.",
+            "Bugün hava çok güzel. Parkta yürüyüş yaptım ve kuşları izledim.",
+            "Bilgisayarınızı hızlandırmak için gereksiz programları kaldırın."
+        ]
+
+        # Doğrulama verisi hazırla
+        validation_texts = toxic_samples + non_toxic_samples
+        if sample_texts and len(sample_texts) > 0:
+            # Kullanıcı örneklerinden bir kısmını ekle (en fazla 5 tane)
+            validation_texts.extend(sample_texts[:5])
+
+        validation_labels = [1, 1, 1, 0, 0, 0] + [0] * min(5, len(sample_texts))
+
+        # En iyi zararlılık modelini seç
+        best_toxicity = self.evaluate_toxicity_models(validation_texts, validation_labels)
+
+        # En iyi kalite modelini seç
+        best_quality = self.evaluate_quality_models(validation_texts)
+
+        success = best_toxicity is not None and best_quality is not None
+
+        if success and self.use_cache:
+            self._save_to_cache()
+
+        return success
+
+    def get_best_models(self) -> Dict[str, Any]:
+        """
+        Seçilen en iyi modelleri döndürür
+
+        Returns:
+            Dict[str, Any]: En iyi modellerin bilgileri
+        """
+        return {
+            "toxicity_model": self.best_toxicity_model["model"] if self.best_toxicity_model else None,
+            "toxicity_tokenizer": self.best_toxicity_model["tokenizer"] if self.best_toxicity_model else None,
+            "quality_pipeline": self.best_quality_model["pipeline"] if self.best_quality_model else None,
+            "toxicity_model_info": {
+                "name": self.best_toxicity_model["name"] if self.best_toxicity_model else "Unknown",
+                "description": self.best_toxicity_model["description"] if self.best_toxicity_model else "Unknown",
+                "language": self.best_toxicity_model["language"] if self.best_toxicity_model else "Unknown"
+            },
+            "quality_model_info": {
+                "name": self.best_quality_model["name"] if self.best_quality_model else "Unknown",
+                "description": self.best_quality_model["description"] if self.best_quality_model else "Unknown",
+                "language": self.best_quality_model["language"] if self.best_quality_model else "Unknown"
+            }
+        }
+
+    def _save_to_cache(self) -> None:
+        """Modellerin değerlendirme sonuçlarını önbelleğe kaydeder"""
+        if not self.use_cache:
+            return
+
+        try:
+            cache_file = os.path.join(self.cache_dir, "model_selection_results.json")
+
+            # Modeller ve tokenizer'ları hariç tutarak kalan bilgileri kaydet
+            cache_data = {
+                "timestamp": time.time(),
+                "toxicity_models": [
+                    {k: v for k, v in model.items() if k not in ["model", "tokenizer"]}
+                    for model in self.toxicity_models
+                ],
+                "quality_models": [
+                    {k: v for k, v in model.items() if k not in ["pipeline"]}
+                    for model in self.quality_models
+                ],
+                "best_toxicity_model": (
+                    {k: v for k, v in self.best_toxicity_model.items() if k not in ["model", "tokenizer"]}
+                    if self.best_toxicity_model else None
+                ),
+                "best_quality_model": (
+                    {k: v for k, v in self.best_quality_model.items() if k not in ["pipeline"]}
+                    if self.best_quality_model else None
+                )
+            }
+
+            with open(cache_file, 'w', encoding='utf-8') as f:
+                json.dump(cache_data, f, ensure_ascii=False, indent=2)
+
+            logger.info(f"Model seçim sonuçları önbelleğe kaydedildi: {cache_file}")
+        except Exception as e:
+            logger.error(f"Önbelleğe kaydetme hatası: {str(e)}")
+
+    def _load_from_cache(self) -> Optional[Dict[str, Any]]:
+        """
+        Önbellekten modellerin değerlendirme sonuçlarını yükler
+
+        Returns:
+            Optional[Dict[str, Any]]: Yüklenen önbellek verisi veya None
+        """
+        if not self.use_cache:
+            return None
+
+        try:
+            cache_file = os.path.join(self.cache_dir, "model_selection_results.json")
+
+            if not os.path.exists(cache_file):
+                return None
+
+            # Önbellek dosyasının yaşını kontrol et (24 saatten eskiyse yok say)
+            file_age = time.time() - os.path.getmtime(cache_file)
+            if file_age > 86400:  # 24 saat = 86400 saniye
+                logger.info(f"Önbellek dosyası çok eski ({file_age / 3600:.1f} saat), tekrar değerlendirme yapılacak")
+                return None
+
+            with open(cache_file, 'r', encoding='utf-8') as f:
+                cache_data = json.load(f)
+
+            logger.info(f"Model seçim sonuçları önbellekten yüklendi: {cache_file}")
+
+            # Önbellekten sadece isim bilgilerini yükle, modellerin kendisini değil
+            return cache_data
+
+        except Exception as e:
+            logger.error(f"Önbellekten yükleme hatası: {str(e)}")
+            return None

requirements.txt

@@ -0,0 +1,62 @@
+altair==5.5.0
+attrs==25.3.0
+blinker==1.9.0
+cachetools==5.5.2
+certifi==2025.1.31
+charset-normalizer==3.4.1
+click==8.1.8
+contourpy==1.3.1
+cycler==0.12.1
+filelock==3.18.0
+fonttools==4.56.0
+fsspec==2025.3.0
+gitdb==4.0.12
+GitPython==3.1.44
+huggingface-hub==0.29.3
+idna==3.10
+Jinja2==3.1.6
+joblib==1.4.2
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+kiwisolver==1.4.8
+MarkupSafe==3.0.2
+matplotlib==3.10.1
+mpmath==1.3.0
+narwhals==1.32.0
+networkx==3.4.2
+numpy==2.2.4
+packaging==24.2
+pandas==2.2.3
+pillow==11.1.0
+plotly==6.0.1
+protobuf==5.29.4
+pyarrow==19.0.1
+pydeck==0.9.1
+pyparsing==3.2.3
+python-dateutil==2.9.0.post0
+pytz==2025.2
+PyYAML==6.0.2
+referencing==0.36.2
+regex==2024.11.6
+requests==2.32.3
+rpds-py==0.24.0
+safetensors==0.5.3
+scikit-learn==1.6.1
+scipy==1.15.2
+sentencepiece==0.2.0
+setuptools==78.1.0
+six==1.17.0
+smmap==5.0.2
+streamlit==1.44.0
+sympy==1.13.1
+tenacity==9.0.0
+threadpoolctl==3.6.0
+tokenizers==0.21.1
+toml==0.10.2
+torch==2.6.0
+tornado==6.4.2
+tqdm==4.67.1
+transformers==4.50.3
+typing_extensions==4.13.0
+tzdata==2025.2
+urllib3==2.3.0

utils/data_handler.py

@@ -0,0 +1,177 @@
+import pandas as pd
+import numpy as np
+import os
+import logging
+from datetime import datetime
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+
+class DataHandler:
+    def __init__(self, quality_scorer=None, toxicity_scorer=None):
+        """
+        Veri işleme sınıfını başlatır.
+
+        Args:
+            quality_scorer: Metin kalitesi değerlendirme nesnesi
+            toxicity_scorer: Zararlılık skoru değerlendirme nesnesi
+        """
+        self.quality_scorer = quality_scorer
+        self.toxicity_scorer = toxicity_scorer
+
+    def load_data(self, file_path, text_column=None):
+        """
+        CSV veya Excel dosyasını yükler.
+
+        Args:
+            file_path: Yüklenecek dosyanın yolu
+            text_column: Metin sütunu adı (belirtilmezse otomatik tespit edilir)
+
+        Returns:
+            pd.DataFrame: Yüklenen veri
+        """
+        try:
+            # Dosya uzantısını kontrol et
+            if file_path.endswith('.csv'):
+                df = pd.read_csv(file_path)
+            elif file_path.endswith(('.xls', '.xlsx')):
+                df = pd.read_excel(file_path)
+            else:
+                raise ValueError("Desteklenmeyen dosya formatı. Lütfen CSV veya Excel dosyası yükleyin.")
+
+            # Metin sütununu belirle
+            if text_column is None:
+                # En çok metin içeriği olan sütunu bul
+                text_lengths = {}
+                for col in df.columns:
+                    if df[col].dtype == object:  # Sadece metin sütunlarını kontrol et
+                        # Ortalama metin uzunluğunu hesapla
+                        avg_len = df[col].astype(str).str.len().mean()
+                        text_lengths[col] = avg_len
+
+                if text_lengths:
+                    # En uzun ortalama metne sahip sütunu seç
+                    text_column = max(text_lengths.items(), key=lambda x: x[1])[0]
+                else:
+                    # Hiçbir metin sütunu bulunamazsa ilk sütunu kullan
+                    text_column = df.columns[0]
+
+                logging.info(f"Otomatik tespit edilen metin sütunu: {text_column}")
+
+            return df, text_column
+
+        except Exception as e:
+            logging.error(f"Veri yükleme hatası: {str(e)}")
+            raise e
+
+    def process_data(self, df, text_column, quality_threshold=0.5, toxicity_threshold=0.5, batch_size=8):
+        """
+        Veriyi işler, kalite ve zararlılık skorlarını hesaplar.
+
+        Args:
+            df: İşlenecek veri çerçevesi
+            text_column: Metin sütunu adı
+            quality_threshold: Kalite eşik değeri
+            toxicity_threshold: Zararlılık eşik değeri
+            batch_size: İşlenecek grup boyutu
+
+        Returns:
+            pd.DataFrame: İşlenmiş veri
+        """
+        try:
+            # Boş veya NaN değerli satırları kontrol et
+            df = df.copy()
+            df[text_column] = df[text_column].astype(str)
+            df = df[df[text_column].str.strip() != ""]
+            df = df.reset_index(drop=True)
+
+            texts = df[text_column].tolist()
+
+            # Kalite skorlarını hesapla
+            if self.quality_scorer:
+                logging.info("Kalite skorları hesaplanıyor...")
+                quality_scores, quality_features = self.quality_scorer.batch_score(texts, batch_size=batch_size)
+                df['quality_score'] = quality_scores
+
+                # Kalite özelliklerini ekle
+                for i, features in enumerate(quality_features):
+                    for feat_name, feat_value in features.items():
+                        if i == 0:  # İlk satır için sütun oluştur
+                            df[feat_name] = np.nan
+                        df.at[i, feat_name] = feat_value
+
+            # Zararlılık skorlarını hesapla
+            if self.toxicity_scorer:
+                logging.info("Zararlılık skorları hesaplanıyor...")
+                toxicity_scores = self.toxicity_scorer.batch_score(texts, batch_size=batch_size)
+                df['toxicity_score'] = toxicity_scores
+
+            # Eşik değerlerine göre etiketle
+            if 'quality_score' in df.columns:
+                df['low_quality'] = df['quality_score'] < quality_threshold
+
+            if 'toxicity_score' in df.columns:
+                df['is_toxic'] = df['toxicity_score'] > toxicity_threshold
+
+            # Genel değerlendirme
+            if 'quality_score' in df.columns and 'toxicity_score' in df.columns:
+                df['acceptable'] = (df['quality_score'] >= quality_threshold) & (
+                            df['toxicity_score'] <= toxicity_threshold)
+
+            logging.info("Veri işleme tamamlandı.")
+            return df
+
+        except Exception as e:
+            logging.error(f"Veri işleme hatası: {str(e)}")
+            raise e
+
+    def filter_data(self, df, quality_threshold=0.5, toxicity_threshold=0.5):
+        """
+        Veriyi belirlenen eşik değerlerine göre filtreler.
+
+        Args:
+            df: Filtrelenecek veri çerçevesi
+            quality_threshold: Kalite eşik değeri
+            toxicity_threshold: Zararlılık eşik değeri
+
+        Returns:
+            pd.DataFrame: Filtrelenmiş veri
+        """
+        filtered_df = df.copy()
+
+        # Kalite filtreleme
+        if 'quality_score' in filtered_df.columns:
+            filtered_df = filtered_df[filtered_df['quality_score'] >= quality_threshold]
+
+        # Zararlılık filtreleme
+        if 'toxicity_score' in filtered_df.columns:
+            filtered_df = filtered_df[filtered_df['toxicity_score'] <= toxicity_threshold]
+
+        return filtered_df
+
+    def save_data(self, df, output_path=None):
+        """
+        İşlenmiş veriyi kaydeder.
+
+        Args:
+            df: Kaydedilecek veri çerçevesi
+            output_path: Çıktı dosyası yolu (belirtilmezse otomatik oluşturulur)
+
+        Returns:
+            str: Kaydedilen dosyanın yolu
+        """
+        if output_path is None:
+            # Varsayılan çıktı yolunu oluştur
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_dir = "data/processed"
+
+            # Klasörü oluştur
+            os.makedirs(output_dir, exist_ok=True)
+
+            output_path = os.path.join(output_dir, f"processed_data_{timestamp}.csv")
+
+        # Veriyi kaydet
+        df.to_csv(output_path, index=False)
+        logging.info(f"Veri başarıyla kaydedildi: {output_path}")
+
+        return output_path

utils/keyword_extractor.py

@@ -0,0 +1,273 @@
+import re
+import string
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
+from collections import Counter
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class KeywordExtractor:
+    """
+    Metin içindeki anahtar kelimeleri çıkaran sınıf.
+    TF-IDF, rakip kelimeler ve diğer metotlarla anahtar kelime çıkarma işlemi yapar.
+    """
+
+    def __init__(self):
+        """Anahtar kelime çıkarıcıyı başlatır"""
+        # Türkçe stopwords (durma kelimeleri)
+        self.turkish_stopwords = [
+            've', 'veya', 'ile', 'için', 'bu', 'bir', 'ya', 'de', 'da', 'ki', 'ne', 'her', 'çok',
+            'daha', 'ama', 'fakat', 'lakin', 'ancak', 'gibi', 'kadar', 'sonra', 'önce', 'göre',
+            'nasıl', 'neden', 'şey', 'ben', 'sen', 'o', 'biz', 'siz', 'onlar', 'kendi', 'aynı',
+            'ise', 'mi', 'mı', 'mu', 'mü', 'hem', 'değil', 'hiç', 'olarak', 'evet', 'hayır',
+            'belki', 'tüm', 'yani', 'hep', 'şu', 'şey', 'tabi', 'tamam', 'bunlar', 'şunlar',
+            'böyle', 'öyle', 'şöyle', 'iki', 'üç', 'dört', 'beş', 'altı', 'yedi', 'sekiz', 'dokuz',
+            'on', 'yüz', 'bin', 'milyon', 'milyar', 'var', 'yok', 'oldu', 'olur', 'oluyor', 'olacak'
+        ]
+
+        # İngilizce stopwords (durma kelimeleri)
+        self.english_stopwords = [
+            'the', 'and', 'a', 'to', 'of', 'in', 'for', 'with', 'on', 'at', 'by', 'from', 'about',
+            'as', 'into', 'like', 'through', 'after', 'over', 'between', 'out', 'against', 'during',
+            'without', 'before', 'under', 'around', 'among', 'is', 'are', 'was', 'were', 'be', 'been',
+            'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'shall', 'should',
+            'may', 'might', 'must', 'can', 'could', 'i', 'you', 'he', 'she', 'it', 'we', 'they',
+            'me', 'him', 'her', 'us', 'them', 'who', 'which', 'whose', 'whom', 'this', 'that', 'these',
+            'those', 'am', 'is', 'are', 'was', 'were', 'an', 'my', 'your', 'his', 'its', 'our', 'their'
+        ]
+
+        # Tüm stopwords listesini birleştir
+        self.stopwords = set(self.turkish_stopwords + self.english_stopwords)
+
+        # TF-IDF vektörleyici
+        self.tfidf_vectorizer = TfidfVectorizer(
+            max_df=0.9,
+            min_df=2,
+            max_features=200,
+            stop_words=self.stopwords,
+            ngram_range=(1, 2)  # Tek kelimeler ve ikili kelime grupları
+        )
+
+        # Sayısal karakter ve noktalama işaretlerini temizlemek için regex pattern
+        self.cleanup_pattern = re.compile(f'[{re.escape(string.punctuation)}]|[0-9]')
+
+        logger.info("Anahtar kelime çıkarıcı başlatıldı")
+
+    def preprocess_text(self, text):
+        """
+        Metni anahtar kelime çıkarma için ön işleme tabi tutar
+
+        Args:
+            text: İşlenecek metin
+
+        Returns:
+            str: Temizlenmiş metin
+        """
+        if not text:
+            return ""
+
+        # Küçük harfe çevir
+        text = text.lower()
+
+        # Noktalama işaretlerini temizle
+        text = self.cleanup_pattern.sub(' ', text)
+
+        # Fazla boşlukları temizle
+        text = re.sub(r'\s+', ' ', text).strip()
+
+        return text
+
+    def extract_keywords_tfidf(self, text, num_keywords=5):
+        """
+        TF-IDF kullanarak metinden anahtar kelimeleri çıkarır
+
+        Args:
+            text: Anahtar kelimeleri çıkarılacak metin
+            num_keywords: Çıkarılacak anahtar kelime sayısı
+
+        Returns:
+            list: [(anahtar_kelime, skor), ...] formatında liste
+        """
+        try:
+            if not text or len(text.strip()) < 10:
+                return []
+
+            # Metni ön işle
+            processed_text = self.preprocess_text(text)
+
+            # TF-IDF matrix oluştur
+            tfidf_matrix = self.tfidf_vectorizer.fit_transform([processed_text])
+
+            # Feature isimleri (kelimeler)
+            feature_names = self.tfidf_vectorizer.get_feature_names_out()
+
+            # Kelimelerin TF-IDF skorlarını hesapla ve sırala
+            tfidf_scores = zip(feature_names, tfidf_matrix.toarray()[0])
+            sorted_scores = sorted(tfidf_scores, key=lambda x: x[1], reverse=True)
+
+            # En yüksek skorlu kelimeleri seç
+            top_keywords = sorted_scores[:num_keywords]
+
+            return top_keywords
+
+        except Exception as e:
+            logger.error(f"TF-IDF anahtar kelime çıkarma hatası: {str(e)}")
+            return []
+
+    def extract_keywords_textrank(self, text, num_keywords=5):
+        """
+        TextRank benzeri bir algoritma ile anahtar kelimeleri çıkarır
+
+        Args:
+            text: Anahtar kelimeleri çıkarılacak metin
+            num_keywords: Çıkarılacak anahtar kelime sayısı
+
+        Returns:
+            list: [(anahtar_kelime, skor), ...] formatında liste
+        """
+        try:
+            if not text or len(text.strip()) < 10:
+                return []
+
+            # Metni ön işle
+            processed_text = self.preprocess_text(text)
+
+            # Kelimeleri ayır
+            words = processed_text.split()
+
+            # Stopwords olmayan kelimeleri filtrele
+            filtered_words = [word for word in words if word not in self.stopwords and len(word) > 2]
+
+            # Kelime frekanslarını hesapla
+            word_freq = Counter(filtered_words)
+
+            # En sık geçen kelimeleri seç
+            most_common = word_freq.most_common(num_keywords * 2)  # Daha fazla al, sonra filtreleyeceğiz
+
+            # TF-IDF skorlaması ile benzer bir yaklaşım uygula
+            # Kelime sıklığının logaritması * kelimenin benzersizliği
+            scored_words = []
+            for word, count in most_common:
+                # Benzersizlik faktörü: Toplam kelime sayısı / kelimenin sıklığı
+                uniqueness = len(filtered_words) / (count + 1)
+                # Skor hesapla
+                score = np.log(count + 1) * uniqueness
+                scored_words.append((word, score))
+
+            # Skorlara göre sırala
+            scored_words.sort(key=lambda x: x[1], reverse=True)
+
+            return scored_words[:num_keywords]
+
+        except Exception as e:
+            logger.error(f"TextRank anahtar kelime çıkarma hatası: {str(e)}")
+            return []
+
+    def extract_bigrams(self, text, num_bigrams=3):
+        """
+        Metinden ikili kelime gruplarını (bigram) çıkarır
+
+        Args:
+            text: Anahtar kelimeleri çıkarılacak metin
+            num_bigrams: Çıkarılacak bigram sayısı
+
+        Returns:
+            list: [(bigram, skor), ...] formatında liste
+        """
+        try:
+            if not text or len(text.strip()) < 10:
+                return []
+
+            # Metni ön işle
+            processed_text = self.preprocess_text(text)
+
+            # Bigram için vektörleyici
+            bigram_vectorizer = CountVectorizer(
+                ngram_range=(2, 2),
+                stop_words=self.stopwords,
+                max_features=100
+            )
+
+            # Bigram matrix oluştur
+            bigram_matrix = bigram_vectorizer.fit_transform([processed_text])
+
+            # Feature isimleri (bigramlar)
+            feature_names = bigram_vectorizer.get_feature_names_out()
+
+            # Bigramların skorlarını hesapla ve sırala
+            bigram_scores = zip(feature_names, bigram_matrix.toarray()[0])
+            sorted_scores = sorted(bigram_scores, key=lambda x: x[1], reverse=True)
+
+            # En yüksek skorlu bigramları seç
+            top_bigrams = sorted_scores[:num_bigrams]
+
+            return top_bigrams
+
+        except Exception as e:
+            logger.error(f"Bigram çıkarma hatası: {str(e)}")
+            return []
+
+    def extract_keywords(self, text, method='combined', num_keywords=10):
+        """
+        Metinden anahtar kelimeleri çıkarır
+
+        Args:
+            text: Anahtar kelimeleri çıkarılacak metin
+            method: Kullanılacak metod ('tfidf', 'textrank', 'combined')
+            num_keywords: Toplam çıkarılacak anahtar kelime sayısı
+
+        Returns:
+            dict: {
+                'keywords': [(anahtar_kelime, skor), ...],
+                'bigrams': [(bigram, skor), ...],
+                'method': kullanılan metod
+            }
+        """
+        if not text or len(text.strip()) < 10:
+            return {
+                'keywords': [],
+                'bigrams': [],
+                'method': method
+            }
+
+        try:
+            keywords = []
+
+            if method == 'tfidf':
+                keywords = self.extract_keywords_tfidf(text, num_keywords)
+            elif method == 'textrank':
+                keywords = self.extract_keywords_textrank(text, num_keywords)
+            else:  # combined
+                # TF-IDF ve TextRank sonuçlarını birleştir
+                tfidf_keywords = self.extract_keywords_tfidf(text, num_keywords // 2)
+                textrank_keywords = self.extract_keywords_textrank(text, num_keywords // 2)
+
+                # İki listeyi birleştir
+                combined = {}
+                for keyword, score in tfidf_keywords + textrank_keywords:
+                    if keyword in combined:
+                        combined[keyword] = max(combined[keyword], score)
+                    else:
+                        combined[keyword] = score
+
+                # En yüksek skorlu kelimeleri seç
+                keywords = sorted(combined.items(), key=lambda x: x[1], reverse=True)[:num_keywords]
+
+            # Bigramları da ekle
+            bigrams = self.extract_bigrams(text, num_keywords // 3)
+
+            return {
+                'keywords': keywords,
+                'bigrams': bigrams,
+                'method': method
+            }
+
+        except Exception as e:
+            logger.error(f"Anahtar kelime çıkarma hatası: {str(e)}")
+            return {
+                'keywords': [],
+                'bigrams': [],
+                'method': method
+            }

utils/language_detector.py

@@ -0,0 +1,260 @@
+import re
+from collections import Counter
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class LanguageDetector:
+    """
+    Metin dilini algılayan sınıf.
+    İstatistiksel yöntemlerle metinlerin dilini tespit eder.
+    """
+
+    def __init__(self):
+        """Dil algılama sınıfını başlatır"""
+        # Dil tanıma için tipik karakter ve kelime varlıkları
+        self.language_profiles = {
+            'tr': {
+                'chars': 'abcçdefgğhıijklmnoöprsştuüvyz',
+                'unique_chars': 'çğıöşü',
+                'common_words': [
+                    've', 'bir', 'bu', 'da', 'de', 'için', 'ile', 'ben', 'sen', 'o',
+                    'biz', 'siz', 'ama', 'ki', 'ya', 'çok', 'daha', 'en', 'ne', 'kadar',
+                    'var', 'yok', 'mı', 'mi', 'mu', 'mü', 'gibi', 'olarak', 'çünkü',
+                    'sonra', 'önce', 'nasıl', 'neden', 'evet', 'hayır', 'ise', 'veya'
+                ]
+            },
+            'en': {
+                'chars': 'abcdefghijklmnopqrstuvwxyz',
+                'unique_chars': 'qwxz',
+                'common_words': [
+                    'the', 'and', 'a', 'to', 'of', 'in', 'is', 'you', 'that', 'it',
+                    'he', 'was', 'for', 'on', 'are', 'as', 'with', 'his', 'they',
+                    'at', 'be', 'this', 'have', 'from', 'or', 'one', 'had', 'by',
+                    'but', 'not', 'what', 'all', 'were', 'we', 'when', 'your', 'can',
+                    'there', 'if', 'more', 'an', 'who'
+                ]
+            },
+            'de': {
+                'chars': 'abcdefghijklmnopqrstuvwxyzäöüß',
+                'unique_chars': 'äöüß',
+                'common_words': [
+                    'der', 'die', 'das', 'und', 'in', 'zu', 'den', 'mit', 'auf', 'für',
+                    'ist', 'im', 'dem', 'nicht', 'ein', 'eine', 'als', 'auch', 'es',
+                    'von', 'sich', 'oder', 'so', 'zum', 'bei', 'eines', 'nur', 'am',
+                    'werden', 'noch', 'wie', 'einer', 'aber', 'aus', 'wenn', 'doch'
+                ]
+            },
+            'fr': {
+                'chars': 'abcdefghijklmnopqrstuvwxyzàâçéèêëîïôùûü',
+                'unique_chars': 'àâçéèêëîïôùûü',
+                'common_words': [
+                    'le', 'la', 'les', 'de', 'des', 'un', 'une', 'et', 'est', 'en',
+                    'du', 'dans', 'qui', 'que', 'pour', 'pas', 'sur', 'ce', 'vous',
+                    'avec', 'au', 'il', 'je', 'sont', 'mais', 'nous', 'si', 'plus',
+                    'leur', 'par', 'ont', 'ou', 'comme', 'elle', 'tout', 'même'
+                ]
+            },
+            'es': {
+                'chars': 'abcdefghijklmnopqrstuvwxyzáéíóúüñ',
+                'unique_chars': 'áéíóúüñ',
+                'common_words': [
+                    'el', 'la', 'los', 'las', 'de', 'del', 'un', 'una', 'unos', 'unas',
+                    'y', 'e', 'o', 'u', 'que', 'en', 'a', 'con', 'por', 'para', 'es',
+                    'son', 'al', 'lo', 'su', 'sus', 'se', 'mi', 'me', 'te', 'nos',
+                    'como', 'pero', 'más', 'este', 'esta', 'esto'
+                ]
+            }
+        }
+
+        # Desteklenen diller
+        self.supported_languages = {
+            'tr': 'Türkçe',
+            'en': 'İngilizce',
+            'de': 'Almanca',
+            'fr': 'Fransızca',
+            'es': 'İspanyolca',
+            'unknown': 'Bilinmeyen'
+        }
+
+        logger.info("Dil algılama modülü başlatıldı")
+
+    def _clean_text(self, text):
+        """
+        Metni temizler
+
+        Args:
+            text: Temizlenecek metin
+
+        Returns:
+            str: Temizlenmiş metin
+        """
+        if not text:
+            return ""
+
+        # Küçük harfe çevir
+        text = text.lower()
+
+        # Sayıları ve özel karakterleri kaldır (dil karakterleri hariç)
+        text = re.sub(r'[0-9]', '', text)
+        text = re.sub(r'[^\w\s\u00C0-\u00FF\u0100-\u017F\u0400-\u04FF]', '', text)
+
+        return text
+
+    def _get_words(self, text):
+        """
+        Metinden kelimeleri çıkarır
+
+        Args:
+            text: Kelimesi çıkarılacak metin
+
+        Returns:
+            list: Kelimeler listesi
+        """
+        words = re.findall(r'\b\w+\b', text.lower())
+        return words
+
+    def _calculate_character_score(self, text, language):
+        """
+        Metindeki karakterlerin dile uygunluğunu hesaplar
+
+        Args:
+            text: Değerlendirilecek metin
+            language: Dil kodu
+
+        Returns:
+            float: Karakter skoru (0-1 arası)
+        """
+        if not text:
+            return 0.0
+
+        profile = self.language_profiles.get(language, {})
+        chars = profile.get('chars', '')
+        unique_chars = profile.get('unique_chars', '')
+
+        # Metin içindeki karakterleri say
+        char_count = Counter(text.lower())
+
+        # Dildeki karakterlerin metinde bulunma oranı
+        total_chars = sum(char_count.values())
+        if total_chars == 0:
+            return 0.0
+
+        matched_chars = sum(char_count.get(char, 0) for char in chars)
+        char_ratio = matched_chars / total_chars
+
+        # Dile özgü karakterlerin varlığını kontrol et
+        unique_char_present = any(char in text.lower() for char in unique_chars)
+        unique_bonus = 0.2 if unique_char_present else 0.0
+
+        return min(1.0, char_ratio + unique_bonus)
+
+    def _calculate_word_score(self, words, language):
+        """
+        Kelimelerin dile uygunluğunu hesaplar
+
+        Args:
+            words: Değerlendirilecek kelimeler listesi
+            language: Dil kodu
+
+        Returns:
+            float: Kelime skoru (0-1 arası)
+        """
+        if not words:
+            return 0.0
+
+        common_words = self.language_profiles.get(language, {}).get('common_words', [])
+
+        # Yaygın kelimelerin metinde bulunma sayısı
+        matched_words = sum(1 for word in words if word in common_words)
+
+        # Yaygın kelime oranı
+        word_ratio = matched_words / min(len(words), 100)  # En fazla 100 kelime değerlendir
+
+        return word_ratio
+
+    def detect_language(self, text):
+        """
+        Metnin dilini tespit eder
+
+        Args:
+            text: Dili tespit edilecek metin
+
+        Returns:
+            dict: {
+                'language_code': dil kodu (tr, en, vb),
+                'language_name': dil adı,
+                'confidence': güven skoru (0-1 arası),
+                'scores': dil bazında skorlar
+            }
+        """
+        if not text or len(text.strip()) < 5:
+            return {
+                'language_code': 'unknown',
+                'language_name': self.supported_languages.get('unknown'),
+                'confidence': 0.0,
+                'scores': {}
+            }
+
+        try:
+            clean_text = self._clean_text(text)
+            words = self._get_words(clean_text)
+
+            scores = {}
+
+            # Her dil için skor hesapla
+            for lang_code in self.language_profiles.keys():
+                char_score = self._calculate_character_score(clean_text, lang_code)
+                word_score = self._calculate_word_score(words, lang_code)
+
+                # Ağırlıklı toplam (karakter:0.4, kelime:0.6)
+                total_score = (char_score * 0.4) + (word_score * 0.6)
+                scores[lang_code] = total_score
+
+            # En yüksek skorlu dili bul
+            if not scores:
+                detected_lang = 'unknown'
+                confidence = 0.0
+            else:
+                detected_lang = max(scores, key=scores.get)
+                confidence = scores[detected_lang]
+
+            # Eğer güven skoru çok düşükse "bilinmeyen" olarak işaretle
+            if confidence < 0.15:
+                detected_lang = 'unknown'
+                confidence = 0.0
+
+            return {
+                'language_code': detected_lang,
+                'language_name': self.supported_languages.get(detected_lang, self.supported_languages.get('unknown')),
+                'confidence': confidence,
+                'scores': scores
+            }
+
+        except Exception as e:
+            logger.error(f"Dil algılama hatası: {str(e)}")
+            return {
+                'language_code': 'unknown',
+                'language_name': self.supported_languages.get('unknown'),
+                'confidence': 0.0,
+                'scores': {}
+            }
+
+    def detect_languages_batch(self, texts):
+        """
+        Birden çok metnin dilini tespit eder
+
+        Args:
+            texts: Dilleri tespit edilecek metinler listesi
+
+        Returns:
+            list: Her metin için dil tespiti sonuçları
+        """
+        results = []
+
+        for text in texts:
+            result = self.detect_language(text)
+            results.append(result)
+
+        return results

utils/quality_scorer.py

@@ -0,0 +1,198 @@
+import numpy as np
+from transformers import pipeline
+import torch
+import logging
+import re
+from sklearn.feature_extraction.text import CountVectorizer
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+
+class QualityScorer:
+    def __init__(self, quality_pipeline=None):
+        """
+        Metin kalitesi değerlendirme sınıfını başlatır.
+
+        Args:
+            quality_pipeline: Metin özetleme pipeline'ı
+        """
+        self.pipeline = quality_pipeline
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # Temel kalite ölçütleri için yardımcı araçlar
+        self.vectorizer = CountVectorizer(max_features=5000)
+
+        # Türkçeye özgü doldurma (filler) kelimeleri
+        self.turkish_filler_words = [
+            'yani', 'işte', 'şey', 'falan', 'filan', 'hani', 'mesela', 'aslında',
+            'ya', 'ki', 'de', 'da', 'çok', 'ama', 'fakat', 'lakin', 'ancak',
+            'gerçekten', 'kesinlikle', 'tabii', 'tabi', 'şimdi', 'sonra', 'önce'
+        ]
+
+    def score_text(self, text):
+        """
+        Metin için kalite skoru hesaplar.
+
+        Args:
+            text: Değerlendirilecek metin
+
+        Returns:
+            float: 0 ile 1 arasında kalite skoru (1 = yüksek kalite)
+        """
+        if not text or len(text.strip()) == 0:
+            return 0.0, {}
+
+        # Metni temizle
+        text = text.strip()
+
+        # Çeşitli metin özelliklerini değerlendirelim
+        features = {}
+
+        # 1. Uzunluk puanı - Çok kısa veya çok uzun metinler düşük puan alır
+        length = len(text.split())
+        if length < 3:
+            features['length_score'] = 0.1
+        elif length < 5:
+            features['length_score'] = 0.2
+        elif length < 10:
+            features['length_score'] = 0.4
+        elif length < 20:
+            features['length_score'] = 0.6
+        elif length < 100:
+            features['length_score'] = 0.8
+        elif length < 500:
+            features['length_score'] = 1.0
+        elif length < 1000:
+            features['length_score'] = 0.8
+        else:
+            features['length_score'] = 0.6
+
+        # 2. Gramer ve yazım denetimi (Türkçe için uyarlanmış)
+        # Türkçede noktalama işaretleri ve büyük harf kullanımı
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+
+        if not sentences:
+            features['grammar_score'] = 0.0
+        else:
+            # Cümlelerin büyük harfle başlayıp başlamadığını kontrol et
+            correct_caps = sum(1 for s in sentences if s and s[0].isupper())
+            caps_ratio = correct_caps / len(sentences) if sentences else 0
+
+            # Noktalama işaretlerinin varlığını kontrol et
+            punct_count = len(re.findall(r'[.!?,;:]', text))
+            expected_punct = max(1, len(sentences) - 1)  # Beklenen minimum noktalama
+            punct_ratio = min(1.0, punct_count / expected_punct) if expected_punct > 0 else 0
+
+            # Türkçe'ye özgü yaygın yazım hatalarını kontrol et
+            common_errors = [
+                ('de da', 'de/da ayrı yazılmalı'),
+                ('ki', 'ki bağlacı ayrı yazılmalı'),
+                ('misin', 'soru eki ayrı yazılmalı'),
+                ('geldimi', 'soru eki ayrı yazılmalı'),
+                ('bişey', 'bir şey ayrı yazılmalı'),
+                ('herşey', 'her şey ayrı yazılmalı'),
+                ('hiçbirşey', 'hiçbir şey ayrı yazılmalı')
+            ]
+
+            error_count = sum(1 for error, _ in common_errors if error in text.lower())
+            error_ratio = 1.0 - min(1.0, error_count / (len(text.split()) / 10 + 1))
+
+            # Gramer puanını hesapla
+            features['grammar_score'] = (caps_ratio * 0.4 + punct_ratio * 0.3 + error_ratio * 0.3)
+
+        # 3. Kelime çeşitliliği (Türkçe için uyarlanmış)
+        words = re.findall(r'\b\w+\b', text.lower())
+        unique_words = set(words)
+        if not words:
+            features['diversity_score'] = 0.0
+        else:
+            # Türkçe metinler için çeşitlilik oranını ayarla
+            diversity_ratio = len(unique_words) / len(words)
+            # Türkçe'nin çekimli yapısı nedeniyle daha yüksek bir baz çeşitlilik beklenir
+            features['diversity_score'] = min(1.0, diversity_ratio * 1.2)
+
+        # 4. Özetlenebilirlik puanı - eğer pipeline varsa
+        if self.pipeline and len(text.split()) > 20:
+            try:
+                # Pipeline özetleme mi yoksa çeviri mi ona göre işle
+                if hasattr(self.pipeline, 'task') and self.pipeline.task == 'translation':
+                    # Çeviri pipeline'ı, bu durumda çevirinin kalitesine bakma
+                    translated = self.pipeline(text, max_length=100)[0]['translation_text']
+                    features['summary_score'] = 0.7  # Varsayılan olarak iyi bir puan
+                else:
+                    # Özetleme pipeline'ı
+                    max_length = min(128, max(30, len(text.split()) // 4))
+                    summary = self.pipeline(text, max_length=max_length, min_length=10, do_sample=False)[0][
+                        'generated_text']
+
+                    # Özet ve orijinal metin arasındaki benzerliğe bakarak puan ver
+                    summary_len = len(summary.split())
+                    orig_len = len(text.split())
+
+                    compression_ratio = summary_len / orig_len if orig_len > 0 else 0
+                    if compression_ratio > 0.8 or compression_ratio < 0.05:
+                        features['summary_score'] = 0.3
+                    elif compression_ratio > 0.6 or compression_ratio < 0.1:
+                        features['summary_score'] = 0.6
+                    else:
+                        features['summary_score'] = 0.9
+            except Exception as e:
+                logging.warning(f"Error during summarization: {str(e)}")
+                features['summary_score'] = 0.5
+        else:
+            features['summary_score'] = 0.5
+
+        # 5. Türkçe doldurma kelimeleri (filler words)
+        filler_count = sum(1 for word in words if word.lower() in self.turkish_filler_words)
+        if not words:
+            features['filler_score'] = 1.0
+        else:
+            filler_ratio = filler_count / len(words)
+            # Türkçede bazı doldurma kelimeleri doğal olabilir, bu yüzden daha toleranslı davran
+            features['filler_score'] = 1.0 - min(1.0, filler_ratio * 3)
+
+        # Puanları birleştir - farklı puanları ağırlıklandırarak
+        weights = {
+            'length_score': 0.15,
+            'grammar_score': 0.3,  # Türkçe için gramere daha fazla ağırlık
+            'diversity_score': 0.25,
+            'summary_score': 0.2,
+            'filler_score': 0.1
+        }
+
+        final_score = sum(features[key] * weights[key] for key in weights.keys())
+
+        # Puanı 0-1 aralığına normalize et
+        final_score = max(0.0, min(1.0, final_score))
+
+        return final_score, features
+
+    def batch_score(self, texts, batch_size=8):
+        """
+        Bir metin listesi için toplu kalite skoru hesaplar.
+
+        Args:
+            texts: Değerlendirilecek metin listesi
+            batch_size: İşlenecek grup boyutu
+
+        Returns:
+            list: Kalite skorları listesi
+        """
+        results = []
+        feature_results = []
+
+        for i in range(0, len(texts), batch_size):
+            batch_texts = texts[i:i + batch_size]
+            batch_results = []
+            batch_features = []
+
+            for text in batch_texts:
+                score, features = self.score_text(text)
+                batch_results.append(score)
+                batch_features.append(features)
+
+            results.extend(batch_results)
+            feature_results.extend(batch_features)
+
+        return results, feature_results

utils/sentiment_analyzer.py

@@ -0,0 +1,169 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import numpy as np
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class SentimentAnalyzer:
+    """
+    Türkçe metinler için duygu analizi yapan sınıf.
+    Pozitif, negatif ve nötr duygu skorları üreterek metnin duygusal tonunu analiz eder.
+    """
+
+    def __init__(self, model=None, tokenizer=None):
+        """
+        Duygu analizi modülünü başlatır.
+
+        Args:
+            model: Duygu analizi modeli (isteğe bağlı)
+            tokenizer: Model için tokenizer (isteğe bağlı)
+        """
+        self.model = model
+        self.tokenizer = tokenizer
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model_info = {"name": "Bilinmeyen Model", "language": "unknown"}
+
+        if model is None or tokenizer is None:
+            logger.info("Duygu analizi için varsayılan model yükleniyor...")
+            self.load_default_model()
+
+    def load_default_model(self):
+        """Varsayılan duygu analizi modelini yükler"""
+        try:
+            # Türkçe duygu analizi modeli
+            model_name = "savasy/bert-base-turkish-sentiment"
+            logger.info(f"Türkçe duygu analizi modeli yükleniyor: {model_name}")
+
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
+            self.model.to(self.device)
+
+            self.model_info = {
+                "name": model_name,
+                "description": "Türkçe duygu analizi modeli",
+                "language": "tr"
+            }
+
+            logger.info("Duygu analizi modeli başarıyla yüklendi")
+            return True
+        except Exception as e:
+            logger.error(f"Duygu analizi modeli yüklenemedi: {str(e)}")
+
+            # Yedek model dene
+            try:
+                backup_model = "dbmdz/bert-base-turkish-cased"
+                logger.info(f"Yedek Türkçe model deneniyor: {backup_model}")
+
+                self.tokenizer = AutoTokenizer.from_pretrained(backup_model)
+                self.model = AutoModelForSequenceClassification.from_pretrained(backup_model)
+                self.model.to(self.device)
+
+                self.model_info = {
+                    "name": backup_model,
+                    "description": "Genel amaçlı Türkçe BERT modeli",
+                    "language": "tr"
+                }
+
+                logger.info("Yedek model başarıyla yüklendi")
+                return True
+            except Exception as e2:
+                logger.error(f"Yedek model yüklenemedi: {str(e2)}")
+                raise e2
+
+    def analyze_sentiment(self, text):
+        """
+        Metindeki duygu tonunu analiz eder.
+
+        Args:
+            text: Analiz edilecek metin
+
+        Returns:
+            dict: {
+                'positive': float,  # Pozitif duygu skoru (0-1)
+                'neutral': float,   # Nötr duygu skoru (0-1)
+                'negative': float,  # Negatif duygu skoru (0-1)
+                'dominant': str     # Baskın duygu (positive, neutral, negative)
+                'score': float      # -1 (çok negatif) ile 1 (çok pozitif) arasında genel skor
+            }
+        """
+        if not text or len(text.strip()) == 0:
+            return {
+                'positive': 0.0,
+                'neutral': 1.0,
+                'negative': 0.0,
+                'dominant': 'neutral',
+                'score': 0.0
+            }
+
+        try:
+            # Metni tokenize et
+            inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+            inputs = {key: val.to(self.device) for key, val in inputs.items()}
+
+            # Tahmin yap
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+
+            # Sonuçları işle
+            logits = outputs.logits
+            probabilities = torch.softmax(logits, dim=1).cpu().numpy()[0]
+
+            # Model çıktısının formatına göre işlem yap
+            if len(probabilities) >= 3:
+                # 3 sınıflı model (negatif, nötr, pozitif)
+                result = {
+                    'negative': float(probabilities[0]),
+                    'neutral': float(probabilities[1]),
+                    'positive': float(probabilities[2])
+                }
+            else:
+                # 2 sınıflı model (negatif, pozitif)
+                result = {
+                    'negative': float(probabilities[0]),
+                    'neutral': 0.0,
+                    'positive': float(probabilities[1])
+                }
+
+            # Baskın duyguyu belirle
+            dominant_sentiment = max(result, key=result.get)
+            result['dominant'] = dominant_sentiment
+
+            # -1 ile 1 arasında genel bir skor hesapla
+            # -1: çok negatif, 0: nötr, 1: çok pozitif
+            weighted_score = result['positive'] - result['negative']
+            result['score'] = float(weighted_score)
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Duygu analizi sırasında hata: {str(e)}")
+            # Hata durumunda nötr sonuç döndür
+            return {
+                'positive': 0.0,
+                'neutral': 1.0,
+                'negative': 0.0,
+                'dominant': 'neutral',
+                'score': 0.0
+            }
+
+    def batch_analyze(self, texts, batch_size=8):
+        """
+        Bir metin listesi için toplu duygu analizi yapar.
+
+        Args:
+            texts: Analiz edilecek metin listesi
+            batch_size: İşlenecek grup boyutu
+
+        Returns:
+            list: Her metin için duygu analizi sonuçları
+        """
+        results = []
+
+        for i in range(0, len(texts), batch_size):
+            batch_texts = texts[i:i + batch_size]
+            batch_results = [self.analyze_sentiment(text) for text in batch_texts]
+            results.extend(batch_results)
+
+        return results

utils/text_improver.py

@@ -0,0 +1,337 @@
+import re
+import logging
+import string
+from collections import Counter
+
+logger = logging.getLogger(__name__)
+
+
+class TextImprover:
+    """
+    Türkçe metinlerde iyileştirme ve öneriler sunan sınıf.
+    Yazım hataları düzeltme, dilbilgisi önerileri ve okunabilirlik analizi yapar.
+    """
+
+    def __init__(self):
+        """Metin iyileştirme sınıfını başlatır"""
+        # Türkçe'de yaygın yazım hataları ve düzeltmeleri
+        self.common_typos = {
+            # Büyük küçük harf duyarsız olarak yazım hataları
+            'bişey': 'bir şey',
+            'herşey': 'her şey',
+            'hiçbirşey': 'hiçbir şey',
+            'birsey': 'bir şey',
+            'hersey': 'her şey',
+            'hicbir': 'hiçbir',
+            'hicbirsey': 'hiçbir şey',
+            'yalnız': 'yalnız',
+            'bi': 'bir',
+            'gelicek': 'gelecek',
+            'gidiyom': 'gidiyorum',
+            'yapıyom': 'yapıyorum',
+            'biliyomusun': 'biliyor musun',
+            'napıyorsun': 'ne yapıyorsun',
+            'naber': 'ne haber',
+            'bilmiyomki': 'bilmiyorum ki',
+            'dicek': 'diyecek',
+            'dicem': 'diyeceğim',
+            'yicek': 'yiyecek',
+            'yicem': 'yiyeceğim'
+        }
+
+        # Türkçe'de sık kullanılan doldurma kelimeleri
+        self.filler_words = [
+            'yani', 'işte', 'şey', 'falan', 'filan', 'hani', 'mesela',
+            'aslında', 'ya', 'ki', 'de', 'da', 'ama', 'fakat', 'lakin',
+            'gerçekten', 'kesinlikle', 'tabii', 'tabi', 'şimdi', 'sonra'
+        ]
+
+        # Türkçe cümle karmaşıklığını değerlendirmek için parametreler
+        self.max_sentence_length = 25  # Kelime sayısı
+        self.max_word_length = 6  # Ortalama kelime uzunluğu
+
+        # Okunabilirlik için kullanılacak parametreler
+        # Türkçe için uyarlanmış Flesch Reading Ease formülü
+        self.readability_thresholds = {
+            'çok_kolay': 90,
+            'kolay': 80,
+            'orta_kolay': 70,
+            'orta': 60,
+            'orta_zor': 50,
+            'zor': 30,
+            'çok_zor': 0
+        }
+
+        logger.info("Metin iyileştirme modülü başlatıldı")
+
+    def fix_typos(self, text):
+        """
+        Metindeki yaygın yazım hatalarını düzeltir
+
+        Args:
+            text: Düzeltilecek metin
+
+        Returns:
+            dict: {
+                'corrected_text': str,  # Düzeltilmiş metin
+                'corrections': list,    # Yapılan düzeltmeler listesi
+                'correction_count': int # Düzeltme sayısı
+            }
+        """
+        corrected_text = text
+        corrections = []
+
+        # Önce metni kelimelere ayır
+        words = re.findall(r'\b\w+\b', text.lower())
+
+        # Her kelimeyi kontrol et
+        for word in words:
+            if word.lower() in self.common_typos:
+                correct_word = self.common_typos[word.lower()]
+                # Kelimenin metindeki tüm örneklerini düzelt
+                # \b ile kelime sınırlarını belirt
+                pattern = r'\b' + re.escape(word) + r'\b'
+                corrected_text = re.sub(pattern, correct_word, corrected_text, flags=re.IGNORECASE)
+                corrections.append(f"'{word}' -> '{correct_word}'")
+
+        return {
+            'corrected_text': corrected_text,
+            'corrections': corrections,
+            'correction_count': len(corrections)
+        }
+
+    def check_grammar(self, text):
+        """
+        Metindeki temel dilbilgisi sorunlarını kontrol eder
+
+        Args:
+            text: Kontrol edilecek metin
+
+        Returns:
+            dict: {
+                'issues': list,  # Tespit edilen sorunlar listesi
+                'suggestions': list, # Öneriler listesi
+                'issue_count': int   # Sorun sayısı
+            }
+        """
+        issues = []
+        suggestions = []
+
+        # Cümlelere ayır
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+
+        for i, sentence in enumerate(sentences):
+            # Büyük harfle başlama kontrolü
+            if sentence and not sentence[0].isupper():
+                issues.append(f"Cümle {i + 1}: Büyük harfle başlamıyor")
+                suggestions.append(f"Cümle {i + 1}: '{sentence[0]}' -> '{sentence[0].upper()}'")
+
+            # Cümle uzunluğu kontrolü
+            words = sentence.split()
+            if len(words) > self.max_sentence_length:
+                issues.append(f"Cümle {i + 1}: Çok uzun ({len(words)} kelime)")
+                suggestions.append(f"Cümle {i + 1}: Daha kısa cümlelere bölmeyi düşünün")
+
+            # Noktalama kontrolü
+            if i < len(sentences) - 1:  # Son cümle değilse
+                if not text.find(sentence + ".") and not text.find(sentence + "!") and not text.find(sentence + "?"):
+                    issues.append(f"Cümle {i + 1}: Noktalama işareti eksik olabilir")
+                    suggestions.append(f"Cümle {i + 1}: Cümle sonuna uygun noktalama işareti ekleyin")
+
+        return {
+            'issues': issues,
+            'suggestions': suggestions,
+            'issue_count': len(issues)
+        }
+
+    def reduce_filler_words(self, text):
+        """
+        Metindeki doldurma kelimelerini tespit eder ve azaltma önerileri sunar
+
+        Args:
+            text: İyileştirilecek metin
+
+        Returns:
+            dict: {
+                'filler_words': list,  # Bulunan doldurma kelimeleri
+                'filler_count': int,   # Doldurma kelimesi sayısı
+                'suggested_text': str  # Önerilen iyileştirilmiş metin
+            }
+        """
+        # Metindeki kelimeleri bul
+        words = re.findall(r'\b\w+\b', text.lower())
+
+        # Doldurma kelimelerini ve sayılarını say
+        filler_counter = Counter()
+        for word in words:
+            if word.lower() in self.filler_words:
+                filler_counter[word.lower()] += 1
+
+        # Metni kelime kelime işle ve fazla doldurma kelimelerini kaldır
+        suggested_text = text
+        for filler_word, count in filler_counter.items():
+            if count > 1:  # Birden fazla geçiyorsa
+                # Her bir örneği bul
+                occurrences = list(re.finditer(r'\b' + re.escape(filler_word) + r'\b', suggested_text, re.IGNORECASE))
+
+                # İlk geçtiği yer hariç diğerlerini kaldır
+                for occurrence in occurrences[1:]:
+                    start, end = occurrence.span()
+                    # Eğer kelimenin önünde veya arkasında boşluk varsa, onu da kaldır
+                    if start > 0 and suggested_text[start - 1] == ' ':
+                        start -= 1
+                    suggested_text = suggested_text[:start] + suggested_text[end:]
+
+        return {
+            'filler_words': list(filler_counter.keys()),
+            'filler_count': sum(filler_counter.values()),
+            'suggested_text': suggested_text
+        }
+
+    def calculate_readability(self, text):
+        """
+        Metnin okunabilirlik skorunu hesaplar (Türkçe'ye uyarlanmış Flesch Reading Ease)
+
+        Args:
+            text: Değerlendirilecek metin
+
+        Returns:
+            dict: {
+                'score': float,        # Okunabilirlik skoru (0-100)
+                'level': str,          # Okunabilirlik seviyesi
+                'avg_sentence_length': float, # Ortalama cümle uzunluğu
+                'avg_word_length': float      # Ortalama kelime uzunluğu
+            }
+        """
+        # Cümleleri ve kelimeleri ayır
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+
+        total_words = 0
+        total_syllables = 0
+
+        for sentence in sentences:
+            words = re.findall(r'\b\w+\b', sentence)
+            total_words += len(words)
+
+            # Türkçe heceleri kabaca hesapla (sesli harf sayısı)
+            for word in words:
+                # Türkçedeki sesli harfler
+                vowels = 'aeıioöuüAEIİOÖUÜ'
+                syllable_count = sum(1 for char in word if char in vowels)
+                # En az bir hece olmalı
+                syllable_count = max(1, syllable_count)
+                total_syllables += syllable_count
+
+        # Hesaplamalar
+        if len(sentences) == 0 or total_words == 0:
+            return {
+                'score': 100,  # Boş metin - en kolay
+                'level': 'çok_kolay',
+                'avg_sentence_length': 0,
+                'avg_word_length': 0
+            }
+
+        avg_sentence_length = total_words / len(sentences)
+        avg_syllables_per_word = total_syllables / total_words
+
+        # Türkçe için uyarlanmış Flesch Reading Ease
+        # (orijinal formül: 206.835 - 1.015 * ASL - 84.6 * ASW)
+        # Türkçe için katsayılar ayarlandı
+        readability_score = 206.835 - (1.3 * avg_sentence_length) - (60.0 * avg_syllables_per_word)
+
+        # Skoru 0-100 aralığına sınırla
+        readability_score = max(0, min(100, readability_score))
+
+        # Seviyeyi belirle
+        level = 'çok_zor'
+        for threshold_level, threshold_value in sorted(self.readability_thresholds.items(), key=lambda x: x[1]):
+            if readability_score >= threshold_value:
+                level = threshold_level
+                break
+
+        return {
+            'score': float(readability_score),
+            'level': level,
+            'avg_sentence_length': float(avg_sentence_length),
+            'avg_word_length': float(avg_syllables_per_word)
+        }
+
+    def improve_text(self, text):
+        """
+        Metni kapsamlı şekilde analiz eder ve iyileştirme önerileri sunar
+
+        Args:
+            text: İyileştirilecek metin
+
+        Returns:
+            dict: Tüm iyileştirme analizlerini içeren sonuçlar
+        """
+        if not text or len(text.strip()) == 0:
+            return {
+                'corrected_text': text,
+                'suggestions': [],
+                'readability': {
+                    'score': 100,
+                    'level': 'çok_kolay'
+                },
+                'improvement_count': 0
+            }
+
+        try:
+            # Yazım hatalarını düzelt
+            typo_results = self.fix_typos(text)
+
+            # Dilbilgisi kontrolü
+            grammar_results = self.check_grammar(typo_results['corrected_text'])
+
+            # Doldurma kelimelerini azalt
+            filler_results = self.reduce_filler_words(typo_results['corrected_text'])
+
+            # Okunabilirlik hesapla
+            readability_results = self.calculate_readability(text)
+
+            # Tüm önerileri birleştir
+            all_suggestions = []
+            all_suggestions.extend([f"Yazım düzeltmesi: {correction}" for correction in typo_results['corrections']])
+            all_suggestions.extend(
+                [f"Dilbilgisi önerisi: {suggestion}" for suggestion in grammar_results['suggestions']])
+
+            if filler_results['filler_count'] > 0:
+                all_suggestions.append(f"Doldurma kelimelerini azaltın: {', '.join(filler_results['filler_words'])}")
+
+            # Okunabilirlik önerisi
+            if readability_results['score'] < 60:  # Orta seviyenin altında ise
+                if readability_results['avg_sentence_length'] > 15:
+                    all_suggestions.append("Daha kısa cümleler kullanın (ortalama cümle uzunluğu yüksek)")
+                if readability_results['avg_word_length'] > 2.5:
+                    all_suggestions.append("Daha basit kelimeler kullanmayı deneyin (ortalama hece sayısı yüksek)")
+
+            # Birleştirilmiş sonuç
+            return {
+                'original_text': text,
+                'corrected_text': typo_results['corrected_text'],
+                'improved_text': filler_results['suggested_text'],
+                'suggestions': all_suggestions,
+                'readability': {
+                    'score': readability_results['score'],
+                    'level': readability_results['level'],
+                    'avg_sentence_length': readability_results['avg_sentence_length']
+                },
+                'improvement_count': len(all_suggestions)
+            }
+
+        except Exception as e:
+            logger.error(f"Metin iyileştirme sırasında hata: {str(e)}")
+            return {
+                'original_text': text,
+                'corrected_text': text,
+                'improved_text': text,
+                'suggestions': ["Metin analizi sırasında bir hata oluştu"],
+                'readability': {
+                    'score': 0,
+                    'level': 'bilinmiyor'
+                },
+                'improvement_count': 0
+            }

utils/toxicity_scorer.py

@@ -0,0 +1,188 @@
+import torch
+import numpy as np
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import logging
+import re
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+
+class ToxicityScorer:
+    def __init__(self, model=None, tokenizer=None):
+        """
+        Toxicity Scorer sınıfını başlatır.
+
+        Args:
+            model: Zararlılık modeli
+            tokenizer: Model için tokenizer
+        """
+        self.model = model
+        self.tokenizer = tokenizer
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.is_turkish_model = False
+
+        if model is None or tokenizer is None:
+            logging.warning("No toxicity model provided. Using default model.")
+            self.load_default_model()
+
+    def load_default_model(self):
+        """
+        Varsayılan zararlılık modelini yükler
+        """
+        try:
+            # Öncelikle Türkçe duygu analizi modeli deneyelim
+            model_name = "savasy/bert-base-turkish-sentiment"
+            logging.info(f"Loading Turkish sentiment model: {model_name}")
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
+            self.model.to(self.device)
+            self.is_turkish_model = True
+            logging.info("Turkish sentiment model loaded successfully")
+        except Exception as e:
+            logging.error(f"Error loading Turkish model: {str(e)}")
+            try:
+                # Yedek olarak genel model yükleyelim
+                backup_model = "dbmdz/bert-base-turkish-cased"
+                logging.info(f"Trying Turkish BERT model: {backup_model}")
+                self.tokenizer = AutoTokenizer.from_pretrained(backup_model)
+                self.model = AutoModelForSequenceClassification.from_pretrained(backup_model)
+                self.model.to(self.device)
+                self.is_turkish_model = True
+                logging.info("Turkish BERT model loaded successfully")
+            except Exception as e2:
+                logging.error(f"Error loading Turkish BERT model: {str(e2)}")
+                try:
+                    # Son çare olarak İngilizce model kullanalım
+                    english_model = "distilbert/distilbert-base-uncased-finetuned-sst-2-english"
+                    logging.info(f"Trying English sentiment model: {english_model}")
+                    self.tokenizer = AutoTokenizer.from_pretrained(english_model)
+                    self.model = AutoModelForSequenceClassification.from_pretrained(english_model)
+                    self.model.to(self.device)
+                    self.is_turkish_model = False
+                    logging.info("English sentiment model loaded successfully")
+                except Exception as e3:
+                    logging.error(f"Error loading English model: {str(e3)}")
+                    raise e3
+
+    def _contains_turkish_profanity(self, text):
+        """
+        Temel Türkçe küfür ve hakaret kontrolü yapar
+        """
+        # Türkçede yaygın küfür/hakaret içeren kelimelerin listesi
+        turkish_profanity = [
+            'aptal', 'salak', 'gerizekalı', 'ahmak', 'enayi', 'mal', 'geri zekalı',
+            'beyinsiz', 'budala', 'adi', 'ahlaksız', 'şerefsiz', 'haysiyetsiz',
+            'orospu', 'piç', 'yavşak', 'sürtük', 'sürtüğü', 'gavat', 'şerefsiz',
+            'siktir', 'pezevenk', 'namussuz'
+        ]
+
+        # Noktalama işaretlerini ve sayıları kaldır
+        text = re.sub(r'[^\w\s]', '', text.lower())
+        text = re.sub(r'\d+', '', text)
+        words = text.split()
+
+        # Metinde küfür/hakaret var mı kontrol et
+        for word in turkish_profanity:
+            if word in words:
+                return True
+
+        return False
+
+    def _contains_negative_words(self, text):
+        """
+        Temel Türkçe olumsuz kelime kontrolü yapar
+        """
+        # Türkçede yaygın olumsuz kelimeler
+        negative_words = [
+            'kötü', 'berbat', 'rezalet', 'korkunç', 'iğrenç', 'üzücü', 'acı',
+            'başarısız', 'yetersiz', 'düşük', 'zayıf', 'korkutucu', 'tehlikeli',
+            'nefret', 'öfke', 'saldırgan', 'yanlış', 'hata', 'hayal kırıklığı'
+        ]
+
+        text = text.lower()
+        count = sum(1 for word in negative_words if word in text.split())
+
+        # Olumsuz kelime yoğunluğunu hesapla
+        return count / len(text.split()) if text.split() else 0
+
+    def score_text(self, text):
+        """
+        Metin için zararlılık skoru hesaplar.
+
+        Args:
+            text: Değerlendirilecek metin
+
+        Returns:
+            float: 0 ile 1 arasında zararlılık skoru (1 = çok zararlı)
+        """
+        if not text or len(text.strip()) == 0:
+            return 0.0
+
+        # Temel kural tabanlı kontroller
+        profanity_detected = self._contains_turkish_profanity(text)
+        negative_ratio = self._contains_negative_words(text)
+
+        if profanity_detected:
+            base_score = 0.8  # Küfür/hakaret varsa yüksek başlangıç skoru
+        else:
+            base_score = negative_ratio * 0.5  # Olumsuz kelime yoğunluğuna göre skor
+
+        try:
+            # Model tabanlı skorlama
+            inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+            inputs = {key: val.to(self.device) for key, val in inputs.items()}
+
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+
+            # Modele göre doğru şekilde skoru alalım
+            if self.is_turkish_model:
+                # Türkçe duygu analizi modeli için özel işlem
+                probs = torch.softmax(outputs.logits, dim=1).cpu().numpy()[0]
+
+                # savasy/bert-base-turkish-sentiment için:
+                # 0: negative, 1: neutral, 2: positive
+                if len(probs) >= 3:
+                    # Negatif olasılığını zararlılık skoru olarak kullan ama çok yüksek değerler üretmemesi için 0.7 ile çarp
+                    model_score = probs[0] * 0.7
+                else:
+                    # İki sınıflı model için
+                    model_score = probs[0] * 0.6
+            else:
+                # İngilizce model için
+                probs = torch.softmax(outputs.logits, dim=1).cpu().numpy()[0]
+                # İngilizce modeller genellikle Türkçe için çok yüksek sonuçlar verir, bu yüzden 0.5 ile çarp
+                model_score = probs[0] * 0.5
+
+            # Kural tabanlı skor ve model skor birleşimi
+            final_score = (base_score * 0.4) + (model_score * 0.6)
+
+            # 0-1 aralığına sınırla
+            final_score = max(0.0, min(1.0, final_score))
+
+            return final_score
+
+        except Exception as e:
+            logging.error(f"Error scoring toxicity: {str(e)}")
+            # Hata durumunda sadece kural tabanlı skoru döndür
+            return min(base_score, 1.0)
+
+    def batch_score(self, texts, batch_size=16):
+        """
+        Bir metin listesi için toplu zararlılık skoru hesaplar.
+
+        Args:
+            texts: Değerlendirilecek metin listesi
+            batch_size: İşlenecek grup boyutu
+
+        Returns:
+            list: Zararlılık skorları listesi
+        """
+        results = []
+
+        for i in range(0, len(texts), batch_size):
+            batch_texts = texts[i:i + batch_size]
+            batch_scores = [self.score_text(text) for text in batch_texts]
+            results.extend(batch_scores)
+
+        return results