changes to app

app.py

@@ -1,333 +1,327 @@
 import json
 import gradio as gr
 from textblob import TextBlob
-from typing import Dict, Any, List
-import asyncio
+import os
 
-class SentimentMCPServer:
-    """MCP Server for Sentiment Analysis using TextBlob"""
-    
-    def __init__(self):
-        self.name = "sentiment-analyzer"
-        self.version = "1.0.0"
-    
-    async def get_tools(self) -> List[Dict]:
-        """Returns the list of tools available in this MCP"""
-        return [
-            {
-                "name": "analyze_sentiment",
-                "description": "Analyze the sentiment of text using TextBlob NLP",
-                "inputSchema": {
-                    "type": "object",
-                    "properties": {
-                        "text": {
-                            "type": "string",
-                            "description": "Text to analyze for sentiment"
-                        },
-                        "detailed": {
-                            "type": "boolean",
-                            "description": "Return detailed analysis including confidence and statistics",
-                            "default": False
-                        }
-                    },
-                    "required": ["text"]
-                }
-            },
-            {
-                "name": "batch_analyze",
-                "description": "Analyze sentiment for multiple texts at once",
-                "inputSchema": {
-                    "type": "object",
-                    "properties": {
-                        "texts": {
-                            "type": "array",
-                            "items": {"type": "string"},
-                            "description": "Array of texts to analyze"
-                        }
-                    },
-                    "required": ["texts"]
-                }
-            },
-            {
-                "name": "sentiment_summary",
-                "description": "Get summary statistics for analyzed texts",
-                "inputSchema": {
-                    "type": "object",
-                    "properties": {
-                        "texts": {
-                            "type": "array",
-                            "items": {"type": "string"}
-                        }
-                    },
-                    "required": ["texts"]
-                }
-            }
-        ]
+def sentiment_analysis(text: str) -> dict:
+    """
+    Analyze the sentiment of the given text.
+    Simplified version for Hugging Face Spaces.
+    """
+    if not text or not text.strip():
+        return {
+            "error": "Please enter some text to analyze",
+            "polarity": 0,
+            "subjectivity": 0,
+            "assessment": "neutral",
+            "confidence": "low"
+        }
     
-    async def call_tool(self, name: str, arguments: Dict) -> Dict:
-        """Call the specified tool with the given arguments."""
-        if name == "analyze_sentiment":
-            return await self.analyze_sentiment(
-                arguments["text"], 
-                arguments.get("detailed", False)
-            )
-        elif name == "batch_analyze":
-            return await self.batch_analyze(arguments["texts"])
-        elif name == "sentiment_summary":
-            return await self.sentiment_summary(arguments["texts"])
-        else:
-            raise ValueError(f"Unknown tool: {name}")
-
-    async def analyze_sentiment(self, text: str, detailed: bool = False) -> Dict[str, Any]:
-        """Main sentiment analysis function"""
-        if not text or not text.strip():
-            return {"error": "Text cannot be empty"}
-        
+    try:
         blob = TextBlob(text)
         sentiment = blob.sentiment
         
-        # Base analysis result
+        # Calculate confidence based on polarity strength
+        polarity_abs = abs(sentiment.polarity)
+        if polarity_abs >= 0.7:
+            confidence = "high"
+        elif polarity_abs >= 0.3:
+            confidence = "medium"
+        else:
+            confidence = "low"
+        
+        # More nuanced assessment
+        if sentiment.polarity > 0.1:
+            assessment = "positive"
+        elif sentiment.polarity < -0.1:
+            assessment = "negative"
+        else:
+            assessment = "neutral"
+        
         result = {
-            "text": text[:100] + "..." if len(text) > 100 else text,
             "polarity": round(sentiment.polarity, 3),
             "subjectivity": round(sentiment.subjectivity, 3),
-            "assessment": self._get_assessment(sentiment.polarity)
+            "assessment": assessment,
+            "confidence": confidence,
+            "word_count": len(text.split()),
+            "character_count": len(text),
+            "text_preview": text[:100] + "..." if len(text) > 100 else text
         }
         
-        # Detailed analysis
-        if detailed:
-            result.update({
-                "confidence": self._get_confidence(sentiment.polarity),
-                "word_count": len(text.split()),
-                "character_count": len(text),
-                "interpretation": self._get_interpretation(sentiment)
-            })
-        
         return result
