Upload 7 files

README.md

@@ -1,13 +1,52 @@
 ---
-title: Sentiment
-emoji: 🔥
-colorFrom: indigo
-colorTo: green
+title: Multilingual Sentiment Analysis
+emoji: 🌍
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 6.2.0
-app_file: app.py
+sdk_version: 4.0.0
+app_file: app_gradio.py
 pinned: false
-short_description: A test simple sentiment analyzer for Turkish,English,Persian
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Multilingual Sentiment Analysis Tool
+
+A comprehensive sentiment analysis tool supporting **English**, **Turkish**, and **Persian** languages using non-deep-learning approaches (lexicon-based, rule-based, and hybrid methods).
+
+## Features
+
+- 🌍 **Multilingual Support**: English, Turkish, and Persian
+- 🔧 **Multiple Methods**: Lexicon-based, rule-based, and hybrid approaches
+- 📊 **Batch Processing**: Analyze multiple texts at once
+- ✨ **Advanced Rules**: 
+  - Comprehensive sentiment lexicons (200+ words per language)
+  - Idiom detection
+  - Emoticon and emoji support
+  - Negation scope detection
+  - Intensifier and diminisher handling
+  - Contrast word detection
+  - And much more!
+
+## Usage
+
+1. Select your language (English, Turkish, or Persian)
+2. Choose analysis method (Lexicon, Rule-based, or Hybrid)
+3. Enter text and click "Analyze Sentiment"
+4. View detailed results with polarity, confidence, and scores
+
+## Methods
+
+- **Lexicon-based**: Uses predefined sentiment dictionaries
+- **Rule-based**: Extends lexicon with linguistic rules
+- **Hybrid** (Recommended): Combines both approaches for best results
+
+## Citation
+
+If you use this tool in your research, please cite:
+
+```
+Multilingual Sentiment Analysis Tool (2024)
+Non-Deep-Learning Approaches for Sentiment Analysis
+```
+

app.py

