Update rhythma.py

rhythma.py

@@ -1,508 +1,291 @@
+import os
+import gradio as gr
 import numpy as np
+import matplotlib
+matplotlib.use('Agg') # Set backend BEFORE importing pyplot
 import matplotlib.pyplot as plt
-from scipy import signal
-import pandas as pd
 from PIL import Image
-import io
-from sklearn.metrics.pairwise import cosine_similarity
 import soundfile as sf
-import os
+import tempfile
+import time
+from rhythma import RhythmaModulationEngine, RhythmaSymphAICore # Assuming rhythma.py is in the same directory
 
-# Try to import optional dependencies
-try:
-    from groq import Groq
-    GROQ_AVAILABLE = True
-except ImportError:
-    GROQ_AVAILABLE = False
-    print("Groq package not installed. Falling back to local analysis.")
+# --- Environment Variable Check ---
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+use_groq = bool(GROQ_API_KEY) # True only if key exists and is not empty
 
+if not use_groq:
+    print("*"*40)
+    print("⚠️ WARNING: GROQ_API_KEY not found or empty in environment variables.")
+    print("   Groq LLM analysis and audio transcription features will be disabled.")
+    print("   Falling back to local analysis methods.")
+    print("*"*40)
+else:
+    print("✅ GROQ_API_KEY found. Enabling Groq features.")
+# --- End Environment Variable Check ---
+
+
+# --- Initialize Core Components ---
 try:
