Update app.py

app.py

@@ -5,110 +5,457 @@ import json
 import os
 from datetime import datetime, date
 import requests
+import logging
 
-app = FastAPI()
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+# Logging ayarı
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
+app = FastAPI(title="AI Chat API", version="1.0.0")
+
+# CORS ayarları
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Dosya yolları ve konfigürasyon
 DB_PATH = "users.json"
 HF_TOKEN = os.getenv("HF_TOKEN", "")
+MODEL_NAME = "mistralai/Mistral-7B-Instruct-v0.2"
+API_URL = f"https://api-inference.huggingface.co/models/{MODEL_NAME}"
+
+# Varsayılan limitler
+DAILY_LIMIT = 100
+MAX_TOKENS = 200
 
 def load_db():
+    """Kullanıcı veritabanını yükle"""
     try:
         if os.path.exists(DB_PATH):
-            with open(DB_PATH, "r") as f:
+            with open(DB_PATH, "r", encoding="utf-8") as f:
                 return json.load(f)
-    except:
+    except Exception as e:
+        logger.error(f"Veritabanı yükleme hatası: {e}")
         return {}
     return {}
 
 def save_db(data):
+    """Kullanıcı veritabanını kaydet"""
     try:
-        with open(DB_PATH, "w") as f:
-            json.dump(data, f, indent=2)
-    except:
-        pass
+        with open(DB_PATH, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        return True
+    except Exception as e:
+        logger.error(f"Veritabanı kaydetme hatası: {e}")
+        return False
 
-def get_model_response(message):
-    """Model yanıtı"""
+def get_model_response_v1(message):
+    """Model yanıtı - V1 (Daha basit format)"""
     if not HF_TOKEN:
-        return "Model hazır değil."
+        logger.warning("HF_TOKEN bulunamadı")
+        return "API token bulunamadı. Lütfen HF_TOKEN ortam değişkenini ayarlayın."
     
     try:
+        # Mistral için uygun prompt formatı
+        formatted_prompt = f"<s>[INST] {message} [/INST]"
+        
         response = requests.post(
-            "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2",
-            headers={"Authorization": f"Bearer {HF_TOKEN}"},
+            API_URL,
+            headers={
+                "Authorization": f"Bearer {HF_TOKEN}",
+                "Content-Type": "application/json"
+            },
             json={
-                "inputs": message,
-                "parameters": {"max_new_tokens": 100}
+                "inputs": formatted_prompt,
+                "parameters": {
+                    "max_new_tokens": MAX_TOKENS,
+                    "temperature": 0.7,
+                    "top_p": 0.95,
+                    "do_sample": True,
+                    "return_full_text": False
+                }
             },
             timeout=30
         )
         
+        logger.info(f"API Yanıt Kodu: {response.status_code}")
+        
         if response.status_code == 200:
             result = response.json()
+            logger.info(f"API Yanıtı: {result}")
+            
+            # Farklı response formatlarını işle
             if isinstance(result, list):
-                return result[0].get('generated_text', 'Yanıt alınamadı')
+                if len(result) > 0:
+                    if isinstance(result[0], dict):
+                        # Format 1: [{'generated_text': '...'}]
+                        if 'generated_text' in result[0]:
+                            text = result[0]['generated_text']
+                            # Prompt'u temizle
+                            if isinstance(text, str):
+                                text = text.replace(formatted_prompt, "").strip()
+                                return text
+                        
+                        # Format 2: [{'generated_text': [{'content': '...'}]}]
+                        for key in result[0]:
+                            if isinstance(result[0][key], str):
+                                text = result[0][key]
+                                text = text.replace(formatted_prompt, "").strip()
+                                return text
+            
+            # Direk string dönerse
+            if isinstance(result, str):
+                return result.replace(formatted_prompt, "").strip()
+                
+            return "Yanıt alındı ancak format beklenmiyor."
+        
+        elif response.status_code == 503:
+            logger.warning("Model yükleniyor...")
+            return "Model şu anda yükleniyor, lütfen 10-20 saniye sonra tekrar deneyin."
+        
+        elif response.status_code == 429:
+            return "Çok fazla istek gönderildi. Lütfen bir süre bekleyin."
         
-        return "Model yanıt veremedi."
+        elif response.status_code == 401:
+            return "API token geçersiz. Lütfen token'ı kontrol edin."
         
-    except:
-        return "Model hatası."
+        else:
+            logger.error(f"API Hatası: {response.status_code} - {response.text[:200]}")
+            return f"API hatası: {response.status_code}"
+        
+    except requests.exceptions.Timeout:
+        logger.error("API timeout hatası")
+        return "Model yanıt verme süresi aşıldı. Lütfen daha sonra tekrar deneyin."
+    
+    except requests.exceptions.ConnectionError:
+        logger.error("API bağlantı hatası")
+        return "API'ye bağlanılamadı. Lütfen internet bağlantınızı kontrol edin."
+    
+    except Exception as e:
+        logger.error(f"Model iletişim hatası: {str(e)}")
+        return f"Beklenmeyen hata: {str(e)}"
+
+def get_model_response_v2(message):
+    """Model yanıtı - V2 (Alternatif yaklaşım)"""
+    if not HF_TOKEN:
+        return "API token bulunamadı."
+    
+    try:
+        # Daha basit prompt formatı
+        formatted_prompt = f"Kullanıcı: {message}\nAsistan:"
+        
+        response = requests.post(
+            API_URL,
+            headers={"Authorization": f"Bearer {HF_TOKEN}"},
+            json={
+                "inputs": formatted_prompt,
+                "parameters": {
+                    "max_new_tokens": 150,
+                    "temperature": 0.8,
+                    "top_k": 50,
+                    "return_full_text": False
+                }
+            },
+            timeout=25
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            
+            # Basit format çözümleme
+            if isinstance(result, list):
+                for item in result:
+                    if isinstance(item, dict):
+                        for key, value in item.items():
+                            if isinstance(value, str):
+                                # Prompt'u temizle
+                                cleaned = value.replace(formatted_prompt, "").strip()
+                                if cleaned:
+                                    return cleaned
+                            elif isinstance(value, list):
+                                for sub_item in value:
+                                    if isinstance(sub_item, dict) and 'content' in sub_item:
+                                        return sub_item['content']
+            
+            return "Anlamlı bir yanıt alınamadı."
+        
+        return "Model geçici olarak kullanılamıyor."
+    
+    except Exception:
+        return "Bağlantı hatası oluştu."
+
+def get_model_response_v3(message):
+    """Model yanıtı - V3 (En basit)"""
+    if not HF_TOKEN:
+        return "Sistem hazır değil. Lütfen daha sonra tekrar deneyin."
+    
+    try:
+        # En basit yaklaşım
+        response = requests.post(
+            API_URL,
+            headers={"Authorization": f"Bearer {HF_TOKEN}"},
+            json={"inputs": message},
+            timeout=20
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            
+            # Çok basit parsing
+            if isinstance(result, list):
+                return str(result[0]) if result else "Boş yanıt"
+            elif isinstance(result, dict):
+                for value in result.values():
+                    if isinstance(value, str) and value.strip():
+                        return value.strip()
+            
+            return "Yanıt işlenemedi"
+        
+        return f"Hata kodu: {response.status_code}"
+    
+    except Exception:
+        return "Servis geçici olarak kullanılamıyor."
+
+def get_model_response(message):
+    """Ana model yanıt fonksiyonu - Tüm versiyonları dener"""
+    logger.info(f"Gelen mesaj: {message}")
+    
+    # Versiyonları sırayla dene
+    responses = []
+    
+    # V1'i dene
+    response_v1 = get_model_response_v1(message)
+    if response_v1 and len(response_v1) > 10 and "token" not in response_v1.lower() and "hata" not in response_v1.lower():
+        return response_v1
+    responses.append(response_v1)
+    
+    # V2'yi dene
+    response_v2 = get_model_response_v2(message)
+    if response_v2 and len(response_v2) > 10 and "token" not in response_v2.lower() and "hata" not in response_v2.lower():
+        return response_v2
+    responses.append(response_v2)
+    
+    # V3'ü dene
+    response_v3 = get_model_response_v3(message)
+    if response_v3 and len(response_v3) > 10:
+        return response_v3
+    
+    # Hiçbiri çalışmazsa en iyi yanıtı seç
+    for resp in responses:
+        if resp and len(resp) > 5:
+            return resp
+    
+    return "Üzgünüm, şu anda yanıt veremiyorum. Lütfen daha sonra tekrar deneyin."
 
 @app.get("/")
 def home():
-    return {"status": "ok"}
+    """Ana sayfa"""
+    return {
+        "app": "AI Chat API",
+        "version": "1.0.0",
+        "status": "active",
+        "endpoints": {
+            "health": "/health",
+            "chat": "/api/chat (POST)",
+            "stats": "/api/stats/{email} (GET)"
+        }
+    }
 
 @app.get("/health")
 def health():
+    """Sağlık kontrolü"""
+    token_status = "valid" if HF_TOKEN else "missing"
+    db_status = "exists" if os.path.exists(DB_PATH) else "missing"
+    
     return {
-        "status": "healthy", 
-        "model": "ready" if HF_TOKEN else "no_token",
-        "time": datetime.now().isoformat()
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "token": token_status,
+        "database": db_status,
+        "model": MODEL_NAME,
+        "daily_limit": DAILY_LIMIT
     }
 
 @app.post("/api/chat")
 async def chat(request: Request):
+    """Chat endpoint'i"""
     try:
         data = await request.json()
         email = data.get("email", "").strip().lower()
         message = data.get("message", "").strip()
         
+        logger.info(f"Chat isteği - Email: {email}, Mesaj: {message[:50]}...")
+        
+        # Validasyon
         if not email or "@" not in email:
-            return JSONResponse(400, {"error": "Email required"})
+            return JSONResponse(
+                status_code=400,
+                content={"error": "Geçerli bir email adresi giriniz."}
+            )
         
         if not message:
-            return JSONResponse(400, {"error": "Message required"})
+            return JSONResponse(
+                status_code=400,
+                content={"error": "Mesaj boş olamaz."}
+            )
+        
+        if len(message) > 1000:
+            return JSONResponse(
+                status_code=400,
+                content={"error": "Mesaj çok uzun. Maksimum 1000 karakter."}
+            )
         
+        # Veritabanı işlemleri
         db = load_db()
+        today = date.today().isoformat()
         
         if email not in db:
             db[email] = {
                 "count": 0,
                 "total": 0,
-                "last_reset": date.today().isoformat()
+                "last_reset": today,
+                "created_at": datetime.now().isoformat(),
+                "last_used": datetime.now().isoformat()
             }
         
         user = db[email]
         
-        if user["last_reset"] != date.today().isoformat():
+        # Günlük limit kontrolü
+        if user["last_reset"] != today:
             user["count"] = 0
-            user["last_reset"] = date.today().isoformat()
+            user["last_reset"] = today
         
-        if user["count"] >= 100:
-            return JSONResponse(429, {"error": "Daily limit reached"})
+        if user["count"] >= DAILY_LIMIT:
+            return JSONResponse(
+                status_code=429,
+                content={
+                    "error": "Günlük limit doldu",
+                    "limit": DAILY_LIMIT,
+                    "reset_date": today
+                }
+            )
         
-        # Model yanıtı
+        # Model yanıtını al
+        start_time = datetime.now()
         ai_response = get_model_response(message)
+        response_time = (datetime.now() - start_time).total_seconds()
         
+        logger.info(f"Yanıt süresi: {response_time:.2f}s")
+        
+        # Kullanıcı istatistiklerini güncelle
         user["count"] += 1
         user["total"] += 1
+        user["last_used"] = datetime.now().isoformat()
+        
+        # Veritabanını kaydet
         save_db(db)
         
+        # Yanıt
         return {
             "response": ai_response,
             "status": "success",
-            "remaining": 100 - user["count"]
+            "remaining": DAILY_LIMIT - user["count"],
+            "used_today": user["count"],
+            "total_used": user["total"],
+            "response_time": f"{response_time:.2f}s"
+        }
+        
+    except json.JSONDecodeError:
+        return JSONResponse(
+            status_code=400,
+            content={"error": "Geçersiz JSON formatı"}
+        )
+    
+    except Exception as e:
+        logger.error(f"Chat hatası: {str(e)}")
+        return JSONResponse(
+            status_code=500,
+            content={"error": f"Sunucu hatası: {str(e)}"}
+        )
+
+@app.get("/api/stats/{email}")
+def get_stats(email: str):
+    """Kullanıcı istatistiklerini getir"""
+    try:
+        email = email.strip().lower()
+        db = load_db()
+        
+        if email not in db:
+            return JSONResponse(
+                status_code=404,
+                content={"error": "Kullanıcı bulunamadı"}
+            )
+        
+        user = db[email]
+        today = date.today().isoformat()
+        
+        # Günlük limit sıfırlama kontrolü
+        if user["last_reset"] != today:
+            user["count"] = 0
+            user["last_reset"] = today
+            save_db(db)
+        
+        return {
+            "email": email,
+            "used_today": user["count"],
+            "remaining_today": DAILY_LIMIT - user["count"],
+            "total_used": user["total"],
+            "last_reset": user["last_reset"],
+            "last_used": user.get("last_used", "never"),
+            "created_at": user.get("created_at", "unknown")
         }
         
     except Exception as e:
-        return JSONResponse(500, {"error": str(e)})
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
+@app.get("/api/reset-test/{email}")
+def reset_test(email: str):
+    """Test için kullanıcı limitini sıfırla"""
+    try:
+        email = email.strip().lower()
+        db = load_db()
+        
+        if email in db:
+            db[email]["count"] = 0
+            db[email]["last_reset"] = date.today().isoformat()
+            save_db(db)
+            
+            return {
+                "status": "success",
+                "message": f"{email} limiti sıfırlandı"
+            }
+        else:
+            return JSONResponse(
+                status_code=404,
+                content={"error": "Kullanıcı bulunamadı"}
+            )
+            
+    except Exception as e:
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    logger.info("=" * 50)
+    logger.info("AI Chat API Başlatılıyor...")
+    logger.info(f"Model: {MODEL_NAME}")
+    logger.info(f"Token Durumu: {'Var' if HF_TOKEN else 'Yok'}")
+    logger.info(f"Günlük Limit: {DAILY_LIMIT}")
+    logger.info("=" * 50)
+    
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )