ss

5.16appbeforesyllables.py

@@ -0,0 +1,336 @@
+import os
+import io
+import gradio as gr
+import torch
+import numpy as np
+import re
+import pronouncing  # Add this to requirements.txt for syllable counting
+import functools  # Add this for lru_cache functionality
+from transformers import (
+    AutoModelForAudioClassification,
+    AutoFeatureExtractor,
+    AutoTokenizer,
+    pipeline,
+    AutoModelForCausalLM,
+    BitsAndBytesConfig
+)
+from huggingface_hub import login
+from utils import (
+    load_audio,
+    extract_audio_duration,
+    extract_mfcc_features,
+    format_genre_results,
+    ensure_cuda_availability
+)
+from emotionanalysis import MusicAnalyzer
+import librosa
+
+# Login to Hugging Face Hub if token is provided
+if "HF_TOKEN" in os.environ:
+    login(token=os.environ["HF_TOKEN"])
+
+# Constants
+GENRE_MODEL_NAME = "dima806/music_genres_classification"
+MUSIC_DETECTION_MODEL = "MIT/ast-finetuned-audioset-10-10-0.4593"
+LLM_MODEL_NAME = "Qwen/Qwen3-32B"
+SAMPLE_RATE = 22050  # Standard sample rate for audio processing
+
+# Check CUDA availability (for informational purposes)
+CUDA_AVAILABLE = ensure_cuda_availability()
+
+# Load models at initialization time
+print("Loading genre classification model...")
+try:
+    genre_feature_extractor = AutoFeatureExtractor.from_pretrained(GENRE_MODEL_NAME)
+    genre_model = AutoModelForAudioClassification.from_pretrained(
+        GENRE_MODEL_NAME,
+        device_map="auto" if CUDA_AVAILABLE else None
+    )
+    # Create a convenience wrapper function with the same interface as before
+    def get_genre_model():
+        return genre_model, genre_feature_extractor
+except Exception as e:
+    print(f"Error loading genre model: {str(e)}")
+    genre_model = None
+    genre_feature_extractor = None
+
+# Load LLM and tokenizer at initialization time
+print("Loading Qwen LLM model with 4-bit quantization...")
+try:
+    # Configure 4-bit quantization for better performance
+    quantization_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.float16,
+        bnb_4bit_use_double_quant=True
+    )
+    
+    llm_tokenizer = AutoTokenizer.from_pretrained(LLM_MODEL_NAME)
+    llm_model = AutoModelForCausalLM.from_pretrained(
+        LLM_MODEL_NAME,
+        quantization_config=quantization_config,
+        device_map="auto",
+        trust_remote_code=True,
+        torch_dtype=torch.float16,
+        use_cache=True
+    )
+except Exception as e:
+    print(f"Error loading LLM model: {str(e)}")
+    llm_tokenizer = None
+    llm_model = None
+
+# Create music analyzer instance
+music_analyzer = MusicAnalyzer()
+
+# Process uploaded audio file
+def process_audio(audio_file):
+    if audio_file is None:
+        return "No audio file provided", None, None, None, None, None, None
+    
+    try:
+        # Load and analyze audio
+        y, sr = load_audio(audio_file, sr=SAMPLE_RATE)
+        
+        # Basic audio information
+        duration = extract_audio_duration(y, sr)
+        
+        # Analyze music with MusicAnalyzer
+        music_analysis = music_analyzer.analyze_music(audio_file)
+        
+        # Extract key information
+        tempo = music_analysis["rhythm_analysis"]["tempo"]
+        time_signature = music_analysis["rhythm_analysis"]["estimated_time_signature"]
+        emotion = music_analysis["emotion_analysis"]["primary_emotion"]
+        theme = music_analysis["theme_analysis"]["primary_theme"]
+        
+        # Use genre classification directly instead of pipeline
+        if genre_model is not None and genre_feature_extractor is not None:
+            # Resample audio to 16000 Hz for the genre model
+            y_16k = librosa.resample(y, orig_sr=sr, target_sr=16000)
+            
+            # Extract features
+            inputs = genre_feature_extractor(
+                y_16k, 
+                sampling_rate=16000, 
+                return_tensors="pt"
+            ).to(genre_model.device)
+            
+            # Classify genre
+            with torch.no_grad():
+                outputs = genre_model(**inputs)
+                logits = outputs.logits
+                probs = torch.nn.functional.softmax(logits, dim=-1)
+                
+            # Get top genres
+            values, indices = torch.topk(probs[0], k=5)
+            top_genres = [(genre_model.config.id2label[idx.item()], val.item()) for val, idx in zip(values, indices)]
+        else:
+            # Fallback if model loading failed
+            top_genres = [("Unknown", 1.0)]
+        
+        # Format genre results for display
+        genre_results_text = format_genre_results(top_genres)
+        primary_genre = top_genres[0][0]
+        
+        # Generate lyrics using LLM
+        lyrics = generate_lyrics(music_analysis, primary_genre, duration)
+        
+        # Prepare analysis summary
+        analysis_summary = f"""
+### Music Analysis Results
+
+**Duration:** {duration:.2f} seconds
+**Tempo:** {tempo:.1f} BPM
+**Time Signature:** {time_signature}
+**Key:** {music_analysis["tonal_analysis"]["key"]} {music_analysis["tonal_analysis"]["mode"]}
+**Primary Emotion:** {emotion}
+**Primary Theme:** {theme}
+**Top Genre:** {primary_genre}
+
+{genre_results_text}
+        """
+        
+        return analysis_summary, lyrics, tempo, time_signature, emotion, theme, primary_genre
+    
+    except Exception as e:
+        error_msg = f"Error processing audio: {str(e)}"
+        print(error_msg)
+        return error_msg, None, None, None, None, None, None
+
+def generate_lyrics(music_analysis, genre, duration):
+    try:
+        # Extract meaningful information for context
+        tempo = music_analysis["rhythm_analysis"]["tempo"]
+        key = music_analysis["tonal_analysis"]["key"]
+        mode = music_analysis["tonal_analysis"]["mode"]
+        emotion = music_analysis["emotion_analysis"]["primary_emotion"]
+        theme = music_analysis["theme_analysis"]["primary_theme"]
+        
+        # Verify LLM is loaded
+        if llm_model is None or llm_tokenizer is None:
+            return "Error: LLM model not properly loaded"
+        
+        # Construct prompt for the LLM with stronger instruction to avoid thinking
+        prompt = f"""Write lyrics for a {genre} song with these specifications:
+- Key: {key} {mode}
+- Tempo: {tempo} BPM
+- Emotion: {emotion}
+- Theme: {theme}
+- Duration: {duration:.1f} seconds
+- Time signature: {music_analysis["rhythm_analysis"]["estimated_time_signature"]}
+
+CRITICAL INSTRUCTIONS:
+- The lyrics should be in English
+- Write ONLY the raw lyrics with no structural labels
+- DO NOT include any thinking, reasoning, or explanations
+- DO NOT include <think> tags or thinking processes
+- DO NOT include [verse], [chorus], [bridge], or any other section markers
+- DO NOT number the verses or lines
+- DO NOT use bullet points
+- Format as simple line-by-line lyrics only
+- Make sure the lyrics match the specified duration and tempo
+- Keep lyrics concise enough to fit the duration when sung at the given tempo
+"""
+
+        # Generate lyrics using the LLM model directly
+        messages = [
+            {"role": "user", "content": prompt}
+        ]
+        
+        # Apply chat template
+        text = llm_tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+        
+        # Tokenize and move to model device
+        model_inputs = llm_tokenizer([text], return_tensors="pt").to(llm_model.device)
+        
+        # Generate with optimized parameters
+        generated_ids = llm_model.generate(
+            **model_inputs,
+            max_new_tokens=1024,
+            do_sample=True,
+            temperature=0.6,  # Lower temperature for more focused responses
+            top_p=0.9,
+            repetition_penalty=1.2,
+            pad_token_id=llm_tokenizer.eos_token_id
+        )
+        
+        # Decode the output
+        output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()
+        lyrics = llm_tokenizer.decode(output_ids, skip_special_tokens=True).strip()
+        
+        # ENHANCED post-processing to remove ALL thinking elements
+        
+        # Remove thinking tags and their content
+        lyrics = re.sub(r'<think>.*?</think>', '', lyrics, flags=re.DOTALL)
+        lyrics = re.sub(r'\[thinking\].*?\[/thinking\]', '', lyrics, flags=re.DOTALL)
+        
+        # Remove any lines with section labels
+        lyrics = re.sub(r'^\[.*?\].*$', '', lyrics, flags=re.MULTILINE)
+        
+        # Remove common prefixes and thinking text (expanded list)
+        thinking_prefixes = [
+            r'^(Here are|Here is|These are|This is|Let me|I will|I\'ll).*?:\s*',
+            r'^Okay, let\'s.*$',
+            r'^First, I need to.*$',
+            r'^Let me brainstorm.*$',
+            r'^I\'ll write.*$',
+            r'^Let\'s create.*$',
+            r'^For a.*song.*$',
+            r'^Now I\'ll.*$',
+            r'^Taking into account.*$',
+            r'^Given the specifications.*$',
+            r'^Based on the.*$',
+            r'^Considering the.*$'
+        ]
+        
+        for pattern in thinking_prefixes:
+            lyrics = re.sub(pattern, '', lyrics, flags=re.MULTILINE|re.IGNORECASE)
+            
+        lyrics = re.sub(r'^Title:.*?$', '', lyrics, flags=re.MULTILINE).strip()
+        
+        # Remove all section markers in any format
+        lyrics = re.sub(r'^\s*(Verse|Chorus|Bridge|Pre.?Chorus|Intro|Outro|Refrain|Hook|Breakdown)(\s*\d*|\s*[A-Z])?:?\s*$', '', lyrics, flags=re.MULTILINE|re.IGNORECASE)
+        lyrics = re.sub(r'\[(Verse|Chorus|Bridge|Pre.?Chorus|Intro|Outro|Refrain|Hook|Breakdown)(\s*\d*|\s*[A-Z])?\]', '', lyrics, flags=re.IGNORECASE)
+        
+        # Remove lines with obvious thinking content
+        lyrics = re.sub(r'^.*?(think|brainstorm|consider|syllable|count|rhyme|scheme|tempo|calculate|bpm).*$', '', lyrics, flags=re.MULTILINE|re.IGNORECASE)
+        
+        # Remove any empty lines at beginning, collapse multiple blank lines, and trim
+        lyrics = re.sub(r'^\s*\n', '', lyrics)
+        lyrics = re.sub(r'\n\s*\n\s*\n+', '\n\n', lyrics)
+        lyrics = lyrics.strip()
+        
+        # One final check - if lyrics still starts with obvious thinking, try to find the actual lyrics
+        if re.match(r'.*?(I need to|Let me|Okay|Hmm|I will|I\'ll|First|Let\'s|Now).*', lyrics[:100], re.IGNORECASE):
+            # Look for a double line break which often separates thinking from lyrics
+            parts = lyrics.split('\n\n')
+            if len(parts) > 1:
+                # Take everything after the first paragraph as the actual lyrics
+                lyrics = '\n\n'.join(parts[1:])
+        
+        return lyrics
+    
+    except Exception as e:
+        error_msg = f"Error generating lyrics: {str(e)}"
+        print(error_msg)
+        return error_msg
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(title="Music Analysis & Lyrics Generator") as demo:
+        gr.Markdown("# Music Analysis & Lyrics Generator")
+        gr.Markdown("Upload a music file or record audio to analyze it and generate matching lyrics")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                audio_input = gr.Audio(
+                    label="Upload or Record Audio", 
+                    type="filepath",
+                    sources=["upload", "microphone"]
+                )
+                analyze_btn = gr.Button("Analyze and Generate Lyrics", variant="primary")
+            
+            with gr.Column(scale=2):
+                with gr.Tab("Analysis"):
+                    analysis_output = gr.Textbox(label="Music Analysis Results", lines=10)
+                    
+                    with gr.Row():
+                        tempo_output = gr.Number(label="Tempo (BPM)")
+                        time_sig_output = gr.Textbox(label="Time Signature")
+                        emotion_output = gr.Textbox(label="Primary Emotion")
+                        theme_output = gr.Textbox(label="Primary Theme")
+                        genre_output = gr.Textbox(label="Primary Genre")
+                
+                with gr.Tab("Generated Lyrics"):
+                    lyrics_output = gr.Textbox(label="Generated Lyrics", lines=20)
+        
+        # Set up event handlers
+        analyze_btn.click(
+            fn=process_audio,
+            inputs=[audio_input],
+            outputs=[analysis_output, lyrics_output, tempo_output, time_sig_output, 
+                    emotion_output, theme_output, genre_output]
+        )
+        
+        gr.Markdown("""
+        ## How it works
+        1. Upload or record a music file
+        2. The system analyzes tempo, beats, time signature and other musical features
+        3. It detects emotion, theme, and music genre
+        4. Using this information, it generates lyrics that match the style and length of your music
+        """)
+    
+    return demo
+
+# Launch the app
+demo = create_interface()
+
+if __name__ == "__main__":
+    demo.launch()
+else:
+    # For Hugging Face Spaces
+    app = demo

app.py

@@ -4,8 +4,8 @@ import gradio as gr
 import torch
 import numpy as np
 import re
-import pronouncing  # Add this to requirements.txt for syllable counting
-import functools  # Add this for lru_cache functionality
+import pronouncing
+import functools
 from transformers import (
     AutoModelForAudioClassification,
     AutoFeatureExtractor,
@@ -22,8 +22,12 @@ from utils import (
     format_genre_results,
     ensure_cuda_availability
 )
-from emotionanalysis import MusicAnalyzer
+from emotionanalysis import MusicAnalyzer 
 import librosa
+from beat_analysis import BeatAnalyzer  # Import the BeatAnalyzer class
+
+# Initialize beat analyzer
+beat_analyzer = BeatAnalyzer()
 
 # Login to Hugging Face Hub if token is provided
 if "HF_TOKEN" in os.environ:
@@ -85,7 +89,7 @@ music_analyzer = MusicAnalyzer()
 # Process uploaded audio file
 def process_audio(audio_file):
     if audio_file is None:
-        return "No audio file provided", None, None, None, None, None, None
+        return "No audio file provided", None, None, None, None, None, None, None
     
     try:
         # Load and analyze audio
@@ -97,9 +101,24 @@ def process_audio(audio_file):
         # Analyze music with MusicAnalyzer
         music_analysis = music_analyzer.analyze_music(audio_file)
         
+        # Extract time signature from MusicAnalyzer result
+        time_signature = music_analysis["rhythm_analysis"]["estimated_time_signature"]
+        
+        # Ensure time signature is one of the supported ones (4/4, 3/4, 2/4, 6/8)
+        if time_signature not in ["4/4", "3/4", "2/4", "6/8"]:
+            time_signature = "4/4"  # Default to 4/4 if unsupported
+            music_analysis["rhythm_analysis"]["estimated_time_signature"] = time_signature
+        
+        # Analyze beat patterns and create lyrics template using MusicAnalyzer's time signature
+        beat_analysis = beat_analyzer.analyze_beat_pattern(audio_file, time_signature=time_signature)
+        lyric_templates = beat_analyzer.create_lyric_template(beat_analysis)
+        
+        # Store these in the music_analysis dict for use in lyrics generation
+        music_analysis["beat_analysis"] = beat_analysis
+        music_analysis["lyric_templates"] = lyric_templates
+        
         # Extract key information
         tempo = music_analysis["rhythm_analysis"]["tempo"]
-        time_signature = music_analysis["rhythm_analysis"]["estimated_time_signature"]
         emotion = music_analysis["emotion_analysis"]["primary_emotion"]
         theme = music_analysis["theme_analysis"]["primary_theme"]
         
@@ -135,6 +154,9 @@ def process_audio(audio_file):
         # Generate lyrics using LLM
         lyrics = generate_lyrics(music_analysis, primary_genre, duration)
         
+        # Create beat/stress/syllable matching analysis
+        beat_match_analysis = analyze_lyrics_rhythm_match(lyrics, lyric_templates, primary_genre)
+        
         # Prepare analysis summary
         analysis_summary = f"""
 ### Music Analysis Results
@@ -148,14 +170,26 @@ def process_audio(audio_file):
 **Top Genre:** {primary_genre}
 
 {genre_results_text}
-        """
+"""
+
+        # Add beat analysis summary
+        if lyric_templates:
+            analysis_summary += f"""
+### Beat Analysis
+
+**Total Phrases:** {len(lyric_templates)}
+**Average Beats Per Phrase:** {np.mean([t['num_beats'] for t in lyric_templates]):.1f}
+**Beat Pattern Examples:** 
+- Phrase 1: {lyric_templates[0]['stress_pattern'] if lyric_templates else 'N/A'}
+- Phrase 2: {lyric_templates[1]['stress_pattern'] if len(lyric_templates) > 1 else 'N/A'}
+"""
         
-        return analysis_summary, lyrics, tempo, time_signature, emotion, theme, primary_genre
+        return analysis_summary, lyrics, tempo, time_signature, emotion, theme, primary_genre, beat_match_analysis
     
     except Exception as e:
         error_msg = f"Error processing audio: {str(e)}"
         print(error_msg)
-        return error_msg, None, None, None, None, None, None
+        return error_msg, None, None, None, None, None, None, None
 
 def generate_lyrics(music_analysis, genre, duration):
     try:
@@ -166,33 +200,48 @@ def generate_lyrics(music_analysis, genre, duration):
         emotion = music_analysis["emotion_analysis"]["primary_emotion"]
         theme = music_analysis["theme_analysis"]["primary_theme"]
         
+        # Get beat analysis and templates
+        lyric_templates = music_analysis.get("lyric_templates", [])
+        
         # Verify LLM is loaded
         if llm_model is None or llm_tokenizer is None:
             return "Error: LLM model not properly loaded"
-        
-        # Construct prompt for the LLM
-        prompt = f"""Write lyrics for a {genre} song with these specifications:
-- Key: {key} {mode}
-- Tempo: {tempo} BPM
-- Emotion: {emotion}
-- Theme: {theme}
-- Duration: {duration:.1f} seconds
-- Time signature: {music_analysis["rhythm_analysis"]["estimated_time_signature"]}
 
-IMPORTANT INSTRUCTIONS:
-- The lyrics should be in English
-- Write ONLY the raw lyrics with no structural labels
-- DO NOT include [verse], [chorus], [bridge], or any other section markers
-- DO NOT include any explanations or thinking about the lyrics
-- DO NOT number the verses or lines
-- DO NOT use bullet points
-- Format as simple line-by-line lyrics only
-- Make sure the lyrics match the specified duration and tempo
-- Keep lyrics concise enough to fit the duration when sung at the given tempo
+        # If no templates, fall back to original method
+        if not lyric_templates:
+            # Simplified prompt
+            prompt = f"""Write song lyrics for a {genre} song in {key} {mode} with tempo {tempo} BPM. The emotion is {emotion} and theme is {theme}.
+
+ONLY WRITE THE ACTUAL LYRICS. NO EXPLANATIONS OR META-TEXT.
+"""
+        else:
+            # Create phrase examples
+            num_phrases = len(lyric_templates)
+            
+            # Create a more direct prompt with examples
+            prompt = f"""Write song lyrics for a {genre} song in {key} {mode} with tempo {tempo} BPM. The emotion is {emotion} and theme is {theme}.
+
+I need EXACTLY {num_phrases} lines of lyrics - one line for each musical phrase. Not one more, not one less.
+
+FORMAT:
+- Just write {num_phrases} plain text lines
+- Each line should be simple song lyrics (no annotations, no numbers, no labeling)
+- Don't include any explanations, thinking tags, or meta-commentary
+- Don't use any <think> or [thinking] tags
+- Don't include [Verse], [Chorus] or section markers
+- Don't include line numbers
+
+EXAMPLE OF WHAT I WANT (for a {num_phrases}-line song):
+Lost in the shadows of yesterday
+Dreams fade away like morning dew
+Time slips through fingers like desert sand
+Memories echo in empty rooms
+(... and so on for exactly {num_phrases} lines)
+
+JUST THE PLAIN LYRICS, EXACTLY {num_phrases} LINES.
 """
 
-        # Generate lyrics using the LLM model directly
-        # Format as chat message
+        # Generate lyrics using the LLM model
         messages = [
             {"role": "user", "content": prompt}
         ]
@@ -214,7 +263,7 @@ IMPORTANT INSTRUCTIONS:
             do_sample=True,
             temperature=0.7,
             top_p=0.9,
-            repetition_penalty=1.1,
+            repetition_penalty=1.2,
             pad_token_id=llm_tokenizer.eos_token_id
         )
         
@@ -222,33 +271,289 @@ IMPORTANT INSTRUCTIONS:
         output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()
         lyrics = llm_tokenizer.decode(output_ids, skip_special_tokens=True).strip()
         
-        # Enhanced post-processing to remove ALL structural elements and thinking
-        # Remove any lines with section labels using a more comprehensive pattern
-        lyrics = re.sub(r'^\[.*?\].*$', '', lyrics, flags=re.MULTILINE)
+        # ULTRA AGGRESSIVE CLEANING - COMPLETELY REVISED
+        # ------------------------------------------------
         
-        # Remove common prefixes and thinking text
-        lyrics = re.sub(r'^(Here are|Here is|These are|This is|Let me|I will|I\'ll).*?:\s*', '', lyrics, flags=re.IGNORECASE)
-        lyrics = re.sub(r'^Title:.*?$', '', lyrics, flags=re.MULTILINE).strip()
+        # 1. First, look for any standard dividers that might separate thinking from lyrics
+        divider_patterns = [
+            r'Here are the lyrics:',
+            r'Here is my song:',
+            r'The lyrics:',
+            r'My lyrics:',
+            r'Song lyrics:',
+            r'\*\*\*+',
+            r'===+',
+            r'---+',
+            r'```',
+            r'Lyrics:'
+        ]
+        
+        for pattern in divider_patterns:
+            matches = re.finditer(pattern, lyrics, re.IGNORECASE)
+            for match in matches:
+                # Keep only content after the divider
+                lyrics = lyrics[match.end():].strip()
         
