Spaces:

CreaturesDigital
/

spotify_dancer

Running

App Files Files Community

CreaturesDigital commited on Dec 25, 2025

Commit

bd10c6b

verified ·

1 Parent(s): c73c192

Upload folder using huggingface_hub

Browse files

Files changed (6) hide show

README.md +132 -4
index.html +57 -18
pyproject.toml +43 -0
spotify_dancer/__init__.py +6 -0
spotify_dancer/main.py +583 -0
style.css +88 -18

README.md CHANGED Viewed

@@ -1,10 +1,138 @@
 ---
 title: Spotify Dancer
-emoji: 👁
-colorFrom: indigo
-colorTo: indigo
 sdk: static
 pinned: false
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

 ---
 title: Spotify Dancer
+emoji: 🎵
+colorFrom: green
+colorTo: gray
 sdk: static
 pinned: false
+license: mit
+tags:
+  - reachy-mini
+  - robotics
+  - spotify
+  - dance
 ---
+# Spotify Dancer for Reachy Mini
+Make your Reachy Mini dance to Spotify music! This app analyzes audio in real-time and generates expressive robot movements synchronized to the beat.
+**Based on [DJ Reactor](https://huggingface.co/spaces/RyeCatcher/dj_reactor)** by RyeCatcher, enhanced with Spotify Connect integration and ALSA loopback for best audio detection quality.
+## Features
+- **Spotify Connect** - Reachy Mini appears as a speaker in your Spotify app
+- **Real-time Beat Detection** - BPM estimation and beat tracking
+- **Dance Styles** - Energetic, Groovy, Chill, and Hip-Hop modes
+- **Stream Analysis** - Direct audio capture via ALSA loopback (best quality)
+- **Web Control Panel** - Live visualizer with adjustable settings
+## Requirements
+- Reachy Mini with wireless connectivity
+- Python 3.10+
+- Spotify account (Free or Premium)
+## Installation
+### From Reachy Mini Dashboard
+1. Go to `http://reachy-mini.local:8000`
+2. Navigate to Apps
+3. Search for "Spotify Dancer"
+4. Click Install
+### Manual Installation
+```bash
+pip install spotify_dancer
+```
+## Setup
+### 1. Install Spotify Connect (raspotify)
+```bash
+curl -sL https://dtcooper.github.io/raspotify/install.sh | sh
+# Configure
+sudo nano /etc/raspotify/conf
+# Set: LIBRESPOT_NAME="Reachy Mini"
+# Set: LIBRESPOT_DEVICE=spotify
+```
+### 2. Enable ALSA Loopback (Recommended)
+For best audio detection, use ALSA loopback:
+```bash
+sudo modprobe snd-aloop pcm_substreams=1
+echo 'snd-aloop' | sudo tee /etc/modules-load.d/loopback.conf
+```
+See the [full ALSA setup guide](docs/spotify_setup.md) for multi-output configuration.
+### 3. Fix Service Permissions
+Create `/etc/systemd/system/raspotify.service.d/override.conf`:
+```ini
+[Service]
+PrivateUsers=false
+PrivateTmp=false
+ProtectSystem=false
+RemoveIPC=false
+User=pollen
+Group=audio
+```
+Then: `sudo systemctl daemon-reload && sudo systemctl restart raspotify`
+## Usage
+1. Start the app from Reachy Mini dashboard
+2. Open control panel: `http://reachy-mini.local:7860`
+3. Select **loopback_in** as Audio Input
+4. Choose a dance style
+5. Click **Start Dancing**
+6. Play music on Spotify → Select "Reachy Mini" as speaker
+## Dance Styles
+| Style | Best For | Movement |
+|-------|----------|----------|
+| Energetic | Rock, EDM | Strong head bobs, wide sway |
+| Groovy | Pop, Funk | Classic nods, balanced movement |
+| Chill | Jazz, Lo-Fi | Smooth tilts, gentle sway |
+| Hip-Hop | Rap, R&B | Rhythmic nods, bass-driven |
+## Audio Input Options
+| Device | Quality | Notes |
+|--------|---------|-------|
+| `loopback_in` | ⭐ Best | Direct stream capture |
+| `reachymini_audio_src` | Poor | Microphone with echo cancellation issues |
+## Architecture
+```
+Spotify App → raspotify → ALSA multi-output
+                              ├──→ Speaker
+                              └──→ Loopback → Spotify Dancer → Robot
+```
+## Troubleshooting
+- **No loopback_in device**: Run `sudo modprobe snd-aloop` and restart the app
+- **Poor detection**: Use loopback_in, increase sensitivity, turn up volume
+- **Tracks skip**: Check ALSA config and IPC permissions (see setup guide)
+## License
+MIT License
+## Credits
+- **DJ Reactor** by [RyeCatcher](https://huggingface.co/spaces/RyeCatcher/dj_reactor) - Original dance movement system
+- **Spotify Connect** via [raspotify](https://github.com/dtcooper/raspotify) (librespot wrapper)
+- Built for the Reachy Mini community

index.html CHANGED Viewed

@@ -1,19 +1,58 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
 </html>

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Spotify Dancer - Reachy Mini App</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🎵 Spotify Dancer</h1>
+            <p>Make your Reachy Mini dance to Spotify music!</p>
+        </div>
+        <div class="features">
+            <div class="feature">
+                <h3>🎧 Spotify Connect</h3>
+                <p>Reachy Mini appears as a speaker in your Spotify app</p>
+            </div>
+            <div class="feature">
+                <h3>🎵 Beat Detection</h3>
+                <p>Real-time audio analysis with BPM estimation</p>
+            </div>
+            <div class="feature">
+                <h3>💃 Dance Styles</h3>
+                <p>Energetic, Groovy, Chill, and Hip-Hop modes</p>
+            </div>
+            <div class="feature">
+                <h3>🔊 Stream Analysis</h3>
+                <p>Direct audio capture via ALSA loopback</p>
+            </div>
+        </div>
+        <div class="install">
+            <h2>Installation</h2>
+            <p>Install this app on your Reachy Mini from the dashboard, or run:</p>
+            <code>pip install spotify_dancer</code>
+        </div>
+        <div class="setup">
+            <h2>Quick Setup</h2>
+            <ol>
+                <li>Install raspotify for Spotify Connect</li>
+                <li>Enable ALSA loopback for best detection</li>
+                <li>Start the app from Reachy Mini dashboard</li>
+                <li>Select 'loopback_in' as audio input</li>
+                <li>Play music on Spotify → Select "Reachy Mini"</li>
+                <li>Click "Start Dancing" and enjoy!</li>
+            </ol>
+        </div>
+        <div class="footer">
+            <p>Built for the Reachy Mini community</p>
+        </div>
+    </div>
+</body>
 </html>

pyproject.toml ADDED Viewed

	@@ -0,0 +1,43 @@

+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "spotify_dancer"
+version = "1.0.0"
+description = "Spotify Dance Mode for Reachy Mini - Robot dances to your music"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "Reachy Community"}
+]
+keywords = ["reachy", "robot", "spotify", "dance", "music", "reachy-mini"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "reachy-mini",
+    "numpy",
+    "gradio>=4.0.0",
+    "sounddevice",
+]
+[project.urls]
+Homepage = "https://huggingface.co/spaces/reachy-community/spotify_dancer"
+Repository = "https://github.com/pollen-robotics/reachy_mini"
+[project.entry-points.reachy_mini_apps]
+spotify_dancer = "spotify_dancer.main:SpotifyDancer"
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["spotify_dancer*"]
+[tool.setuptools.package-data]
+spotify_dancer = ["*.html", "*.css", "*.js"]

spotify_dancer/__init__.py ADDED Viewed

	@@ -0,0 +1,6 @@

+"""Spotify Dancer - Make Reachy Mini dance to your Spotify music."""
+from spotify_dancer.main import SpotifyDancer
+__version__ = "1.0.0"
+__all__ = ["SpotifyDancer"]

spotify_dancer/main.py ADDED Viewed

	@@ -0,0 +1,583 @@

+"""
+Spotify Dancer - Reachy Mini dances to your Spotify music.
+Based on DJ Reactor by RyeCatcher (https://huggingface.co/spaces/RyeCatcher/dj_reactor)
+Enhanced with Spotify Connect integration and ALSA loopback for best audio detection.
+Usage:
+    1. Install raspotify for Spotify Connect
+    2. Configure ALSA loopback (see README)
+    3. Run this app
+    4. Select 'loopback_in' as audio input
+    5. Play music on Spotify, select 'Reachy Mini' as speaker
+    6. Click 'Start Dancing'
+"""
+import math
+import time
+import threading
+import logging
+import subprocess
+from dataclasses import dataclass
+from typing import Optional
+from collections import deque
+import numpy as np
+import gradio as gr
+try:
+    import sounddevice as sd
+    SOUNDDEVICE_AVAILABLE = True
+except ImportError:
+    sd = None
+    SOUNDDEVICE_AVAILABLE = False
+from reachy_mini import ReachyMini, ReachyMiniApp
+from reachy_mini.utils import create_head_pose
+logger = logging.getLogger(__name__)
+# =============================================================================
+# Audio Analysis Constants
+# =============================================================================
+BASS_RANGE = (20, 250)
+MID_RANGE = (250, 2000)
+TREBLE_RANGE = (2000, 8000)
+@dataclass
+class AudioFeatures:
+    """Real-time audio features extracted from the stream."""
+    bass: float = 0.0
+    mid: float = 0.0
+    treble: float = 0.0
+    rms: float = 0.0
+    bpm: float = 120.0
+    beat_detected: bool = False
+@dataclass
+class DanceStyle:
+    """Movement characteristics for different music styles."""
+    name: str
+    display_name: str
+    head_bob_amplitude: float = 12.0
+    head_bob_speed: float = 1.0
+    body_sway_amplitude: float = 60.0
+    body_sway_speed: float = 1.0
+    antenna_amplitude: float = 0.6
+    emphasis: str = "nod"  # nod, headbang, tilt
+    smoothing: float = 0.3
+DANCE_STYLES = {
+    "energetic": DanceStyle(
+        name="energetic", display_name="Energetic (Rock/EDM)",
+        head_bob_amplitude=18.0, body_sway_amplitude=70.0,
+        antenna_amplitude=1.0, emphasis="headbang", smoothing=0.2,
+    ),
+    "groovy": DanceStyle(
+        name="groovy", display_name="Groovy (Pop/Funk)",
+        head_bob_amplitude=14.0, body_sway_amplitude=65.0,
+        antenna_amplitude=0.8, emphasis="nod", smoothing=0.25,
+    ),
+    "chill": DanceStyle(
+        name="chill", display_name="Chill (Jazz/Lo-Fi)",
+        head_bob_amplitude=10.0, head_bob_speed=1.3,
+        body_sway_amplitude=75.0, body_sway_speed=1.3,
+        antenna_amplitude=0.5, emphasis="tilt", smoothing=0.4,
+    ),
+    "hiphop": DanceStyle(
+        name="hiphop", display_name="Hip-Hop",
+        head_bob_amplitude=16.0, head_bob_speed=0.9,
+        body_sway_amplitude=60.0, antenna_amplitude=0.7,
+        emphasis="nod", smoothing=0.2,
+    ),
+}
+# =============================================================================
+# Audio Analyzer
+# =============================================================================
+class AudioAnalyzer:
+    """Real-time audio analysis for beat detection and frequency bands."""
+    def __init__(self, sample_rate: int = 44100, chunk_size: int = 1024,
+                 device_index: Optional[int] = None, sensitivity: float = 0.7):
+        self.sample_rate = sample_rate
+        self.chunk_size = chunk_size
+        self.device_index = device_index
+        self.sensitivity = sensitivity
+        # FFT setup
+        freqs = np.fft.rfftfreq(chunk_size, 1.0 / sample_rate)
+        self.bass_bins = np.where((freqs >= BASS_RANGE[0]) & (freqs <= BASS_RANGE[1]))[0]
+        self.mid_bins = np.where((freqs >= MID_RANGE[0]) & (freqs <= MID_RANGE[1]))[0]
+        self.treble_bins = np.where((freqs >= TREBLE_RANGE[0]) & (freqs <= TREBLE_RANGE[1]))[0]
+        # Beat tracking
+        self.energy_history = deque(maxlen=20)
+        self.beat_times = deque(maxlen=50)
+        self.last_beat_time = 0.0
+        self.estimated_bpm = 120.0
+        # State
+        self.is_running = False
+        self.stream = None
+        self.latest_features = AudioFeatures()
+        self.start_time = 0.0
+    def _audio_callback(self, indata, frames, time_info, status):
+        """Process incoming audio data."""
+        if len(indata.shape) > 1:
+            audio = np.mean(indata, axis=1)
+        else:
+            audio = indata.flatten()
+        current_time = time.time() - self.start_time
+        # RMS energy
+        rms = np.sqrt(np.mean(audio ** 2))
+        is_silent = rms < 0.0001  # Lowered threshold
+        # FFT analysis
+        windowed = audio * np.hanning(len(audio))
+        if len(windowed) < self.chunk_size:
+            windowed = np.pad(windowed, (0, self.chunk_size - len(windowed)))
+        spectrum = np.abs(np.fft.rfft(windowed[:self.chunk_size]))
+        # Extract band energies (boosted for better detection)
+        bass = min(np.mean(spectrum[self.bass_bins]) / 1.5, 1.0) if len(self.bass_bins) > 0 else 0
+        mid = min(np.mean(spectrum[self.mid_bins]) / 1.0, 1.0) if len(self.mid_bins) > 0 else 0
+        treble = min(np.mean(spectrum[self.treble_bins]) / 2.0, 1.0) if len(self.treble_bins) > 0 else 0
+        # Beat detection
+        self.energy_history.append(bass + mid * 0.5)
+        beat_detected = False
+        if len(self.energy_history) >= 5 and not is_silent:
+            avg_energy = np.mean(list(self.energy_history)[:-1])
+            current_energy = self.energy_history[-1]
+            onset_threshold = 1.1 + (1.0 - self.sensitivity) * 0.5
+            min_interval = 0.15 + (1.0 - self.sensitivity) * 0.15
+            if current_energy > avg_energy * onset_threshold:
+                if current_time - self.last_beat_time > min_interval:
+                    beat_detected = True
+                    self.beat_times.append(current_time)
+                    self.last_beat_time = current_time
+                    # Estimate BPM
+                    if len(self.beat_times) >= 4:
+                        intervals = np.diff(list(self.beat_times)[-8:])
+                        valid = intervals[(intervals > 0.25) & (intervals < 2.0)]
+                        if len(valid) > 0:
+                            avg_interval = np.mean(valid)
+                            self.estimated_bpm = 60.0 / avg_interval
+        self.latest_features = AudioFeatures(
+            bass=float(bass),
+            mid=float(mid),
+            treble=float(treble),
+            rms=min(float(rms) * 5, 1.0),
+            bpm=float(np.clip(self.estimated_bpm, 60, 200)),
+            beat_detected=beat_detected,
+        )
+    def start(self):
+        """Start audio capture."""
+        if not SOUNDDEVICE_AVAILABLE:
+            logger.error("sounddevice not available")
+            return
+        self.start_time = time.time()
+        self.is_running = True
+        try:
+            self.stream = sd.InputStream(
+                device=self.device_index,
+                channels=2,
+                samplerate=self.sample_rate,
+                blocksize=self.chunk_size,
+                callback=self._audio_callback,
+            )
+            self.stream.start()
+            logger.info(f"Audio stream started (device: {self.device_index})")
+        except Exception as e:
+            logger.error(f"Failed to start audio stream: {e}")
+            self.is_running = False
+    def stop(self):
+        """Stop audio capture."""
+        self.is_running = False
+        if self.stream:
+            self.stream.stop()
+            self.stream.close()
+            self.stream = None
+    def update_sensitivity(self, sensitivity: float):
+        """Update beat detection sensitivity."""
+        self.sensitivity = max(0.1, min(1.0, sensitivity))
+# =============================================================================
+# Dance Controller
+# =============================================================================
+class DanceController:
+    """Converts audio features into robot movements."""
+    def __init__(self, style: DanceStyle, intensity: float = 0.7):
+        self.style = style
+        self.intensity = intensity
+        self.phase = 0.0
+        self.last_beat_phase = 0.0
+        # Smoothed values
+        self.smooth_bass = 0.0
+        self.smooth_mid = 0.0
+        self.smooth_energy = 0.0
+    def update(self, features: AudioFeatures, dt: float) -> dict:
+        """Generate movement commands from audio features."""
+        # Smooth the inputs
+        alpha = 1.0 - self.style.smoothing
+        self.smooth_bass = self.smooth_bass * (1 - alpha) + features.bass * alpha
+        self.smooth_mid = self.smooth_mid * (1 - alpha) + features.mid * alpha
+        self.smooth_energy = self.smooth_energy * (1 - alpha) + features.rms * alpha
+        # Update phase based on BPM
+        bpm = features.bpm
+        beat_freq = bpm / 60.0
+        self.phase += dt * beat_freq * 2 * math.pi * self.style.head_bob_speed
+        # Beat emphasis
+        beat_boost = 1.5 if features.beat_detected else 1.0
+        # Calculate movements based on style
+        energy = self.smooth_energy * self.intensity * beat_boost
+        if self.style.emphasis == "headbang":
+            # Strong up-down motion
+            head_z = self.style.head_bob_amplitude * energy * math.sin(self.phase)
+            head_roll = self.style.head_bob_amplitude * 0.3 * energy * math.sin(self.phase * 0.5)
+        elif self.style.emphasis == "tilt":
+            # Smooth side-to-side
+            head_z = self.style.head_bob_amplitude * 0.5 * energy * math.sin(self.phase)
+            head_roll = self.style.head_bob_amplitude * energy * math.sin(self.phase * 0.7)
+        else:  # nod
+            # Classic head bob
+            head_z = self.style.head_bob_amplitude * energy * abs(math.sin(self.phase))
+            head_roll = self.style.head_bob_amplitude * 0.5 * energy * math.sin(self.phase * 0.3)
+        # Body sway follows bass
+        body_yaw = self.style.body_sway_amplitude * self.smooth_bass * self.intensity * math.sin(self.phase * 0.5)
+        # Antennas react to treble
+        antenna_base = self.style.antenna_amplitude * self.intensity
+        antenna_left = antenna_base * (0.5 + features.treble * 0.5) * math.sin(self.phase * 1.5)
+        antenna_right = antenna_base * (0.5 + features.treble * 0.5) * math.sin(self.phase * 1.5 + math.pi)
+        return {
+            'head_z': head_z,
+            'head_roll': head_roll,
+            'body_yaw': body_yaw,
+            'antenna_left': antenna_left,
+            'antenna_right': antenna_right,
+        }
+    def update_style(self, style: DanceStyle):
+        """Change dance style."""
+        self.style = style
+    def update_intensity(self, intensity: float):
+        """Change movement intensity."""
+        self.intensity = max(0.1, min(1.0, intensity))
+# =============================================================================
+# Utility Functions
+# =============================================================================
+def list_audio_devices() -> list:
+    """List available audio input devices."""
+    if not SOUNDDEVICE_AVAILABLE:
+        return []
+    devices = []
+    try:
+        for i, dev in enumerate(sd.query_devices()):
+            if dev['max_input_channels'] > 0:
+                devices.append({
+                    'index': i,
+                    'name': dev['name'],
+                    'channels': dev['max_input_channels'],
+                    'sample_rate': dev['default_samplerate'],
+                })
+    except Exception as e:
+        logger.error(f"Failed to list audio devices: {e}")
+    return devices
+def setup_loopback() -> bool:
+    """Attempt to load ALSA loopback module."""
+    try:
+        result = subprocess.run(
+            ['sudo', 'modprobe', 'snd-aloop', 'pcm_substreams=1'],
+            capture_output=True, timeout=5
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+# =============================================================================
+# Main App
+# =============================================================================
+class SpotifyDancer(ReachyMiniApp):
+    """Reachy Mini dances to your Spotify music."""
+    custom_app_url: str | None = "http://0.0.0.0:7860"
+    dont_start_webserver: bool = True  # We handle Gradio ourselves
+    request_media_backend: str | None = "no_media"  # Don't need camera
+    def __init__(self):
+        super().__init__()
+        self.is_dancing = False
+        self.analyzer: Optional[AudioAnalyzer] = None
+        self.controller: Optional[DanceController] = None
+        self.current_style = "groovy"
+        self.intensity = 0.7
+        self.sensitivity = 0.7
+        self.latest_features = AudioFeatures()
+    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
+        """Main app loop."""
+        # Start UI in background
+        ui_thread = threading.Thread(
+            target=self._run_ui,
+            args=(reachy_mini, stop_event),
+            daemon=True
+        )
+        ui_thread.start()
+        # Movement loop
+        last_time = time.time()
+        while not stop_event.is_set():
+            current_time = time.time()
+            dt = current_time - last_time
+            last_time = current_time
+            if self.is_dancing and self.analyzer and self.controller:
+                self.latest_features = self.analyzer.latest_features
+                movement = self.controller.update(self.latest_features, dt)
+                try:
+                    head_pose = create_head_pose(
+                        z=movement['head_z'],
+                        roll=movement['head_roll'],
+                        mm=True,
+                        degrees=True
+                    )
+                    reachy_mini.goto_target(
+                        head=head_pose,
+                        antennas=[movement['antenna_left'], movement['antenna_right']],
+                        body_yaw=np.deg2rad(movement['body_yaw']),
+                        duration=0.1,
+                        method="minjerk"
+                    )
+                except Exception as e:
+                    logger.debug(f"Movement error: {e}")
+            time.sleep(0.05)
+        # Cleanup
+        if self.analyzer:
+            self.analyzer.stop()
+    def _run_ui(self, reachy_mini: ReachyMini, stop_event: threading.Event):
+        """Run Gradio UI."""
+        devices = list_audio_devices()
+        device_names = [d['name'] for d in devices]
+        style_choices = [(s.display_name, name) for name, s in DANCE_STYLES.items()]
+        # Check for loopback
+        has_loopback = any('loopback' in d['name'].lower() for d in devices)
+        def start_dancing(device_name, style, intensity, sensitivity):
+            if self.is_dancing:
+                return get_status()
+            device_idx = None
+            for d in devices:
+                if d['name'] == device_name:
+                    device_idx = d['index']
+                    break
+            self.current_style = style
+            self.intensity = intensity
+            self.sensitivity = sensitivity
+            dance_style = DANCE_STYLES.get(style, DANCE_STYLES["groovy"])
+            self.controller = DanceController(dance_style, intensity)
+            self.analyzer = AudioAnalyzer(device_index=device_idx, sensitivity=sensitivity)
+            self.analyzer.start()
+            self.is_dancing = True
+            return get_status()
+        def stop_dancing():
+            self.is_dancing = False
+            if self.analyzer:
+                self.analyzer.stop()
+                self.analyzer = None
+            return get_status()
+        def change_style(style):
+            self.current_style = style
+            if self.controller:
+                self.controller.update_style(DANCE_STYLES.get(style, DANCE_STYLES["groovy"]))
+            return get_status()
+        def update_intensity(val):
+            self.intensity = val
+            if self.controller:
+                self.controller.update_intensity(val)
+        def update_sensitivity(val):
+            self.sensitivity = val
+            if self.analyzer:
+                self.analyzer.update_sensitivity(val)
+        def try_setup_loopback():
+            if setup_loopback():
+                return "Loopback enabled! Refresh page to see new devices."
+            return "Failed to enable loopback (may need sudo)"
+        def bar(value, color):
+            width = int(value * 100)
+            return f'<div style="background:#e0e0e0;border-radius:4px;overflow:hidden;"><div style="width:{width}%;height:12px;background:{color};transition:width 0.1s;"></div></div>'
+        def get_status():
+            f = self.latest_features
+            status = "Dancing!" if self.is_dancing else "Ready"
+            color = "#4CAF50" if self.is_dancing else "#666"
+            beat = " *" if f.beat_detected and self.is_dancing else ""
+            style_name = DANCE_STYLES.get(self.current_style, DANCE_STYLES["groovy"]).display_name
+            return f"""
+            <div style="padding:15px;">
+                <div style="text-align:center;margin-bottom:15px;">
+                    <div style="font-size:18px;font-weight:bold;color:{color};">{status}{beat}</div>
+                    <div style="font-size:12px;color:#888;margin-top:4px;">{style_name}</div>
+                </div>
+                <div style="text-align:center;margin-bottom:20px;">
+                    <div style="font-size:48px;font-family:monospace;font-weight:bold;">{f.bpm:.0f}</div>
+                    <div style="font-size:14px;color:#666;">BPM</div>
+                </div>
+                <div style="background:#f5f5f5;padding:15px;border-radius:10px;">
+                    <div style="margin-bottom:12px;">
+                        <div style="font-size:12px;color:#666;margin-bottom:4px;">Bass</div>
+                        {bar(f.bass, '#e91e63')}
+                    </div>
+                    <div style="margin-bottom:12px;">
+                        <div style="font-size:12px;color:#666;margin-bottom:4px;">Mid</div>
+                        {bar(f.mid, '#9c27b0')}
+                    </div>
+                    <div style="margin-bottom:12px;">
+                        <div style="font-size:12px;color:#666;margin-bottom:4px;">Treble</div>
+                        {bar(f.treble, '#3f51b5')}
+                    </div>
+                    <div>
+                        <div style="font-size:12px;color:#666;margin-bottom:4px;">Energy</div>
+                        {bar(f.rms, '#4CAF50')}
+                    </div>
+                </div>
+            </div>
+            """
+        with gr.Blocks(title="Spotify Dancer", theme=gr.themes.Soft()) as demo:
+            gr.HTML("""
+            <div style="background:linear-gradient(135deg,#1DB954 0%,#191414 100%);
+                        color:white;padding:25px;border-radius:15px;text-align:center;margin-bottom:15px;">
+                <h1 style="margin:0;font-size:32px;">Spotify Dancer</h1>
+                <p style="margin:8px 0 0 0;opacity:0.9;">Reachy Mini dances to your music</p>
+            </div>
+            """)
+            if not has_loopback:
+                gr.HTML("""
+                <div style="background:#fff3cd;border:1px solid #ffc107;padding:10px;border-radius:8px;margin-bottom:15px;">
+                    <b>Tip:</b> For best results, use 'loopback_in' as audio input.
+                    This captures the audio stream directly instead of using the microphone.
+                </div>
+                """)
+            with gr.Row():
+                with gr.Column(scale=1):
+                    device_dropdown = gr.Dropdown(
+                        choices=device_names,
+                        value=next((d for d in device_names if 'loopback_in' in d.lower()), device_names[0] if device_names else None),
+                        label="Audio Input",
+                        info="Use 'loopback_in' for best results"
+                    )
+                    style_radio = gr.Radio(
+                        choices=style_choices,
+                        value="groovy",
+                        label="Dance Style"
+                    )
+                    intensity_slider = gr.Slider(
+                        0.1, 1.0, value=0.7, step=0.1,
+                        label="Movement Intensity"
+                    )
+                    sensitivity_slider = gr.Slider(
+                        0.3, 1.0, value=0.7, step=0.1,
+                        label="Beat Sensitivity"
+                    )
+                    with gr.Row():
+                        start_btn = gr.Button("Start Dancing", variant="primary", size="lg")
+                        stop_btn = gr.Button("Stop", size="lg")
+                    if not has_loopback:
+                        loopback_btn = gr.Button("Enable Loopback", size="sm")
+                        loopback_status = gr.Textbox(label="", visible=False)
+                        loopback_btn.click(fn=try_setup_loopback, outputs=[loopback_status])
+                with gr.Column(scale=1):
+                    status_html = gr.HTML(value=get_status())
+            timer = gr.Timer(value=0.2)
+            timer.tick(fn=get_status, outputs=[status_html])
+            start_btn.click(
+                fn=start_dancing,
+                inputs=[device_dropdown, style_radio, intensity_slider, sensitivity_slider],
+                outputs=[status_html]
+            )
+            stop_btn.click(fn=stop_dancing, outputs=[status_html])
+            style_radio.change(fn=change_style, inputs=[style_radio], outputs=[status_html])
+            intensity_slider.change(fn=update_intensity, inputs=[intensity_slider])
+            sensitivity_slider.change(fn=update_sensitivity, inputs=[sensitivity_slider])
+        demo.launch(server_name="0.0.0.0", server_port=7860, quiet=True, prevent_thread_lock=True)
+        while not stop_event.is_set():
+            time.sleep(1)
+if __name__ == "__main__":
+    app = SpotifyDancer()
+    try:
+        app.wrapped_run()
+    except KeyboardInterrupt:
+        app.stop()

style.css CHANGED Viewed

@@ -1,28 +1,98 @@
 body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
 }
-h1 {
-	font-size: 16px;
-	margin-top: 0;
 }
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
 }
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
 }
