Update app.py

app.py

@@ -1,68 +1,181 @@
 import gradio as gr
-from transformers import pipeline
+from transformers import pipeline, AutoModelForSeq2SeqGeneration, AutoTokenizer
 import feedparser
-from datetime import datetime
+from datetime import datetime, timedelta
 import json
 import os
+import requests
+from bs4 import BeautifulSoup
+import threading
+import time
+import schedule
 
-# Initialize the pipeline using an open source model instead of Llama
-# Using facebook/bart-large-cnn which is specialized for summarization
+# Initialize the summarization model
 summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
 
+# Initialize translation model for multiple languages
+translator = pipeline("translation", model="Helsinki-NLP/opus-mt-en-MANY")
+
+# News sources configuration
+NEWS_SOURCES = {
+    "Technology": [
+        "https://feeds.feedburner.com/TechCrunch",
+        "https://www.wired.com/feed/rss",
+        "https://www.theverge.com/rss/index.xml",
+        "https://feeds.feedburner.com/thenextweb"
+    ],
+    "Business": [
+        "https://feeds.feedburner.com/BusinessInsider",
+        "https://www.forbes.com/innovation/feed2",
+        "https://www.entrepreneur.com/feed/latest",
+        "https://www.ft.com/rss/home"
+    ],
+    "Sports": [
+        "https://www.espn.com/espn/rss/news",
+        "https://www.sports.yahoo.com/rss/",
+        "https://www.skysports.com/rss/news-feed",
+        "https://www.cbssports.com/rss/headlines/"
+    ],
+    "Science": [
+        "https://www.sciencedaily.com/rss/all.xml",
+        "https://www.nature.com/nature.rss",
+        "https://www.newscientist.com/feed/home/"
+    ],
+    "Health": [
+        "https://www.who.int/rss-feeds/news-english.xml",
+        "https://www.health.harvard.edu/feed",
+        "https://rss.medicalnewstoday.com/featurednews.xml"
+    ],
+    "Entertainment": [
+        "https://variety.com/feed/",
+        "https://www.hollywoodreporter.com/feed",
+        "https://deadline.com/feed"
+    ]
+}
+
+class NewsCache:
+    def __init__(self):
+        self.cache = {}
+        self.last_updated = None
+        self.update_interval = 30  # minutes
+
+    def needs_update(self):
+        if not self.last_updated:
+            return True
+        return datetime.now() - self.last_updated > timedelta(minutes=self.update_interval)
+
+news_cache = NewsCache()
+
+def translate_text(text, target_language):
+    """Translate text to target language"""
+    if target_language == "English":
+        return text
+    
+    try:
+        translation = translator(text, target_lang=target_language.upper())[0]['translation_text']
+        return translation
+    except Exception as e:
+        print(f"Translation error: {e}")
+        return text
+
+def fetch_full_article(url):
+    """Fetch full article content from URL"""
+    try:
+        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
+        response = requests.get(url, headers=headers, timeout=10)
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        # Remove unwanted elements
+        for tag in soup(['script', 'style', 'nav', 'header', 'footer', 'aside']):
+            tag.decompose()
+        
+        # Get article content (this might need adjustment based on specific sites)
+        article = soup.find('article') or soup.find('main') or soup.find('div', class_=['content', 'article'])
+        
+        if article:
+            return article.get_text().strip()
+        return None
+    except Exception as e:
+        print(f"Error fetching article: {e}")
+        return None
+
 def fetch_news_from_rss(interests):
     """Fetch news from RSS feeds based on interests"""
-    rss_feeds = {
-        "Technology": "https://feeds.feedburner.com/TechCrunch",
-        "Business": "https://feeds.feedburner.com/BusinessInsider",
-        "Sports": "https://www.espn.com/espn/rss/news",
-    }
+    if news_cache.needs_update():
+        articles = []
+        for interest in interests:
+            if interest in NEWS_SOURCES:
+                for feed_url in NEWS_SOURCES[interest]:
+                    try:
+                        feed = feedparser.parse(feed_url)
+                        for entry in feed.entries[:5]:  # Get top 5 articles from each feed
+                            article = {
+                                'title': entry.get('title', 'Untitled'),
+                                'description': entry.get('description', ''),
+                                'link': entry.get('link', ''),
+                                'category': interest,
+                                'published': entry.get('published', datetime.now().isoformat()),
+                                'source': feed_url
+                            }
+                            
+                            # Try to get full article content
+                            full_content = fetch_full_article(article['link'])
+                            if full_content:
+                                article['content'] = full_content
+                            
+                            articles.append(article)
+                    except Exception as e:
+                        print(f"Error fetching from {feed_url}: {e}")
+        
+        news_cache.cache = articles
+        news_cache.last_updated = datetime.now()
     
-    articles = []
-    for interest in interests:
-        if interest in rss_feeds:
-            try:
-                feed = feedparser.parse(rss_feeds[interest])
-                articles.extend(feed.entries[:3])
-            except Exception as e:
-                print(f"Error fetching {interest} news: {e}")
-    return articles
-
-def generate_summary(text, language="English"):
+    return news_cache.cache
+
+def generate_summary(text, max_length=150, min_length=50):
     """Generate summary using BART"""
     try:
-        # BART requires text to be within certain length limits
-        max_input_length = 1024  # BART's limit
+        # Handle long texts by chunking
+        max_input_length = 1024
         if len(text) > max_input_length:
-            text = text[:max_input_length]
-        
-        summary = summarizer(
-            text,
-            max_length=130,
-            min_length=30,
-            do_sample=False
-        )[0]['summary_text']
-        
-        # For languages other than English, we can add translation here
-        # You might want to add a translation pipeline for other languages
-        return summary
-        
+            chunks = [text[i:i + max_input_length] for i in range(0, len(text), max_input_length)]
+            summaries = []
+            for chunk in chunks:
+                summary = summarizer(
+                    chunk,
+                    max_length=max_length,
+                    min_length=min_length,
+                    do_sample=False
+                )[0]['summary_text']
+                summaries.append(summary)
+            return " ".join(summaries)
+        else:
+            return summarizer(
+                text,
+                max_length=max_length,
+                min_length=min_length,
+                do_sample=False
+            )[0]['summary_text']
     except Exception as e:
         print(f"Error generating summary: {e}")
         return "Error generating summary. Please try again."
 
-def save_user_preferences(name, language, interests):
+def save_user_preferences(name, language, interests, summary_length, update_frequency):
     if not name or not language or not interests:
-        return "Please fill in all fields!"
+        return "Please fill in all required fields!"
     
     preferences = {
         "name": name,
         "language": language,
         "interests": interests,
+        "summary_length": summary_length,
+        "update_frequency": update_frequency,
         "last_updated": datetime.now().isoformat()
     }
     
     try:
-        with open(f"preferences_{name}.json", "w") as f:
+        os.makedirs('user_preferences', exist_ok=True)
+        with open(f"user_preferences/preferences_{name}.json", "w") as f:
             json.dump(preferences, f)
         return f"Preferences saved for {name}!"
     except Exception as e:
@@ -73,7 +186,7 @@ def get_personalized_summary(name):
         return "Please enter your name!"
         
     try:
-        with open(f"preferences_{name}.json", "r") as f:
+        with open(f"user_preferences/preferences_{name}.json", "r") as f:
             preferences = json.load(f)
     except FileNotFoundError:
         return "Please set your preferences first!"
@@ -87,44 +200,84 @@ def get_personalized_summary(name):
     summaries = []
     for article in articles:
         title = article.get("title", "Untitled")
-        content = article.get("description", article.get("summary", ""))
+        content = article.get("content", article.get("description", ""))
+        category = article.get("category", "Uncategorized")
+        
         if content:
-            summary = generate_summary(content, preferences["language"])
-            summaries.append(f"📰 {title}\n\n{summary}\n\n---")
+            summary = generate_summary(
+                content,
+                max_length=preferences["summary_length"],
+                min_length=max(30, preferences["summary_length"] // 3)
+            )
+            
+            if preferences["language"] != "English":
+                summary = translate_text(summary, preferences["language"])
+                title = translate_text(title, preferences["language"])
+            
+            formatted_summary = f"""
+📰 {title}
+📁 Category: {category}
+⏰ {datetime.now().strftime('%Y-%m-%d %H:%M')}
+
+{summary}
+
+---"""
+            summaries.append(formatted_summary)
     
     return "\n".join(summaries) if summaries else "No summaries generated. Please try again."
 
 # Create Gradio interface
-with gr.Blocks(title="News Summarizer") as demo:
-    gr.Markdown("# 📰 AI News Summarizer")
+with gr.Blocks(title="Enhanced News Summarizer") as demo:
+    gr.Markdown("# 📰 Enhanced AI News Summarizer")
     
     with gr.Tab("Set Preferences"):
         name_input = gr.Textbox(label="Your Name")
         language_dropdown = gr.Dropdown(
-            # For now, we'll keep English as the main language since we're not using translation
-            choices=["English"],
+            choices=[
+                "English", "Spanish", "French", "German",
+                "Italian", "Portuguese", "Russian", "Chinese",
+                "Japanese", "Korean", "Arabic"
+            ],
             label="Preferred Language",
             value="English"
         )
         interests_checkboxes = gr.CheckboxGroup(
-            choices=["Technology", "Business", "Sports"],
-            label="News Interests"
+            choices=list(NEWS_SOURCES.keys()),
+            label="News Interests (Select multiple)"
+        )
+        summary_length = gr.Slider(
+            minimum=50,
+            maximum=300,
+            value=150,
+            step=10,
+            label="Summary Length (words)"
+        )
+        update_frequency = gr.Dropdown(
+            choices=["30 minutes", "1 hour", "2 hours", "4 hours", "12 hours", "24 hours"],
+            label="News Update Frequency",
+            value="1 hour"
         )
         save_button = gr.Button("Save Preferences")
         preferences_output = gr.Textbox(label="Status")
         
         save_button.click(
             save_user_preferences,
-            inputs=[name_input, language_dropdown, interests_checkboxes],
+            inputs=[name_input, language_dropdown, interests_checkboxes, 
+                   summary_length, update_frequency],
             outputs=[preferences_output]
         )
     
     with gr.Tab("Get News Summary"):
         name_check = gr.Textbox(label="Enter your name to get summary")
+        refresh_interval = gr.Dropdown(
+            choices=["Manual", "30 seconds", "1 minute", "5 minutes"],
+            label="Auto-refresh interval",
+            value="Manual"
+        )
         get_summary_button = gr.Button("Get Summary")
         summary_output = gr.Textbox(
             label="Your Personalized News Summary",
-            lines=10
+            lines=20
         )
         
         get_summary_button.click(