-        # Remove all section markers in any format
-        lyrics = re.sub(r'^\s*(Verse|Chorus|Bridge|Pre.?Chorus|Intro|Outro|Refrain|Hook|Breakdown)(\s*\d*|\s*[A-Z])?:?\s*$', '', lyrics, flags=re.MULTILINE|re.IGNORECASE)
-        lyrics = re.sub(r'\[(Verse|Chorus|Bridge|Pre.?Chorus|Intro|Outro|Refrain|Hook|Breakdown)(\s*\d*|\s*[A-Z])?\]', '', lyrics, flags=re.IGNORECASE)
+        # 2. Remove thinking tags completely before splitting into lines
+        lyrics = re.sub(r'<think>.*?</think>', '', lyrics, flags=re.DOTALL)
+        lyrics = re.sub(r'\[thinking\].*?\[/thinking\]', '', lyrics, flags=re.DOTALL)
+        lyrics = re.sub(r'<think>', '', lyrics, flags=re.DOTALL)
+        lyrics = re.sub(r'</think>', '', lyrics, flags=re.DOTALL)
+        lyrics = re.sub(r'\[thinking\]', '', lyrics, flags=re.DOTALL)
+        lyrics = re.sub(r'\[/thinking\]', '', lyrics, flags=re.DOTALL)
         
-        # Remove any "thinking" or explanatory parts that might be at the beginning
-        lyrics = re.sub(r'^.*?(Let\'s|Here\'s|I need|I want|I\'ll|First|The|This).*?:\s*', '', lyrics, flags=re.IGNORECASE)
+        # 3. Split text into lines for aggressive line-by-line filtering
+        lines = lyrics.strip().split('\n')
+        clean_lines = []
         
-        # Remove any empty lines at beginning, collapse multiple blank lines, and trim
-        lyrics = re.sub(r'^\s*\n', '', lyrics)
-        lyrics = re.sub(r'\n\s*\n\s*\n+', '\n\n', lyrics)
-        lyrics = lyrics.strip()
+        # 4. Define comprehensive patterns for non-lyrical content
+        non_lyric_patterns = [
+            # Meta-commentary
+            r'^(note|thinking|thoughts|let me|i will|i am going|i would|i can|i need to|i have to|i should|let\'s|here|now)',
+            r'^(first|second|third|next|finally|importantly|remember|so|ok|okay|as requested|as asked|considering)',
+            # Explanations
+            r'syllable[s]?|phrase|rhythm|beats?|tempo|bpm|instruction|follow|alignment|match|corresponding',
+            r'verses?|chorus|bridge|section|stanza|part|template|format|pattern|example',
+            r'requirements?|guidelines?|song structure|stressed|unstressed',
+            # Technical language
+            r'generated|output|result|provide|create|write|draft|version',
+            # Annotations and numbering
+            r'^line \d+|^\d+[\.\):]|^\[\w+\]|^[\*\-\+] ',
+            # Questions or analytical statements
+            r'\?$|analysis|evaluate|review|check|ensure',
+            # Instruction-like statements
+            r'make sure|please note|important|notice|pay attention'
+        ]
         
-        return lyrics
+        # 5. Identify which lines are likely actual lyrics vs non-lyrics
+        for line in lines:
+            line = line.strip()
+            
+            # Skip empty lines or lines with just spaces/tabs
+            if not line or line.isspace():
+                continue
+            
+            # Skip lines that match any non-lyric pattern
+            should_skip = False
+            for pattern in non_lyric_patterns:
+                if re.search(pattern, line.lower()):
+                    should_skip = True
+                    break
+            
+            if should_skip:
+                continue
+            
+            # Skip section headers
+            if (line.startswith('[') and ']' in line) or (line.startswith('(') and ')' in line and len(line) < 20):
+                continue
+            
+            # Skip lines that look like annotations (not prose-like)
+            if ':' in line and not any(word in line.lower() for word in ['like', 'when', 'where', 'how', 'why', 'what']):
+                if len(line.split(':')[0]) < 15:  # Short prefixes followed by colon are likely annotations
+                    continue
+            
+            # Skip very short lines that aren't likely to be lyrics (unless it's just a few words which could be valid)
+            if len(line) < 3:
+                continue
+            
+            # Skip lines that are numbered or bulleted
+            if re.match(r'^\d+\.|\(#\d+\)|\d+\)', line):
+                continue
+            
+            # Skip markdown-style emphasis or headers
+            if re.match(r'^#{1,6} |^\*\*|^__', line):
+                continue
+            
+            # Skip lines with think tags
+            if '<think>' in line.lower() or '</think>' in line.lower() or '[thinking]' in line.lower() or '[/thinking]' in line.lower():
+                continue
+                
+            # Add this line as it passed all filters
+            clean_lines.append(line)
+        
+        # 6. Additional block-level filters for common patterns
+        # Check beginning of lyrics for common prefixes
+        if clean_lines and any(clean_lines[0].lower().startswith(prefix) for prefix in 
+                            ['here are', 'these are', 'below are', 'following are']):
+            clean_lines = clean_lines[1:]  # Skip the first line
+        
+        # 7. Process blocks of lines to detect explanation blocks
+        if len(clean_lines) > 3:
+            # Check for explanation blocks at the beginning
+            first_three = ' '.join(clean_lines[:3]).lower()
+            if any(term in first_three for term in ['i will', 'i have created', 'i\'ll provide', 'i\'ll write']):
+                # This looks like an explanation, skip the first few lines
+                start_idx = 0
+                for i, line in enumerate(clean_lines):
+                    if i >= 3 and not any(term in line.lower() for term in ['i will', 'created', 'write', 'provide']):
+                        start_idx = i
+                        break
+                clean_lines = clean_lines[start_idx:]
+            
+            # Check for explanation blocks at the end
+            last_three = ' '.join(clean_lines[-3:]).lower()
+            if any(term in last_three for term in ['hope this', 'these lyrics', 'as you can see', 'this song', 'i have']):
+                # This looks like an explanation at the end, truncate
+                end_idx = len(clean_lines)
+                for i in range(len(clean_lines) - 1, max(0, len(clean_lines) - 4), -1):
+                    if i < len(clean_lines) and not any(term in clean_lines[i].lower() for term in 
+                                                    ['hope', 'these lyrics', 'as you can see', 'this song']):
+                        end_idx = i + 1
+                        break
+                clean_lines = clean_lines[:end_idx]
+        
+        # 8. Cleanup - Remove remaining annotations or thinking
+        for i in range(len(clean_lines)):
+            # Remove trailing thoughts/annotations
+            clean_lines[i] = re.sub(r'\s+//.*$', '', clean_lines[i])
+            clean_lines[i] = re.sub(r'\s+\(.*?\)$', '', clean_lines[i])
+            
+            # Remove thinking tags completely
+            clean_lines[i] = re.sub(r'<think>.*?</think>', '', clean_lines[i], flags=re.DOTALL)
+            clean_lines[i] = re.sub(r'\[thinking\].*?\[/thinking\]', '', clean_lines[i], flags=re.DOTALL)
+            clean_lines[i] = re.sub(r'<think>', '', clean_lines[i])
+            clean_lines[i] = re.sub(r'</think>', '', clean_lines[i])
+            clean_lines[i] = re.sub(r'\[thinking\]', '', clean_lines[i])
+            clean_lines[i] = re.sub(r'\[/thinking\]', '', clean_lines[i])
+        
+        # 9. Filter out any remaining empty lines after tag removal
+        clean_lines = [line for line in clean_lines if line.strip() and not line.isspace()]
+        
+        # 10. If we have lyric templates, ensure we have the correct number of lines
+        if lyric_templates:
+            num_required = len(lyric_templates)
+            
+            # If we have too many lines, keep just the best ones
+            if len(clean_lines) > num_required:
+                # Keep the first num_required lines
+                clean_lines = clean_lines[:num_required]
+            
+            # If we don't have enough lines, generate placeholders
+            while len(clean_lines) < num_required:
+                placeholder = f"Echoes of {emotion} fill the {genre} night"
+                if len(clean_lines) > 0:
+                    # Try to make the placeholder somewhat related to previous lines
+                    last_words = [word for line in clean_lines[-1:] for word in line.split() if len(word) > 3]
+                    if last_words:
+                        import random
+                        word = random.choice(last_words)
+                        placeholder = f"{word.capitalize()} whispers through the {emotion} silence"
+                
+                clean_lines.append(placeholder)
+        
+        # Assemble final lyrics
+        final_lyrics = '\n'.join(clean_lines)
+        
+        # 11. Final sanity check - if we have nothing or garbage, return an error
+        if not final_lyrics or len(final_lyrics) < 10:
+            return "The model generated only thinking content but no actual lyrics. Please try again."
+        
+        return final_lyrics
     
     except Exception as e:
         error_msg = f"Error generating lyrics: {str(e)}"
         print(error_msg)
         return error_msg
 
