Upload tool

app.py

@@ -0,0 +1,6 @@
+from smolagents import launch_gradio_demo
+from tool import SimpleTool
+
+tool = SimpleTool()
+
+launch_gradio_demo(tool)

requirements.txt

@@ -0,0 +1,4 @@
+bs4
+requests
+transformers
+smolagents

tool.py

@@ -0,0 +1,161 @@
+from smolagents import Tool
+from typing import Any, Optional
+
+class SimpleTool(Tool):
+    name = "analyze_content"
+    description = "Enhanced web content analyzer with multiple analysis modes."
+    inputs = {"input_text":{"type":"string","description":"URL or direct text to analyze."},"mode":{"type":"string","nullable":True,"description":"Analysis mode ('analyze', 'summarize', 'sentiment', 'topics')."}}
+    output_type = "string"
+
+    def forward(self, input_text: str, mode: str = "analyze") -> str:
+        """Enhanced web content analyzer with multiple analysis modes.
+
+        Args:
+            input_text: URL or direct text to analyze.
+            mode: Analysis mode ('analyze', 'summarize', 'sentiment', 'topics').
+
+        Returns:
+            str: JSON-formatted analysis results
+        """
+        import requests
+        from bs4 import BeautifulSoup
+        import re
+        from transformers import pipeline
+        import json
+
+        try:
+            # Setup request headers
+            headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
+
+            # Process input
+            if input_text.startswith(('http://', 'https://')):
+                response = requests.get(input_text, headers=headers, timeout=10)
+                soup = BeautifulSoup(response.text, 'html.parser')
+
+                # Clean page content
+                for tag in soup(['script', 'style', 'meta']):
+                    tag.decompose()
+
+                title = soup.title.string if soup.title else "No title found"
+                content = soup.get_text()
+            else:
+                title = "Text Analysis"
+                content = input_text
+
+            # Clean text
+            clean_text = re.sub(r'\s+', ' ', content).strip()
+
+            if len(clean_text) < 100:
+                return json.dumps({
+                    "status": "error",
+                    "message": "Content too short for analysis (minimum 100 characters)"
+                })
+
+            # Initialize models
+            summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
+            classifier = pipeline("text-classification", 
+                               model="nlptown/bert-base-multilingual-uncased-sentiment")
+
+            # Basic stats
+            stats = {
+                "title": title,
+                "characters": len(clean_text),
+                "words": len(clean_text.split()),
+                "paragraphs": len([p for p in clean_text.split("\n") if p.strip()]),
+                "reading_time": f"{len(clean_text.split()) // 200} minutes"
+            }
+
+            result = {"status": "success", "stats": stats}
+
+            # Mode-specific processing
+            if mode == "analyze":
+                # Get summary
+                summary = summarizer(clean_text[:1024], max_length=100, min_length=30)[0]['summary_text']
+
+                # Get overall sentiment
+                sentiment = classifier(clean_text[:512])[0]
+                score = int(sentiment['label'][0])
+                sentiment_text = ["Very Negative", "Negative", "Neutral", "Positive", "Very Positive"][score-1]
+
+                result.update({
+                    "summary": summary,
+                    "sentiment": {
+                        "overall": sentiment_text,
+                        "score": score,
+                        "confidence": f"{score/5*100:.1f}%"
+                    }
+                })
+
+            elif mode == "sentiment":
+                # Analyze paragraphs
+                paragraphs = [p for p in clean_text.split("\n") if len(p.strip()) > 50]
+                sentiments = []
+
+                for i, para in enumerate(paragraphs[:5]):
+                    sent = classifier(para[:512])[0]
+                    score = int(sent['label'][0])
+                    sentiments.append({
+                        "section": i + 1,
+                        "text": para[:100] + "...",
+                        "sentiment": ["Very Negative", "Negative", "Neutral", "Positive", "Very Positive"][score-1],
+                        "score": score
+                    })
+
+                result.update({
+                    "sentiment_analysis": {
+                        "sections": sentiments,
+                        "total_sections": len(sentiments)
+                    }
+                })
+
+            elif mode == "summarize":
+                # Process in chunks
+                chunks = [clean_text[i:i+1024] for i in range(0, min(len(clean_text), 3072), 1024)]
+                summaries = []
+
+                for chunk in chunks:
+                    if len(chunk) > 100:
+                        summary = summarizer(chunk, max_length=100, min_length=30)[0]['summary_text']
+                        summaries.append(summary)
+
+                result.update({
+                    "summaries": summaries,
+                    "chunks_analyzed": len(summaries)
+                })
+
+            elif mode == "topics":
+                # Basic topic categorization
+                categories = {
+                    "Technology": r"tech|software|hardware|digital|computer|AI|data",
+                    "Business": r"business|market|finance|economy|industry",
+                    "Science": r"science|research|study|discovery",
+                    "Health": r"health|medical|medicine|wellness",
+                    "General": r"news|world|people|life"
+                }
+
+                topic_scores = {}
+                for topic, pattern in categories.items():
+                    matches = len(re.findall(pattern, clean_text.lower()))
+                    topic_scores[topic] = matches
+
+                result.update({
+                    "topic_analysis": {
+                        "detected_topics": topic_scores,
+                        "primary_topic": max(topic_scores.items(), key=lambda x: x[1])[0]
+                    }
+                })
+
+            return json.dumps(result, indent=2)
+
+        except requests.exceptions.RequestException as e:
+            return json.dumps({
+                "status": "error",
+                "message": f"Failed to fetch content: {str(e)}",
+                "type": "request_error"
+            })
+        except Exception as e:
+            return json.dumps({
+                "status": "error",
+                "message": f"Analysis failed: {str(e)}",
+                "type": "general_error"
+            })