Switch Telegram bot to webhook mode for HF Spaces

app/api/routes/telegram.py

@@ -110,3 +110,16 @@ async def record_fr_snapshot():
         "message": f"Recorded FR snapshot for {count} coins",
         "count": count
     }
+
+
+@router.post("/webhook")
+async def telegram_webhook(request: dict):
+    """
+    Webhook endpoint for Telegram bot updates.
+    Telegram will POST updates here instead of polling.
+    """
+    from app.services.telegram_bot import TelegramBot
+    
+    success = await TelegramBot.process_update(request)
+    
+    return {"ok": success}

app/main.py

@@ -18,7 +18,6 @@ from app.api import (
     watchlist_router,
     telegram_router,
 )
-from app.services.telegram_bot import router as telegram_webhook_router
 
 # Initialize settings
 settings = get_settings()
@@ -53,23 +52,6 @@ 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."""
@@ -81,10 +63,12 @@ async def lifespan(app: FastAPI):
     client = get_mexc_client()
     await client.refresh_data()
     
-    # Initialize Telegram bot with webhook
+    # Setup Telegram bot with webhook
     from app.services.telegram_bot import TelegramBot
-    webhook_url = get_webhook_base_url()
-    await TelegramBot.init(webhook_base_url=webhook_url)
+    webhook_url = os.environ.get("SPACE_HOST")
+    if webhook_url:
+        webhook_url = f"https://{webhook_url}"
+    await TelegramBot.setup(webhook_base_url=webhook_url)
     
     # Setup scheduler
     scheduler.add_job(
@@ -94,7 +78,6 @@ async def lifespan(app: FastAPI):
         id='data_refresh',
         replace_existing=True,
     )
-    
     scheduler.add_job(
         scheduled_fr_snapshot,
         'interval',
@@ -102,7 +85,6 @@ async def lifespan(app: FastAPI):
         id='fr_snapshot',
         replace_existing=True,
     )
-    
     scheduler.add_job(
         scheduled_telegram_notify,
         'interval',
@@ -148,14 +130,12 @@ 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()
     
@@ -164,7 +144,7 @@ async def root():
         "message": "MEXC FR Report API is running",
         "version": "2.0.0",
         "cache_age_seconds": cache_age,
-        "telegram_webhook": TelegramBot._initialized,
+        "data_refresh": "every 5 minutes",
     }
 
 
@@ -173,7 +153,6 @@ 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()
@@ -183,7 +162,6 @@ 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",
     }
 
 

app/services/telegram_bot.py

@@ -1,24 +1,25 @@
-"""Telegram Bot using Webhook mode for HF Spaces compatibility."""
-import os
+"""Telegram Bot with webhook mode for HF Spaces."""
+import asyncio
 from telegram import Update, Bot
 from telegram.ext import Application, CommandHandler, ContextTypes
-from fastapi import APIRouter, Request, Response
+from fastapi import Request
 from app.config import get_settings
 
-router = APIRouter(prefix="/telegram-webhook", tags=["Telegram Webhook"])
-
 
 class TelegramBot:
     """Telegram bot with webhook handlers."""
     
     _app: Application = None
     _bot: Bot = None
-    _initialized = False
+    _started = False
     _webhook_url: str = None
     
     @classmethod
-    async def init(cls, webhook_base_url: str = None):
-        """Initialize the Telegram bot with webhook."""
+    async def setup(cls, webhook_base_url: str = None):
+        """
+        Setup the Telegram bot (webhook mode).
+        Call this during app startup.
+        """
         settings = get_settings()
         
         if not settings.telegram_bot_token:
@@ -26,9 +27,8 @@ class TelegramBot:
             return False
         
         try:
-            # Build application
+            cls._bot = Bot(token=settings.telegram_bot_token)
             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))
@@ -37,30 +37,44 @@ class TelegramBot:
             cls._app.add_handler(CommandHandler("top", cls._handle_top))
             cls._app.add_handler(CommandHandler("watchlist", cls._handle_watchlist))
             
-            # Initialize (but don't start polling)
+            # Initialize app (but don't start polling)
             await cls._app.initialize()
             
             # Set webhook if URL provided
             if webhook_base_url:
-                cls._webhook_url = f"{webhook_base_url}/telegram-webhook/update"
+                cls._webhook_url = f"{webhook_base_url}/api/v1/telegram/webhook"
                 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")
+            cls._started = True
+            print("Telegram bot: Initialized successfully")
             return True
             
         except Exception as e:
-            print(f"Telegram bot: Failed to initialize ({e.__class__.__name__}: {e})")
+            print(f"Telegram bot: Failed to setup ({e.__class__.__name__}: {e})")
             cls._app = None
             cls._bot = None
-            cls._initialized = False
+            cls._started = False
+            return False
+    
+    @classmethod
+    async def process_update(cls, update_data: dict):
+        """Process incoming webhook update."""
+        if not cls._app or not cls._started:
+            return False
+        
+        try:
+            update = Update.de_json(update_data, cls._bot)
+            await cls._app.process_update(update)
+            return True
+        except Exception as e:
+            print(f"Telegram bot: Error processing update ({e})")
             return False
     
     @classmethod
     async def shutdown(cls):
         """Shutdown the bot."""
-        if cls._app and cls._initialized:
+        if cls._app and cls._started:
             try:
                 # Remove webhook
                 if cls._bot:
@@ -70,18 +84,6 @@ class TelegramBot:
             except Exception as 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):
         """Handle /start command."""
@@ -89,7 +91,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 environment:\n"
+            f"Copy this Chat ID and add it to your .env file:\n"
             f"<code>TELEGRAM_CHAT_ID={chat_id}</code>\n\n"
             f"<b>Commands:</b>\n"
             f"/top - Get Top 5 FR coins\n"
@@ -128,17 +130,19 @@ class TelegramBot:
     
     @classmethod
     async def _handle_top(cls, update: Update, context: ContextTypes.DEFAULT_TYPE):
-        """Handle /top command."""
+        """Handle /top command - send top FR coins."""
         from app.services.telegram_service import get_telegram_service
         service = get_telegram_service()
+        
         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."""
+        """Handle /watchlist command - send watchlist coins."""
         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)
         
@@ -150,28 +154,5 @@ class 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