Initial commit with full functionality extend app req

app.py

@@ -1,154 +1,79 @@
 # app.py
-import gradio as gr
-from smart_web_analyzer import WebAnalyzer
-from typing import Dict, List, Any
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
+import datetime
+import requests
+import pytz
+import yaml
+from tools.final_answer import FinalAnswerTool
+from Gradio_UI import GradioUI
 
-analyzer = WebAnalyzer()
+# Helper function for text extraction
+def extract_text_tool(url: str) -> str:
+    """A tool that extracts clean text content from a webpage
+    Args:
+        url: The URL of the webpage to analyze
+    """
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        return response.text
+    except Exception as e:
+        return f"Error extracting text: {str(e)}"
 
-def format_results(results: Dict[str, Any]) -> Dict[str, str]:
-    """Format analysis results for Gradio components"""
-    if 'error' in results:
-        error_msg = f"❌ Error: {results['error']}"
-        return {
-            "clean_text": error_msg,
-            "summary": error_msg,
-            "sentiment": error_msg,
-            "topics": error_msg
-        }
-    
-    formatted = {}
-    
-    # Format clean text
-    text = results.get('clean_text', 'No text extracted')
-    formatted["clean_text"] = text[:2000] + "..." if len(text) > 2000 else text
-    
-    # Format summary
-    formatted["summary"] = (
-        f"**AI Summary:**\n{results['summary']}"
-        if 'summary' in results else "No summary requested"
-    )
-    
-    # Format sentiment
-    formatted["sentiment"] = (
-        f"**Sentiment Analysis:**\n{results['sentiment']}"
-        if 'sentiment' in results else "No sentiment analysis requested"
-    )
-    
-    # Format topics
-    if 'topics' in results:
-        topics_list = sorted(
-            results['topics'].items(),
-            key=lambda x: x[1],
-            reverse=True
-        )
-        topics_text = "\n".join(
-            f"- **{topic}**: {score:.1%}" 
-            for topic, score in topics_list
-        )
-        formatted["topics"] = f"**Detected Topics:**\n{topics_text}"
-    else:
-        formatted["topics"] = "No topic analysis requested"
-    
-    return formatted
+# Time zone tool from the example
+def get_current_time_in_timezone(timezone: str) -> str:
+    """A tool that fetches the current local time in a specified timezone.
+    Args:
+        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+    """
+    try:
+        tz = pytz.timezone(timezone)
+        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        return f"The current local time in {timezone} is: {local_time}"
+    except Exception as e:
+        return f"Error fetching time for timezone '{timezone}': {str(e)}"
 
-def validate_url(url: str) -> bool:
-    """Basic URL validation"""
-    return bool(url and url.strip().startswith(('http://', 'https://')))
+# Initialize components
+final_answer = FinalAnswerTool()
+search_tool = DuckDuckGoSearchTool()
 
-def update_button_state(url: str) -> Dict:
-    """Update button state based on URL validity"""
-    return gr.update(interactive=validate_url(url))
+# Setup the model
+model = HfApiModel(
+    max_tokens=2096,
+    temperature=0.5,
+    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
+    custom_role_conversions=None,
+)
 
-with gr.Blocks(title="Smart Web Analyzer Plus", theme=gr.themes.Soft()) 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",
-                interactive=False
-            )
-    
-    # Content display
-    clean_text_out = gr.Markdown(visible=True, label="Clean Text")
-    summary_out = gr.Markdown(visible=True, label="Summary")
-    sentiment_out = gr.Markdown(visible=True, label="Sentiment")
-    topics_out = gr.Markdown(visible=True, label="Topics")
-    
-    with gr.Tabs() as tabs:
-        with gr.Tab("📄 Clean Text"):
-            clean_text_out
-        with gr.Tab("📝 Summary"):
-            summary_out
-        with gr.Tab("🎭 Sentiment"):
-            sentiment_out
-        with gr.Tab("📊 Topics"):
-            topics_out
-    
-    # Loading indicator
-    status = gr.Markdown(visible=False)
-    
-    # Example Section
-    gr.Examples(
-        label="Try these examples",
-        examples=[
-            ["https://www.bbc.com/news/technology-67881954", ["summarize", "sentiment"]],
-            ["https://arxiv.org/html/2312.17296v1", ["topics", "summarize"]]
-        ],
-        inputs=[url_input, analysis_types]
-    )
-    
-    # Event Handlers
-    url_input.change(
-        fn=update_button_state,
-        inputs=[url_input],
-        outputs=[analyze_btn],
-        queue=False
-    )
-    
-    def on_analyze_start():
-        return gr.update(value="⏳ Analysis in progress...", visible=True)
-    
-    def on_analyze_end():
-        return gr.update(value="", visible=False)
-    
-    analyze_btn.click(
-        fn=on_analyze_start,
-        outputs=[status],
-        queue=False
-    ).then(
-        fn=lambda url, m: format_results(analyzer.analyze(url, m)),
-        inputs=[url_input, analysis_types],
-        outputs=[
-            clean_text_out,
-            summary_out,
-            sentiment_out,
-            topics_out
-        ]
-    ).then(
-        fn=on_analyze_end,
-        outputs=[status]
-    )
+# Import image generation tool
+image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
+# Load prompt templates
+with open("prompts.yaml", 'r') as stream:
+    prompt_templates = yaml.safe_load(stream)
+
+# Create the agent with all tools
+agent = CodeAgent(
+    model=model,
+    tools=[
+        final_answer,
+        search_tool,  # For web search
+        tool(extract_text_tool),  # For text extraction
+        tool(get_current_time_in_timezone),  # For timezone checks
+        image_generation_tool  # For image generation
+    ],
+    max_steps=6,
+    verbosity_level=1,
+    grammar=None,
+    planning_interval=None,
+    name="Web Analyzer Agent",
+    description="An agent that analyzes web content using various tools",
+    prompt_templates=prompt_templates
+)
+
+# Launch the Gradio interface
 if __name__ == "__main__":
-    demo.launch(
+    GradioUI(agent).launch(
         server_name="0.0.0.0",
         server_port=7860
     )

requirements.txt

@@ -1,7 +1,5 @@
-# requirements.txt
-gradio>=4.0.0
-beautifulsoup4>=4.12.0
-requests>=2.31.0
-transformers>=4.40.0
-torch>=2.2.0
-requests
+smolagents
+gradio
+requests
+pytz
+pyyaml