Update app.py

app.py

@@ -1,33 +1,25 @@
+
 import gradio as gr
 from transformers import pipeline
 import feedparser
 from datetime import datetime, timedelta
-import json
-import os
-import logging
 import pytz
 from bs4 import BeautifulSoup
-import hashlib
-import threading
-
-# Logging setup
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Global settings
-SUMMARIZER_MODEL = "facebook/bart-large-cnn"  # You can replace this with other summarization models
-CACHE_SIZE = 500  # Maximum number of cached summaries
-RSS_FETCH_INTERVAL = timedelta(hours=8)  # Fetch recent news within the last 8 hours
-ARTICLE_LIMIT = 5  # Limit to the last 5 articles
+SUMMARIZER_MODEL = "facebook/bart-large-cnn"
+RSS_FETCH_INTERVAL = timedelta(hours=8)
+ARTICLE_LIMIT = 5
 
 # News sources
 NEWS_SOURCES = {
     "Technology": {
         "TheNewYorkTimes": "https://rss.nytimes.com/services/xml/rss/nyt/Technology.xml",
-        "reutersagency": "https://www.reutersagency.com/feed/?best-topics=tech&post_type=best"
+        "Reuters": "https://www.reutersagency.com/feed/?best-topics=tech&post_type=best"
     },
     "Business": {
         "TheNewYorkTimes": "https://rss.nytimes.com/services/xml/rss/nyt/Business.xml",
-        "reutersagency": "https://www.reutersagency.com/feed/?best-topics=business-finance&post_type=best"
+        "Reuters": "https://www.reutersagency.com/feed/?best-topics=business-finance&post_type=best"
     },
     "Science": {
         "TheNewYorkTimes": "https://rss.nytimes.com/services/xml/rss/nyt/Science.xml"
@@ -36,46 +28,23 @@ NEWS_SOURCES = {
         "TheNewYorkTimes": "https://rss.nytimes.com/services/xml/rss/nyt/World.xml",
         "BBC": "http://feeds.bbci.co.uk/news/world/rss.xml",
         "CNN": "http://rss.cnn.com/rss/edition_world.rss",
-        "reutersagency": "https://www.reutersagency.com/feed/?taxonomy=best-regions&post_type=best"
+        "Reuters": "https://www.reutersagency.com/feed/?taxonomy=best-regions&post_type=best"
     },
     "Sports": {
         "TheNewYorkTimes": "https://rss.nytimes.com/services/xml/rss/nyt/Sports.xml",
-        "reutersagency": "https://www.reutersagency.com/feed/?best-topics=sports&post_type=best"
+        "Reuters": "https://www.reutersagency.com/feed/?best-topics=sports&post_type=best"
     },
     "Health": {
         "TheNewYorkTimes": "https://rss.nytimes.com/services/xml/rss/nyt/Health.xml",
-        "politico": "http://rss.politico.com/healthcare.xml",
-        "reutersagency": "https://www.reutersagency.com/feed/?best-topics=health&post_type=best"
+        "Politico": "http://rss.politico.com/healthcare.xml",
+        "Reuters": "https://www.reutersagency.com/feed/?best-topics=health&post_type=best"
     },
 }
 
-# Initialize cache
-class NewsCache:
-    def __init__(self, size):
-        self.cache = {}
-        self.size = size
-        self.lock = threading.Lock()
-
-    def get(self, key):
-        with self.lock:
-            return self.cache.get(key)
-
-    def set(self, key, value):
-        with self.lock:
-            if len(self.cache) >= self.size:
-                # Remove oldest cached item
-                oldest_key = next(iter(self.cache))
-                del self.cache[oldest_key]
-            self.cache[key] = value
-
-cache = NewsCache(CACHE_SIZE)
-
-# Initialize summarizer
+# Summarizer initialization
 summarizer = pipeline("summarization", model=SUMMARIZER_MODEL, device=-1)
 
-# Utility functions
 def fetch_rss_news(categories):
-    """Fetch news articles from RSS feeds based on selected categories."""
     articles = []
     cutoff_time = datetime.now(pytz.UTC) - RSS_FETCH_INTERVAL
 
@@ -84,7 +53,6 @@ def fetch_rss_news(categories):
             try:
                 feed = feedparser.parse(url)
                 for entry in feed.entries:
-                    # Parse publication time
                     published = datetime(*entry.published_parsed[:6], tzinfo=pytz.UTC)
                     if published > cutoff_time:
                         articles.append({
@@ -96,115 +64,73 @@ def fetch_rss_news(categories):
                             "published": published
                         })
             except Exception as e:
-                logging.error(f"Failed to fetch from {url}: {e}")
-    
-    # Sort articles by published date (most recent first) and limit to ARTICLE_LIMIT
+                print(f"Error fetching from {url}: {e}")
+
     articles = sorted(articles, key=lambda x: x["published"], reverse=True)[:ARTICLE_LIMIT]
     return articles
 
-def summarize_text(text):
-    """Summarize the text using the AI model."""
-    content_hash = hashlib.md5(text.encode()).hexdigest()
-    cached_summary = cache.get(content_hash)
-    if cached_summary:
-        return cached_summary
-
+def summarize_with_ai(text):
     try:
         result = summarizer(text, max_length=120, min_length=40, truncation=True)
-        summary = result[0]['summary_text']
-        cache.set(content_hash, summary)
-        return summary
+        return result[0]['summary_text']
     except Exception as e:
-        logging.error(f"Summarization failed: {e}")
+        print(f"AI summarization error: {e}")
         return "Summary unavailable."
 
-def summarize_articles(articles, template_choice):
-    """Summarize the last 5 fetched articles using the selected template."""
+def summarize_with_free_module(text):
+    # Simple heuristic summarization: return the first few sentences
+    return '. '.join(text.split('. ')[:3]) + '...'
+
+def summarize_articles(articles, method="AI Model"):
     summaries = []
+    summarizer_function = summarize_with_ai if method == "AI Model" else summarize_with_free_module
+
     for article in articles:
         try:
-            content = article["description"]
-            title = article["title"]
-            category = article["category"]
-            source = article["source"]
-            link = article["link"]
-            published = article["published"].strftime('%Y-%m-%d %H:%M')
-
-            # Summarize article content
-            summary = summarize_text(content)
-
-            if summary:
-                if template_choice == "Default":
-                    summaries.append(f"""
-                    📰 {title}
-
-                    - 📁 Category:  {category}  
-                    - 💡 Source: {source}  
-                    - ⏰ Published:  {published}  
-
-                    📃 Summary: 
-                    {summary}  
-                    🔗 Read the full article here ({link})  
-
-                    ---
-                    """)
-                elif template_choice == "Free":
-                    summaries.append(f"""
-                    **{title}**
-
-                    *Category:* {category}  
-                    *Source:* {source}  
-                    *Published:* {published}  
-
-                    *Summary:* 
-                    {summary}  
-                    *Link:* [{link}]({link})  
-
-                    ---
-                    """)
+            summary = summarizer_function(article["description"])
+            summaries.append(
+                "Title: {0}
+- Category: {1}
+- Source: {2}
+- Published: {3}
+Summary: {4}
+Read more: {5}".format(
+                    article["title"], 
+                    article["category"], 
+                    article["source"], 
+                    article["published"].strftime('%Y-%m-%d %H:%M'), 
+                    summary, 
+                    article["link"]
+                )
+            )
         except Exception as e:
-            logging.error(f"Error summarizing article: {e}")
-            continue
+            print(f"Error summarizing article: {e}")
+
     return summaries
 
-def generate_summary(selected_interests, template_choice):
-    """Generate a news summary based on user preferences."""
-    categories = selected_interests
+# Gradio Interface
+def generate_summary(categories, method):
     if not categories:
-        return "No categories selected. Please update your preferences."
-
-    # Fetch news
+        return "Please select at least one category."
     articles = fetch_rss_news(categories)
     if not articles:
-        return "No recent news found in your selected categories."
-
-    # Summarize all articles
-    summaries = summarize_articles(articles, template_choice)
+        return "No recent articles found."
+    summaries = summarize_articles(articles, method)
+    return "
 
-    # Combine and return summaries
-    return "\n\n".join(summaries) if summaries else "No summaries available."
+".join(summaries)
 
-# Gradio interface
 demo = gr.Blocks()
 
 with demo:
-    gr.Markdown("# 📰 AI News Summarizer")
-    
+    gr.Markdown("# AI News Summarizer")
     with gr.Row():
-        interests = gr.CheckboxGroup(
-            choices=list(NEWS_SOURCES.keys()),
-            label="Select Your Interests"
-        )
-        template_choice = gr.Radio(
-            choices=["Default", "Free"],
-            label="Choose Summary Template",
-            value="Default"
-        )
-    
-    fetch_button = gr.Button("Get Summary")
-    summary_output = gr.Textbox(label="News Summary", lines=20)
-    
-    fetch_button.click(generate_summary, inputs=[interests, template_choice], outputs=summary_output)
+        categories = gr.CheckboxGroup(choices=list(NEWS_SOURCES.keys()), label="Select Categories")
+        method = gr.Dropdown(choices=["AI Model", "Free Module"], label="Summarization Method", value="AI Model")
+    summarize_button = gr.Button("Generate Summary")
+    output = gr.Textbox(label="Summarized News", lines=15)
+
+    summarize_button.click(generate_summary, inputs=[categories, method], outputs=output)
 
 if __name__ == "__main__":
     demo.launch()