-    
-    async def batch_analyze(self, texts: List[str]) -> Dict[str, Any]:
-        """Analyze sentiment for multiple texts"""
-        results = []
-        for i, text in enumerate(texts):
-            try:
-                result = await self.analyze_sentiment(text, detailed=True)
-                result["index"] = i
-                results.append(result)
-            except Exception as e:
-                results.append({"index": i, "error": str(e), "text": text})
-        
-        return {"results": results, "total_analyzed": len(texts)}
-    
-    async def sentiment_summary(self, texts: List[str]) -> Dict[str, Any]:
-        """Generate summary statistics for a batch of texts"""
-        batch_result = await self.batch_analyze(texts)
-        results = batch_result["results"]
-        
-        # Фильтруем успешные результаты
-        valid_results = [r for r in results if "error" not in r]
-        
-        if not valid_results:
-            return {"error": "No valid results to summarize"}
-        
-        polarities = [r["polarity"] for r in valid_results]
-        assessments = [r["assessment"] for r in valid_results]
-        
-        # Подсчет по категориям
-        positive = sum(1 for a in assessments if a == "positive")
-        negative = sum(1 for a in assessments if a == "negative")
-        neutral = sum(1 for a in assessments if a == "neutral")
         
+    except Exception as e:
         return {
-            "total_texts": len(texts),
-            "analyzed": len(valid_results),
-            "average_polarity": round(sum(polarities) / len(polarities), 3),
-            "sentiment_distribution": {
-                "positive": positive,
-                "negative": negative,
-                "neutral": neutral
-            },
-            "percentages": {
-                "positive": round(positive / len(valid_results) * 100, 1),
-                "negative": round(negative / len(valid_results) * 100, 1),
-                "neutral": round(neutral / len(valid_results) * 100, 1)
-            }
+            "error": f"Analysis failed: {str(e)}",
+            "polarity": 0,
+            "subjectivity": 0,
+            "assessment": "error",
+            "confidence": "low"
         }
-    
-    def _get_assessment(self, polarity: float) -> str:
-        """Sentiment assessment based on polarity"""
-        if polarity > 0.1:
-            return "positive"
-        elif polarity < -0.1:
-            return "negative"
-        else:
-            return "neutral"
-    
-    def _get_confidence(self, polarity: float) -> str:
-        """Confidence level based on polarity"""
-        abs_polarity = abs(polarity)
-        if abs_polarity >= 0.7:
-            return "high"
-        elif abs_polarity >= 0.3:
-            return "medium"
-        else:
-            return "low"
-    
-    def _get_interpretation(self, sentiment) -> str:
-        """Reult interpretation based on sentiment analysis"""
-        polarity = sentiment.polarity
-        subjectivity = sentiment.subjectivity
-        
-        if subjectivity > 0.7:
-            subj_desc = "highly subjective (opinion-based)"
-        elif subjectivity > 0.3:
-            subj_desc = "moderately subjective"
-        else:
-            subj_desc = "objective (fact-based)"
-        
-        if abs(polarity) > 0.5:
-            pol_desc = "strong sentiment"
-        elif abs(polarity) > 0.2:
-            pol_desc = "moderate sentiment"
-        else:
-            pol_desc = "neutral sentiment"
-        
-        return f"This text shows {pol_desc} and is {subj_desc}."
-
-# Global instance of the MCP server
-mcp_server = SentimentMCPServer()
-
-def sentiment_analysis(text: str) -> Dict[str, Any]:
-    """Wrapper for Gradio interface to call MCP server"""
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    try:
-        result = loop.run_until_complete(
-            mcp_server.analyze_sentiment(text, detailed=True)
-        )
-        return result
-    finally:
-        loop.close()
 
-def format_results(result: Dict[str, Any]) -> str:
-    """Format the results for display in Gradio"""
+def format_results(result: dict) -> str:
+    """Format the analysis results for better display."""
     if "error" in result:
         return f"❌ **Error:** {result['error']}"
     
