add new tg bot

.env.example

@@ -2,4 +2,7 @@ TELEGRAM_TOKEN=
 FINNHUB_API_TOKEN=
 SPACE_ID=
 GEMINI_API_TOKEN=
-OPENROUTER_API_TOKEN=
+OPENROUTER_API_TOKEN=
+GOOGLE_APPS_SCRIPT_URL=
+WEBHOOK_SECRET=
+SPECE_URL=

Dockerfile

@@ -58,7 +58,8 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
 
 # Run the application when the container starts HF
 #CMD ["uvicorn", "src.telegram_bot:app", "--host", "0.0.0.0", "--port", "7860"]
-#CMD ["python", "main.py"]
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["python", "main.py"]
+#CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+#CMD ["uvicorn", "src.tg_bot:app", "--host", "0.0.0.0", "--port", "7860"]
 # Uncomment the line below to run the application locally
 #CMD ["python", "-m", "telegram_bot"]

src/tg_bot.py

@@ -0,0 +1,321 @@
+"""
+FastAPI Telegram Bot with Google Apps Script Proxy
+
+This implementation uses Google Apps Script as a proxy to bypass
+HuggingFace's restrictions on Telegram API calls.
+"""
+
+import logging
+import os
+from typing import Optional, Dict, Any
+import httpx
+from fastapi import FastAPI, Request, HTTPException
+from pydantic import BaseModel
+import uvicorn
+import asyncio
+from contextlib import asynccontextmanager
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+# Configuration
+class Config:
+    BOT_TOKEN: str = os.getenv("BOT_TOKEN") or os.getenv("TELEGRAM_TOKEN")
+    GOOGLE_APPS_SCRIPT_URL: str = os.getenv("GOOGLE_APPS_SCRIPT_URL", "")
+    WEBHOOK_SECRET: str = os.getenv("WEBHOOK_SECRET", "your-secret-key")
+    PORT: int = int(os.getenv("PORT", 7860))
+
+    @classmethod
+    def validate(cls) -> bool:
+        """Validate required configuration"""
+        missing = []
+        if not cls.BOT_TOKEN:
+            missing.append("BOT_TOKEN")
+        if not cls.GOOGLE_APPS_SCRIPT_URL:
+            missing.append("GOOGLE_APPS_SCRIPT_URL")
+
+        if missing:
+            logger.error(f"Missing required environment variables: {missing}")
+            return False
+        return True
+
+
+# Pydantic models for request/response validation
+class TelegramUpdate(BaseModel):
+    update_id: int
+    message: Optional[Dict[str, Any]] = None
+    callback_query: Optional[Dict[str, Any]] = None
+
+
+class TelegramMessage(BaseModel):
+    message_id: int
+    from_user: Dict[str, Any] = {}
+    chat: Dict[str, Any]
+    text: Optional[str] = None
+
+
+# Telegram Bot Service
+class TelegramBotService:
+    def __init__(self):
+        self.config = Config()
+        self.http_client: Optional[httpx.AsyncClient] = None
+
+    async def initialize(self):
+        """Initialize HTTP client"""
+        self.http_client = httpx.AsyncClient(
+            timeout=httpx.Timeout(30.0),
+            limits=httpx.Limits(max_keepalive_connections=5, max_connections=10)
+        )
+        logger.info("TelegramBotService initialized")
+
+    async def cleanup(self):
+        """Cleanup resources"""
+        if self.http_client:
+            await self.http_client.aclose()
+        logger.info("TelegramBotService cleaned up")
+
+    async def send_message_via_proxy(
+            self,
+            chat_id: int,
+            text: str,
+            parse_mode: str = "HTML"
+    ) -> Dict[str, Any]:
+        """
+        Send message to Telegram via Google Apps Script proxy
+
+        Args:
+            chat_id: Telegram chat ID
+            text: Message text
+            parse_mode: Message parse mode (HTML, Markdown, etc.)
+
+        Returns:
+            Response from Telegram API
+        """
+        if not self.http_client:
+            raise RuntimeError("HTTP client not initialized")
+
+        payload = {
+            "method": "sendMessage",
+            "bot_token": self.config.BOT_TOKEN,
+            "chat_id": chat_id,
+            "text": text,
+            "parse_mode": parse_mode
+        }
+
+        try:
+            logger.info(f"Sending message to chat {chat_id} via proxy")
+            response = await self.http_client.post(
+                self.config.GOOGLE_APPS_SCRIPT_URL,
+                json=payload,
+                headers={"Content-Type": "application/json"}
+            )
+            response.raise_for_status()
+
+            result = response.json()
+            logger.info(f"Message sent successfully: {result.get('ok', False)}")
+            return result
+
+        except httpx.RequestError as e:
+            logger.error(f"HTTP request failed: {e}")
+            raise HTTPException(status_code=500, detail="Failed to send message")
+        except Exception as e:
+            logger.error(f"Unexpected error: {e}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    async def process_update(self, update: TelegramUpdate) -> None:
+        """Process incoming Telegram update"""
+        try:
+            if not update.message:
+                logger.debug("No message in update, skipping")
+                return
+
+            message = update.message
+            chat_id = message.get("chat", {}).get("id")
+            text = message.get("text", "").strip()
+            user_name = message.get("from", {}).get("first_name", "User")
+
+            if not chat_id:
+                logger.warning("No chat ID found in message")
+                return
+
+            logger.info(f"Processing message: '{text}' from user: {user_name}")
+
+            # Command handling
+            if text.startswith("/"):
+                await self._handle_command(chat_id, text, user_name)
+            else:
+                await self._handle_regular_message(chat_id, text, user_name)
+
+        except Exception as e:
+            logger.error(f"Error processing update: {e}")
+            if update.message and update.message.get("chat", {}).get("id"):
+                await self.send_message_via_proxy(
+                    update.message["chat"]["id"],
+                    "Sorry, something went wrong. Please try again later."
+                )
+
+    async def _handle_command(self, chat_id: int, command: str, user_name: str) -> None:
+        """Handle bot commands"""
+        command = command.lower().strip()
+
+        if command in ["/start", "/hello"]:
+            response = f"👋 Hello, {user_name}! Welcome to the Financial News Bot!\n\n"
+            response += "Available commands:\n"
+            response += "/hello - Say hello\n"
+            response += "/help - Show help\n"
+            response += "/status - Check bot status"
+
+        elif command == "/help":
+            response = "🤖 <b>Financial News Bot Help</b>\n\n"
+            response += "<b>Commands:</b>\n"
+            response += "/start or /hello - Get started\n"
+            response += "/help - Show this help message\n"
+            response += "/status - Check bot status\n\n"
+            response += "<b>About:</b>\n"
+            response += "This bot provides financial news and sentiment analysis."
+
+        elif command == "/status":
+            response = "✅ <b>Bot Status: Online</b>\n\n"
+            response += "🔧 System: Running on HuggingFace Spaces\n"
+            response += "🌐 Proxy: Google Apps Script\n"
+            response += "📊 Status: All systems operational"
+
+        else:
+            response = f"❓ Unknown command: {command}\n\n"
+            response += "Type /help to see available commands."
+
+        await self.send_message_via_proxy(chat_id, response)
+
+    async def _handle_regular_message(self, chat_id: int, text: str, user_name: str) -> None:
+        """Handle regular (non-command) messages"""
+        response = f"Hello {user_name}! 👋\n\n"
+        response += f"You said: <i>\"{text}\"</i>\n\n"
+        response += "I'm a financial news bot. Try these commands:\n"
+        response += "/hello - Get started\n"
+        response += "/help - Show help\n"
+        response += "/status - Check status"
+
+        await self.send_message_via_proxy(chat_id, response)
+
+
+# Global bot service instance
+bot_service = TelegramBotService()
+
+
+# FastAPI lifespan management
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Manage application lifespan"""
+    # Startup
+    logger.info("Starting up application...")
+
+    if not Config.validate():
+        raise RuntimeError("Invalid configuration")
+
+    await bot_service.initialize()
+    logger.info("Application startup complete")
+
+    yield
+
+    # Shutdown
+    logger.info("Shutting down application...")
+    await bot_service.cleanup()
+    logger.info("Application shutdown complete")
+
+
+# FastAPI app
+app = FastAPI(
+    title="Financial News Telegram Bot",
+    description="A Telegram bot for financial news with Google Apps Script proxy",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+
+@app.get("/")
+async def root():
+    """Root endpoint for health checks"""
+    return {
+        "status": "running",
+        "message": "Financial News Telegram Bot",
+        "version": "1.0.0",
+        "bot_configured": bool(Config.BOT_TOKEN),
+        "proxy_configured": bool(Config.GOOGLE_APPS_SCRIPT_URL)
+    }
+
+
+@app.get("/health")
+async def health_check():
+    """Detailed health check"""
+    return {
+        "status": "healthy",
+        "timestamp": "2025-01-01T00:00:00Z",
+        "services": {
+            "bot": "online",
+            "proxy": "configured" if Config.GOOGLE_APPS_SCRIPT_URL else "not_configured"
+        }
+    }
+
+
+@app.post(f"/webhook/{Config.WEBHOOK_SECRET}")
+async def webhook(request: Request):
+    """
+    Webhook endpoint for Telegram updates
+    URL: https://your-space.hf.space/webhook/{WEBHOOK_SECRET}
+    """
+    try:
+        json_data = await request.json()
+        logger.debug(f"Received webhook data: {json_data}")
+
+        # Validate update structure
+        update = TelegramUpdate(**json_data)
+
+        # Process update asynchronously
+        asyncio.create_task(bot_service.process_update(update))
+
+        return {"ok": True}
+
+    except Exception as e:
+        logger.error(f"Webhook error: {e}")
+        raise HTTPException(status_code=400, detail="Invalid update format")
+
+
+@app.get("/webhook_info")
+async def webhook_info():
+    """Get webhook configuration info"""
+    return {
+        "webhook_url": f"https://your-space-id.hf.space/webhook/{Config.WEBHOOK_SECRET}",
+        "instructions": [
+            "1. Deploy this app to HuggingFace Spaces",
+            "2. Set up Google Apps Script proxy",
+            "3. Set webhook URL using Telegram Bot API",
+            "4. Test with /hello command"
+        ]
+    }
+
+
+@app.post("/test_message")
+async def test_message(chat_id: int, message: str = "Hello World!"):
+    """Test endpoint to send a message (for debugging)"""
+    try:
+        result = await bot_service.send_message_via_proxy(chat_id, message)
+        return {"success": True, "result": result}
+    except Exception as e:
+        logger.error(f"Test message failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# Development server
+if __name__ == "__main__":
+    logger.info(f"Starting Financial News Bot on port {Config.PORT}")
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=Config.PORT,
+        log_level="info"
+    )