Refactor application structure: implement EmojiProcessor, enhance Gradio interface, and add configuration management

app.py

@@ -1,80 +1,54 @@
-import gradio as gr
-from sentence_transformers import SentenceTransformer
-from sklearn.metrics.pairwise import cosine_similarity
-import numpy as np
-import requests
-from PIL import Image
-from io import BytesIO
-
-# Load model
-model = SentenceTransformer('all-mpnet-base-v2')
-
-# Load emoji dictionaries
-def kitchen_txt_to_dict(filepath):
-    emoji_dict = {}
-    with open(filepath, 'r', encoding='utf-8') as f:
-        for line in f:
-            parts = line.strip().split(' ', 1)
-            if len(parts) == 2:
-                emoji, desc = parts
-                emoji_dict[emoji] = desc
-    return emoji_dict
-
-file_path_emotion = 'google-emoji-kitchen-emotion.txt'
-file_path_item = 'google-emoji-kitchen-item.txt'
-
-emotion_dict = kitchen_txt_to_dict(file_path_emotion)
-event_dict = kitchen_txt_to_dict('google-emoji-kitchen-item.txt')
-
-# Precompute embeddings
-emotion_embeddings = {emoji: model.encode(desc) for emoji, desc in emotion_dict.items()}
-event_embeddings = {emoji: model.encode(desc) for emoji, desc in event_dict.items()}
+"""
+Main application file for the Emoji Mashup app.
+This module handles the Gradio interface and application setup.
+"""
 
-# Helper functions
-def find_top_emojis(embedding, emoji_embeddings, top_n=1):
-    similarities = [
-        (emoji, cosine_similarity([embedding], [e_embed])[0][0])
-        for emoji, e_embed in emoji_embeddings.items()
-    ]
-    similarities.sort(key=lambda x: x[1], reverse=True)
-    return [emoji for emoji, _ in similarities[:top_n]]
-
-def get_emoji_kitchen_url(emoji1, emoji2, size=256):
-    return f"https://emojik.vercel.app/s/{emoji1}_{emoji2}?size={size}"
-
-def fetch_image(url):
-    try:
-        response = requests.get(url)
-        if response.status_code == 200 and "image" in response.headers.get("Content-Type", ""):
-            return Image.open(BytesIO(response.content))
-        else:
-            return None
-    except:
-        return None
-
-# Main function for Gradio
-def sentence_to_emojis(sentence):
-    embedding = model.encode(sentence)
-    
-    top_emotion = find_top_emojis(embedding, emotion_embeddings, top_n=1)[0]
-    top_event = find_top_emojis(embedding, event_embeddings, top_n=1)[0]
-    
-    mashup_url = get_emoji_kitchen_url(top_emotion, top_event)
-    mashup_image = fetch_image(mashup_url)
-    
-    return top_emotion, top_event, mashup_image
-
-# Gradio interface
-demo = gr.Interface(
-    fn=sentence_to_emojis,
-    inputs=gr.Textbox(lines=2, placeholder="Type a sentence..."),
-    outputs=[
-        gr.Text(label="Top Emotion Emoji"),
-        gr.Text(label="Top Event Emoji"),
-        gr.Image(label=" Kitchen Emoji")
-    ],
-    title="Sentence → Emoji Mashup",
-    description="Get the top emotion and event emoji from your sentence, and view the mashup!"
-)
-
-demo.launch(share=True)
+import gradio as gr
+from utils import logger
+from emoji_processor import EmojiProcessor
+
+class EmojiMashupApp:
+    def __init__(self):
+        """Initialize the Gradio application."""
+        logger.info("Initializing Emoji Mashup App")
+        self.processor = EmojiProcessor()
+        self.processor.load_emoji_dictionaries()
+        
+    def create_interface(self):
+        """Create and configure the Gradio interface.
+        
+        Returns:
+            Gradio Interface object
+        """
+        return gr.Interface(
+            fn=self.processor.sentence_to_emojis,
+            inputs=gr.Textbox(lines=2, placeholder="Type a sentence..."),
+            outputs=[
+                gr.Text(label="Top Emotion Emoji"),
+                gr.Text(label="Top Event Emoji"),
+                gr.Image(label="Mashup Emoji")
+            ],
+            title="Sentence → Emoji Mashup",
+            description="Get the top emotion and event emoji from your sentence, and view the mashup!",
+            examples=[
+                ["I feel so happy today!"],
+                ["I'm really angry right now"],
+                ["Feeling tired after a long day"]
+            ]
+        )
+        
+    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()
+        interface.launch(share=share)
+
+
+# Main entry point
+if __name__ == "__main__":
+    app = EmojiMashupApp()
+    app.run(share=True)

config.py

@@ -0,0 +1,12 @@
+"""
+Configuration settings for the Emoji Mashup application.
+"""
+
+# Application configuration
+CONFIG = {
+    "model_name": "all-mpnet-base-v2",
+    "emotion_file": "google-emoji-kitchen-emotion.txt",
+    "item_file": "google-emoji-kitchen-item.txt",
+    "emoji_kitchen_url": "https://emojik.vercel.app/s/{emoji1}_{emoji2}",
+    "default_size": 256
+}

