add Finnhub News Sentiment Analysis Module

Dockerfile

@@ -58,6 +58,6 @@ 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 ["python", "main.py"]
 # Uncomment the line below to run the application locally
-#CMD ["python", "-m", "telegram_bot"]
+CMD ["python", "-m", "telegram_bot"]

src/{financial_news_requester.py → api/financial_news_requester.py}

@@ -18,6 +18,9 @@ def fetch_comp_financial_news(ticker: str = 'NVDA', date_from = "2025-07-31", da
     try:
         finnhub_client = finnhub.Client(api_key=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}")
+            return None
         logging.info(f'got total amount of news: {len(news_feed)} for ticker: {ticker}')
         return news_feed
     except Exception as e:

src/core/news_analysis/data/financial_lexicon.json

@@ -0,0 +1,59 @@
+{
+  "positive": {
+    "profit": 3, "profits": 3, "profitable": 3, "earnings": 2, "revenue": 2,
+    "growth": 2, "growing": 2, "grew": 2, "increase": 2, "increased": 2,
+    "rising": 2, "rise": 2, "surge": 3, "surged": 3, "surging": 3,
+    "rally": 2, "rallied": 2, "rallying": 2, "gain": 2, "gains": 2,
+    "gained": 2, "outperform": 2, "outperformed": 2, "outperforming": 2,
+    "beat": 2, "beats": 2, "exceeded": 2, "exceeds": 2, "exceed": 2,
+    "strong": 2, "stronger": 2, "strength": 2, "robust": 2, "solid": 2,
+    "positive": 2, "optimistic": 2, "bullish": 2, "bull": 2,
+    "breakthrough": 3, "innovation": 2, "innovative": 2, "launch": 1,
+    "launched": 1, "expansion": 2, "expand": 2, "expanding": 2,
+    "acquisition": 1, "merger": 1, "deal": 1, "partnership": 1,
+    "agreement": 1, "contract": 1, "approve": 1, "approved": 1,
+    "upgrade": 2, "upgraded": 2, "buy": 1, "recommend": 1,
+    "target": 1, "opportunity": 1, "opportunities": 1,
+    "record": 2, "milestone": 2, "achievement": 2, "success": 2,
+    "successful": 2, "win": 2, "winner": 2, "winning": 2,
+    "excellent": 3, "outstanding": 3, "exceptional": 3, "remarkable": 3,
+    "impressive": 2, "good": 1, "great": 2, "better": 1, "best": 2,
+    "high": 1, "higher": 1, "up": 1, "upward": 1, "improve": 2,
+    "improved": 2, "improvement": 2, "recovery": 2, "recovering": 2,
+    "momentum": 1, "confident": 2, "confidence": 2, "stable": 1,
+    "stability": 1, "steady": 1, "secure": 1, "attractive": 1
+  },
+  "negative": {
+    "loss": -2, "losses": -2, "losing": -2, "lost": -2, "decline": -2,
+    "declined": -2, "declining": -2, "decrease": -2, "decreased": -2,
+    "fall": -2, "fell": -2, "falling": -2, "drop": -2, "dropped": -2,
+    "dropping": -2, "plunge": -3, "plunged": -3, "plunging": -3,
+    "crash": -3, "crashed": -3, "crashing": -3, "collapse": -3,
+    "collapsed": -3, "collapsing": -3, "tumble": -2, "tumbled": -2,
+    "weak": -2, "weakness": -2, "weaker": -2, "poor": -2, "worse": -2,
+    "worst": -3, "bad": -2, "negative": -2, "pessimistic": -2,
+    "bearish": -2, "bear": -2, "concern": -1, "concerns": -1,
+    "worried": -2, "worry": -2, "worrying": -2, "risk": -1, "risks": -1,
+    "risky": -1, "threat": -2, "threaten": -2, "threatening": -2,
+    "problem": -2, "problems": -2, "issue": -1, "issues": -1,
+    "challenge": -1, "challenges": -1, "difficulty": -2, "difficulties": -2,
+    "struggle": -2, "struggling": -2, "struggled": -2, "fail": -2,
+    "failed": -2, "failing": -2, "failure": -2, "miss": -2, "missed": -2,
+    "disappointing": -2, "disappointed": -2, "disappointment": -2,
+    "underperform": -2, "underperformed": -2, "underperforming": -2,
+    "downgrade": -2, "downgraded": -2, "sell": -1, "cut": -1,
+    "cuts": -1, "cutting": -1, "reduce": -1, "reduced": -1, "reduction": -1,
+    "layoff": -2, "layoffs": -2, "fire": -2, "fired": -2, "firing": -2,
+    "eliminate": -2, "elimination": -2, "suspend": -2, "suspended": -2,
+    "delay": -1, "delayed": -1, "postpone": -1, "postponed": -1,
+    "cancel": -2, "cancelled": -2, "bankruptcy": -3, "bankrupt": -3,
+    "debt": -1, "debts": -1, "deficit": -2, "shortage": -2, "shortages": -2,
+    "crisis": -3, "recession": -3, "downturn": -2, "slump": -2,
+    "volatile": -1, "volatility": -1, "uncertain": -1, "uncertainty": -2,
+    "unstable": -2, "instability": -2, "warning": -2, "warn": -2,
+    "warned": -2, "alert": -1, "caution": -1, "cautious": -1,
+    "investigation": -2, "lawsuit": -2, "sue": -2, "sued": -2,
+    "fraud": -3, "scandal": -3, "controversy": -2, "dispute": -2,
+    "conflict": -2, "penalty": -2, "fine": -2, "violation": -2
+  }
+}

src/core/news_analysis/data/news_analysis.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass, asdict
+from typing import Any
+
+from src.core.news_analysis.data.news_item import NewsItem
+from src.core.news_analysis.data.sentiment_result import SentimentResult
+
+
+@dataclass
+class NewsAnalysis:
+    news_item: NewsItem
+    headline_sentiment: SentimentResult
+    summary_sentiment: SentimentResult
+    overall_sentiment: SentimentResult
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            'news_item': asdict(self.news_item),
+            'headline_sentiment': asdict(self.headline_sentiment),
+            'summary_sentiment': asdict(self.summary_sentiment),
+            'overall_sentiment': asdict(self.overall_sentiment)
+        }

