Update rhythma.py

rhythma.py

@@ -1,291 +1,411 @@
-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 # pandas wasn't used, commented out
 from PIL import Image
+import io
+from sklearn.metrics.pairwise import cosine_similarity
 import soundfile as sf
-import tempfile
-import time
-from rhythma import RhythmaModulationEngine, RhythmaSymphAICore # Assuming rhythma.py is in the same directory
-
-# --- 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 ---
+import os
+import traceback # For better error logging
+
+# --- Optional Dependency Handling ---
+try:
+    from groq import Groq
+    GROQ_AVAILABLE = True
+except ImportError:
+    GROQ_AVAILABLE = False
+    print("⚠️ Groq package not installed. LLM analysis and transcription disabled.")
+
 try:
-    # 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
-        )
-
-        # --- 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
-                )
-
-        # 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)
+    from sentence_transformers import SentenceTransformer
+    SENTENCE_TRANSFORMER_AVAILABLE = True
+except ImportError:
+    SENTENCE_TRANSFORMER_AVAILABLE = False
+    print("⚠️ SentenceTransformer not installed. Falling back to simple text matching for analysis.")
+# --- End Optional Dependency Handling ---
+
+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. Overridden by emotional_state if provided.
+            modulation_type (str): Type of modulation (sine, pulse, chirp). Defaults to "sine".
+            rhythm_pattern (str, optional): Pattern type (calm, active, focused, relaxed). Defaults to "calm".
+            emotional_state (str, optional): Emotional state (anxious, stressed, calm, etc.). Maps to specific frequencies.
+        """
+        self.modulation_type = modulation_type
+        self.sample_rate = 44100  # Standard audio sample rate
+
+        # Define frequency mappings for emotional states (Example frequencies)
+        self.emotional_frequencies = {
+            "anxious": 396,
+            "stressed": 528,
+            "calm": 741,
+            "sad": 417,
+            "angry": 852,
+            "fearful": 639,
+            "confused": 285,
+            "happy": 432,
+            "neutral": 440, # Added neutral state
+            "focused": 639, # Example mapping for focus intention
+            "relaxed": 741, # Example mapping for relax intention
+            "active": 528,  # Example mapping for active intention
+        }
+
+        # Detailed information about emotional states/frequencies
+        self.emotional_info = {
+            "anxious": {"name": "Liberating Guilt and Fear", "advice": "The 396 Hz frequency may help release fear and guilt."},
+            "stressed": {"name": "Transformation and Miracles", "advice": "The 528 Hz frequency is associated with transformation."},
+            "calm": {"name": "Awakening Intuition", "advice": "The 741 Hz frequency is associated with awakening intuition."},
+            "sad": {"name": "Facilitating Change", "advice": "The 417 Hz frequency is linked to facilitating change."},
+            "angry": {"name": "Returning to Spiritual Order", "advice": "The 852 Hz frequency may aid in returning to inner strength."},
+            "fearful": {"name": "Connecting Relationships", "advice": "The 639 Hz frequency is associated with connecting relationships."},
+            "confused": {"name": "Quantum Cognition", "advice": "The 285 Hz frequency is believed to influence energy fields."},
+            "happy": {"name": "Harmonizing Vibrations", "advice": "The 432 Hz frequency is associated with natural harmony."},
+            "neutral": {"name": "Grounded Presence", "advice": "The 440 Hz frequency provides a stable reference point."},
+            "focused": {"name": "Clarity and Connection", "advice": "The 639 Hz frequency may support focus and understanding."},
+             "relaxed": {"name": "Intuitive Calm", "advice": "The 741 Hz frequency is linked to intuitive states and problem-solving."},
+             "active": {"name": "Dynamic Energy", "advice": "The 528 Hz frequency is associated with positive transformation."},
+        }
+
+        # 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"
+        }
+
+        # Determine emotional state and base frequency
+        valid_emotional_state = emotional_state if emotional_state and emotional_state in self.emotional_frequencies else None
+        self.emotional_state = valid_emotional_state
+
+        if self.emotional_state:
+            self.base_freq = self.emotional_frequencies[self.emotional_state]
+        elif base_freq and base_freq > 0: # Check if base_freq override is valid
+             self.base_freq = base_freq
+             # Try to find a state close to the frequency for info purposes
+             min_diff = float('inf')
+             closest_state = None
+             for state, freq in self.emotional_frequencies.items():
+                 diff = abs(freq - base_freq)
+                 if diff < min_diff:
+                     min_diff = diff
+                     closest_state = state
+             # Only assign if reasonably close (e.g., within 10 Hz)
+             if min_diff <= 10:
+                 self.emotional_state = closest_state # Use for info display only
+             else:
+                 self.emotional_state = None # No specific emotional state tied
+        else:
+            self.emotional_state = "neutral" # Default state if no emotion/freq provided
+            self.base_freq = self.emotional_frequencies[self.emotional_state]
+
+
+        # Set rhythm pattern
+        valid_rhythm_pattern = rhythm_pattern if rhythm_pattern and rhythm_pattern in self.rhythm_configs else None
+        self.rhythm_pattern = valid_rhythm_pattern or "calm"  # Default to calm if not provided or invalid
+
+        # Get current rhythm config
+        self.config = self.rhythm_configs.get(self.rhythm_pattern, self.rhythm_configs["calm"])
+
+    def _generate_base_wave(self, duration):
+        """Generate the base carrier wave"""
+        t = np.linspace(0, duration, int(self.sample_rate * duration), endpoint=False)
+        # Initial simple sine wave
+        base_wave = np.sin(2 * np.pi * self.base_freq * t)
+
+        # Apply harmonics for richer base sound *before* modulation
+        harmonics = self.config["harmonics"]
+        rich_wave = np.zeros_like(base_wave)
+        for i, harmonic_amp in enumerate(harmonics):
+            harmonic_freq = self.base_freq * (i + 1)
+            # Ensure harmonic frequency does not exceed Nyquist limit
+            if harmonic_freq < self.sample_rate / 2:
+                rich_wave += harmonic_amp * np.sin(2 * np.pi * harmonic_freq * t)
+
+        # Normalize the rich base wave before modulation
+        if np.max(np.abs(rich_wave)) > 0:
+           rich_wave = rich_wave / np.max(np.abs(rich_wave))
+        else:
+            rich_wave = base_wave # Fallback if harmonics resulted in zero
+
+        return t, rich_wave
+
+
+    def _apply_sine_modulation(self, t, carrier):
+        """Apply sine wave amplitude modulation"""
+        mod_freq = self.config["mod_freq"]
+        mod_depth = self.config["mod_depth"]
+        mod_env = 1.0 + mod_depth * np.sin(2 * np.pi * mod_freq * t + self.config["phase_shift"])
+        return carrier * mod_env
+
+    def _apply_pulse_modulation(self, t, carrier):
+        """Apply pulse wave amplitude modulation"""
+        mod_freq = self.config["mod_freq"]
+        mod_depth = self.config["mod_depth"]
+        pulse_width = self.config["pulse_width"]
+        pulse = 0.5 * (signal.square(2 * np.pi * mod_freq * t, duty=pulse_width) + 1) # 0 to 1
+        mod_env = 1.0 - mod_depth + mod_depth * pulse # Modulates between (1-depth) and 1
+        return carrier * mod_env
+
+    def _apply_chirp_modulation(self, t, carrier):
+        """Apply frequency chirp modulation (applied differently)"""
+        # Chirp modulation modifies frequency directly, not amplitude envelope
+        # This implementation is more complex and might replace the base wave generation
+        # For simplicity, let's keep amplitude modulation for 'chirp' but with a varying mod freq
+
+        # Simple approach: vary the *modulation frequency* over time (like a siren)
+        start_mod_freq = max(0.1, self.config["mod_freq"] / 2) # Avoid 0 Hz
+        end_mod_freq = self.config["mod_freq"] * 2
+        instantaneous_mod_freq = np.linspace(start_mod_freq, end_mod_freq, len(t))
+
+        mod_depth = self.config["mod_depth"]
+        # Integrate frequency to get phase: 2 * pi * integral(f(t) dt)
+        phase = 2 * np.pi * np.cumsum(instantaneous_mod_freq) / self.sample_rate
+        mod_env = 1.0 + mod_depth * np.sin(phase + self.config["phase_shift"])
+        return carrier * mod_env
+
+    def generate_modulated_wave(self, duration):
+        """
+        Generate modulated audio wave based on current settings.
+        Applies harmonics to the base wave first, then applies modulation.
+        """
+        t, base_carrier = self._generate_base_wave(duration) # Base carrier now includes harmonics
+
+        # Apply the selected amplitude modulation type
+        if self.modulation_type == "sine":
+            modulated = self._apply_sine_modulation(t, base_carrier)
+        elif self.modulation_type == "pulse":
+            modulated = self._apply_pulse_modulation(t, base_carrier)
+        elif self.modulation_type == "chirp":
+             # Using the amplitude modulation with varying frequency approach
+            modulated = self._apply_chirp_modulation(t, base_carrier)
+        else:
+            modulated = base_carrier  # Default to unmodulated rich carrier
+
+        # Final normalization to prevent clipping
+        max_amp = np.max(np.abs(modulated))
+        if max_amp > 0:
+            normalized = 0.9 * modulated / max_amp # Use 0.9 to leave headroom
+        else:
+            normalized = modulated # Avoid division by zero if signal is silent
+
+        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"
+        try:
+            sf.write(file_path, audio, self.sample_rate)
+            print(f"Audio saved to: {file_path}")
+            return file_path
+        except Exception as e:
+            print(f"Error saving audio file: {e}")
+            traceback.print_exc()
+            return None # Return None if saving fails
+
+
+    def visualize_waveform(self, duration):
+        """Generate visualization of the modulated waveform"""
+        # Generate a shorter segment for visualization consistency
+        vis_duration = min(duration, 0.5) # Shorter duration for clearer plot
+        plot_samples = int(self.sample_rate * vis_duration)
+
+        t = np.linspace(0, vis_duration, plot_samples, endpoint=False)
+        modulated = self.generate_modulated_wave(vis_duration) # Generate specific duration
+
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 6), gridspec_kw={'height_ratios': [1, 1]})
+
+        # Plot time domain (zoom in on a small section for detail)
+        zoom_samples = min(plot_samples, 2000) # Show max ~45ms
+        ax1.plot(t[:zoom_samples], modulated[:zoom_samples])
+        title = f'Rhythma Waveform: {self.rhythm_pattern.capitalize()} ({self.modulation_type.capitalize()})'
+        if self.emotional_state:
+            title += f' - {self.emotional_state.capitalize()} ({self.base_freq} Hz)'
+        else:
+             title += f' - {self.base_freq} Hz'
+        ax1.set_title(title)
+        ax1.set_xlabel('Time (s)')
+        ax1.set_ylabel('Amplitude')
+        ax1.grid(True)
+
+        # Plot frequency domain (spectrogram)
+        try:
+             # Use the full generated segment for spectrogram if possible
+             full_wave = self.generate_modulated_wave(duration)
+             f, t_spec, Sxx = signal.spectrogram(full_wave, self.sample_rate, nperseg=1024)
+             # Limit frequency display range for clarity (e.g., up to 2kHz)
+             freq_limit_idx = np.where(f >= 2000)[0]
+             if len(freq_limit_idx) > 0:
+                 f = f[:freq_limit_idx[0]]
+                 Sxx = Sxx[:freq_limit_idx[0], :]
+             else: # Handle cases where max freq is below limit
+                  pass
+             # Use logarithmic scale for power if needed
+             pcm = ax2.pcolormesh(t_spec, f, 10 * np.log10(Sxx + 1e-9), shading='gouraud', cmap='viridis') # Log scale power
+             fig.colorbar(pcm, ax=ax2, label='Power (dB)') # Add colorbar
+             ax2.set_ylabel('Frequency (Hz)')
+             ax2.set_xlabel('Time (s)')
+             ax2.set_title('Spectrogram')
+
+        except Exception as e:
+            print(f"Error generating spectrogram: {e}")
+            ax2.set_title('Spectrogram (Error)')
+            ax2.text(0.5, 0.5, 'Could not generate spectrogram', horizontalalignment='center', verticalalignment='center', transform=ax2.transAxes)
+
+
+        plt.tight_layout(rect=[0, 0.05, 1, 1]) # Adjust layout to prevent overlap, leave space at bottom
+
+        # Add symbolic interpretation below plots
+        fig_text = self.get_symbolic_interpretation()
+        emotion_info = self.emotional_info.get(self.emotional_state, {})
+        if emotion_info:
+             fig_text += f"\n{self.base_freq} Hz - {emotion_info.get('name', '')}: {emotion_info.get('advice', '')}"
+        elif not self.emotional_state: # Case where only base_freq was set
+             fig_text += f"\nBase Frequency: {self.base_freq} Hz"
+
+
+        fig.text(0.5, 0.01, fig_text, ha='center', va='bottom', fontsize=9, style='italic', wrap=True)
+
+        return fig
+
+
+    def get_waveform_image(self):
+        """Generate a simple waveform image as a PIL Image"""
+        # Generate a short, clear representation of the *base* frequency wave
+        duration = 0.05  # Very short duration for visualization
+        t = np.linspace(0, duration, int(self.sample_rate * duration), False)
+        # Use the base frequency determined in __init__
+        tone = np.sin(2 * np.pi * self.base_freq * t)
+
+        plt.figure(figsize=(6, 2)) # Smaller figure for simple image
+        plt.plot(t, tone)
+        # plt.title(f"Base Tone: {self.base_freq} Hz") # Title might clutter small image
+        plt.xlabel("Time (s)")
+        plt.ylabel("Amplitude")
+        plt.ylim(-1.1, 1.1)
+        plt.grid(True)
+        plt.tight_layout()
+
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png', bbox_inches='tight')
+        buf.seek(0)
+        plt.close() # Close the plot to free memory
+
+        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, "Pattern Interpretation: Default")
+
+    def get_emotional_advice(self):
+        """Get advice based on emotional state if available"""
+        if not self.emotional_state:
+            return "No specific emotional state identified."
+
+        emotion_info = self.emotional_info.get(self.emotional_state, {})
+        return emotion_info.get('advice', "General well-being advice applies.")
+
+
+    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, {})
+            analysis.append(f"Detected State/Intention: {self.emotional_state.capitalize()}")
+            analysis.append(f"Resonant Frequency: {self.base_freq} Hz - {emotion_info.get('name', 'Frequency Information')}")
+            analysis.append(f"Guidance: {emotion_info.get('advice', 'Focus on the sound.')}")
+        else:
+             # This case happens if only override_freq was used and it didn't map closely to a state
+            analysis.append(f"Using Manual Frequency: {self.base_freq} Hz")
+            analysis.append("Guidance: Tune into the custom frequency.")
+
+        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 - Interprets input to determine emotional state and rhythm pattern.
+    Handles text and audio input, utilizing Groq LLM and Sentence Transformers if available.
+    """
+
+    def __init__(self, use_groq=True):
+        """Initialize the SymphAI Core"""
+        # Expanded emotional states / intentions
+        self.emotional_states = [
+            "anxious", "stressed", "calm", "sad",
+            "angry", "fearful", "confused", "happy",
+            "neutral", "focused", "relaxed", "active", # Added intentions
+        ]
+
+        # Default rhythm patterns
+        self.rhythm_patterns = list(RhythmaModulationEngine().rhythm_configs.keys()) # Get from engine
+
+        # Initialize Groq client if available and requested
+        self.groq_client = None
+        self.use_groq = use_groq and GROQ_AVAILABLE
+        if self.use_groq:
+            api_key = os.environ.get("GROQ_API_KEY")
+            if api_key:
+                try:
+                    self.groq_client = Groq(api_key=api_key)
+                    print("✅ Groq client initialized successfully.")
+                except Exception as e:
+                    print(f"⚠️ Failed to initialize Groq client: {str(e)}")
+                    self.use_groq = False # Disable Groq if init fails
+            else:
+                print("⚠️ GROQ_API_KEY environment variable not found. Groq features disabled.")
+                self.use_groq = False
+
+        # Initialize sentence transformer for semantic matching if available
+        self.embedding_model = None
+        self.emotional_embeddings = {}
+        self.rhythm_embeddings = {}
+        if SENTENCE_TRANSFORMER_AVAILABLE:
+            try:
+                # Using a common, effective model
+                self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+                # Pre-compute embeddings for faster lookup
+                self.emotional_embeddings = {
+                    state: self.embedding_model.encode([state])[0] # Get the 1D array
+                    for state in self.emotional_states
+                }
+                self.rhythm_embeddings = {
+                    pattern: self.embedding_model.encode([pattern])[0] # Get the 1D array
+                    for pattern in self.rhythm_patterns
+                }
+                print("✅ SentenceTransformer initialized successfully.")
+            except Exception as e:
+                print(f"⚠️ Failed to initialize SentenceTransformer: {str(e)}. Using basic text matching.")
+                self.embedding_model = None # Ensure it's None if init fails
+        else:
+             print("ℹ️ SentenceTransformer not installed. Using basic text matching.")
+
+
+    def detect_emotion_with_groq(self, input_text):
+