Initial commit with full functionality extend app req tools

Gradio_UI.py

@@ -1,157 +1,147 @@
 # Gradio_UI.py
 import gradio as gr
-from smolagents import CodeAgent
-from typing import Optional, List, Tuple
-import logging
-from bs4 import BeautifulSoup
 import requests
-import json
+from bs4 import BeautifulSoup
+import logging
+from typing import List, Tuple
 
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-class GradioUI:
-    def __init__(self, agent: CodeAgent):
+class WebAnalyzer:
+    def __init__(self, agent):
         self.agent = agent
 
-    def fetch_content(self, url: str) -> str:
-        """Fetch content from URL."""
+    def fetch_webpage(self, url: str) -> str:
+        """Fetch and extract text content from a webpage."""
         try:
-            response = requests.get(url)
+            response = requests.get(url, timeout=10)
             response.raise_for_status()
             soup = BeautifulSoup(response.text, 'html.parser')
-            return soup.get_text()
+            # Remove script and style elements
+            for script in soup(["script", "style"]):
+                script.decompose()
+            text = soup.get_text(separator='\n')
+            # Clean up whitespace
+            lines = (line.strip() for line in text.splitlines())
+            text = '\n'.join(line for line in lines if line)
+            return text
         except Exception as e:
-            logger.error(f"Error fetching URL: {str(e)}")
-            return f"Error fetching content: {str(e)}"
-
-    def analyze_content(self, content: str, analysis_types: List[str]) -> dict:
-        """Analyze the content based on selected analysis types."""
-        results = {
-            'clean_text': content[:1000] + '...' if len(content) > 1000 else content,
-            'summary': '',
-            'sentiment': '',
-            'topics': ''
-        }
+            logger.error(f"Error fetching webpage: {e}")
+            return f"Error: Failed to fetch webpage - {str(e)}"
 
-        try:
-            if 'summarize' in analysis_types:
-                results['summary'] = self.agent.run(f"Summarize this text: {content[:2000]}")
-            
-            if 'sentiment' in analysis_types:
-                results['sentiment'] = self.agent.run(f"Analyze the sentiment of this text: {content[:2000]}")
-            
-            if 'topics' in analysis_types:
-                results['topics'] = self.agent.run(f"Identify the main topics in this text: {content[:2000]}")
-        
-        except Exception as e:
-            logger.error(f"Error in analysis: {str(e)}")
-            return {
-                'error': str(e),
-                'clean_text': 'Analysis failed',
-                'summary': '',
-                'sentiment': '',
-                'topics': ''
-            }
-
-        return results
-
-    def process_url(self, url: str, analysis_types: List[str]) -> Tuple[str, str, str, str]:
-        """Process URL and return analysis results."""
+    def analyze_content(self, url: str, analysis_types: List[str]) -> Tuple[str, str, str, str]:
+        """Analyze webpage content based on selected analysis types."""
         try:
             # Fetch content
-            content = self.fetch_content(url)
-            
-            # Analyze content
-            results = self.analyze_content(content, analysis_types)
-            
-            # Return results for each tab
-            return (
-                results.get('clean_text', ''),
-                results.get('summary', ''),
-                results.get('sentiment', ''),
-                results.get('topics', '')
-            )
+            content = self.fetch_webpage(url)
+            if content.startswith("Error:"):
+                return content, "", "", ""
+
+            # Initialize results
+            clean_text = content[:2000] + "..." if len(content) > 2000 else content
+            summary = ""
+            sentiment = ""
+            topics = ""
+
+            # Perform selected analyses
+            if "summarize" in analysis_types:
+                summary = self.agent.run(f"Please summarize this text concisely: {clean_text}")
+
+            if "sentiment" in analysis_types:
+                sentiment = self.agent.run(f"Analyze the sentiment of this text: {clean_text}")
+
+            if "topics" in analysis_types:
+                topics = self.agent.run(f"Identify and list the main topics in this text: {clean_text}")
+
+            return clean_text, summary, sentiment, topics
+
         except Exception as e:
-            error_msg = f"Error: {str(e)}"
-            return error_msg, error_msg, error_msg, error_msg
+            error_msg = f"Error during analysis: {str(e)}"
+            logger.error(error_msg)
+            return error_msg, "", "", ""
 
-    def launch(self, 
-               server_name: Optional[str] = None,
-               server_port: Optional[int] = None,
-               share: bool = False):
-        """Launch the Gradio interface."""
+class GradioUI:
+    def __init__(self, agent):
+        self.analyzer = WebAnalyzer(agent)
+
+    def create_interface(self):
+        """Create the Gradio interface."""
+        # Create interface components
+        url_input = gr.Textbox(
+            label="Enter URL",
+            placeholder="https://example.com"
+        )
         
-        with gr.Blocks(title="Smart Web Analyzer Plus") as demo:
-            # Header
-            gr.Markdown("# 🌐 Smart Web Analyzer Plus")
+        analysis_types = gr.CheckboxGroup(
+            choices=["summarize", "sentiment", "topics"],
+            value=["summarize"],
+            label="Analysis Types"
+        )
+
+        # Create output components
+        with gr.Blocks() as demo:
+            gr.Markdown("# Smart Web Analyzer Plus")
             gr.Markdown("Analyze web content using AI to extract summaries, determine sentiment, and identify topics.")
-            
-            # Input section
+
             with gr.Row():
