lushapp 2.0.0

package/src/lush/cava.py

@@ -0,0 +1,665 @@
+# LUSH - Live CAVA Real-Time Audio DSP Engine & Shimmer Visualizers
+import subprocess
+import threading
+import time
+import math
+import random
+from pathlib import Path
+
+class CavaVisualizerEngine:
+    def __init__(self, config_file: Path, sensitivity: int = 180, framerate: int = 144):
+        self.config_file = config_file
+        self.sensitivity = sensitivity
+        self.framerate = framerate
+        self.bars = [0] * 32
+        self.running = True
+        self.proc = None
+        self.lock = threading.Lock()
+
+        self._ensure_config()
+        self.thread = threading.Thread(target=self._reader_loop, daemon=True)
+        self.thread.start()
+
+    def _ensure_config(self):
+        self.config_file.parent.mkdir(parents=True, exist_ok=True)
+        cfg_content = f"""[general]
+framerate = {self.framerate}
+bars = 32
+sensitivity = {self.sensitivity}
+autosens = 1
+
+[input]
+method = pulse
+source = auto
+
+[output]
+method = raw
+raw_target = /dev/stdout
+data_format = ascii
+ascii_max_range = 8
+
+[smoothing]
+monstercat = 1.2
+noise_reduction = 20
+"""
+        with open(self.config_file, "w", encoding="utf-8") as f:
+            f.write(cfg_content)
+
+    def update_settings(self, sensitivity: int, framerate: int = 144):
+        self.sensitivity = sensitivity
+        self.framerate = framerate
+        self._ensure_config()
+        if self.proc:
+            try:
+                self.proc.terminate()
+            except Exception:
+                pass
+
+    def _reader_loop(self):
+        while self.running:
+            try:
+                self.proc = subprocess.Popen(
+                    ["cava", "-p", str(self.config_file)],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.DEVNULL,
+                    text=True
+                )
+                while self.running:
+                    line = self.proc.stdout.readline()
+                    if not line: break
+                    vals = [int(x) for x in line.strip().split(';') if x.isdigit()]
+                    if vals:
+                        with self.lock:
+                            self.bars = vals[:32]
+            except Exception:
+                # Procedural harmonic wave fallback when CAVA is not installed
+                t0 = time.time()
+                for _ in range(30):
+                    if not self.running: break
+                    t = time.time() - t0
+                    synth_bars = []
+                    for i in range(32):
+                        freq = (i + 1) * 0.8
+                        v = (math.sin(t * 5.0 + i * 0.4) * 0.5 + 0.5) * \
+                            (math.cos(t * 2.5 + freq) * 0.3 + 0.7) * \
+                            (math.sin(t * 9.0 + i * 0.8) * 0.2 + 0.8)
+                        amp = max(0, min(8, int(v * 8 * (1.0 - (i / 64.0)))))
+                        synth_bars.append(amp)
+                    with self.lock:
+                        self.bars = synth_bars
+                    time.sleep(1.0 / 30.0)
+
+    def stop(self):
+        self.running = False
+        if self.proc:
+            try:
+                if self.proc.stdout:
+                    self.proc.stdout.close()
+            except Exception:
+                pass
+            try:
+                self.proc.terminate()
+                self.proc.wait(timeout=0.2)
+            except Exception:
+                try:
+                    self.proc.kill()
+                    self.proc.wait(timeout=0.1)
+                except Exception:
+                    pass
+            self.proc = None
+        if hasattr(self, 'thread') and self.thread.is_alive() and threading.current_thread() != self.thread:
+            self.thread.join(timeout=0.3)
+
+    # 1. Standard Spectrum
+    def get_spectrum_str(self, width: int, is_playing: bool) -> str:
+        if not is_playing: return " " * width
+        with self.lock:
+            cur = list(self.bars)
+        chars = [' ', ' ', '▂', '▃', '▄', '▅', '▆', '▇', '█']
+        if not cur or all(b == 0 for b in cur): return " " * width
+
+        step = len(cur) / max(1, width)
+        out = []
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            v = min(len(chars)-1, max(0, cur[src_i]))
+            out.append(chars[v])
+        return ''.join(out)
+
+    # 2. Shimmer Spectrum Bars (with dynamic white-hot tips and traveling sheen wave)
+    def get_shimmer_spectrum_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [(" ", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        chars = [' ', ' ', '▂', '▃', '▄', '▅', '▆', '▇', '█']
+        if not cur or all(b == 0 for b in cur):
+            return [(" ", 14)] * width
+
+        wave_pos = ((t_now * 0.9) % 2.2) - 0.4
+        step = len(cur) / max(1, width)
+        out = []
+
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            raw_v = cur[src_i]
+            v = min(len(chars)-1, max(0, raw_v))
+            ch = chars[v]
+
+            x_norm = i / max(1, width - 1)
+            dist = abs(x_norm - wave_pos)
+
+            # Intensity blends bar amplitude with sheen wave
+            amp_ratio = raw_v / 8.0
+            glow_boost = max(0.0, 0.45 - dist * 2.2)
+            intensity = amp_ratio * 0.65 + glow_boost
+
+            if intensity > 0.85:
+                pair = 10  # Peak White-Hot
+            elif intensity > 0.65:
+                pair = 11  # Sheen Highlight
+            elif intensity > 0.45:
+                pair = 12  # Neon Glow
+            elif intensity > 0.25:
+                pair = 13  # Mid Glow
+            else:
+                pair = 14  # Base Tone
+
+            out.append((ch, pair))
+        return out
+
+    # 3. Shimmer Audio String (Vibrating Braille string with sheen wave)
+    def get_shimmer_string_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("─", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        braille = ['⣀', '⣤', '⣶', '⣷', '⣿', '⣾', '⣴', '⣄', '⣀']
+        if not cur or all(b == 0 for b in cur):
+            return [("─", 14)] * width
+
+        wave_pos = ((t_now * 0.95) % 2.2) - 0.4
+        step = len(cur) / max(1, width)
+        out = []
+
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            raw_v = cur[src_i]
+            v = min(len(braille)-1, max(0, raw_v))
+            ch = braille[v]
+
+            x_norm = i / max(1, width - 1)
+            dist = abs(x_norm - wave_pos)
+
+            amp_ratio = raw_v / 8.0
+            glow_boost = max(0.0, 0.5 - dist * 2.5)
+            intensity = amp_ratio * 0.6 + glow_boost
+
+            if intensity > 0.80:
+                pair = 10
+            elif intensity > 0.60:
+                pair = 11
+            elif intensity > 0.40:
+                pair = 12
+            elif intensity > 0.20:
+                pair = 13
+            else:
+                pair = 14
+
+            out.append((ch, pair))
+        return out
+
+
+    # 4. Harmonic Resonant Strings (Harmonic nodes and antinodes with traveling glints)
+    def get_harmonic_strings_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("─", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        if not cur or all(b == 0 for b in cur):
+            return [("─", 14)] * width
+
+        wave_pos = ((t_now * 1.1) % 2.2) - 0.4
+        step = len(cur) / max(1, width)
+        out = []
+
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            raw_v = cur[src_i]
+            x_norm = i / max(1, width - 1)
+            dist = abs(x_norm - wave_pos)
+
+            # Calculate harmonic node vibration
+            harm_phase = math.sin(x_norm * math.pi * 4.0 + t_now * 4.0)
+            amp = (raw_v / 8.0) * (0.5 + 0.5 * harm_phase)
+
+            if amp > 0.75:
+                ch = "◈"
+            elif amp > 0.55:
+                ch = "◇"
+            elif amp > 0.35:
+                ch = "·"
+            elif amp > 0.18:
+                ch = "╌"
+            else:
+                ch = "─"
+
+            glow = max(0.0, 0.55 - dist * 2.4)
+            intensity = (raw_v / 8.0) * 0.6 + glow
+
+            if intensity > 0.80:
+                pair = 10
+            elif intensity > 0.60:
+                pair = 11
+            elif intensity > 0.40:
+                pair = 12
+            elif intensity > 0.20:
+                pair = 13
+            else:
+                pair = 14
+
+            out.append((ch, pair))
+        return out
+
+    # 5. Neon Laser Cords (High-voltage pulsing laser cords with tension bending)
+    def get_laser_cords_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("═", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        if not cur or all(b == 0 for b in cur):
+            return [("═", 14)] * width
+
+        spark_pos = ((t_now * 1.6) % 2.0) - 0.3
+        step = len(cur) / max(1, width)
+        out = []
+
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            raw_v = cur[src_i]
+            x_norm = i / max(1, width - 1)
+            dist = abs(x_norm - spark_pos)
+
+            if dist < 0.05 and raw_v >= 3:
+                ch = "⟡"
+                pair = 10
+            elif dist < 0.12 and raw_v >= 2:
+                ch = "⟢"
+                pair = 11
+            elif raw_v >= 6:
+                ch = "═"
+                pair = 10 if dist < 0.3 else 11
+            elif raw_v >= 4:
+                ch = "━"
+                pair = 12
+            elif raw_v >= 2:
+                ch = "─"
+                pair = 13
+            else:
+                ch = "═"
+                pair = 14
+
+            out.append((ch, pair))
+        return out
+
+    # 6. Quantum String Shimmer (Superstring theory particle vibration)
+    def get_quantum_strings_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("·", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        if not cur or all(b == 0 for b in cur):
+            return [("·", 14)] * width
+
+        particles = ["·", "•", "○", "●", "⊛", "✦", "⊛", "●", "○", "•", "·"]
+        wave_pos = ((t_now * 0.85) % 2.2) - 0.4
+        step = len(cur) / max(1, width)
+        out = []
+
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            raw_v = cur[src_i]
+            x_norm = i / max(1, width - 1)
+            dist = abs(x_norm - wave_pos)
+
+            p_idx = (int(t_now * 8) + int(raw_v * 1.5) + i) % len(particles)
+            ch = particles[p_idx] if raw_v > 0 else "·"
+
+            glow = max(0.0, 0.5 - dist * 2.2)
+            intensity = (raw_v / 8.0) * 0.65 + glow
+
+            if intensity > 0.80:
+                pair = 10
+            elif intensity > 0.60:
+                pair = 11
+            elif intensity > 0.40:
+                pair = 12
+            elif intensity > 0.20:
+                pair = 13
+            else:
+                pair = 14
+
+            out.append((ch, pair))
+        return out
+
+    # 7. Aurora Shimmer Strings (Flowing celestial ribbons with wave drift)
+    def get_aurora_ribbon_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("~", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        if not cur or all(b == 0 for b in cur):
+            return [("~", 14)] * width
+
+        aurora_chars = ["~", "∿", "≈", "≋", "∿", "≈", "~"]
+        wave_pos = ((t_now * 0.75) % 2.2) - 0.4
+        step = len(cur) / max(1, width)
+        out = []
+
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            raw_v = cur[src_i]
+            x_norm = i / max(1, width - 1)
+            dist = abs(x_norm - wave_pos)
+
+            wave_offset = math.sin(x_norm * 6.0 + t_now * 3.0)
+            idx = int((wave_offset + 1.0) * 0.5 * (len(aurora_chars) - 1))
+            ch = aurora_chars[max(0, min(len(aurora_chars)-1, idx))]
+
+            glow = max(0.0, 0.55 - dist * 2.3)
+            intensity = (raw_v / 8.0) * 0.6 + glow
+
+            if intensity > 0.80:
+                pair = 10
+            elif intensity > 0.60:
+                pair = 11
+            elif intensity > 0.40:
+                pair = 12
+            elif intensity > 0.20:
+                pair = 13
+            else:
+                pair = 14
+
+            out.append((ch, pair))
+        return out
+
+    # 8. Stereo Harp Strings (Dual acoustic harp strings plucking towards center)
+    def get_stereo_harp_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("─", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        if not cur or all(b == 0 for b in cur):
+            return [("─", 14)] * width
+
+        half_w = max(2, (width - 1) // 2)
+        step = len(cur) / max(1, half_w)
+        left_side = []
+        right_side = []
+
+        for i in range(half_w):
+            l_src = min(len(cur)-1, int(i * step))
+            r_src = min(len(cur)-1, int((half_w - 1 - i) * step))
+            l_v = cur[l_src]
+            r_v = cur[r_src]
+
+            l_ch = "◈" if l_v >= 6 else ("◇" if l_v >= 4 else ("─" if l_v >= 2 else "╌"))
+            l_pair = 10 if l_v >= 7 else (11 if l_v >= 5 else (12 if l_v >= 3 else 14))
+            left_side.append((l_ch, l_pair))
+
+            r_ch = "◈" if r_v >= 6 else ("◇" if r_v >= 4 else ("─" if r_v >= 2 else "╌"))
+            r_pair = 10 if r_v >= 7 else (11 if r_v >= 5 else (12 if r_v >= 3 else 14))
+            right_side.append((r_ch, r_pair))
+
+        center_ch = ("|*|" if max(cur) >= 7 else " | ", 10 if max(cur) >= 7 else 11)
+        return left_side + [(center_ch[0][1], center_ch[1])] + right_side
+
+    # 9. Mirrored Butterfly Spectrum (Dual Wings)
+    def get_mirrored_butterfly_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [(" ", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        chars = [' ', ' ', '▂', '▃', '▄', '▅', '▆', '▇', '█']
+        if not cur or all(b == 0 for b in cur):
+            return [(" ", 14)] * width
+
+        half_w = max(2, (width - 1) // 2)
+        step = len(cur) / max(1, half_w)
+        right_wing = []
+
+        for i in range(half_w):
+            src_i = min(len(cur)-1, int(i * step))
+            raw_v = cur[src_i]
+            v = min(len(chars)-1, max(0, raw_v))
+            ch = chars[v]
+
+            pair = 10 if raw_v >= 7 else (11 if raw_v >= 5 else (12 if raw_v >= 3 else 14))
+            right_wing.append((ch, pair))
+
+        left_wing = list(reversed(right_wing))
+        center_char = ("│", 11 if max(cur) >= 6 else 14)
+
+        return left_wing + [center_char] + right_wing
+
+    # 5. Cyberpunk Matrix Rain Stream
+    def get_matrix_rain_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [(" ", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        glyphs = ['0', '1', 'ｱ', 'ｶ', 'ｻ', 'ﾀ', 'ﾅ', 'ﾊ', 'ﾐ', 'ﾋ', 'ｰ', ' ']
+        if not cur or all(b == 0 for b in cur):
+            return [(" ", 14)] * width
+
+        step = len(cur) / max(1, width)
+        out = []
+
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            raw_v = cur[src_i]
+
+            if raw_v == 0:
+                out.append((" ", 14))
+            else:
+                glyph_idx = (int(t_now * 12) + i * 3) % len(glyphs)
+                ch = glyphs[glyph_idx]
+                pair = 10 if raw_v >= 7 else (11 if raw_v >= 5 else (12 if raw_v >= 3 else 13))
+                out.append((ch, pair))
+        return out
+
+    # 6. Standard Waveform Line
+
+    # 10. High-Energy Spectral Beams
+    def get_frequency_beams_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("·", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        if not cur or all(b == 0 for b in cur):
+            return [("·", 14)] * width
+
+        step = len(cur) / max(1, width)
+        beam_chars = [" ", "▂", "▃", "▄", "▅", "▆", "▇", "█"]
+        out = []
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            v = cur[src_i]
+            ch = beam_chars[min(len(beam_chars)-1, v)]
+            if v >= 7: p = 10
+            elif v >= 5: p = 11
+            elif v >= 3: p = 12
+            elif v >= 1: p = 13
+            else: p = 14
+            out.append((ch, p))
+        return out
+
+    # 11. Acoustic Wave Interference
+    def get_sine_interference_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("~", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        if not cur or all(b == 0 for b in cur):
+            return [("~", 14)] * width
+
+        energy = sum(cur) / max(1, len(cur) * 8.0)
+        bass = max(cur[:4]) / 8.0 if len(cur) >= 4 else 0
+        treble = max(cur[14:]) / 8.0 if len(cur) >= 15 else 0
+        out = []
+        for i in range(width):
+            x_norm = i / max(1, width - 1)
+            w1 = math.sin(x_norm * 8.0 + t_now * (2.0 + bass * 4.0))
+            w2 = math.sin(x_norm * 14.0 - t_now * (3.0 + treble * 5.0))
+            interference = (w1 + w2) * 0.5
+            if abs(interference) > 0.75:
+                ch = "◈" if energy > 0.6 else "◇"
+                p = 10 if energy > 0.6 else 11
+            elif abs(interference) > 0.40:
+                ch = "≈"
+                p = 12
+            elif abs(interference) > 0.15:
+                ch = "∿"
+                p = 13
+            else:
+                ch = "·"
+                p = 14
+            out.append((ch, p))
+        return out
+
+    # 12. High-Res Braille Oscilloscope
+    def get_braille_oscilloscope_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("⠤", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        if not cur or all(b == 0 for b in cur):
+            return [("⠤", 14)] * width
+
+        braille_waves = ["⠤", "⠢", "⠰", "⠠", "⠤", "⠶", "⠒", "⠓", "⠚", "⠛"]
+        step = len(cur) / max(1, width)
+        out = []
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            v = cur[src_i]
+            idx = min(len(braille_waves)-1, int((v / 8.0) * (len(braille_waves)-1)))
+            ch = braille_waves[idx]
+            p = 10 if v >= 7 else (11 if v >= 5 else (12 if v >= 3 else 13))
+            out.append((ch, p))
+        return out
+
+    # 13. Bass Transient Shockwave
+    def get_radial_shock_burst_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("·", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        if not cur or all(b == 0 for b in cur):
+            return [("·", 14)] * width
+
+        bass = max(cur[:4]) / 8.0 if len(cur) >= 4 else 0
+        shock_pos = (t_now * (1.5 + bass * 3.0)) % 1.2
+        out = []
+        for i in range(width):
+            dist_c = abs((i / max(1, width - 1)) - 0.5) * 2.0
+            wave_diff = abs(dist_c - shock_pos)
+            if wave_diff < 0.10 and bass > 0.6:
+                ch = "◈"
+                p = 10
+            elif wave_diff < 0.20:
+                ch = "•"
+                p = 11
+            elif wave_diff < 0.35:
+                ch = "·"
+                p = 12
+            else:
+                ch = "─"
+                p = 14
+            out.append((ch, p))
+        return out
+
+    # 14. Harmonic Constellation
+    def get_starlight_constellation_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing:
+            return [("·", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        if not cur or all(b == 0 for b in cur):
+            return [("·", 14)] * width
+
+        step = len(cur) / max(1, width)
+        out = []
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            v = cur[src_i]
+            if v >= 7:
+                ch, p = "◆", 10
+            elif v >= 5:
+                ch, p = "◈", 11
+            elif v >= 3:
+                ch, p = "◇", 12
+            elif v >= 1:
+                ch, p = "─", 13
+            else:
+                ch, p = "·", 14
+            out.append((ch, p))
+        return out
+
+    def get_waveform_str(self, width: int, is_playing: bool) -> str:
+        if not is_playing: return "─" * width
+        with self.lock:
+            cur = list(self.bars)
+        braille = ['⣀', '⣤', '⣶', '⣷', '⣿', '⣾', '⣴', '⣄', '⣀']
+        if not cur or all(b == 0 for b in cur): return "─" * width
+
+        step = len(cur) / max(1, width)
+        out = []
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            v = min(len(braille)-1, max(0, cur[src_i]))
+            out.append(braille[v])
+        return ''.join(out)
+
+    # 7. Stereo VU Meter
+    def get_stereo_vu_str(self, width: int, is_playing: bool) -> str:
+        bar_w = max(4, (width - 10) // 2)
+        if not is_playing:
+            return f"L [{'░' * bar_w}]  R [{'░' * bar_w}]"
+        with self.lock:
+            cur = list(self.bars)
+
+        half = len(cur) // 2
+        l_max = max(cur[:half]) if half > 0 else 0
+        r_max = max(cur[half:]) if half > 0 else 0
+        l_len = int((l_max / 8.0) * bar_w)
+        r_len = int((r_max / 8.0) * bar_w)
+        l_str = '█' * l_len + '░' * (bar_w - l_len)
+        r_str = '█' * r_len + '░' * (bar_w - r_len)
+        return f"L [{l_str}]  R [{r_str}]"
+
+    # 8. Frequency Peak Dots with Shimmer Glow
+    def get_peak_dots_elements(self, width: int, is_playing: bool, t_now: float):
+        if not is_playing: return [(" ", 14)] * width
+        with self.lock:
+            cur = list(self.bars)
+        dot_chars = [' ', '·', '⠂', '⠒', '⠶', '⠷', '⠿', '█']
+        if not cur or all(b == 0 for b in cur): return [(" ", 14)] * width
+
+        step = len(cur) / max(1, width)
+        out = []
+        for i in range(width):
+            src_i = min(len(cur)-1, int(i * step))
+            raw_v = cur[src_i]
+            v = min(len(dot_chars)-1, max(0, raw_v))
+            ch = dot_chars[v]
+            pair = 10 if raw_v >= 7 else (11 if raw_v >= 5 else (12 if raw_v >= 3 else 14))
+            out.append((ch, pair))
+        return out
+
+    def shutdown(self):
+        self.running = False
+        if self.proc:
+            try:
+                self.proc.terminate()
+            except Exception:
+                pass