fix dockerfile and dockerfile

Dockerfile

@@ -2,12 +2,11 @@ FROM python:3.10-slim
 
 # Set environment variables
 ENV HOME=/app
+ENV PYTHONPATH=$HOME
 
 # Create app directory and set as working dir
 WORKDIR $HOME
 
-ENV PYTHONPATH=$HOME
-
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
@@ -16,15 +15,20 @@ RUN apt-get update && apt-get install -y \
     && rm -rf /var/lib/apt/lists/*
 
 COPY requirements.txt ./
-COPY src/ ./src/
 
 RUN pip3 install --no-cache-dir -r requirements.txt
 
-ENV http_proxy ""
-ENV https_proxy ""
+COPY src/ ./src/
+
+ENV http_proxy=""
+ENV https_proxy=""
 
 EXPOSE 7860
 
-HEALTHCHECK CMD curl --fail http://localhost:7860/
+# Health check for Flask app
+HEALTHCHECK CMD curl --fail http://localhost:7860/ || exit 1
+
+# Choose ONE of these based on your file structure:
 
-ENTRYPOINT ["uvicorn", "src.telegram_bot:app", "--host", "0.0.0.0", "--port", "7860"]
+# Option A: If main file is src/telegram_bot.py with Flask app
+ENTRYPOINT ["python", "src/telegram_bot.py"]

src/telegram_bot.py

@@ -1,64 +1,92 @@
 import logging
 import os
-import sys
 from typing import Any
 
 from telegram import Update
-from telegram.ext import Application, ApplicationBuilder, CommandHandler, ContextTypes
+from telegram.ext import Application, CommandHandler, ContextTypes
 from dotenv import load_dotenv
 from src.financial_news_requester import fetch_comp_financial_news
 from fastapi import FastAPI, Request
 import uvicorn
-import asyncio
-
+import httpx
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-
 load_dotenv()
 
-TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN")
-if not TELEGRAM_TOKEN:
-    logger.error("TELEGRAM_TOKEN not found! Please add it in Space Settings > Repository secrets")
-    raise ValueError("TELEGRAM_TOKEN not found in environment variables")
-SPACE_ID = os.environ.get('SPACE_ID', 'ResearchEngineering/news_sentiment_analyzer')
+# Fix 1: Use consistent token name (BOT_TOKEN is standard for HF Spaces)
+BOT_TOKEN = os.getenv("BOT_TOKEN") or os.getenv("TELEGRAM_TOKEN")
+if not BOT_TOKEN:
+    logger.error("BOT_TOKEN not found! Please add it in Space Settings > Repository secrets")
+    raise ValueError("BOT_TOKEN not found in environment variables")
+
+# Fix 2: Correct SPACE_ID format
+SPACE_ID = os.environ.get('SPACE_ID', 'researchengineering-news_sentiment_analyzer')
 PORT = int(os.environ.get('PORT', 7860))
 
+# Fix 3: Create application GLOBALLY so webhook can access it
+application = Application.builder().token(BOT_TOKEN).build()
+
 
 def format_news_for_telegram(news_json: list[dict[str, Any]]) -> str:
     message = ""
     for item in news_json:
         message += (
-            f"📰 <b>{item.get('headline')}</b>\n"
-            f"📝 {item.get('summary')}\n"
-            f"🏷️ Source: {item.get('source')}\n"
-            f"🔗 <a href=\"{item.get('url')}\">Read more</a>\n\n"
+            f"📰 <b>{item.get('headline', 'No headline')}</b>\n"
+            f"📝 {item.get('summary', 'No summary')}\n"
+            f"🏷️ Source: {item.get('source', 'Unknown')}\n"
+            f"🔗 <a href=\"{item.get('url', '#')}\">Read more</a>\n\n"
         )
-    return message
+    return message if message else "No news available."
 
 
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    await update.message.reply_text("Hello! I'm your Financial Bot.")
+    await update.message.reply_text("Hello! I'm your Financial News Bot. Use /run to get latest news.")
+
 
 async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
     """Handle /help command"""
-    await update.message.reply_text("🤖 Available commands:\n/start - Start the bot\n/help - Show this help")
+    await update.message.reply_text(
+        "🤖 Available commands:\n"
+        "/start - Start the bot\n"
+        "/help - Show this help\n"
+        "/run - Get latest financial news"
+    )
+
 
 async def run_crew(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    await update.message.reply_text("Running ...")
+    await update.message.reply_text("Fetching latest financial news...")
     try:
         feed = fetch_comp_financial_news()
-        logging.info(f"processed: {feed} news")
-        await update.message.reply_text(f"Result:\n{format_news_for_telegram(feed)}", parse_mode='HTML')
+        logger.info(f"Processed: {len(feed)} news items")
+
+        formatted_news = format_news_for_telegram(feed)
+
+        # Split message if too long (Telegram limit is 4096 characters)
+        if len(formatted_news) > 4000:
+            # Send in chunks
+            chunks = [formatted_news[i:i + 4000] for i in range(0, len(formatted_news), 4000)]
+            for chunk in chunks:
+                await update.message.reply_text(chunk, parse_mode='HTML')
+        else:
+            await update.message.reply_text(formatted_news, parse_mode='HTML')
+
     except Exception as e:
-        await update.message.reply_text(f"Error: {e}")
+        logger.error(f"Error in run_crew: {e}")
+        await update.message.reply_text(f"Sorry, there was an error fetching news: {str(e)}")
+
 
+# Add handlers to the global application
+application.add_handler(CommandHandler("start", start))
+application.add_handler(CommandHandler("help", help_command))
+application.add_handler(CommandHandler("run", run_crew))
 
-app = FastAPI()
+# Create FastAPI app
+app = FastAPI(title="Financial News Bot", description="Telegram bot for financial news")
 
 
-@app.post(f"/{TELEGRAM_TOKEN}")
+@app.post(f"/{BOT_TOKEN}")
 async def webhook(request: Request):
     """Handle incoming webhook from Telegram"""
     try:
@@ -78,27 +106,35 @@ async def webhook(request: Request):
 @app.get("/")
 async def root():
     """Health check endpoint"""
-    return {"status": "Bot is running!", "webhook_url": f"https://{SPACE_ID}.hf.space/{TELEGRAM_TOKEN}"}
+    return {
+        "status": "Financial News Bot is running!",
+        "webhook_url": f"https://{SPACE_ID}.hf.space/{BOT_TOKEN[:10]}...",
+        "space_id": SPACE_ID,
+        "available_endpoints": ["/", "/set_webhook", "/webhook_info"]
+    }
 
 
 @app.get("/set_webhook")
 async def set_webhook():
     """Manually set the webhook (call this once after deployment)"""
     try:
-        webhook_url = f"https://{SPACE_ID}.hf.space/{TELEGRAM_TOKEN}"
-
-        # Use a simple HTTP request to set webhook instead of bot.set_webhook()
-        import httpx
+        webhook_url = f"https://{SPACE_ID}.hf.space/{BOT_TOKEN}"
+        set_webhook_url = f"https://api.telegram.org/bot{BOT_TOKEN}/setWebhook"
 
-        set_webhook_url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/setWebhook"
+        logger.info(f"Setting webhook to: {webhook_url}")
 
-        async with httpx.AsyncClient() as client:
-            response = await client.post(set_webhook_url, json={"url": webhook_url})
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(set_webhook_url, json={
+                "url": webhook_url,
+                "drop_pending_updates": True
+            })
             result = response.json()
 
         if result.get("ok"):
+            logger.info("Webhook set successfully!")
             return {"status": "success", "webhook_url": webhook_url, "result": result}
         else:
+            logger.error(f"Failed to set webhook: {result}")
             return {"status": "error", "result": result}
 
     except Exception as e:
@@ -106,37 +142,33 @@ async def set_webhook():
         return {"status": "error", "message": str(e)}
 
 
+@app.get("/webhook_info")
+async def webhook_info():
+    """Get current webhook information"""
+    try:
+        info_url = f"https://api.telegram.org/bot{BOT_TOKEN}/getWebhookInfo"
 
-def func():
-    logging.basicConfig(level=logging.INFO)
-    app = ApplicationBuilder().token(TELEGRAM_TOKEN).build()
-    app.add_handler(CommandHandler("start", start))
-    app.add_handler(CommandHandler("run", run_crew))
-    app.run_polling()
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(info_url)
+            result = response.json()
 
+        return result
+    except Exception as e:
+        logger.error(f"Error getting webhook info: {e}")
+        return {"status": "error", "message": str(e)}
 
-def test_func():
-    application = Application.builder().token(TELEGRAM_TOKEN).build()
-    application.add_handler(CommandHandler("start", start))
-    PORT = int(os.environ.get('PORT', 8000))
 
-    # Run webhook (better for HF Spaces)
-    application.run_webhook(
-        listen="0.0.0.0",
-        port=PORT,
-        url_path=TELEGRAM_TOKEN,
-        webhook_url=f"https://{os.environ.get('SPACE_ID', SPACE_ID)}.hf.space/{TELEGRAM_TOKEN}"
-    )
+@app.get("/health")
+async def health():
+    """Additional health check"""
+    return {"status": "healthy", "bot_token_set": bool(BOT_TOKEN)}
 
 
 if __name__ == "__main__":
-    # Create telegram application WITHOUT initializing
-    application = Application.builder().token(TELEGRAM_TOKEN).build()
-    application.add_handler(CommandHandler("start", start))
-    application.add_handler(CommandHandler("help", help_command))
-
-    logger.info(f"Starting bot on port {PORT}")
-    logger.info(f"Webhook URL will be: https://{SPACE_ID}.hf.space/{TELEGRAM_TOKEN}")
+    logger.info(f"Starting Financial News Bot on port {PORT}")
+    logger.info(f"Bot token: {BOT_TOKEN[:10]}..." if BOT_TOKEN else "No token set")
+    logger.info(f"Space ID: {SPACE_ID}")
+    logger.info(f"Webhook URL will be: https://{SPACE_ID}.hf.space/{BOT_TOKEN[:10]}...")
     logger.info("After deployment, visit /set_webhook to configure the webhook")
 
-    uvicorn.run(app, host="0.0.0.0", port=PORT)
+    uvicorn.run(app, host="0.0.0.0", port=PORT)