+def analyze_lyrics_rhythm_match(lyrics, lyric_templates, genre="pop"):
+    """Analyze how well the generated lyrics match the beat patterns and syllable requirements"""
+    if not lyric_templates or not lyrics:
+        return "No beat templates or lyrics available for analysis."
+    
+    # Split lyrics into lines
+    lines = lyrics.strip().split('\n')
+    lines = [line for line in lines if line.strip()]  # Remove empty lines
+    
+    # Prepare analysis result
+    result = "### Beat & Syllable Match Analysis\n\n"
+    result += "| Line | Syllables | Target Range | Match | Stress Pattern |\n"
+    result += "| ---- | --------- | ------------ | ----- | -------------- |\n"
+    
+    # Maximum number of lines to analyze (either all lines or all templates)
+    line_count = min(len(lines), len(lyric_templates))
+    
+    # Track overall match statistics
+    total_matches = 0
+    total_range_matches = 0
+    total_stress_matches = 0
+    total_stress_percentage = 0
+    total_ideal_matches = 0
+    
+    for i in range(line_count):
+        line = lines[i]
+        template = lyric_templates[i]
+        
+        # Check match between line and template with genre awareness
+        check_result = beat_analyzer.check_syllable_stress_match(line, template, genre)
+        
+        # Get match symbols
+        syllable_match = "✓" if check_result["matches_beat_count"] else ("✓*" if check_result["within_range"] else "✗")
+        stress_match = "✓" if check_result["stress_matches"] else f"{int(check_result['stress_match_percentage']*100)}%"
+        
+        # Update stats
+        if check_result["matches_beat_count"]:
+            total_matches += 1
+        if check_result["within_range"]:
+            total_range_matches += 1
+        if check_result["stress_matches"]:
+            total_stress_matches += 1
+        total_stress_percentage += check_result["stress_match_percentage"]
+        
+        # Track how close we are to ideal count for this genre
+        if abs(check_result["syllable_count"] - check_result["ideal_syllable_count"]) <= 1:
+            total_ideal_matches += 1
+        
+        # Create visual representation of the stress pattern
+        stress_visual = ""
+        for char in template['stress_pattern']:
+            if char == "S":
+                stress_visual += "X"  # Strong
+            elif char == "M":
+                stress_visual += "x"  # Medium
+            else:
+                stress_visual += "."  # Weak
+        
+        # Add line to results table
+        result += f"| {i+1} | {check_result['syllable_count']} | {check_result['min_expected']}-{check_result['max_expected']} | {syllable_match} | {stress_visual} |\n"
+    
+    # Add summary statistics
+    if line_count > 0:
+        exact_match_rate = (total_matches / line_count) * 100
+        range_match_rate = (total_range_matches / line_count) * 100
+        ideal_match_rate = (total_ideal_matches / line_count) * 100
+        stress_match_rate = (total_stress_matches / line_count) * 100
+        avg_stress_percentage = (total_stress_percentage / line_count) * 100
+        
+        result += f"\n**Summary:**\n"
+        result += f"- Exact syllable match rate: {exact_match_rate:.1f}%\n"
+        result += f"- Genre-appropriate syllable range match rate: {range_match_rate:.1f}%\n"
+        result += f"- Ideal genre syllable count match rate: {ideal_match_rate:.1f}%\n"
+        result += f"- Perfect stress pattern match rate: {stress_match_rate:.1f}%\n"
+        result += f"- Average stress pattern accuracy: {avg_stress_percentage:.1f}%\n"
+        result += f"- Overall rhythmic accuracy: {((range_match_rate + avg_stress_percentage) / 2):.1f}%\n"
+        
+        # Add genre-specific notes
+        result += f"\n**Genre Notes ({genre}):**\n"
+        
+        # Add appropriate genre notes based on genre
+        if genre.lower() == "pop":
+            result += "- Pop music typically allows 1-3 syllables per beat using melisma and syncopation\n"
+            result += "- Strong downbeats often align with stressed syllables of important words\n"
+        elif genre.lower() == "rock":
+            result += "- Rock music often uses 1-2 syllables per beat with some variation\n"
+            result += "- Emphasis on strong beats for impact and rhythmic drive\n"
+        elif genre.lower() in ["hiphop", "rap"]:
+            result += "- Hip-hop/rap often features 2-5 syllables per beat through rapid delivery\n"
+            result += "- Complex rhyme patterns and fast delivery create higher syllable density\n"
+        elif genre.lower() in ["folk", "country"]:
+            result += "- Folk/country music often stays closer to 1:1 syllable-to-beat ratio\n"
+            result += "- Narrative focus leads to clearer enunciation of syllables\n"
+        else:
+            result += "- This genre typically allows for flexible syllable-to-beat relationships\n"
+            result += "- Syllable count can vary based on vocal style and song section\n"
+    
+    return result
+
 # Create Gradio interface
 def create_interface():
     with gr.Blocks(title="Music Analysis & Lyrics Generator") as demo:
@@ -277,13 +582,16 @@ def create_interface():
                 
                 with gr.Tab("Generated Lyrics"):
                     lyrics_output = gr.Textbox(label="Generated Lyrics", lines=20)
+                
+                with gr.Tab("Beat Matching"):
+                    beat_match_output = gr.Markdown(label="Beat & Syllable Matching Analysis")
         
         # Set up event handlers
         analyze_btn.click(
             fn=process_audio,
             inputs=[audio_input],
             outputs=[analysis_output, lyrics_output, tempo_output, time_sig_output, 
-                    emotion_output, theme_output, genre_output]
+                    emotion_output, theme_output, genre_output, beat_match_output]
         )
         
         gr.Markdown("""
@@ -291,7 +599,8 @@ def create_interface():
         1. Upload or record a music file
         2. The system analyzes tempo, beats, time signature and other musical features
         3. It detects emotion, theme, and music genre
-        4. Using this information, it generates lyrics that match the style and length of your music
+        4. Using beat patterns and syllable stress analysis, it generates perfectly aligned lyrics
+        5. Each line of the lyrics is matched to the beat pattern of the corresponding musical phrase
         """)
     
     return demo

