Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import requests | |
| import time | |
| from bs4 import BeautifulSoup | |
| from transformers import pipeline | |
| import PyPDF2 | |
| import docx | |
| import os | |
| from typing import List, Optional | |
| class ContentAnalyzer: | |
| def __init__(self): | |
| print("[DEBUG] Initializing pipelines...") | |
| self.summarizer = pipeline("summarization", model="facebook/bart-large-cnn") | |
| self.sentiment_analyzer = pipeline("sentiment-analysis") | |
| self.zero_shot = pipeline("zero-shot-classification") | |
| print("[DEBUG] Pipelines initialized.") | |
| def read_file(self, file_obj) -> str: | |
| """Read content from different file types.""" | |
| if file_obj is None: | |
| return "" | |
| file_ext = os.path.splitext(file_obj.name)[1].lower() | |
| print(f"[DEBUG] File extension: {file_ext}") | |
| try: | |
| if file_ext == '.txt': | |
| return file_obj.read().decode('utf-8') | |
| elif file_ext == '.pdf': | |
| pdf_reader = PyPDF2.PdfReader(file_obj) | |
| text = "" | |
| for page in pdf_reader.pages: | |
| text += page.extract_text() + "\n" | |
| return text | |
| elif file_ext == '.docx': | |
| doc = docx.Document(file_obj) | |
| return "\n".join([paragraph.text for paragraph in doc.paragraphs]) | |
| else: | |
| return f"Unsupported file type: {file_ext}" | |
| except Exception as e: | |
| return f"Error reading file: {str(e)}" | |
| def fetch_web_content(self, url: str) -> str: | |
| """Fetch content from URL.""" | |
| print(f"[DEBUG] Attempting to fetch URL: {url}") | |
| try: | |
| response = requests.get(url, timeout=10) | |
| response.raise_for_status() | |
| soup = BeautifulSoup(response.text, 'html.parser') | |
| # Remove scripts and styles | |
| for script in soup(["script", "style"]): | |
| script.decompose() | |
| text = soup.get_text(separator='\n') | |
| lines = (line.strip() for line in text.splitlines()) | |
| final_text = "\n".join(line for line in lines if line) | |
| return final_text | |
| except Exception as e: | |
| return f"Error fetching URL: {str(e)}" | |
| def analyze_content( | |
| self, | |
| content: str, | |
| analysis_types: List[str], | |
| ) -> dict: | |
| """Perform summarization, sentiment analysis, and topic detection on `content`.""" | |
| results = {} | |
| truncated = content[:1000] + "..." if len(content) > 1000 else content | |
| results["original_text"] = truncated | |
| # Summarize | |
| if "summarize" in analysis_types: | |
| summary = self.summarizer(content[:1024], max_length=130, min_length=30) | |
| results["summary"] = summary[0]['summary_text'] | |
| # Sentiment | |
| if "sentiment" in analysis_types: | |
| sentiment = self.sentiment_analyzer(content[:512]) | |
| results["sentiment"] = { | |
| "label": sentiment[0]['label'], | |
| "score": round(sentiment[0]['score'], 3) | |
| } | |
| # Topics | |
| if "topics" in analysis_types: | |
| topics = self.zero_shot( | |
| content[:512], | |
| candidate_labels=[ | |
| "technology", "science", "business", "politics", | |
| "entertainment", "education", "health", "sports" | |
| ] | |
| ) | |
| results["topics"] = [ | |
| {"label": label, "score": round(score, 3)} | |
| for label, score in zip(topics['labels'], topics['scores']) | |
| if score > 0.1 | |
| ] | |
| return results | |
| def create_interface(): | |
| analyzer = ContentAnalyzer() | |
| with gr.Blocks(title="Content Analyzer") as demo: | |
| gr.Markdown("# 📑 Content Analyzer") | |
| gr.Markdown( | |
| "Analyze text from **Text**, **URL**, or **File** with summarization, " | |
| "sentiment, and topic detection. A progress bar will appear during processing." | |
| ) | |
| # Dropdown for input type | |
| input_choice = gr.Dropdown( | |
| choices=["Text", "URL", "File"], | |
| value="Text", | |
| label="Select Input Type" | |
| ) | |
| # We use three separate columns to conditionally display | |
| with gr.Column(visible=True) as text_col: | |
| text_input = gr.Textbox( | |
| label="Enter Text", | |
| placeholder="Paste your text here...", | |
| lines=5 | |
| ) | |
| with gr.Column(visible=False) as url_col: | |
| url_input = gr.Textbox( | |
| label="Enter URL", | |
| placeholder="https://example.com" | |
| ) | |
| with gr.Column(visible=False) as file_col: | |
| file_input = gr.File( | |
| label="Upload File", | |
| file_types=[".txt", ".pdf", ".docx"] | |
| ) | |
| def show_inputs(choice): | |
| """Return a dict mapping columns to booleans for visibility.""" | |
| return { | |
| text_col: choice == "Text", | |
| url_col: choice == "URL", | |
| file_col: choice == "File" | |
| } | |
| input_choice.change( | |
| fn=show_inputs, | |
| inputs=[input_choice], | |
| outputs=[text_col, url_col, file_col] | |
| ) | |
| analysis_types = gr.CheckboxGroup( | |
| choices=["summarize", "sentiment", "topics"], | |
| value=["summarize"], | |
| label="Analysis Types" | |
| ) | |
| analyze_btn = gr.Button("Analyze", variant="primary") | |
| # Output tabs | |
| with gr.Tabs(): | |
| with gr.Tab("Original Text"): | |
| original_text = gr.Markdown() | |
| with gr.Tab("Summary"): | |
| summary_output = gr.Markdown() | |
| with gr.Tab("Sentiment"): | |
| sentiment_output = gr.Markdown() | |
| with gr.Tab("Topics"): | |
| topics_output = gr.Markdown() | |
| def process_analysis(choice, text_val, url_val, file_val, types): | |
| """ | |
| This function does everything in one place using a 'with gr.Progress() as p:' block, | |
| so we can show each step of the process. We add time.sleep(1) just to demonstrate | |
| the progress bar (otherwise it may appear/disappear too quickly). | |
| """ | |
| with gr.Progress() as p: | |
| # STEP 1: Retrieve content | |
| p(0, total=4, desc="Reading input") | |
| time.sleep(1) # For demonstration | |
| if choice == "Text": | |
| content = text_val or "" | |
| elif choice == "URL": | |
| content = analyzer.fetch_web_content(url_val or "") | |
| else: # File | |
| content = analyzer.read_file(file_val) | |
| if not content or content.startswith("Error"): | |
| return content or "No content provided", "", "", "" | |
| # STEP 2: Summarize | |
| p(1, total=4, desc="Summarizing content") | |
| time.sleep(1) # For demonstration | |
| # STEP 3: Sentiment | |
| p(2, total=4, desc="Performing sentiment analysis") | |
| time.sleep(1) # For demonstration | |
| # STEP 4: Topics | |
| p(3, total=4, desc="Identifying topics") | |
| time.sleep(1) # For demonstration | |
| # After the progress steps, do the actual analysis in one shot | |
| # (You could interleave the calls to pipeline with each progress step | |
| # if you want real-time progress. This is a simplified approach.) | |
| results = analyzer.analyze_content(content, types) | |
| if "error" in results: | |
| return results["error"], "", "", "" | |
| original = results.get("original_text", "") | |
| summary = results.get("summary", "") | |
| sentiment = "" | |
| if "sentiment" in results: | |
| s = results["sentiment"] | |
| sentiment = f"**Sentiment:** {s['label']} (Confidence: {s['score']})" | |
| topics = "" | |
| if "topics" in results: | |
| t_list = "\n".join([ | |
| f"- {t['label']}: {t['score']}" | |
| for t in results["topics"] | |
| ]) | |
| topics = "**Detected Topics:**\n" + t_list | |
| return original, summary, sentiment, topics | |
| analyze_btn.click( | |
| fn=process_analysis, | |
| inputs=[input_choice, text_input, url_input, file_input, analysis_types], | |
| outputs=[original_text, summary_output, sentiment_output, topics_output], | |
| show_progress=True # This ensures the Gradio progress bar is enabled | |
| ) | |
| return demo | |
| if __name__ == "__main__": | |
| demo = create_interface() | |
| demo.launch() | |