Update app.py

app.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from transformers import pipeline, MarianMTModel, AutoTokenizer
+from transformers import pipeline
 import feedparser
 from datetime import datetime, timedelta
 import json
@@ -44,40 +44,21 @@ NEWS_SOURCES = {
     }
 }
 
-# Language codes and their corresponding MarianMT model names
-LANGUAGE_CODES = {
-    "English": {"code": "en", "model": None},  # No translation needed for English
-    "Spanish": {"code": "es", "model": "Helsinki-NLP/opus-mt-en-es"},
-    "French": {"code": "fr", "model": "Helsinki-NLP/opus-mt-en-fr"},
-    "German": {"code": "de", "model": "Helsinki-NLP/opus-mt-en-de"},
-    "Italian": {"code": "it", "model": "Helsinki-NLP/opus-mt-en-it"},
-    "Portuguese": {"code": "pt", "model": "Helsinki-NLP/opus-mt-en-pt"},
-    "Dutch": {"code": "nl", "model": "Helsinki-NLP/opus-mt-en-nl"},
-    "Russian": {"code": "ru", "model": "Helsinki-NLP/opus-mt-en-ru"},
-    "Chinese": {"code": "zh", "model": "Helsinki-NLP/opus-mt-en-zh"},
-    "Japanese": {"code": "ja", "model": "Helsinki-NLP/opus-mt-en-jap"},
-    "Arabic": {"code": "ar", "model": "Helsinki-NLP/opus-mt-en-ar"}
-}
-
 # Initialize global variables
 summarizer = None
-translators = {}
 
 class NewsCache:
     def __init__(self):
         self.summaries = {}
-        self.translations = {}
         self.max_cache_size = 1000
         
-    def store_summary(self, content_hash, summary, language=None):
-        cache_key = f"{content_hash}_{language}" if language else content_hash
+    def store_summary(self, content_hash, summary):
         if len(self.summaries) >= self.max_cache_size:
             self.summaries.pop(next(iter(self.summaries)))
-        self.summaries[cache_key] = summary
+        self.summaries[content_hash] = summary
         
-    def get_summary(self, content_hash, language=None):
-        cache_key = f"{content_hash}_{language}" if language else content_hash
-        return self.summaries.get(cache_key)
+    def get_summary(self, content_hash):
+        return self.summaries.get(content_hash)
 
 news_cache = NewsCache()
 
@@ -120,8 +101,8 @@ def fetch_news_from_rss(categories):
     return articles
 
 def initialize_models():
-    """Initialize the summarization and translation models"""
-    global summarizer, translators
+    """Initialize the summarization model"""
+    global summarizer
     
     try:
         # Initialize summarizer
@@ -130,55 +111,13 @@ def initialize_models():
             model="facebook/bart-large-cnn",
             device=-1  # Use CPU
         )
-        
-        # Initialize translators for each language
-        for lang, info in LANGUAGE_CODES.items():
-            if info["model"]:  # Skip English as it doesn't need translation
-                try:
-                    model = MarianMTModel.from_pretrained(info["model"])
-                    tokenizer = AutoTokenizer.from_pretrained(info["model"])
-                    translators[lang] = (model, tokenizer)
-                    logging.info(f"Initialized translator for {lang}")
-                    logging.info["model"]
-                except Exception as e:
-                    logging.error(f"Error initializing translator for {lang}: {e}")
-                    
         return True
     except Exception as e:
         logging.error(f"Error initializing models: {e}")
         return False
 
-def translate_text(text, target_language):
-    """Translate text to target language"""
-    if target_language == "English" or not text:
-        return text
-        
-    try:
-        if target_language not in translators:
-            logging.error(f"Translator not found for {target_language}")
-            return text
-            
-        model, tokenizer = translators[target_language]
-        
-        # Split text into chunks to handle long text
-        max_length = 512
-        chunks = [text[i:i+max_length] for i in range(0, len(text), max_length)]
-        translated_chunks = []
-        
-        for chunk in chunks:
-            inputs = tokenizer(chunk, return_tensors="pt", truncation=True, max_length=512)
-            translated = model.generate(**inputs)
-            translated_text = tokenizer.decode(translated[0], skip_special_tokens=True)
-            translated_chunks.append(translated_text)
-            
-        return " ".join(translated_chunks)
-        
-    except Exception as e:
-        logging.error(f"Translation error: {e}")
-        return text
-
-def generate_summary(text, title="", category="", language="English"):
-    """Generate summary with translation support"""
+def generate_summary(text, title="", category=""):
+    """Generate summary for the article"""
     if not summarizer:
         if not initialize_models():
             return None
@@ -186,11 +125,11 @@ def generate_summary(text, title="", category="", language="English"):
     try:
         # Check cache first
         content_hash = get_content_hash(text)
