app.py

"""
Main application file for the Emoji Mashup app.
This module handles the Gradio interface and application setup.
"""

import gradio as gr
from utils import logger
from emoji_processor import EmojiProcessor
from config import EMBEDDING_MODELS
import random
import os

class EmojiMashupApp:
    def __init__(self):
        """Initialize the Gradio application."""
        logger.info("Initializing Emoji Mashup App")
        self.processor = EmojiProcessor(model_key="mpnet", use_cached_embeddings=True)  # Default to mpnet
        self.processor.load_emoji_dictionaries()
        
        # Store all example sentences for the random picker
        self.all_examples = []
        
    def create_model_dropdown_choices(self):
        """Create formatted choices for the model dropdown.
        
        Returns:
            List of formatted model choices
        """
        return [
            f"{key} ({info['size']}) - {info['notes']}" 
            for key, info in EMBEDDING_MODELS.items()
        ]
        
    def handle_model_change(self, dropdown_value, use_cached_embeddings):
        """Handle model selection change from dropdown.
        
        Args:
            dropdown_value: Selected value from dropdown
            use_cached_embeddings: Whether to use cached embeddings
            
        Returns:
            Status message about model change
        """
        # Extract model key from dropdown value (first word before space)
        model_key = dropdown_value.split()[0] if dropdown_value else "mpnet"
        
        # Update processor cache setting
        self.processor.use_cached_embeddings = use_cached_embeddings
        
        if model_key in EMBEDDING_MODELS:
            success = self.processor.switch_model(model_key)
            if success:
                cache_status = "using cached embeddings" if use_cached_embeddings else "computing fresh embeddings"
                return f"Switched to {model_key} model ({cache_status}): {EMBEDDING_MODELS[model_key]['notes']}"
            else:
                return f"Failed to switch to {model_key} model"
        else:
            return f"Unknown model: {model_key}"
    
    def get_random_example(self):
        """Get a random example from the collected examples.
        
        Returns:
            A randomly selected example sentence
        """
        if not self.all_examples:
            # Return a default message if no examples are available
            return "I feel so happy and excited today!"
        return random.choice(self.all_examples)
            
    def process_with_model(self, model_selection, text, use_cached_embeddings):
        """Process text with selected model.
        
        Args:
            model_selection: Selected model from dropdown
            text: User input text
            use_cached_embeddings: Whether to use cached embeddings
            
        Returns:
            Tuple of (emotion emoji, event emoji, mashup image)
        """
        # Extract model key from dropdown value (first word before space)
        model_key = model_selection.split()[0] if model_selection else "mpnet"
        
        # Update processor cache setting
        self.processor.use_cached_embeddings = use_cached_embeddings
        
        if model_key in EMBEDDING_MODELS:
            self.processor.switch_model(model_key)
            
        # Process text with current model
        return self.processor.sentence_to_emojis(text)
        
    def create_interface(self):
        """Create and configure the Gradio interface.
        
        Returns:
            Gradio Interface object
        """
        # Define all example sentences
        primary_examples = [
            "I feel so happy and excited today!",
            "I'm feeling really sad and down right now",
            "I completely trust my best friend with my life",
            "That smells absolutely disgusting and makes me nauseous",
            "I'm terrified of what might happen next",
            "I'm furious about how they treated me yesterday",
            "Wow! I can't believe what just happened - totally unexpected!",
            "I'm eagerly waiting to see what happens next"
        ]
        
        secondary_examples = [
            "I deeply love and adore my family more than anything",
            "I respect their authority and will follow their instructions",
            "I'm in awe of the magnificent view from the summit",
            "I'm disappointed by the unexpected poor quality of work",
            "I feel so guilty and ashamed about what I did",
            "I have nothing but contempt for their dishonest behavior",
            "I'm determined to confront them about this issue",
            "I'm optimistic and hopeful about what the future holds"
        ]
        
        tertiary_examples = [
            "I'm feeling anxious about my upcoming presentation",
            "I'm hopeful that everything will work out in the end",
            "I felt jealous when I saw them together laughing",
            "Looking at old photos makes me feel nostalgic and sentimental",
            "I'm in complete despair and see no way out of this situation",
            "I'm so embarrassed and ashamed of my behavior yesterday",
            "I have a strange fascination with creepy abandoned buildings",
            "I was absolutely delighted by the unexpected gift"
        ]
        
        # Store all examples for the random picker
        self.all_examples = primary_examples + secondary_examples + tertiary_examples
        
        with gr.Blocks(title="Sentence → Emoji Mashup") as interface:
            gr.Markdown("# Sentence → Emoji Mashup")
            gr.Markdown("Get the top emotion and event emoji from your sentence, and view the mashup!")
            
            with gr.Row():
                with gr.Column(scale=3):
                    # Model selection dropdown
                    model_dropdown = gr.Dropdown(
                        choices=self.create_model_dropdown_choices(),
                        value=self.create_model_dropdown_choices()[0],  # Default to first model (mpnet)
                        label="Embedding Model",
                        info="Select the model used for text-emoji matching"
                    )
                    
                    # Cache toggle
                    cache_toggle = gr.Checkbox(
                        label="Use cached embeddings",
                        value=True,
                        info="When enabled, embeddings will be saved to and loaded from disk"
                    )
                    
                    # Text input with random example button
                    with gr.Row():
                        text_input = gr.Textbox(
                            lines=2, 
                            placeholder="Type a sentence...",
                            label="Your message",
                            scale=9
                        )
                        random_btn = gr.Button("🎲 Random", scale=1, min_width=40, size="sm", variant="secondary")
                    
                    # Process button
                    submit_btn = gr.Button("Generate Emoji Mashup", variant="primary")
                
                with gr.Column(scale=2):
                    # Model info display
                    model_info = gr.Textbox(
                        value=f"Using mpnet model (using cached embeddings): {EMBEDDING_MODELS['mpnet']['notes']}",
                        label="Model Info", 
                        interactive=False
                    )
                    
                    # Output displays
                    emotion_out = gr.Text(label="Top Emotion Emoji")
                    event_out = gr.Text(label="Top Event Emoji")
                    mashup_out = gr.Image(label="Mashup Emoji")
                    
                    # Share button and result message
                    share_btn = gr.Button("Copy Link to Clipboard", variant="secondary", visible=False)
                    share_result = gr.Textbox(visible=False, label="Share Status")
            
            # Set up event handlers
            model_dropdown.change(
                fn=self.handle_model_change,
                inputs=[model_dropdown, cache_toggle],
                outputs=[model_info]
            )
            
            cache_toggle.change(
                fn=self.handle_model_change,
                inputs=[model_dropdown, cache_toggle],
                outputs=[model_info]
            )
            
            # Random example button handler
            random_btn.click(
                fn=self.get_random_example,
                inputs=None,
                outputs=text_input
            )
            
            # Process button handler with share button visibility update
            def process_and_show_share(model_selection, text, use_cached_embeddings):
                result = self.process_with_model(model_selection, text, use_cached_embeddings)
                # Make share button visible after generating result
                return result[0], result[1], result[2], True, False
                
            submit_btn.click(
                fn=process_and_show_share,
                inputs=[model_dropdown, text_input, cache_toggle],
                outputs=[emotion_out, event_out, mashup_out, share_btn, share_result]
            )
            
            # Simple share button handler - just show a message
            def show_share_message():
                return True, "Link copied! Share this page's URL with others to show your result."
                
            share_btn.click(
                fn=show_share_message,
                inputs=None,
                outputs=[share_result, share_result]
            )
            
            # Examples section - using Tabs instead of Accordion to ensure visibility
            gr.Markdown("## Emotion Examples")
            gr.Markdown("Try these examples based on Plutchik's Wheel of Emotions:")
            
            with gr.Tabs() as tabs:
                with gr.TabItem("Primary Emotions"):
                    gr.Examples(
                        examples=[[example] for example in primary_examples],
                        inputs=text_input
                    )
                
                with gr.TabItem("Secondary Emotions"):
                    gr.Examples(
                        examples=[[example] for example in secondary_examples],
                        inputs=text_input
                    )
                
                with gr.TabItem("Tertiary Emotions"):
                    gr.Examples(
                        examples=[[example] for example in tertiary_examples],
                        inputs=text_input
                    )
            
        return interface
        
    def run(self, share=True):
        """Launch the Gradio application.
        
        Args:
            share: Whether to create a public sharing link
        """
        logger.info("Starting Emoji Mashup App")

        interface = self.create_interface()
        # Check if running on Hugging Face Spaces
        is_on_spaces = os.environ.get("SPACE_ID") is not None
        
        # If on Spaces, never use share=True
        if is_on_spaces:
            # When on Spaces, don't use share parameter at all
            interface.launch()
        else:
            # When running locally, default to share=True unless explicitly set
            if share is None:
                share = True
            interface.launch(share=share)


# Main entry point
if __name__ == "__main__":
    app = EmojiMashupApp()
    app.run()