Update app.py

app.py

@@ -1,7 +1,9 @@
 import collections
 import collections.abc
-# Monkeypatch for pySmartDL compatibility with Python 3.10+
-collections.Iterable = collections.abc.Iterable
+
+# ─── Monkeypatch: pySmartDL Python 3.10+ uyumluluğu ───
+if not hasattr(collections, "Iterable"):
+    collections.Iterable = collections.abc.Iterable
 
 import os
 import json
@@ -9,198 +11,354 @@ import logging
 import tempfile
 import asyncio
 import threading
+import signal
+import sys
+import time
 from http.server import HTTPServer, BaseHTTPRequestHandler
 from datetime import datetime, timedelta
+
 from pySmartDL import SmartDL
 from pydrive2.auth import GoogleAuth
 from pydrive2.drive import GoogleDrive
 from oauth2client.service_account import ServiceAccountCredentials
+
 from telegram import Update
-from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, filters, ContextTypes
+from telegram.ext import (
+    ApplicationBuilder,
+    CommandHandler,
+    MessageHandler,
+    filters,
+    ContextTypes,
+)
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
-# Logging setup
+# ──────────────────────────────────────────────
+#  LOGGING
+# ──────────────────────────────────────────────
 logging.basicConfig(
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    level=logging.INFO
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    level=logging.INFO,
 )
 logger = logging.getLogger(__name__)
 
-# Environment Variables
+# ──────────────────────────────────────────────
+#  ENVIRONMENT VARIABLES
+# ──────────────────────────────────────────────
 BOT_TOKEN = os.getenv("BOT_TOKEN")
 GDRIVE_SERVICE_ACCOUNT_JSON = os.getenv("GDRIVE_SERVICE_ACCOUNT_JSON")
 GDRIVE_FOLDER_ID = os.getenv("GDRIVE_FOLDER_ID")
 AUTHORIZED_USER_ID = os.getenv("AUTHORIZED_USER_ID")
 
 if AUTHORIZED_USER_ID:
-    AUTHORIZED_USER_ID = int(AUTHORIZED_USER_ID)
-
-# Global Drive Client variable and processing lock
+    try:
+        AUTHORIZED_USER_ID = int(AUTHORIZED_USER_ID)
+    except ValueError:
+        logger.error("AUTHORIZED_USER_ID geçerli bir sayı değil!")
+        AUTHORIZED_USER_ID = None
+
+# ──────────────────────────────────────────────
+#  GLOBAL STATE
+# ──────────────────────────────────────────────
 drive_client = None
-processing_lock = asyncio.Lock()
+processing_lock = None          # event loop varken oluşturulacak
+scheduler = None                # event loop varken başlatılacak
+health_server_ready = False     # health check hazır mı?
+
+
+# ══════════════════════════════════════════════
+#  HEALTH CHECK SERVER  (ayrı thread)
+# ══════════════════════════════════════════════
+class HealthCheckHandler(BaseHTTPRequestHandler):
+    """HuggingFace Spaces bu endpoint'e bakarak 'Running' durumuna geçirir."""
+
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header("Content-Type", "text/plain")
+        self.end_headers()
+        self.wfile.write(b"OK - Bot is running!")
+
+    def do_HEAD(self):
+        self.send_response(200)
+        self.send_header("Content-Type", "text/plain")
+        self.end_headers()
+
+    # Logları sustur (her 30 sn health check loglamasın)
+    def log_message(self, format, *args):
+        return
+
+
+def run_health_check_server():
+    """Port 7860'da basit HTTP sunucusu başlatır."""
+    global health_server_ready
+
+    port = int(os.environ.get("PORT", 7860))
+    server = HTTPServer(("0.0.0.0", port), HealthCheckHandler)
+    health_server_ready = True
+    logger.info(f"✅ Health-check sunucusu 0.0.0.0:{port} üzerinde çalışıyor")
+    server.serve_forever()
 
-# Google Drive Authentication
+
+# ══════════════════════════════════════════════
+#  GOOGLE DRIVE
+# ══════════════════════════════════════════════
 def get_gdrive_client():
     global drive_client
+
     if not GDRIVE_SERVICE_ACCOUNT_JSON:
-        logger.error("GDRIVE_SERVICE_ACCOUNT_JSON not found in environment variables.")
+        logger.error("GDRIVE_SERVICE_ACCOUNT_JSON ortam değişkeni bulunamadı.")
         return None
 
     try:
-        # Save JSON to a temporary file
-        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.json') as temp_json:
-            temp_json.write(GDRIVE_SERVICE_ACCOUNT_JSON)
-            temp_json_path = temp_json.name
-
-        scope = ['https://www.googleapis.com/auth/drive']
+        # JSON'ı geçici dosyaya yaz
+        with tempfile.NamedTemporaryFile(
+            mode="w", delete=False, suffix=".json"
+        ) as tmp:
+            tmp.write(GDRIVE_SERVICE_ACCOUNT_JSON)
+            tmp_path = tmp.name
+
+        scope = ["https://www.googleapis.com/auth/drive"]
         gauth = GoogleAuth()
-        gauth.auth_method = 'service'
-        gauth.credentials = ServiceAccountCredentials.from_json_keyfile_name(temp_json_path, scope)
+        gauth.auth_method = "service"
+        gauth.credentials = ServiceAccountCredentials.from_json_keyfile_name(
+            tmp_path, scope
+        )
 
         drive_client = GoogleDrive(gauth)
+        os.unlink(tmp_path)
 
-        # Clean up the temporary file after initializing
-        os.unlink(temp_json_path)
+        logger.info("✅ Google Drive bağlantısı başarılı.")
         return drive_client
+
     except Exception as e:
-        logger.error(f"Error authenticating with Google Drive: {e}")
+        logger.error(f"Google Drive kimlik doğrulama hatası: {e}")
         return None
 
-# Scheduler for automatic deletion
-scheduler = AsyncIOScheduler()
-scheduler.start()
 
-async def delete_from_drive(file_id):
+# ══════════════════════════════════════════════
+#  SCHEDULER – OTOMATİK SİLME
+# ══════════════════════════════════════════════
+async def delete_from_drive(file_id: str):
+    """2 saat sonra çağrılır, dosyayı Drive'dan siler."""
     try:
         global drive_client
         if not drive_client:
             drive_client = await asyncio.to_thread(get_gdrive_client)
 
         if drive_client:
-            file = await asyncio.to_thread(drive_client.CreateFile, {'id': file_id})
-            await asyncio.to_thread(file.Delete)
-            logger.info(f"File {file_id} deleted successfully after 2 hours.")
+            gfile = await asyncio.to_thread(
+                drive_client.CreateFile, {"id": file_id}
+            )
+            await asyncio.to_thread(gfile.Delete)
+            logger.info(f"🗑  Dosya {file_id} başarıyla silindi (2 saat doldu).")
     except Exception as e:
-        logger.error(f"Error deleting file {file_id}: {e}")
+        logger.error(f"Dosya silme hatası ({file_id}): {e}")
 
-async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    if not AUTHORIZED_USER_ID or update.effective_user.id != AUTHORIZED_USER_ID:
-        return
-    await update.message.reply_text("Merhaba! Bana bir direkt indirme linki gönder, senin için Google Drive'a yükleyeyim.")
 
-def download_file(url, dest):
-    obj = SmartDL(url, dest, progress_bar=False, timeout=30)
+# ══════════════════════════════════════════════
+#  DOWNLOAD & UPLOAD HELPERS
+# ══════════════════════════════════════════════
+def download_file(url: str, dest_dir: str) -> SmartDL:
+    obj = SmartDL(url, dest_dir, progress_bar=False, timeout=120)
     obj.start()
     return obj
 
-def upload_file(file_path, file_name):
+
+def upload_file(file_path: str, file_name: str):
     global drive_client
     if not drive_client:
         drive_client = get_gdrive_client()
+    if not drive_client:
+        raise RuntimeError("Google Drive istemcisi başlatılamadı!")
 
-    metadata = {'title': file_name}
+    metadata = {"title": file_name}
     if GDRIVE_FOLDER_ID:
-        metadata['parents'] = [{'id': GDRIVE_FOLDER_ID}]
+        metadata["parents"] = [{"id": GDRIVE_FOLDER_ID}]
 
     gfile = drive_client.CreateFile(metadata)
     gfile.SetContentFile(file_path)
     gfile.Upload()
     return gfile
 
+
+# ══════════════════════════════════════════════
+#  TELEGRAM HANDLERS
+# ══════════════════════════════════════════════
+async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    if AUTHORIZED_USER_ID and update.effective_user.id != AUTHORIZED_USER_ID:
+        return
+    await update.message.reply_text(
+        "Merhaba! Bana bir direkt indirme linki gönder, "
+        "senin için Google Drive'a yükleyeyim. 🚀"
+    )
+
+
 async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    if not AUTHORIZED_USER_ID or update.effective_user.id != AUTHORIZED_USER_ID:
-        logger.warning(f"Unauthorized access attempt by user {update.effective_user.id}")
+    global processing_lock, scheduler
+
+    # Yetki kontrolü
+    if AUTHORIZED_USER_ID and update.effective_user.id != AUTHORIZED_USER_ID:
+        logger.warning(
+            f"Yetkisiz erişim denemesi: user_id={update.effective_user.id}"
+        )
         return
 
-    url = update.message.text
+    url = update.message.text.strip()
     if not url.startswith(("http://", "https://")):
-        await update.message.reply_text("Geçersiz link. Lütfen geçerli bir HTTP veya HTTPS linki gönder.")
+        await update.message.reply_text(
+            "⛔ Geçersiz link. Lütfen geçerli bir HTTP/HTTPS linki gönder."
+        )
         return
 
+    # Lock: aynı anda tek dosya işlensin
     async with processing_lock:
-        status_message = await update.message.reply_text("⏳ İşlem sıraya alındı ve başlatılıyor...")
+        status_msg = await update.message.reply_text(
+            "⏳ İşlem sıraya alındı, başlatılıyor..."
+        )
 
+        file_path = None
         try:
-            # Download to current directory instead of /tmp for HF Spaces compatibility with large files
-            dest = os.getcwd()
-            await status_message.edit_text("📥 Dosya sunucuya indiriliyor...")
+            # ── İndirme ──
+            dest = os.path.join(os.getcwd(), "downloads")
+            os.makedirs(dest, exist_ok=True)
 
+            await status_msg.edit_text("📥 Dosya sunucuya indiriliyor...")
             obj = await asyncio.to_thread(download_file, url, dest)
 
-            if not obj.is_successful():
-                await status_message.edit_text("❌ İndirme başarısız oldu. Linkin doğruluğunu kontrol edin.")
+            if not obj.isSuccessful():
+                await status_msg.edit_text(
+                    "❌ İndirme başarısız oldu. Linkin geçerliliğini kontrol edin."
+                )
                 return
 
             file_path = obj.get_dest()
             file_name = os.path.basename(file_path)
-
-            # Size check (Approx 5GB)
             file_size = os.path.getsize(file_path)
-            if file_size > 5 * 1024 * 1024 * 1024:
-                await status_message.edit_text(f"⚠️ Dosya çok büyük ({file_size / (1024**3):.2f} GB). Maksimum limit 5GB.")
+
+            # 5 GB sınır
+            max_size = 5 * 1024 * 1024 * 1024
+            if file_size > max_size:
+                await status_msg.edit_text(
+                    f"⚠️ Dosya çok büyük ({file_size / (1024**3):.2f} GB). "
+                    f"Maksimum 5 GB desteklenir."
+                )
                 os.remove(file_path)
+                file_path = None
                 return
 
-            await status_message.edit_text(f"✅ İndirme tamamlandı: `{file_name}`\n📤 Google Drive'a yükleniyor...", parse_mode='Markdown')
+            size_str = (
+                f"{file_size / (1024**2):.1f} MB"
+                if file_size > 1024 * 1024
+                else f"{file_size / 1024:.1f} KB"
+            )
+
+            await status_msg.edit_text(
+                f"✅ İndirme tamamlandı: `{file_name}` ({size_str})\n"
+                f"📤 Google Drive'a yükleniyor...",
+                parse_mode="Markdown",
+            )
 
-            # Upload to Google Drive
+            # ── Yükleme ──
             gfile = await asyncio.to_thread(upload_file, file_path, file_name)
 
-            file_id = gfile['id']
-            drive_link = gfile['alternateLink']
+            file_id = gfile["id"]
+            drive_link = gfile.get(
+                "alternateLink",
+                f"https://drive.google.com/file/d/{file_id}/view",
+            )
 
