lushapp 2.0.0

package/src/lush/net.py

@@ -0,0 +1,27 @@
+# LUSH - Network Bandwidth Monitor
+import time
+
+def get_net_bytes():
+    rx = 0
+    tx = 0
+    try:
+        with open('/proc/net/dev') as f:
+            for line in f.readlines()[2:]:
+                parts = line.split(':')
+                if len(parts) == 2:
+                    iface = parts[0].strip()
+                    if iface != 'lo':
+                        cols = parts[1].split()
+                        rx += int(cols[0])
+                        tx += int(cols[8])
+    except Exception:
+        pass
+    return rx, tx
+
+def format_speed(bps: float) -> str:
+    if bps < 1024:
+        return f"{bps:.0f} B/s"
+    elif bps < 1024 * 1024:
+        return f"{bps/1024:.1f} KB/s"
+    else:
+        return f"{bps/(1024*1024):.2f} MB/s"

package/src/lush/notify.py

@@ -0,0 +1,154 @@
+# LUSH - Cross-Platform Desktop Track Notifications
+import platform
+import subprocess
+import threading
+import shutil
+import time
+import re
+from typing import Optional
+
+class NotificationManager:
+    """
+    Lightweight, thread-safe desktop notification manager supporting 
+    Linux (notify-send), macOS (osascript), and Windows (PowerShell Toast).
+    
+    Includes smart filtering to ignore soundscapes, ambient noise, station bumpers,
+    and duplicate metadata events.
+    """
+
+    def __init__(self, enabled: bool = True):
+        self.enabled = enabled
+        self._last_track = ""
+        self._last_time = 0.0
+        self._lock = threading.Lock()
+        self._system = platform.system()
+
+    def set_enabled(self, enabled: bool):
+        with self._lock:
+            self.enabled = enabled
+
+    def is_enabled(self) -> bool:
+        with self._lock:
+            return self.enabled
+
+    @staticmethod
+    def should_suppress(track_title: str, station_name: str, genre: str = "", category: str = "") -> bool:
+        """
+        Smart filter heuristic to determine if a notification should be suppressed.
+        Mutes soundscapes, ambient overlays, station identifiers, and promotional bumpers.
+        """
+        if not track_title or not track_title.strip():
+            return True
+
+        clean_track = track_title.strip().lower()
+        clean_station = station_name.strip().lower() if station_name else ""
+        clean_genre = genre.strip().lower() if genre else ""
+        clean_cat = category.strip().lower() if category else ""
+
+        # 1. Ignore pure soundscapes and ambient FX
+        if clean_cat in ("soundscape", "ambient", "fx", "nature"):
+            return True
+        if any(amb in clean_genre for amb in ["ambient", "soundscape", "rain", "spa", "drone", "whitenoise", "sleep"]):
+            return True
+
+        # 2. Ignore when track title is identical to station name (common on radio startup)
+        if clean_station and (clean_track == clean_station or clean_track in clean_station):
+            return True
+
+        # 3. Ignore common radio bumpers and commercial placeholders
+        bumper_phrases = [
+            "station will continue",
+            "this break",
+            "commercial break",
+            "after this",
+            "stream offline",
+            "connecting",
+            "buffering",
+            "continuous music",
+            "music mix",
+            "various artists"
+        ]
+        if any(phrase in clean_track for phrase in bumper_phrases):
+            return True
+
+        # 4. Ignore pure soundscape track names
+        soundscape_names = ["deep rain", "pink rain", "ocean waves", "campfire", "space drone", "soma drone"]
+        if any(s_name in clean_track for s_name in soundscape_names):
+            return True
+
+        return False
+
+    def send_track_notification(self, track_title: str, station_name: str, genre: str = "", category: str = ""):
+        """Dispatches a non-blocking desktop notification in a daemon thread."""
+        with self._lock:
+            if not self.enabled:
+                return
+
+            if self.should_suppress(track_title, station_name, genre, category):
+                return
+
+            now = time.time()
+            clean = track_title.strip()
+            # Debounce duplicate notifications within 20 seconds
+            if clean == self._last_track and (now - self._last_time < 20.0):
+                return
+
+            self._last_track = clean
+            self._last_time = now
+
+        threading.Thread(
+            target=self._dispatch,
+            args=(clean, station_name.strip() if station_name else "", genre.strip() if genre else ""),
+            daemon=True
+        ).start()
+
+    def _dispatch(self, track: str, station: str, genre: str):
+        """Worker thread to run native OS notification command with strict timeout."""
+        app_title = "LUSH ♫"
+        body = f"{track}"
+        if station:
+            body += f"\n[{station}]"
+
+        try:
+            if self._system == "Linux":
+                self._dispatch_linux(app_title, body)
+            elif self._system == "Darwin":
+                self._dispatch_macos(app_title, track, station)
+            elif self._system == "Windows":
+                self._dispatch_windows(app_title, body)
+        except Exception:
+            pass
+
+    @staticmethod
+    def _dispatch_linux(title: str, body: str):
+        if shutil.which("notify-send"):
+            subprocess.run(
+                ["notify-send", "-a", "LUSH", "-i", "audio-headphones", title, body],
+                capture_output=True,
+                timeout=2.0
+            )
+
+    @staticmethod
+    def _dispatch_macos(title: str, track: str, station: str):
+        subtitle = f"[{station}]" if station else "Now Playing"
+        # Escape quotes for AppleScript
+        safe_track = track.replace('"', '\\"')
+        safe_sub = subtitle.replace('"', '\\"')
+        script = f'display notification "{safe_track}" with title "{title}" subtitle "{safe_sub}"'
+        subprocess.run(["osascript", "-e", script], capture_output=True, timeout=2.0)
+
+    @staticmethod
+    def _dispatch_windows(title: str, body: str):
+        safe_title = title.replace('"', '`"')
+        safe_body = body.replace('"', '`"')
+        ps_script = f'''
+        [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null
+        $template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
+        $textNodes = $template.GetElementsByTagName("text")
+        $textNodes.Item(0).AppendChild($template.CreateTextNode("{safe_title} - Now Playing")) > $null
+        $textNodes.Item(1).AppendChild($template.CreateTextNode("{safe_body}")) > $null
+        $notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("LUSH")
+        $notification = [Windows.UI.Notifications.ToastNotification]::new($template)
+        $notifier.Show($notification)
+        '''
+        subprocess.run(["powershell", "-NoProfile", "-Command", ps_script], capture_output=True, timeout=3.0)