src/core/news_analysis/data/news_item.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class NewsItem:
+    id: int
+    headline: str
+    category: str
+    summary: str
+    datetime: int
+    source: str
+    related: str
+    image: str
+    url: str

src/core/news_analysis/data/sentiment_result.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class SentimentResult:
+    score: float
+    polarity: str
+    confidence: float
+    positive_words: list[str]
+    negative_words: list[str]
+    word_count: int

src/core/news_analysis/lexicon_based_sentiment_analyzer.py

@@ -0,0 +1,530 @@
+"""
+Finnhub News Sentiment Analysis Module
+
+This module provides sentiment analysis for Finnhub company news API responses
+using NLTK for text processing and TextBlob for sentiment analysis.
+"""
+
+import re
+import logging
+from typing import Any
+import statistics
+import json
+import os
+
+import nltk
+from textblob import TextBlob
+
+import ssl
+try:
+    _create_unverified_https_context = ssl._create_unverified_context
+except AttributeError:
+    pass
+else:
+    ssl._create_default_https_context = _create_unverified_https_context
+
+def _download_nltk_requirements():
+    """Download required NLTK data."""
+    nltk_downloads = [
+        'punkt',
+        'stopwords',
+        'wordnet',
+        'vader_lexicon',
+        'averaged_perceptron_tagger',
+        'omw-1.4'
+    ]
+    for item in nltk_downloads:
+        nltk.download(item, quiet=True)
+
+_download_nltk_requirements()
+
+
+from nltk.corpus import stopwords
+
+from nltk.tokenize import word_tokenize
+from nltk.stem import WordNetLemmatizer
+
+from src.core.news_analysis.data.news_item import NewsItem
+from src.core.news_analysis.data.sentiment_result import SentimentResult
+from src.core.news_analysis.data.news_analysis import NewsAnalysis
+from src.api.financial_news_requester import fetch_comp_financial_news
+
+
+class FinnhubSentimentAnalyzer:
+    """
+    Sentiment analyzer for Finnhub news data using NLTK and TextBlob.
+
+    This analyzer combines lexicon-based approach with TextBlob's machine learning
+    sentiment analysis for more accurate results.
+    """
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self._nltk_initialize()
+        self.financial_lexicon = self._get_financial_lexicon()
+
+    def _nltk_initialize(self) -> None:
+        self._download_nltk_requirements()
+        # Initialize NLTK components
+        try:
+            self.stop_words = set(stopwords.words('english'))
+            self.lemmatizer = WordNetLemmatizer()
+        except Exception as e:
+            self.logger.error(f"NLTK data not found: {e}")
+            self.logger.info("Please run nltk.download() to install required data")
+            raise
+
+    def _download_nltk_requirements(self):
+        """Download required NLTK data."""
+        nltk_downloads = [
+            'punkt',
+            'stopwords',
+            'wordnet',
+            'vader_lexicon',
+            'averaged_perceptron_tagger',
+            'omw-1.4'
+        ]
+        for item in nltk_downloads:
+            try:
+                nltk.download(item, quiet=True)
+            except Exception as e:
+                self.logger.warning(f"Failed to download {item}: {e}")
+
+    def _get_financial_lexicon(self) -> dict[str, dict[str, float]]:
+        """
+        Load financial-specific sentiment lexicon from a JSON file.
+        """
+        lexicon_path = os.path.join(
+            os.path.dirname(__file__),
+            "./data/financial_lexicon.json"
+        )
+        with open(lexicon_path, "r", encoding="utf-8") as f:
+            lexicon = json.load(f)
+        return lexicon
+
+    def _preprocess_text(self, text: str) -> tuple[str, list[str]]:
+        """
+        Preprocess text using NLTK.
+
+        Args:
+            text: Raw text to preprocess
+
+        Returns:
+            Tuple of (cleaned_text, tokenized_words)
+        """
+        if not text:
+            return "", []
+        # Convert to lowercase
+        text = text.lower()
+        # Remove URLs, email addresses, and special characters
+        text = re.sub(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', '', text)
+        text = re.sub(r'\S+@\S+', '', text)
+        text = re.sub(r'[^\w\s]', ' ', text)
+        # Tokenize
+        try:
+            tokens = word_tokenize(text)
+        except LookupError:
+            # Fallback if punkt tokenizer is not available
+            tokens = text.split()
+        # Remove stop words and lemmatize
+        processed_tokens = []
+        for token in tokens:
+            if token not in self.stop_words and len(token) > 2:
+                try:
+                    lemmatized = self.lemmatizer.lemmatize(token)
+                    processed_tokens.append(lemmatized)
+                except:
+                    processed_tokens.append(token)
+        processed_text = ' '.join(processed_tokens)
+        return processed_text, processed_tokens
+
+    def _get_lexicon_sentiment(self, tokens: list[str]) -> tuple[float, list[str], list[str]]:
+        """
+        Calculate sentiment using financial lexicon.
+
+        Args:
+            tokens: List of preprocessed tokens
+
+        Returns:
+            Tuple of (score, positive_words, negative_words)
+        """
+        score = 0.0
+        positive_words = []
+        negative_words = []
+        for token in tokens:
+            if token in self.financial_lexicon['positive']:
+                word_score = self.financial_lexicon['positive'][token]
+                score += word_score
+                positive_words.append(token)
+            elif token in self.financial_lexicon['negative']:
+                word_score = self.financial_lexicon['negative'][token]
+                score += word_score
+                negative_words.append(token)
+        return score, positive_words, negative_words
+
+    def _analyze_text_sentiment(self, text: str) -> SentimentResult:
+        """
+        Analyze sentiment of text using both TextBlob and lexicon approach.
+
+        Args:
+            text: Text to analyze
+
+        Returns:
+            SentimentResult object
+        """
+        if not text:
+            return SentimentResult(
+                score=0.0,
+                polarity='neutral',
+                confidence=0.0,
+                positive_words=[],
+                negative_words=[],
+                word_count=0
+            )
+        processed_text, tokens = self._preprocess_text(text)
+        if not tokens:
+            return SentimentResult(
+                score=0.0,
+                polarity='neutral',
+                confidence=0.0,
+                positive_words=[],
+                negative_words=[],
+                word_count=0
+            )
+        blob = TextBlob(text)
+        textblob_polarity = blob.sentiment.polarity  # Range: -1 to 1
+        textblob_subjectivity = blob.sentiment.subjectivity  # Range: 0 to 1
+        lexicon_score, positive_words, negative_words = self._get_lexicon_sentiment(tokens)
+        # Normalize lexicon score
+        normalized_lexicon_score = lexicon_score / len(tokens) if tokens else 0.0
+        # Combine TextBlob and lexicon scores (weighted average)
+        # TextBlob: 60%, Lexicon: 40%
+        combined_score = (textblob_polarity * 0.6) + (normalized_lexicon_score * 0.4)
+        # Determine polarity
+        if combined_score > 0.1:
+            polarity = 'positive'
+        elif combined_score < -0.1:
+            polarity = 'negative'
+        else:
+            polarity = 'neutral'
+        # Calculate confidence
+        # Based on TextBlob subjectivity and number of sentiment words found
+        sentiment_word_ratio = (len(positive_words) + len(negative_words)) / len(tokens)
+        confidence = (textblob_subjectivity * 0.5) + (sentiment_word_ratio * 0.5)
+        confidence = min(confidence, 1.0)
+        return SentimentResult(
+            score=round(combined_score, 4),
+            polarity=polarity,
+            confidence=round(confidence, 4),
+            positive_words=positive_words,
+            negative_words=negative_words,
+            word_count=len(tokens)
+        )
+
+    def analyze_news_item(self, news_data: dict[str, Any]) -> NewsAnalysis:
+        """
+        Analyze sentiment of a single news item.
+
+        Args:
+            news_data: Dictionary containing news data from Finnhub API
+
+        Returns:
+            NewsAnalysis object
+        """
+        news_item = NewsItem(**news_data)
+        headline_sentiment = self._analyze_text_sentiment(news_item.headline)
+        summary_sentiment = self._analyze_text_sentiment(news_item.summary)
+
+        # TODO: this snippet should be refactored :)
+        # Calculate overall sentiment (weighted: headline 30%, summary 70%)
+        if headline_sentiment.word_count > 0 and summary_sentiment.word_count > 0:
+            overall_score = (headline_sentiment.score * 0.3) + (summary_sentiment.score * 0.7)
+            overall_positive_words = list(set(headline_sentiment.positive_words + summary_sentiment.positive_words))
+            overall_negative_words = list(set(headline_sentiment.negative_words + summary_sentiment.negative_words))
+            total_words = headline_sentiment.word_count + summary_sentiment.word_count
+            overall_confidence = ((headline_sentiment.confidence * headline_sentiment.word_count) +
+                                  (summary_sentiment.confidence * summary_sentiment.word_count)) / total_words
+        elif headline_sentiment.word_count > 0:
+            overall_score = headline_sentiment.score
+            overall_positive_words = headline_sentiment.positive_words
+            overall_negative_words = headline_sentiment.negative_words
+            total_words = headline_sentiment.word_count
+            overall_confidence = headline_sentiment.confidence
+        elif summary_sentiment.word_count > 0:
+            overall_score = summary_sentiment.score
+            overall_positive_words = summary_sentiment.positive_words
+            overall_negative_words = summary_sentiment.negative_words
+            total_words = summary_sentiment.word_count
+            overall_confidence = summary_sentiment.confidence
+        else:
+            overall_score = 0.0
+            overall_positive_words = []
+            overall_negative_words = []
+            total_words = 0
+            overall_confidence = 0.0
+
+        # Determine overall polarity
+        if overall_score > 0.1:
+            overall_polarity = 'positive'
+        elif overall_score < -0.1:
+            overall_polarity = 'negative'
+        else:
+            overall_polarity = 'neutral'
+        overall_sentiment = SentimentResult(
+            score=round(overall_score, 4),
+            polarity=overall_polarity,
+            confidence=round(overall_confidence, 4),
+            positive_words=overall_positive_words,
+            negative_words=overall_negative_words,
+            word_count=total_words
+        )
+        return NewsAnalysis(
+            news_item=news_item,
+            headline_sentiment=headline_sentiment,
+            summary_sentiment=summary_sentiment,
+            overall_sentiment=overall_sentiment
+        )
+
+    def analyze_news_batch(self, news_data: list[dict[str, Any]]) -> list[NewsAnalysis]:
+        """
+        Analyze sentiment for a batch of news items.
+
+        Args:
+            news_data: List of news dictionaries from Finnhub API
+
+        Returns:
+            List of NewsAnalysis objects
+        """
+        if not news_data:
+            self.logger.warning("No news data provided for analysis")
+            return []
+        analyses = []
+        for news_item in news_data:
+            try:
+                analysis = self.analyze_news_item(news_item)
+                analyses.append(analysis)
+            except Exception as e:
+                self.logger.error(f"Error analyzing news item {news_item.get('id', 'unknown')}: {e}")
+                continue
+        self.logger.info(f"Successfully analyzed {len(analyses)} out of {len(news_data)} news items")
+        return analyses
+
+    # TODO: refactor this method
+    def get_sentiment_summary(self, analyses: list[NewsAnalysis]) -> dict[str, Any]:
+        """
+        Generate summary statistics for sentiment analyses.
+
+        Args:
+            analyses: List of NewsAnalysis objects
+
+        Returns:
+            Dictionary containing summary statistics
+        """
+        if not analyses:
+            return {
+                'total_articles': 0,
+                'positive_count': 0,
+                'negative_count': 0,
+                'neutral_count': 0,
+                'average_sentiment': 0.0,
+                'sentiment_distribution': {'positive': 0.0, 'negative': 0.0, 'neutral': 0.0},
+                'average_confidence': 0.0,
+                'most_positive': None,
+                'most_negative': None,
+                'sentiment_trend': 'neutral'
+            }
+
+        # Count sentiment polarities
+        positive_count = sum(1 for a in analyses if a.overall_sentiment.polarity == 'positive')
+        negative_count = sum(1 for a in analyses if a.overall_sentiment.polarity == 'negative')
+        neutral_count = sum(1 for a in analyses if a.overall_sentiment.polarity == 'neutral')
+
+        # Calculate averages
+        scores = [a.overall_sentiment.score for a in analyses]
+        confidences = [a.overall_sentiment.confidence for a in analyses]
+
+        avg_sentiment = statistics.mean(scores) if scores else 0.0
+        avg_confidence = statistics.mean(confidences) if confidences else 0.0
+
+        # Determine overall sentiment trend
+        if avg_sentiment > 0.1:
+            sentiment_trend = 'positive'
+        elif avg_sentiment < -0.1:
+            sentiment_trend = 'negative'
+        else:
+            sentiment_trend = 'neutral'
+
+        # Find most positive and negative articles
+        most_positive = max(analyses, key=lambda x: x.overall_sentiment.score) if analyses else None
+        most_negative = min(analyses, key=lambda x: x.overall_sentiment.score) if analyses else None
+
+        total = len(analyses)
+
+        return {
+            'total_articles': total,
+            'positive_count': positive_count,
+            'negative_count': negative_count,
+            'neutral_count': neutral_count,
+            'average_sentiment': round(avg_sentiment, 4),
+            'sentiment_distribution': {
+                'positive': round(positive_count / total * 100, 2) if total > 0 else 0.0,
+                'negative': round(negative_count / total * 100, 2) if total > 0 else 0.0,
+                'neutral': round(neutral_count / total * 100, 2) if total > 0 else 0.0
+            },
+            'average_confidence': round(avg_confidence, 4),
+            'sentiment_trend': sentiment_trend,
+            'most_positive': {
+                'id': most_positive.news_item.id,
+                'headline': most_positive.news_item.headline,
+                'score': most_positive.overall_sentiment.score,
+                'source': most_positive.news_item.source
+            } if most_positive else None,
+            'most_negative': {
+                'id': most_negative.news_item.id,
+                'headline': most_negative.news_item.headline,
+                'score': most_negative.overall_sentiment.score,
+                'source': most_negative.news_item.source
+            } if most_negative else None
+        }
+
+
+# Integration function with your existing Finnhub API code
+def analyze_finnhub_news_sentiment(ticker: str = 'NVDA',
+                                   date_from: str = "2025-07-31",
+                                   date_to: str = "2025-08-01") -> dict[str, Any] | None:
+    """
+    Complete pipeline to fetch and analyze Finnhub news sentiment using NLTK and TextBlob.
+
+    Args:
+        ticker: Stock ticker symbol
+        date_from: Start date for news fetch
+        date_to: End date for news fetch
+
+    Returns:
+        Dictionary containing analysis results or None if error
+    """
+    import os
+    from dotenv import load_dotenv
+    import finnhub
+
+    load_dotenv()
+    api_key = os.getenv('FINNHUB_API_TOKEN')
+
+    if not api_key:
+        logging.error("FINNHUB_API_TOKEN not found in environment variables")
+        return None
+
+    try:
+        # Fetch news data using your existing function
+        finnhub_client = finnhub.Client(api_key=api_key)
+        news_feed = finnhub_client.company_news(ticker, _from=date_from, to=date_to)
+        logging.info(f'Got total amount of news: {len(news_feed)} for ticker: {ticker}')
+
+        if not news_feed:
+            logging.warning(f"No news found for ticker {ticker}")
+            return None
+
+        # Initialize analyzer and analyze sentiment
+        analyzer = FinnhubSentimentAnalyzer()
+        analyses = analyzer.analyze_news_batch(news_feed)
+
+        if not analyses:
+            logging.warning("No successful sentiment analyses")
+            return None
+
+        # Generate summary
+        summary = analyzer.get_sentiment_summary(analyses)
+
+        return {
+            'ticker': ticker,
+            'date_range': {'from': date_from, 'to': date_to},
+            'summary': summary,
+            'detailed_analyses': [analysis.to_dict() for analysis in analyses]
+        }
+
+    except Exception as e:
+        logging.error(f"Error in sentiment analysis pipeline: {e}")
+        return None
+
+
+# TODO: this function should be refactored
+if __name__ == "__main__":
+    # Example usage
+    logging.basicConfig(level=logging.INFO)
+
+    '''
+    # Sample news data for testing
+    sample_news = [
+        {
+            "category": "company news",
+            "datetime": 1569550360,
+            "headline": "Apple reports record quarterly earnings with exceptional iPhone sales growth",
+            "id": 25286,
+            "image": "https://example.com/image1.jpg",
+            "related": "AAPL",
+            "source": "Reuters",
+            "summary": "Apple Inc. announced outstanding quarterly results, with revenue reaching new record highs driven by strong iPhone sales and robust performance across all product categories. The company exceeded analyst expectations and demonstrated excellent growth in services revenue, leading to optimistic investor sentiment.",
+            "url": "https://example.com/news1"
+        },
+        {
+            "category": "company news",
+            "datetime": 1569528720,
+            "headline": "Tesla struggles with production delays amid supply chain crisis",
+            "id": 25287,
+            "image": "https://example.com/image2.jpg",
+            "related": "TSLA",
+            "source": "Bloomberg",
+            "summary": "Tesla is experiencing significant production challenges due to severe supply chain disruptions and semiconductor shortages. The company warned investors about potential negative impact on delivery targets and profit margins, raising concerns about disappointing quarterly results.",
+            "url": "https://example.com/news2"
+        }
+    ]
+    '''
+
+    sample_news = fetch_comp_financial_news(ticker='NVDA', date_from='2025-08-02', date_to='2025-08-03')
+    print(sample_news)
+    print(len(sample_news))
+
+    # Initialize analyzer
+    analyzer = FinnhubSentimentAnalyzer()
+
+    # Analyze sample news, # Limit to last 2 items for testing
+    results = analyzer.analyze_news_batch(sample_news[:3])
+
+    # Print results
+    for result in results:
+        print(f"\n{'=' * 60}")
+        print(f"News ID: {result.news_item.id}")
+        print(f"Headline: {result.news_item.headline}")
+        print(f"Source: {result.news_item.source}")
+        print(f"\nHeadline Sentiment: {result.headline_sentiment.polarity} "
+              f"(Score: {result.headline_sentiment.score}, "
+              f"Confidence: {result.headline_sentiment.confidence})")
+        print(f"Summary Sentiment: {result.summary_sentiment.polarity} "
+              f"(Score: {result.summary_sentiment.score}, "
+              f"Confidence: {result.summary_sentiment.confidence})")
+        print(f"Overall Sentiment: {result.overall_sentiment.polarity} "
+              f"(Score: {result.overall_sentiment.score}, "
+              f"Confidence: {result.overall_sentiment.confidence})")
+        print(f"Positive words: {result.overall_sentiment.positive_words}")
+        print(f"Negative words: {result.overall_sentiment.negative_words}")
+
+    # Generate and print summary
+    summary = analyzer.get_sentiment_summary(results)
+    print(f"\n{'=' * 60}")
+    print("SENTIMENT SUMMARY")
+    print(f"{'=' * 60}")
+    print(f"Total articles: {summary['total_articles']}")
+    print(f"Positive: {summary['positive_count']} ({summary['sentiment_distribution']['positive']}%)")
+    print(f"Negative: {summary['negative_count']} ({summary['sentiment_distribution']['negative']}%)")
+    print(f"Neutral: {summary['neutral_count']} ({summary['sentiment_distribution']['neutral']}%)")
+    print(f"Average sentiment: {summary['average_sentiment']}")
+    print(f"Average confidence: {summary['average_confidence']}")
+    print(f"Overall trend: {summary['sentiment_trend']}")
+
+    if summary['most_positive']:
+        print(f"\nMost positive article: {summary['most_positive']['headline']}")
+        print(f"Score: {summary['most_positive']['score']}")
+
+    if summary['most_negative']:
+        print(f"\nMost negative article: {summary['most_negative']['headline']}")
+        print(f"Score: {summary['most_negative']['score']}")

src/telegram_bot.py

@@ -5,7 +5,7 @@ from typing import Any
 from telegram import Update
 from telegram.ext import Application, CommandHandler, ContextTypes
 from dotenv import load_dotenv
-from src.financial_news_requester import fetch_comp_financial_news
+from api.financial_news_requester import fetch_comp_financial_news
 from fastapi import FastAPI, Request
 import uvicorn
 import httpx