Spaces:

aghilTQ
/

Syllable

Build error

Syllable / src /streamlit_app.py

Update src/streamlit_app.py

e4504fe verified over 1 year ago

21.8 kB

import streamlit as st
import pyphen
import re
from typing import List, Tuple
import string
import os

# Initialize pyphen for syllable splitting
dic = pyphen.Pyphen(lang='en')

# Configure Streamlit page
st.set_page_config(
    page_title="Text Pronunciation Analyzer",
    page_icon="🗣️",
    layout="wide",
    initial_sidebar_state="collapsed"
)

# 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;
    }
    
    .subtitle {
        text-align: center;
        color: #666;
        font-size: 1.2rem;
        margin-bottom: 2rem;
    }
    
    .word-highlight {
        display: inline-block;
        padding: 2px 4px;
        margin: 0 1px;
        border-radius: 4px;
        transition: all 0.3s ease;
        cursor: pointer;
        color: #666;
        background-color: transparent;
    }
    
    .word-highlight:hover {
        transform: translateY(-1px);
        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
    }
    
    .pronunciation-word {
        display: inline-block;
        padding: 2px 4px;
        margin: 0 1px;
        border-radius: 4px;
        transition: all 0.3s ease;
        cursor: pointer;
        font-family: 'Courier New', monospace;
        letter-spacing: 1px;
        color: #666;
        background-color: transparent;
    }
    
    .pronunciation-word:hover {
        transform: translateY(-1px);
        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
    }
    
    /* Active states when hovered/linked */
    .word-active {
        background-color: rgba(110, 142, 251, 0.2) !important;
        color: #6e8efb !important;
        transform: translateY(-1px);
        box-shadow: 0 2px 12px rgba(110, 142, 251, 0.3);
    }
    
    .pronunciation-active {
        background-color: rgba(110, 142, 251, 0.2) !important;
        color: #6e8efb !important;
        transform: translateY(-1px);
        box-shadow: 0 2px 12px rgba(110, 142, 251, 0.3);
    }
    
    /* Color classes - only used for subtle borders */
    .color-1 { border-left: 0px solid #6e8efb; }
    .color-2 { border-left: 0px solid #a777e3; }
    .color-3 { border-left: 0px solid #4facfe; }
    .color-4 { border-left: 0px solid #00f2fe; }
    .color-5 { border-left: 0px solid #43e97b; }
    .color-6 { border-left: 0px solid #38f9d7; }
    .color-7 { border-left: 0px solid #fa709a; }
    .color-8 { border-left: 0px solid #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.8;
        color: #666;
    }
    
    .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;
    }
    
    /* Interactive hover JavaScript */
    .hover-container {
        position: relative;
    }
</style>
<script>
function addHoverInteraction() {
    // Add event listeners for word-syllable linking
    setTimeout(() => {
        const words = document.querySelectorAll('.word-highlight');
        const pronunciations = document.querySelectorAll('.pronunciation-word');
        
        // Clear any existing listeners
        words.forEach(word => {
            word.replaceWith(word.cloneNode(true));
        });
        pronunciations.forEach(pron => {
            pron.replaceWith(pron.cloneNode(true));
        });
        
        // Re-select after cloning
        const newWords = document.querySelectorAll('.word-highlight');
        const newPronunciations = document.querySelectorAll('.pronunciation-word');
        
        newWords.forEach((word, index) => {
            word.addEventListener('mouseenter', () => {
                // Highlight corresponding pronunciation
                word.classList.add('word-active');
                if (newPronunciations[index]) {
                    newPronunciations[index].classList.add('pronunciation-active');
                }
            });
            
            word.addEventListener('mouseleave', () => {
                // Remove highlights
                word.classList.remove('word-active');
                if (newPronunciations[index]) {
                    newPronunciations[index].classList.remove('pronunciation-active');
                }
            });
        });
        
        newPronunciations.forEach((pron, index) => {
            pron.addEventListener('mouseenter', () => {
                // Highlight corresponding word
                pron.classList.add('pronunciation-active');
                if (newWords[index]) {
                    newWords[index].classList.add('word-active');
                }
            });
            
            pron.addEventListener('mouseleave', () => {
                // Remove highlights
                pron.classList.remove('pronunciation-active');
                if (newWords[index]) {
                    newWords[index].classList.remove('word-active');
                }
            });
        });
    }, 100);
}
// Run the interaction setup when page loads
document.addEventListener('DOMContentLoaded', addHoverInteraction);
</script>
""", unsafe_allow_html=True)

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'
        ]
    
    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]
    
    def _basic_syllable_split(self, word: str) -> List[str]:
        """Basic vowel-based syllable splitting as fallback"""
        vowels = 'aeiouy'
        syllables = []
        current_syllable = ''
        
        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 = ''
        
        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"""
        # Enhanced regex-based tokenization
        # This pattern matches:
        # - Words (including contractions like "don't")
        # - Numbers
        # - Punctuation marks
        # - Preserves spacing
        
        # Split text into tokens while preserving structure
        pattern = r"(?:\w+(?:'\w+)?|\d+|[^\w\s])"
        tokens = re.findall(pattern, text)
        
        # Add spaces back where needed
        result = []
        text_pos = 0
        
        for token in tokens:
            # Find the token's position in the original text
            token_pos = text.find(token, text_pos)
            
            # Add any whitespace before the token
            if token_pos > text_pos:
                whitespace = text[text_pos:token_pos]
                if whitespace.strip() == '':  # Only add if it's pure whitespace
                    result.extend(list(whitespace))
            
            result.append(token)
            text_pos = token_pos + len(token)
        
        # Filter out empty strings and normalize
        return [token for token in result if token.strip()]
    
    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 render_highlighted_text(word_syllables: List[Tuple[str, List[str]]], analyzer: PronunciationAnalyzer):
    """Render original text with word highlighting"""
    html_parts = []
    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}" data-word-index="{word_index}">{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(' ')
    
    return ''.join(html_parts)

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 word_syllables:
        if any(c.isalnum() for c in word):
            color_class = analyzer.color_classes[word_index % len(analyzer.color_classes)]
            
            # Join syllables with dots
            syllable_text = '<span class="pronunciation-separator">·</span>'.join(syllables)
            html_parts.append(f'<span class="pronunciation-word {color_class}" data-word-index="{word_index}">{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(' ')
    
    return ''.join(html_parts)

def main():
    # Initialize analyzer
    analyzer = PronunciationAnalyzer()
    
    # 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...",
        key="text_input"
    )
    
    # Update session state
    if text_input:
        st.session_state.input_text = text_input
    
    # Analyze button
    col1, col2, col3 = st.columns([1, 1, 1])
    with col2:
        analyze_button = st.button("🔍 Analyze Text", type="primary", use_container_width=True)
    
    # Clear button
    if st.button("🗑️ Clear"):
        st.session_state.input_text = ""
        st.rerun()
    
    # Analysis results
    if analyze_button and text_input.strip():
        with st.spinner("Analyzing text..."):
            word_syllables, stats = analyzer.analyze_text(text_input)
        
        if word_syllables:
            st.markdown("---")
            st.markdown("## 📊 Analysis Results")
            
            # Statistics
            st.markdown("### 📈 Text Statistics")
            col1, col2, col3, col4 = st.columns(4)
            
            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 hover-container"><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 hover-container"><div class="results-text">{pronunciation_html}</div></div>', unsafe_allow_html=True)
            
            # Add JavaScript for hover interaction
            st.components.v1.html("""
            <script>
            function addHoverInteraction() {
                const words = parent.document.querySelectorAll('.word-highlight');
                const pronunciations = parent.document.querySelectorAll('.pronunciation-word');
                
                // Clear existing event listeners by cloning nodes
                words.forEach((word, index) => {
                    const wordIndex = word.getAttribute('data-word-index');
                    if (wordIndex !== null) {
                        const newWord = word.cloneNode(true);
                        word.parentNode.replaceChild(newWord, word);
                        
                        newWord.addEventListener('mouseenter', () => {
                            newWord.classList.add('word-active');
                            const correspondingPron = parent.document.querySelector(`[data-word-index="${wordIndex}"].pronunciation-word`);
                            if (correspondingPron) {
                                correspondingPron.classList.add('pronunciation-active');
                            }
                        });
                        
                        newWord.addEventListener('mouseleave', () => {
                            newWord.classList.remove('word-active');
                            const correspondingPron = parent.document.querySelector(`[data-word-index="${wordIndex}"].pronunciation-word`);
                            if (correspondingPron) {
                                correspondingPron.classList.remove('pronunciation-active');
                            }
                        });
                    }
                });
                
                pronunciations.forEach((pron, index) => {
                    const wordIndex = pron.getAttribute('data-word-index');
                    if (wordIndex !== null) {
                        const newPron = pron.cloneNode(true);
                        pron.parentNode.replaceChild(newPron, pron);
                        
                        newPron.addEventListener('mouseenter', () => {
                            newPron.classList.add('pronunciation-active');
                            const correspondingWord = parent.document.querySelector(`[data-word-index="${wordIndex}"].word-highlight`);
                            if (correspondingWord) {
                                correspondingWord.classList.add('word-active');
                            }
                        });
                        
                        newPron.addEventListener('mouseleave', () => {
                            newPron.classList.remove('pronunciation-active');
                            const correspondingWord = parent.document.querySelector(`[data-word-index="${wordIndex}"].word-highlight`);
                            if (correspondingWord) {
                                correspondingWord.classList.remove('word-active');
                            }
                        });
                    }
                });
            }
            
            // Run interaction setup
            setTimeout(addHoverInteraction, 300);
            </script>
            """, height=0)
            
            # 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 by @aghilalb and ai</div>',
        unsafe_allow_html=True
    )

if __name__ == "__main__":
    main()

	import streamlit as st
	import pyphen
	import re
	from typing import List, Tuple
	import string
	import os

	# Initialize pyphen for syllable splitting
	dic = pyphen.Pyphen(lang='en')

	# Configure Streamlit page
	st.set_page_config(
	page_title="Text Pronunciation Analyzer",
	page_icon="🗣️",
	layout="wide",
	initial_sidebar_state="collapsed"
	)

	# 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;
	}

	.subtitle {
	text-align: center;
	color: #666;
	font-size: 1.2rem;
	margin-bottom: 2rem;
	}

	.word-highlight {
	display: inline-block;
	padding: 2px 4px;
	margin: 0 1px;
	border-radius: 4px;
	transition: all 0.3s ease;
	cursor: pointer;
	color: #666;
	background-color: transparent;
	}

	.word-highlight:hover {
	transform: translateY(-1px);
	box-shadow: 0 2px 8px rgba(0,0,0,0.1);
	}

	.pronunciation-word {
	display: inline-block;
	padding: 2px 4px;
	margin: 0 1px;
	border-radius: 4px;
	transition: all 0.3s ease;
	cursor: pointer;
	font-family: 'Courier New', monospace;
	letter-spacing: 1px;
	color: #666;
	background-color: transparent;
	}

	.pronunciation-word:hover {
	transform: translateY(-1px);
	box-shadow: 0 2px 8px rgba(0,0,0,0.1);
	}

	/* Active states when hovered/linked */
	.word-active {
	background-color: rgba(110, 142, 251, 0.2) !important;
	color: #6e8efb !important;
	transform: translateY(-1px);
	box-shadow: 0 2px 12px rgba(110, 142, 251, 0.3);
	}

	.pronunciation-active {
	background-color: rgba(110, 142, 251, 0.2) !important;
	color: #6e8efb !important;
	transform: translateY(-1px);
	box-shadow: 0 2px 12px rgba(110, 142, 251, 0.3);
	}

	/* Color classes - only used for subtle borders */
	.color-1 { border-left: 0px solid #6e8efb; }
	.color-2 { border-left: 0px solid #a777e3; }
	.color-3 { border-left: 0px solid #4facfe; }
	.color-4 { border-left: 0px solid #00f2fe; }
	.color-5 { border-left: 0px solid #43e97b; }
	.color-6 { border-left: 0px solid #38f9d7; }
	.color-7 { border-left: 0px solid #fa709a; }
	.color-8 { border-left: 0px solid #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.8;
	color: #666;
	}

	.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;
	}

	/* Interactive hover JavaScript */
	.hover-container {
	position: relative;
	}
	</style>

	<script>
	function addHoverInteraction() {
	// Add event listeners for word-syllable linking
	setTimeout(() => {
	const words = document.querySelectorAll('.word-highlight');
	const pronunciations = document.querySelectorAll('.pronunciation-word');

	// Clear any existing listeners
	words.forEach(word => {
	word.replaceWith(word.cloneNode(true));
	});
	pronunciations.forEach(pron => {
	pron.replaceWith(pron.cloneNode(true));
	});

	// Re-select after cloning
	const newWords = document.querySelectorAll('.word-highlight');
	const newPronunciations = document.querySelectorAll('.pronunciation-word');

	newWords.forEach((word, index) => {
	word.addEventListener('mouseenter', () => {
	// Highlight corresponding pronunciation
	word.classList.add('word-active');
	if (newPronunciations[index]) {
	newPronunciations[index].classList.add('pronunciation-active');
	}
	});

	word.addEventListener('mouseleave', () => {
	// Remove highlights
	word.classList.remove('word-active');
	if (newPronunciations[index]) {
	newPronunciations[index].classList.remove('pronunciation-active');
	}
	});
	});

	newPronunciations.forEach((pron, index) => {
	pron.addEventListener('mouseenter', () => {
	// Highlight corresponding word
	pron.classList.add('pronunciation-active');
	if (newWords[index]) {
	newWords[index].classList.add('word-active');
	}
	});

	pron.addEventListener('mouseleave', () => {
	// Remove highlights
	pron.classList.remove('pronunciation-active');
	if (newWords[index]) {
	newWords[index].classList.remove('word-active');
	}
	});
	});
	}, 100);
	}

	// Run the interaction setup when page loads
	document.addEventListener('DOMContentLoaded', addHoverInteraction);
	</script>
	""", unsafe_allow_html=True)

	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'
	]

	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]

	def _basic_syllable_split(self, word: str) -> List[str]:
	"""Basic vowel-based syllable splitting as fallback"""
	vowels = 'aeiouy'
	syllables = []
	current_syllable = ''

	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 = ''

	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"""
	# Enhanced regex-based tokenization
	# This pattern matches:
	# - Words (including contractions like "don't")
	# - Numbers
	# - Punctuation marks
	# - Preserves spacing

	# Split text into tokens while preserving structure
	pattern = r"(?:\w+(?:'\w+)?\|\d+\|[^\w\s])"
	tokens = re.findall(pattern, text)

	# Add spaces back where needed
	result = []
	text_pos = 0

	for token in tokens:
	# Find the token's position in the original text
	token_pos = text.find(token, text_pos)

	# Add any whitespace before the token
	if token_pos > text_pos:
	whitespace = text[text_pos:token_pos]
	if whitespace.strip() == '': # Only add if it's pure whitespace
	result.extend(list(whitespace))

	result.append(token)
	text_pos = token_pos + len(token)

	# Filter out empty strings and normalize
	return [token for token in result if token.strip()]

	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 render_highlighted_text(word_syllables: List[Tuple[str, List[str]]], analyzer: PronunciationAnalyzer):
	"""Render original text with word highlighting"""
	html_parts = []
	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}" data-word-index="{word_index}">{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(' ')

	return ''.join(html_parts)

	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 word_syllables:
	if any(c.isalnum() for c in word):
	color_class = analyzer.color_classes[word_index % len(analyzer.color_classes)]

	# Join syllables with dots
	syllable_text = '<span class="pronunciation-separator">·</span>'.join(syllables)
	html_parts.append(f'<span class="pronunciation-word {color_class}" data-word-index="{word_index}">{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(' ')

	return ''.join(html_parts)

	def main():
	# Initialize analyzer
	analyzer = PronunciationAnalyzer()

	# 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...",
	key="text_input"
	)

	# Update session state
	if text_input:
	st.session_state.input_text = text_input

	# Analyze button
	col1, col2, col3 = st.columns([1, 1, 1])
	with col2:
	analyze_button = st.button("🔍 Analyze Text", type="primary", use_container_width=True)

	# Clear button
	if st.button("🗑️ Clear"):
	st.session_state.input_text = ""
	st.rerun()

	# Analysis results
	if analyze_button and text_input.strip():
	with st.spinner("Analyzing text..."):
	word_syllables, stats = analyzer.analyze_text(text_input)

	if word_syllables:
	st.markdown("---")
	st.markdown("## 📊 Analysis Results")

	# Statistics
	st.markdown("### 📈 Text Statistics")
	col1, col2, col3, col4 = st.columns(4)

	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 hover-container"><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 hover-container"><div class="results-text">{pronunciation_html}</div></div>', unsafe_allow_html=True)

	# Add JavaScript for hover interaction
	st.components.v1.html("""
	<script>
	function addHoverInteraction() {
	const words = parent.document.querySelectorAll('.word-highlight');
	const pronunciations = parent.document.querySelectorAll('.pronunciation-word');

	// Clear existing event listeners by cloning nodes
	words.forEach((word, index) => {
	const wordIndex = word.getAttribute('data-word-index');
	if (wordIndex !== null) {
	const newWord = word.cloneNode(true);
	word.parentNode.replaceChild(newWord, word);

	newWord.addEventListener('mouseenter', () => {
	newWord.classList.add('word-active');
	const correspondingPron = parent.document.querySelector(`[data-word-index="${wordIndex}"].pronunciation-word`);
	if (correspondingPron) {
	correspondingPron.classList.add('pronunciation-active');
	}
	});

	newWord.addEventListener('mouseleave', () => {
	newWord.classList.remove('word-active');
	const correspondingPron = parent.document.querySelector(`[data-word-index="${wordIndex}"].pronunciation-word`);
	if (correspondingPron) {
	correspondingPron.classList.remove('pronunciation-active');
	}
	});
	}
	});

	pronunciations.forEach((pron, index) => {
	const wordIndex = pron.getAttribute('data-word-index');
	if (wordIndex !== null) {
	const newPron = pron.cloneNode(true);
	pron.parentNode.replaceChild(newPron, pron);

	newPron.addEventListener('mouseenter', () => {
	newPron.classList.add('pronunciation-active');
	const correspondingWord = parent.document.querySelector(`[data-word-index="${wordIndex}"].word-highlight`);
	if (correspondingWord) {
	correspondingWord.classList.add('word-active');
	}
	});

	newPron.addEventListener('mouseleave', () => {
	newPron.classList.remove('pronunciation-active');
	const correspondingWord = parent.document.querySelector(`[data-word-index="${wordIndex}"].word-highlight`);
	if (correspondingWord) {
	correspondingWord.classList.remove('word-active');
	}
	});
	}
	});
	}

	// Run interaction setup
	setTimeout(addHoverInteraction, 300);
	</script>
	""", height=0)

	# 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 by @aghilalb and ai</div>',
	unsafe_allow_html=True
	)

	if __name__ == "__main__":
	main()