-.card p:last-child {
-	margin-bottom: 0;
 }

+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
 body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    color: #fff;
+    min-height: 100vh;
+    padding: 20px;
+}
+.container {
+    max-width: 800px;
+    margin: 0 auto;
+}
+.header {
+    text-align: center;
+    padding: 40px 20px;
+    background: linear-gradient(135deg, #1DB954 0%, #191414 100%);
+    border-radius: 20px;
+    margin-bottom: 30px;
+}
+.header h1 {
+    font-size: 2.5em;
+    margin-bottom: 10px;
+}
+.header p {
+    font-size: 1.2em;
+    opacity: 0.9;
+}
+.features {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 20px;
+    margin-bottom: 30px;
+}
+.feature {
+    background: rgba(255, 255, 255, 0.1);
+    padding: 20px;
+    border-radius: 15px;
+    text-align: center;
+}
+.feature h3 {
+    font-size: 1.3em;
+    margin-bottom: 10px;
+    color: #1DB954;
+}
+.feature p {
+    opacity: 0.8;
+    font-size: 0.95em;
+}
+.install, .setup {
+    background: rgba(255, 255, 255, 0.05);
+    padding: 25px;
+    border-radius: 15px;
+    margin-bottom: 20px;
+}
+.install h2, .setup h2 {
+    color: #1DB954;
+    margin-bottom: 15px;
 }
+code {
+    background: #000;
+    padding: 10px 15px;
+    border-radius: 8px;
+    display: inline-block;
+    font-family: 'Monaco', 'Consolas', monospace;
+    margin-top: 10px;
 }
+.setup ol {
+    padding-left: 25px;
 }
+.setup li {
+    margin-bottom: 10px;
+    line-height: 1.6;
 }
+.footer {
+    text-align: center;
+    padding: 20px;
+    opacity: 0.6;
+    font-size: 0.9em;
 }