micforge 1.3.0__py3-none-any.whl

micforge/ui/theme.py

@@ -0,0 +1,42 @@
+"""Shared console + palette."""
+from __future__ import annotations
+
+import sys
+
+if sys.platform == "win32":
+    # Enable UTF-8 encoding and native Virtual Terminal (VT100) processing for Windows CMD / conhost
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+        kernel32.SetConsoleOutputCP(65001)
+        kernel32.SetConsoleCP(65001)
+        handle = kernel32.GetStdHandle(-11)  # STD_OUTPUT_HANDLE
+        mode = ctypes.c_ulong()
+        if kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            kernel32.SetConsoleMode(handle, mode.value | 0x0004)  # ENABLE_VIRTUAL_TERMINAL_PROCESSING
+    except Exception:
+        pass
+
+from rich.console import Console
+from rich.theme import Theme
+
+THEME = Theme(
+    {
+        "accent": "bold cyan",
+        "dim": "grey50",
+        "ok": "green",
+        "warn": "yellow",
+        "bad": "bold red",
+        "key": "bold black on cyan",
+    }
+)
+
+console = Console(theme=THEME, highlight=False, legacy_windows=False if sys.platform == "win32" else None)
+
+LEVEL_ICON = {"ok": "[ok]✔[/]", "warn": "[warn]![/]", "bad": "[bad]✖[/]"}

micforge/ui/tray.py

