Update app.py

app.py

@@ -1,481 +1,244 @@
-from langchain_groq import ChatGroq
-from langgraph.graph import StateGraph, START, END
-from IPython.display import Image, display, Markdown
-from typing_extensions import TypedDict
-from langgraph.constants import Send
-from langchain_core.messages import HumanMessage, SystemMessage
-from langchain_community.tools.tavily_search import TavilySearchResults
 import os
-import getpass
-from typing import Annotated, List, Dict, Any
-import operator
-from pydantic import BaseModel, Field
+import re
 from datetime import datetime
+from typing import List, Dict, Any
+from collections import Counter
+import matplotlib.pyplot as plt
+from textblob import TextBlob
+from wordcloud import WordCloud
+import gradio as gr
+from langchain_community.utilities.tavily_search import TavilySearchResults
 import requests
 from bs4 import BeautifulSoup
-import re
-import json
-import gradio as gr
-from langdetect import detect
-from transformers import pipeline  # Import Hugging Face pipeline for text generation
-
-# Define models for structured output
-class NewsItem(BaseModel):
-    title: str = Field(description="Title of the news article")
-    url: str = Field(description="URL of the news article")
-    source: str = Field(description="Source website of the news")
-    description: str = Field(description="Brief description of the news article")
-
-class NewsResults(BaseModel):
-    news_items: List[NewsItem] = Field(description="List of news articles found")
+import time
+from urllib.parse import urlparse
 
-class Subsection(BaseModel):
-    title: str = Field(description="Title of the subsection (based on news item title)")
-    source: str = Field(description="Source of the news item")
-    url: str = Field(description="URL of the news item")
-    content: str = Field(description="Content for this subsection")
-
-class Section(BaseModel):
-    name: str = Field(description="Name for this section of the blog")
-    description: str = Field(description="Description for this section of the blog")
-    information: str = Field(description="Information which should be included in this section of the blog")
-    subsections: List[Subsection] = Field(description="Subsections for each news item in this category", default=[])
-
-class Sections(BaseModel):
-    sections: List[Section] = Field(description="List of sections for this blog")
-
-# State definitions
+# Define a typed dictionary for state management
 class NewsState(TypedDict):
-    query: str
+    topic: str
     date: str
     search_results: List[Dict[str, Any]]
     news_items: List[Dict[str, Any]]
-    
-class BlogState(TypedDict):
-    content: str
-    sections: List[Section]
-    completed_sections: Annotated[List, operator.add]
-    final_report: str
-
-class WorkerState(TypedDict):
-    section: Section
-    completed_sections: Annotated[List, operator.add]
-
-class ArticleScraperState(TypedDict):
-    url: str
-    article_content: str
 
-# Helper function to detect English language
-def is_english(text):
-    if not text or len(text.strip()) < 50:
-        return False
-        
+def is_english(text: str) -> bool:
+    """Check if the text is primarily in English by attempting ASCII encoding.
+    
+    Args:
+        text (str): Text to check.
+    Returns:
+        bool: True if text is English, False otherwise.
+    """
     try:
-        return detect(text) == 'en'
-    except:
+        text.encode('ascii')
+        return True
+    except UnicodeEncodeError:
         return False
 
-# News search functions
-def search_general_news(state: NewsState):
-    """Search for the latest news using Tavily based on the provided query."""
-    search_tool = TavilySearchResults(max_results=10)
-    
-    today = state.get("date", datetime.now().strftime("%Y-%m-%d"))
-    query = state.get("query", f"latest news {today} english")
+def search_news(state: NewsState) -> Dict[str, List[Dict[str, Any]]]:
+    """Search for news articles using Tavily based on the topic and date.
     
+    Args:
+        state (NewsState): State containing topic and date.
+    Returns:
+        dict: Dictionary with search results limited to 5 articles.
+    """
+    search_tool = TavilySearchResults(max_results=10)
+    query = f"latest {state['topic']} news {state['date']} english"
     search_results = search_tool.invoke({"query": query})