-                url_input = gr.Textbox(
-                    label="Enter URL",
-                    placeholder="https://example.com",
-                    scale=3
-                )
-                analysis_types = gr.CheckboxGroup(
-                    choices=["summarize", "sentiment", "topics"],
-                    value=["summarize"],
-                    label="Analysis Types",
-                    scale=2
-                )
-                analyze_btn = gr.Button(
-                    "Analyze",
-                    variant="primary",
-                    scale=1
-                )
-            
-            # Progress indicator
-            progress = gr.Markdown(visible=False)
-            
-            # Results section - using a single Tabs component
-            with gr.Tabs() as output_tabs:
-                with gr.Tab("Clean Text", id="clean_text"):
+                with gr.Column(scale=4):
+                    url_input.render()
+                with gr.Column(scale=2):
+                    analysis_types.render()
+                with gr.Column(scale=1):
+                    analyze_button = gr.Button("Analyze", variant="primary")
+
+            # Status indicator
+            status = gr.Markdown(visible=False)
+
+            # Output tabs
+            with gr.Tabs():
+                with gr.Tab("Clean Text"):
                     clean_text_output = gr.Markdown()
-                with gr.Tab("Summary", id="summary"):
+                with gr.Tab("Summary"):
                     summary_output = gr.Markdown()
-                with gr.Tab("Sentiment", id="sentiment"):
+                with gr.Tab("Sentiment"):
                     sentiment_output = gr.Markdown()
-                with gr.Tab("Topics", id="topics"):
+                with gr.Tab("Topics"):
                     topics_output = gr.Markdown()
-            
+
             # Examples
             gr.Examples(
                 examples=[
                     ["https://www.bbc.com/news/technology-67881954", ["summarize", "sentiment"]],
                     ["https://arxiv.org/html/2312.17296v1", ["topics", "summarize"]]
                 ],
-                inputs=[url_input, analysis_types]
+                inputs=[url_input, analysis_types],
             )
-            
+
             # Event handlers
-            def show_progress():
-                return gr.update(value="⏳ Analysis in progress...", visible=True)
-            
-            def hide_progress():
-                return gr.update(value="", visible=False)
-            
-            # Connect the button click event
-            analyze_btn.click(
-                fn=show_progress,
-                outputs=progress
+            def on_analyze_click(url, types):
+                if not url:
+                    return "Please enter a URL", "", "", ""
+                if not types:
+                    return "Please select at least one analysis type", "", "", ""
+                return self.analyzer.analyze_content(url, types)
+
+            analyze_button.click(
+                fn=lambda: gr.Markdown("⏳ Analysis in progress...", visible=True),
+                outputs=[status]
             ).then(
-                fn=self.process_url,
+                fn=on_analyze_click,
                 inputs=[url_input, analysis_types],
                 outputs=[clean_text_output, summary_output, sentiment_output, topics_output]
             ).then(
-                fn=hide_progress,
-                outputs=progress
+                fn=lambda: gr.Markdown("", visible=False),
+                outputs=[status]
             )
-        
-        # Launch the interface
+
+        return demo
+
+    def launch(self, server_name=None, server_port=None, share=False):
+        """Launch the Gradio interface."""
+        demo = self.create_interface()
         demo.launch(
             server_name=server_name,
             server_port=server_port,
-            share=share,
-            debug=True
+            share=share
         )

app.py

@@ -1,32 +1,18 @@
 # app.py
 from smolagents import CodeAgent, HfApiModel
-from tools.final_answer import FinalAnswerTool
-import yaml
-from Gradio_UI import GradioUI
 import logging
-import sys
+from Gradio_UI import GradioUI
 
 # Configure logging
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(sys.stdout),
-        logging.FileHandler('app.log')
-    ]
+    format='%(asctime)s - %(levelname)s - %(message)s'
 )
 logger = logging.getLogger(__name__)
 
 def create_agent():
     """Create and configure the agent."""
     try:
-        # Initialize tools
-        final_answer = FinalAnswerTool()
-        
-        # Load prompts
-        with open("prompts.yaml", 'r', encoding='utf-8') as stream:
-            prompt_templates = yaml.safe_load(stream)
-        
         # Initialize model
         model = HfApiModel(
             model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
@@ -34,16 +20,14 @@ def create_agent():
             temperature=0.5
         )
         
-        # Create agent
+        # Create agent with simple configuration
         return CodeAgent(
             model=model,
-            tools=[final_answer],
-            max_steps=6,
-            verbosity_level=1,
-            prompt_templates=prompt_templates
+            max_steps=3,
+            verbosity_level=1
         )
     except Exception as e:
-        logger.error(f"Failed to create agent: {str(e)}")
+        logger.error(f"Failed to create agent: {e}")
         raise
 
 def main():
@@ -59,12 +43,11 @@ def main():
         ui = GradioUI(agent)
         ui.launch(
             server_name="0.0.0.0",
-            server_port=7860,
-            share=False
+            server_port=7860
         )
     except Exception as e:
-        logger.error(f"Application failed to start: {str(e)}")
-        sys.exit(1)
+        logger.error(f"Application failed to start: {e}")
+        raise
 
 if __name__ == "__main__":
     main()

requirements.txt

@@ -1,20 +1,6 @@
 # requirements.txt
-smolagents>=0.2.0
 gradio>=4.0.0
 requests>=2.31.0
-pytz>=2023.3
-pyyaml>=6.0.1
-python-dotenv>=1.0.0
 beautifulsoup4>=4.12.2
-numpy>=1.24.3
-pandas>=2.0.3
-scikit-learn>=1.3.0
-nltk>=3.8.1
-spacy>=3.7.2
-transformers>=4.35.0
-torch>=2.0.1
-tqdm>=4.65.0
-validators>=0.22.0
-aiohttp>=3.8.5
-cachetools>=5.3.1
-python-dateutil>=2.8.2
+smolagents>=0.2.0
+python-dotenv>=1.0.0