Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,191 +1,419 @@
 import streamlit as st
 import pyphen
 import re
-import random
 from typing import List, Tuple
+import nltk
+from nltk.tokenize import word_tokenize
+import string
 
-# Configure page
+# Download required NLTK data
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
+
+# Initialize pyphen for syllable splitting
+dic = pyphen.Pyphen(lang='en')
+
+# Configure Streamlit page
 st.set_page_config(
-    page_title="Text Syllabification Tool",
-    page_icon="🔤",
+    page_title="Text Pronunciation Analyzer",
+    page_icon="🗣️",
     layout="wide",
     initial_sidebar_state="collapsed"
 )
 
-# Initialize pyphen dictionary for English
-@st.cache_resource
-def get_pyphen_dict():
-    return pyphen.Pyphen(lang='en')
-
-def generate_color_palette(num_colors: int) -> List[str]:
-    """Generate gray shades for syllables"""
-    # Use different shades of gray instead of bright colors
-    base_grays = [
-        "#2C3E50", "#34495E", "#5D6D7E", "#85929E", "#566573",
-        "#515A5A", "#626567", "#797D7F", "#922B21", "#A93226",
-        "#B7472A", "#C0392B", "#CD6155", "#D98880", "#E8DAEF",
-        "#D7BDE2", "#BB8FCE", "#A569BD", "#8E44AD", "#7D3C98"
-    ]
+# Custom CSS for styling
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #6e8efb, #a777e3);
+        -webkit-background-clip: text;
+        background-clip: text;
+        color: transparent;
+        text-align: center;
+        font-size: 3rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+    }
     
-    # Generate more gray shades if needed
-    while len(base_grays) < num_colors:
-        # Generate random gray shades
-        gray_val = random.randint(60, 140)
-        color = f"#{gray_val:02x}{gray_val:02x}{gray_val:02x}"
-        base_grays.append(color)
+    .subtitle {
+        text-align: center;
+        color: #666;
+        font-size: 1.2rem;
+        margin-bottom: 2rem;
+    }
     
