api.py

#!/usr/bin/env python3
# api.py - Fixed API Calls berdasarkan CupidHelper
import time
import requests
import random
from datetime import datetime

class APIManager:
    def __init__(self):
        self.apis = {
            "groq": {
                "name": "Groq",
                "key": "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",
                "url": "https://api.groq.com/openai/v1/chat/completions",
                "model": "llama-3.1-8b-instant",  # 🆕 Model yang betul
                "active": True,
                "last_used": None
            },
            "deepseek": {
                "name": "DeepSeek",
                "key": "sk-018cc05d3a574de68947e669673fdf65",
                "url": "https://api.deepseek.com/chat/completions",  # 🆕 URL yang betul
                "model": "deepseek-chat",
                "active": True,
                "last_used": None
            },
            "gemini": {
                "name": "Gemini",
                "key": "AIzaSyDVoBSniv6CtvNZDPxvPNRPfRXWvj3304M",
                "url": "https://generativelanguage.googleapis.com/v1/models/gemini-2.0-flash:generateContent",  # 🆕 URL yang betul
                "active": True,
                "last_used": None
            }
        }

        self.request_history = []
        self.fallback_order = ["groq", "deepseek", "gemini"]  # 🆕 Order berdasarkan CupidHelper

    def get_ai_response(self, prompt, bot_name="www", max_retries=2):
        """Get AI response dengan fallback - FIXED"""
        print(f"🤖 [{bot_name}] Requesting AI response...")

        for attempt in range(max_retries):
            for api_name in self.fallback_order:
                if self.apis[api_name]["active"]:
                    try:
                        response = self._call_api(api_name, prompt)
                        if response and len(response.strip()) > 3:
                            return response
                    except Exception as e:
                        print(f"❌ {api_name} failed: {e}")
                        self.apis[api_name]["active"] = False

            if attempt < max_retries - 1:
                print(f"🔄 Attempt {attempt + 1} failed, retrying...")
                time.sleep(1)

        return "Maaf, semua API sedang sibuk. Cuba sebentar lagi."

    def _call_api(self, api_name, prompt):
        """Call specific API - FIXED berdasarkan CupidHelper"""
        api_config = self.apis[api_name]

        try:
            if api_name == "groq":
                return self._call_groq(prompt, api_config)
            elif api_name == "deepseek":
                return self._call_deepseek(prompt, api_config)
            elif api_name == "gemini":
                return self._call_gemini(prompt, api_config)
        except Exception as e:
            print(f"❌ {api_name} error: {e}")
            raise

    def _call_groq(self, prompt, config):
        """Call Groq API - FIXED"""
        headers = {
            "Authorization": f"Bearer {config['key']}",
            "Content-Type": "application/json"
        }

        data = {
            "model": config["model"],  # 🆕 Gunakan model yang betul
            "messages": [
                {
                    "role": "user",
                    "content": prompt
                }
            ],
            "temperature": 0.7,
            "max_tokens": 150
        }

        response = requests.post(config["url"], headers=headers, json=data, timeout=10)

        if response.status_code != 200:
            raise Exception(f"HTTP {response.status_code}: {response.text}")

        result = response.json()
        content = result["choices"][0]["message"]["content"].strip()

        config["last_used"] = time.time()
        self._log_request("groq", True, len(content))

        return self._trim_response(content)

    def _call_deepseek(self, prompt, config):
        """Call DeepSeek API - FIXED"""
        headers = {
            "Authorization": f"Bearer {config['key']}",
            "Content-Type": "application/json"
        }

        data = {
            "model": config["model"],
            "messages": [
                {
                    "role": "user",
                    "content": prompt
                }
            ],
            "temperature": 0.7,
            "max_tokens": 150
        }

        response = requests.post(config["url"], headers=headers, json=data, timeout=10)

        if response.status_code != 200:
            raise Exception(f"HTTP {response.status_code}: {response.text}")

        result = response.json()
        content = result["choices"][0]["message"]["content"].strip()

        config["last_used"] = time.time()
        self._log_request("deepseek", True, len(content))

        return self._trim_response(content)

    def _call_gemini(self, prompt, config):
        """Call Gemini API - FIXED"""
        url = f"{config['url']}?key={config['key']}"

        data = {
            "contents": [
                {
                    "parts": [
                        {"text": prompt}
                    ]
                }
            ],
            "generationConfig": {
                "maxOutputTokens": 150,
                "temperature": 0.7
            }
        }

        response = requests.post(url, json=data, timeout=10)

        if response.status_code != 200:
            raise Exception(f"HTTP {response.status_code}: {response.text}")

        result = response.json()
        content = result["candidates"][0]["content"]["parts"][0]["text"].strip()

        config["last_used"] = time.time()
        self._log_request("gemini", True, len(content))

        return self._trim_response(content)

    def _trim_response(self, text, max_length=200):
        """Trim response to max length"""
        if len(text) > max_length:
            text = text[:max_length-3] + "..."
        return text

    def _log_request(self, api_name, success, response_length):
        """Log API requests"""
        log_entry = {
            "timestamp": datetime.now(),
            "api": api_name,
            "success": success,
            "response_length": response_length
        }

        self.request_history.append(log_entry)

        if len(self.request_history) > 50:
            self.request_history.pop(0)

    def get_api_status(self):
        """Get status of all APIs"""
        status = {}
        for api_name, config in self.apis.items():
            status[api_name] = {
                "active": config["active"],
                "last_used": config["last_used"],
                "requests_count": len([r for r in self.request_history if r["api"] == api_name])
            }
        return status

# Global instance
api_manager = APIManager()