Initial commit with full functionality extend app req tools

Gradio_UI.py

@@ -1,164 +1,122 @@
 # Gradio_UI.py
 import gradio as gr
 from smolagents import CodeAgent
-from typing import Optional, Dict, List, Tuple
-import re
+from typing import Optional, List, Tuple
 import logging
-from functools import lru_cache
+from bs4 import BeautifulSoup
+import requests
 import json
-from datetime import datetime
-import time
 
 logger = logging.getLogger(__name__)
 
 class GradioUI:
     def __init__(self, agent: CodeAgent):
         self.agent = agent
-        self.cache = {}
-        self.rate_limit = {}
 
-    def validate_url(self, url: str) -> bool:
-        """Validate URL format."""
-        url_pattern = re.compile(
-            r'^https?://'
-            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|'
-            r'localhost|'
-            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'
-            r'(?::\d+)?'
-            r'(?:/?|[/?]\S+)$', re.IGNORECASE)
-        return bool(url_pattern.match(url))
-
-    def check_rate_limit(self, url: str) -> bool:
-        """Check if URL has been requested too frequently."""
-        current_time = time.time()
-        if url in self.rate_limit:
-            last_request = self.rate_limit[url]
-            if current_time - last_request < 60:  # 1 minute cooldown
-                return False
-        self.rate_limit[url] = current_time
-        return True
-
-    @lru_cache(maxsize=100)
-    def get_cached_analysis(self, url: str, analysis_types: tuple) -> Optional[Dict]:
-        """Get cached analysis results if available."""
-        cache_key = f"{url}_{','.join(analysis_types)}"
-        return self.cache.get(cache_key)
-
-    def store_cache(self, url: str, analysis_types: List[str], results: Dict):
-        """Store analysis results in cache."""
-        cache_key = f"{url}_{','.join(analysis_types)}"
-        self.cache[cache_key] = {
-            'results': results,
-            'timestamp': datetime.now().isoformat()
+    def fetch_content(self, url: str) -> str:
+        """Fetch content from URL."""
+        try:
+            response = requests.get(url)
+            response.raise_for_status()
+            soup = BeautifulSoup(response.text, 'html.parser')
+            return soup.get_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': ''
         }
 
-    def process_query(self, url: str, analysis_types: List[str]) -> Tuple[str, str, str, str]:
-        """Process the analysis query and return results for all output tabs."""
         try:
-            # Input validation
-            if not url:
-                raise ValueError("Please enter a URL")
-            if not self.validate_url(url):
-                raise ValueError("Invalid URL format")
-            if not self.check_rate_limit(url):
-                raise ValueError("Please wait before analyzing this URL again")
-
-            # Check cache
-            cached = self.get_cached_analysis(url, tuple(analysis_types))
-            if cached:
-                logger.info(f"Returning cached results for {url}")
-                results = cached['results']
-                return (
-                    results.get('clean_text', ''),
-                    results.get('summary', ''),
-                    results.get('sentiment', ''),
-                    results.get('topics', '')
-                )
-
-            # Create analysis prompt
-            prompt = self.create_analysis_prompt(url, analysis_types)
+            if 'summarize' in analysis_types:
+                results['summary'] = self.agent.run(f"Summarize this text: {content[:2000]}")
             
-            # Run analysis
-            response = self.agent.run(prompt)
+            if 'sentiment' in analysis_types:
+                results['sentiment'] = self.agent.run(f"Analyze the sentiment of this text: {content[:2000]}")
             