beat_analysis.py

@@ -0,0 +1,392 @@
+import librosa
+import numpy as np
+import pronouncing
+import re
+from functools import lru_cache
+import string
+from nltk.corpus import cmudict
+import nltk
+
+try:
+    nltk.data.find('corpora/cmudict')
+except LookupError:
+    nltk.download('cmudict')
+
+class BeatAnalyzer:
+    def __init__(self):
+        # Mapping for standard stress patterns by time signature
+        # Simplified to only include 4/4, 3/4, 2/4, and 6/8
+        self.stress_patterns = {
+            # Format: Strong (1.0), Medium (0.5), Weak (0.0)
+            "4/4": [1.0, 0.0, 0.5, 0.0],  # Strong, weak, medium, weak
+            "3/4": [1.0, 0.0, 0.0],       # Strong, weak, weak
+            "2/4": [1.0, 0.0],            # Strong, weak
+            "6/8": [1.0, 0.0, 0.0, 0.5, 0.0, 0.0]   # Strong, weak, weak, medium, weak, weak
+        }
+        
+        self.cmudict = None
+        try:
+            self.cmudict = cmudict.dict()
+        except:
+            pass  # Fall back to rule-based counting if cmudict is not available
+            
+        # Genre-specific syllable-to-beat ratio guidelines
+        self.genre_syllable_ratios = {
+            # Genre: (min_ratio, typical_ratio, max_ratio)
+            'pop': (0.7, 1.5, 3.0),        # Pop tends to have more syllables per beat
+            'rock': (0.7, 1.2, 2.5),       # Rock can vary widely
+            'hiphop': (1.5, 3.0, 5.0),     # Hip hop often has many syllables per beat
+            'rap': (2.0, 4.0, 7.0),        # Rap often has very high syllable counts
+            'folk': (0.8, 1.0, 1.5),       # Folk often has close to 1:1 ratio
+            'country': (0.7, 1.2, 2.0),    # Country tends to be moderate
+            'jazz': (0.5, 1.0, 3.0),       # Jazz can be very flexible
+            'reggae': (0.6, 1.0, 1.5),     # Reggae often emphasizes specific beats
+            'soul': (0.7, 1.2, 2.0),       # Soul music tends to be expressive
+            'r&b': (0.8, 1.5, 2.5),        # R&B can have melisma
+            'electronic': (0.5, 1.0, 2.0), # Electronic music varies widely
+            'disco': (1.0, 1.5, 2.5),      # Disco tends to have more syllables
+            'classical': (0.5, 1.0, 2.0),  # Classical can vary by subgenre
+            'metal': (0.8, 1.5, 3.0),      # Metal often has more syllables on strong beats
+            'blues': (0.5, 0.8, 1.5),      # Blues often extends syllables
+            'default': (0.7, 1.5, 3.0)     # Default for unknown genres
+        }
+        
+    @lru_cache(maxsize=128)
+    def count_syllables(self, word):
+        """Count syllables in a word using CMU dictionary if available, otherwise use rule-based method."""
+        word = word.lower().strip()
+        word = re.sub(r'[^a-z]', '', word)  # Remove non-alphabetic characters
+        
+        if not word:
+            return 0
+            
+        # Try using CMUDict first if available
+        if self.cmudict and word in self.cmudict:
+            return max([len(list(y for y in x if y[-1].isdigit())) for x in self.cmudict[word]])
+            
+        # Rule-based syllable counting as fallback
+        # Modified version from NLTK's implementation
+        vowels = "aeiouy"
+        double_vowels = ['aa', 'ae', 'ai', 'ao', 'au', 'ay', 'ea', 'ee', 'ei', 'eo', 'eu', 'ey', 'ia', 'ie', 'ii', 'io', 'iu', 'oa', 'oe', 'oi', 'oo', 'ou', 'oy', 'ua', 'ue', 'ui', 'uo', 'uy']
+        prev_was_vowel = False
+        count = 0
+        final_e = False
+        
+        if word.endswith('e') and not word.endswith('le'):
+            final_e = True
+            
+        for i, char in enumerate(word):
+            if char in vowels:
+                # Check if current char and previous char form a dipthong
+                if prev_was_vowel and i > 0 and (word[i-1:i+1] in double_vowels):
+                    prev_was_vowel = True
+                    continue
+                
+                if not prev_was_vowel:
+                    count += 1
+                prev_was_vowel = True
+            else:
+                prev_was_vowel = False
+                
+        # Handle edge cases
+        if word.endswith('le') and len(word) > 2 and word[-3] not in vowels:
+            count += 1
+        elif final_e:
+            count = max(count-1, 1)  # Remove last 'e', but ensure at least 1 syllable
+        elif word.endswith('y') and not prev_was_vowel:
+            count += 1
+            
+        # Ensure at least one syllable
+        return max(count, 1)
+    
+    def analyze_beat_pattern(self, audio_path, sr=22050, time_signature="4/4"):
+        """Analyze beat patterns and stresses in music using the provided time signature."""
+        # Load audio
+        y, sr = librosa.load(audio_path, sr=sr)
+        
+        # Get tempo and beat frames
+        tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)
+        beat_times = librosa.frames_to_time(beat_frames, sr=sr)
+        
+        # Get beat strengths using onset envelope
+        onset_env = librosa.onset.onset_strength(y=y, sr=sr)
+        beat_strengths = onset_env[beat_frames]
+        
+        # Normalize beat strengths
+        if len(beat_strengths) > 0 and np.max(beat_strengths) > np.min(beat_strengths):
+            beat_strengths = (beat_strengths - np.min(beat_strengths)) / (np.max(beat_strengths) - np.min(beat_strengths))
+        
+        # Parse time signature
+        if '/' in time_signature:
+            num, denom = map(int, time_signature.split('/'))
+        else:
+            num, denom = 4, 4  # Default to 4/4
+        
+        # Group beats into bars (each bar is one phrase based on time signature)
+        bars = []
+        current_bar = []
+        
+        for i, (time, strength) in enumerate(zip(beat_times, beat_strengths)):
+            # Determine metrical position and stress
+            metrical_position = i % num
+            
+            # Define stress pattern according to time signature
+            if time_signature == "4/4":
+                if metrical_position == 0:  # First beat (strongest)
+                    stress = "S"  # Strong
+                elif metrical_position == 2:  # Third beat (medium)
+                    stress = "M"  # Medium
+                else:  # Second and fourth beats (weak)
+                    stress = "W"  # Weak
+            elif time_signature == "3/4":
+                if metrical_position == 0:  # First beat (strongest)
+                    stress = "S"  # Strong
+                else:  # Other beats (weak)
+                    stress = "W"  # Weak
+            elif time_signature == "6/8":
+                if metrical_position == 0:  # First beat (strongest)
+                    stress = "S"  # Strong
+                elif metrical_position == 3:  # Fourth beat (medium)
+                    stress = "M"  # Medium
+                else:  # Other beats (weak)
+                    stress = "W"  # Weak
+            elif time_signature == "2/4":
+                if metrical_position == 0:  # First beat (strongest)
+                    stress = "S"  # Strong
+                else:  # Second beat (weak)
+                    stress = "W"  # Weak
+            else:
+                # Default pattern for other time signatures
+                if metrical_position == 0:
+                    stress = "S"
+                else:
+                    stress = "W"
+            
+            # Add beat to current bar
+            current_bar.append({
+                'time': time,
+                'strength': strength,
+                'stress': stress,
+                'metrical_position': metrical_position
+            })
+            
+            # When we complete a bar, add it to our bars list
+            if metrical_position == num - 1 or i == len(beat_times) - 1:
+                if current_bar:
+                    bars.append(current_bar)
+                    current_bar = []
+                    
+        # If there's any remaining beats, add them as a partial bar
+        if current_bar:
+            bars.append(current_bar)
+        
+        # Organize beats into phrases (one phrase = one bar)
+        phrases = []
+        
+        for i, bar in enumerate(bars):
+            phrase_beats = bar
+            
+            if not phrase_beats:
+                continue
+                
+            # Calculate the phrase information
+            phrase = {
+                'id': i,
+                'num_beats': len(phrase_beats),
+                'beats': phrase_beats,
+                'stress_pattern': ''.join(beat['stress'] for beat in phrase_beats),
+                'start_time': phrase_beats[0]['time'],
+                'end_time': phrase_beats[-1]['time'] + (phrase_beats[-1]['time'] - phrase_beats[-2]['time'] if len(phrase_beats) > 1 else 0.5),
+            }
+            
+            phrases.append(phrase)
+        
+        return {
+            'tempo': tempo,
+            'time_signature': time_signature,
+            'num_beats': len(beat_times),
+            'beat_times': beat_times.tolist(),
+            'beat_strengths': beat_strengths.tolist(),
+            'phrases': phrases
+        }
+    
+    def create_lyric_template(self, beat_analysis):
+        """Create templates for lyrics based on beat phrases."""
+        templates = []
+        
+        if not beat_analysis or 'phrases' not in beat_analysis:
+            return templates
+            
+        phrases = beat_analysis['phrases']
+        
+        for i, phrase in enumerate(phrases):
+            duration = phrase['end_time'] - phrase['start_time']
+            
+            template = {
+                'id': phrase['id'],
+                'start_time': phrase['start_time'],
+                'end_time': phrase['end_time'],
+                'duration': duration,
+                'num_beats': phrase['num_beats'],
+                'stress_pattern': phrase['stress_pattern'],
+                'syllable_guide': self.generate_phrase_guide(phrase)
+            }
+            
+            templates.append(template)
+            
+        return templates
+    
+    def generate_phrase_guide(self, template, words_per_beat=0.5):
+        """Generate a guide for each phrase to help the LLM."""
+        num_beats = template['num_beats']
+        stress_pattern = template['stress_pattern']
+        
+        # Create a visual representation of the stress pattern
+        # S = Strong stress, M = Medium stress, W = Weak stress
+        visual_pattern = ""
+        for i, stress in enumerate(stress_pattern):
+            if stress == "S":
+                visual_pattern += "STRONG "
+            elif stress == "M":
+                visual_pattern += "medium "
+            else:
+                visual_pattern += "weak "
+        
+        # Estimate number of words based on beats (very rough estimate)
+        est_words = max(1, int(num_beats * words_per_beat))
+        
+        # Estimate syllables - more flexible now, allowing for reasonable ranges
+        # Typical song might have 1-3 syllables per beat
+        min_syllables = num_beats
+        max_syllables = num_beats * 3
+        
+        guide = f"~{est_words} words, ~{min_syllables}-{max_syllables} syllables | Pattern: {visual_pattern}"
+        return guide
+
+    def check_syllable_stress_match(self, text, template, genre="pop"):
+        """Check if lyrics match the syllable and stress pattern with genre-specific flexibility."""
+        # Split text into words and count syllables
+        words = text.split()
+        syllable_count = sum(self.count_syllables(word) for word in words)
+        
+        # Get expected syllable count based on number of beats
+        expected_count = template['num_beats']
+        
+        # Get syllable-to-beat ratios based on genre
+        genre_lower = genre.lower()
+        if genre_lower in self.genre_syllable_ratios:
+            min_ratio, typical_ratio, max_ratio = self.genre_syllable_ratios[genre_lower]
+        else:
+            min_ratio, typical_ratio, max_ratio = self.genre_syllable_ratios['default']
+        
+        # Calculate flexible min and max syllable expectations based on genre
+        min_expected = max(1, int(expected_count * min_ratio))
+        max_expected = int(expected_count * max_ratio)
+        
+        # Check if syllable count falls within genre-appropriate range
+        within_range = min_expected <= syllable_count <= max_expected
+        
+        # Consider typical ratio - how close are we to the ideal for this genre?
+        ideal_count = int(expected_count * typical_ratio)
+        closeness_to_ideal = 1.0 - min(abs(syllable_count - ideal_count) / (max_expected - min_expected + 1), 1.0)
+        
+        # Get detailed syllable breakdown for stress analysis
+        word_syllables = []
+        for word in words:
+            count = self.count_syllables(word)
+            word_syllables.append(count)
+        
+        # Analyze stress pattern match using a more flexible approach
+        stress_pattern = template['stress_pattern']
+        
+        # Simple stress matching algorithm (can be improved in future versions)
+        # We need to map syllables to beats in a more flexible way
+        syllable_to_beat_mapping = self._map_syllables_to_beats(word_syllables, stress_pattern)
+        
+        # Calculate stress match score based on alignment of stressed syllables with strong beats
+        stress_match_percentage = self._calculate_stress_match(words, word_syllables, syllable_to_beat_mapping, stress_pattern)
+        
+        # Consider a stress match if the percentage is high enough
+        stress_matches = stress_match_percentage >= 0.7
+        
+        return {
+            'syllable_count': syllable_count,
+            'expected_count': expected_count,
+            'min_expected': min_expected,
+            'max_expected': max_expected,
+            'within_range': within_range,
+            'matches_beat_count': syllable_count == expected_count,  # Exact match (strict)
+            'close_match': within_range,  # Flexible match (based on genre)
+            'stress_matches': stress_matches,
+            'stress_match_percentage': stress_match_percentage,
+            'closeness_to_ideal': closeness_to_ideal,
+            'word_syllables': word_syllables,
+            'ideal_syllable_count': ideal_count
+        }
+    
+    def _map_syllables_to_beats(self, word_syllables, stress_pattern):
+        """Map syllables to beats in a flexible way."""
+        total_syllables = sum(word_syllables)
+        total_beats = len(stress_pattern)
+        
+        # Simple mapping for now - this could be improved with more sophisticated algorithms
+        if total_syllables <= total_beats:
+            # Fewer syllables than beats - some beats have no syllables (prolongation)
+            mapping = []
+            syllable_index = 0
+            for beat_index in range(total_beats):
+                if syllable_index < total_syllables:
+                    mapping.append((syllable_index, beat_index))
+                    syllable_index += 1
+            return mapping
+        else:
+            # More syllables than beats - some beats have multiple syllables (melisma/syncopation)
+            mapping = []
+            syllables_per_beat = total_syllables / total_beats
+            for beat_index in range(total_beats):
+                start_syllable = int(beat_index * syllables_per_beat)
+                end_syllable = int((beat_index + 1) * syllables_per_beat)
+                for syllable_index in range(start_syllable, end_syllable):
+                    if syllable_index < total_syllables:
+                        mapping.append((syllable_index, beat_index))
+            return mapping
+    
+    def _calculate_stress_match(self, words, word_syllables, syllable_to_beat_mapping, stress_pattern):
+        """Calculate how well syllable stresses match beat stresses."""
+        # This is a simplified version - real stress analysis would be more complex
+        # For now, we'll assume the first syllable of each word is stressed
+        
+        # First, create a flat list of all syllables with their stress (1 = stressed, 0 = unstressed)
+        syllable_stresses = []
+        for word, syllable_count in zip(words, word_syllables):
+            # Simple assumption: first syllable is stressed, rest are unstressed
+            for i in range(syllable_count):
+                if i == 0:  # First syllable of word
+                    syllable_stresses.append(1)  # Stressed
+                else:
+                    syllable_stresses.append(0)  # Unstressed
+        
+        # Count matches between syllable stress and beat stress
+        matches = 0
+        total_mapped = 0
+        
+        for syllable_index, beat_index in syllable_to_beat_mapping:
+            if syllable_index < len(syllable_stresses):
+                syllable_stress = syllable_stresses[syllable_index]
+                beat_stress = 1 if stress_pattern[beat_index] == 'S' else (0.5 if stress_pattern[beat_index] == 'M' else 0)
+                
+                # Consider it a match if:
+                # - Stressed syllable on Strong beat
+                # - Unstressed syllable on Weak beat
+                # - Some partial credit for other combinations
+                if (syllable_stress == 1 and beat_stress > 0.5) or (syllable_stress == 0 and beat_stress < 0.5):
+                    matches += 1
+                elif syllable_stress == 1 and beat_stress == 0.5:  # Stressed syllable on Medium beat
+                    matches += 0.7
+                
+                total_mapped += 1
+        
+        if total_mapped == 0:
+            return 0
+            
+        return matches / total_mapped