-        cached_summary = news_cache.get_summary(content_hash, language)
+        cached_summary = news_cache.get_summary(content_hash)
         if cached_summary:
             return cached_summary
         
-        # Generate English summary first
+        # Generate summary
         prompt_template = f"""
 Analyze and summarize this {category} news article titled "{title}".
 Focus on providing:
@@ -221,11 +160,7 @@ Please provide a clear, concise summary that a general audience can understand:"
             sentences = summary.split(". ")
             formatted_summary = "\n• " + "\n• ".join(filter(None, sentences))
             
-            # Translate if needed
-            if language != "English":
-                formatted_summary = translate_text(formatted_summary, language)
-            
-            news_cache.store_summary(content_hash, formatted_summary, language)
+            news_cache.store_summary(content_hash, formatted_summary)
             return formatted_summary
             
         return None
@@ -235,7 +170,7 @@ Please provide a clear, concise summary that a general audience can understand:"
         return None
 
 def get_personalized_summary(name, progress=gr.Progress()):
-    """Generate personalized news summary in user's preferred language"""
+    """Generate personalized news summary"""
     start_time = time.time()
     logging.info(f"Starting summary generation for user: {name}")
     
@@ -250,14 +185,12 @@ def get_personalized_summary(name, progress=gr.Progress()):
     except Exception as e:
         return f"Error loading preferences: {e}"
 
-    user_language = preferences.get("language", "English")
-    
     # Fetch articles with progress
     progress(0.2, desc="Fetching recent news...")
     articles = fetch_news_from_rss(preferences["interests"])
     
     if not articles:
-        return translate_text("No recent news articles found from the last 8 hours. Please try again later.", user_language)
+        return "No recent news articles found from the last 8 hours. Please try again later."
 
     # Process articles with timeout
     progress(0.4, desc="Analyzing and summarizing...")
@@ -284,24 +217,18 @@ def get_personalized_summary(name, progress=gr.Progress()):
             if not content:
                 continue
                 
-            summary = generate_summary(content, title, category, user_language)
+            summary = generate_summary(content, title, category)
             if not summary:
                 continue
-                
-            # Translate title and category if needed
-            if user_language != "English":
-                title = translate_text(title, user_language)
-                category = translate_text(category, user_language)
-                published_str = translate_text(published_str, user_language)
             
             formatted_summary = f"""
 📰 {title}
-📁 {translate_text("Category", user_language)}: {category}
-⏰ {translate_text("Published", user_language)}: {published_str}
+📁 Category: {category}
+⏰ Published: {published_str}
 
 {summary}
 
-🔗 {translate_text("Read more", user_language)}: {link}
+🔗 Read more: {link}
 
 ---"""
             summaries.append(formatted_summary)
@@ -311,22 +238,17 @@ def get_personalized_summary(name, progress=gr.Progress()):
             continue
 
     if not summaries:
-        return translate_text("Unable to generate summaries for recent news. Please try again.", user_language)
+        return "Unable to generate summaries for recent news. Please try again."
     
     progress(1.0, desc="Done!")
     return "\n".join(summaries)
 
 # Gradio interface
-with gr.Blocks(title="Enhanced News Summarizer") as demo:
-    gr.Markdown("# 📰 Enhanced AI News Summarizer")
+with gr.Blocks(title="News Summarizer") as demo:
+    gr.Markdown("# 📰 AI News Summarizer")
     
     with gr.Tab("Set Preferences"):
         name_input = gr.Textbox(label="Your Name")
-        language_dropdown = gr.Dropdown(
-            choices=list(LANGUAGE_CODES.keys()),
-            label="Preferred Language",
-            value="English"
-        )
         interests_checkboxes = gr.CheckboxGroup(
             choices=list(NEWS_SOURCES.keys()),
             label="News Interests (Select multiple)"
@@ -334,13 +256,12 @@ with gr.Blocks(title="Enhanced News Summarizer") as demo:
         save_button = gr.Button("Save Preferences")
         preferences_output = gr.Textbox(label="Status")
         
-        def save_preferences(name, language, interests):
-            if not name or not language or not interests:
+        def save_preferences(name, interests):
+            if not name or not interests:
                 return "Please fill in all required fields!"
             
             preferences = {
                 "name": name,
-                "language": language,
                 "interests": interests,
                 "last_updated": datetime.now().isoformat()
             }
@@ -356,7 +277,7 @@ with gr.Blocks(title="Enhanced News Summarizer") as demo:
         
         save_button.click(
             save_preferences,
-            inputs=[name_input, language_dropdown, interests_checkboxes],
+            inputs=[name_input, interests_checkboxes],
             outputs=[preferences_output]
         )