-    emoji_map = {"positive": "😊", "negative": "😞", "neutral": "😐"}
-    polarity_color = "🟢" if result["polarity"] > 0 else "🔴" if result["polarity"] < 0 else "🟡"
+    # Emoji mapping for sentiment
+    emoji_map = {
+        "positive": "😊",
+        "negative": "😞", 
+        "neutral": "😐",
+        "error": "❌"
+    }
+    
+    # Color coding for polarity
+    polarity = result["polarity"]
+    if polarity > 0:
+        polarity_color = "🟢"
+        polarity_desc = "Positive"
+    elif polarity < 0:
+        polarity_color = "🔴"
+        polarity_desc = "Negative"
+    else:
+        polarity_color = "🟡"
+        polarity_desc = "Neutral"
     
-    return f"""
-## 📊 MCP Sentiment Analysis Results
+    # Confidence indicators
+    confidence_icons = {
+        "high": "🔥",
+        "medium": "⚡",
+        "low": "💫"
+    }
+    
+    formatted = f"""
+## 📊 Sentiment Analysis Results
 
-### {emoji_map[result['assessment']]} Assessment: **{result['assessment'].title()}**
+### {emoji_map[result['assessment']]} Overall Assessment: **{result['assessment'].title()}**
 
-### 📈 Metrics:
-- **Polarity:** {polarity_color} {result['polarity']} 
-- **Subjectivity:** 🎯 {result['subjectivity']}
-- **Confidence:** {result.get('confidence', 'N/A').title()}
+### 📈 Detailed Metrics:
+- **Polarity:** {polarity_color} **{result['polarity']}** ({polarity_desc})
+  - Range: -1.0 (very negative) to +1.0 (very positive)
+- **Subjectivity:** 🎯 **{result['subjectivity']}**
+  - Range: 0.0 (objective) to 1.0 (subjective)
+- **Confidence:** {confidence_icons.get(result['confidence'], '❓')} **{result['confidence'].title()}**
 
-### 📝 Statistics:
-- **Words:** {result.get('word_count', 'N/A')}
-- **Characters:** {result.get('character_count', 'N/A')}
+### 📝 Text Statistics:
+- **Words:** {result['word_count']}
+- **Characters:** {result['character_count']}
+- **Preview:** "{result.get('text_preview', 'N/A')}"
 
 ### 💡 Interpretation:
-{result.get('interpretation', 'No interpretation available')}
+- **Polarity** measures emotional tone from negative to positive
+- **Subjectivity** measures opinion vs factual content
+- **Confidence** indicates strength of sentiment signal
 
 ---
-*🔗 This analysis is available via MCP protocol for AI assistants*
+*🔗 Powered by TextBlob NLP • Ready for MCP integration*
 """
+    return formatted
+
+def analyze_with_formatting(text: str) -> str:
+    """Wrapper function that combines analysis and formatting."""
+    result = sentiment_analysis(text)
+    return format_results(result)
 
-# Gradio interface setup
-with gr.Blocks(title="🎯 MCP Sentiment Analyzer") as demo:
+def batch_analyze_simple(texts_input: str) -> str:
+    """Simple batch analysis for multiple texts."""
+    if not texts_input.strip():
+        return "❌ Please enter some texts, one per line."
+    
+    texts = [line.strip() for line in texts_input.split('\n') if line.strip()]
+    
+    if not texts:
+        return "❌ No valid texts found."
+    
+    results = []
+    positive_count = 0
+    negative_count = 0
+    neutral_count = 0
+    total_polarity = 0
+    
+    for i, text in enumerate(texts, 1):
+        result = sentiment_analysis(text)
+        if "error" not in result:
+            assessment = result["assessment"]
+            if assessment == "positive":
+                positive_count += 1
+            elif assessment == "negative":
+                negative_count += 1
+            else:
+                neutral_count += 1
+            
+            total_polarity += result["polarity"]
+            
+            results.append(f"**Text {i}:** {result['assessment']} ({result['polarity']}) - \"{result['text_preview']}\"")
+        else:
+            results.append(f"**Text {i}:** Error - {result['error']}")
+    
+    avg_polarity = total_polarity / len(texts) if texts else 0
+    
+    summary = f"""
+## 📊 Batch Analysis Results
+
+### 📈 Summary Statistics:
+- **Total Texts:** {len(texts)}
+- **Average Polarity:** {round(avg_polarity, 3)}
+- **Positive:** {positive_count} ({round(positive_count/len(texts)*100, 1)}%)
+- **Negative:** {negative_count} ({round(negative_count/len(texts)*100, 1)}%)
+- **Neutral:** {neutral_count} ({round(neutral_count/len(texts)*100, 1)}%)
+
+### 📋 Individual Results:
+{chr(10).join(results)}
+"""
+    return summary
+
+# Sample texts for quick testing
+sample_texts = [
+    "I absolutely love this product! It's amazing and works perfectly.",
+    "This is the worst experience I've ever had. Completely disappointed.",
+    "The weather today is partly cloudy with a chance of rain.",
+    "I'm not sure how I feel about this new update. It has some good features but also some issues.",
+    "Artificial intelligence is transforming various industries including healthcare, finance, and transportation."
+]
+
+# Create the Gradio interface
+with gr.Blocks(
+    theme=gr.themes.Soft(),
+    title="🎯 Sentiment Analyzer",
+    css="""
+    .gradio-container {
+        max-width: 1200px !important;
+        margin: auto !important;
+    }
+    .main-header {
+        text-align: center;
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
+        font-size: 2.5em;
+        font-weight: bold;
+        margin-bottom: 20px;
+    }
+    .subtitle {
+        text-align: center;
+        color: #666;
+        font-size: 1.2em;
+        margin-bottom: 30px;
+    }
+    """
+) as demo:
+    
     gr.HTML("""