emotionanalysis.py

@@ -36,15 +36,12 @@ class MusicAnalyzer:
         self.key_names = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
         
         # Common time signatures and their beat patterns with weights for prior probability
+        # Simplified to only include 4/4, 3/4, 2/4, and 6/8
         self.common_time_signatures = {
-            "4/4": {"beats_per_bar": 4, "beat_pattern": [1.0, 0.2, 0.5, 0.2], "weight": 0.35},
+            "4/4": {"beats_per_bar": 4, "beat_pattern": [1.0, 0.2, 0.5, 0.2], "weight": 0.45},
             "3/4": {"beats_per_bar": 3, "beat_pattern": [1.0, 0.2, 0.3], "weight": 0.25},
             "2/4": {"beats_per_bar": 2, "beat_pattern": [1.0, 0.3], "weight": 0.15},
-            "6/8": {"beats_per_bar": 6, "beat_pattern": [1.0, 0.2, 0.3, 0.8, 0.2, 0.3], "weight": 0.25},
-            "5/4": {"beats_per_bar": 5, "beat_pattern": [1.0, 0.2, 0.4, 0.7, 0.2], "weight": 0.10},
-            "7/8": {"beats_per_bar": 7, "beat_pattern": [1.0, 0.2, 0.3, 0.8, 0.2, 0.2, 0.3], "weight": 0.10},
-            "9/8": {"beats_per_bar": 9, "beat_pattern": [1.0, 0.2, 0.3, 0.8, 0.2, 0.3, 0.7, 0.2, 0.3], "weight": 0.10},
-            "12/8": {"beats_per_bar": 12, "beat_pattern": [1.0, 0.2, 0.3, 0.6, 0.2, 0.3, 0.8, 0.2, 0.3, 0.6, 0.2, 0.3], "weight": 0.15}
+            "6/8": {"beats_per_bar": 6, "beat_pattern": [1.0, 0.2, 0.3, 0.8, 0.2, 0.3], "weight": 0.15}
         }
         
         # Add common accent patterns for different time signatures
