Update src/streamlit_app.py

src/streamlit_app.py

@@ -2,8 +2,7 @@ import streamlit as st
 import pyphen
 import re
 import random
-from typing import List, Tuple, Dict
-import requests
+from typing import List, Tuple
 
 # Configure page
 st.set_page_config(
@@ -18,60 +17,43 @@ st.set_page_config(
 def get_pyphen_dict():
     return pyphen.Pyphen(lang='en')
 
-# Cache for IPA pronunciations to avoid repeated API calls
-@st.cache_data
-def get_ipa_pronunciation(word: str) -> str:
-    """Get IPA pronunciation for a word using a free dictionary API"""
-    try:
-        clean_word = re.sub(r'[^\w]', '', word.lower())
-        if not clean_word:
-            return ""
-        
-        url = f"https://api.dictionaryapi.dev/api/v2/entries/en/{clean_word}"
-        response = requests.get(url, timeout=2)
-        
-        if response.status_code == 200:
-            data = response.json()
-            if data and len(data) > 0:
-                phonetics = data[0].get('phonetics', [])
-                for phonetic in phonetics:
-                    if 'text' in phonetic and phonetic['text']:
-                        return phonetic['text']
-        return ""
-    except:
-        return ""
-
 def generate_color_palette(num_colors: int) -> List[str]:
-    """Generate colors for syllables"""
-    colors = [
-        "#2C3E50", "#E74C3C", "#3498DB", "#2ECC71", "#F39C12",
-        "#9B59B6", "#1ABC9C", "#E67E22", "#34495E", "#F1C40F",
-        "#8E44AD", "#16A085", "#27AE60", "#E8753F", "#BDC3C7",
-        "#95A5A6", "#D35400", "#C0392B", "#8B4513", "#FF6347"
+    """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"
     ]
     
-    while len(colors) < num_colors:
-        r = random.randint(50, 200)
-        g = random.randint(50, 200)
-        b = random.randint(50, 200)
-        colors.append(f"#{r:02x}{g:02x}{b:02x}")
+    # 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)
     
-    return colors[:num_colors]
+    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():
@@ -85,260 +67,124 @@ def syllabify_word(word: str, pyphen_dict) -> List[str]:
     except:
         return [clean_word]
 
-def process_text(text: str) -> Tuple[List[Tuple[str, str, str]], List[Tuple[str, List[Tuple[str, str]]]], Dict[str, str]]:
-    """Process text and return original words, syllable breakdown, and IPA dictionary"""
+def process_text(text: str) -> List[Tuple[str, List[Tuple[str, str]]]]:
+    """Process text and return syllable breakdown only"""
     pyphen_dict = get_pyphen_dict()
     
+    # Split into words
     words = re.findall(r'\b\w+\b', text)
-    original_words = []
     syllable_breakdown = []
-    ipa_dict = {}
-    
-    # Generate colors for unique words
-    unique_words = list(set([word.lower() for word in words]))
-    word_colors = {}
-    colors = generate_color_palette(len(unique_words))
     
-    for i, unique_word in enumerate(unique_words):
-        word_colors[unique_word] = colors[i % len(colors)]
-    
-    for i, word in enumerate(words):
-        # Get IPA pronunciation
-        ipa = get_ipa_pronunciation(word)
-        ipa_dict[word.lower()] = ipa
-        
-        color = word_colors[word.lower()]
-        word_id = f"word_{i}"
+    for word in words:
+        syllables_list = syllabify_word(word, pyphen_dict)
         
-        # Add to original words
-        original_words.append((word, color, word_id))
+        # Generate gray colors for this word's syllables
+        colors = generate_color_palette(len(syllables_list))
         
-        # Process syllables
-        syllables_list = syllabify_word(word, pyphen_dict)
-        syllable_colored = [(syl, color) for syl in syllables_list]
+        # Add to syllable breakdown
+        syllable_colored = [(syl, colors[i % len(colors)]) for i, syl in enumerate(syllables_list)]
         syllable_breakdown.append((word, syllable_colored))
     
-    return original_words, syllable_breakdown, ipa_dict
+    return syllable_breakdown
 
-def display_text_with_colors(words_data: List[Tuple[str, str, str]], title: str, is_syllables: bool = False):
-    """Display text with colors using Streamlit columns for hover effect simulation"""
-    st.markdown(f"### {title}")
-    
-    # Create a grid layout for words
-    cols_per_row = 8
-    word_chunks = [words_data[i:i + cols_per_row] for i in range(0, len(words_data), cols_per_row)]
-    
-    for chunk in word_chunks:
-        cols = st.columns(len(chunk))
-        for i, (word_info, col) in enumerate(zip(chunk, cols)):
-            if is_syllables:
-                word, syllables = word_info
-                if len(syllables) > 1:
-                    display_text = '-'.join([syl for syl, _ in syllables])
-                else:
-                    display_text = syllables[0][0] if syllables else word
-                color = syllables[0][1] if syllables else "#333333"
-            else:
-                word, color, word_id = word_info
-                display_text = word
-            
-            with col:
-                st.markdown(
-                    f'<span style="color: {color}; font-weight: bold; font-size: 16px; padding: 4px; display: inline-block;">{display_text}</span>',
-                    unsafe_allow_html=True
-                )
+def display_colored_text(colored_words: List[Tuple[str, str]]):
+    """Display text with colored words"""
+    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>')
+        else:
+            html_parts.append(word)
+    
+    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)
 
-def display_word_grid_with_ipa(original_words, syllable_breakdown, ipa_dict, selected_word_idx=None):
-    """Display words in a grid format with IPA information"""
-    
-    # Create tabs for different views
-    tab1, tab2 = st.tabs(["📝 Original Text", "🔤 Syllabified Text"])
-    
-    with tab1:
-        st.markdown("*Click on a word to see its IPA pronunciation*")
-        
-        # Display original words in a flowing text format
-        html_words = []
-        for i, (word, color, word_id) in enumerate(original_words):
-            if i == selected_word_idx:
-                # Highlight selected word
-                html_words.append(f'<strong style="color: {color}; background-color: yellow; padding: 2px 4px; border-radius: 3px; font-size: 18px;">{word}</strong>')
+def display_syllable_breakdown(syllable_breakdown: List[Tuple[str, List[Tuple[str, str]]]]):
+    """Display syllable breakdown with hyphens"""
+    html_parts = []
+    
+    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>')
+            
+            # 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:
-                html_words.append(f'<span style="color: {color}; font-weight: bold; font-size: 16px; margin: 0 2px;">{word}</span>')
-        
-        text_html = ' '.join(html_words)
-        st.markdown(f'<div style="line-height: 1.8; padding: 15px; border: 2px solid #ddd; border-radius: 8px; background-color: #f9f9f9;">{text_html}</div>', unsafe_allow_html=True)
+                syllable_display = syllable_spans[0]
+            
+            html_parts.append(f'<span style="margin-right: 12px; display: inline-block; margin-bottom: 6px;">{syllable_display}</span>')
     
-    with tab2:
-        st.markdown("*Click on a word to see its IPA pronunciation*")
-        
-        # Display syllabified words
-        html_words = []
-        for i, (word, syllables) in enumerate(syllable_breakdown):
-            if syllables:
-                if len(syllables) > 1:
-                    syllable_parts = []
-                    for syl, color in syllables:
-                        syllable_parts.append(f'<span style="color: {color}; font-weight: bold;">{syl}</span>')
-                    syllable_text = '<span style="color: #666;">-</span>'.join(syllable_parts)
-                else:
-                    syllable_text = f'<span style="color: {syllables[0][1]}; font-weight: bold;">{syllables[0][0]}</span>'
-                
-                if i == selected_word_idx:
-                    html_words.append(f'<span style="background-color: yellow; padding: 2px 4px; border-radius: 3px; font-size: 18px;">{syllable_text}</span>')
-                else:
-                    html_words.append(f'<span style="font-size: 16px; margin: 0 4px;">{syllable_text}</span>')
-        
-        syllable_html = ' '.join(html_words)
-        st.markdown(f'<div style="line-height: 1.8; padding: 15px; border: 2px solid #ddd; border-radius: 8px; background-color: #f0f8ff;">{syllable_html}</div>', unsafe_allow_html=True)
+    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)
 
+# Main app
 def main():
-    st.title("🔤 Enhanced Text Syllabification Tool")
-    st.markdown("*Enter text to see syllable breakdown with IPA pronunciation and interactive word selection*")
+    st.title("🔤 Text Syllabification Tool")
+    st.markdown("*Enter text to see accurate syllable breakdown with color coding*")
     
     # Input text area
     input_text = st.text_area(
         "Enter your text:",
         placeholder="Type or paste your text here...",
         height=100,
-        help="Enter any text to see syllables and IPA pronunciations"
+        help="Enter any text to see how words are broken down into syllables"
     )
     
     # Submit button
     submit_clicked = st.button("🔍 Submit", type="primary", use_container_width=True)
     
     if submit_clicked and input_text.strip():
-        with st.spinner("Processing text and fetching pronunciations..."):
-            original_words, syllable_breakdown, ipa_dict = process_text(input_text)
-        
-        # Word selection interface
-        st.subheader("📚 Interactive Word Explorer")
-        
-        # Create word selection buttons
-        word_list = [word for word, _, _ in original_words]
-        
-        # Display words as clickable buttons in columns
-        st.markdown("**Click on any word to see detailed information:**")
-        
-        cols_per_row = 6
-        word_chunks = [word_list[i:i + cols_per_row] for i in range(0, len(word_list), cols_per_row)]
+        # Process the text
+        syllable_breakdown = process_text(input_text)
         
-        selected_word_idx = None
-        selected_word = None
-        
-        for chunk_idx, chunk in enumerate(word_chunks):
-            cols = st.columns(len(chunk))
-            for word_idx_in_chunk, (word, col) in enumerate(zip(chunk, cols)):
-                actual_word_idx = chunk_idx * cols_per_row + word_idx_in_chunk
-                with col:
-                    if st.button(word, key=f"word_btn_{actual_word_idx}", use_container_width=True):
-                        selected_word_idx = actual_word_idx
-                        selected_word = word
-        
-        # Display text with highlighting
-        display_word_grid_with_ipa(original_words, syllable_breakdown, ipa_dict, selected_word_idx)
-        
-        # Show detailed information for selected word
-        if selected_word_idx is not None and selected_word:
-            st.subheader(f"🔍 Details for: **{selected_word}**")
-            
-            col1, col2, col3 = st.columns(3)
-            
-            with col1:
-                st.markdown("**Original Word:**")
-                word_info = original_words[selected_word_idx]
-                st.markdown(f'<span style="color: {word_info[1]}; font-weight: bold; font-size: 20px;">{word_info[0]}</span>', unsafe_allow_html=True)
-            
-            with col2:
-                st.markdown("**Syllables:**")
-                syllables = syllable_breakdown[selected_word_idx][1]
-                if len(syllables) > 1:
-                    syllable_display = " - ".join([syl for syl, _ in syllables])
-                    st.markdown(f"**{syllable_display}** ({len(syllables)} syllables)")
-                else:
-                    st.markdown(f"**{syllables[0][0]}** (1 syllable)")
-            
-            with col3:
-                st.markdown("**IPA Pronunciation:**")
-                ipa = ipa_dict.get(selected_word.lower(), "")
-                if ipa:
-                    st.markdown(f"**{ipa}**")
-                    st.markdown("🔊 *Hover to hear pronunciation*")
-                else:
-                    st.markdown("*Not available*")
+        # 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"**📊 Statistics: {total_words} words • {total_syllables} syllables**")
+        st.markdown(f"**📊 {total_words} words • {total_syllables} syllables**")
         
-        # Detailed information in expandable section
-        with st.expander("📈 Complete Analysis", expanded=False):
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                st.markdown("**Syllable Counts:**")
-                for word, syllables in syllable_breakdown:
-                    st.text(f"{word}: {len(syllables)} syllable{'s' if len(syllables) > 1 else ''}")
-            
-            with col2:
-                st.markdown("**IPA Pronunciations:**")
-                ipa_available = {word: ipa for word, ipa in ipa_dict.items() if ipa}
-                if ipa_available:
-                    for word, ipa in sorted(ipa_available.items()):
-                        st.text(f"{word}: {ipa}")
-                else:
-                    st.text("No IPA pronunciations available.")
+        # 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)
     
     elif submit_clicked and not input_text.strip():
         st.warning("⚠️ Please enter some text first!")
     
-    else:
-        st.info("👆 Enter some text above and click Submit to start exploring!")
+    elif not submit_clicked:
+        st.info("👆 Enter some text above and click Submit to see the syllabification!")
         
         # Example
         st.subheader("Example")
-        example_text = "The preparation of abstracts requires intellectual familiarity."
+        example_text = "The preparation of abstracts is an intellectual effort requiring general familiarity."
         st.code(example_text)
         
         if st.button("Try Example"):
-            with st.spinner("Processing example..."):
-                original_words, syllable_breakdown, ipa_dict = process_text(example_text)
+            # Process example
+            syllable_breakdown = process_text(example_text)
             
-            display_word_grid_with_ipa(original_words, syllable_breakdown, ipa_dict)
+            st.subheader("Syllable Breakdown")
+            display_syllable_breakdown(syllable_breakdown)
             
+            # 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 Enhanced Tool"):
+    with st.expander("About this tool"):
         st.markdown("""
-        This enhanced syllabification tool provides:
-        
-        **🔤 Core Features:**
-        - Accurate English syllabification using pyphen (Hunspell algorithm)
-        - Color-coded words and syllables for easy identification
-        - Two view modes: Original text and Syllabified text
-        
-        **🎯 Interactive Features:**
-        - **Click-to-explore**: Click any word button to see detailed analysis
-        - **Word highlighting**: Selected words are highlighted in both views
-        - **IPA pronunciations**: See phonetic transcriptions for each word
-        - **Syllable counting**: Visual breakdown of syllable structure
-        
-        **📊 Analysis Tools:**
-        - Complete syllable counts for all words
-        - Statistical overview (total words and syllables)
-        - Pronunciation data from Free Dictionary API
-        
-        **💡 How to Use:**
-        1. Enter your text in the input area
-        2. Click Submit to process the text
-        3. Click on any word button to see detailed information
-        4. Switch between Original and Syllabified views using tabs
-        5. Check the Complete Analysis section for full details
+            Created by @aghilalb        
         """)
 
 if __name__ == "__main__":