@@ -0,0 +1,276 @@
+"""System Tray Daemon for Micforge.
+
+Provides a persistent icon in the Windows taskbar with:
+* Live dynamic icon (cyan when active, gray with red slash when muted, amber when bypassed)
+* Instant mute / bypass controls
+* Presets and CoFi-Lite / Spectral model switcher
+* Quick access to Settings & Hotkeys GUI
+* Windows autostart toggle
+* Hide / Restore console window
+"""
+from __future__ import annotations
+
+import ctypes
+import logging
+import os
+import threading
+from typing import Any, Callable
+
+from PIL import Image, ImageDraw
+
+from .. import __version__
+from ..audio.engine import AudioEngine
+from ..config import AppConfig
+from ..presets import list_presets
+from ..util.autostart import is_autostart_enabled, set_autostart
+from .settings_gui import open_settings_window
+
+log = logging.getLogger("micforge.tray")
+
+
+def _safe_patch_pystray_win32() -> None:
+    """Patch pystray's ChangeWindowMessageFilterEx to gracefully handle Windows UIPI security restrictions."""
+    if os.name != "nt":
+        return
+    try:
+        import pystray._util.win32 as w32util
+
+        orig = getattr(w32util, "ChangeWindowMessageFilterEx", None)
+        if orig is not None and not getattr(orig, "_micforge_patched", False):
+
+            def _safe_filter(*args, **kwargs):
+                try:
+                    return orig(*args, **kwargs)
+                except Exception:
+                    return True
+
+            _safe_filter._micforge_patched = True  # type: ignore[attr-defined]
+            w32util.ChangeWindowMessageFilterEx = _safe_filter
+    except Exception as exc:  # noqa: BLE001
+        log.debug("pystray win32 patch failed: %s", exc)
+
+
+def generate_tray_icon(state: str = "active") -> Image.Image:
+    """Procedurally draw a crisp 64x64 RGBA microphone icon."""
+    im = Image.new("RGBA", (64, 64), (0, 0, 0, 0))
+    d = ImageDraw.Draw(im)
+
+    if state == "muted":
+        color = (150, 150, 155)
+    elif state == "bypass":
+        color = (250, 204, 21)  # Amber
+    else:
+        color = (6, 182, 212)  # Cyan
+
+    # 1. Microphone capsule
+    d.rounded_rectangle([24, 12, 40, 36], radius=7, fill=color)
+
+    # 2. Cradle arc
+    d.arc([16, 20, 48, 44], start=0, end=180, fill=color, width=3)
+
+    # 3. Base stem and foot
+    d.line([32, 44, 32, 54], fill=color, width=3)
+    d.line([20, 54, 44, 54], fill=color, width=3)
+
+    # 4. If muted, add prominent red diagonal slash and indicator dot
+    if state == "muted":
+        d.line([14, 14, 50, 50], fill=(239, 68, 68), width=5)
+        d.ellipse([44, 10, 56, 22], fill=(239, 68, 68))
+
+    return im
+
+
+class SystemTrayDaemon:
+    """Manages the Windows system tray lifecycle, icon updates, and menu actions."""
+
+    def __init__(
+        self,
+        app: AppConfig,
+        engine: AudioEngine,
+        on_exit: Callable[[], None],
+        on_switch_preset: Callable[[str], None] | None = None,
+        on_switch_model: Callable[[str], None] | None = None,
+    ) -> None:
+        self.app = app
+        self.engine = engine
+        self.on_exit = on_exit
+        self.on_switch_preset = on_switch_preset
+        self.on_switch_model = on_switch_model
+
+        self._icon: Any = None
+        self._thread: threading.Thread | None = None
+        self._running = False
+        self._console_visible = True
+
+    @property
+    def current_state(self) -> str:
+        if self.engine.muted:
+            return "muted"
+        if self.engine.bypass:
+            return "bypass"
+        return "active"
+
+    def update_icon(self) -> None:
+        """Refresh tray icon image to reflect current mute/bypass state."""
+        if self._icon is not None:
+            try:
+                self._icon.icon = generate_tray_icon(self.current_state)
+                self._icon.title = f"Micforge v{__version__} ({self.current_state.capitalize()})"
+            except Exception as exc:  # noqa: BLE001
+                log.debug("Tray icon refresh failed: %s", exc)
+
+    def start(self) -> None:
+        """Start the system tray icon in a dedicated daemon thread."""
+        try:
+            import pystray
+        except ImportError:
+            log.warning("pystray not installed; running without system tray.")
+            return
+
+        self._running = True
+        self._thread = threading.Thread(target=self._run_tray, daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._running = False
+        if self._icon is not None:
+            try:
+                self._icon.stop()
+            except Exception:  # noqa: BLE001
+                pass
+            self._icon = None
+
+    def toggle_console(self) -> None:
+        """Toggle console window visibility on Windows."""
+        if os.name != "nt":
+            return
+        try:
+            kernel32 = ctypes.windll.kernel32
+            user32 = ctypes.windll.user32
+            hwnd = kernel32.GetConsoleWindow()
+            if hwnd:
+                self._console_visible = not self._console_visible
+                # SW_HIDE = 0, SW_SHOW = 5
+                user32.ShowWindow(hwnd, 5 if self._console_visible else 0)
+        except Exception as exc:  # noqa: BLE001
+            log.debug("Console toggle failed: %s", exc)
+
+    def _build_menu(self):
+        import pystray
+
+        # Preset submenu
+        preset_items = []
+        for p in list_presets():
+            p_name = p.name
+
+            def _make_preset_cb(name: str):
+                return lambda item: self._on_preset_click(name)
+
+            def _make_preset_checked(name: str):
+                return lambda item: self.app.preset == name
+
+            preset_items.append(
+                pystray.MenuItem(
+                    p_name,
+                    _make_preset_cb(p_name),
+                    checked=_make_preset_checked(p_name),
+                    radio=True,
+                )
+            )
+
+        # Model submenu
+        def _set_cofilite(item):
+            if self.on_switch_model:
+                self.on_switch_model("cofilite")
+
+        def _set_spectral(item):
+            if self.on_switch_model:
+                self.on_switch_model("spectral")
+
+        def _is_cofilite(item):
+            dn = self.engine.chain.stage("denoise")
+            return getattr(dn, "name", "") == "denoise" and "cofilite" in getattr(dn, "model_name", "").lower()
+
+        def _is_spectral(item):
+            dn = self.engine.chain.stage("denoise")
+            return getattr(dn, "name", "") == "denoise" and "cofilite" not in getattr(dn, "model_name", "").lower()
+
+        model_items = [
+            pystray.MenuItem("CoFi-Lite Neural (High Quality, <70ms)", _set_cofilite, checked=_is_cofilite, radio=True),
+            pystray.MenuItem("Spectral Wiener (Ultra-Low Latency, <48ms)", _set_spectral, checked=_is_spectral, radio=True),
+        ]
+
+        # Top level menu
+        menu = pystray.Menu(
+            pystray.MenuItem(
+                lambda item: "✔ Muted" if self.engine.muted else "Mute Mic",
+                self._on_toggle_mute,
+                checked=lambda item: self.engine.muted,
+            ),
+            pystray.MenuItem(
+                lambda item: "✔ Bypass On" if self.engine.bypass else "Bypass DSP",
+                self._on_toggle_bypass,
+                checked=lambda item: self.engine.bypass,
+            ),
+            pystray.Menu.SEPARATOR,
+            pystray.MenuItem("Presets", pystray.Menu(*preset_items)),
+            pystray.MenuItem("Noise Suppression Model", pystray.Menu(*model_items)),
+            pystray.Menu.SEPARATOR,
+            pystray.MenuItem("Settings & Hotkeys...", lambda item: open_settings_window(self.app, self._on_settings_applied)),
+            pystray.MenuItem(
+                "Start on Windows Boot",
+                self._on_toggle_autostart,
+                checked=lambda item: is_autostart_enabled(),
+            ),
+            pystray.MenuItem(
+                lambda item: "Hide Dashboard" if self._console_visible else "Show Dashboard",
+                lambda item: self.toggle_console(),
+            ),
+            pystray.Menu.SEPARATOR,
+            pystray.MenuItem("Exit Micforge", lambda item: self.on_exit()),
+        )
+        return menu
+
+    def _run_tray(self) -> None:
+        _safe_patch_pystray_win32()
+        import pystray
+
+        initial_image = generate_tray_icon(self.current_state)
+        self._icon = pystray.Icon(
+            "micforge",
+            initial_image,
+            title=f"Micforge v{__version__} ({self.current_state.capitalize()})",
+            menu=self._build_menu(),
+        )
+        try:
+            self._icon.run()
+        except Exception as exc:  # noqa: BLE001
+            log.warning("System tray run exited: %s", exc)
+
+    def _on_toggle_mute(self, item=None) -> None:
+        self.engine.toggle_mute()
+        self.update_icon()
+
+    def _on_toggle_bypass(self, item=None) -> None:
+        self.engine.toggle_bypass()
+        self.update_icon()
+
+    def _on_preset_click(self, preset_name: str) -> None:
+        self.app.preset = preset_name
+        try:
+            self.app.save()
+        except Exception:  # noqa: BLE001
+            pass
+        if self.on_switch_preset is not None:
+            self.on_switch_preset(preset_name)
+
+    def _on_toggle_autostart(self, item=None) -> None:
+        current = is_autostart_enabled()
+        set_autostart(not current)
+
+    def _on_settings_applied(self, updated_app: AppConfig) -> None:
+        log.info("Settings updated via GUI")
+        self.app = updated_app
+        self.engine.cues.set_enabled(updated_app.hotkeys.play_cues)
+        self.engine.cues.set_volume(updated_app.hotkeys.cue_volume)
+

micforge/ui/tuning.py

@@ -0,0 +1,138 @@
+"""Simple and Advanced tuning schema and macro-to-DSP mappings."""
+from __future__ import annotations
+
+import copy
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+from ..config import ChainConfig, CompressorConfig, DenoiseConfig, EQBand, GateConfig, LimiterConfig
+from ..presets import BUILTIN, get_preset
+
+
+@dataclass
+class MacroKnobs:
+    """Four intuitive macro knobs for casual/streamer tuning (0-100 scale)."""
+    clarity: float = 50.0        # Presence, air, sibilance control, mud cut
+    warmth: float = 50.0         # Chest resonance, proximity body, low-end richness
+    noise_removal: float = 65.0  # AI suppression depth & gate aggressiveness
+    room_cleanup: float = 40.0   # Room flutter dereverberation & rumble isolation
+
+    def __post_init__(self) -> None:
+        self.clamp()
+
+    def clamp(self) -> None:
+        self.clarity = float(max(0.0, min(100.0, self.clarity)))
+        self.warmth = float(max(0.0, min(100.0, self.warmth)))
+        self.noise_removal = float(max(0.0, min(100.0, self.noise_removal)))
+        self.room_cleanup = float(max(0.0, min(100.0, self.room_cleanup)))
+
+    def to_dict(self) -> dict[str, float]:
+        return asdict(self)
+
+
+def macro_to_chain_config(macros: MacroKnobs, base_preset_name: str | ChainConfig = "discord") -> ChainConfig:
+    """Deterministically map 4 macro knobs (0-100) onto a full 11-stage DSP ChainConfig."""
+    macros.clamp()
+
+    # Always clone a fresh instance so built-ins are never mutated
+    if isinstance(base_preset_name, ChainConfig):
+        cfg = copy.deepcopy(base_preset_name)
+    else:
+        cfg = copy.deepcopy(get_preset(base_preset_name))
+
+    # 1. CLARITY (0 - 100)
+    # Scales: presence peak (+0 to +6 dB at 3200 Hz), air shelf (+0 to +5 dB at 9000 Hz), mud cut (-0 to -4.5 dB at 280 Hz)
+    clarity_norm = macros.clarity / 100.0
+    presence_gain = 1.0 + (clarity_norm * 4.5)     # 1.0 -> 5.5 dB
+    air_gain = 1.0 + (clarity_norm * 4.0)          # 1.0 -> 5.0 dB
+    mud_cut = -1.0 - (clarity_norm * 3.5)          # -1.0 -> -4.5 dB
+
+    cfg.eq = [
+        EQBand("peak", 280, mud_cut, 1.1),
+        EQBand("peak", 3200, presence_gain, 0.9),
+        EQBand("highshelf", 9000, air_gain, 0.7),
+    ]
+    # Sibilance taming scales with clarity to prevent harshness
+    if clarity_norm > 0.3:
+        cfg.deesser.enabled = True
+        cfg.deesser.threshold_db = -28.0 - (clarity_norm * 8.0)  # -30.4 to -36.0 dBFS
+        cfg.deesser.ratio = 2.5 + (clarity_norm * 2.0)
+    else:
+        cfg.deesser.enabled = False
+
+    # 2. WARMTH (0 - 100)
+    # Scales: proximity effect amount, saturation warmth, chest resonance
+    warmth_norm = macros.warmth / 100.0
+    if warmth_norm > 0.05:
+        cfg.proximity.enabled = True
+        cfg.proximity.amount = float(np_clip(warmth_norm * 1.1, 0.0, 1.0))
+        cfg.proximity.warmth = float(np_clip(warmth_norm * 0.75, 0.0, 0.85))
+        cfg.proximity.body_hz = 105.0 + (warmth_norm * 35.0)  # 105 -> 140 Hz
+        cfg.proximity.mud_cleanup = float(np_clip(0.3 + clarity_norm * 0.4, 0.0, 1.0))
+    else:
+        cfg.proximity.enabled = False
+
+    # 3. NOISE REMOVAL (0 - 100)
+    # Scales: AI suppression strength (0 to 1.0) and gate threshold
+    noise_norm = macros.noise_removal / 100.0
+    cfg.denoise.enabled = noise_norm > 0.05
+    cfg.denoise.strength = float(np_clip(noise_norm, 0.0, 1.0))
+    cfg.denoise.max_reduction_db = 14.0 + (noise_norm * 20.0)  # 14 -> 34 dB
+
+    if noise_norm > 0.2:
+        cfg.gate.enabled = True
+        cfg.gate.threshold_db = -54.0 + (noise_norm * 18.0)    # -50.4 -> -36.0 dBFS
+        cfg.gate.range_db = 15.0 + (noise_norm * 20.0)         # 19 -> 35 dB
+    else:
+        cfg.gate.enabled = False
+
+    # 4. ROOM CLEANUP (0 - 100)
+    # Scales: room de-verb amount and highpass rumble filter
+    room_norm = macros.room_cleanup / 100.0
+    if room_norm > 0.08:
+        cfg.deverb.enabled = True
+        cfg.deverb.amount = float(np_clip(room_norm * 0.9, 0.0, 0.85))
+        cfg.deverb.room_decay = 0.25 + (room_norm * 0.5)       # 0.29 -> 0.75 s
+    else:
+        cfg.deverb.enabled = False
+
+    cfg.highpass_hz = int(75 + (room_norm * 35))              # 75 -> 110 Hz
+
+    cfg.validate()
+    return cfg
+
+
+def chain_config_to_macro(cfg: ChainConfig) -> MacroKnobs:
+    """Project a full DSP ChainConfig back into 4 approximate macro knob values (0-100)."""
+    # 1. Clarity estimate from EQ presence and air
+    eq_gains = [b.gain_db for b in cfg.eq if b.gain_db > 0]
+    clarity = 50.0
+    if eq_gains:
+        clarity = float(np_clip(np_mean(eq_gains) * 15.0, 0.0, 100.0))
+
+    # 2. Warmth estimate from proximity
+    warmth = 0.0
+    if cfg.proximity.enabled:
+        warmth = float(np_clip(cfg.proximity.amount * 100.0, 0.0, 100.0))
+
+    # 3. Noise removal estimate
+    noise = 0.0
+    if cfg.denoise.enabled:
+        noise = float(np_clip(cfg.denoise.strength * 100.0, 0.0, 100.0))
+
+    # 4. Room cleanup estimate
+    room = 0.0
+    if cfg.deverb.enabled:
+        room = float(np_clip(cfg.deverb.amount * 115.0, 0.0, 100.0))
+
+    knobs = MacroKnobs(clarity=clarity, warmth=warmth, noise_removal=noise, room_cleanup=room)
+    knobs.clamp()
+    return knobs
+
+
+def np_clip(v: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, v))
+
+
+def np_mean(arr: list[float]) -> float:
+    return sum(arr) / len(arr) if arr else 0.0

