lushapp 2.0.0

package/src/lush/state.py

@@ -0,0 +1,550 @@
+# LUSH - State and Storage Management
+import os
+import json
+import threading
+import time
+from pathlib import Path
+from .constants import DEFAULT_THEMES, SHIMMER_EFFECTS, SHIMMER_EFFECT_LABELS, ALL_SIDEBAR_ITEMS, VISUALIZER_MODES, VISUALIZER_LABELS, AMBIENT_PRESETS
+from .audio import AudioEngine
+from .cava import CavaVisualizerEngine
+from .net import get_net_bytes, format_speed
+from .stats import StatsEngine
+from .notify import NotificationManager
+from .search import fuzzy_filter_stations
+
+CONFIG_DIR = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config")) / "lush"
+STATIONS_FILE = CONFIG_DIR / "stations.json"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+THEMES_FILE = CONFIG_DIR / "themes.json"
+FAVORITES_FILE = CONFIG_DIR / "favorites.json"
+HISTORY_FILE = CONFIG_DIR / "history.json"
+STATS_FILE = CONFIG_DIR / "stats.json"
+
+def load_history():
+    try:
+        if HISTORY_FILE.exists():
+            with open(HISTORY_FILE, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, list):
+                    return data
+    except Exception:
+        pass
+    return []
+
+def save_history(history):
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        tmp_file = HISTORY_FILE.with_suffix(".tmp")
+        with open(tmp_file, "w", encoding="utf-8") as f:
+            json.dump(history[:150], f, ensure_ascii=False, indent=2)
+        tmp_file.replace(HISTORY_FILE)
+    except Exception:
+        pass
+
+CAVA_CFG_FILE = CONFIG_DIR / "cava.conf"
+RECORDINGS_DIR = Path.home() / "Music" / "Recordings"
+
+def get_bundled_stations():
+    try:
+        bundled_path = Path(__file__).parent / "data" / "stations.json"
+        if bundled_path.exists():
+            with open(bundled_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, list) and data:
+                    return data
+    except Exception:
+        pass
+    return []
+
+DEFAULT_STATIONS = get_bundled_stations()
+
+def load_stations():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    bundled = get_bundled_stations()
+    try:
+        if STATIONS_FILE.exists():
+            with open(STATIONS_FILE, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, list) and len(data) >= 100:
+                    return data
+    except Exception:
+        pass
+    if bundled:
+        save_stations(bundled)
+        return bundled
+    return DEFAULT_STATIONS
+
+def save_stations(stations):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(STATIONS_FILE, "w", encoding="utf-8") as f:
+        json.dump(stations, f, ensure_ascii=False, indent=2)
+
+def load_favorites():
+    try:
+        if FAVORITES_FILE.exists():
+            with open(FAVORITES_FILE, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, list):
+                    return set(data)
+    except Exception:
+        pass
+    return set()
+
+def save_favorites(favs):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(FAVORITES_FILE, "w", encoding="utf-8") as f:
+        json.dump(list(favs), f, ensure_ascii=False, indent=2)
+
+def load_config():
+    try:
+        if CONFIG_FILE.exists():
+            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, dict):
+                    return data
+    except Exception:
+        pass
+    return {
+        "theme": "Plur1bus",
+        "section": "top_artists",
+        "visualizer": "spectrum",
+        "ambient_preset": "none",
+        "ambient_volume": 40,
+        "cava_sensitivity": 180,
+        "master_volume": 100,
+        "nsfw_enabled": False
+    }
+
+def save_config(cfg):
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        cur = load_config()
+        cur.update(cfg)
+        tmp_file = CONFIG_FILE.with_suffix(".tmp")
+        with open(tmp_file, "w", encoding="utf-8") as f:
+            json.dump(cur, f, ensure_ascii=False, indent=2)
+        tmp_file.replace(CONFIG_FILE)
+    except Exception:
+        pass
+
+def load_themes():
+    themes = dict(DEFAULT_THEMES)
+    try:
+        if THEMES_FILE.exists():
+            with open(THEMES_FILE, "r", encoding="utf-8") as f:
+                custom = json.load(f)
+                if isinstance(custom, dict):
+                    themes.update(custom)
+    except Exception:
+        pass
+    return themes
+
+class PlayerState:
+    def __init__(self):
+        self.stations = load_stations()
+        self.favorites = load_favorites()
+        self.themes = load_themes()
+        cfg = load_config()
+
+        self.theme_name = cfg.get("theme", "Plur1bus")
+        if self.theme_name not in self.themes:
+            self.theme_name = "Plur1bus" if "Plur1bus" in self.themes else list(self.themes.keys())[0]
+
+        self.section_key = cfg.get("section", "top_artists")
+        if self.section_key in ("all", "lush"): self.section_key = "top_artists"
+        keys = [it["key"] for it in ALL_SIDEBAR_ITEMS]
+        if self.section_key not in keys:
+            self.section_key = "all"
+
+        self.sidebar_idx = keys.index(self.section_key)
+        self.region = "content"
+        self.search_active = False
+        self.search_query = ""
+
+        # Visualizer & Ambient
+        self.visualizer_mode = cfg.get("visualizer", "shimmer_string")
+        if self.visualizer_mode not in VISUALIZER_MODES:
+            self.visualizer_mode = "shimmer_string"
+
+        self.ambient_preset = cfg.get("ambient_preset", "none")
+        self.ambient_volume = cfg.get("ambient_volume", 40)
+        self.cava_sensitivity = cfg.get("cava_sensitivity", 180)
+        self.volume = cfg.get("master_volume", 100)
+        self.nsfw_enabled = cfg.get("nsfw_enabled", False)
+        self.headphone_warned_session = False
+        self.config = cfg
+        self.show_welcome = cfg.get("show_welcome", True)
+        self.deck_style = cfg.get("deck_style", "vinyl")
+        self.framerate = cfg.get("framerate", 144)
+        self.shimmer_effect = cfg.get("shimmer_effect", "cava_sync")
+        if self.shimmer_effect not in SHIMMER_EFFECTS: self.shimmer_effect = "cava_sync"
+
+        # Network and Bitrate
+        self.net_down_str = "↓ 0 B/s"
+        self.net_up_str = "↑ 0 B/s"
+        self.stream_bitrate = "128 kbps"
+
+        # Station selection: resume last station or pick random trending/legend artist on first launch
+        last_url = cfg.get("last_station_url")
+        last_name = cfg.get("last_station_name")
+
+        target_idx = None
+        if last_url:
+            for i, s in enumerate(self.stations):
+                if s.get("url") == last_url:
+                    target_idx = i
+                    break
+        if target_idx is None and last_name:
+            for i, s in enumerate(self.stations):
+                if s.get("name") == last_name:
+                    target_idx = i
+                    break
+
+        # First-time user boot experience: pick random trending or legends artist
+        if target_idx is None:
+            import random
+            popular_keywords = [
+                "taylor swift", "billie eilish", "olivia rodrigo", "the weeknd", "britney",
+                "daft punk", "lana del rey", "dua lipa", "queen", "michael jackson",
+                "eminem", "shakira", "justin timberlake", "timbaland", "nelly", "usher",
+                "ariana grande", "harry styles", "rihanna", "lady gaga", "k-pop", "sabrina carpenter",
+                "charli xcx", "post malone", "drake", "sza", "pink floyd", "david bowie"
+            ]
+            candidates = [
+                i for i, s in enumerate(self.stations)
+                if (s.get("category") == "music" or "exclusive.radio" in s.get("url", "").lower())
+                and any(k in s.get("name", "").lower() for k in popular_keywords)
+            ]
+            if candidates:
+                target_idx = random.choice(candidates)
+            else:
+                target_idx = 0
+
+        self.idx = target_idx
+        self.cursor_idx = target_idx
+        self.current_track = self.stations[self.idx]["name"]
+        self.history = load_history()
+        self.playing = True
+        self.quit = False
+        self.toast_msg = ""
+        self.toast_time = 0
+        self.lock = threading.RLock()
+
+        # SSD Wear Reduction: In-Memory Dirty Tracking
+        self._cfg_dirty = False
+        self._last_cfg_save = 0.0
+
+        # Subsystems
+        self.audio = AudioEngine(RECORDINGS_DIR)
+        self.cava = CavaVisualizerEngine(CAVA_CFG_FILE, sensitivity=self.cava_sensitivity, framerate=self.framerate)
+        self.stats = StatsEngine(STATS_FILE, HISTORY_FILE, RECORDINGS_DIR)
+        self.notify_mgr = NotificationManager(enabled=cfg.get("notifications_enabled", True))
+
+        # Initial playback
+        self.audio.set_volume(self.volume)
+        self.audio.play_station(self.stations[self.idx]["url"])
+        if self.ambient_preset != "none":
+            self.start_ambient_preset(self.ambient_preset, notify=False)
+
+    def add_history_entry(self, track_title, station_name, station_url, genre):
+        if not track_title:
+            return
+        entry = {
+            "name": track_title,
+            "station": station_name,
+            "genre": genre,
+            "url": station_url,
+            "time": time.strftime("%H:%M"),
+            "date": time.strftime("%Y-%m-%d"),
+            "timestamp": time.time()
+        }
+        if self.history and self.history[0].get("name") == track_title:
+            return
+        self.history.insert(0, entry)
+        if len(self.history) > 150:
+            self.history = self.history[:150]
+        save_history(self.history)
+        if hasattr(self, "stats") and self.stats:
+            self.stats.record_track(track_title, station_name, genre, station_url)
+
+    def get_current_sidebar_item(self):
+        for it in ALL_SIDEBAR_ITEMS:
+            if it["key"] == self.section_key:
+                return it
+        return ALL_SIDEBAR_ITEMS[0]
+
+    def get_filtered_stations_unlocked(self):
+        cur_item = self.get_current_sidebar_item()
+        k = cur_item["key"]
+
+        if k == "bookmarks":
+            filtered = [(i, s) for i, s in enumerate(self.stations) if s["name"] in self.favorites]
+        elif k == "playing":
+            filtered = [(self.idx, self.stations[self.idx])]
+        elif k == "history":
+            filtered = [(i, h) for i, h in enumerate(self.history)]
+        elif k == "lush":
+            if not self.nsfw_enabled:
+                filtered = []
+            else:
+                filtered = [(i, s) for i, s in enumerate(self.stations) if cur_item.get("match", lambda x: True)(s)]
+        elif "match" in cur_item:
+            match_fn = cur_item["match"]
+            filtered = [(i, s) for i, s in enumerate(self.stations) if match_fn(s)]
+            if "sort_key" in cur_item:
+                sort_fn = cur_item["sort_key"]
+                filtered.sort(key=lambda item: sort_fn(item[1]))
+        else:
+            filtered = [(i, s) for i, s in enumerate(self.stations)]
+
+        # Strictly filter out 18+ / sensual / ASMR content when 18+ is disabled
+        if not self.nsfw_enabled:
+            filtered = [(i, s) for i, s in filtered if not (
+                s.get("nsfw") is True or
+                s.get("category") == "lush" or
+                any(sens in s.get("genre", "").lower() for sens in ["sensual", "erotic", "adult", "18+", "nsfw"])
+            )]
+
+        if self.search_query:
+            matched = fuzzy_filter_stations(filtered, self.search_query)
+            if not matched and k not in ("playing", "history"):
+                # Fallback to search all available stations
+                all_indexed = [(i, s) for i, s in enumerate(self.stations)]
+                if not self.nsfw_enabled:
+                    all_indexed = [(i, s) for i, s in all_indexed if not (
+                        s.get("nsfw") is True or
+                        s.get("category") == "lush" or
+                        any(sens in s.get("genre", "").lower() for sens in ["sensual", "erotic", "adult", "18+", "nsfw"])
+                    )]
+                matched = fuzzy_filter_stations(all_indexed, self.search_query)
+            filtered = matched
+
+        return filtered
+
+    def get_filtered_stations(self):
+        with self.lock:
+            return self.get_filtered_stations_unlocked()
+
+    def play_station(self, global_idx):
+        with self.lock:
+            if global_idx < 0 or global_idx >= len(self.stations): return
+            self.idx = global_idx
+            st = self.stations[self.idx]
+            self.current_track = st["name"]
+            self.add_history_entry(st["name"], st["name"], st["url"], st.get("genre", "Unknown"))
+            self.audio.play_station(st["url"])
+            self.playing = True
+            self.save_current_config()
+            self.set_toast(f"▶ Tuning into: {st['name']}")
+
+    def toggle_play(self):
+        with self.lock:
+            self.playing = self.audio.toggle_play(self.playing)
+            if self.playing:
+                self.set_toast("▶ Resumed")
+            else:
+                self.set_toast("→ PAUSED")
+
+    def adjust_volume(self, delta):
+        with self.lock:
+            new_v = max(0, min(100, int(self.volume + delta)))
+            self.volume = new_v
+            self.audio.set_volume(new_v)
+            save_config({"master_volume": new_v})
+            self.set_toast(f"Volume: {new_v}%")
+
+    def cycle_visualizer(self):
+        with self.lock:
+            cur_i = VISUALIZER_MODES.index(self.visualizer_mode) if self.visualizer_mode in VISUALIZER_MODES else 0
+            self.visualizer_mode = VISUALIZER_MODES[(cur_i + 1) % len(VISUALIZER_MODES)]
+            self.save_current_config()
+            self.set_toast(f"Visualizer: {VISUALIZER_LABELS[self.visualizer_mode]}")
+
+    def start_ambient_preset(self, preset_id, notify=True):
+        preset = next((p for p in AMBIENT_PRESETS if p["id"] == preset_id), None)
+        if not preset: return
+        self.ambient_preset = preset_id
+        save_config({"ambient_preset": preset_id, "ambient_volume": self.ambient_volume})
+        self.audio.play_ambient(preset["url"], self.ambient_volume)
+        if notify:
+            if not preset["url"]:
+                self.set_toast("Ambient FX: Muted")
+            else:
+                self.set_toast(f"Ambient FX: {preset['name']}")
+
+    def toggle_ambient(self):
+        with self.lock:
+            if self.ambient_preset != "none":
+                self.start_ambient_preset("none")
+            else:
+                self.start_ambient_preset("deep_rain")
+
+    def adjust_ambient_volume(self, delta):
+        with self.lock:
+            new_v = max(0, min(100, int(self.ambient_volume + delta)))
+            self.ambient_volume = new_v
+            self.audio.set_ambient_volume(new_v)
+            save_config({"ambient_volume": new_v})
+            self.set_toast(f"Ambient Vol: {new_v}%")
+
+    def toggle_recording(self):
+        with self.lock:
+            st = self.stations[self.idx]
+            ok, msg, path = self.audio.toggle_recording(st["name"], st["url"], getattr(self, "current_track", ""))
+            self.set_toast(msg, duration=3.0)
+
+    def toggle_favorite(self):
+        with self.lock:
+            filtered = self.get_filtered_stations_unlocked()
+            if not filtered or self.cursor_idx >= len(filtered): return
+            st_name = filtered[self.cursor_idx][1]["name"]
+            if st_name in self.favorites:
+                self.favorites.remove(st_name)
+                self.set_toast(f"Removed from Favs: {st_name}")
+            else:
+                self.favorites.add(st_name)
+                self.set_toast(f"Added to Favs: {st_name}")
+            save_favorites(self.favorites)
+
+    def select_section(self, section_key):
+        with self.lock:
+            keys = [it["key"] for it in ALL_SIDEBAR_ITEMS]
+            if section_key in keys:
+                self.section_key = section_key
+                self.sidebar_idx = keys.index(section_key)
+                self.cursor_idx = 0
+                self.save_current_config()
+                it = self.get_current_sidebar_item()
+                self.set_toast(f"Section: {it['label']}")
+
+    def save_current_config(self, force=False):
+        try:
+            self._cfg_dirty = True
+            t_now = time.time()
+            if not force and (t_now - self._last_cfg_save < 2.0):
+                return
+            cfg = {
+                "theme": self.theme_name,
+                "section": self.section_key,
+                "visualizer": self.visualizer_mode,
+                "ambient_preset": self.ambient_preset,
+                "ambient_volume": self.ambient_volume,
+                "cava_sensitivity": self.cava_sensitivity,
+                "master_volume": self.volume,
+                "nsfw_enabled": self.nsfw_enabled,
+                "show_welcome": getattr(self, "show_welcome", True),
+                "deck_style": getattr(self, "deck_style", "vinyl"),
+                "framerate": getattr(self, "framerate", 144),
+                "shimmer_effect": getattr(self, "shimmer_effect", "cava_sync"),
+                "notifications_enabled": self.notify_mgr.is_enabled() if hasattr(self, "notify_mgr") else True,
+                "last_station_url": self.stations[self.idx]["url"] if (self.stations and self.idx < len(self.stations)) else "",
+                "last_station_name": self.stations[self.idx]["name"] if (self.stations and self.idx < len(self.stations)) else ""
+            }
+            save_config(cfg)
+            self._cfg_dirty = False
+            self._last_cfg_save = t_now
+        except Exception:
+            pass
+
+    def toggle_notifications(self):
+        with self.lock:
+            new_state = not self.notify_mgr.is_enabled()
+            self.notify_mgr.set_enabled(new_state)
+            self.save_current_config()
+            status = "ON" if new_state else "OFF"
+            self.set_toast(f"Desktop Notifications: {status}")
+
+    def cycle_framerate(self, step=1):
+        rates = [144, 120, 60, 240]
+        with self.lock:
+            cur_i = rates.index(self.framerate) if self.framerate in rates else 0
+            self.framerate = rates[(cur_i + step) % len(rates)]
+            self.cava.update_settings(self.cava_sensitivity, self.framerate)
+            self.save_current_config()
+            self.set_toast(f"Display Refresh: {self.framerate} Hz")
+
+    def cycle_deck(self):
+        with self.lock:
+            self.deck_style = "cassette" if self.deck_style == "vinyl" else "vinyl"
+            self.save_current_config()
+            lbl = "Vinyl Turntable" if self.deck_style == "vinyl" else "Cassette Master Deck"
+            self.set_toast(f"Now Playing Deck: {lbl}")
+
+    def cycle_shimmer(self):
+        with self.lock:
+            cur_i = SHIMMER_EFFECTS.index(self.shimmer_effect) if self.shimmer_effect in SHIMMER_EFFECTS else 0
+            self.shimmer_effect = SHIMMER_EFFECTS[(cur_i + 1) % len(SHIMMER_EFFECTS)]
+            self.save_current_config()
+            self.set_toast(f"Logo Shimmer: {SHIMMER_EFFECT_LABELS.get(self.shimmer_effect, self.shimmer_effect)}")
+
+    def cycle_theme(self):
+        with self.lock:
+            names = list(self.themes.keys())
+            if not names: return
+            cur = names.index(self.theme_name) if self.theme_name in names else 0
+            self.theme_name = names[(cur + 1) % len(names)]
+            self.save_current_config()
+            self.set_toast(f"Theme: {self.theme_name}")
+
+    def set_theme(self, name):
+        with self.lock:
+            if name in self.themes:
+                self.theme_name = name
+                self.save_current_config()
+                self.set_toast(f"Theme: {self.theme_name}")
+
+    def set_toast(self, msg, duration=1.8):
+        self.toast_msg = msg
+        self.toast_time = time.time() + duration
+
+    def shutdown(self):
+        with self.lock:
+            self.quit = True
+            self.save_current_config(force=True)
+            if hasattr(self, 'stats') and self.stats:
+                self.stats.flush()
+            if hasattr(self, 'cava') and self.cava:
+                self.cava.stop()
+            if hasattr(self, 'audio') and self.audio:
+                self.audio.shutdown()
+
+def metadata_loop(state: PlayerState):
+    last_rx, last_tx = get_net_bytes()
+    last_t = time.time()
+
+    while not state.quit:
+        try:
+            now = time.time()
+            dt = max(0.1, now - last_t)
+            cur_rx, cur_tx = get_net_bytes()
+
+            rx_spd = max(0, (cur_rx - last_rx) / dt)
+            tx_spd = max(0, (cur_tx - last_tx) / dt)
+            last_rx, last_tx = cur_rx, cur_tx
+            last_t = now
+
+            with state.lock:
+                state.net_down_str = f"↓ {format_speed(rx_spd)}"
+                state.net_up_str = f"↑ {format_speed(tx_spd)}"
+
+            # Periodic debounced write of dirty config
+            if getattr(state, "_cfg_dirty", False) and (now - getattr(state, "_last_cfg_save", 0.0) >= 2.0):
+                state.save_current_config(force=True)
+
+            if state.audio.player:
+                meta = state.audio.player.metadata
+                if meta:
+                    title = meta.get("icy-title") or meta.get("title")
+                    br = meta.get("icy-br")
+                    with state.lock:
+                        if br:
+                            state.stream_bitrate = f"{br} kbps"
+                        if title and title != state.current_track:
+                            state.current_track = title
+                            st = state.stations[state.idx]
+                            state.add_history_entry(title, st["name"], st["url"], st.get("genre", "Unknown"))
+                            if hasattr(state, "notify_mgr") and state.notify_mgr:
+                                state.notify_mgr.send_track_notification(title, st.get("name", ""), st.get("genre", ""), st.get("category", ""))
+        except Exception:
+            pass
+        time.sleep(0.5)