-            # Parse response
-            try:
-                results = json.loads(response) if isinstance(response, str) else response
-            except json.JSONDecodeError:
-                results = {
-                    'clean_text': response,
-                    'summary': '',
-                    'sentiment': '',
-                    'topics': ''
-                }
-
-            # Cache results
-            self.store_cache(url, analysis_types, results)
-
+            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."""
+        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', '')
             )
-
         except Exception as e:
-            logger.error(f"Error processing query: {str(e)}")
-            error_msg = f"⚠️ Error: {str(e)}"
+            error_msg = f"Error: {str(e)}"
             return error_msg, error_msg, error_msg, error_msg
 
-    def create_analysis_prompt(self, url: str, types: List[str]) -> str:
-        """Create the analysis prompt based on selected types."""
-        if not types:
-            types = ["summarize"]  # Default analysis type
-        type_str = ", ".join(types)
-        return f"Analyze the content at {url} and provide the following analysis: {type_str}. Return results in JSON format with keys: clean_text, summary, sentiment, topics."
-
     def launch(self, 
                server_name: Optional[str] = None,
                server_port: Optional[int] = None,
                share: bool = False):
         """Launch the Gradio interface."""
         
-        # Create the interface
-        with gr.Blocks(title="Smart Web Analyzer Plus", theme=gr.themes.Soft()) as demo:
+        with gr.Blocks(title="Smart Web Analyzer Plus") as demo:
             # Header
             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():
-                with gr.Column(scale=3):
-                    url_input = gr.Textbox(
-                        label="Enter URL",
-                        placeholder="https://example.com",
-                        show_label=True
-                    )
-                with gr.Column(scale=2):
-                    analysis_types = gr.CheckboxGroup(
-                        choices=["summarize", "sentiment", "topics"],
-                        label="Analysis Types",
-                        value=["summarize"],
-                        show_label=True
-                    )
-                with gr.Column(scale=1):
-                    analyze_btn = gr.Button(
-                        "Analyze",
-                        variant="primary"
-                    )
+                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
+                )
             
-            # Status indicator
-            status = gr.Markdown(visible=False)
+            # Progress indicator
+            progress = gr.Markdown(visible=False)
             
-            # Output tabs
-            with gr.Tabs() as tabs:
-                with gr.TabItem("📄 Clean Text"):
+            # Results section - using a single Tabs component
+            with gr.Tabs() as output_tabs:
+                with gr.Tab("Clean Text", id="clean_text"):
                     clean_text_output = gr.Markdown()
-                with gr.TabItem("📝 Summary"):
+                with gr.Tab("Summary", id="summary"):
                     summary_output = gr.Markdown()
-                with gr.TabItem("🎭 Sentiment"):
+                with gr.Tab("Sentiment", id="sentiment"):
                     sentiment_output = gr.Markdown()
-                with gr.TabItem("📊 Topics"):
+                with gr.Tab("Topics", id="topics"):
                     topics_output = gr.Markdown()
             
             # Examples
@@ -167,33 +125,33 @@ class GradioUI:
                     ["https://www.bbc.com/news/technology-67881954", ["summarize", "sentiment"]],
                     ["https://arxiv.org/html/2312.17296v1", ["topics", "summarize"]]
                 ],
-                inputs=[url_input, analysis_types],
-                label="Try these examples"
+                inputs=[url_input, analysis_types]
             )
             
             # Event handlers
-            def on_analyze_click():
+            def show_progress():
                 return gr.update(value="⏳ Analysis in progress...", visible=True)
-
-            def on_analyze_complete():
+            
+            def hide_progress():
                 return gr.update(value="", visible=False)
-
+            
+            # Connect the button click event
             analyze_btn.click(
-                fn=on_analyze_click,
-                outputs=[status],
-                queue=False
+                fn=show_progress,
+                outputs=progress
             ).then(
-                fn=self.process_query,
+                fn=self.process_url,
                 inputs=[url_input, analysis_types],
                 outputs=[clean_text_output, summary_output, sentiment_output, topics_output]
             ).then(
-                fn=on_analyze_complete,
-                outputs=[status]
+                fn=hide_progress,
+                outputs=progress
             )
         
         # Launch the interface
         demo.launch(
             server_name=server_name,
             server_port=server_port,
-            share=share
+            share=share,
+            debug=True
         )

app.py

@@ -4,31 +4,37 @@ from tools.final_answer import FinalAnswerTool
 import yaml
 from Gradio_UI import GradioUI
 import logging
+import sys
 
 # Configure logging
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler('app.log')
+    ]
 )
 logger = logging.getLogger(__name__)
 
 def create_agent():
+    """Create and configure the agent."""
     try:
-        # Initialize the final answer tool
+        # Initialize tools
         final_answer = FinalAnswerTool()
         
-        # Load prompt templates
+        # Load prompts
         with open("prompts.yaml", 'r', encoding='utf-8') as stream:
             prompt_templates = yaml.safe_load(stream)
         
-        # Create the model
+        # Initialize model
         model = HfApiModel(
             model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
             max_tokens=2096,
             temperature=0.5
         )
         
-        # Create and return the agent
+        # Create agent
         return CodeAgent(
             model=model,
             tools=[final_answer],
@@ -37,25 +43,28 @@ def create_agent():
             prompt_templates=prompt_templates
         )
     except Exception as e:
-        logger.error(f"Error creating agent: {str(e)}")
+        logger.error(f"Failed to create agent: {str(e)}")
         raise
 
 def main():
+    """Main application entry point."""
     try:
-        # Create and launch the agent
-        logger.info("Initializing Smart Web Analyzer Plus...")
+        logger.info("Starting Smart Web Analyzer Plus...")
+        
+        # Create agent
         agent = create_agent()
+        logger.info("Agent created successfully")
         
-        # Initialize and launch UI
+        # Create and launch UI
         ui = GradioUI(agent)
         ui.launch(
             server_name="0.0.0.0",
             server_port=7860,
-            share=False  # Set to True if you want to share publicly
+            share=False
         )
     except Exception as e:
-        logger.error(f"Application startup failed: {str(e)}")
-        raise
+        logger.error(f"Application failed to start: {str(e)}")
+        sys.exit(1)
 
 if __name__ == "__main__":
     main()