Update app.py

app.py

@@ -1,30 +1,101 @@
 import os
-import soundfile as sf
 import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
-from rhythma import RhythmaModulationEngine
+from PIL import Image
+import soundfile as sf
+import tempfile
+import time
+from rhythma import RhythmaModulationEngine, RhythmaSymphAICore
+
+# Initialize the SymphAI Core
+symphai_core = RhythmaSymphAICore()
 
-# Function to apply modulation and visualize waveform
-def generate_modulated_audio(base_freq, modulation_type, rhythm_pattern, duration=5):
-    engine = RhythmaModulationEngine(base_freq, modulation_type, rhythm_pattern)
+def analyze_input(input_text=None, audio_input=None):
+    """Analyze user input for emotional state and rhythm patterns"""
+    if audio_input:
+        # If audio transcription service is available, integrate here
+        transcription = "Audio transcription would go here"
+        input_text = transcription
+        
+    if not input_text or not input_text.strip():
+        return {
+            "error": "Please enter a description of your emotional state or provide an audio input."
+        }
+        
+    # Analyze the input using SymphAI Core
+    analysis = symphai_core.analyze_input(input_text)
     
-    # Generate modulated audio
-    modulated_audio = engine.generate_modulated_wave(duration)
+    return {
+        "input_text": input_text,
+        "emotional_state": analysis["emotional_state"],
+        "rhythm_pattern": analysis["rhythm_pattern"],
+        "transcription": input_text if audio_input else None
+    }
+
+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"""
+    if "error" in analysis_result:
+        return analysis_result["error"], None, None, None, None
+        
+    # Create a unique timestamp for file naming
+    timestamp = int(time.time())
+    
+    # Use emotional state and rhythm pattern from analysis if not manually overridden
+    emotional_state = analysis_result["emotional_state"]
+    rhythm_pattern = rhythm_pattern or analysis_result["rhythm_pattern"]
     
-    # Save and return path for Gradio interface
-    file_path = "modulated_audio.wav"
-    sf.write(file_path, modulated_audio, engine.sample_rate)
+    # Initialize the Rhythma Engine
+    engine = RhythmaModulationEngine(
+        base_freq=base_freq,  # Will be overridden by emotional state if None
+        modulation_type=modulation_type,
+        rhythm_pattern=rhythm_pattern,
+        emotional_state=emotional_state
+    )
+    
+    # Generate modulated audio
+    temp_dir = tempfile.gettempdir()
+    audio_file = os.path.join(temp_dir, f"rhythma_{timestamp}.wav")
+    engine.save_audio(duration, audio_file)
     
-    # Visualize waveform
+    # Generate waveform visualization
     fig = engine.visualize_waveform(duration)
     
+    # Get simple waveform image
+    waveform_image = engine.get_waveform_image()
+    
+    # Get complete analysis text
+    analysis_text = engine.get_complete_analysis()
+    
     # Get symbolic interpretation
     symbolic = engine.get_symbolic_interpretation()
     
-    return file_path, fig, symbolic
+    return analysis_text, audio_file, fig, waveform_image, symbolic
+
+def rhythma_experience(
+    input_text, audio_input, 
+    override_freq=None, 
+    override_modulation="sine", 
+    override_rhythm=None, 
+    duration=5
+):
+    """Complete Rhythma experience pipeline"""
+    # Step 1: Analyze input
+    analysis = analyze_input(input_text, audio_input)
+    
+    # Step 2: Generate modulated experience
+    analysis_text, audio_file, fig, waveform_image, symbolic = generate_modulated_experience(
+        analysis, 
+        base_freq=override_freq, 
+        modulation_type=override_modulation,
+        rhythm_pattern=override_rhythm,
+        duration=duration
+    )
+    
+    # Return all outputs
+    return analysis_text, audio_file, fig, waveform_image, symbolic
 
-# Gradio interface setup
+# Create the Gradio interface
 def create_interface():
     with gr.Blocks(title="Rhythma: The Living Modulation Engine") as demo:
         gr.Markdown("# Rhythma: The Living Modulation Engine")
@@ -32,50 +103,91 @@ def create_interface():
         
         with gr.Row():
             with gr.Column(scale=1):
-                # Controls for frequency, modulation type, and rhythm
-                base_frequency = gr.Slider(minimum=20, maximum=1000, value=440, step=1, label="Base Frequency (Hz)")
-                modulation_type = gr.Dropdown(
-                    choices=["sine", "pulse", "chirp"], 
-                    value="sine",
-                    label="Modulation Type"
+                # Input section
+                input_text = gr.Textbox(
+                    label="How are you feeling?", 
+                    placeholder="Describe your emotional state or intention..."
                 )
-                rhythm_pattern = gr.Dropdown(
-                    choices=["calm", "active", "focused", "relaxed"], 
-                    value="calm",
-                    label="Rhythm Pattern"
+                audio_input = gr.Audio(
+                    type="filepath", 
+                    label="Or speak about your feelings"
                 )
-                duration = gr.Slider(minimum=1, maximum=30, value=5, step=1, label="Duration (seconds)")
+                
+                with gr.Accordion("Advanced Settings", open=False):
+                    override_freq = gr.Slider(
+                        minimum=20, maximum=1000, value=None, 
+                        label="Override Frequency (Hz, leave at 0 for automatic)"
+                    )
+                    override_modulation = gr.Dropdown(
+                        choices=["sine", "pulse", "chirp"], 
+                        value="sine",
+                        label="Modulation Type"
+                    )
+                    override_rhythm = gr.Dropdown(
+                        choices=[None, "calm", "active", "focused", "relaxed"], 
+                        value=None,
+                        label="Override Rhythm Pattern (leave blank for automatic)"
+                    )
+                    duration = gr.Slider(
+                        minimum=1, maximum=30, value=5, step=1, 
+                        label="Duration (seconds)"
+                    )
                 
                 # Generate button
-                generate_button = gr.Button("Generate Modulated Audio", variant="primary")
+                generate_button = gr.Button("Generate Rhythma Experience", variant="primary")
                 
             with gr.Column(scale=2):
                 # Outputs
+                analysis_output = gr.Textbox(label="Rhythma Analysis", lines=10)
+                with gr.Row():
+                    audio_output = gr.Audio(label="Modulated Audio", type="filepath")
+                    waveform_simple = gr.Image(label="Basic Waveform")
+                waveform_plot = gr.Plot(label="Detailed Waveform Analysis")
                 symbolic_output = gr.Textbox(label="Symbolic Interpretation")
-                modulated_audio_output = gr.Audio(label="Modulated Audio", type="filepath")
-                waveform_plot = gr.Plot(label="Waveform Visualization")
 
         # Button action
         generate_button.click(
-            generate_modulated_audio, 
-            inputs=[base_frequency, modulation_type, rhythm_pattern, duration], 
-            outputs=[modulated_audio_output, waveform_plot, symbolic_output]
+            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
+            ]
+        )
+        
+        # Examples
+        gr.Examples(
+            examples=[
+                ["I'm feeling anxious about my upcoming presentation.", None],
+                ["I feel at peace and grounded today.", None],
+                ["I need to focus on my work but keep getting distracted.", None],
+                ["I'm feeling overwhelmed with all my responsibilities.", None],
+                ["I'm excited about my vacation next week!", None]
+            ],
+            inputs=[input_text, audio_input]
         )
         
         gr.Markdown("""
-        ## About Rhythma
+        ## About Rhythma: The Living Modulation Engine
+        
+        Rhythma is a dynamic rhythm-based enhancer that creates responsive sound experiences
+        based on your emotional state and intentions.
+        
+        ### Key Features:
         
-        Rhythma is a dynamic rhythm-based enhancer that creates responsive sound experiences.
+        1. **Input Layer** – Senses the rhythm through text descriptions and audio input
+        2. **SymphAI Core** – Interprets your emotional state and maps it to rhythm patterns
+        3. **Modulation Engine** – Creates dynamic audio experiences with frequency modulation
+        4. **Output Layer** – Delivers audio-visual feedback tailored to your state
         
-        It uses principles of Floquet modulation and rhythm analysis to generate audio that
+        Rhythma uses principles of Floquet modulation and rhythm analysis to generate audio that
         resonates with your current state or intention.
         
-        **How to use:**
-        1. Select a base frequency
-        2. Choose a modulation type
-        3. Select a rhythm pattern that matches your intention
-        4. Set the duration
-        5. Generate and listen to the modulated audio
+        © 2025 Rhythma Technologies
         """)
 
     return demo