-            await status_message.edit_text(
+            await status_msg.edit_text(
                 f"🚀 Yükleme başarılı!\n\n"
                 f"📁 Dosya: `{file_name}`\n"
+                f"📦 Boyut: {size_str}\n"
                 f"🔗 Link: {drive_link}\n\n"
-                f"⏱ Bu dosya 2 saat sonra otomatik olarak silinecektir.",
-                parse_mode='Markdown'
+                f"⏱ Bu dosya **2 saat** sonra otomatik olarak silinecektir.",
+                parse_mode="Markdown",
             )
 
-            # Clean up local file
-            if os.path.exists(file_path):
+            # Lokal dosyayı temizle
+            if file_path and os.path.exists(file_path):
                 os.remove(file_path)
+                file_path = None
 
-            # Schedule deletion
+            # 2 saat sonra sil
             run_date = datetime.now() + timedelta(hours=2)
-            scheduler.add_job(delete_from_drive, 'date', run_date=run_date, args=[file_id])
+            scheduler.add_job(
+                delete_from_drive, "date", run_date=run_date, args=[file_id]
+            )
 
         except Exception as e:
-            logger.error(f"Error during processing: {e}")
-            await update.message.reply_text(f"❌ Bir hata oluştu: {str(e)}")
-
-# Simple health check server for Hugging Face Spaces
-class HealthCheckHandler(BaseHTTPRequestHandler):
-    def do_GET(self):
-        self.send_response(200)
-        self.end_headers()
-        self.wfile.write(b"Bot is running!")
-
-def run_health_check_server():
-    port = int(os.environ.get("PORT", 7860))
-    server_address = ('', port)
-    httpd = HTTPServer(server_address, HealthCheckHandler)
-    logger.info(f"Starting health check server on port {port}...")
-    httpd.serve_forever()
-
+            logger.error(f"İşlem hatası: {e}", exc_info=True)
+            try:
+                await status_msg.edit_text(f"❌ Bir hata oluştu:\n`{e}`", parse_mode="Markdown")
+            except Exception:
+                pass
+
+        finally:
+            # Hata olsa bile lokal dosyayı temizle
+            if file_path and os.path.exists(file_path):
+                try:
+                    os.remove(file_path)
+                except OSError:
+                    pass
+
+
+# ══════════════════════════════════════════════
+#  MAIN
+# ══════════════════════════════════════════════
 def main():
-    if not BOT_TOKEN:
-        logger.error("BOT_TOKEN not found!")
-        return
+    global processing_lock, scheduler
 
-    # Start health check server in a separate thread
-    threading.Thread(target=run_health_check_server, daemon=True).start()
-
-    # Initialize Drive Client
+    if not BOT_TOKEN:
+        logger.error("❌ BOT_TOKEN ortam değişkeni bulunamadı! Çıkılıyor.")
+        sys.exit(1)
+
+    # ── 1) Health-check sunucusunu HEMEN başlat ──
+    #    HuggingFace bunu görünce "Running" yapar
+    health_thread = threading.Thread(target=run_health_check_server, daemon=True)
+    health_thread.start()
+
+    # Health check'in gerçekten bind olmasını bekle
+    for _ in range(50):
+        if health_server_ready:
+            break
+        time.sleep(0.1)
+    logger.info("Health-check sunucusu hazır.")
+
+    # ── 2) Google Drive istemcisini başlat ──
     get_gdrive_client()
 
-    application = ApplicationBuilder().token(BOT_TOKEN).build()
-
-    application.add_handler(CommandHandler("start", start))
-    application.add_handler(MessageHandler(filters.TEXT & (~filters.COMMAND), handle_message))
-
-    logger.info("Bot started...")
-    application.run_polling()
-
-if __name__ == '__main__':
+    # ── 3) Telegram Application'ı oluştur ──
+    application = (
+        ApplicationBuilder()
+        .token(BOT_TOKEN)
+        .connect_timeout(30)
+        .read_timeout(30)
+        .write_timeout(30)
+        .build()
+    )
+
+    application.add_handler(CommandHandler("start", cmd_start))
+    application.add_handler(
+        MessageHandler(filters.TEXT & (~filters.COMMAND), handle_message)
+    )
+
+    # ── 4) Post-init: event loop var, şimdi lock ve scheduler başlat ──
+    async def post_init(app):
+        global processing_lock, scheduler
+        processing_lock = asyncio.Lock()
+        scheduler = AsyncIOScheduler()
+        scheduler.start()
+        logger.info("✅ Scheduler ve processing lock başlatıldı.")
+
+    application.post_init = post_init
+
+    # ── 5) Bot'u çalıştır ──
+    logger.info("🤖 Bot başlatılıyor (polling)...")
+    application.run_polling(
+        allowed_updates=Update.ALL_TYPES,
+        drop_pending_updates=True,
+    )
+
+
+if __name__ == "__main__":
     main()