Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,5 +1,5 @@
 import streamlit as st
-import syllables
+import pyphen
 import re
 import random
 from typing import List, Tuple
@@ -11,6 +11,11 @@ st.set_page_config(
     layout="wide"
 )
 
+# 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 distinct colors for syllables"""
     colors = [
@@ -22,13 +27,13 @@ def generate_color_palette(num_colors: int) -> List[str]:
     
     # If we need more colors than predefined, generate random ones
     while len(colors) < num_colors:
-        color = f"#{random.randint(0, 255):02x}{random.randint(0, 255):02x}{random.randint(0, 255):02x}"
+        color = f"#{random.randint(100, 255):02x}{random.randint(100, 255):02x}{random.randint(100, 255):02x}"
         colors.append(color)
     
     return colors[:num_colors]
 
-def syllabify_word(word: str) -> List[str]:
-    """Syllabify a single word using the syllables library"""
+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)
     
@@ -36,107 +41,32 @@ def syllabify_word(word: str) -> List[str]:
         return [word]
     
     try:
-        # Get syllable count
-        syl_count = syllables.estimate(clean_word)
-        
-        # For basic syllabification, we'll use a simple approach
-        # The syllables library mainly provides counts, so we'll implement basic rules
-        syllable_list = simple_syllabify(clean_word)
+        # Use pyphen to get syllables
+        syllabified = pyphen_dict.inserted(clean_word.lower())
+        syllables = syllabified.split('-')
         
-        # If our simple method doesn't match the count, adjust
-        if len(syllable_list) != syl_count and syl_count > 0:
-            syllable_list = adjust_syllables(clean_word, syl_count)
-            
-        return syllable_list
-    except:
-        return [word]
-
-def simple_syllabify(word: str) -> List[str]:
-    """Simple syllabification based on vowel patterns"""
-    word = word.lower()
-    vowels = "aeiouy"
-    syllables_list = []
-    current_syllable = ""
-    
-    i = 0
-    while i < len(word):
-        current_syllable += word[i]
+        # If no syllables found (single syllable word), return the word
+        if len(syllables) == 1 and syllables[0] == clean_word.lower():
+            return [clean_word]
         
-        # If current character is a vowel
-        if word[i] in vowels:
-            # Look ahead for consonant clusters
-            consonant_cluster = ""
-            j = i + 1
-            while j < len(word) and word[j] not in vowels:
-                consonant_cluster += word[j]
-                j += 1
-            
-            # If we're at the end of the word, add everything
-            if j >= len(word):
-                current_syllable += consonant_cluster
-                syllables_list.append(current_syllable)
-                break
-            
-            # Split consonant cluster
-            if len(consonant_cluster) <= 1:
-                # Single consonant goes with next syllable
-                syllables_list.append(current_syllable)
-                current_syllable = consonant_cluster
-            else:
-                # Multiple consonants: split them
-                split_point = len(consonant_cluster) // 2
-                current_syllable += consonant_cluster[:split_point]
-                syllables_list.append(current_syllable)
-                current_syllable = consonant_cluster[split_point:]
-            
-            i = j - 1
+        # 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()
         
-        i += 1
-    
-    if current_syllable:
-        if syllables_list:
-            syllables_list[-1] += current_syllable
-        else:
-            syllables_list.append(current_syllable)
-    
-    return syllables_list if syllables_list else [word]
-
-def adjust_syllables(word: str, target_count: int) -> List[str]:
-    """Adjust syllable split to match target count"""
-    simple_split = simple_syllabify(word)
-    
-    if len(simple_split) == target_count:
-        return simple_split
-    
-    # If we have fewer syllables than target, try to split more
-    if len(simple_split) < target_count:
-        # Split longest syllable
-        longest_idx = max(range(len(simple_split)), key=lambda i: len(simple_split[i]))
-        longest = simple_split[longest_idx]
-        
-        if len(longest) > 2:
-            mid = len(longest) // 2
-            simple_split[longest_idx:longest_idx+1] = [longest[:mid], longest[mid:]]
-    
-    # If we have more syllables than target, try to merge
-    elif len(simple_split) > target_count and len(simple_split) > 1:
-        # Merge shortest adjacent syllables
-        min_combined_len = float('inf')
-        merge_idx = 0
-        
-        for i in range(len(simple_split) - 1):
-            combined_len = len(simple_split[i]) + len(simple_split[i + 1])
-            if combined_len < min_combined_len:
-                min_combined_len = combined_len
-                merge_idx = i
-        
-        merged = simple_split[merge_idx] + simple_split[merge_idx + 1]
-        simple_split[merge_idx:merge_idx+2] = [merged]
-    
-    return simple_split
+        return syllables if syllables else [clean_word]
+    except:
+        return [clean_word]
 
 def process_text(text: str) -> Tuple[List[Tuple[str, str]], List[Tuple[str, List[Tuple[str, str]]]]]:
     """Process text and return colored words and syllable breakdown"""
+    pyphen_dict = get_pyphen_dict()
+    
     # Split into words while preserving spaces
     words = re.findall(r'\b\w+\b', text)  # Only actual words, no spaces
     