emoji_processor.py

@@ -0,0 +1,119 @@
+"""
+Core emoji processing logic for the Emoji Mashup application.
+"""
+
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import requests
+from PIL import Image
+from io import BytesIO
+
+from config import CONFIG
+from utils import logger, kitchen_txt_to_dict
+
+class EmojiProcessor:
+    def __init__(self, model_name=CONFIG["model_name"]):
+        """Initialize the emoji processor with the specified model.
+        
+        Args:
+            model_name: Name of the sentence transformer model to use
+        """
+        logger.info(f"Loading model: {model_name}")
+        self.model = SentenceTransformer(model_name)
+        self.emotion_dict = {}
+        self.event_dict = {}
+        self.emotion_embeddings = {}
+        self.event_embeddings = {}
+
+    def load_emoji_dictionaries(self, emotion_file=CONFIG["emotion_file"], item_file=CONFIG["item_file"]):
+        """Load emoji dictionaries from text files.
+        
+        Args:
+            emotion_file: Path to the emotion emoji file
+            item_file: Path to the item emoji file
+        """
+        logger.info("Loading emoji dictionaries")
+        self.emotion_dict = kitchen_txt_to_dict(emotion_file)
+        self.event_dict = kitchen_txt_to_dict(item_file)
+        
+        # Precompute embeddings
+        logger.info("Computing embeddings for emoji dictionaries")
+        self.emotion_embeddings = {emoji: self.model.encode(desc) for emoji, desc in self.emotion_dict.items()}
+        self.event_embeddings = {emoji: self.model.encode(desc) for emoji, desc in self.event_dict.items()}
+
+    def find_top_emojis(self, embedding, emoji_embeddings, top_n=1):
+        """Find top matching emojis based on cosine similarity.
+        
+        Args:
+            embedding: Sentence embedding to compare
+            emoji_embeddings: Dictionary of emoji embeddings
+            top_n: Number of top emojis to return
+            
+        Returns:
+            List of top matching emojis
+        """
+        similarities = [
+            (emoji, cosine_similarity([embedding], [e_embed])[0][0])
+            for emoji, e_embed in emoji_embeddings.items()
+        ]
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        return [emoji for emoji, _ in similarities[:top_n]]
+
+    def get_emoji_mashup_url(self, emoji1, emoji2, size=CONFIG["default_size"]):
+        """Generate URL for emoji mashup.
+        
+        Args:
+            emoji1: First emoji character
+            emoji2: Second emoji character
+            size: Image size in pixels
+            
+        Returns:
+            URL for the emoji mashup
+        """
+        return f"{CONFIG['emoji_kitchen_url'].format(emoji1=emoji1, emoji2=emoji2)}?size={size}"
+
+    def fetch_mashup_image(self, url):
+        """Fetch emoji mashup image from URL.
+        
+        Args:
+            url: URL of the emoji mashup image
+            
+        Returns:
+            PIL Image object or None if fetch failed
+        """
+        try:
+            response = requests.get(url)
+            if response.status_code == 200 and "image" in response.headers.get("Content-Type", ""):
+                return Image.open(BytesIO(response.content))
+            else:
+                logger.warning(f"Failed to fetch image: Status code {response.status_code}")
+                return None
+        except Exception as e:
+            logger.error(f"Error fetching image: {e}")
+            return None
+
+    def sentence_to_emojis(self, sentence):
+        """Process sentence to find matching emojis and generate mashup.
+        
+        Args:
+            sentence: User input text
+            
+        Returns:
+            Tuple of (emotion emoji, event emoji, mashup image)
+        """
+        if not sentence.strip():
+            return "❓", "❓", None
+            
+        try:
+            embedding = self.model.encode(sentence)
+            
+            top_emotion = self.find_top_emojis(embedding, self.emotion_embeddings, top_n=1)[0]
+            top_event = self.find_top_emojis(embedding, self.event_embeddings, top_n=1)[0]
+            
+            mashup_url = self.get_emoji_mashup_url(top_emotion, top_event)
+            mashup_image = self.fetch_mashup_image(mashup_url)
+            
+            return top_emotion, top_event, mashup_image
+        except Exception as e:
+            logger.error(f"Error processing sentence: {e}")
+            return "❌", "❌", None

utils.py

@@ -0,0 +1,39 @@
+"""
+Utility functions for the Emoji Mashup application.
+"""
+
+import logging
+
+# Configure logging
+def setup_logging():
+    """Configure application logging."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    return logging.getLogger(__name__)
+
+# Initialize logger
+logger = setup_logging()
+
+def kitchen_txt_to_dict(filepath):
+    """Convert emoji kitchen text file to dictionary.
+    
+    Args:
+        filepath: Path to the emoji kitchen text file
+        
+    Returns:
+        Dictionary mapping emojis to descriptions
+    """
+    emoji_dict = {}
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            for line in f:
+                parts = line.strip().split(' ', 1)
+                if len(parts) == 2:
+                    emoji, desc = parts
+                    emoji_dict[emoji] = desc
+        return emoji_dict
+    except Exception as e:
+        logger.error(f"Error loading emoji dictionary from {filepath}: {e}")
+        return {}