Upload folder using huggingface_hub

deploy.py

@@ -1,43 +1,687 @@
 
-#file is saved as deploy.py
+# This deploy.py file contains the complete code for the Instagram Reels Analysis Gradio App.
 
-import io # Import io for handling image bytes
+# --- Imports ---
 import gradio as gr
+import time
+import random
+import matplotlib.pyplot as plt
+import pandas as pd
+import torch
+import emoji
+import re
+import numpy as np
+import io # Import io for handling image bytes
 
-# Global variables to maintain state across Gradio calls
-# Assuming cl and explore_reels_list are already defined and populated by login/fetch steps
-# from previous cells in a real execution environment.
-# For this cell's context, we ensure they are declared global.
+from google.colab import userdata
+from instagrapi import Client
+from transformers import (
+    pipeline,
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    Trainer,
+    TrainingArguments,
+    RobertaForSequenceClassification,
+    AlbertForSequenceClassification
+)
+from datasets import Dataset, Features, Value
+from collections import Counter
+from sklearn.metrics import accuracy_score, f1_score
+
+# --- Configuration ---
+CONFIG = {
+    "max_length": 128,
+    "batch_size": 16,
+    "learning_rate": 2e-5,
+    "num_train_epochs": 3,
+    "few_shot_examples": 5,  # per class
+    "confidence_threshold": 0.7,
+    "neutral_reanalysis_threshold": 0.33
+}
+
+# --- Global Variables for State Management ---
 global cl
 global explore_reels_list
 global sentiment_analyzer_instance
 global content_classifier_pipeline
 
