Delete api_integrations.py

api_integrations.py

@@ -1,480 +0,0 @@
-"""
-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
-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()
-
-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)
-    
-    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
-    
-    def get_available_models(self) -> List[str]:
-        """
-        Kullanılabilir OpenAI modellerini döndürür.
-        
-        Returns:
-            List[str]: Kullanılabilir modeller listesi
-        """
-        if not self.api_key:
-            return OPENAI_MODELS
-        
-        try:
-            models = openai.models.list()
-            # Sadece GPT modellerini filtrele
-            gpt_models = [model.id for model in models.data if "gpt" in model.id.lower()]
-            
-            # Tüm OpenAI modellerini döndür, API'den alınamayanlar için varsayılan listeyi kullan
-            all_models = list(set(gpt_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')
-                )
-            )
-            
-            return sorted_models
-        except Exception:
-            # API anahtarı geçersiz veya başka bir hata durumunda varsayılan modelleri döndür
-            return 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)
-    
-    def get_available_models(self) -> List[str]:
-        """
-        Kullanılabilir Gemini modellerini döndürür.
-        
-        Returns:
-            List[str]: Kullanılabilir modeller listesi
-        """
-        if not self.api_key:
-            return GEMINI_MODELS
-        
-        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)
-            
-            # Tüm Gemini modellerini döndür, API'den alınamayanlar için varsayılan listeyi kullan
-            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')
-                )
-            )
-            
-            return sorted_models
-        except Exception:
-            # API anahtarı geçersiz veya başka bir hata durumunda varsayılan modelleri döndür
-            return 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
-    
-    def get_available_models(self) -> List[str]:
-        """
-        Kullanılabilir OpenRouter modellerini döndürür.
-        
-        Returns:
-            List[str]: Kullanılabilir modeller listesi
-        """
-        if not self.api_key:
-            return OPENROUTER_MODELS
-        
-        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"]]
-                
-                # API'den alınan modeller ve varsayılan modelleri birleştir
-                all_models = list(set(api_models + OPENROUTER_MODELS))
-                
-                return all_models
-            else:
-                return OPENROUTER_MODELS
-        except Exception:
-            # API anahtarı geçersiz veya başka bir hata durumunda varsayılan modelleri döndür
-            return 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": ""}
-
-
-# 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)
-
-# 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()
-            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()
-            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()
-            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()