@@ -0,0 +1,168 @@
+"""
+Gradio App for Multilingual Sentiment Analysis
+Deploy this to Hugging Face Spaces
+"""
+
+import gradio as gr
+from sentiment_analyzer import MultilingualSentimentAnalyzer
+
+def analyze_sentiment(text, language, method):
+    """Analyze sentiment and return formatted results"""
+    if not text or not text.strip():
+        return "Please enter some text to analyze."
+    
+    try:
+        analyzer = MultilingualSentimentAnalyzer(language=language, method=method)
+        result = analyzer.analyze(text)
+        
+        # Format the output nicely
+        output = f"""
+## Sentiment Analysis Results
+
+**Polarity:** {result['polarity'].upper()}
+**Confidence:** {result['confidence']*100:.1f}%
+
+**Scores:**
+- Positive: {result['positive_score']:.2f}
+- Negative: {result['negative_score']:.2f}
+
+**Details:**
+- Method: {result['method']}
+- Language: {result['language']}
+- Words analyzed: {result.get('word_count', 0)}
+"""
+        
+        return output
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def batch_analyze(texts, language, method):
+    """Analyze multiple texts"""
+    if not texts:
+        return "Please enter texts to analyze (one per line)."
+    
+    text_list = [t.strip() for t in texts.split('\n') if t.strip()]
+    if not text_list:
+        return "No valid texts found."
+    
+    try:
+        analyzer = MultilingualSentimentAnalyzer(language=language, method=method)
+        results = analyzer.analyze_batch(text_list)
+        stats = analyzer.get_statistics(text_list)
+        
+        output = f"""
+## Batch Analysis Results
+
+**Statistics:**
+- Total texts: {stats['total_texts']}
+- Average confidence: {stats['average_confidence']*100:.1f}%
+
+**Polarity Distribution:**
+"""
+        for polarity, percentage in stats['polarity_percentages'].items():
+            output += f"- {polarity.capitalize()}: {percentage}%\n"
+        
+        output += "\n**Individual Results:**\n"
+        for i, (text, result) in enumerate(zip(text_list, results), 1):
+            output += f"\n{i}. \"{text[:50]}...\" → {result['polarity']} ({result['confidence']*100:.1f}%)\n"
+        
+        return output
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="Multilingual Sentiment Analysis", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🌍 Multilingual Sentiment Analysis Tool
+    
+    Analyze sentiment in **English**, **Turkish**, and **Persian** text using non-deep-learning approaches.
+    
+    This tool uses lexicon-based, rule-based, and hybrid methods for interpretable sentiment analysis.
+    """)
+    
+    with gr.Tabs():
+        with gr.TabItem("Single Text Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="Enter Text",
+                        placeholder="Type your text here...",
+                        lines=5
+                    )
+                    language = gr.Dropdown(
+                        choices=["english", "turkish", "persian"],
+                        value="english",
+                        label="Language"
+                    )
+                    method = gr.Dropdown(
+                        choices=["lexicon", "rule", "hybrid"],
+                        value="hybrid",
+                        label="Analysis Method"
+                    )
+                    analyze_btn = gr.Button("Analyze Sentiment", variant="primary")
+                
+                with gr.Column():
+                    output = gr.Markdown(label="Results")
+            
+            analyze_btn.click(
+                fn=analyze_sentiment,
+                inputs=[text_input, language, method],
+                outputs=output
+            )
+        
+        with gr.TabItem("Batch Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    batch_texts = gr.Textbox(
+                        label="Enter Texts (one per line)",
+                        placeholder="Enter multiple texts, one per line...",
+                        lines=10
+                    )
+                    batch_language = gr.Dropdown(
+                        choices=["english", "turkish", "persian"],
+                        value="english",
+                        label="Language"
+                    )
+                    batch_method = gr.Dropdown(
+                        choices=["lexicon", "rule", "hybrid"],
+                        value="hybrid",
+                        label="Analysis Method"
+                    )
+                    batch_btn = gr.Button("Analyze Batch", variant="primary")
+                
+                with gr.Column():
+                    batch_output = gr.Markdown(label="Batch Results")
+            
+            batch_btn.click(
+                fn=batch_analyze,
+                inputs=[batch_texts, batch_language, batch_method],
+                outputs=batch_output
+            )
+        
+        with gr.TabItem("Examples"):
+            gr.Markdown("""
+            ### Example Texts to Try:
+            
+            **English:**
+            - "I love this product! It's absolutely amazing!!! 😊"
+            - "This is terrible. I hate it."
+            - "Not bad, actually it's quite good!"
+            
+            **Turkish:**
+            - "Bu ürünü çok seviyorum! Harika!"
+            - "Berbat bir deneyim. Hiç beğenmedim."
+            
+            **Persian:**
+            - "این محصول عالی است!"
+            - "خیلی بد بود"
+            """)
+    
+    gr.Markdown("""
+    ---
+    **About:** This tool uses lexicon-based, rule-based, and hybrid approaches (without deep learning) 
+    for interpretable sentiment analysis. Supports English, Turkish, and Persian languages.
+    """)
+
+if __name__ == "__main__":
+    demo.launch()
+

lexicons/english_lexicon.json

@@ -0,0 +1,197 @@
+{
+  "positive": [
+    "good", "great", "excellent", "amazing", "wonderful", "fantastic", "superb", "marvelous",
+    "love", "like", "adore", "cherish", "treasure", "appreciate", "enjoy", "delight",
+    "best", "perfect", "ideal", "flawless", "impeccable", "outstanding", "remarkable",
+    "beautiful", "gorgeous", "stunning", "lovely", "charming", "attractive", "appealing",
+    "nice", "pleasant", "agreeable", "satisfying", "pleasing", "gratifying",
+    "happy", "joyful", "cheerful", "glad", "pleased", "delighted", "thrilled", "ecstatic",
+    "satisfied", "content", "fulfilled", "gratified", "comfortable", "at ease",
+    "awesome", "brilliant", "magnificent", "splendid", "fabulous", "terrific", "incredible",
+    "successful", "triumphant", "victorious", "winning", "prosperous", "flourishing",
+    "optimistic", "hopeful", "confident", "positive", "upbeat", "encouraging",
+    "grateful", "thankful", "appreciative", "obliged", "indebted",
+    "excited", "enthusiastic", "eager", "passionate", "zealous", "ardent",
+    "proud", "honored", "privileged", "blessed", "fortunate", "lucky",
+    "impressive", "admirable", "praiseworthy", "commendable", "laudable",
+    "refreshing", "invigorating", "energizing", "uplifting", "inspiring",
+    "reliable", "trustworthy", "dependable", "solid", "steady", "consistent",
+    "valuable", "precious", "worthwhile", "beneficial", "advantageous", "profitable",
+    "smooth", "easy", "effortless", "seamless", "convenient", "user-friendly",
+    "innovative", "creative", "original", "unique", "distinctive", "special",
+    "professional", "expert", "skilled", "competent", "capable", "proficient",
+    "helpful", "supportive", "beneficial", "useful", "practical", "effective",
+    "clear", "transparent", "honest", "genuine", "authentic", "sincere",
+    "peaceful", "calm", "serene", "tranquil", "relaxing", "soothing",
+    "fun", "entertaining", "enjoyable", "amusing", "delightful", "pleasurable",
+    "fast", "quick", "rapid", "swift", "efficient", "speedy",
+    "affordable", "reasonable", "fair", "economical", "budget-friendly",
+    "modern", "contemporary", "up-to-date", "current", "fresh", "new",
+    "clean", "tidy", "organized", "neat", "orderly", "pristine",
+    "safe", "secure", "protected", "reliable", "stable", "sound",
+    "flexible", "adaptable", "versatile", "multipurpose", "all-purpose",
+    "recommend", "suggest", "endorse", "approve", "support", "back",
+    "exceed", "surpass", "outperform", "outshine", "beat", "top"
+  ],
+  "negative": [
+    "bad", "terrible", "awful", "horrible", "dreadful", "atrocious", "appalling",
+    "worst", "poorest", "lowest", "inferior", "substandard", "unacceptable",
+    "hate", "loathe", "despise", "detest", "abhor", "disgust", "repulse",
+    "dislike", "disapprove", "reject", "refuse", "decline", "deny",
+    "poor", "inadequate", "insufficient", "deficient", "lacking", "wanting",
+    "disappointed", "let down", "disillusioned", "disheartened", "discouraged",
+    "sad", "unhappy", "miserable", "depressed", "down", "blue", "gloomy",
+    "angry", "mad", "furious", "enraged", "irritated", "annoyed", "upset",
+    "frustrated", "exasperated", "aggravated", "bothered", "irked", "vexed",
+    "annoying", "irritating", "bothersome", "troublesome", "pesky", "nagging",
+    "boring", "tedious", "dull", "monotonous", "repetitive", "tiresome",
+    "ugly", "unattractive", "hideous", "repulsive", "revolting", "disgusting",
+    "pathetic", "pitiful", "lamentable", "deplorable", "regrettable",
+    "miserable", "wretched", "unfortunate", "unlucky", "hapless",
+    "depressing", "disheartening", "discouraging", "demoralizing", "daunting",
+    "unpleasant", "disagreeable", "offensive", "repugnant", "repellent",
+    "disappointing", "unsatisfactory", "inadequate", "subpar", "below expectations",
+    "frustrating", "infuriating", "maddening", "exasperating", "aggravating",
+    "confusing", "bewildering", "perplexing", "puzzling", "mystifying",
+    "difficult", "hard", "challenging", "tough", "arduous", "strenuous",
+    "slow", "sluggish", "slack", "delayed", "late", "behind schedule",
+    "expensive", "costly", "pricey", "overpriced", "unaffordable", "exorbitant",
+    "outdated", "obsolete", "old-fashioned", "archaic", "antiquated",
+    "dirty", "filthy", "unclean", "messy", "disorganized", "cluttered",
+    "unsafe", "dangerous", "risky", "hazardous", "perilous", "precarious",
+    "broken", "damaged", "defective", "faulty", "malfunctioning", "flawed",
+    "unreliable", "untrustworthy", "undependable", "inconsistent", "unstable",
+    "useless", "worthless", "pointless", "futile", "ineffective", "inefficient",
+    "complicated", "complex", "convoluted", "intricate", "elaborate",
+    "waste", "squander", "throw away", "lose", "miss", "fail",
+    "problem", "issue", "trouble", "difficulty", "hardship", "obstacle",
+    "error", "mistake", "fault", "flaw", "defect", "bug",
+    "complaint", "grievance", "objection", "protest", "criticism",
+    "regret", "remorse", "sorrow", "grief", "anguish", "distress",
+    "worry", "concern", "anxiety", "stress", "tension", "pressure",
+    "fear", "dread", "terror", "panic", "alarm", "apprehension",
+    "pain", "ache", "hurt", "suffering", "agony", "torment",
+    "weak", "feeble", "frail", "fragile", "delicate", "vulnerable",
+    "stupid", "foolish", "silly", "ridiculous", "absurd", "nonsensical",
+    "lazy", "sluggish", "inactive", "idle", "indolent", "lethargic",
+    "rude", "impolite", "discourteous", "ill-mannered", "offensive",
+    "selfish", "greedy", "self-centered", "egotistical", "narcissistic",
+    "dishonest", "deceptive", "misleading", "fraudulent", "deceitful",
+    "unfair", "unjust", "biased", "prejudiced", "discriminatory",
+    "reject", "refuse", "decline", "deny", "dismiss", "turn down"
+  ],
+  "intensifiers": {
+    "very": 1.5,
+    "extremely": 2.0,
+    "really": 1.3,
+    "quite": 1.2,
+    "too": 1.4,
+    "so": 1.3,
+    "absolutely": 1.8,
+    "completely": 1.5,
+    "totally": 1.6,
+    "incredibly": 1.7,
+    "amazingly": 1.6,
+    "exceptionally": 1.7,
+    "particularly": 1.4,
+    "especially": 1.4,
+    "highly": 1.6,
+    "greatly": 1.5,
+    "significantly": 1.5,
+    "substantially": 1.5,
+    "considerably": 1.4,
+    "tremendously": 1.8,
+    "immensely": 1.7,
+    "enormously": 1.7,
+    "hugely": 1.6,
+    "massively": 1.6,
+    "dramatically": 1.6,
+    "remarkably": 1.6,
+    "extraordinarily": 1.8,
+    "unbelievably": 1.7,
+    "incredibly": 1.7,
+    "surprisingly": 1.4,
+    "unusually": 1.4,
+    "remarkably": 1.6,
+    "deeply": 1.5,
+    "profoundly": 1.6,
+    "thoroughly": 1.5,
+    "utterly": 1.7,
+    "entirely": 1.5,
+    "fully": 1.4,
+    "perfectly": 1.6,
+    "purely": 1.4,
+    "simply": 1.3,
+    "just": 1.2,
+    "even": 1.2,
+    "more": 1.3,
+    "most": 1.5,
+    "much": 1.4,
+    "many": 1.3,
+    "most": 1.5,
+    "super": 1.5,
+    "mega": 1.6,
+    "ultra": 1.7,
+    "hyper": 1.6,
+    "overly": 1.4,
+    "excessively": 1.5,
+    "intensely": 1.6,
+    "severely": 1.5,
+    "badly": 1.4,
+    "terribly": 1.6,
+    "awfully": 1.6,
+    "horribly": 1.6,
+    "dreadfully": 1.6
+  },
+  "negation": [
+    "not", "no", "never", "none", "nobody", "nothing", "nowhere",
+    "neither", "cannot", "can't", "won't", "don't", "doesn't",
+    "didn't", "isn't", "aren't", "wasn't", "weren't", "hasn't",
+    "haven't", "hadn't", "wouldn't", "couldn't", "shouldn't",
+    "mustn't", "mightn't", "mayn't", "shan't", "ain't",
+    "without", "lacking", "missing", "absent", "devoid",
+    "neither", "nor", "nobody", "nowhere", "nothing",
+    "nowhere", "nevermore", "nohow", "nowise", "noways",
+    "barely", "hardly", "scarcely", "rarely", "seldom",
+    "little", "few", "less", "least", "minimal",
+    "refuse", "reject", "deny", "decline", "dismiss"
+  ],
+  "diminishers": {
+    "slightly": 0.7,
+    "somewhat": 0.8,
+    "a bit": 0.7,
+    "a little": 0.7,
+    "kind of": 0.8,
+    "sort of": 0.8,
+    "rather": 0.9,
+    "pretty": 0.9,
+    "fairly": 0.9,
+    "relatively": 0.85,
+    "moderately": 0.85,
+    "reasonably": 0.9,
+    "barely": 0.6,
+    "hardly": 0.6,
+    "scarcely": 0.6,
+    "almost": 0.8,
+    "nearly": 0.8,
+    "partially": 0.7,
+    "partly": 0.7
+  },
+  "contrast_words": [
+    "but", "however", "although", "though", "yet", "still",
+    "nevertheless", "nonetheless", "despite", "in spite of",
+    "whereas", "while", "on the other hand", "conversely"
+  ],
+  "idioms_positive": [
+    "over the moon", "on cloud nine", "thrilled to bits", "tickled pink",
+    "walking on air", "in seventh heaven", "feeling great", "top notch",
+    "second to none", "head and shoulders above", "out of this world",
+    "worth its weight in gold", "the bee's knees", "the cat's pajamas"
+  ],
+  "idioms_negative": [
+    "down in the dumps", "feeling blue", "under the weather", "out of sorts",
+    "at the end of one's rope", "at wit's end", "in a pickle", "in hot water",
+    "the last straw", "the final nail in the coffin", "hit rock bottom",
+    "go from bad to worse", "go downhill", "go to pieces", "fall apart"
+  ]
+}

lexicons/persian_lexicon.json

@@ -0,0 +1,110 @@
+{
+  "positive": [
+    "خوب", "عالی", "عالیه", "ممتاز", "برجسته", "فوق‌العاده",
+    "دوست دارم", "خوشم میاد", "پسندیدم", "علاقه دارم", "عاشق", "محبوب",
+    "زیبا", "قشنگ", "خوب", "نیک", "خوب", "عالی",
+    "موفق", "کامیاب", "پیروز", "فاتح", "برنده", "کامیاب",
+    "راضی", "خوشحال", "شاد", "خوش", "مسرور", "خوشنود",
+    "لذت بخش", "خوشایند", "مطلوب", "مثبت", "امیدوار", "خوش بین",
+    "راضی کننده", "قانع کننده", "رضایت بخش", "خوشایند",
+    "ممتاز", "عالی", "برجسته", "فوق‌العاده", "استثنایی",
+    "خوب", "نیک", "خوب", "عالی", "ممتاز", "برجسته",
+    "زیبا", "قشنگ", "خوب", "نیک", "خوب", "عالی",
+    "خوشحال", "شاد", "خوش", "مسرور", "خوشنود", "شادمان",
+    "مفید", "سودمند", "کارآمد", "عملی", "موثر", "کاربردی",
+    "با کیفیت", "مرغوب", "عالی", "برتر", "عالی", "ممتاز",
+    "سریع", "تند", "چابک", "عاجل", "فوری", "سریع",
+    "ارزان", "اقتصادی", "مقرون به صرفه", "مناسب", "جذاب",
+    "تمیز", "پاک", "منظم", "مرتب", "منظم", "پاکیزه",
+    "امن", "ایمن", "مطمئن", "قابل اعتماد", "پایدار", "مستحکم",
+    "راحت", "آسوده", "آرام", "ساکت", "آرام", "آرامش",
+    "سرگرم کننده", "جالب", "خوشایند", "لذت بخش", "خوش", "شاد",
+    "جدید", "نو", "مدرن", "معاصر", "جاری", "تازه",
+    "آسان", "ساده", "راحت", "قابل فهم", "روشن", "واضح",
+    "توصیه می‌کنم", "پیشنهاد می‌کنم", "توصیه می‌کنم", "پیشنهاد می‌دهم"
+  ],
+  "negative": [
+    "بد", "زشت", "ناگوار", "ناخوشایند", "نفرت", "نپسندیدم",
+    "بد", "بد", "بد", "زشت", "ناگوار", "ناخوشایند",
+    "نپسندیدم", "خوشم نیامد", "دوست ندارم", "نفرت دارم", "متنفرم",
+    "غمگین", "عصبانی", "ناراحت", "ناامید", "مایوس", "دلگیر",
+    "ناامیدی", "یأس", "ناامیدی", "نومیدی", "ناامیدی",
+    "خسته کننده", "کسل کننده", "خسته‌کننده", "ملال‌آور", "خسته‌کننده",
+    "ناگوار", "ناخوشایند", "ناپسند", "منفور", "متنفر",
+    "ناراضی", "غمگین", "اندوهگین", "غمناک", "دردناک", "اندوهناک",
+    "غم", "اندوه", "درد", "رنج", "الم", "غم", "اندوه",
+    "عصبانیت", "خشم", "غضب", "خشم", "عصبانیت", "خشم",
+    "ناراحت", "ناخوشنود", "ناراضی", "ناراضی", "ناراضی",
+    "کند", "آهسته", "دیر", "تاخیر", "تنبل", "کند",
+    "گران", "پرهزینه", "گران", "گران قیمت", "پرهزینه",
+    "کثیف", "آلوده", "ناپاک", "کثیف", "آلوده", "ناپاک",
+    "خطرناک", "ریسکی", "مضر", "خطرناک", "ناامن", "خطرناک",
+    "خراب", "معیوب", "ناقص", "ناقص", "ناقص", "ناقص",
+    "غیر قابل اعتماد", "غیر قابل اعتماد", "ناپایدار", "ناپایدار", "نامطمئن",
+    "بی‌فایده", "بی‌فایده", "بی‌فایده", "بی‌معنی", "بی‌معنی",
+    "پیچیده", "مشکل", "نامفهوم", "مبهم", "مبهم", "مبهم",
+    "شکایت", "درد", "مشکل", "مسئله", "ناراحتی", "درد",
+    "اشتباه", "خطا", "نقص", "کمبود", "کمبود", "نقص",
+    "پشیمانی", "ندامت", "غم", "اندوه", "درد", "الم",
+    "نگرانی", "اضطراب", "استرس", "فشار", "تنش", "نگرانی",
+    "ترس", "وحشت", "هراس", "هشدار", "نگرانی", "اضطراب",
+    "درد", "الم", "رنج", "الم", "الم", "رنج",
+    "ضعیف", "ناتوان", "ضعیف", "شکننده", "حساس", "شکننده",
+    "احمق", "نادان", "احمق", "بی‌معنی", "بی‌معنی", "بی‌منطق",
+    "تنبل", "کند", "بیکار", "خالی", "بی‌حرکت", "ساکن",
+    "بی‌ادب", "ناسزاگو", "زخم‌زبان", "ناعادلانه", "ناعادلانه",
+    "خودخواه", "حریص", "خودخواه", "خودخواه", "خودخواه",
+    "نادرست", "فریبنده", "گمراه‌کننده", "جعلی", "دروغگو",
+    "ناعادلانه", "ناعادلانه", "متعصب", "تبعیض‌آمیز", "نابرابر",
+    "رد", "انکار", "نفی", "رد", "نپذیرفتن"
+  ],
+  "intensifiers": {
+    "خیلی": 1.5,
+    "بسیار": 1.6,
+    "فوق العاده": 2.0,
+    "کاملا": 1.8,
+    "و��قعا": 1.3,
+    "نسبتا": 1.2,
+    "زیاد": 1.4,
+    "تمام": 1.5,
+    "حتما": 1.7,
+    "شدیدا": 1.6,
+    "به شدت": 1.7,
+    "بسیار زیاد": 1.8,
+    "خیلی زیاد": 1.7,
+    "بسیار": 1.6,
+    "به کرات": 1.5,
+    "بیش از حد": 1.6,
+    "به طور کامل": 1.5,
+    "کاملا": 1.8,
+    "تماما": 1.5,
+    "به طور کامل": 1.5
+  },
+  "negation": [
+    "نیست", "نیست", "نه", "هیچ", "هیچ وقت", "هرگز",
+    "نمی", "نمی‌کنم", "نکردم", "نخواهم کرد",
+    "نمی‌خواهم", "نپسندیدم", "خوشم نمی‌آید",
+    "نیستم", "نیستی", "نیست", "نیستیم", "نیستید", "نیستند",
+    "نیست", "نیست", "نیست", "نیست", "نیست", "نیست",
+    "نه", "نیست", "نیست", "نیست", "هرگز", "هیچ",
+    "نه...نه", "نه هم", "هیچ", "هیچ وقت", "هرگز"
+  ],
+  "diminishers": {
+    "کمی": 0.7,
+    "کم": 0.6,
+    "کمی": 0.7,
+    "کوچک": 0.7,
+    "سبک": 0.8,
+    "نسبتا": 0.85,
+    "نسبتا": 0.9,
+    "تقریبا": 0.8,
+    "تقریبا": 0.8,
+    "تا حدی": 0.7,
+    "جزئی": 0.7
+  },
+  "contrast_words": [
+    "اما", "ولی", "لیکن", "با این حال", "با این وجود",
+    "با این حال", "با این وجود", "با این حال",
+    "در حالی که", "در حالی که", "در حالی که", "بر خلاف", "بر خلاف"
+  ]
+}

lexicons/turkish_lexicon.json

@@ -0,0 +1,119 @@
+{
+  "positive": [
+    "iyi", "güzel", "harika", "mükemmel", "muhteşem", "süper", "müthiş", "olağanüstü",
+    "seviyorum", "beğendim", "beğeniyorum", "hoşlanıyorum", "sevdim", "aşığım",
+    "hoş", "güzel", "şahane", "nefis", "leziz", "tatlı", "sevimli", "hoş",
+    "başarılı", "başarılı", "başarı", "zafer", "galibiyet", "kazanç",
+    "memnun", "mutlu", "sevinçli", "neşeli", "keyifli", "zevkli", "hoşnut",
+    "tatmin", "memnuniyet", "beğeni", "hoşnutluk", "razı", "kabul",
+    "övgü", "takdir", "alkış", "bravo", "aferin", "tebrik", "kutlama",
+    "mükemmel", "kusursuz", "mükemmeliyet", "mükemmellik", "mükemmel",
+    "harika", "muhteşem", "olağanüstü", "fevkalade", "sıra dışı",
+    "güzel", "hoş", "şirin", "sevimli", "çekici", "cazibeli", "alımlı",
+    "mutlu", "sevinçli", "neşeli", "keyifli", "şen", "sevinç dolu",
+    "başarılı", "başarılı", "başarılı", "başarılı", "başarılı",
+    "faydalı", "yararlı", "kullanışlı", "pratik", "etkili", "verimli",
+    "kaliteli", "nitelikli", "üstün", "yüksek kalite", "premium",
+    "hızlı", "çabuk", "süratli", "tez", "ivedi", "acele",
+    "ucuz", "ekonomik", "uygun fiyatlı", "makul", "cazip",
+    "temiz", "düzenli", "tertipli", "derli toplu", "düzenli",
+    "güvenli", "emniyetli", "güvenilir", "sağlam", "istikrarlı",
+    "rahat", "konforlu", "huzurlu", "sakin", "dingin", "sükunetli",
+    "eğlenceli", "keyifli", "zevkli", "hoş", "neşeli", "şen",
+    "yeni", "modern", "çağdaş", "güncel", "aktüel", "fresh",
+    "kolay", "basit", "sade", "anlaşılır", "açık", "net",
+    "öneriyorum", "tavsiye ediyorum", "öneririm", "tavsiye ederim"
+  ],
+  "negative": [
+    "kötü", "berbat", "çirkin", "iğrenç", "nefret", "beğenmedim", "hoşlanmadım",
+    "kötü", "fena", "berbat", "rezil", "korkunç", "dehşet", "felaket",
+    "beğenmedim", "hoşlanmadım", "sevmedim", "nefret ediyorum", "tiksinme",
+    "üzgün", "kızgın", "sinirli", "öfkeli", "hiddetli", "kızgın",
+    "hayal kırıklığı", "hayal kırıklığı", "umutsuzluk", "çaresizlik",
+    "can sıkıcı", "sıkıcı", "bıktırıcı", "usandırıcı", "bezdirici",
+    "tatsız", "hoş olmayan", "nahoş", "itici", "tiksindirici",
+    "mutsuz", "üzgün", "kederli", "hüzünlü", "acılı", "elemli",
+    "üzüntü", "keder", "acı", "elem", "hüzün", "gam", "kaygı",
+    "kızgınlık", "öfke", "sinir", "hiddet", "gazap", "kızgınlık",
+    "rahatsız", "hoşnutsuz", "memnuniyetsiz", "beğenmeme", "razı olmama",
+    "yavaş", "ağır", "gecikmiş", "gecikmeli", "tembel", "atıl",
+    "pahalı", "masraflı", "maliyetli", "pahalı", "yüksek fiyatlı",
+    "kirli", "pis", "murdar", "kirli", "pasaklı", "dağınık",
+    "tehlikeli", "riskli", "zararlı", "tehlikeli", "güvensiz",
+    "bozuk", "arızalı", "hatalı", "kusurlu", "eksik", "noksan",
+    "güvensiz", "güvenilmez", "istikrarsız", "kararsız", "belirsiz",
+    "işe yaramaz", "faydasız", "yararsız", "boş", "anlamsız",
+    "karmaşık", "karışık", "anlaşılmaz", "belirsiz", "muğlak",
+    "şikayet", "dert", "sorun", "problem", "sıkıntı", "dert",
+    "hata", "yanlış", "kusur", "eksiklik", "noksanlık", "arız",
+    "pişmanlık", "nedamet", "üzüntü", "keder", "acı", "elem",
+    "endişe", "kaygı", "stres", "baskı", "gerilim", "tedirginlik",
+    "korku", "dehşet", "panik", "alarm", "endişe", "kaygı",
+    "ağrı", "acı", "sancı", "sızı", "elem", "ızdırap",
+    "zayıf", "güçsüz", "cılız", "narin", "hassas", "kırılgan",
+    "aptal", "ahmak", "budala", "saçma", "anlamsız", "mantıksız",
+    "tembel", "atalet", "işsiz", "boş", "hareketsiz", "durgun",
+    "kaba", "nezaketsiz", "kırıcı", "incitici", "haksız", "adil olmayan",
+    "bencil", "açgözlü", "kendini düşünen", "egoist", "narsist",
+    "dürüst olmayan", "aldatıcı", "yanıltıcı", "sahte", "yalancı",
+    "haksız", "adil olmayan", "önyargılı", "ayrımcı", "eşitsiz",
+    "reddet", "ret", "inkar", "yadsıma", "kabul etmeme"
+  ],
+  "intensifiers": {
+    "çok": 1.5,
+    "çok fazla": 1.6,
+    "aşırı": 2.0,
+    "son derece": 1.8,
+    "gerçekten": 1.3,
+    "oldukça": 1.2,
+    "fazlasıyla": 1.4,
+    "tamamen": 1.5,
+    "kesinlikle": 1.7,
+    "müthiş": 1.6,
+    "fevkalade": 1.8,
+    "olağanüstü": 1.9,
+    "son derece": 1.8,
+    "hayli": 1.4,
+    "epey": 1.3,
+    "bir hayli": 1.4,
+    "oldukça": 1.2,
+    "epeyce": 1.3,
+    "hayli": 1.4,
+    "daha": 1.3,
+    "en": 1.5,
+    "pek": 1.4,
+    "gayet": 1.3,
+    "iyice": 1.4,
+    "iyiden iyiye": 1.5
+  },
+  "negation": [
+    "değil", "yok", "hayır", "hiç", "hiçbir", "hiçbir şey",
+    "hiçbir zaman", "asla", "bir daha", "olmaz", "olmayacak",
+    "yapmam", "yapmıyorum", "yapmadım", "yapmayacağım",
+    "istemiyorum", "beğenmedim", "hoşlanmıyorum",
+    "değilim", "değilsin", "değil", "değiliz", "değilsiniz", "değiller",
+    "yok", "yoktur", "yoktur", "yok", "yok", "yok",
+    "hayır", "olmaz", "yok", "değil", "asla", "hiç",
+    "ne...ne", "ne de", "hiç de", "hiç değil", "asla değil"
+  ],
+  "diminishers": {
+    "biraz": 0.7,
+    "az": 0.6,
+    "birazcık": 0.7,
+    "küçük": 0.7,
+    "hafif": 0.8,
+    "nispeten": 0.85,
+    "oldukça": 0.9,
+    "epey": 0.9,
+    "hayli": 0.9,
+    "neredeyse": 0.8,
+    "hemen hemen": 0.8,
+    "kısmen": 0.7,
+    "kısmi": 0.7
+  },
+  "contrast_words": [
+    "ama", "fakat", "lakin", "ancak", "yalnız", "sadece",
+    "buna rağmen", "yine de", "gene de", "bununla birlikte",
+    "oysa", "oysaki", "halbuki", "buna karşın", "bunun aksine"
+  ]
+}

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.0.0
+

sentiment_analyzer.py

@@ -0,0 +1,555 @@
+"""
+Multilingual Sentiment Analysis Tool
+Supports Turkish, Persian, and English using lexicon-based and machine learning approaches
+"""
+
+import re
+import json
+import os
+from typing import Dict, List, Tuple, Optional
+from collections import Counter
+import math
+
+
+class SentimentLexicon:
+    """Base class for sentiment lexicons"""
+    
+    def __init__(self, language: str):
+        self.language = language
+        self.positive_words = set()
+        self.negative_words = set()
+        self.intensifiers = {}
+        self.negation_words = set()
+        self.diminishers = {}
+        self.contrast_words = set()
+        self.idioms_positive = []
+        self.idioms_negative = []
+        self._load_lexicon()
+    
+    def _load_lexicon(self):
+        """Load language-specific sentiment lexicon"""
+        lexicon_file = f"lexicons/{self.language}_lexicon.json"
+        if os.path.exists(lexicon_file):
+            with open(lexicon_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                self.positive_words = set(data.get('positive', []))
+                self.negative_words = set(data.get('negative', []))
+                self.intensifiers = data.get('intensifiers', {})
+                self.negation_words = set(data.get('negation', []))
+                self.diminishers = data.get('diminishers', {})
+                self.contrast_words = set(data.get('contrast_words', []))
+                self.idioms_positive = data.get('idioms_positive', [])
+                self.idioms_negative = data.get('idioms_negative', [])
+        else:
+            # Default English lexicon
+            self._load_default_english()
+    
+    def _load_default_english(self):
+        """Load default English sentiment words"""
+        self.positive_words = {
+            'good', 'great', 'excellent', 'amazing', 'wonderful', 'fantastic',
+            'love', 'like', 'best', 'perfect', 'beautiful', 'nice', 'happy',
+            'pleased', 'satisfied', 'awesome', 'brilliant', 'outstanding'
+        }
+        self.negative_words = {
+            'bad', 'terrible', 'awful', 'horrible', 'worst', 'hate', 'dislike',
+            'poor', 'disappointed', 'sad', 'angry', 'frustrated', 'annoying',
+            'boring', 'ugly', 'awful', 'disgusting', 'pathetic'
+        }
+        self.intensifiers = {
+            'very': 1.5, 'extremely': 2.0, 'really': 1.3, 'quite': 1.2,
+            'too': 1.4, 'so': 1.3, 'absolutely': 1.8, 'completely': 1.5
+        }
+        self.negation_words = {
+            'not', 'no', 'never', 'none', 'nobody', 'nothing', 'nowhere',
+            'neither', 'cannot', "can't", "won't", "don't", "doesn't"
+        }
+        self.diminishers = {}
+        self.contrast_words = set()
+        self.idioms_positive = []
+        self.idioms_negative = []
+
+
+class TextPreprocessor:
+    """Text preprocessing for different languages"""
+    
+    def __init__(self, language: str):
+        self.language = language
+    
+    def preprocess(self, text: str) -> List[str]:
+        """Preprocess text and return tokens"""
+        # Convert to lowercase
+        text = text.lower()
+        
+        # Remove URLs
+        text = re.sub(r'http\S+|www\S+|https\S+', '', text, flags=re.MULTILINE)
+        
+        # Remove email addresses
+        text = re.sub(r'\S+@\S+', '', text)
+        
+        # Remove special characters but keep punctuation for sentiment analysis
+        text = re.sub(r'[^\w\s\.,!?;:()\-\']', '', text)
+        
+        # Tokenize
+        tokens = re.findall(r'\b\w+\b|[.,!?;:()]', text)
+        
+        return tokens
+    
+    def normalize_turkish(self, text: str) -> str:
+        """Normalize Turkish text (handle special characters)"""
+        # Turkish character normalization
+        replacements = {
+            'ı': 'i', 'İ': 'I',
+            'ğ': 'g', 'Ğ': 'G',
+            'ü': 'u', 'Ü': 'U',
+            'ş': 's', 'Ş': 'S',
+            'ö': 'o', 'Ö': 'O',
+            'ç': 'c', 'Ç': 'C'
+        }
+        for old, new in replacements.items():
+            text = text.replace(old, new)
+        return text
+    
+    def normalize_persian(self, text: str) -> str:
+        """Normalize Persian text (handle different character forms)"""
+        # Persian/Arabic character normalization
+        # This is a simplified version - real implementation would be more complex
+        return text
+
+
+class LexiconBasedAnalyzer:
+    """Lexicon-based sentiment analysis with enhanced features"""
+    
+    def __init__(self, language: str):
+        self.language = language
+        self.lexicon = SentimentLexicon(language)
+        self.preprocessor = TextPreprocessor(language)
+    
+    def _check_idioms(self, text: str) -> Tuple[float, float]:
+        """Check for sentiment idioms in text"""
+        pos_score = 0.0
+        neg_score = 0.0
+        text_lower = text.lower()
+        
+        for idiom in self.lexicon.idioms_positive:
+            if idiom.lower() in text_lower:
+                pos_score += 2.0  # Idioms carry stronger sentiment
+        
+        for idiom in self.lexicon.idioms_negative:
+            if idiom.lower() in text_lower:
+                neg_score += 2.0
+        
+        return pos_score, neg_score
+    
+    def analyze(self, text: str) -> Dict:
+        """Analyze sentiment using lexicon-based approach"""
+        tokens = self.preprocessor.preprocess(text)
+        text_lower = text.lower()
+        
+        positive_score = 0
+        negative_score = 0
+        sentiment_words = []
+        negation_count = 0
+        
+        # Check idioms first
+        idiom_pos, idiom_neg = self._check_idioms(text)
+        positive_score += idiom_pos
+        negative_score += idiom_neg
+        
+        # Check for negation and intensifiers with improved scope detection
+        window_size = 4  # Increased window for better context
+        i = 0
+        while i < len(tokens):
+            token = tokens[i]
+            is_negated = False
+            intensifier_strength = 1.0
+            diminisher_strength = 1.0
+            
+            # Check for negation in window (improved scope)
+            for j in range(max(0, i - window_size), min(len(tokens), i + window_size + 1)):
+                if tokens[j] in self.lexicon.negation_words:
+                    # Check if negation is still in scope (not interrupted by punctuation)
+                    if j < i:
+                        # Check for punctuation between negation and token
+                        has_punctuation = any(
+                            tokens[k] in ['.', '!', '?', ';', ','] 
+                            for k in range(j + 1, i)
+                        )
+                        if not has_punctuation:
+                            is_negated = True
+                            negation_count += 1
+                            break
+            
+            # Check for intensifiers
+            if i > 0 and tokens[i-1] in self.lexicon.intensifiers:
+                intensifier_strength = self.lexicon.intensifiers[tokens[i-1]]
+            
+            # Check for diminishers
+            if i > 0 and tokens[i-1] in self.lexicon.diminishers:
+                diminisher_strength = self.lexicon.diminishers[tokens[i-1]]
+            
+            # Check sentiment
+            if token in self.lexicon.positive_words:
+                score = 1.0 * intensifier_strength * diminisher_strength
+                if is_negated:
+                    negative_score += score
+                    sentiment_words.append(('negative', token, is_negated))
+                else:
+                    positive_score += score
+                    sentiment_words.append(('positive', token, is_negated))
+            elif token in self.lexicon.negative_words:
+                score = 1.0 * intensifier_strength * diminisher_strength
+                if is_negated:
+                    positive_score += score
+                    sentiment_words.append(('positive', token, is_negated))
+                else:
+                    negative_score += score
+                    sentiment_words.append(('negative', token, is_negated))
+            
+            i += 1
+        
+        # Calculate final sentiment
+        total_score = positive_score + negative_score
+        if total_score == 0:
+            polarity = 'neutral'
+            confidence = 0.0
+        elif positive_score > negative_score:
+            polarity = 'positive'
+            confidence = positive_score / total_score if total_score > 0 else 0.0
+        else:
+            polarity = 'negative'
+            confidence = negative_score / total_score if total_score > 0 else 0.0
+        
+        return {
+            'polarity': polarity,
+            'confidence': round(confidence, 3),
+            'positive_score': round(positive_score, 3),
+            'negative_score': round(negative_score, 3),
+            'sentiment_words': sentiment_words[:10],  # Limit to first 10
+            'method': 'lexicon-based'
+        }
+
+
+class RuleBasedAnalyzer:
+    """Rule-based sentiment analysis with advanced linguistic rules"""
+    
+    def __init__(self, language: str):
+        self.language = language
+        self.lexicon = SentimentLexicon(language)
+        self.preprocessor = TextPreprocessor(language)
+    
+    def _detect_emoticons(self, text: str) -> Tuple[float, float]:
+        """Detect and score emoticons and emojis"""
+        pos_score = 0.0
+        neg_score = 0.0
+        
+        # Positive emoticons
+        positive_emoticons = [
+            ':)', ':-)', '=)', ';)', ';-)', '=D', ':D', ':-D',
+            '😊', '😀', '😁', '😂', '🤣', '😃', '😄', '😆', '😍', '🥰',
+            '😎', '🤗', '👍', '👏', '🎉', '❤️', '💕', '💖', '💗', '💓'
+        ]
+        
+        # Negative emoticons
+        negative_emoticons = [
+            ':(', ':-(', '=(', ':/', ':-/', ':|', ':-|', '>:(', '>:(',
+            '😢', '😞', '😠', '😡', '😤', '😭', '😰', '😨', '😱', '😖',
+            '😣', '😫', '😩', '👎', '💔', '😒', '😔', '😕', '🙁'
+        ]
+        
+        for emoji in positive_emoticons:
+            count = text.count(emoji)
+            pos_score += count * 1.5
+        
+        for emoji in negative_emoticons:
+            count = text.count(emoji)
+            neg_score += count * 1.5
+        
+        return pos_score, neg_score
+    
+    def _handle_contrast_words(self, text: str, tokens: List[str], 
+                                pos_score: float, neg_score: float) -> Tuple[float, float]:
+        """Handle contrast words that may shift sentiment"""
+        # Find contrast words and adjust sentiment
+        contrast_positions = []
+        for i, token in enumerate(tokens):
+            if token.lower() in self.lexicon.contrast_words:
+                contrast_positions.append(i)
+        
+        # If contrast word found, reduce weight of sentiment before it
+        if contrast_positions:
+            # Simple heuristic: reduce earlier sentiment by 30%
+            reduction_factor = 0.7
+            return pos_score * reduction_factor, neg_score * reduction_factor
+        
+        return pos_score, neg_score
+    
+    def _detect_comparatives_superlatives(self, tokens: List[str]) -> float:
+        """Detect comparative and superlative forms that intensify sentiment"""
+        multiplier = 1.0
+        
+        # Check for superlatives
+        superlative_indicators = ['most', 'best', 'worst', 'least', 'greatest']
+        for token in tokens:
+            if token.lower() in superlative_indicators:
+                multiplier = max(multiplier, 1.4)
+        
+        # Check for comparatives
+        comparative_patterns = ['more', 'less', 'better', 'worse', 'greater', 'smaller']
+        for token in tokens:
+            if token.lower() in comparative_patterns:
+                multiplier = max(multiplier, 1.2)
+        
+        return multiplier
+    
+    def _detect_repetition(self, text: str) -> float:
+        """Detect repeated characters/words that indicate emphasis"""
+        multiplier = 1.0
+        
+        # Repeated characters (e.g., "soooo good")
+        repeated_chars = re.findall(r'(\w)\1{2,}', text.lower())
+        if repeated_chars:
+            multiplier += len(repeated_chars) * 0.1
+        
+        # Repeated words (e.g., "good good good")
+        words = text.lower().split()
+        if len(words) > 2:
+            for i in range(len(words) - 2):
+                if words[i] == words[i+1] == words[i+2]:
+                    multiplier += 0.2
+                    break
+        
+        return min(multiplier, 1.5)  # Cap at 1.5x
+    
+    def _detect_sentiment_shifters(self, text: str) -> float:
+        """Detect words that shift sentiment polarity"""
+        shifters = {
+            'but': 0.6, 'however': 0.6, 'although': 0.7, 'though': 0.7,
+            'yet': 0.6, 'still': 0.7, 'nevertheless': 0.6, 'nonetheless': 0.6
+        }
+        
+        text_lower = text.lower()
+        for shifter, factor in shifters.items():
+            if shifter in text_lower:
+                return factor
+        
+        return 1.0
+    
+    def analyze(self, text: str) -> Dict:
+        """Analyze sentiment using rule-based approach with advanced rules"""
+        # Use lexicon-based as base
+        base_analyzer = LexiconBasedAnalyzer(self.language)
+        result = base_analyzer.analyze(text)
+        
+        # Apply advanced rules
+        tokens = self.preprocessor.preprocess(text)
+        text_lower = text.lower()
+        
+        # Rule 1: Exclamation marks increase sentiment strength
+        exclamation_count = text.count('!')
+        if exclamation_count > 0:
+            multiplier = 1 + min(exclamation_count * 0.15, 0.5)  # Cap at 50% increase
+            result['positive_score'] *= multiplier
+            result['negative_score'] *= multiplier
+        
+        # Rule 2: Question marks may indicate uncertainty or sarcasm
+        question_count = text.count('?')
+        if question_count > 1:
+            uncertainty_factor = max(0.7, 1 - (question_count * 0.1))
+            result['confidence'] *= uncertainty_factor
+        
+        # Rule 3: All caps increase sentiment strength (but check length)
+        caps_words = [w for w in text.split() if w.isupper() and len(w) > 2]
+        if len(caps_words) > 0:
+            caps_multiplier = 1 + (len(caps_words) * 0.1)
+            result['positive_score'] *= caps_multiplier
+            result['negative_score'] *= caps_multiplier
+        
+        # Rule 4: Enhanced emoticon detection
+        emoji_pos, emoji_neg = self._detect_emoticons(text)
+        result['positive_score'] += emoji_pos
+        result['negative_score'] += emoji_neg
+        
+        # Rule 5: Contrast words handling
+        result['positive_score'], result['negative_score'] = self._handle_contrast_words(
+            text, tokens, result['positive_score'], result['negative_score']
+        )
+        
+        # Rule 6: Comparatives and superlatives
+        comp_super_mult = self._detect_comparatives_superlatives(tokens)
+        result['positive_score'] *= comp_super_mult
+        result['negative_score'] *= comp_super_mult
+        
+        # Rule 7: Repetition detection
+        rep_mult = self._detect_repetition(text)
+        result['positive_score'] *= rep_mult
+        result['negative_score'] *= rep_mult
+        
+        # Rule 8: Sentiment shifters
+        shifter_factor = self._detect_sentiment_shifters(text)
+        if shifter_factor < 1.0:
+            # Reduce earlier sentiment
+            result['positive_score'] *= shifter_factor
+            result['negative_score'] *= shifter_factor
+        
+        # Rule 9: Ellipsis may indicate uncertainty or trailing off
+        if '...' in text or '…' in text:
+            result['confidence'] *= 0.9
+        
+        # Rule 10: Multiple punctuation (e.g., "!!!") increases emphasis
+        multi_punct = re.findall(r'[!?]{2,}', text)
+        if multi_punct:
+            punct_mult = 1 + (len(multi_punct) * 0.1)
+            result['positive_score'] *= punct_mult
+            result['negative_score'] *= punct_mult
+        
+        # Rule 11: Hashtags in social media context
+        hashtags = re.findall(r'#\w+', text)
+        if hashtags:
+            # Check if hashtags contain sentiment words
+            for tag in hashtags:
+                tag_lower = tag.lower()
+                if any(word in tag_lower for word in self.lexicon.positive_words):
+                    result['positive_score'] += 0.5
+                if any(word in tag_lower for word in self.lexicon.negative_words):
+                    result['negative_score'] += 0.5
+        
+        # Rule 12: URL presence may indicate spam or less personal content
+        if re.search(r'http[s]?://', text):
+            result['confidence'] *= 0.95
+        
+        # Rule 13: Length-based confidence adjustment
+        word_count = len(text.split())
+        if word_count < 3:
+            result['confidence'] *= 0.8  # Very short texts are less reliable
+        elif word_count > 100:
+            result['confidence'] *= 0.95  # Very long texts may have mixed sentiment
+        
+        # Recalculate polarity
+        total = result['positive_score'] + result['negative_score']
+        if total > 0:
+            if result['positive_score'] > result['negative_score']:
+                result['polarity'] = 'positive'
+                result['confidence'] = result['positive_score'] / total
+            else:
+                result['polarity'] = 'negative'
+                result['confidence'] = result['negative_score'] / total
+        else:
+            result['polarity'] = 'neutral'
+            result['confidence'] = 0.0
+        
+        result['method'] = 'rule-based'
+        return result
+
+
+class HybridAnalyzer:
+    """Hybrid approach combining lexicon, rules, and simple ML features"""
+    
+    def __init__(self, language: str):
+        self.language = language
+        self.lexicon_analyzer = LexiconBasedAnalyzer(language)
+        self.rule_analyzer = RuleBasedAnalyzer(language)
+    
+    def analyze(self, text: str) -> Dict:
+        """Analyze sentiment using hybrid approach"""
+        # Get results from both methods
+        lexicon_result = self.lexicon_analyzer.analyze(text)
+        rule_result = self.rule_analyzer.analyze(text)
+        
+        # Combine scores with weights
+        lexicon_weight = 0.4
+        rule_weight = 0.6
+        
+        combined_positive = (lexicon_result['positive_score'] * lexicon_weight + 
+                           rule_result['positive_score'] * rule_weight)
+        combined_negative = (lexicon_result['negative_score'] * lexicon_weight + 
+                           rule_result['negative_score'] * rule_weight)
+        
+        total = combined_positive + combined_negative
+        if total == 0:
+            polarity = 'neutral'
+            confidence = 0.0
+        elif combined_positive > combined_negative:
+            polarity = 'positive'
+            confidence = combined_positive / total
+        else:
+            polarity = 'negative'
+            confidence = combined_negative / total
+        
+        return {
+            'polarity': polarity,
+            'confidence': round(confidence, 3),
+            'positive_score': round(combined_positive, 3),
+            'negative_score': round(combined_negative, 3),
+            'lexicon_result': lexicon_result,
+            'rule_result': rule_result,
+            'method': 'hybrid'
+        }
+
+
+class MultilingualSentimentAnalyzer:
+    """Main sentiment analyzer supporting multiple languages and methods"""
+    
+    def __init__(self, language: str = 'english', method: str = 'hybrid'):
+        """
+        Initialize sentiment analyzer
+        
+        Args:
+            language: 'english', 'turkish', or 'persian'
+            method: 'lexicon', 'rule', or 'hybrid'
+        """
+        self.language = language.lower()
+        self.method = method.lower()
+        
+        if method == 'lexicon':
+            self.analyzer = LexiconBasedAnalyzer(self.language)
+        elif method == 'rule':
+            self.analyzer = RuleBasedAnalyzer(self.language)
+        else:  # hybrid
+            self.analyzer = HybridAnalyzer(self.language)
+    
+    def analyze(self, text: str) -> Dict:
+        """Analyze sentiment of input text"""
+        if not text or not text.strip():
+            return {
+                'polarity': 'neutral',
+                'confidence': 0.0,
+                'error': 'Empty text provided'
+            }
+        
+        try:
+            result = self.analyzer.analyze(text)
+            result['language'] = self.language
+            result['text_length'] = len(text)
+            result['word_count'] = len(text.split())
+            return result
+        except Exception as e:
+            return {
+                'polarity': 'neutral',
+                'confidence': 0.0,
+                'error': str(e)
+            }
+    
+    def analyze_batch(self, texts: List[str]) -> List[Dict]:
+        """Analyze multiple texts"""
+        return [self.analyze(text) for text in texts]
+    
+    def get_statistics(self, texts: List[str]) -> Dict:
+        """Get aggregate statistics for a batch of texts"""
+        results = self.analyze_batch(texts)
+        
+        polarity_counts = Counter([r['polarity'] for r in results])
+        total = len(results)
+        
+        avg_confidence = sum([r.get('confidence', 0) for r in results]) / total if total > 0 else 0
+        
+        return {
+            'total_texts': total,
+            'polarity_distribution': dict(polarity_counts),
+            'polarity_percentages': {
+                k: round(v / total * 100, 2) 
+                for k, v in polarity_counts.items()
+            },
+            'average_confidence': round(avg_confidence, 3)
+        }
+