package/src/lush/search.py

@@ -0,0 +1,185 @@
+# LUSH - In-Memory Fuzzy Search & Relevance Ranking Engine
+import re
+import difflib
+from typing import List, Tuple, Dict, Any
+
+STOPWORDS = {
+    'the', 'a', 'an', 'and', 'or', 'in', 'on', 'of', 'one', 'that', 'this',
+    'to', 'for', 'with', 'by', 'at', 'from', 'is', 'it', 'station', 'radio'
+}
+
+def _extract_tokens(text: str) -> List[str]:
+    """
+    Extracts search tokens from text, handling whitespace, punctuation, 
+    CamelCase word splitting, and compound 2-word combinations (e.g. 'Anne-Marie' -> 'annemarie').
+    """
+    raw_words = re.findall(r'[a-zA-Z0-9]+', text)
+    tokens = set()
+    for w in raw_words:
+        tokens.add(w.lower())
+        camel_parts = re.findall(r'[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\d|\W|$)|\d+', w)
+        if len(camel_parts) > 1:
+            for cp in camel_parts:
+                tokens.add(cp.lower())
+
+    for i in range(len(raw_words) - 1):
+        combo = (raw_words[i] + raw_words[i+1]).lower()
+        if len(combo) <= 20:
+            tokens.add(combo)
+
+    return list(tokens)
+
+
+def _token_similarity(q_tok: str, cand_tok: str) -> float:
+    """
+    Computes token-level similarity between query word and candidate word.
+    Handles exact, prefix, substring, SequenceMatcher ratio, sub-sequence acronyms,
+    and conversational synonyms (e.g. 'sister' <-> 'sis').
+    """
+    if not q_tok or not cand_tok:
+        return 0.0
+    if q_tok == cand_tok:
+        return 1.0
+    if cand_tok.startswith(q_tok):
+        return 0.95
+    if q_tok in cand_tok:
+        return 0.88
+    if len(cand_tok) >= 3 and cand_tok in q_tok:
+        return 0.50 + 0.35 * (len(cand_tok) / len(q_tok))
+
+    # Common colloquial abbreviations
+    if (q_tok == 'sister' and cand_tok == 'sis') or (q_tok == 'sis' and cand_tok == 'sister'):
+        return 0.95
+
+    r = difflib.SequenceMatcher(None, q_tok, cand_tok).ratio()
+
+    # If first letter differs on short words, apply typo penalty
+    if q_tok[0] != cand_tok[0]:
+        if len(q_tok) <= 5 or len(cand_tok) <= 5:
+            r = r * 0.75
+
+    # Subsequence ratio within token (e.g. 'swft' in 'swift', 'sntra' in 'sinatra')
+    if len(q_tok) >= 3 and len(cand_tok) >= len(q_tok):
+        sub_idx = 0
+        for ch in cand_tok:
+            if ch == q_tok[sub_idx]:
+                sub_idx += 1
+                if sub_idx == len(q_tok):
+                    sub_r = len(q_tok) / len(cand_tok)
+                    if q_tok[0] == cand_tok[0]:
+                        return max(r, 0.75 + 0.25 * sub_r)
+                    else:
+                        return max(r, 0.60 + 0.20 * sub_r)
+    return r
+
+
+def score_station_match(query: str, station: Dict[str, Any]) -> float:
+    """
+    Computes an in-memory fuzzy relevance score (0.0 to 100.0) between a user query
+    and a station's metadata (name, genre, category, description).
+    """
+    if not query:
+        return 1.0
+
+    q = query.strip().lower()
+    if not q:
+        return 1.0
+
+    name = station.get("name", "").lower()
+    genre = station.get("genre", "").lower()
+    cat = station.get("category", "").lower()
+    full_text = f"{name} {genre} {cat}"
+
+    # 1. Exact string match
+    if q == name:
+        return 100.0
+
+    # 2. Exact prefix match on name
+    if name.startswith(q):
+        return 95.0 - (len(name) - len(q)) * 0.02
+
+    # 3. Whole query substring in name
+    if q in name:
+        return 90.0
+
+    # 4. Token-to-Token Multi-Word Alignment
+    q_all_words = [w.lower() for w in re.findall(r'[a-zA-Z0-9]+', q)]
+    q_words = [w for w in q_all_words if w not in STOPWORDS]
+    if not q_words:
+        q_words = q_all_words
+
+    name_tokens = _extract_tokens(station.get("name", ""))
+    full_tokens = _extract_tokens(full_text)
+
+    if q_words:
+        # Match against name tokens
+        token_scores = []
+        for qw in q_words:
+            best_t = 0.0
+            for nt in name_tokens:
+                s = _token_similarity(qw, nt)
+                if s > best_t:
+                    best_t = s
+            token_scores.append(best_t)
+
+        avg_score = sum(token_scores) / len(token_scores)
+        min_score = min(token_scores)
+
+        if min_score >= 0.55 or (len(q_words) > 1 and avg_score >= 0.70 and min_score >= 0.40):
+            return 60.0 + avg_score * 30.0
+
+        # Match against full metadata (name + genre + category)
+        full_token_scores = []
+        for qw in q_words:
+            best_ft = 0.0
+            for ft in full_tokens:
+                s = _token_similarity(qw, ft)
+                if s > best_ft:
+                    best_ft = s
+            full_token_scores.append(best_ft)
+
+        avg_full = sum(full_token_scores) / len(full_token_scores)
+        min_full = min(full_token_scores)
+        if min_full >= 0.55 or (len(q_words) > 1 and avg_full >= 0.70 and min_full >= 0.40):
+            return 45.0 + avg_full * 25.0
+
+    # 5. Full-string character stream alignment (handles squished names)
+    clean_q = "".join(q_words)
+    clean_name = "".join(name_tokens)
+    if clean_q and clean_name:
+        if clean_q == clean_name:
+            return 93.0
+        if clean_name.startswith(clean_q):
+            return 88.0
+        if clean_q in clean_name:
+            return 83.0
+        full_r = difflib.SequenceMatcher(None, clean_q, clean_name).ratio()
+        if full_r >= 0.65:
+            return 50.0 + full_r * 30.0
+
+    # 6. Acronym / Initialism
+    if len(q_words) == 1 and len(q) >= 2:
+        initials = "".join(w[0] for w in name_tokens if w)
+        if q == initials or q in initials:
+            return 75.0
+
+    return 0.0
+
+
+def fuzzy_filter_stations(indexed_stations: List[Tuple[int, Dict[str, Any]]], query: str) -> List[Tuple[int, Dict[str, Any]]]:
+    """
+    Filters and sorts a list of (global_index, station_dict) tuples using 
+    in-memory fuzzy scoring. Preserves original order if query is empty.
+    """
+    if not query or not query.strip():
+        return indexed_stations
+
+    scored_items = []
+    for orig_idx, st in indexed_stations:
+        score = score_station_match(query, st)
+        if score > 0.0:
+            scored_items.append((score, orig_idx, st))
+
+    # Sort primarily by score (descending), secondarily by original order
+    scored_items.sort(key=lambda item: (-item[0], item[1]))
+    return [(orig_idx, st) for _, orig_idx, st in scored_items]