Upload 2 files

api_integrations.py

@@ -0,0 +1,722 @@
+"""
+API entegrasyonları için yardımcı fonksiyonlar.
+Bu modül, OpenAI, Google Gemini ve OpenRouter API'leri ile etkileşim için gerekli fonksiyonları içerir.
+"""
+
+import os
+import json
+import time
+import threading
+from typing import Dict, Any, List, Optional
+import openai
+from google import generativeai as genai
+import requests
+from dotenv import load_dotenv
+
+# Prompt şablonlarından model listelerini içe aktar
+from prompt_templates import OPENAI_MODELS, GEMINI_MODELS, OPENROUTER_MODELS
+
+# .env dosyasını yükle (varsa)
+load_dotenv()
+
+# Model önbelleği için global değişkenler
+MODEL_CACHE = {
+    "openai": {
+        "models": [],
+        "last_updated": 0,
+        "update_interval": 3600  # 1 saat (saniye cinsinden)
+    },
+    "gemini": {
+        "models": [],
+        "last_updated": 0,
+        "update_interval": 3600  # 1 saat (saniye cinsinden)
+    },
+    "openrouter": {
+        "models": [],
+        "last_updated": 0,
+        "update_interval": 3600  # 1 saat (saniye cinsinden)
+    }
+}
+
+# Model önbelleği dosya yolu
+CACHE_FILE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "model_cache.json")
+
+def load_model_cache():
+    """
+    Disk üzerindeki model önbelleğini yükler.
+    """
+    global MODEL_CACHE
+    try:
+        if os.path.exists(CACHE_FILE_PATH):
+            with open(CACHE_FILE_PATH, 'r') as f:
+                cache_data = json.load(f)
+                MODEL_CACHE = cache_data
+                print(f"Model önbelleği yüklendi: {len(MODEL_CACHE['openai']['models'])} OpenAI, {len(MODEL_CACHE['gemini']['models'])} Gemini, {len(MODEL_CACHE['openrouter']['models'])} OpenRouter modeli")
+    except Exception as e:
+        print(f"Model önbelleği yüklenirken hata oluştu: {str(e)}")
+
+def save_model_cache():
+    """
+    Model önbelleğini diske kaydeder.
+    """
+    try:
+        with open(CACHE_FILE_PATH, 'w') as f:
+            json.dump(MODEL_CACHE, f)
+            print("Model önbelleği diske kaydedildi")
+    except Exception as e:
+        print(f"Model önbelleği kaydedilirken hata oluştu: {str(e)}")
+
+# Uygulama başlangıcında önbelleği yükle
+load_model_cache()
+
+class APIManager:
+    """
+    API yönetimi için sınıf.
+    Bu sınıf, API anahtarlarını yönetir ve API'lerin durumunu kontrol eder.
+    """
+    
+    def __init__(self):
+        """
+        API yöneticisini başlat.
+        """
+        self.api_keys = {
+            "openai": os.getenv("OPENAI_API_KEY", ""),
+            "gemini": os.getenv("GEMINI_API_KEY", ""),
+            "openrouter": os.getenv("OPENROUTER_API_KEY", "")
+        }
+    
+    def set_api_key(self, provider: str, api_key: str) -> None:
+        """
+        Belirli bir sağlayıcı için API anahtarını ayarlar.
+        
+        Args:
+            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
+            api_key (str): API anahtarı
+        """
+        if provider in self.api_keys:
+            self.api_keys[provider] = api_key
+            
+            # API anahtarını ilgili kütüphane için de ayarla
+            if provider == "openai":
+                openai.api_key = api_key
+            elif provider == "gemini":
+                genai.configure(api_key=api_key)
+            
+            # API anahtarı değiştiğinde model önbelleğini sıfırla
+            global MODEL_CACHE
+            MODEL_CACHE[provider]["last_updated"] = 0
+    
+    def get_api_key(self, provider: str) -> str:
+        """
+        Belirli bir sağlayıcı için API anahtarını döndürür.
+        
+        Args:
+            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
+            
+        Returns:
+            str: API anahtarı
+        """
+        return self.api_keys.get(provider, "")
+    
+    def check_api_key_validity(self, provider: str) -> bool:
+        """
+        Belirli bir sağlayıcı için API anahtarının geçerliliğini kontrol eder.
+        
+        Args:
+            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
+            
+        Returns:
+            bool: API anahtarı geçerli ise True, değilse False
+        """
+        api_key = self.get_api_key(provider)
+        
+        if not api_key:
+            return False
+        
+        try:
+            if provider == "openai":
+                openai.api_key = api_key
+                # Basit bir model listesi isteği ile API anahtarının geçerliliğini kontrol et
+                openai.models.list()
+                return True
+            
+            elif provider == "gemini":
+                genai.configure(api_key=api_key)
+                # Kullanılabilir modelleri listeleyerek API anahtarının geçerliliğini kontrol et
+                genai.list_models()
+                return True
+            
+            elif provider == "openrouter":
+                headers = {
+                    "Authorization": f"Bearer {api_key}"
+                }
+                response = requests.get(
+                    "https://openrouter.ai/api/v1/models",
+                    headers=headers
+                )
+                return response.status_code == 200
+            
+            return False
+        
+        except Exception:
+            return False
+
+
+class OpenAIHandler:
+    """
+    OpenAI API ile etkileşim için sınıf.
+    """
+    
+    def __init__(self, api_key: str = ""):
+        """
+        OpenAI işleyicisini başlat.
+        
+        Args:
+            api_key (str, optional): OpenAI API anahtarı
+        """
+        self.api_key = api_key
+        if api_key:
+            openai.api_key = api_key
+    
+    def set_api_key(self, api_key: str) -> None:
+        """
+        OpenAI API anahtarını ayarlar.
+        
+        Args:
+            api_key (str): OpenAI API anahtarı
+        """
+        self.api_key = api_key
+        openai.api_key = api_key
+        
+        # API anahtarı değiştiğinde model önbelleğini sıfırla
+        global MODEL_CACHE
+        MODEL_CACHE["openai"]["last_updated"] = 0
+    
+    def fetch_models_from_api(self) -> List[str]:
+        """
+        OpenAI API'sinden modelleri çeker.
+        
+        Returns:
+            List[str]: API'den çekilen modeller listesi
+        """
+        if not self.api_key:
+            return []
+        
+        try:
+            models = openai.models.list()
+            # Sadece GPT modellerini filtrele
+            gpt_models = [model.id for model in models.data if "gpt" in model.id.lower()]
+            return gpt_models
+        except Exception as e:
+            print(f"OpenAI modellerini çekerken hata oluştu: {str(e)}")
+            return []
+    
+    def get_available_models(self, force_refresh: bool = False) -> List[str]:
+        """
+        Kullanılabilir OpenAI modellerini döndürür.
+        
+        Args:
+            force_refresh (bool): Önbelleği zorla yenileme
+            
+        Returns:
+            List[str]: Kullanılabilir modeller listesi
+        """
+        global MODEL_CACHE
+        
+        current_time = time.time()
+        cache = MODEL_CACHE["openai"]
+        
+        # Önbellek yenileme koşulları: 
+        # 1. Zorla yenileme istenmiş
+        # 2. Önbellek boş
+        # 3. Önbellek güncellenme zamanı aşılmış
+        if (force_refresh or 
+            not cache["models"] or 
+            current_time - cache["last_updated"] > cache["update_interval"]):
+            
+            # API'den modelleri çek
+            api_models = self.fetch_models_from_api()
+            
+            if api_models:
+                # API'den modeller başarıyla çekildiyse önbelleği güncelle
+                all_models = list(set(api_models + OPENAI_MODELS))
+                
+                # Varsayılan modelleri önceliklendir
+                sorted_models = sorted(
+                    all_models,
+                    key=lambda x: (
+                        0 if x in OPENAI_MODELS else 1,
+                        OPENAI_MODELS.index(x) if x in OPENAI_MODELS else float('inf')
+                    )
+                )
+                
+                # Önbelleği güncelle
+                MODEL_CACHE["openai"]["models"] = sorted_models
+                MODEL_CACHE["openai"]["last_updated"] = current_time
+                
+                # Önbelleği diske kaydet
+                save_model_cache()
+                
+                return sorted_models
+            else:
+                # API'den model çekilemediyse önbellekteki modelleri kullan
+                if cache["models"]:
+                    return cache["models"]
+                else:
+                    return OPENAI_MODELS
+        else:
+            # Önbellek güncel, önbellekteki modelleri kullan
+            return cache["models"] if cache["models"] else OPENAI_MODELS
+    
+    def generate_response(self, prompt: str, model: str = "gpt-3.5-turbo", temperature: float = 0.7, max_tokens: int = 2000) -> Dict[str, Any]:
+        """
+        OpenAI API kullanarak yanıt oluşturur.
+        
+        Args:
+            prompt (str): Gönderilecek prompt
+            model (str): Kullanılacak model
+            temperature (float): Sıcaklık değeri (0.0-1.0)
+            max_tokens (int): Maksimum token sayısı
+            
+        Returns:
+            Dict[str, Any]: Yanıt bilgilerini içeren sözlük
+        """
+        if not self.api_key:
+            return {"success": False, "error": "OpenAI API anahtarı ayarlanmamış.", "content": ""}
+        
+        try:
+            response = openai.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+            
+            return {
+                "success": True,
+                "content": response.choices[0].message.content,
+                "model": model,
+                "usage": {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "completion_tokens": response.usage.completion_tokens,
+                    "total_tokens": response.usage.total_tokens
+                }
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e), "content": ""}
+
+
+class GeminiHandler:
+    """
+    Google Gemini API ile etkileşim için sınıf.
+    """
+    
+    def __init__(self, api_key: str = ""):
+        """
+        Gemini işleyicisini başlat.
+        
+        Args:
+            api_key (str, optional): Gemini API anahtarı
+        """
+        self.api_key = api_key
+        if api_key:
+            genai.configure(api_key=api_key)
+    
+    def set_api_key(self, api_key: str) -> None:
+        """
+        Gemini API anahtarını ayarlar.
+        
+        Args:
+            api_key (str): Gemini API anahtarı
+        """
+        self.api_key = api_key
+        genai.configure(api_key=api_key)
+        
+        # API anahtarı değiştiğinde model önbelleğini sıfırla
+        global MODEL_CACHE
+        MODEL_CACHE["gemini"]["last_updated"] = 0
+    
+    def fetch_models_from_api(self) -> List[str]:
+        """
+        Gemini API'sinden modelleri çeker.
+        
+        Returns:
+            List[str]: API'den çekilen modeller listesi
+        """
+        if not self.api_key:
+            return []
+        
+        try:
+            models = genai.list_models()
+            api_models = []
+            
+            # Tüm model türlerini topla (gemini, imagen, veo, vb.)
+            for model in models:
+                model_name = model.name.split("/")[-1]
+                if any(keyword in model_name.lower() for keyword in ["gemini", "imagen", "veo"]):
+                    api_models.append(model_name)
+            
+            return api_models
+        except Exception as e:
+            print(f"Gemini modellerini çekerken hata oluştu: {str(e)}")
+            return []
+    
+    def get_available_models(self, force_refresh: bool = False) -> List[str]:
+        """
+        Kullanılabilir Gemini modellerini döndürür.
+        
+        Args:
+            force_refresh (bool): Önbelleği zorla yenileme
+            
+        Returns:
+            List[str]: Kullanılabilir modeller listesi
+        """
+        global MODEL_CACHE
+        
+        current_time = time.time()
+        cache = MODEL_CACHE["gemini"]
+        
+        # Önbellek yenileme koşulları: 
+        # 1. Zorla yenileme istenmiş
+        # 2. Önbellek boş
+        # 3. Önbellek güncellenme zamanı aşılmış
+        if (force_refresh or 
+            not cache["models"] or 
+            current_time - cache["last_updated"] > cache["update_interval"]):
+            
+            # API'den modelleri çek
+            api_models = self.fetch_models_from_api()
+            
+            if api_models:
+                # API'den modeller başarıyla çekildiyse önbelleği güncelle
+                all_models = list(set(api_models + GEMINI_MODELS))
+                
+                # Varsayılan modelleri önceliklendir
+                sorted_models = sorted(
+                    all_models,
+                    key=lambda x: (
+                        0 if x in GEMINI_MODELS else 1,
+                        GEMINI_MODELS.index(x) if x in GEMINI_MODELS else float('inf')
+                    )
+                )
+                
+                # Önbelleği güncelle
+                MODEL_CACHE["gemini"]["models"] = sorted_models
+                MODEL_CACHE["gemini"]["last_updated"] = current_time
+                
+                # Önbelleği diske kaydet
+                save_model_cache()
+                
+                return sorted_models
+            else:
+                # API'den model çekilemediyse önbellekteki modelleri kullan
+                if cache["models"]:
+                    return cache["models"]
+                else:
+                    return GEMINI_MODELS
+        else:
+            # Önbellek güncel, önbellekteki modelleri kullan
+            return cache["models"] if cache["models"] else GEMINI_MODELS
+    
+    def generate_response(self, prompt: str, model: str = "gemini-1.5-pro", temperature: float = 0.7) -> Dict[str, Any]:
+        """
+        Gemini API kullanarak yanıt oluşturur.
+        
+        Args:
+            prompt (str): Gönderilecek prompt
+            model (str): Kullanılacak model
+            temperature (float): Sıcaklık değeri (0.0-1.0)
+            
+        Returns:
+            Dict[str, Any]: Yanıt bilgilerini içeren sözlük
+        """
+        if not self.api_key:
+            return {"success": False, "error": "Gemini API anahtarı ayarlanmamış.", "content": ""}
+        
+        try:
+            model_obj = genai.GenerativeModel(model)
+            response = model_obj.generate_content(
+                prompt,
+                generation_config=genai.types.GenerationConfig(
+                    temperature=temperature
+                )
+            )
+            
+            return {
+                "success": True,
+                "content": response.text,
+                "model": model
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e), "content": ""}
+
+
+class OpenRouterHandler:
+    """
+    OpenRouter API ile etkileşim için sınıf.
+    """
+    
+    def __init__(self, api_key: str = ""):
+        """
+        OpenRouter işleyicisini başlat.
+        
+        Args:
+            api_key (str, optional): OpenRouter API anahtarı
+        """
+        self.api_key = api_key
+        self.base_url = "https://openrouter.ai/api/v1"
+    
+    def set_api_key(self, api_key: str) -> None:
+        """
+        OpenRouter API anahtarını ayarlar.
+        
+        Args:
+            api_key (str): OpenRouter API anahtarı
+        """
+        self.api_key = api_key
+        
+        # API anahtarı değiştiğinde model önbelleğini sıfırla
+        global MODEL_CACHE
+        MODEL_CACHE["openrouter"]["last_updated"] = 0
+    
+    def fetch_models_from_api(self) -> List[str]:
+        """
+        OpenRouter API'sinden modelleri çeker.
+        
+        Returns:
+            List[str]: API'den çekilen modeller listesi
+        """
+        if not self.api_key:
+            return []
+        
+        try:
+            headers = {
+                "Authorization": f"Bearer {self.api_key}"
+            }
+            
+            response = requests.get(
+                f"{self.base_url}/models",
+                headers=headers
+            )
+            
+            if response.status_code == 200:
+                models_data = response.json()
+                api_models = [model["id"] for model in models_data["data"]]
+                return api_models
+            else:
+                print(f"OpenRouter modellerini çekerken HTTP hatası: {response.status_code}")
+                return []
+        except Exception as e:
+            print(f"OpenRouter modellerini çekerken hata oluştu: {str(e)}")
+            return []
+    
+    def get_available_models(self, force_refresh: bool = False) -> List[str]:
+        """
+        Kullanılabilir OpenRouter modellerini döndürür.
+        
+        Args:
+            force_refresh (bool): Önbelleği zorla yenileme
+            
+        Returns:
+            List[str]: Kullanılabilir modeller listesi
+        """
+        global MODEL_CACHE
+        
+        current_time = time.time()
+        cache = MODEL_CACHE["openrouter"]
+        
+        # Önbellek yenileme koşulları: 
+        # 1. Zorla yenileme istenmiş
+        # 2. Önbellek boş
+        # 3. Önbellek güncellenme zamanı aşılmış
+        if (force_refresh or 
+            not cache["models"] or 
+            current_time - cache["last_updated"] > cache["update_interval"]):
+            
+            # API'den modelleri çek
+            api_models = self.fetch_models_from_api()
+            
+            if api_models:
+                # API'den modeller başarıyla çekildiyse önbelleği güncelle
+                all_models = list(set(api_models + OPENROUTER_MODELS))
+                
+                # Varsayılan modelleri önceliklendir
+                sorted_models = sorted(
+                    all_models,
+                    key=lambda x: (
+                        0 if x in OPENROUTER_MODELS else 1,
+                        OPENROUTER_MODELS.index(x) if x in OPENROUTER_MODELS else float('inf')
+                    )
+                )
+                
+                # Önbelleği güncelle
+                MODEL_CACHE["openrouter"]["models"] = sorted_models
+                MODEL_CACHE["openrouter"]["last_updated"] = current_time
+                
+                # Önbelleği diske kaydet
+                save_model_cache()
+                
+                return sorted_models
+            else:
+                # API'den model çekilemediyse önbellekteki modelleri kullan
+                if cache["models"]:
+                    return cache["models"]
+                else:
+                    return OPENROUTER_MODELS
+        else:
+            # Önbellek güncel, önbellekteki modelleri kullan
+            return cache["models"] if cache["models"] else OPENROUTER_MODELS
+    
+    def generate_response(self, prompt: str, model: str = "openai/gpt-4-turbo", temperature: float = 0.7, max_tokens: int = 2000) -> Dict[str, Any]:
+        """
+        OpenRouter API kullanarak yanıt oluşturur.
+        
+        Args:
+            prompt (str): Gönderilecek prompt
+            model (str): Kullanılacak model
+            temperature (float): Sıcaklık değeri (0.0-1.0)
+            max_tokens (int): Maksimum token sayısı
+            
+        Returns:
+            Dict[str, Any]: Yanıt bilgilerini içeren sözlük
+        """
+        if not self.api_key:
+            return {"success": False, "error": "OpenRouter API anahtarı ayarlanmamış.", "content": ""}
+        
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+            
+            data = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+            
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=headers,
+                json=data
+            )
+            
+            if response.status_code == 200:
+                response_data = response.json()
+                return {
+                    "success": True,
+                    "content": response_data["choices"][0]["message"]["content"],
+                    "model": model,
+                    "usage": response_data.get("usage", {})
+                }
+            else:
+                return {
+                    "success": False, 
+                    "error": f"HTTP {response.status_code}: {response.text}", 
+                    "content": ""
+                }
+        except Exception as e:
+            return {"success": False, "error": str(e), "content": ""}
+
+
+# Arka planda model listelerini güncelleyen fonksiyon
+def background_model_updater():
+    """
+    Arka planda çalışarak model listelerini periyodik olarak günceller.
+    """
+    while True:
+        try:
+            # Her sağlayıcı için modelleri güncelle
+            if openai_handler.api_key:
+                openai_handler.get_available_models(force_refresh=True)
+            
+            if gemini_handler.api_key:
+                gemini_handler.get_available_models(force_refresh=True)
+            
+            if openrouter_handler.api_key:
+                openrouter_handler.get_available_models(force_refresh=True)
+            
+            print("Model listeleri arka planda güncellendi")
+            
+            # 1 saat bekle
+            time.sleep(3600)
+        except Exception as e:
+            print(f"Arka plan model güncelleyicisinde hata: {str(e)}")
+            time.sleep(60)  # Hata durumunda 1 dakika bekle ve tekrar dene
+
+
+# API işleyicilerini oluştur
+api_manager = APIManager()
+openai_handler = OpenAIHandler()
+gemini_handler = GeminiHandler()
+openrouter_handler = OpenRouterHandler()
+
+# API anahtarlarını ayarla (varsa)
+openai_api_key = os.getenv("OPENAI_API_KEY", "")
+gemini_api_key = os.getenv("GEMINI_API_KEY", "")
+openrouter_api_key = os.getenv("OPENROUTER_API_KEY", "")
+
+if openai_api_key:
+    openai_handler.set_api_key(openai_api_key)
+
+if gemini_api_key:
+    gemini_handler.set_api_key(gemini_api_key)
+
+if openrouter_api_key:
+    openrouter_handler.set_api_key(openrouter_api_key)
+
+# Arka plan model güncelleyicisini başlat
+updater_thread = threading.Thread(target=background_model_updater, daemon=True)
+updater_thread.start()
+
+# Test fonksiyonu
+def test_api_connections():
+    """
+    API bağlantılarını test eder.
+    """
+    print("API Bağlantı Testi:")
+    
+    # OpenAI API testi
+    if openai_api_key:
+        print("\nOpenAI API Testi:")
+        try:
+            models = openai_handler.get_available_models(force_refresh=True)
+            print(f"Kullanılabilir modeller: {models[:5]}...")
+            print("OpenAI API bağlantısı başarılı.")
+        except Exception as e:
+            print(f"OpenAI API hatası: {str(e)}")
+    else:
+        print("\nOpenAI API anahtarı ayarlanmamış.")
+        print(f"Varsayılan modeller: {OPENAI_MODELS}")
+    
+    # Gemini API testi
+    if gemini_api_key:
+        print("\nGemini API Testi:")
+        try:
+            models = gemini_handler.get_available_models(force_refresh=True)
+            print(f"Kullanılabilir modeller: {models}")
+            print("Gemini API bağlantısı başarılı.")
+        except Exception as e:
+            print(f"Gemini API hatası: {str(e)}")
+    else:
+        print("\nGemini API anahtarı ayarlanmamış.")
+        print(f"Varsayılan modeller: {GEMINI_MODELS}")
+    
+    # OpenRouter API testi
+    if openrouter_api_key:
+        print("\nOpenRouter API Testi:")
+        try:
+            models = openrouter_handler.get_available_models(force_refresh=True)
+            print(f"Kullanılabilir modeller: {len(models)} model bulundu")
+            print(f"İlk 10 model: {models[:10]}...")
+            print("OpenRouter API bağlantısı başarılı.")
+        except Exception as e:
+            print(f"OpenRouter API hatası: {str(e)}")
+    else:
+        print("\nOpenRouter API anahtarı ayarlanmamış.")
+        print(f"Varsayılan modeller: {len(OPENROUTER_MODELS)} model bulundu")
+        print(f"İlk 10 model: {OPENROUTER_MODELS[:10]}...")
+
+if __name__ == "__main__":
+    test_api_connections()