-    
-    filtered_results = []
-    for result in search_results:
-        if "youtube.com" not in result.get("url", "").lower():
-            content = result.get("content", "") + " " + result.get("title", "")
-            if is_english(content):
-                filtered_results.append(result)
-    
-    return {"search_results": filtered_results}
-
-def parse_news_items(state: NewsState):
-    """Parse search results into structured news items using a more robust approach"""
-    search_results = state["search_results"]
-    
-    formatted_results = "\n\n".join([
-        f"Title: {result.get('title', 'No title')}\n"
-        f"URL: {result.get('url', 'No URL')}\n"
-        f"Content: {result.get('content', 'No content')}"
-        for result in search_results
-    ])
-    
-    system_prompt = """
-    Extract news articles from these search results. Filter out any that aren't relevant.
-    
-    For each relevant news article, provide:
-    - title: The title of the article
-    - url: The URL of the article
-    - source: The source website of the news
-    - description: A brief description of the article
-    
-    Format your response as a JSON list of objects. Only include the relevant fields, nothing else.
+    # Filter out YouTube links and non-English content
+    filtered_results = [
+        result for result in search_results
+        if "youtube.com" not in result.get("url", "").lower()
+        and is_english(result.get("content", "") + " " + result.get("title", ""))
+    ]
+    return {"search_results": filtered_results[:5]}  # Limit to 5 for performance
+
+def scrape_article_content(url: str) -> str:
+    """Scrape article content from the URL with error handling and ethical practices.
+    
+    Args:
+        url (str): URL of the article to scrape.
+    Returns:
+        str: Scraped content or error message.
     """
-    
-    response = llm.invoke([
-        SystemMessage(content=system_prompt),
-        HumanMessage(content=f"Here are the search results:\n\n{formatted_results}")
-    ])
-    
-    response_text = response.content
-    json_match = re.search(r'\[\s*\{.*\}\s*\]', response_text, re.DOTALL)
-    
-    news_items = []
-    if json_match:
-        try:
-            news_items = json.loads(json_match.group(0))
-        except json.JSONDecodeError:
-            news_items = []
-    
-    return {"news_items": news_items}
-
-def scrape_article_content(state: ArticleScraperState):
-    """Scrape the content from a news article URL"""
-    url = state["url"]
-    
     try:
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        }
+        headers = {'User-Agent': 'NewsBlogGenerator/1.0 (https://example.com/bot)'}
         response = requests.get(url, headers=headers, timeout=10)
         response.raise_for_status()
-        
         soup = BeautifulSoup(response.text, 'html.parser')
-        
-        article_text = ""
-        article = soup.find('article')
-        if article:
-            paragraphs = article.find_all('p')
-        else:
-            paragraphs = soup.find_all('p')
-        
-        article_text = "\n\n".join([p.get_text().strip() for p in paragraphs])
-        article_text = re.sub(r'\s+', ' ', article_text).strip()
-        
-        if len(article_text) > 10000:
-            article_text = article_text[:10000] + "..."
-        
-        if not is_english(article_text[:500]):
-            return {"article_content": "Content not in English or insufficient text to analyze."}
-            
-        return {"article_content": article_text}
-    
+        paragraphs = soup.find_all('p')
+        article_text = " ".join([p.get_text().strip() for p in paragraphs])[:2000]  # Limit content length
+        if not article_text or not is_english(article_text[:500]):
+            return "Content unavailable or not in English."
+        time.sleep(1)  # Delay to respect server load
+        return article_text
     except Exception as e:
-        return {"article_content": f"Error scraping article: {str(e)}"}
+        print(f"Failed to scrape {url}: {e}")
+        return f"Scraping failed: {str(e)}"
 
-# Blog generation functions
-def orchestrator(state: BlogState):
-    """Orchestrator that generates a plan for the blog based on news items"""
-    
-    try:
-        content_lines = state['content'].split('\n\n')
-        news_items = []
-        current_item = {}
-        
-        for content_block in content_lines:
-            if content_block.startswith('TITLE:'):
-                if current_item and 'title' in current_item:
-                    news_items.append(current_item)
-                current_item = {}
-                
-                lines = content_block.split('\n')
-                for line in lines:
-                    if line.startswith('TITLE:'):
-                        current_item['title'] = line.replace('TITLE:', '').strip()
-                    elif line.startswith('SOURCE:'):
-                        current_item['source'] = line.replace('SOURCE:', '').strip()
-                    elif line.startswith('URL:'):
-                        current_item['url'] = line.replace('URL:', '').strip()
-                    elif line.startswith('DESCRIPTION:'):
-                        current_item['description'] = line.replace('DESCRIPTION:', '').strip()
-                    elif line.startswith('CONTENT:'):
-                        current_item['content'] = line.replace('CONTENT:', '').strip()
-            elif 'content' in current_item:
-                current_item['content'] += ' ' + content_block
-        
-        if current_item and 'title' in current_item:
-            news_items.append(current_item)
-        
-        sections = []
-        
-        # Create sections with subsections
-        for item in news_items:
-            title = item.get('title', '').lower()
-            description = item.get('description', '').lower()
-            section_name = "General News"
-            section_description = "Latest updates on various topics."
-            
-            subsections = [
-                Subsection(
-                    title=item['title'],
-                    source=item['source'],
-                    url=item['url'],
-                    content=f"{item.get('description', '')} {item.get('content', '')[:500]}..."
-                )
-            ]
-            
-            sections.append(Section(
-                name=section_name,
-                description=section_description,
-                information="Cover the latest developments in various topics.",
-                subsections=subsections
-            ))
-        
-        return {"sections": sections}
-    except Exception as e:
-        print(f"Error in orchestrator: {str(e)}")
-        return {"sections": []}
-
-def llm_call(state: WorkerState):
-    """Worker writes a section of the blog with subsections for each news item"""
-    
-    section = state['section']
-    
-    section_header = f"## {section.name}\n\n{section.description}\n"
-    
-    subsections_content = ""
-    if section.subsections:
-        for idx, subsection in enumerate(section.subsections):
-            subsection_prompt = f"""
-Write a detailed subsection about this news item:
-Title: {subsection.title}
-Source: {subsection.source}
-URL: {subsection.url}
-Content to summarize and expand on:
-{subsection.content}
-Keep your response focused on the news item and make it engaging. Use markdown formatting.
-"""
-            
-            subsection_content = llm.invoke([
-                SystemMessage(content="You are writing a subsection for a news blog. Write in a professional but engaging style. Include key details and insights. Use markdown formatting."),
-                HumanMessage(content=subsection_prompt)
-            ])
-            
-            formatted_subsection = f"### {subsection.title}\n\n"
-            formatted_subsection += f"*Source: [{subsection.source}]({subsection.url})*\n\n"
-            formatted_subsection += subsection_content.content
-            
-            subsections_content += formatted_subsection + "\n\n"
-    else:
-        section_content = llm.invoke([
-            SystemMessage(content="Write a blog section following the provided name, description, and information. Include no preamble. Use markdown formatting."),
-            HumanMessage(content=f"Here is the section name: {section.name}\nDescription: {section.description}\nInformation: {section.information}")
-        ])
-        subsections_content = section_content.content
-    
-    complete_section = section_header + subsections_content
-    
-    return {"completed_sections": [complete_section]}
-
-def synthesizer(state: BlogState):
-    """Synthesize full blog from sections with proper formatting and hierarchical TOC"""
-    
-    completed_sections = state["completed_sections"]
-    
-    completed_report = "\n\n".join(completed_sections)
-    
-    today = datetime.now().strftime("%Y-%m-%d")
-    blog_title = f"# News Roundup - {today}"
-    
-    intro = llm.invoke([
-        SystemMessage(content="Write a brief introduction for a news roundup blog post. Keep it under 100 words. Be engaging and professional."),
-        HumanMessage(content=f"Today's date is {today}. Write a brief introduction for a news roundup.")
-    ])
-    
-    table_of_contents = "## Table of Contents\n\n"
-    
-    section_matches = re.findall(r'## ([^\n]+)', completed_report)
-    
-    for i, section_name in enumerate(section_matches, 1):
-        section_anchor = section_name.lower().replace(' ', '-')
-        table_of_contents += f"{i}. [{section_name}](#{section_anchor})\n"
-        
-        section_start = completed_report.find(f"## {section_name}")
-        next_section_match = re.search(r'## ', completed_report[section_start+1:])
-        if next_section_match:
-            section_end = section_start + 1 + next_section_match.start()
-            section_text = completed_report[section_start:section_end]
-        else:
-            section_text = completed_report[section_start:]
-        
-        subsection_matches = re.findall(r'### ([^\n]+)', section_text)
-        
-        for j, subsection_name in enumerate(subsection_matches, 1):
-            subsection_anchor = subsection_name.lower().replace(' ', '-').replace(':', '').replace('?', '').replace('!', '').replace('.', '')
-            table_of_contents += f"   {i}.{j}. [{subsection_name}](#{subsection_anchor})\n"
-    
-    final_report = f"{blog_title}\n\n{intro.content}\n\n{table_of_contents}\n\n---\n\n{completed_report}\n\n---\n\n*This news roundup was automatically generated on {today}.*"
-    
-    return {"final_report": final_report}
-
-# Edge function to create workers for each section
-def assign_workers(state: BlogState):
-    """Assign a worker to each section in the plan"""
-    
-    return [Send("llm_call", {"section": s}) for s in state["sections"]]
-
-# Main workflow functions
-def create_news_search_workflow():
-    """Create a workflow for searching and parsing general news"""
-    workflow = StateGraph(NewsState)
-    
-    workflow.add_node("search_general_news", search_general_news)
-    workflow.add_node("parse_news_items", parse_news_items)
-    
-    workflow.add_edge(START, "search_general_news")
-    workflow.add_edge("search_general_news", "parse_news_items")
-    workflow.add_edge("parse_news_items", END)
-    
-    return workflow.compile()
-
-def create_article_scraper_workflow():
-    """Create a workflow for scraping article content"""
-    workflow = StateGraph(ArticleScraperState)
-    
-    workflow.add_node("scrape_article", scrape_article_content)
-    
-    workflow.add_edge(START, "scrape_article")
-    workflow.add_edge("scrape_article", END)
-    
-    return workflow.compile()
-
-def create_blog_generator_workflow():
-    """Create a workflow for generating the blog"""
-    workflow = StateGraph(BlogState)
-    
-    workflow.add_node("orchestrator", orchestrator)
-    workflow.add_node("llm_call", llm_call)
-    workflow.add_node("synthesizer", synthesizer)
-    
-    workflow.add_edge(START, "orchestrator")
-    workflow.add_conditional_edges("orchestrator", assign_workers, ["llm_call"])
-    workflow.add_edge("llm_call", "synthesizer")
-    workflow.add_edge("synthesizer", END)
-    
-    return workflow.compile()
-
-def generate_general_news_blog(groq_api_key=None, tavily_api_key=None, date=None, topic=None):
-    """Main function to generate news blog based on a specified topic."""
-    if groq_api_key:
-        os.environ["GROQ_API_KEY"] = groq_api_key
-    if tavily_api_key:
-        os.environ["TAVILY_API_KEY"] = tavily_api_key
-    
-    global llm
-    llm = ChatGroq(model="qwen-2.5-32b")
-    
-    if not date:
-        today = datetime.now().strftime("%Y-%m-%d")
-    else:
-        today = date
-    
-    query = f"latest {topic} news {today} english" if topic else f"latest news {today} english"
-    
-    news_search = create_news_search_workflow()
-    news_results = news_search.invoke({"query": query, "date": today})
-    
-    print(f"Found {len(news_results['news_items'])} news items")
-    
-    article_scraper = create_article_scraper_workflow()
-    news_contents = []
-    
-    for item in news_results["news_items"]:
-        print(f"Scraping: {item['title']} from {item['source']}")
-        result = article_scraper.invoke({"url": item['url']})
-        
-        if "not in English" in result["article_content"]:
-            print(f"Skipping non-English content: {item['title']}")
-            continue
-        
-        news_contents.append({
-            "title": item['title'],
-            "url": item['url'],
-            "source": item['source'],
-            "description": item['description'],
-            "content": result["article_content"]
-        })
+def generate_source_count_figure(news_contents: List[Dict[str, str]]):
+    """Generate a bar chart of news sources if content is available.
     