@@ -52,11 +49,7 @@ class MusicAnalyzer:
             "4/4": [[1, 0, 0, 0], [1, 0, 2, 0], [1, 0, 2, 0, 3, 0, 2, 0]],
             "3/4": [[1, 0, 0], [1, 0, 2]],
             "2/4": [[1, 0], [1, 2]],
-            "6/8": [[1, 0, 0, 2, 0, 0], [1, 0, 0, 2, 0, 3]],
-            "5/4": [[1, 0, 0, 2, 0], [1, 0, 2, 0, 0]],
-            "7/8": [[1, 0, 0, 2, 0, 0, 0], [1, 0, 0, 2, 0, 3, 0]],
-            "9/8": [[1, 0, 0, 2, 0, 0, 3, 0, 0]],
-            "12/8": [[1, 0, 0, 2, 0, 0, 3, 0, 0, 4, 0, 0]]
+            "6/8": [[1, 0, 0, 2, 0, 0], [1, 0, 0, 2, 0, 3]]
         }
         
         # Expected rhythm density (relative note density per beat) for different time signatures
@@ -64,9 +57,7 @@ class MusicAnalyzer:
             "4/4": [1.0, 0.7, 0.8, 0.6],
             "3/4": [1.0, 0.6, 0.7],
             "6/8": [1.0, 0.5, 0.4, 0.8, 0.5, 0.4],
-            "2/4": [1.0, 0.6],
-            "5/4": [1.0, 0.6, 0.8, 0.7, 0.6],
-            "7/8": [1.0, 0.5, 0.4, 0.8, 0.5, 0.4, 0.5]
+            "2/4": [1.0, 0.6]
         }
 
     def load_audio(self, file_path, sr=22050, duration=None):
@@ -320,7 +311,7 @@ class MusicAnalyzer:
         
         # Find peaks in spectrum
         peaks = signal.find_peaks(S_tempo, height=np.max(S_tempo)*0.1, distance=5)[0]
-        
+
         if len(peaks) == 0:
             return {"time_signature": "4/4", "confidence": 0.4}
             
@@ -448,18 +439,18 @@ class MusicAnalyzer:
     
     def _estimate_from_tempo(self, tempo):
         """Use tempo to help estimate likely time signature"""
-        # Statistical tendencies: slower tempos often in compound meters (6/8, 12/8)
-        # Very fast tempos often counted in cut time (2/2 instead of 4/4)
+        # Statistical tendencies: slower tempos often in compound meters (6/8)
+        # Fast tempos often favor simple meters (2/4)
         
         scores = {}
         
         if tempo < 70:
             # Slow tempos favor compound meters
             scores = {
-                "4/4": 0.4,
-                "3/4": 0.5,
-                "6/8": 0.7,
-                "12/8": 0.6
+                "4/4": 0.5,
+                "3/4": 0.4,
+                "2/4": 0.3,
+                "6/8": 0.7
             }
         elif 70 <= tempo <= 120:
             # Medium tempos favor 4/4, 3/4
@@ -467,15 +458,15 @@ class MusicAnalyzer:
                 "4/4": 0.7,
                 "3/4": 0.6,
                 "2/4": 0.4,
-                "6/8": 0.5
+                "6/8": 0.3
             }
         else:
             # Fast tempos favor simpler meters
             scores = {
                 "4/4": 0.6,
                 "2/4": 0.7,
-                "2/2": 0.6,
-                "3/4": 0.4
+                "3/4": 0.4,
+                "6/8": 0.2
             }
         
         # Find best match

requirements.txt

@@ -13,3 +13,4 @@ scipy>=1.12.0
 soundfile>=0.12.1
 matplotlib>=3.7.0 
 pronouncing>=0.2.0
+nltk>=3.8.1