Switch Telegram bot to webhook mode for HF Spaces compatibility

app/main.py

@@ -3,6 +3,7 @@ MEXC Funding Rate Report - Backend API
 
 FastAPI application for providing funding rate data and analysis.
 """
+import os
 from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -17,6 +18,7 @@ from app.api import (
     watchlist_router,
     telegram_router,
 )
+from app.services.telegram_bot import router as telegram_webhook_router
 
 # Initialize settings
 settings = get_settings()
@@ -51,6 +53,23 @@ async def scheduled_telegram_notify():
         await service.send_watchlist_notification()
 
 
+def get_webhook_base_url() -> str:
+    """Get the base URL for webhook based on environment."""
+    # Check for HF Spaces
+    space_id = os.environ.get("SPACE_ID")
+    if space_id:
+        # Format: username-spacename
+        return f"https://{space_id.replace('/', '-')}.hf.space"
+    
+    # Check for explicit WEBHOOK_URL
+    webhook_url = os.environ.get("WEBHOOK_URL")
+    if webhook_url:
+        return webhook_url
+    
+    # Local development - no webhook
+    return None
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Application lifespan manager."""
@@ -60,14 +79,14 @@ async def lifespan(app: FastAPI):
     # Initial data fetch
     from app.services import get_mexc_client
     client = get_mexc_client()
-    await client.refresh_data()  # Initial fetch on startup
+    await client.refresh_data()
     
-    # Start Telegram bot
+    # Initialize Telegram bot with webhook
     from app.services.telegram_bot import TelegramBot
-    await TelegramBot.start()
+    webhook_url = get_webhook_base_url()
+    await TelegramBot.init(webhook_base_url=webhook_url)
     
     # Setup scheduler
-    # Data refresh every 5 minutes
     scheduler.add_job(
         scheduled_data_refresh,
         'interval',
@@ -76,7 +95,6 @@ async def lifespan(app: FastAPI):
         replace_existing=True,
     )
     
-    # FR snapshot for watchlist
     scheduler.add_job(
         scheduled_fr_snapshot,
         'interval',
@@ -85,7 +103,6 @@ async def lifespan(app: FastAPI):
         replace_existing=True,
     )
     
-    # Telegram notifications
     scheduler.add_job(
         scheduled_telegram_notify,
         'interval',
@@ -101,7 +118,7 @@ async def lifespan(app: FastAPI):
     
     # Shutdown
     scheduler.shutdown()
-    await TelegramBot.stop()
+    await TelegramBot.shutdown()
     await Database.disconnect()
 
 
@@ -131,12 +148,14 @@ app.include_router(stats_router, prefix="/api/v1")
 app.include_router(alerts_router, prefix="/api/v1")
 app.include_router(watchlist_router, prefix="/api/v1")
 app.include_router(telegram_router, prefix="/api/v1")
+app.include_router(telegram_webhook_router)  # Telegram webhook at /telegram-webhook
 
 
 @app.get("/")
 async def root():
     """Health check endpoint."""
     from app.services import get_mexc_client
+    from app.services.telegram_bot import TelegramBot
     client = get_mexc_client()
     cache_age = client.get_cache_age_seconds()
     
@@ -145,7 +164,7 @@ async def root():
         "message": "MEXC FR Report API is running",
         "version": "2.0.0",
         "cache_age_seconds": cache_age,
-        "data_refresh": "every 5 minutes",
+        "telegram_webhook": TelegramBot._initialized,
     }
 
 
@@ -154,6 +173,7 @@ async def health():
     """Health check endpoint for monitoring."""
     from app.database import get_database
     from app.services import get_mexc_client
+    from app.services.telegram_bot import TelegramBot
     
     db = get_database()
     client = get_mexc_client()
@@ -163,11 +183,11 @@ async def health():
         "database": "connected" if db is not None else "disconnected",
         "mexc_cache_age": client.get_cache_age_seconds(),
         "mexc_tickers_count": len(client.get_cached_tickers()),
+        "telegram": "webhook" if TelegramBot._initialized else "disabled",
     }
 
 
 if __name__ == "__main__":
-    import os
     import uvicorn
     port = int(os.environ.get("PORT", 8000))
     uvicorn.run("app.main:app", host="0.0.0.0", port=port, reload=True)

app/services/telegram_bot.py

@@ -1,30 +1,34 @@
-"""Telegram Bot with webhook for /start command."""
-import asyncio
+"""Telegram Bot using Webhook mode for HF Spaces compatibility."""
+import os
 from telegram import Update, Bot
 from telegram.ext import Application, CommandHandler, ContextTypes
+from fastapi import APIRouter, Request, Response
 from app.config import get_settings
 
+router = APIRouter(prefix="/telegram-webhook", tags=["Telegram Webhook"])
+
 
 class TelegramBot:
     """Telegram bot with webhook handlers."""
     
-    _instance = None
     _app: Application = None
     _bot: Bot = None
-    _started = False
+    _initialized = False
+    _webhook_url: str = None
     
     @classmethod
-    async def start(cls):
-        """Start the Telegram bot (graceful - won't crash on failure)."""
+    async def init(cls, webhook_base_url: str = None):
+        """Initialize the Telegram bot with webhook."""
         settings = get_settings()
         
         if not settings.telegram_bot_token:
             print("Telegram bot: Not configured (no token)")