+    Args:
+        news_contents (List[Dict]): List of news items with source info.
+    Returns:
+        matplotlib.figure.Figure or None: Bar chart figure or None if no content.
+    """
     if not news_contents:
-        return "No English language news items found for the specified date. Please try a different date."
-        
-    formatted_content = "\n\n".join([f"TITLE: {item['title']}\nSOURCE: {item['source']}\nURL: {item['url']}\nDESCRIPTION: {item['description']}\nCONTENT: {item['content'][:2000]}..."
-        for item in news_contents
-    ])
-    
-    blog_generator = create_blog_generator_workflow()
-    blog_result = blog_generator.invoke({
-        "content": formatted_content,
-        "completed_sections": []
-    })
-    
-    return blog_result["final_report"]
-
-# Gradio UI
-def create_gradio_interface():
-    """Create a Gradio interface for the General News Blog Generator"""
+        return None
+    sources = [item['source'] for item in news_contents]
+    source_count = Counter(sources)
+    fig, ax = plt.subplots(figsize=(8, 4))
+    source_count_sorted = dict(sorted(source_count.items(), key=lambda x: x[1], reverse=True))
+    ax.bar(source_count_sorted.keys(), source_count_sorted.values())
+    ax.set_title("News Source Distribution")
+    plt.xticks(rotation=45, ha='right')
+    plt.tight_layout()
+    return fig
+
+def generate_sentiment_analysis_figure(news_contents: List[Dict[str, str]]):
+    """Generate a pie chart of sentiment distribution if content is available.
+    
+    Args:
+        news_contents (List[Dict]): List of news items with content.
+    Returns:
+        matplotlib.figure.Figure or None: Pie chart figure or None if no content.
+    """
+    if not news_contents:
+        return None
+    sentiments = []
+    for item in news_contents:
+        text = item['content'][:1000]  # Limit for performance
+        blob = TextBlob(text)
+        polarity = blob.sentiment.polarity
+        sentiment = "positive" if polarity > 0 else "negative" if polarity < 0 else "neutral"
+        sentiments.append(sentiment)
+    sentiment_count = Counter(sentiments)
+    fig, ax = plt.subplots()
+    ax.pie(sentiment_count.values(), labels=sentiment_count.keys(), autopct='%1.1f%%', startangle=90)
+    ax.set_title("Sentiment Analysis")
+    return fig
+
+def generate_word_cloud_figure(news_contents: List[Dict[str, str]]):
+    """Generate a word cloud from news content if content is available.
+    
+    Args:
+        news_contents (List[Dict]): List of news items with content.
+    Returns:
+        matplotlib.figure.Figure or None: Word cloud figure or None if no content.
+    """
+    if not news_contents:
+        return None
+    all_text = ' '.join([clean_text(item['content']) for item in news_contents])
+    stopwords = {"the", "and", "in", "to", "of", "is", "for", "with", "on", "that", "this", "are", "was", "be", "have", "it", "not", "they", "by", "from"}
+    wordcloud = WordCloud(width=800, height=400, background_color='white', 
+                          stopwords=stopwords, max_words=50, min_word_length=3).generate(all_text)
+    fig = plt.figure(figsize=(8, 4))
+    plt.imshow(wordcloud, interpolation='bilinear')
+    plt.axis("off")
+    return fig
+
+def clean_text(text: str) -> str:
+    """Clean text by removing punctuation and converting to lowercase.
+    
+    Args:
+        text (str): Text to clean.
+    Returns:
+        str: Cleaned text.
+    """
+    text = re.sub(r'[^\w\s]', '', text.lower())
+    return text
+
+def generate_blog(news_contents: List[Dict[str, str]], topic: str, date: str) -> str:
+    """Generate a Markdown blog post from the news contents.
+    
+    Args:
+        news_contents (List[Dict]): List of news items.
+        topic (str): Topic of the blog.
+        date (str): Date of the news.
+    Returns:
+        str: Markdown-formatted blog content.
+    """
+    if not news_contents:
+        return f"# No News Found\n\nSorry, no articles were found for '{topic}' on {date}."
+    blog = f"# Latest {topic.capitalize()} News - {date}\n\nHere’s a roundup of the latest in {topic}:\n\n"
+    for i, item in enumerate(news_contents, 1):
+        blog += f"### {i}. {item['title']}\n\n{item['content'][:500]}...\n\n[Read more]({item['url']})\n\n"
+    return blog
+
+def run_generation(groq_key: str, tavily_key: str, date: str, topic: str):
+    """Run the entire generation process: search, scrape, generate blog and visualizations.
+    
+    Args:
+        groq_key (str): Groq API key.
+        tavily_key (str): Tavily API key.
+        date (str): Date in YYYY-MM-DD format.
+        topic (str): Topic to search for.
+    Returns:
+        tuple: Blog content and three visualization figures.
+    """
+    # Set API keys in environment
+    os.environ["GROQ_API_KEY"] = groq_key
+    os.environ["TAVILY_API_KEY"] = tavily_key
     
-    def run_generation(groq_key, tavily_key, selected_date, topic):
-        if not groq_key or not tavily_key:
-            return "Please provide both API keys."
-        
-        try:
-            result = generate_general_news_blog(groq_key, tavily_key, selected_date, topic)
-            return result
-        except Exception as e:
-            return f"Error generating blog: {str(e)}"
+    # Initialize state
+    state = NewsState(topic=topic, date=date, search_results=[], news_items=[])
+    state.update(search_news(state))
     
-    with gr.Blocks(title="General News Blog Generator") as demo:
-        gr.Markdown("# General News Blog Generator")
-        gr.Markdown("Generate a daily roundup of news articles on various topics.")
-        
+    # Scrape content and filter successful results
+    news_contents = []
+    for item in state["search_results"]:
+        content = scrape_article_content(item["url"])
+        if "failed" not in content and "unavailable" not in content:
+            source = urlparse(item["url"]).netloc
+            news_contents.append({
+                "title": item.get("title", "Untitled"),
+                "url": item["url"],
+                "source": source,
+                "content": content
+            })
+    
+    # Generate outputs
+    blog_md = generate_blog(news_contents, topic, date)
+    source_fig = generate_source_count_figure(news_contents)
+    sentiment_fig = generate_sentiment_analysis_figure(news_contents)
+    wordcloud_fig = generate_word_cloud_figure(news_contents)
+    
+    return blog_md, source_fig, sentiment_fig, wordcloud_fig
+
+def create_interface():
+    """Create and return the Gradio interface."""
+    with gr.Blocks(title="News Blog Generator") as demo:
+        gr.Markdown("# News Blog Generator")
         with gr.Row():
             with gr.Column():
-                groq_key = gr.Textbox(label="Groq API Key", placeholder="Enter your Groq API key", type="password")
-                tavily_key = gr.Textbox(label="Tavily API Key", placeholder="Enter your Tavily API key", type="password")
-                date_picker = gr.Textbox(label="Date (YYYY-MM-DD)", placeholder="Leave empty for today's date", 
-                                        value=datetime.now().strftime("%Y-%m-%d"))
-                topic_input = gr.Textbox(label="Topic", placeholder="Enter a topic for news generation")
-                with gr.Row():
-                    generate_button = gr.Button("Generate News Blog", variant="primary")
-                    clear_button = gr.Button("Clear Output")
-            
+                groq_key = gr.Textbox(label="Groq API Key", type="password")
+                tavily_key = gr.Textbox(label="Tavily API Key", type="password")
+                date_picker = gr.Textbox(label="Date (YYYY-MM-DD)", value=datetime.now().strftime("%Y-%m-%d"))
+                topic_input = gr.Textbox(label="Topic", placeholder="e.g., AI, Blockchain")
+                generate_btn = gr.Button("Generate")
             with gr.Column():
-                status_text = gr.Textbox(label="Status", placeholder="Ready to generate", interactive=False)
-                output_md = gr.Markdown("Your news blog will appear here.")
-        
-        generate_button.click(
-            fn=lambda: "Generating News Blog... This may take several minutes.",
+                status = gr.Textbox(label="Status", value="Ready", interactive=False)
+                blog_output = gr.Markdown(label="Generated Blog")
+                source_plot = gr.Plot(label="Source Count")
+                sentiment_plot = gr.Plot(label="Sentiment Analysis")
+                wordcloud_plot = gr.Plot(label="Word Cloud")
+        # Chain events for progress feedback
+        generate_btn.click(
+            fn=lambda: "Searching and generating blog...",
             inputs=None,
-            outputs=status_text,
-            queue=False
+            outputs=status
         ).then(
             fn=run_generation,
             inputs=[groq_key, tavily_key, date_picker, topic_input],
-            outputs=output_md
+            outputs=[blog_output, source_plot, sentiment_plot, wordcloud_plot]
         ).then(
-            fn=lambda: "Blog generation complete!",
+            fn=lambda: "Generation complete!",
             inputs=None,
-            outputs=status_text
+            outputs=status
         )
-        
-        clear_button.click(
-            fn=lambda: ("Ready to generate", ""),
-            inputs=None,
-            outputs=[status_text, output_md]
-        )
-    
     return demo
 
-# Run the entire pipeline
 if __name__ == "__main__":
-    try:
-        demo = create_gradio_interface()
-        demo.launch()
-        
-    except Exception as e:
-        print(f"Error running the pipeline: {str(e)}")
+    interface = create_interface()
+    interface.launch()