test_dynamic_models.py

@@ -0,0 +1,93 @@
+"""
+API entegrasyonlarını test etmek için script.
+Bu script, dinamik model keşfi özelliğini test eder.
+"""
+
+import os
+import time
+from api_integrations import (
+    api_manager,
+    openai_handler,
+    gemini_handler,
+    openrouter_handler,
+    MODEL_CACHE,
+    load_model_cache,
+    save_model_cache
+)
+
+def test_dynamic_model_discovery():
+    """
+    Dinamik model keşfi özelliğini test eder.
+    """
+    print("Dinamik Model Keşfi Testi\n" + "="*30)
+    
+    # Mevcut önbellek durumunu göster
+    print("\nMevcut Önbellek Durumu:")
+    for provider in MODEL_CACHE:
+        model_count = len(MODEL_CACHE[provider]["models"])
+        last_updated = MODEL_CACHE[provider]["last_updated"]
+        last_updated_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(last_updated)) if last_updated > 0 else "Hiç güncellenmemiş"
+        
+        print(f"{provider.capitalize()}: {model_count} model, Son güncelleme: {last_updated_str}")
+    
+    # OpenAI modellerini test et
+    print("\nOpenAI Modelleri Testi:")
+    if openai_handler.api_key:
+        print("API anahtarı mevcut, API'den modelleri çekme...")
+        models = openai_handler.get_available_models(force_refresh=True)
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"İlk 10 model: {models[:10]}")
+    else:
+        print("API anahtarı mevcut değil, varsayılan modeller kullanılacak.")
+        models = openai_handler.get_available_models()
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"Modeller: {models}")
+    
+    # Gemini modellerini test et
+    print("\nGemini Modelleri Testi:")
+    if gemini_handler.api_key:
+        print("API anahtarı mevcut, API'den modelleri çekme...")
+        models = gemini_handler.get_available_models(force_refresh=True)
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"Modeller: {models}")
+    else:
+        print("API anahtarı mevcut değil, varsayılan modeller kullanılacak.")
+        models = gemini_handler.get_available_models()
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"Modeller: {models}")
+    
+    # OpenRouter modellerini test et
+    print("\nOpenRouter Modelleri Testi:")
+    if openrouter_handler.api_key:
+        print("API anahtarı mevcut, API'den modelleri çekme...")
+        models = openrouter_handler.get_available_models(force_refresh=True)
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"İlk 10 model: {models[:10]}")
+    else:
+        print("API anahtarı mevcut değil, varsayılan modeller kullanılacak.")
+        models = openrouter_handler.get_available_models()
+        print(f"Toplam {len(models)} model bulundu.")
+        print(f"İlk 10 model: {models[:10]}")
+    
+    # Önbellek dosyasını kontrol et
+    cache_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "model_cache.json")
+    if os.path.exists(cache_file_path):
+        print(f"\nÖnbellek dosyası mevcut: {cache_file_path}")
+        print(f"Dosya boyutu: {os.path.getsize(cache_file_path)} byte")
+    else:
+        print(f"\nÖnbellek dosyası henüz oluşturulmamış: {cache_file_path}")
+    
+    # Önbellek yeniden yükleme testi
+    print("\nÖnbellek Yeniden Yükleme Testi:")
+    load_model_cache()
+    for provider in MODEL_CACHE:
+        model_count = len(MODEL_CACHE[provider]["models"])
+        last_updated = MODEL_CACHE[provider]["last_updated"]
+        last_updated_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(last_updated)) if last_updated > 0 else "Hiç güncellenmemiş"
+        
+        print(f"{provider.capitalize()}: {model_count} model, Son güncelleme: {last_updated_str}")
+    
+    print("\nTest tamamlandı!")
+
+if __name__ == "__main__":
+    test_dynamic_model_discovery()