micforge/ui/widgets.py

@@ -0,0 +1,109 @@
+"""Pure rendering helpers: meters, spectrum columns, bars. No I/O, trivially testable."""
+from __future__ import annotations
+
+import math
+
+import numpy as np
+from rich.text import Text
+
+BLOCKS = " ▁▂▃▄▅▆▇█"
+
+
+def _clamp(v: float, lo: float = 0.0, hi: float = 1.0) -> float:
+    return lo if v < lo else hi if v > hi else v
+
+
+def level_style(db: float) -> str:
+    if db >= -6.0:
+        return "bold red"
+    if db >= -18.0:
+        return "yellow"
+    return "green"
+
+
+def level_bar(peak_db: float, hold_db: float, width: int, lo: float = -60.0, hi: float = 0.0) -> Text:
+    width = max(8, width)
+    filled = int(round(_clamp((peak_db - lo) / (hi - lo)) * width))
+    hold_pos = int(round(_clamp((hold_db - lo) / (hi - lo)) * width)) - 1
+    t = Text()
+
+    curr_char = ""
+    curr_style = ""
+    curr_count = 0
+
+    def flush():
+        nonlocal curr_char, curr_style, curr_count
+        if curr_count > 0:
+            t.append(curr_char * curr_count, style=curr_style)
+            curr_count = 0
+
+    for i in range(width):
+        cell_db = lo + (i + 0.5) / width * (hi - lo)
+        if i == hold_pos and hold_db > lo:
+            ch = "┃"
+            st = level_style(hold_db)
+        elif i < filled:
+            ch = "█"
+            st = level_style(cell_db)
+        else:
+            ch = "·"
+            st = "grey23"
+
+        if ch == curr_char and st == curr_style:
+            curr_count += 1
+        else:
+            flush()
+            curr_char = ch
+            curr_style = st
+            curr_count = 1
+    flush()
+    return t
+
+
+def reduction_bar(db: float, width: int, max_db: float = 24.0, style: str = "cyan") -> Text:
+    filled = int(round(_clamp(db / max_db) * width))
+    t = Text()
+    t.append("█" * filled, style=style)
+    t.append("·" * (width - filled), style="grey23")
+    return t
+
+
+def load_bar(frac: float, width: int) -> Text:
+    frac = _clamp(frac)
+    style = "green" if frac < 0.5 else "yellow" if frac < 0.8 else "bold red"
+    filled = int(round(frac * width))
+    t = Text()
+    t.append("█" * filled, style=style)
+    t.append("·" * (width - filled), style="grey23")
+    return t
+
+
+def spectrum_rows(levels_db: np.ndarray, height: int, rep: int = 1, lo: float = -95.0, hi: float = -35.0,
+                  style: str = "green") -> list[Text]:
+    """Multi-row bar spectrum using eighth-block characters. Row 0 is the top."""
+    norm = np.clip((np.asarray(levels_db, dtype=float) - lo) / (hi - lo), 0.0, 1.0)
+    eighths = norm * height * 8.0
+    rows = []
+    for r in range(height - 1, -1, -1):
+        chars = []
+        for e in eighths:
+            cell = int(round(_clamp(e - r * 8.0, 0.0, 8.0)))
+            chars.append(BLOCKS[cell] * rep)
+        rows.append(Text("".join(chars), style=style))
+    return rows
+
+
+def freq_axis(n_bands: int, rep: int, f_lo: float, f_hi: float) -> Text:
+    width = n_bands * rep
+    chars = [" "] * width
+    for f, label in ((100, "100"), (1000, "1k"), (10000, "10k")):
+        if f_lo < f < f_hi:
+            pos = int(n_bands * math.log(f / f_lo) / math.log(f_hi / f_lo) * rep)
+            for j, c in enumerate(label):
+                if 0 <= pos + j < width:
+                    chars[pos + j] = c
+    return Text("".join(chars), style="grey50")
+
+
+def fmt_db(db: float) -> str:
+    return " -inf" if db <= -119.0 else f"{db:6.1f}"