-    <h1 style="text-align: center; color: #667eea;">
-        🎯 MCP-Enabled Sentiment Analyzer
-    </h1>
-    <p style="text-align: center; color: #666;">
-        Advanced sentiment analysis with Model Context Protocol support
-    </p>
+    <div class="main-header">
+        🎯 AI Sentiment Analyzer
+    </div>
+    <div class="subtitle">
+        Advanced sentiment analysis powered by TextBlob NLP
+    </div>
     """)
     
-    with gr.Tab("🔍 Single Analysis"):
-        text_input = gr.Textbox(
-            placeholder="Enter text for sentiment analysis...",
-            lines=5,
-            label="Text to Analyze"
-        )
-        analyze_btn = gr.Button("🔍 Analyze", variant="primary")
-        output = gr.Markdown()
+    with gr.Tabs():
+        with gr.Tab("🔍 Single Analysis"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📝 Enter Your Text")
+                    text_input = gr.Textbox(
+                        placeholder="Type or paste your text here for sentiment analysis...",
+                        lines=6,
+                        max_lines=15,
+                        label="Text to Analyze",
+                        info="💡 Tip: Longer texts generally provide more accurate sentiment analysis"
+                    )
+                    
+                    with gr.Row():
+                        analyze_btn = gr.Button("🔍 Analyze Sentiment", variant="primary", size="lg")
+                        clear_btn = gr.Button("🗑️ Clear", variant="secondary", size="lg")
+                    
+                    gr.Markdown("### 🎯 Try Quick Examples")
+                    examples_dropdown = gr.Dropdown(
+                        choices=sample_texts,
+                        label="Select a sample text to analyze",
+                        value=None,
+                        interactive=True
+                    )
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📊 Analysis Results")
+                    output = gr.Markdown(
+                        value="👋 **Welcome!** Enter some text and click 'Analyze Sentiment' to get started with AI-powered sentiment analysis.",
+                        label="Sentiment Analysis Output"
+                    )
         
-        analyze_btn.click(
-            fn=lambda x: format_results(sentiment_analysis(x)),
-            inputs=text_input,
-            outputs=output
-        )
+        with gr.Tab("📊 Batch Analysis"):
+            gr.Markdown("### 📝 Analyze Multiple Texts")
+            batch_input = gr.Textbox(
+                placeholder="Enter multiple texts, one per line...\n\nExample:\nI love this product!\nThis is terrible.\nThe weather is nice today.",
+                lines=8,
+                label="Multiple Texts (one per line)",
+                info="Enter each text on a separate line for batch analysis"
+            )
+            batch_btn = gr.Button("📊 Analyze All", variant="primary", size="lg")
+            batch_output = gr.Markdown(
+                value="👋 Enter multiple texts above and click 'Analyze All' to get batch sentiment analysis.",
+                label="Batch Analysis Results"
+            )
     
-    with gr.Tab("📊 Batch Analysis"):
-        batch_input = gr.Textbox(
-            placeholder="Enter multiple texts, one per line...",
-            lines=8,
-            label="Multiple Texts"
-        )
-        batch_btn = gr.Button("📊 Batch Analyze", variant="primary")
-        batch_output = gr.JSON(label="Batch Results")
-        
-        def batch_analyze_wrapper(texts_str: str):
-            if not texts_str.strip():
-                return {"error": "Please enter some texts"}
+    # Additional info section
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("""
+            ### 🔍 About This Tool
             