-    from sentence_transformers import SentenceTransformer
-    SENTENCE_TRANSFORMER_AVAILABLE = True
-except ImportError:
-    SENTENCE_TRANSFORMER_AVAILABLE = False
-    print("SentenceTransformer not installed. Simple text matching will be used.")
-
-class RhythmaModulationEngine:
-    """
-    Rhythma: The Living Modulation Engine
-    A dynamic rhythm-based audio modulation system that creates responsive
-    sound experiences based on rhythm patterns and emotional states.
-    """
-    
-    def __init__(self, base_freq=None, modulation_type="sine", rhythm_pattern=None, emotional_state=None):
-        """
-        Initialize the RhythmaModulationEngine.
-        
-        Args:
-            base_freq (float, optional): The base frequency in Hz
-            modulation_type (str): Type of modulation (sine, pulse, chirp)
-            rhythm_pattern (str, optional): Pattern type (calm, active, focused, relaxed)
-            emotional_state (str, optional): Emotional state (anxious, stressed, calm, etc.)
-        """
-        self.modulation_type = modulation_type
-        self.sample_rate = 44100  # Standard audio sample rate
-        
-        # Define frequency mappings for emotional states
-        self.emotional_frequencies = {
-            "anxious": 396,
-            "stressed": 528,
-            "calm": 741,
-            "sad": 417,
-            "angry": 852,
-            "fearful": 639,
-            "confused": 285,
-            "happy": 432
-        }
-        
-        # Detailed information about emotional states
-        self.emotional_info = {
-            "anxious": {
-                "name": "Liberating Guilt and Fear",
-                "advice": "The 396 Hz frequency is associated with releasing fear and guilt."
-            },
-            "stressed": {
-                "name": "Transformation and Miracles",
-                "advice": "The 528 Hz frequency is known as the 'miracle tone' for transformation and DNA repair."
-            },
-            "calm": {
-                "name": "Awakening Intuition",
-                "advice": "The 741 Hz frequency is associated with awakening intuition and solving problems."
-            },
-            "sad": {
-                "name": "Facilitating Change",
-                "advice": "The 417 Hz frequency is believed to facilitate change and let go of negative energy."
-            },
-            "angry": {
-                "name": "Returning to Spiritual Order",
-                "advice": "The 852 Hz frequency is associated with returning to spiritual order and inner strength."
-            },
-            "fearful": {
-                "name": "Connecting Relationships",
-                "advice": "The 639 Hz frequency is linked to connecting relationships and understanding."
-            },
-            "confused": {
-                "name": "Quantum Cognition",
-                "advice": "The 285 Hz frequency is believed to influence energy fields and aid in healing."
-            },
-            "happy": {
-                "name": "Harmonizing Vibrations",
-                "advice": "The 432 Hz frequency is associated with harmonizing vibrations and promoting wellbeing."
-            }
-        }
-        
-        # Configure rhythm patterns
-        self.rhythm_configs = {
-            "calm": {
-                "mod_depth": 0.15,
-                "mod_freq": 0.5,
-                "pulse_width": 0.7,
-                "phase_shift": 0.1,
-                "harmonics": [1.0, 0.5, 0.25, 0.125]
-            },
-            "active": {
-                "mod_depth": 0.4,
-                "mod_freq": 2.5,
-                "pulse_width": 0.3,
-                "phase_shift": 0.3,
-                "harmonics": [1.0, 0.7, 0.5, 0.3]
-            },
-            "focused": {
-                "mod_depth": 0.25,
-                "mod_freq": 1.5,
-                "pulse_width": 0.5,
-                "phase_shift": 0.2,
-                "harmonics": [1.0, 0.6, 0.3, 0.15]
-            },
-            "relaxed": {
-                "mod_depth": 0.2,
-                "mod_freq": 0.3,
-                "pulse_width": 0.8,
-                "phase_shift": 0.05,
-                "harmonics": [1.0, 0.4, 0.2, 0.1]
-            }
-        }
-        
-        # Symbolic mapping for rhythm patterns
-        self.symbolic_mapping = {
-            "calm": "Resonating in the Circle Archetype: completion, wholeness, presence",
-            "active": "Resonating in the Spiral Archetype: flow, transition, emergence",
-            "focused": "Resonating in the Triangle Archetype: clarity, direction, purpose",
-            "relaxed": "Resonating in the Wave Archetype: fluidity, acceptance, surrender"
-        }
-        
-        # Set the base frequency based on emotional state if provided, otherwise use base_freq
-        if emotional_state and emotional_state in self.emotional_frequencies:
-            self.emotional_state = emotional_state
-            self.base_freq = self.emotional_frequencies[emotional_state]
-        else:
-            self.emotional_state = None
-            self.base_freq = base_freq or 440  # Default to A4 if no frequency or emotion provided
-            
-        # Set rhythm pattern 
-        self.rhythm_pattern = rhythm_pattern or "calm"  # Default to calm if not provided
-        
-        # Get current rhythm config
-        self.config = self.rhythm_configs.get(
-            self.rhythm_pattern, 
-            self.rhythm_configs["calm"]  # Default to calm if pattern not found
+    # Pass the determined use_groq flag to the core
+    symphai_core = RhythmaSymphAICore(use_groq=use_groq)
+except Exception as e:
+     print(f"❌ FATAL ERROR: Could not initialize RhythmaSymphAICore: {e}")
+     # Handle fatal error appropriately - maybe exit or disable functionality
+     symphai_core = None # Indicate failure
+# --- End Initialization ---
+
+
+# --- Core Functions ---
+def analyze_input(input_text=None, audio_input=None):
+    """Analyze user input using the SymphAI Core."""
+    if symphai_core is None:
+        return {"error": "Analysis Core failed to initialize."}
+
+    # Ensure audio_input is a filepath string or None
+    audio_filepath = audio_input if isinstance(audio_input, str) else None
+
+    # Pass to SymphAI Core for analysis
+    # Add default empty string for input_text if None, as core expects string or None
+    return symphai_core.analyze_input(input_text or "", audio_filepath)
+
+
+def generate_modulated_experience(analysis_result, base_freq=None, modulation_type="sine", rhythm_pattern=None, duration=5):
+    """Generate a complete modulated experience based on analysis and parameters."""
+    print(f"DEBUG: generate_modulated_experience received analysis: {analysis_result}")
+    print(f"DEBUG: Overrides - Freq: {base_freq}, Mod: {modulation_type}, Rhythm: {rhythm_pattern}, Dur: {duration}")
+
+    # --- Input Validation ---
+    if not isinstance(analysis_result, dict):
+        error_msg = "Internal Error: Analysis result is not in the expected format."
+        print(f"❌ {error_msg}")
+        return error_msg, None, None, None, None
+
+    if "error" in analysis_result and analysis_result["error"]:
+        error_msg = f"Analysis Error: {analysis_result['error']}"
+        print(f"❌ {error_msg}")
+        # Return the error message clearly for the analysis output
+        return error_msg, None, None, None, None
+
+    # Ensure required keys exist, even if defaults were used in analysis
+    emotional_state = analysis_result.get("emotional_state", "neutral") # Default if missing
+    rhythm_pattern_from_analysis = analysis_result.get("rhythm_pattern", "calm") # Default if missing
+
+    # --- Determine Final Parameters ---
+    # Use manual override if provided and valid, otherwise use analysis result
+    final_rhythm_pattern = rhythm_pattern if rhythm_pattern else rhythm_pattern_from_analysis
+    # Use manual frequency override ONLY if it's > 0
+    final_base_freq = base_freq if base_freq and base_freq > 0 else None # Pass None to let engine use emotion/default
+
+    print(f"DEBUG: Engine Params - Emotion: {emotional_state}, Freq Override: {final_base_freq}, Rhythm: {final_rhythm_pattern}, Mod: {modulation_type}")
+
+    try:
+        # --- Initialize the Rhythma Engine ---
+        engine = RhythmaModulationEngine(
+            base_freq=final_base_freq,  # Engine handles None: uses emotional_state or default
+            modulation_type=modulation_type,
+            rhythm_pattern=final_rhythm_pattern,
+            emotional_state=emotional_state if not final_base_freq else None # Pass emotion only if freq isn't overridden
         )
 
-    def _generate_base_wave(self, duration):
-        """Generate the base carrier wave"""
-        t = np.linspace(0, duration, int(self.sample_rate * duration), endpoint=False)
-        return t, np.sin(2 * np.pi * self.base_freq * t)
-    
-    def _apply_sine_modulation(self, t, carrier):
-        """Apply sine wave modulation"""
-        mod_freq = self.config["mod_freq"]
-        mod_depth = self.config["mod_depth"]
-        
-        # Create modulation envelope
-        mod_env = 1.0 + mod_depth * np.sin(2 * np.pi * mod_freq * t + self.config["phase_shift"])
-        
-        # Apply modulation
-        return carrier * mod_env
-    
-    def _apply_pulse_modulation(self, t, carrier):
-        """Apply pulse modulation"""
-        mod_freq = self.config["mod_freq"]
-        mod_depth = self.config["mod_depth"]
-        pulse_width = self.config["pulse_width"]
-        
-        # Create pulse modulation envelope
-        pulse = signal.square(2 * np.pi * mod_freq * t, duty=pulse_width)
-        mod_env = 1.0 + mod_depth * pulse
-        
-        # Apply modulation
-        return carrier * mod_env
-    
-    def _apply_chirp_modulation(self, t, carrier):
-        """Apply frequency chirp modulation"""
-        mod_depth = self.config["mod_depth"]
-        
-        # Create chirp modulation with frequency that increases with time
-        start_freq = self.base_freq * (1 - mod_depth/2)
-        end_freq = self.base_freq * (1 + mod_depth/2)
-        
-        # Linear chirp
-        chirp = signal.chirp(t, start_freq, t[-1], end_freq)
-        
-        # Apply modulation
-        return chirp * carrier
-
-    def _apply_harmonics(self, t, wave):
-        """Apply harmonic overtones to enrich the sound"""
-        harmonics = self.config["harmonics"]
-        rich_wave = np.zeros_like(wave)
-        
-        for i, harmonic_amp in enumerate(harmonics):
-            harmonic_freq = self.base_freq * (i + 1)
-            rich_wave += harmonic_amp * np.sin(2 * np.pi * harmonic_freq * t)
-        
-        # Normalize
-        rich_wave = rich_wave / np.max(np.abs(rich_wave))
-        return rich_wave
-    
-    def generate_modulated_wave(self, duration):
-        """
-        Generate modulated audio wave based on current settings
-        
-        Args:
-            duration (float): Duration of audio in seconds
-            
-        Returns:
-            numpy.ndarray: The modulated audio waveform
-        """
-        t, carrier = self._generate_base_wave(duration)
-        
-        # Apply the selected modulation type
-        if self.modulation_type == "sine":
-            modulated = self._apply_sine_modulation(t, carrier)
-        elif self.modulation_type == "pulse":
-            modulated = self._apply_pulse_modulation(t, carrier)
-        elif self.modulation_type == "chirp":
-            modulated = self._apply_chirp_modulation(t, carrier)
-        else:
-            modulated = carrier  # Default to unmodulated carrier
-        
-        # Apply harmonics for richer sound
-        enriched = self._apply_harmonics(t, modulated)
-        
-        # Normalize to prevent clipping
-        normalized = 0.8 * enriched / np.max(np.abs(enriched))
-        
-        return normalized
-    
-    def save_audio(self, duration, file_path=None):
-        """Generate and save audio to a file"""
-        audio = self.generate_modulated_wave(duration)
-        file_path = file_path or f"rhythma_{self.base_freq}Hz_{self.rhythm_pattern}.wav"
-        sf.write(file_path, audio, self.sample_rate)
-        return file_path
-        
-    def visualize_waveform(self, duration):
-        """
-        Generate visualization of the modulated waveform
-        
-        Args:
-            duration (float): Duration of audio in seconds
-            
-        Returns:
-            matplotlib.figure.Figure: Figure containing the waveform visualization
-        """
-        # Generate a shorter segment for visualization
-        t = np.linspace(0, min(duration, 2), int(self.sample_rate * min(duration, 2)), endpoint=False)
-        
-        # Generate modulated wave for plotting
-        modulated = self.generate_modulated_wave(min(duration, 2))
-        
-        # Create visualization
-        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
-        
-        # Plot time domain
-        ax1.plot(t[:1000], modulated[:1000])
-        title = f'Rhythma Modulated Waveform: {self.rhythm_pattern} ({self.modulation_type})'
-        if self.emotional_state:
-            title += f' - {self.emotional_state.capitalize()} state'
-        ax1.set_title(title)
-        ax1.set_xlabel('Time (s)')
-        ax1.set_ylabel('Amplitude')
-        
-        # Plot frequency domain (spectrogram)
-        f, t, Sxx = signal.spectrogram(modulated, self.sample_rate)
-        ax2.pcolormesh(t, f[:500], Sxx[:500], shading='gouraud')
-        ax2.set_ylabel('Frequency (Hz)')
-        ax2.set_xlabel('Time (s)')
-        ax2.set_title(f'Spectrogram - Base Frequency: {self.base_freq} Hz')
-        
-        plt.tight_layout()
-        
-        # Add symbolic interpretation
-        fig_text = self.get_symbolic_interpretation()
-        if self.emotional_state:
-            emotion_info = self.emotional_info.get(self.emotional_state, {})
-            if emotion_info:
-                fig_text += f"\n{self.base_freq} Hz - {emotion_info.get('name', '')}"
-        
-        fig.text(0.5, 0.01, fig_text, ha='center', fontsize=10, style='italic')
-        
-        return fig
-    
-    def get_waveform_image(self):
-        """Generate waveform as a PIL Image"""
-        duration = 0.1  # Short duration for visualization
-        t = np.linspace(0, duration, int(self.sample_rate * duration), False)
-        tone = np.sin(2 * np.pi * self.base_freq * t)
-        
-        plt.figure(figsize=(10, 4))
-        plt.plot(t, tone)
-        plt.title(f"Waveform of {self.base_freq} Hz Tone")
-        plt.xlabel("Time (s)")
-        plt.ylabel("Amplitude")
-        plt.ylim(-1.1, 1.1)
-        plt.grid(True)
-        
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png')
-        buf.seek(0)
-        plt.close()
-        
-        return Image.open(buf)
-        
-    def get_symbolic_interpretation(self):
-        """Return the symbolic interpretation of the current rhythm pattern"""
-        return self.symbolic_mapping.get(self.rhythm_pattern, "Unknown pattern")
-
-    def get_emotional_advice(self):
-        """Get advice based on emotional state if available"""
-        if not self.emotional_state:
-            return ""
-            
-        emotion_info = self.emotional_info.get(self.emotional_state, {})
-        if not emotion_info:
-            return ""
-            
-        return f"{emotion_info.get('advice', '')}"
-        
-    def get_complete_analysis(self):
-        """Get a complete analysis including emotional and rhythmic information"""
-        analysis = []
-        
-        if self.emotional_state:
-            emotion_info = self.emotional_info.get(self.emotional_state, {})
-            if emotion_info:
-                analysis.append(f"Emotional State: {self.emotional_state.capitalize()}")
-                analysis.append(f"Resonant Frequency: {self.base_freq} Hz - {emotion_info.get('name', '')}")
-                analysis.append(f"Emotional Advice: {emotion_info.get('advice', '')}")
-        else:
-            analysis.append(f"Base Frequency: {self.base_freq} Hz")
-            
-        analysis.append(f"Rhythm Pattern: {self.rhythm_pattern.capitalize()}")
-        analysis.append(f"Symbolic Interpretation: {self.get_symbolic_interpretation()}")
-        analysis.append(f"Modulation Type: {self.modulation_type.capitalize()}")
-        
-        return "\n\n".join(analysis)
-
-
-class RhythmaSymphAICore:
-    """
-    SymphAI Core - The intelligent symbolic engine that interprets rhythm and state
-    """
-    
-    def __init__(self, use_groq=True):
-        """Initialize the SymphAI Core"""
-        # Default emotional states that can be detected
-        self.emotional_states = [
-            "anxious", "stressed", "calm", "sad", 
-            "angry", "fearful", "confused", "happy"
-        ]
-        
-        # Default rhythm patterns
-        self.rhythm_patterns = [
-            "calm", "active", "focused", "relaxed"
-        ]
-        
-        # Initialize Groq client if available and requested
-        self.use_groq = use_groq and GROQ_AVAILABLE
-        if self.use_groq:
-            try:
-                self.groq_client = Groq(
-                    api_key=os.environ.get("GROQ_API_KEY"),
+        # --- Generate Outputs ---
+        timestamp = int(time.time())
+        temp_dir = tempfile.gettempdir()
+        # Ensure temp_dir exists (useful in some restricted environments)
+        os.makedirs(temp_dir, exist_ok=True)
+        audio_file = os.path.join(temp_dir, f"rhythma_{timestamp}.wav")
+
+        # Generate and save audio
+        saved_audio_path = engine.save_audio(duration, audio_file)
+        if not saved_audio_path: # Check if saving failed
+             raise RuntimeError("Failed to save generated audio file.")
+
+        # Generate waveform visualization (Plot)
+        fig = engine.visualize_waveform(duration)
+
+        # Get simple waveform image (PIL Image)
+        waveform_image = engine.get_waveform_image()
+
+        # Get complete analysis text from the engine's perspective
+        analysis_text = engine.get_complete_analysis()
+
+        # Get symbolic interpretation
+        symbolic = engine.get_symbolic_interpretation()
+
+        print("✅ Modulation experience generated successfully.")
+        return analysis_text, saved_audio_path, fig, waveform_image, symbolic
+
+    except Exception as e:
+        error_msg = f"Error during Rhythma generation: {e}"
+        print(f"❌ {error_msg}")
+        import traceback
+        traceback.print_exc()
+        # Return error message for analysis, and None for other outputs
+        return error_msg, None, None, None, None
+
+
+def rhythma_experience(
+    input_text, audio_input,
+    override_freq=None,
+    override_modulation="sine",
+    override_rhythm=None,
+    duration=5
+):
+    """Complete Rhythma experience pipeline: Analysis -> Generation"""
+    print("\n--- Starting New Rhythma Experience ---")
+    # Clean up input text
+    input_text = input_text.strip() if input_text else ""
+
+    # --- Step 1: Analyze input ---
+    # Ensure override_freq is float or None
+    try:
+         freq_override_value = float(override_freq) if override_freq is not None else 0.0
+    except (ValueError, TypeError):
+         freq_override_value = 0.0 # Default to 0 if invalid input
+
+    analysis = analyze_input(input_text, audio_input)
+
+    # --- Step 2: Generate modulated experience ---
+    # Pass analysis results and overrides to the generation function
+    analysis_text, audio_file, fig, waveform_image, symbolic = generate_modulated_experience(
+        analysis,
+        base_freq=freq_override_value, # Pass the validated float/int
+        modulation_type=override_modulation,
+        rhythm_pattern=override_rhythm if override_rhythm else None, # Pass None if dropdown default is selected
+        duration=duration
+    )
+
+    # --- Step 3: Prepare Outputs ---
+    # Get transcription from analysis result (will be empty string if no audio/transcription)
+    transcription = analysis.get("transcription", "") if isinstance(analysis, dict) else ""
+    # If analysis itself failed, analysis_text will contain the error message from generate_modulated_experience
+    # If only transcription failed, it might be in the transcription field
+
+    # Handle potential None figure if generation failed
+    plot_output = fig if fig else None # Gradio handles None for Plot output
+
+    print("--- Rhythma Experience Complete ---")
+    # Return all outputs for Gradio interface
+    return analysis_text, audio_file, plot_output, waveform_image, symbolic, transcription
+
+# --- Create the Gradio Interface ---
+def create_interface():
+    with gr.Blocks(theme=gr.themes.Soft(), title="Rhythma: The Living Modulation Engine") as demo:
+        gr.Markdown("# Rhythma: The Living Modulation Engine")
+        gr.Markdown("### Dynamic rhythm-based sound modulation for wellbeing")
+
+        if not use_groq:
+            gr.Warning("Running with limited functionality: GROQ_API_KEY not found. "
+                       "Advanced AI analysis and audio transcription are disabled.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("**1. Describe Your State or Intention**")
+                input_text = gr.Textbox(
+                    label="How are you feeling, or what is your intention?",
+                    placeholder="e.g., 'feeling stressed about work', 'want to relax', 'need focus'...",
+                    lines=3
+                )
+
+                gr.Markdown("**Optional: Use Your Voice (Requires Groq API Key)**")
+                audio_input = gr.Audio(
+                    sources=["microphone"], # Prioritize microphone
+                    type="filepath", # RhythmaSymphAICore expects a filepath
+                    label="Record or Upload Audio" if use_groq else "Audio Input (Disabled)",
+                    interactive=use_groq # Disable if Groq not available
+                )
+
+                with gr.Accordion("Advanced Settings (Optional Overrides)", open=False):
+                    override_freq = gr.Slider(
+                        minimum=0, maximum=1000, value=0, step=1,
+                        label="Override Frequency (Hz)",
+                        info="Leave at 0 to use automatic frequency based on analysis."
+                    )
+                    override_modulation = gr.Dropdown(
+                        choices=["sine", "pulse", "chirp"],
+                        value="sine",
+                        label="Override Modulation Type"
+                    )
+                    # Get available patterns from the engine instance
+                    available_patterns = list(RhythmaModulationEngine().rhythm_configs.keys())
+                    override_rhythm = gr.Dropdown(
+                        choices=[None] + available_patterns, # Add None option for automatic
+                        value=None, # Default to automatic
+                        label="Override Rhythm Pattern",
+                        info="Leave blank to use automatic pattern based on analysis."
+                    )
+                    duration = gr.Slider(
+                        minimum=3, maximum=60, value=10, step=1,
+                        label="Duration (seconds)"
+                    )
+
+                generate_button = gr.Button("Generate Rhythma Experience", variant="primary", scale=2)
+
+            with gr.Column(scale=2):
+                gr.Markdown("**2. Experience Your Rhythma Soundscape**")
+                analysis_output = gr.Textbox(label="Rhythma Analysis & Guidance", lines=8, interactive=False)
+                with gr.Row():
+                    audio_output = gr.Audio(label="Modulated Audio", type="filepath", interactive=False)
+                    waveform_simple = gr.Image(label="Base Waveform", interactive=False, height=100, width=200)
+                waveform_plot = gr.Plot(label="Detailed Waveform & Spectrogram", interactive=False)
+                symbolic_output = gr.Textbox(label="Symbolic Interpretation", interactive=False)
+                # Conditionally visible transcription output
+                transcription_output = gr.Textbox(
+                    label="Transcribed Audio (If Provided)",
+                    interactive=False,
+                    visible=use_groq # Only show if Groq is potentially usable
                 )
-                print("Groq client initialized successfully.")
-            except Exception as e:
-                print(f"Failed to initialize Groq client: {str(e)}")
-                self.use_groq = False
-        
-        # Initialize sentence transformer for semantic matching if available
-        if SENTENCE_TRANSFORMER_AVAILABLE:
-            try:
-                self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
-                self.emotional_embeddings = {
-                    emotion: self.embedding_model.encode([emotion]) 
-                    for emotion in self.emotional_states
-                }
-                self.rhythm_embeddings = {
-                    pattern: self.embedding_model.encode([pattern]) 
-                    for pattern in self.rhythm_patterns
-                }
-                print("SentenceTransformer initialized successfully.")
-            except Exception as e:
-                print(f"Failed to initialize SentenceTransformer: {str(e)}")
-                self.embedding_model = None
-                self.emotional_embeddings = {}
-                self.rhythm_embeddings = {}
-        else:
-            self.embedding_model = None
-            self.emotional_embeddings = {}
-            self.rhythm_embeddings = {}
-
-    def detect_emotion_with_groq(self, input_text):
-        """Use Groq LLM to detect emotion in text"""
-        if not self.use_groq:
-            return None
-            
-        prompt = f"""Analyze the following text and determine the primary emotion expressed. 
-Choose the most appropriate emotion from this list: anxious, stressed, calm, sad, angry, fearful, confused, happy.
-Provide your answer as a single word that best describes the emotional state.
-
-Text: {input_text}
-Emotion:"""
-
-        try:
-            chat_completion = self.groq_client.chat.completions.create(
-                messages=[
-                    {
-                        "role": "user",
-                        "content": prompt,
-                    }
-                ],
-                model="llama-3.3-70b-versatile",
-                max_tokens=10,
-            )
-            
-            detected_emotion = chat_completion.choices[0].message.content.strip().lower()
-            
-            # Validate the detected emotion
-            if detected_emotion in self.emotional_states:
-                return detected_emotion
-            else:
-                # If LLM returns something not in our list, find closest match
-                return self.get_closest_emotional_state(detected_emotion)
-                
-        except Exception as e:
-            print(f"Error using Groq for emotion detection: {str(e)}")
-            return None
-    
-    def get_closest_emotional_state(self, input_text):
-        """Map input text to the closest emotional state"""
-        # First try simple word matching
-        for emotion in self.emotional_states:
-            if emotion in input_text.lower():
-                return emotion
-                
-        # If sentence transformer is available, use semantic similarity
-        if self.embedding_model:
-            input_embedding = self.embedding_model.encode([input_text])
-            similarities = {
-                emotion: cosine_similarity(input_embedding, embedding)[0][0] 
-                for emotion, embedding in self.emotional_embeddings.items()
-            }
-            return max(similarities, key=similarities.get)
-            
-        # Default fallback
-        return "calm"
-        
-    def get_closest_rhythm_pattern(self, input_text=None, emotional_state=None):
-        """Map input text or emotional state to the closest rhythm pattern"""
-        # If emotional state is provided, use direct mapping
-        if emotional_state:
-            # Map emotional states to rhythm patterns
-            mapping = {
-                "anxious": "active",
-                "stressed": "active",
-                "calm": "calm",
-                "sad": "relaxed",
-                "angry": "active",
-                "fearful": "active",
-                "confused": "focused",
-                "happy": "calm"
-            }
-            return mapping.get(emotional_state, "calm")
-            
-        # If input text is provided and sentence transformer is available
-        if input_text and self.embedding_model:
-            input_embedding = self.embedding_model.encode([input_text])
-            similarities = {
-                pattern: cosine_similarity(input_embedding, embedding)[0][0] 
-                for pattern, embedding in self.rhythm_embeddings.items()
-            }
-            return max(similarities, key=similarities.get)
-            
-        # Default fallback
-        return "calm"
-    
-    def transcribe_audio(self, audio_path):
-        """Transcribe audio using Groq if available"""
-        if not self.use_groq:
-            return "Audio transcription requires Groq API. Please enter text instead."
-            
-        try:
-            # Open and read the audio file
-            with open(audio_path, "rb") as audio_file:
-                audio_data = audio_file.read()
-
-            # Transcribe the audio using Distil-Whisper
-            transcription = self.groq_client.audio.transcriptions.create(
-                file=(os.path.basename(audio_path), audio_data),
-                model="distil-whisper-large-v3-en",
-                response_format="verbose_json",
-            )
-            
-            return transcription.text
-        except Exception as e:
-            return f"Error in transcription: {str(e)}"
-        
-    def analyze_input(self, input_text, audio_path=None):
-        """Analyze input text and return appropriate emotional state and rhythm patterns"""
+
+        # Define button action
+        generate_button.click(
+            fn=rhythma_experience,
+            inputs=[
+                input_text, audio_input,
+                override_freq, override_modulation, override_rhythm,
+                duration
+            ],
+            outputs=[
+                analysis_output, audio_output,
+                waveform_plot, waveform_simple, symbolic_output,
+                transcription_output
+            ]
+        )
+
+        # Add Examples
+        gr.Examples(
+            examples=[
+                ["I'm feeling anxious about my upcoming presentation.", None, 0, "sine", None, 10],
+                ["I feel at peace and grounded today.", None, 0, "sine", None, 15],
+                ["I need to focus on my work but keep getting distracted.", None, 0, "sine", None, 20],
+                ["Feeling overwhelmed with responsibilities.", None, 0, "sine", None, 10],
+                ["Excited about my vacation next week!", None, 0, "sine", None, 10],
+                ["Just want to relax after a long day.", None, 0, "sine", "relaxed", 30], # Example with override
+                ["Feeling sad and low energy.", None, 0, "sine", None, 15],
+            ],
+            inputs=[input_text, audio_input, override_freq, override_modulation, override_rhythm, duration],
+            outputs=[analysis_output, audio_output, waveform_plot, waveform_simple, symbolic_output, transcription_output],
+            fn=rhythma_experience, # Ensure examples also run the main function
+            cache_examples=False # Maybe disable caching during development
+        )
+
+        gr.Markdown("---")
+        gr.Markdown("""
+        ## About Rhythma
+        Rhythma creates personalized soundscapes using frequency modulation based on your described emotional state or intention.
+        It leverages AI analysis (enhanced with Groq if available) and principles of rhythmic sound design.
+        **Note:** This is an experimental tool. The frequencies and interpretations are based on various theories and are not medical advice.
+        © 2024 Your Rhythma Project
+        """)
+
+    return demo
+
+# --- Run the Gradio App ---
+if __name__ == "__main__":
+    if symphai_core is None:
+         print("\n❌ Cannot launch Gradio app because RhythmaSymphAICore failed to initialize.\n")
+    else:
+        print("\n🚀 Launching Rhythma Gradio Interface...")
+        app_demo = create_interface()
+        # Set share=True if you need a public link (useful for testing deployment)
+        # Set debug=True for more verbose logs during development
+        app_demo.launch()#debug=True)