-# Initialize sentiment analyzer if not already done (can be done here or lazily in analyze_reels_gradio)
-# Doing it here ensures the model is loaded when this cell runs, potentially reducing latency on first analyze click.
-try:
-    sentiment_analyzer_instance = ReelSentimentAnalyzer()
-    print("Sentiment Analyzer initialized.")
-    # Optional: Train Hindi model if needed and data is available
-    # sample_train_data = [...] # Define your training data
-    # sentiment_analyzer_instance.train_hindi_model(sample_train_data)
-except Exception as e:
-    print(f"Error initializing Sentiment Analyzer globally: {e}")
-    sentiment_analyzer_instance = None
-
-
-# Initialize content classifier pipeline if not already done (can be done here or lazily)
-try:
-    print("Initializing Content Classifier Pipeline globally...")
-    content_classifier_pipeline = pipeline(
-        "zero-shot-classification",
-        model="facebook/bart-large-mnli",
-        device=0 if torch.cuda.is_available() else -1 # Use GPU if available
+cl = None
+explore_reels_list = []
+sentiment_analyzer_instance = None
+content_classifier_pipeline = None
+
+
+# --- Sentiment Analysis Class ---
+class ReelSentimentAnalyzer:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self._initialize_models()
+
+    def _initialize_models(self):
+        """Initialize and configure all models"""
+        print("\nInitializing Sentiment Analysis Models...")
+        # English models
+        print("Loading English Emotion Model...")
+        self.emotion_tokenizer = AutoTokenizer.from_pretrained("finiteautomata/bertweet-base-emotion-analysis")
+        self.emotion_model = AutoModelForSequenceClassification.from_pretrained(
+            "finiteautomata/bertweet-base-emotion-analysis"
+        ).to(self.device)
+        print("Loading English Sentiment Model...")
+        self.sentiment_tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment-latest")
+        self.sentiment_model = RobertaForSequenceClassification.from_pretrained(
+            "cardiffnlp/twitter-roberta-base-sentiment-latest",
+            ignore_mismatched_sizes=True
+        ).to(self.device)
+
+        # Hindi/English model (we'll fine-tune this)
+        print("Loading Indic-BERT Model for Hindi/Hinglish...")
+        self.hindi_tokenizer = AutoTokenizer.from_pretrained("ai4bharat/indic-bert")
+        self.hindi_model = AlbertForSequenceClassification.from_pretrained(
+            "ai4bharat/indic-bert",
+            num_labels=3,
+            id2label={0: "negative", 1: "neutral", 2: "positive"},
+            label2id={"negative": 0, "neutral": 1, "positive": 2}
+        ).to(self.device)
+        # Store label2id mapping for easy access
+        self.hindi_label2id = self.hindi_model.config.label2id
+        print("Models Initialized.")
+
+        # Emotion to sentiment mapping
+        self.emotion_map = {
+            "joy": "positive", "love": "positive", "happy": "positive",
+            "anger": "negative", "sadness": "negative", "fear": "negative",
+            "surprise": "neutral", "neutral": "neutral", "disgust": "negative", "shame": "negative"
+        }
+
+        # Neutral keywords
+        self.neutral_keywords = {
+            "ad", "sponsored", "promo", "sale", "discount", "offer", "giveaway",
+            "buy", "shop", "link in bio",
+            "विज्ञापन", "प्रचार", "ऑफर", "डिस्काउंट", "बिक्री", "लिंक ब���यो में"
+        }
+
+    def train_hindi_model(self, train_data, eval_data=None):
+        """
+        Fine-tune the Hindi/English model on labeled data
+        Args:
+            train_data: List of dicts [{"text": "...", "label": "positive/negative/neutral"}]
+            eval_data: Optional evaluation data
+        """
+        print("\nStarting Hindi model training...")
+        # Convert to dataset
+        train_dataset = Dataset.from_pandas(pd.DataFrame(train_data))
+
+        # Map string labels to integer IDs
+        def map_labels_to_ids(examples):
+            # Ensure label exists and is in expected range
+            labels = []
+            for label_str in examples["label"]:
+                 if label_str in self.hindi_label2id:
+                     labels.append(self.hindi_label2id[label_str])
+                 else:
+                     # Handle unexpected labels, maybe map to neutral or skip
+                     print(f"Warning: Unexpected label '{label_str}'. Mapping to neutral.")
+                     labels.append(self.hindi_label2id["neutral"]) # Map unknown to neutral
+            examples["label"] = labels
+            return examples
+
+
+        train_dataset = train_dataset.map(map_labels_to_ids, batched=True)
+
+        # Explicitly set the label column to integer type
+        train_dataset = train_dataset.cast_column("label", Value("int64"))
+
+
+        def tokenize_function(examples):
+            return self.hindi_tokenizer(
+                examples["text"],
+                padding="max_length",
+                truncation=True,
+                max_length=CONFIG["max_length"]
+            )
+
+        tokenized_train = train_dataset.map(tokenize_function, batched=True)
+
+        # Training arguments - using eval_strategy instead of evaluation_strategy
+        training_args = TrainingArguments(
+            output_dir="./results",
+            eval_strategy="epoch" if eval_data else "no",
+            per_device_train_batch_size=CONFIG["batch_size"],
+            per_device_eval_batch_size=CONFIG["batch_size"],
+            learning_rate=CONFIG["learning_rate"],
+            num_train_epochs=CONFIG["num_train_epochs"],
+            weight_decay=0.01,
+            save_strategy="no", # Don't save checkpoints during training
+            logging_dir='./logs',
+            logging_steps=10,
+            report_to="none" # Don't report to external services
+        )
+
+        # Compute metrics function
+        def compute_metrics(p):
+            predictions, labels = p
+            predictions = np.argmax(predictions, axis=1)
+            return {
+                "accuracy": accuracy_score(labels, predictions),
+                "f1": f1_score(labels, predictions, average="weighted")
+            }
+
+        # Trainer
+        eval_dataset_processed = None
+        if eval_data:
+            eval_dataset = Dataset.from_pandas(pd.DataFrame(eval_data))
+            eval_dataset = eval_dataset.map(map_labels_to_ids, batched=True)
+            eval_dataset_processed = eval_dataset.cast_column("label", Value("int64")).map(tokenize_function, batched=True)
+
+
+        trainer = Trainer(
+            model=self.hindi_model,
+            args=training_args,
+            train_dataset=tokenized_train,
+            eval_dataset=eval_dataset_processed,
+            compute_metrics=compute_metrics if eval_data else None,
+        )
+
+        # Train
+        trainer.train()
+
+        # Save the fine-tuned model
+        print("Saving fine-tuned Hindi model...")
+        self.hindi_model.save_pretrained("./fine_tuned_hindi_sentiment")
+        self.hindi_tokenizer.save_pretrained("./fine_tuned_hindi_sentiment")
+        print("Hindi model training complete.")
+
+    def preprocess_text(self, text):
+        """Enhanced text cleaning with multilingual support"""
+        if not text:
+            return ""
+
+        # Convert emojis to text
+        text = emoji.demojize(text, delimiters=(" ", " "))
+
+        # Remove URLs and mentions
+        text = re.sub(r"http\S+|@\w+", "", text)
+
+        # Expand common abbreviations (can be extended)
+        abbrevs = {
+            r"\bomg\b": "oh my god",
+            r"\btbh\b": "to be honest",
+            r"\bky\b": "kyun",  # Hindi 'why'
+            r"\bkb\b": "kab",   # Hindi 'when'
+            r"\bkya\b": "kya",  # Hindi 'what'
+            r"\bkahan\b": "kahan", # Hindi 'where'
+            r"\bkaisa\b": "kaisa" # Hindi 'how'
+        }
+        for pattern, replacement in abbrevs.items():
+            text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
+
+        # Remove extra whitespace
+        text = re.sub(r"\s+", " ", text).strip()
+
+        return text
+
+    def detect_language(self, text):
+        """Improved language detection"""
+        if re.search(r"[\u0900-\u097F]", text):  # Devanagari script (Hindi, Marathi etc.)
+            return "hi"
+        # Simple check for common Hindi/Hinglish words (can be expanded)
+        hinglish_keywords = ["hai", "kyun", "nahi", "kya", "acha", "bas", "yaar", "main"]
+        if any(re.search(rf"\b{kw}\b", text.lower()) for kw in hinglish_keywords):
+            return "hi-latin"
+        # Fallback to English if no strong Hindi/Hinglish indicators
+        return "en"
+
+
+    def analyze_content(self, text):
+        """Main analysis function with improved confidence handling"""
+        processed = self.preprocess_text(text)
+
+        if not processed:
+            return "neutral", 0.5, {"reason": "empty_text"}
+
+        lang = self.detect_language(processed)
+
+        # Check for neutral keywords first with higher confidence
+        if any(re.search(rf"\b{re.escape(kw)}\b", processed.lower()) for kw in self.neutral_keywords):
+            return "neutral", 0.9, {"reason": "neutral_keyword"}
+
+        try:
+            if lang in ("hi", "hi-latin"):
+                # Use Hindi model for Hindi/Hinglish
+                return self._analyze_hindi_content(processed)
+            else:
+                # Use ensemble for English
+                return self._analyze_english_content(processed)
+        except Exception as e:
+            print(f"Analysis error for text '{processed[:50]}...': {e}")
+            return "neutral", 0.5, {"error": str(e), "original_text": text[:50]}
+
+    def _analyze_hindi_content(self, text):
+        """Analyze Hindi content with fine-tuned model"""
+        inputs = self.hindi_tokenizer(
+            text,
+            return_tensors="pt",
+            truncation=True,
+            padding=True,
+            max_length=CONFIG["max_length"]
+        ).to(self.device)
+
+        with torch.no_grad():
+            outputs = self.hindi_model(**inputs)
+
+        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        pred_idx = torch.argmax(probs).item()
+        confidence = probs[0][pred_idx].item()
+
+        label = self.hindi_model.config.id2label[pred_idx]
+        return label, confidence, {"model": "fine-tuned-indic-bert", "lang": "hi"}
+
+    def _analyze_english_content(self, text):
+        """Analyze English content with ensemble approach"""
+        # Emotion analysis
+        emotion_inputs = self.emotion_tokenizer(
+            text,
+            return_tensors="pt",
+            truncation=True,
+            max_length=CONFIG["max_length"]
+        ).to(self.device)
+
+        with torch.no_grad():
+            emotion_outputs = self.emotion_model(**emotion_inputs)
+
+        emotion_probs = torch.nn.functional.softmax(emotion_outputs.logits, dim=-1)
+        emotion_pred = torch.argmax(emotion_probs).item()
+        emotion_label = self.emotion_model.config.id2label[emotion_pred]
+        emotion_score = emotion_probs[0][emotion_pred].item()
+
+        # Sentiment analysis
+        sentiment_inputs = self.sentiment_tokenizer(
+            text,
+            return_tensors="pt",
+            truncation=True,
+            max_length=CONFIG["max_length"]
+        ).to(self.device)
+
+        with torch.no_grad():
+            sentiment_outputs = self.sentiment_model(**sentiment_inputs)
+
+        sentiment_probs = torch.nn.functional.softmax(sentiment_outputs.logits, dim=-1)
+        sentiment_pred = torch.argmax(sentiment_probs).item()
+        # sentiment_label comes as 'LABEL_0', 'LABEL_1', 'LABEL_2'
+        # Need to map these to 'negative', 'neutral', 'positive'
+        # The roberta-base-sentiment-latest model has mapping: 0: Negative, 1: Neutral, 2: Positive
+        sentiment_label_mapping = {0: 'negative', 1: 'neutral', 2: 'positive'}
+        sentiment_label = sentiment_label_mapping.get(sentiment_pred, 'neutral') # Default to neutral if mapping fails
+        sentiment_score = sentiment_probs[0][sentiment_pred].item()
+
+        # Combine results
+        mapped_emotion = self.emotion_map.get(emotion_label, "neutral")
+
+        # Prioritize high-confidence sentiment
+        if sentiment_score > CONFIG["confidence_threshold"]:
+            final_label = sentiment_label
+            final_confidence = sentiment_score
+            reason = "high_sentiment_confidence"
+        # Then prioritize high-confidence emotion if not neutral
+        elif emotion_score > CONFIG["confidence_threshold"] and mapped_emotion != "neutral":
+            final_label = mapped_emotion
+            final_confidence = emotion_score
+            reason = "high_emotion_confidence"
+        else:
+            # Fallback mechanism for lower confidence or conflicting results
+            # A simple weighted sum or voting could be used,
+            # but let's use a clearer logic:
+            # If both are low confidence or neutral, and their results align, use that.
+            # Otherwise, default to neutral or pick the one with slightly higher confidence
+            # if it's not neutral.
+
+            if sentiment_label == mapped_emotion and sentiment_label != "neutral":
+                 final_label = sentiment_label
+                 final_confidence = (sentiment_score + emotion_score) / 2
+                 reason = "emotion_sentiment_agreement"
+            elif sentiment_label != "neutral" and sentiment_score > emotion_score and sentiment_score > 0.4: # Use sentiment if somewhat confident
+                 final_label = sentiment_label
+                 final_confidence = sentiment_score * 0.9 # Slightly reduce confidence
+                 reason = "sentiment_slightly_higher"
+            elif mapped_emotion != "neutral" and emotion_score > sentiment_score and emotion_score > 0.4: # Use emotion if somewhat confident
+                 final_label = mapped_emotion
+                 final_confidence = emotion_score * 0.9 # Slightly reduce confidence
+                 reason = "emotion_slightly_higher"
+            else: # Default to neutral if no strong signal
+                 final_label = "neutral"
+                 final_confidence = 0.6 # Assign a baseline neutral confidence
+                 reason = "fallback_to_neutral"
+
+
+        return final_label, final_confidence, {
+            "emotion_label": emotion_label,
+            "emotion_score": emotion_score,
+            "sentiment_label": sentiment_label,
+            "sentiment_score": sentiment_score,
+            "mapped_emotion": mapped_emotion,
+            "model": "ensemble",
+            "lang": "en",
+            "reason": reason
+        }
+
+    def analyze_reels(self, reels, max_to_analyze=100):
+        """Batch analysis with improved neutral handling"""
+        print(f"\n--- Starting Sentiment Analysis ({max_to_analyze} reels) ---")
+        results = Counter()
+        detailed_results = []
+
+        for i, reel in enumerate(reels[:max_to_analyze], 1):
+            caption = getattr(reel, 'caption_text', '') or getattr(reel, 'caption', '') or ''
+            print(f"Analyzing sentiment for reel {i}/{max_to_analyze} (ID: {reel.id})...")
+            label, confidence, details = self.analyze_content(caption)
+            results[label] += 1
+            detailed_results.append({
+                "reel_id": reel.id, # Add reel ID
+                "text": caption,
+                "label": label,
+                "confidence": confidence,
+                "details": details
+            })
+
+        print("\nInitial Sentiment Distribution:", dict(results))
+
+        # Post-analysis neutral reduction if a significant portion is neutral
+        total_analyzed = sum(results.values())
+        if total_analyzed > 0 and results["neutral"] / total_analyzed > CONFIG["neutral_reanalysis_threshold"]:
+            print(f"High neutral count ({results['neutral']}). Attempting to re-analyze...")
+            self._reduce_neutrals(results, detailed_results)
+            print("Sentiment distribution after re-analysis:", dict(results))
+
+        print("Sentiment Analysis Complete.")
+        return results, detailed_results
+
+    def _reduce_neutrals(self, results, detailed_results):
+        """Apply additional techniques to reduce neutral classifications"""
+        neutrals_to_recheck = [item for item in detailed_results if item["label"] == "neutral" and item["confidence"] < 0.8]
+
+        print(f"Re-checking {len(neutrals_to_recheck)} neutral reels...")
+
+        for item in neutrals_to_recheck:
+            original_text = item["text"]
+            processed_text = self.preprocess_text(original_text)
+            text_lower = processed_text.lower()
+
+            # Try keyword analysis for strong positive/negative signals
+            pos_keywords_strong = {"amazing", "love", "best", "fantastic", "awesome", "superb", "great",
+                                   "अद्भुत", "शानदार", "बहुत अच्छा", "मज़ेदार"}
+            neg_keywords_strong = {"hate", "worst", "bad", "terrible", "awful", "disappointed", "horrible", "cringe",
+                                   "खराब", "बेकार", "बहुत बुरा", "घटिया"}
+
+            is_strong_pos = any(re.search(rf"\b{re.escape(kw)}\b", text_lower) for kw in pos_keywords_strong)
+            is_strong_neg = any(re.search(rf"\b{re.escape(kw)}\b", text_lower) for kw in neg_keywords_strong)
+
+            if is_strong_pos and not is_strong_neg:
+                # Reclassify as positive if strong positive keywords found and no strong negative ones
+                results["neutral"] -= 1
+                results["positive"] += 1
+                item.update({
+                    "label": "positive",
+                    "confidence": min(0.95, item["confidence"] + 0.3), # Increase confidence
+                    "reanalyzed": True,
+                    "reanalysis_reason": "strong_pos_keywords"
+                })
+                # print(f"  Reclassified reel {item['reel_id']} to Positive (Keywords)")
+            elif is_strong_neg and not is_strong_pos:
+                # Reclassify as negative if strong negative keywords found and no strong positive ones
+                results["neutral"] -= 1
+                results["negative"] += 1
+                item.update({
+                    "label": "negative",
+                    "confidence": min(0.95, item["confidence"] + 0.3), # Increase confidence
+                    "reanalyzed": True,
+                    "reanalysis_reason": "strong_neg_keywords"
+                })
+                # print(f"  Reclassified reel {item['reel_id']} to Negative (Keywords)")
+            # Add other potential re-analysis rules here if needed
+            # e.g., checking for question marks (might indicate neutral query),
+            # or checking length (very short captions often neutral)
+            # For now, we stick to keyword-based re-analysis for simplicity
+
+
+def plot_sentiment_pie(results, title="Reels Sentiment Analysis"):
+    """
+    Creates a pie chart from sentiment analysis results and returns the matplotlib figure.
+
+    Args:
+        results: Counter object or dict with 'positive', 'neutral', 'negative' keys
+        title: Chart title
+
+    Returns:
+        Matplotlib Figure object, or None if no data.
+    """
+    labels = ['Positive', 'Neutral', 'Negative']
+    sizes = [results.get('positive', 0), results.get('neutral', 0), results.get('negative', 0)]
+
+    if sum(sizes) == 0:
+        return None
+
+    colors = ['#4CAF50', '#FFC107', '#F44336']
+    explode = (0.05, 0, 0.05)
+
+    fig, ax = plt.subplots(figsize=(8, 6))
+
+    filtered_labels = [label for i, label in enumerate(labels) if sizes[i] > 0]
+    filtered_sizes = [size for size in sizes if size > 0]
+    filtered_colors = [colors[i] for i, size in enumerate(sizes) if size > 0]
+    explode_map = {'Positive': 0.05, 'Neutral': 0, 'Negative': 0.05}
+    filtered_explode = [explode_map.get(label, 0) for label in filtered_labels]
+
+    ax.pie(filtered_sizes, explode=filtered_explode, labels=filtered_labels, colors=filtered_colors,
+           autopct='%1.1f%%', shadow=True, startangle=140,
+           textprops={'fontsize': 12, 'color': 'black'})
+
+    ax.axis('equal')
+    plt.title(title, fontsize=16, pad=20)
+    plt.tight_layout()
+
+    # Return the figure object
+    return fig
+
+# --- Content Analysis Logic ---
+# Content categories
+content_categories = [
+    "news", "meme", "sports", "science", "music", "movie",
+    "gym", "comedy", "food", "technology", "travel", "fashion", "art", "business"
+]
+
+category_keywords = {
+    "news": {"news", "update", "breaking", "reported", "headlines"},
+    "meme": {"meme", "funny", "lol", "haha", "relatable"},
+    "sports": {"sports", "cricket", "football", "match", "game", "team", "score"},
+    "science": {"science", "research", "discovery", "experiment", "facts", "theory"},
+    "music": {"music", "song", "album", "release", "artist", "beats"},
+    "movie": {"movie", "film", "bollywood", "trailer", "series", "actor"},
+    "gym": {"gym", "workout", "fitness", "exercise", "training", "bodybuilding"},
+    "comedy": {"comedy", "joke", "humor", "standup", "skit", "laugh"},
+    "food": {"food", "recipe", "cooking", "eat", "delicious", "restaurant", "kitchen"},
+    "technology": {"tech", "phone", "computer", "ai", "gadget", "software", "innovation"},
+    "travel": {"travel", "trip", "vacation", "explore", "destination", "adventure"},
+    "fashion": {"fashion", "style", "ootd", "outfit", "trends", "clothing"},
+    "art": {"art", "artist", "painting", "drawing", "creative", "design"},
+    "business": {"business", "startup", "marketing", "money", "finance", "entrepreneur"}
+}
+
+def preprocess_text_cat(text):
+    """Basic text cleaning for categorization"""
+    if not text:
+        return ""
+    text = re.sub(r"http\S+|@\w+|#\w+", "", text).lower()
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+def classify_reel_content(text):
+    """Classify content using keywords and zero-shot model"""
+    global content_classifier_pipeline # Use the global pipeline
+
+    processed = preprocess_text_cat(text)
+
+    if not processed or len(processed.split()) < 2:
+        return "other", {"reason": "short_text"}
+
+    for category, keywords in category_keywords.items():
+        if any(re.search(rf"\b{re.escape(keyword)}\b", processed) for keyword in keywords):
+            return category, {"reason": "keyword_match"}
+
+    model_text = processed[:256]
+
+    if content_classifier_pipeline is None:
+        # Should not happen if initialized in analyze_reels_gradio or globally
+        print("Content classifier pipeline not initialized in classify_reel_content.")
+        return "other", {"reason": "classifier_not_initialized"}
+
+    try:
+        result = content_classifier_pipeline(model_text, content_categories, multi_label=False)
+        top_label = result['labels'][0]
+        top_score = result['scores'][0]
+
+        if top_score > 0.5:
+             return top_label, {"reason": "model_prediction", "score": top_score}
+        else:
+             return "other", {"reason": "low_model_confidence", "score": top_score}
+
+    except Exception as e:
+        print(f"Error during zero-shot classification for text '{model_text}...': {e}")
+        return "other", {"reason": "classification_error"}
+
+
+def plot_category_distribution(counter, title="Reels Content Distribution"):
+    """
+    Generate pie chart from category counts and returns the matplotlib figure.
+
+    Args:
+        counter: Counter object with category counts.
+        title: Chart title.
+
+    Returns:
+        Matplotlib Figure object, or None if no data.
+    """
+    labels = []
+    sizes = []
+
+    total = sum(counter.values())
+    if total == 0:
+        return None
+
+    threshold = total * 0.02
+    other_count = 0
+
+    sorted_categories = counter.most_common()
+
+    for category, count in sorted_categories:
+        if count >= threshold and category != "other":
+            labels.append(category.replace('_', ' ').title())
+            sizes.append(count)
+        elif category == "other":
+             other_count += count
+        else:
+            other_count += count
+
+    if other_count > 0:
+        labels.append("Other")
+        sizes.append(other_count)
+
+    if not sizes:
+         return None
+
+    fig, ax = plt.subplots(figsize=(10, 8))
+    colors = plt.cm.viridis(np.linspace(0, 1, len(sizes)))
+
+    ax.pie(
+        sizes,
+        labels=labels,
+        autopct='%1.1f%%',
+        startangle=140,
+        colors=colors,
+        wedgeprops={'edgecolor': 'white', 'linewidth': 1},
+        textprops={'fontsize': 11, 'color': 'black'}
     )
-    print("Content Classifier Pipeline Initialized.")
-except Exception as e:
-    print(f"Error initializing Content Classifier globally: {e}")
-    content_classifier_pipeline = None
+
+    plt.title(title, pad=20, fontsize=15)
+    plt.axis('equal')
+    plt.tight_layout()
+
+    # Return the figure object
+    return fig
+
+
+# --- Gradio-Compatible Functions ---
+# Preset username from Colab secrets
+# Ensure USERNAME is set in your Colab secrets
+USERNAME = "jattman1993" # Replace with your preset username or fetch from secrets if needed
+
+def login_gradio_auto():
+    """Gradio-compatible function for automatic login."""
+    global cl
+    try:
+        # Fetch password securely from Colab secrets
+        PASSWORD = userdata.get('password')
+    except Exception as e:
+        return f"Error accessing password secret: {e}", gr.update(visible=False) # Hide OTP input on error
+
+    if not PASSWORD:
+        return "Error: Instagram password not found in Colab secrets. Please add it to Colab secrets with the key 'password'.", gr.update(visible=False) # Hide OTP input
+
+    cl = Client()
+
+    try:
+        cl.login(USERNAME, PASSWORD)
+        # If login is successful, return success message and hide OTP input
+        return f"Successfully logged in as {USERNAME}", gr.update(visible=False)
+    except Exception as e:
+        cl = None # Ensure cl is None on failure
+        error_message = str(e)
+        if "Two factor challenged" in error_message or "challenge_required" in error_message:
+            # If 2FA is required, show the OTP input field
+            return f"Login failed: Two-factor authentication required. Please enter the code below.", gr.update(visible=True)
+        else:
+            # For other errors, hide OTP input and show error message
+            return f"Error during login: {error_message}", gr.update(visible=False)
+
+# Function to handle OTP submission (if 2FA was required)
+def submit_otp_gradio(otp_code):
+    """Gradio-compatible function to submit OTP."""
+    global cl
+    if cl is None:
+        return "Error: Not logged in or client not initialized.", "", gr.update(visible=False) # Hide OTP input
+
+    try:
+        # Assuming the challenge was set up correctly in the login attempt
+        # and the cl object has the challenge_data
+        cl.two_factor_login(otp_code)
+        # If OTP is successful
+        return f"OTP successful. Successfully logged in as {USERNAME}.", "", gr.update(visible=False) # Clear OTP input and hide field
+    except Exception as e:
+        # If OTP fails
+        return f"OTP submission failed: {e}. Please try again.", "", gr.update(visible=True) # Keep OTP input visible
+
+
+def fetch_reels_gradio():
+    """Gradio-compatible function to fetch explore reels."""
+    global cl
+    global explore_reels_list
+
+    if cl is None:
+        explore_reels_list = [] # Ensure list is empty on failure
+        return "Error: Not logged in. Please log in first."
+
+    try:
+        # Fetch a limited number of reels for demonstration purposes
+        # You might want to make this number configurable later
+        fetched_reels = cl.explore_reels()[:100] # Fetch up to 100 for analysis
+        explore_reels_list = fetched_reels
+        if explore_reels_list:
+            return f"Successfully fetched {len(explore_reels_list)} explore reels."
+        else:
+            explore_reels_list = [] # Ensure it's an empty list
+            return "Fetched 0 explore reels."
+    except Exception as e:
+        explore_reels_list = [] # Ensure it's an empty list on error
+        return f"Error fetching explore reels: {e}"
 
 
 def analyze_reels_gradio(max_to_analyze):
@@ -58,11 +702,28 @@ def analyze_reels_gradio(max_to_analyze):
          return "Error: No reels available to analyze.", None, None
 
 
-    # Check if analyzers are initialized
+    # Initialize sentiment analyzer if not already done
     if sentiment_analyzer_instance is None:
-         return "Error: Sentiment Analyzer not initialized.", None, None
+        try:
+            sentiment_analyzer_instance = ReelSentimentAnalyzer()
+             # Optional: Train Hindi model if needed and data is available
+            # sample_train_data = [...] # Define your training data
+            # sentiment_analyzer_instance.train_hindi_model(sample_train_data)
+        except Exception as e:
+            return f"Error initializing Sentiment Analyzer: {e}", None, None
+
+    # Initialize content classifier pipeline if not already done
     if content_classifier_pipeline is None:
-         return "Error: Content Classifier not initialized.", None, None
+         try:
+             print("Initializing Content Classifier Pipeline...")
+             content_classifier_pipeline = pipeline(
+                 "zero-shot-classification",
+                 model="facebook/bart-large-mnli",
+                 device=0 if torch.cuda.is_available() else -1 # Use GPU if available
+             )
+             print("Content Classifier Pipeline Initialized.")
+         except Exception as e:
+             return f"Error initializing Content Classifier: {e}", None, None
 
 
     analysis_status_messages = []
@@ -115,28 +776,34 @@ def analyze_reels_gradio(max_to_analyze):
     return final_status_message, sentiment_plot_figure, content_plot_figure
 
 
-# Re-define plot functions to return bytes (if not already done in a previous cell)
-# Assuming they were defined in the previous subtask's code block.
-# If not, they would need to be included here.
-
 # --- Gradio Blocks Interface ---
 with gr.Blocks() as demo:
     gr.Markdown("# Instagram Reels Analysis")
+
+    # Login Section
     with gr.Row():
-        username_input = gr.Textbox(label="Instagram Username")
-        login_button = gr.Button("Login")
+        connect_button = gr.Button("Connect Instagram")
     login_status_output = gr.Label(label="Login Status")
 
+    # OTP Input (initially hidden)
+    with gr.Row(visible=False) as otp_row:
+        otp_input = gr.Textbox(label="Enter OTP Code")
+        otp_submit_button = gr.Button("Submit OTP")
+
+
+    # Fetch Reels Section
     with gr.Row():
         fetch_button = gr.Button("Fetch Reels")
     fetch_status_output = gr.Label(label="Fetch Status")
 
+    # Analysis Section
     with gr.Row():
         max_reels_input = gr.Slider(minimum=1, maximum=100, value=10, step=1, label="Number of Reels to Analyze")
         analyze_button = gr.Button("Analyze Reels")
 
     analyze_status_output = gr.Label(label="Analysis Status")
 
+    # Results Section
     with gr.Row():
         # Sentiment Analysis Outputs
         with gr.Column():
@@ -149,74 +816,50 @@ with gr.Blocks() as demo:
             content_plot_output = gr.Plot(label="Content Distribution")
 
 
-    # Link login and fetch buttons (assuming login_gradio and fetch_reels_gradio are defined)
-    # Redefine login_gradio and fetch_reels_gradio here within the Blocks context
-    # to ensure they are linked correctly, even though they were defined above.
-    # This is a common pattern in Gradio Blocks.
-
-    def login_gradio_blocks(username):
-        """Gradio-compatible login function for Blocks."""
-        global cl
-        try:
-             PASSWORD = userdata.get('password')
-        except Exception as e:
-             return f"Error accessing password secret: {e}"
-
-
-        if not PASSWORD:
-            return "Error: Instagram password not found in Colab secrets."
-
-        cl = Client()
-
-        try:
-            cl.login(username, PASSWORD)
-            return f"Successfully logged in as {username}"
-        except Exception as e:
-            cl = None # Ensure cl is None on failure
-            return f"Error during login: {e}"
-
-    def fetch_reels_gradio_blocks():
-        """Gradio-compatible function to fetch explore reels for Blocks."""
-        global cl
-        global explore_reels_list
-
-        if cl is None:
-            explore_reels_list = [] # Ensure list is empty on failure
-            return "Error: Not logged in. Please log in first."
-
-        try:
-            # Fetch a limited number of reels for demonstration purposes
-            # You might want to make this number configurable later
-            fetched_reels = cl.explore_reels()[:100] # Fetch up to 100 for analysis
-            explore_reels_list = fetched_reels
-            if explore_reels_list:
-                return f"Successfully fetched {len(explore_reels_list)} explore reels."
-            else:
-                explore_reels_list = [] # Ensure it's an empty list
-                return "Fetched 0 explore reels."
-        except Exception as e:
-            explore_reels_list = [] # Ensure it's an empty list on error
-            return f"Error fetching explore reels: {e}"
-
+    # Link buttons to functions
+    connect_button.click(
+        fn=login_gradio_auto,
+        inputs=None, # No direct inputs, username is preset
+        outputs=[login_status_output, otp_row]
+    )
 
-    login_button.click(
-        fn=login_gradio_blocks,
-        inputs=username_input,
-        outputs=login_status_output
+    otp_submit_button.click(
+        fn=submit_otp_gradio,
+        inputs=otp_input,
+        outputs=[login_status_output, otp_input, otp_row]
     )
 
     fetch_button.click(
-        fn=fetch_reels_gradio_blocks,
+        fn=fetch_reels_gradio,
         inputs=None, # No direct inputs needed for fetching
         outputs=fetch_status_output
     )
 
-    # Link the Analyze button to the analysis function
     analyze_button.click(
         fn=analyze_reels_gradio,
         inputs=max_reels_input, # Input is the slider value
         outputs=[analyze_status_output, sentiment_plot_output, content_plot_output] # Outputs are status and the two plots
     )
 
-# The demo is now fully defined. It can be launched in the next step.
-demo.launch()
+# --- Launch the Gradio app ---
+if __name__ == "__main__":
+    # This block ensures the app only launches when the script is executed directly
+    # (e.g., when running `python deploy.py` or `gradio deploy.py`)
+    # It prevents the app from launching automatically when the file is written in Colab.
+    # When deploying to Hugging Face Spaces via `gradio deploy`, it will find and run this.
+    # For Colab sharing, you can use `demo.launch(share=True)` outside this if block.
+
+    # For standalone deploy.py, you might want to uncomment this:
+    # demo.launch()
+
+    # For Colab and `gradio deploy` compatibility, the `gradio deploy` command handles launching.
+    # The `demo.launch()` line is removed here from the main script block.
+    pass # Keep the __main__ block if needed for local testing setup
+
+
+# Note: When using `gradio deploy` on Hugging Face Spaces, the `demo` object is
+# automatically discovered and launched. You don't need `demo.launch()` here
+# for that specific deployment method.
+
+# For running directly in Colab to test before deploying:
+# demo.launch(share=True)