tg bot refactoring

.env.example

@@ -5,4 +5,4 @@ GEMINI_API_TOKEN=
 OPENROUTER_API_TOKEN=
 GOOGLE_APPS_SCRIPT_URL=
 WEBHOOK_SECRET=
-SPECE_URL=
+SPACE_URL=

main.py

@@ -1,23 +1,3 @@
-'''
-from src.telegram_bot import main as telegram_bot
-
-
-if __name__ == "__main__":
-    telegram_bot()
-'''
-
-'''
-from fastapi import FastAPI
-import uvicorn
-
-app = FastAPI()
-
-@app.get("/")
-def read_root():
-    return {"Hello": "World"}
-'''
-
-
 from src.tg_bot import main as tgbot
 
 

src/api/finnhub/financial_news_requester.py

@@ -1,14 +1,13 @@
-import os
 import logging
 from typing import Any
 
 from dotenv import load_dotenv
 import finnhub
 
+from src.telegram_bot.config import Config
 
-load_dotenv()
 
-api_key = os.getenv('FINNHUB_API_TOKEN')
+load_dotenv()
 
 
 def fetch_comp_financial_news(ticker: str = 'NVDA', date_from = "2025-07-31", date_to = "2025-08-01") -> list[dict[str, Any]] | None:
@@ -16,7 +15,7 @@ def fetch_comp_financial_news(ticker: str = 'NVDA', date_from = "2025-07-31", da
     Fetch financial news using Finnhub API.
     """
     try:
-        finnhub_client = finnhub.Client(api_key=api_key)
+        finnhub_client = finnhub.Client(api_key=Config.FINNHUB_API_KEY)
         news_feed = finnhub_client.company_news(ticker, _from=date_from, to=date_to)
         if not news_feed:
             logging.warning(f"No news found for ticker {ticker}")

src/telegram_bot/config.py

@@ -0,0 +1,27 @@
+import os
+
+from src.telegram_bot.logger import main_logger
+
+
+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", "secret-key")
+    SPACE_ID = os.environ.get('SPACE_ID', '')
+    SPACE_URL = os.environ.get('SPACE_URL', '')
+    PORT: int = int(os.getenv("PORT", 7860))
+    FINNHUB_API_KEY = os.getenv('FINNHUB_API_TOKEN')
+
+    @classmethod
+    def validate(cls) -> bool:
+        """Validate required configuration"""
+        missing = []
+        for var in dir(cls):
+            if var.isupper():
+                value = getattr(cls, var)
+                if value in (None, "", []):
+                    missing.append(var)
+        if missing:
+            main_logger.error(f"Missing required environment variables: {missing}")
+            return False
+        return True

src/telegram_bot/logger.py

@@ -0,0 +1,43 @@
+import logging
+import sys
+from pathlib import Path
+
+
+def setup_logger(name: str = None, level: str = "INFO", log_file: str = None) -> logging.Logger:
+    """
+    Set up logger with consistent configuration across the application.
+
+    Args:
+        name: Logger name (defaults to root logger)
+        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_file: Optional file path for logging to file
+
+    Returns:
+        Configured logger instance
+    """
+    logger = logging.getLogger(name)
+    # Prevent adding multiple handlers if logger already configured
+    if logger.handlers:
+        return logger
+    logger.setLevel(getattr(logging, level.upper()))
+    # Create formatter
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    # File handler (optional)
+    if log_file:
+        # Create log directory if it doesn't exist
+        Path(log_file).parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    return logger
+
+
+# Initialize the main application logger
+main_logger = setup_logger("telegram-bot", level="INFO", log_file=None)

src/{telegram_bot.py → telegram_bot/telegram_bot.py}

@@ -1,3 +1,7 @@
+'''
+this module should be deleted in the future
+'''
+
 import logging
 import os
 from typing import Any

src/telegram_bot/telegram_bot_service.py

@@ -0,0 +1,190 @@
+from typing import Any
+
+import httpx
+from fastapi import HTTPException
+
+from src.telegram_bot.logger import main_logger
+from src.telegram_bot.config import Config
+from src.telegram_bot.tg_models import TelegramUpdate
+from src.api.finnhub.financial_news_requester import fetch_comp_financial_news
+
+
+class TelegramBotService:
+    def __init__(self):
+        self.config = Config()
+        self.http_client: httpx.AsyncClient | None = 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)
+        )
+        main_logger.info("TelegramBotService initialized")
+
+    async def cleanup(self):
+        """Cleanup resources"""
+        if self.http_client:
+            await self.http_client.aclose()
+        main_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:
+            main_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()
+            main_logger.info(f"Message sent successfully: {result.get('ok', False)}")
+            return result
+
+        except httpx.RequestError as e:
+            main_logger.error(f"HTTP request failed: {e}")
+            raise HTTPException(status_code=500, detail="Failed to send message")
+        except Exception as e:
+            main_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:
+                main_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:
+                main_logger.warning("No chat ID found in message")
+                return
+
+            main_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:
+            main_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"
+
+        elif command == "/run":
+            await self.news_feed_analysing(chat_id, command, user_name)
+            return
+
+        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)
+
+    def _format_news_for_telegram(self, news_json: list[dict[str, Any]]) -> str:
+        message = ""
+        for item in news_json:
+            message += (
+                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 if message else "No news available."
+
+    async def news_feed_analysing(self, chat_id: int, text: str, user_name: str) -> None:
+        await self.send_message_via_proxy(chat_id, "Fetching latest financial news...")
+        try:
+            feed = fetch_comp_financial_news()
+            main_logger.info(f"Processed: {len(feed)} news items")
+            formatted_news = self._format_news_for_telegram(feed)
+            # Split message if too long (Telegram limit is 4096 characters)
+            if len(formatted_news) > 4000:
+                items = formatted_news.split('\n\n')
+                chunk = ""
+                for item in items:
+                    if len(chunk) + len(item) + 2 > 4000:
+                        await self.send_message_via_proxy(chat_id, chunk)
+                        chunk = ""
+                    chunk += item + "\n\n"
+                if chunk:
+                    await self.send_message_via_proxy(chat_id, chunk)
+            else:
+                await self.send_message_via_proxy(chat_id, formatted_news)
+        except Exception as e:
+            main_logger.error(f"Error in run_crew: {e}")
+            await self.send_message_via_proxy(chat_id, f"Sorry, there was an error fetching news: {str(e)}")

src/telegram_bot/tg_models.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class TelegramUpdate(BaseModel):
+    update_id: int
+    message: dict[str, Any] | None = None
+    callback_query: dict[str, Any] | None = None
+
+
+class TelegramMessage(BaseModel):
+    message_id: int
+    from_user: dict[str, Any] = {}
+    chat: dict[str, Any]
+    text: str | None = None

src/tg_bot.py

@@ -5,9 +5,6 @@ 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
@@ -15,192 +12,10 @@ 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)
+from src.telegram_bot.config import Config
+from src.telegram_bot.logger import main_logger as logger
+from src.telegram_bot.tg_models import TelegramUpdate
+from src.telegram_bot.telegram_bot_service import TelegramBotService
 
 
 # Global bot service instance
@@ -333,4 +148,4 @@ if __name__ == "__main__":
         host="0.0.0.0",
         port=Config.PORT,
         log_level="info"
-    )
+    )