-            texts = [line.strip() for line in texts_str.split('\n') if line.strip()]
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                return loop.run_until_complete(mcp_server.batch_analyze(texts))
-            finally:
-                loop.close()
-        
-        batch_btn.click(
-            fn=batch_analyze_wrapper,
-            inputs=batch_input,
-            outputs=batch_output
-        )
+            This **AI-powered sentiment analyzer** uses advanced Natural Language Processing to determine:
+            - **Emotional tone** (positive, negative, neutral)
+            - **Subjectivity level** (opinion vs fact)
+            - **Confidence scores** based on signal strength
+            
+            Perfect for analyzing:
+            - 📝 Customer reviews and feedback
+            - 📱 Social media posts and comments  
+            - 📧 Email and message sentiment
+            - 📊 Survey responses and testimonials
+            - 📈 Product feedback and ratings
+            
+            **Features:**
+            - Real-time sentiment analysis
+            - Batch processing for multiple texts
+            - Detailed confidence metrics
+            - User-friendly interface
+            """)
     
-    with gr.Tab("📈 Summary Stats"):
-        summary_input = gr.Textbox(
-            placeholder="Enter texts for summary statistics...",
-            lines=6,
-            label="Texts for Summary"
-        )
-        summary_btn = gr.Button("📈 Get Summary", variant="primary")
-        summary_output = gr.JSON(label="Summary Statistics")
-        
-        def summary_wrapper(texts_str: str):
-            if not texts_str.strip():
-                return {"error": "Please enter some texts"}
-            texts = [line.strip() for line in texts_str.split('\n') if line.strip()]
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                return loop.run_until_complete(mcp_server.sentiment_summary(texts))
-            finally:
-                loop.close()
-        
-        summary_btn.click(
-            fn=summary_wrapper,
-            inputs=summary_input,
-            outputs=summary_output
-        )
+    # Event handlers for Single Analysis
+    analyze_btn.click(
+        fn=analyze_with_formatting,
+        inputs=text_input,
+        outputs=output
+    )
+    
+    clear_btn.click(
+        fn=lambda: ("", "👋 **Welcome!** Enter some text and click 'Analyze Sentiment' to get started."),
+        outputs=[text_input, output]
+    )
+    
+    examples_dropdown.change(
+        fn=lambda x: x if x else "",
+        inputs=examples_dropdown,
+        outputs=text_input
+    )
+    
+    text_input.submit(
+        fn=analyze_with_formatting,
+        inputs=text_input,
+        outputs=output
+    )
+    
+    # Event handlers for Batch Analysis
+    batch_btn.click(
+        fn=batch_analyze_simple,
+        inputs=batch_input,
+        outputs=batch_output
+    )
 
+# Simple launch for Hugging Face Spaces
 if __name__ == "__main__":
-    print("🚀 Starting MCP-Enabled Sentiment Analyzer...")
-    print("📡 MCP Server: Available for AI assistant integration")
-    print("🔧 Available MCP tools:")
-    print("  - analyze_sentiment: Single text analysis")
-    print("  - batch_analyze: Multiple texts analysis") 
-    print("  - sentiment_summary: Statistical summary")
-    print("🌐 Web UI: http://localhost:7860")
-    
-    demo.launch(
-        mcp_server=True,
-        server_name="127.0.0.1",
-        server_port=7860,
-        inbrowser=True
-    )
+    print("🚀 Starting Sentiment Analyzer for Hugging Face Spaces...")
+    demo.launch(mcp_server=True)

requirements.txt

@@ -1,6 +1,3 @@
 # Minimal requirements for basic MCP Sentiment Analyzer
 gradio>=4.0.0
-textblob>=0.17.1
-asyncio>=3.4.3
-pydantic>=2.0.0
-typing-extensions>=4.8.0
+textblob>=0.17.1