micforge/util/autostart.py

@@ -0,0 +1,56 @@
+"""Windows Registry Run key helper for starting Micforge on boot."""
+from __future__ import annotations
+
+import logging
+import os
+import sys
+
+log = logging.getLogger("micforge.autostart")
+
+RUN_KEY = r"Software\Microsoft\Windows\CurrentVersion\Run"
+APP_NAME = "Micforge"
+
+
+def is_autostart_enabled() -> bool:
+    """Return True if Micforge is registered in HKCU Run key."""
+    if os.name != "nt":
+        return False
+    try:
+        import winreg
+
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_KEY, 0, winreg.KEY_READ) as key:
+            val, _ = winreg.QueryValueEx(key, APP_NAME)
+            return bool(val)
+    except OSError:
+        return False
+
+
+def set_autostart(enabled: bool) -> bool:
+    """Enable or disable Micforge auto-start on Windows user login."""
+    if os.name != "nt":
+        return False
+    try:
+        import winreg
+
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_KEY, 0, winreg.KEY_SET_VALUE) as key:
+            if enabled:
+                # Use pythonw if running via python interpreter to avoid opening a blank console
+                py_exe = sys.executable
+                if "python.exe" in py_exe.lower():
+                    pyw = py_exe.lower().replace("python.exe", "pythonw.exe")
+                    if os.path.exists(pyw):
+                        py_exe = pyw
+                cmd = f'"{py_exe}" -m micforge.cli run --tray'
+                winreg.SetValueEx(key, APP_NAME, 0, winreg.REG_SZ, cmd)
+                log.info("Registered Micforge autostart command: %s", cmd)
+            else:
+                try:
+                    winreg.DeleteValue(key, APP_NAME)
+                    log.info("Removed Micforge autostart command")
+                except FileNotFoundError:
+                    pass
+        return True
+    except OSError as exc:
+        log.warning("Could not update Windows registry autostart key: %s", exc)
+        return False
+