@@ -151,7 +81,7 @@ def process_text(text: str) -> Tuple[List[Tuple[str, str]], List[Tuple[str, List
         if part.strip() and re.match(r'\w', part):  # If it's a word
             if word_index < len(words):
                 word = words[word_index]
-                syllables_list = syllabify_word(word)
+                syllables_list = syllabify_word(word, pyphen_dict)
                 
                 # Generate colors for this word's syllables
                 colors = generate_color_palette(len(syllables_list))
@@ -176,15 +106,15 @@ def display_colored_text(colored_words: List[Tuple[str, str]]):
     html_parts = []
     for word, color in colored_words:
         if word.strip():
-            html_parts.append(f'<span style="color: {color}; font-weight: bold;">{word}</span>')
+            html_parts.append(f'<span style="color: {color}; font-weight: bold; font-size: 18px;">{word}</span>')
         else:
             html_parts.append(word)
     
     html_content = ''.join(html_parts)
-    st.markdown(f'<div style="font-size: 18px; line-height: 1.6; padding: 15px; border: 2px solid #ddd; border-radius: 10px; background-color: #f9f9f9;">{html_content}</div>', unsafe_allow_html=True)
+    st.markdown(f'<div style="font-size: 18px; line-height: 1.8; padding: 20px; border: 2px solid #ddd; border-radius: 10px; background-color: #f9f9f9;">{html_content}</div>', unsafe_allow_html=True)
 
 def display_syllable_breakdown(syllable_breakdown: List[Tuple[str, List[Tuple[str, str]]]]):
-    """Display syllable breakdown"""
+    """Display syllable breakdown with hyphens"""
     html_parts = []
     
     for word, syllables in syllable_breakdown:
@@ -192,24 +122,24 @@ def display_syllable_breakdown(syllable_breakdown: List[Tuple[str, List[Tuple[st
             # Create hyphenated syllable display
             syllable_spans = []
             for syl, color in syllables:
-                syllable_spans.append(f'<span style="color: {color}; font-weight: bold;">{syl}</span>')
+                syllable_spans.append(f'<span style="color: {color}; font-weight: bold; font-size: 18px;">{syl}</span>')
             
             # Join with hyphens for multi-syllable words
             if len(syllables) > 1:
-                syllable_display = '<span style="color: #666;">-</span>'.join(syllable_spans)
+                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: 20px; display: inline-block; margin-bottom: 8px;">{syllable_display}</span>')
+            html_parts.append(f'<span style="margin-right: 25px; display: inline-block; margin-bottom: 12px;">{syllable_display}</span>')
     
     if html_parts:
         html_content = ''.join(html_parts)
-        st.markdown(f'<div style="font-size: 18px; line-height: 2.0; padding: 15px; border: 2px solid #ddd; border-radius: 10px; background-color: #f0f8ff;">{html_content}</div>', unsafe_allow_html=True)
+        st.markdown(f'<div style="font-size: 18px; line-height: 2.2; padding: 20px; border: 2px solid #ddd; border-radius: 10px; background-color: #f0f8ff;">{html_content}</div>', unsafe_allow_html=True)
 
 # Main app
 def main():
     st.title("🔤 Text Syllabification Tool")
-    st.markdown("Enter text below to see syllable breakdown with color coding!")
+    st.markdown("Enter text below to see accurate syllable breakdown with color coding using **pyphen** library!")
     
     # Input text area
     input_text = st.text_area(
@@ -243,25 +173,27 @@ def main():
         
         # Show syllable counts
         if syllable_breakdown:
-            st.subheader("Syllable Counts")
-            counts_html = []
+            st.subheader("Syllable Counts per Word")
+            counts_data = []
             for word, syllables in syllable_breakdown:
                 count = len(syllables)
-                counts_html.append(f"<span style='margin-right: 15px;'><strong>{word}</strong>: {count}</span>")
+                counts_data.append(f"**{word}**: {count}")
             
-            counts_display = " ".join(counts_html)
-            st.markdown(f'<div style="padding: 10px; background-color: #f0f0f0; border-radius: 5px;">{counts_display}</div>', unsafe_allow_html=True)
+            # Display in columns for better readability
+            cols = st.columns(3)
+            for i, count_info in enumerate(counts_data):
+                with cols[i % 3]:
+                    st.markdown(count_info)
     
     else:
         st.info("👆 Enter some text above to see the syllabification in action!")
         
         # Example
         st.subheader("Example")
-        example_text = "Beautiful mountains and valleys create wonderful landscapes."
+        example_text = "The preparation of abstracts is an intellectual effort requiring general familiarity."
         st.code(example_text)
         
         if st.button("Try Example"):
-            st.session_state.example_clicked = True
             # Process example
             colored_words, syllable_breakdown = process_text(example_text)
             
@@ -274,6 +206,25 @@ def main():
             with col2:
                 st.subheader("Syllable Breakdown")
                 display_syllable_breakdown(syllable_breakdown)
+            
+            # Show example statistics
+            total_words = len([word for word, _ in syllable_breakdown])
+            total_syllables = sum(len(syls) for _, syls in syllable_breakdown)
+            st.markdown(f"**Example Statistics:** {total_words} words, {total_syllables} syllables")
+
+    # About section
+    with st.expander("About this tool"):
+        st.markdown("""
+        This tool uses the **pyphen** library, which implements the Hunspell hyphenation algorithm.
+        It provides much more accurate syllabification than simple rule-based approaches.
+        
+        **Features:**
+        - Accurate English syllabification using pyphen
+        - Color-coded visualization
+        - Preserves original text formatting
+        - Shows syllable counts and statistics
+        - Handles capitalization properly
+        """)
 
 if __name__ == "__main__":
     main()