-            return
+            return False
         
         try:
-            cls._bot = Bot(token=settings.telegram_bot_token)
+            # Build application
             cls._app = Application.builder().token(settings.telegram_bot_token).build()
+            cls._bot = cls._app.bot
             
             # Add handlers
             cls._app.add_handler(CommandHandler("start", cls._handle_start))
@@ -33,30 +37,50 @@ class TelegramBot:
             cls._app.add_handler(CommandHandler("top", cls._handle_top))
             cls._app.add_handler(CommandHandler("watchlist", cls._handle_watchlist))
             
-            # Start polling in background
+            # Initialize (but don't start polling)
             await cls._app.initialize()
-            await cls._app.start()
-            await cls._app.updater.start_polling(drop_pending_updates=True)
             
-            cls._started = True
-            print("Telegram bot: Started with polling")
+            # Set webhook if URL provided
+            if webhook_base_url:
+                cls._webhook_url = f"{webhook_base_url}/telegram-webhook/update"
+                await cls._bot.set_webhook(url=cls._webhook_url)
+                print(f"Telegram bot: Webhook set to {cls._webhook_url}")
+            
+            cls._initialized = True
+            print("Telegram bot: Initialized in webhook mode")
+            return True
+            
         except Exception as e:
-            print(f"Telegram bot: Failed to start ({e.__class__.__name__})")
+            print(f"Telegram bot: Failed to initialize ({e.__class__.__name__}: {e})")
             cls._app = None
             cls._bot = None
-            cls._started = False
+            cls._initialized = False
+            return False
     
     @classmethod
-    async def stop(cls):
-        """Stop the Telegram bot."""
-        if cls._app and cls._started:
+    async def shutdown(cls):
+        """Shutdown the bot."""
+        if cls._app and cls._initialized:
             try:
-                await cls._app.updater.stop()
-                await cls._app.stop()
+                # Remove webhook
+                if cls._bot:
+                    await cls._bot.delete_webhook()
                 await cls._app.shutdown()
-                print("Telegram bot: Stopped")
+                print("Telegram bot: Shutdown complete")
             except Exception as e:
-                print(f"Telegram bot: Error stopping ({e})")
+                print(f"Telegram bot: Error during shutdown ({e})")
+    
+    @classmethod
+    async def process_update(cls, update_data: dict):
+        """Process incoming webhook update."""
+        if not cls._initialized or not cls._app:
+            return
+        
+        try:
+            update = Update.de_json(update_data, cls._bot)
+            await cls._app.process_update(update)
+        except Exception as e:
+            print(f"Telegram bot: Error processing update ({e})")
     
     @classmethod
     async def _handle_start(cls, update: Update, context: ContextTypes.DEFAULT_TYPE):
@@ -65,7 +89,7 @@ class TelegramBot:
         message = (
             f"🚀 <b>MEXC FR Report Bot</b>\n\n"
             f"📍 Your Chat ID: <code>{chat_id}</code>\n\n"
-            f"Copy this Chat ID and add it to your .env file:\n"
+            f"Copy this Chat ID and add it to your environment:\n"
             f"<code>TELEGRAM_CHAT_ID={chat_id}</code>\n\n"
             f"<b>Commands:</b>\n"
             f"/top - Get Top 5 FR coins\n"
@@ -104,20 +128,17 @@ class TelegramBot:
     
     @classmethod
     async def _handle_top(cls, update: Update, context: ContextTypes.DEFAULT_TYPE):
-        """Handle /top command - send top FR coins."""
+        """Handle /top command."""
         from app.services.telegram_service import get_telegram_service
         service = get_telegram_service()
-        
-        # Override chat_id for this message
         chat_id = update.effective_chat.id
         await service.send_top_fr_notification(chat_id=chat_id)
     
     @classmethod
     async def _handle_watchlist(cls, update: Update, context: ContextTypes.DEFAULT_TYPE):
-        """Handle /watchlist command - send watchlist coins."""
+        """Handle /watchlist command."""
         from app.services.telegram_service import get_telegram_service
         service = get_telegram_service()
-        
         chat_id = update.effective_chat.id
         success = await service.send_watchlist_notification(chat_id=chat_id)
         
@@ -129,6 +150,28 @@ class TelegramBot:
             )
 
 
-# Create singleton getter
-def get_telegram_bot() -> TelegramBot:
+# Webhook endpoint
+@router.post("/update")
+async def telegram_webhook(request: Request):
+    """Handle incoming Telegram webhook updates."""
+    try:
+        update_data = await request.json()
+        await TelegramBot.process_update(update_data)
+        return Response(status_code=200)
+    except Exception as e:
+        print(f"Webhook error: {e}")
+        return Response(status_code=200)  # Always return 200 to Telegram
+
+
+@router.get("/status")
+async def webhook_status():
+    """Check webhook status."""
+    return {
+        "initialized": TelegramBot._initialized,
+        "webhook_url": TelegramBot._webhook_url,
+        "mode": "webhook"
+    }
+
+
+def get_telegram_bot():
     return TelegramBot