-    return base_grays[:num_colors]
-
-def syllabify_word(word: str, pyphen_dict) -> List[str]:
-    """Syllabify a single word using pyphen"""
-    # Clean the word of punctuation for syllabification
-    clean_word = re.sub(r'[^\w]', '', word)
-    
-    if not clean_word:
-        return [word]
-    
-    try:
-        # Use pyphen to get syllables
-        syllabified = pyphen_dict.inserted(clean_word.lower())
-        syllables = syllabified.split('-')
-        
-        # If no syllables found (single syllable word), return the word
-        if len(syllables) == 1 and syllables[0] == clean_word.lower():
-            return [clean_word]
-        
-        # Handle case preservation
-        if clean_word.isupper():
-            syllables = [syl.upper() for syl in syllables]
-        elif clean_word[0].isupper():
-            for i, syl in enumerate(syllables):
-                if i == 0:
-                    syllables[i] = syl.capitalize()
-                else:
-                    syllables[i] = syl.lower()
-        
-        return syllables if syllables else [clean_word]
-    except:
-        return [clean_word]
+    .word-highlight {
+        display: inline-block;
+        padding: 0 4px;
+        margin: 0 2px;
+        border-radius: 4px;
+        transition: all 0.2s ease;
+        cursor: pointer;
+    }
+    
+    .pronunciation-word {
+        display: inline-block;
+        padding: 0 4px;
+        margin: 0 2px;
+        border-radius: 4px;
+        transition: all 0.2s ease;
+        cursor: pointer;
+        font-family: 'Courier New', monospace;
+        letter-spacing: 1px;
+    }
+    
+    .color-1 { background-color: rgba(110, 142, 251, 0.15); color: #6e8efb; }
+    .color-2 { background-color: rgba(167, 119, 227, 0.15); color: #a777e3; }
+    .color-3 { background-color: rgba(79, 172, 254, 0.15); color: #4facfe; }
+    .color-4 { background-color: rgba(0, 242, 254, 0.15); color: #00f2fe; }
+    .color-5 { background-color: rgba(67, 233, 123, 0.15); color: #43e97b; }
+    .color-6 { background-color: rgba(56, 249, 215, 0.15); color: #38f9d7; }
+    .color-7 { background-color: rgba(250, 112, 154, 0.15); color: #fa709a; }
+    .color-8 { background-color: rgba(177, 151, 9, 0.15); color: #b19709; }
+    
+    .pronunciation-separator {
+        color: #a777e3;
+        font-weight: bold;
+        margin: 0 2px;
+    }
+    
+    .analysis-card {
+        background: white;
+        padding: 1.5rem;
+        border-radius: 12px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        margin: 1rem 0;
+    }
+    
+    .section-title {
+        font-size: 0.9rem;
+        font-weight: 600;
+        color: #666;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+        margin-bottom: 0.5rem;
+    }
+    
+    .results-text {
+        font-size: 1.1rem;
+        line-height: 1.6;
+    }
+    
+    .sample-buttons {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 0.5rem;
+        justify-content: center;
+        margin: 1rem 0;
+    }
+    
+    .sample-btn {
+        background: #f0f0f0;
+        border: none;
+        padding: 0.5rem 1rem;
+        border-radius: 20px;
+        cursor: pointer;
+        transition: background-color 0.2s;
+    }
+    
+    .sample-btn:hover {
+        background: #e0e0e0;
+    }
+    
+    .stats-container {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+        gap: 1rem;
+        margin: 1rem 0;
+    }
+    
+    .stat-box {
+        background: #f8f9fa;
+        padding: 1rem;
+        border-radius: 8px;
+        text-align: center;
+    }
+    
+    .stat-number {
+        font-size: 2rem;
+        font-weight: bold;
+        color: #6e8efb;
+    }
+    
+    .stat-label {
+        font-size: 0.9rem;
+        color: #666;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+    }
+</style>
+""", unsafe_allow_html=True)
 
-def process_text(text: str) -> List[Tuple[str, List[Tuple[str, str]]]]:
-    """Process text and return syllable breakdown only"""
-    pyphen_dict = get_pyphen_dict()
+class PronunciationAnalyzer:
+    def __init__(self):
+        self.dic = pyphen.Pyphen(lang='en')
+        self.color_classes = [
+            'color-1', 'color-2', 'color-3', 'color-4', 
+            'color-5', 'color-6', 'color-7', 'color-8'
+        ]
     
-    # Split into words
-    words = re.findall(r'\b\w+\b', text)
-    syllable_breakdown = []
+    def get_syllables(self, word: str) -> List[str]:
+        """Get syllables for a word using pyphen"""
+        # Remove punctuation and convert to lowercase
+        clean_word = word.lower().strip(string.punctuation)
+        
+        if not clean_word:
+            return [word]
+        
+        # Use pyphen to split into syllables
+        syllables = self.dic.inserted(clean_word).split('-')
+        
+        # If pyphen couldn't split (returns original word), try basic vowel-based splitting
+        if len(syllables) == 1 and len(clean_word) > 3:
+            syllables = self._basic_syllable_split(clean_word)
+        
+        return syllables if syllables else [word]
     
-    for word in words:
-        syllables_list = syllabify_word(word, pyphen_dict)
+    def _basic_syllable_split(self, word: str) -> List[str]:
+        """Basic vowel-based syllable splitting as fallback"""
+        vowels = 'aeiouy'
+        syllables = []
+        current_syllable = ''
         
-        # Generate gray colors for this word's syllables
-        colors = generate_color_palette(len(syllables_list))
+        for i, char in enumerate(word):
+            current_syllable += char
+            
+            # Look ahead for vowel patterns
+            if i < len(word) - 1:
+                if char in vowels and word[i + 1] not in vowels:
+                    # Vowel followed by consonant - potential syllable break
+                    if len(current_syllable) >= 2:
+                        syllables.append(current_syllable)
+                        current_syllable = ''
         
-        # Add to syllable breakdown
-        syllable_colored = [(syl, colors[i % len(colors)]) for i, syl in enumerate(syllables_list)]
-        syllable_breakdown.append((word, syllable_colored))
+        if current_syllable:
+            syllables.append(current_syllable)
+        
+        return syllables if syllables else [word]
+    
+    def tokenize_text(self, text: str) -> List[str]:
+        """Tokenize text into words while preserving punctuation"""
+        # Use NLTK for better tokenization
+        tokens = word_tokenize(text)
+        return tokens
     
-    return syllable_breakdown
+    def analyze_text(self, text: str) -> Tuple[List[Tuple[str, List[str]]], dict]:
+        """Analyze text and return word-syllable pairs and statistics"""
+        if not text.strip():
+            return [], {}
+        
+        # Tokenize the text
+        words = self.tokenize_text(text)
+        
+        # Filter out pure punctuation tokens for analysis
+        content_words = [word for word in words if any(c.isalnum() for c in word)]
+        
+        # Get syllables for each word
+        word_syllables = []
+        total_syllables = 0
+        
+        for word in words:
+            if any(c.isalnum() for c in word):  # Only analyze words with alphanumeric characters
+                syllables = self.get_syllables(word)
+                word_syllables.append((word, syllables))
+                total_syllables += len(syllables)
+            else:
+                word_syllables.append((word, [word]))  # Keep punctuation as-is
+        
+        # Calculate statistics
+        stats = {
+            'total_words': len(content_words),
+            'total_syllables': total_syllables,
+            'avg_syllables': round(total_syllables / len(content_words), 2) if content_words else 0,
+            'longest_word': max(content_words, key=len) if content_words else '',
+            'most_syllables': max(content_words, key=lambda w: len(self.get_syllables(w))) if content_words else ''
+        }
+        
+        return word_syllables, stats
 
-def display_colored_text(colored_words: List[Tuple[str, str]]):
-    """Display text with colored words"""
+def render_highlighted_text(word_syllables: List[Tuple[str, List[str]]], analyzer: PronunciationAnalyzer):
+    """Render original text with word highlighting"""
     html_parts = []
-    for word, color in colored_words:
-        if word.strip():
-            html_parts.append(f'<span style="color: {color}; font-weight: bold; font-size: 16px;">{word}</span>')
+    word_index = 0
+    
+    for word, syllables in word_syllables:
+        if any(c.isalnum() for c in word):
+            color_class = analyzer.color_classes[word_index % len(analyzer.color_classes)]
+            html_parts.append(f'<span class="word-highlight {color_class}">{word}</span>')
+            word_index += 1
         else:
             html_parts.append(word)
+        
+        # Add space after word (except for punctuation that shouldn't have spaces)
+        if word not in '.,!?;:':
+            html_parts.append(' ')
     
-    html_content = ''.join(html_parts)
-    st.markdown(f'<div style="font-size: 16px; line-height: 1.6; padding: 15px; border: 2px solid #ddd; border-radius: 8px; background-color: #f9f9f9;">{html_content}</div>', unsafe_allow_html=True)
+    return ''.join(html_parts)
 
-def display_syllable_breakdown(syllable_breakdown: List[Tuple[str, List[Tuple[str, str]]]]):
-    """Display syllable breakdown with hyphens"""
+def render_pronunciation(word_syllables: List[Tuple[str, List[str]]], analyzer: PronunciationAnalyzer):
+    """Render pronunciation with syllable breakdown"""
     html_parts = []
+    word_index = 0
     
-    for word, syllables in syllable_breakdown:
-        if syllables and len(syllables) > 0:
-            # Create hyphenated syllable display
-            syllable_spans = []
-            for syl, color in syllables:
-                syllable_spans.append(f'<span style="color: {color}; font-weight: bold; font-size: 16px;">{syl}</span>')
+    for word, syllables in word_syllables:
+        if any(c.isalnum() for c in word):
+            color_class = analyzer.color_classes[word_index % len(analyzer.color_classes)]
             
-            # Join with hyphens for multi-syllable words
-            if len(syllables) > 1:
-                syllable_display = '<span style="color: #666; font-weight: bold;">-</span>'.join(syllable_spans)
-            else:
-                syllable_display = syllable_spans[0]
-            
-            html_parts.append(f'<span style="margin-right: 12px; display: inline-block; margin-bottom: 6px;">{syllable_display}</span>')
+            # Join syllables with dots
+            syllable_text = '<span class="pronunciation-separator">·</span>'.join(syllables)
+            html_parts.append(f'<span class="pronunciation-word {color_class}">{syllable_text}</span>')
+            word_index += 1
+        else:
+            html_parts.append(f'<span class="pronunciation-word">{word}</span>')
+        
+        # Add space after word (except for punctuation that shouldn't have spaces)
+        if word not in '.,!?;:':
+            html_parts.append(' ')
     
-    if html_parts:
-        html_content = ''.join(html_parts)
-        st.markdown(f'<div style="font-size: 16px; line-height: 1.6; padding: 15px; border: 2px solid #ddd; border-radius: 8px; background-color: #f0f8ff;">{html_content}</div>', unsafe_allow_html=True)
+    return ''.join(html_parts)
 
-# Main app
 def main():
-    st.title("🔤 Text Syllabification Tool")
-    st.markdown("*Enter text to see accurate syllable breakdown with color coding*")
+    # Initialize analyzer
+    analyzer = PronunciationAnalyzer()
     
-    # Input text area
-    input_text = st.text_area(
-        "Enter your text:",
+    # Header
+    st.markdown('<h1 class="main-header">🗣️ Text Pronunciation Analyzer</h1>', unsafe_allow_html=True)
+    st.markdown('<p class="subtitle">Enter any text below to see its pronunciation breakdown with advanced syllable detection</p>', unsafe_allow_html=True)
+    
+    # Input section
+    st.markdown("### 📝 Enter Your Text")
+    
+    # Sample texts
+    sample_texts = [
+        "Hello world",
+        "Pronunciation analyzer",
+        "Supercalifragilisticexpialidocious",
+        "Linguistics and phonetics",
+        "The quick brown fox jumps over the lazy dog"
+    ]
+    
+    # Sample buttons
+    st.markdown("**Try these samples:**")
+    cols = st.columns(len(sample_texts))
+    for i, sample in enumerate(sample_texts):
+        if cols[i].button(sample, key=f"sample_{i}"):
+            st.session_state.input_text = sample
+    
+    # Text input
+    text_input = st.text_area(
+        "Text to analyze:",
+        value=st.session_state.get('input_text', ''),
+        height=120,
         placeholder="Type or paste your text here...",
-        height=100,
-        help="Enter any text to see how words are broken down into syllables"
+        key="text_input"
     )
     
-    # Submit button
-    submit_clicked = st.button("🔍 Submit", type="primary", use_container_width=True)
+    # Update session state
+    if text_input:
+        st.session_state.input_text = text_input
     
-    if submit_clicked and input_text.strip():
-        # Process the text
-        syllable_breakdown = process_text(input_text)
-        
-        # Display syllable breakdown
-        st.subheader("Syllable Breakdown")
-        display_syllable_breakdown(syllable_breakdown)
-        
-        # Statistics
-        total_words = len(syllable_breakdown)
-        total_syllables = sum(len(syls) for _, syls in syllable_breakdown)
-        
-        st.markdown(f"**📊 {total_words} words • {total_syllables} syllables**")
-        
-        # Show syllable counts in a more compact way
-        if syllable_breakdown:
-            with st.expander("📈 Syllable Counts per Word", expanded=False):
-                counts_text = " • ".join([f"{word}: {len(syllables)}" for word, syllables in syllable_breakdown])
-                st.markdown(f"<small>{counts_text}</small>", unsafe_allow_html=True)
+    # Analyze button
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col2:
+        analyze_button = st.button("🔍 Analyze Text", type="primary", use_container_width=True)
     
-    elif submit_clicked and not input_text.strip():
-        st.warning("⚠️ Please enter some text first!")
+    # Clear button
+    if st.button("🗑️ Clear"):
+        st.session_state.input_text = ""
+        st.rerun()
     
-    elif not submit_clicked:
-        st.info("👆 Enter some text above and click Submit to see the syllabification!")
+    # Analysis results
+    if analyze_button and text_input.strip():
+        with st.spinner("Analyzing text..."):
+            word_syllables, stats = analyzer.analyze_text(text_input)
         
-        # Example
-        st.subheader("Example")
-        example_text = "The preparation of abstracts is an intellectual effort requiring general familiarity."
-        st.code(example_text)
-        
-        if st.button("Try Example"):
-            # Process example
-            syllable_breakdown = process_text(example_text)
+        if word_syllables:
+            st.markdown("---")
+            st.markdown("## 📊 Analysis Results")
             
-            st.subheader("Syllable Breakdown")
-            display_syllable_breakdown(syllable_breakdown)
+            # Statistics
+            st.markdown("### 📈 Text Statistics")
+            col1, col2, col3, col4 = st.columns(4)
             
-            # Show example statistics
-            total_words = len(syllable_breakdown)
-            total_syllables = sum(len(syls) for _, syls in syllable_breakdown)
-            st.markdown(f"**📊 {total_words} words • {total_syllables} syllables**")
-
-    # About section
-    with st.expander("About this tool"):
-        st.markdown("""
-            Created by @aghilalb        
-        """)
+            with col1:
+                st.markdown(f"""
+                <div class="stat-box">
+                    <div class="stat-number">{stats['total_words']}</div>
+                    <div class="stat-label">Words</div>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            with col2:
+                st.markdown(f"""
+                <div class="stat-box">
+                    <div class="stat-number">{stats['total_syllables']}</div>
+                    <div class="stat-label">Syllables</div>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            with col3:
+                st.markdown(f"""
+                <div class="stat-box">
+                    <div class="stat-number">{stats['avg_syllables']}</div>
+                    <div class="stat-label">Avg/Word</div>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            with col4:
+                longest_syllables = len(analyzer.get_syllables(stats['most_syllables']))
+                st.markdown(f"""
+                <div class="stat-box">
+                    <div class="stat-number">{longest_syllables}</div>
+                    <div class="stat-label">Max Syllables</div>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            # Original text with highlights
+            st.markdown("### 📖 Original Text")
+            original_html = render_highlighted_text(word_syllables, analyzer)
+            st.markdown(f'<div class="analysis-card"><div class="results-text">{original_html}</div></div>', unsafe_allow_html=True)
+            
+            # Pronunciation breakdown
+            st.markdown("### 🔤 Pronunciation Breakdown")
+            pronunciation_html = render_pronunciation(word_syllables, analyzer)
+            st.markdown(f'<div class="analysis-card"><div class="results-text">{pronunciation_html}</div></div>', unsafe_allow_html=True)
+            
+            # Word-by-word breakdown
+            st.markdown("### 📝 Word-by-Word Analysis")
+            
+            # Create expandable sections for detailed breakdown
+            content_words = [(word, syllables) for word, syllables in word_syllables if any(c.isalnum() for c in word)]
+            
+            if content_words:
+                # Group words into rows of 3
+                for i in range(0, len(content_words), 3):
+                    cols = st.columns(3)
+                    for j, (word, syllables) in enumerate(content_words[i:i+3]):
+                        with cols[j]:
+                            st.markdown(f"""
+                            <div style="background: #f8f9fa; padding: 1rem; border-radius: 8px; margin-bottom: 0.5rem;">
+                                <div style="font-weight: bold; color: #333; margin-bottom: 0.5rem;">{word}</div>
+                                <div style="color: #666; font-family: monospace;">{'·'.join(syllables)}</div>
+                                <div style="color: #999; font-size: 0.8rem;">{len(syllables)} syllable{'s' if len(syllables) != 1 else ''}</div>
+                            </div>
+                            """, unsafe_allow_html=True)
+    
+    elif analyze_button:
+        st.warning("Please enter some text to analyze.")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown(
+        '<div style="text-align: center; color: #666; padding: 2rem;">Created with ❤️ using Streamlit and pyphen</div>',
+        unsafe_allow_html=True
+    )
 
 if __name__ == "__main__":
     main()