wrkmon 1.0.0__py3-none-any.whl

wrkmon/ui/widgets/player_bar.py

@@ -0,0 +1,115 @@
+"""Player bar widget - persistent playback controls at the bottom."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.reactive import reactive
+from textual.widgets import Static, ProgressBar
+
+from wrkmon.utils.stealth import get_stealth
+
+
+class PlayerBar(Static):
+    """Persistent player bar showing current track and playback controls."""
+
+    # Reactive state
+    title = reactive("No process running")
+    is_playing = reactive(False)
+    position = reactive(0.0)
+    duration = reactive(0.0)
+    volume = reactive(80)
+    status_text = reactive("")  # For showing errors/buffering
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="player-bar-inner"):
+            # Now playing row
+            with Horizontal(id="now-playing-row"):
+                yield Static("NOW", id="now-label", classes="label")
+                yield Static(self._get_status_icon(), id="play-status")
+                yield Static(self.title, id="track-title")
+
+            # Progress row
+            with Horizontal(id="progress-row"):
+                yield Static(self._format_time(0), id="time-current")
+                yield ProgressBar(total=100, show_percentage=False, id="progress")
+                yield Static(self._format_time(0), id="time-total")
+
+            # Volume row
+            with Horizontal(id="volume-row"):
+                yield Static("VOL", id="vol-label", classes="label")
+                yield ProgressBar(total=100, show_percentage=False, id="volume")
+                yield Static(f"{self.volume}%", id="vol-value")
+
+    def _get_status_icon(self) -> str:
+        return "▶" if self.is_playing else "■"
+
+    def _format_time(self, seconds: float) -> str:
+        return self._stealth.format_duration(seconds)
+
+    def _format_title(self, title: str) -> str:
+        return self._stealth.get_fake_process_name(title)
+
+    # Watchers for reactive properties
+    def watch_title(self, new_title: str) -> None:
+        """Update title display."""
+        try:
+            display_title = self._format_title(new_title) if new_title else "No process running"
+            self.query_one("#track-title", Static).update(display_title)
+        except Exception:
+            pass
+
+    def watch_is_playing(self) -> None:
+        """Update play/pause icon."""
+        try:
+            self.query_one("#play-status", Static).update(self._get_status_icon())
+        except Exception:
+            pass
+
+    def watch_position(self, new_pos: float) -> None:
+        """Update progress bar and time."""
+        try:
+            self.query_one("#time-current", Static).update(self._format_time(new_pos))
+            if self.duration > 0:
+                progress = (new_pos / self.duration) * 100
+                self.query_one("#progress", ProgressBar).update(progress=progress)
+        except Exception:
+            pass
+
+    def watch_duration(self, new_dur: float) -> None:
+        """Update total duration display."""
+        try:
+            self.query_one("#time-total", Static).update(self._format_time(new_dur))
+        except Exception:
+            pass
+
+    def watch_volume(self, new_vol: int) -> None:
+        """Update volume display."""
+        try:
+            self.query_one("#volume", ProgressBar).update(progress=new_vol)
+            self.query_one("#vol-value", Static).update(f"{new_vol}%")
+        except Exception:
+            pass
+
+    def update_playback(
+        self,
+        title: str | None = None,
+        is_playing: bool | None = None,
+        position: float | None = None,
+        duration: float | None = None,
+    ) -> None:
+        """Batch update playback state."""
+        if title is not None:
+            self.title = title
+        if is_playing is not None:
+            self.is_playing = is_playing
+        if position is not None:
+            self.position = position
+        if duration is not None:
+            self.duration = duration
+
+    def set_volume(self, volume: int) -> None:
+        """Update volume display."""
+        self.volume = max(0, min(100, volume))

wrkmon/ui/widgets/result_item.py

@@ -0,0 +1,98 @@
+"""Result item widget for displaying search results, queue items, etc."""
+
+from textual.app import ComposeResult
+from textual.widgets import ListItem, Label
+
+from wrkmon.core.youtube import SearchResult
+from wrkmon.utils.stealth import get_stealth
+
+
+class ResultItem(ListItem):
+    """A list item representing a search result or track."""
+
+    def __init__(
+        self,
+        result: SearchResult,
+        index: int,
+        status: str = "READY",
+        show_duration: bool = True,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.result = result
+        self.index = index
+        self.status = status
+        self.show_duration = show_duration
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        process_name = self._stealth.get_fake_process_name(self.result.title)
+        pid = self._stealth.get_fake_pid()
+
+        if self.show_duration:
+            duration = self._stealth.format_duration(self.result.duration)
+            text = f"{self.index:>2}  {process_name:<38}  {pid:>5}  {duration:>7}  {self.status}"
+        else:
+            text = f"{self.index:>2}  {process_name:<42}  {pid:>5}  {self.status}"
+
+        yield Label(text, classes="result-text")
+
+
+class QueueItem(ListItem):
+    """A list item representing a queue entry."""
+
+    def __init__(
+        self,
+        title: str,
+        duration: int,
+        index: int,
+        is_current: bool = False,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.title = title
+        self.duration = duration
+        self.index = index
+        self.is_current = is_current
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        process_name = self._stealth.get_fake_process_name(self.title)
+        duration = self._stealth.format_duration(self.duration)
+        status = "RUNNING" if self.is_current else "QUEUED"
+        marker = "▶" if self.is_current else " "
+
+        text = f"{marker} {self.index:>2}  {process_name:<40}  {duration:>7}  {status}"
+        yield Label(text, classes="queue-text")
+
+
+class HistoryItem(ListItem):
+    """A list item representing a history entry."""
+
+    def __init__(
+        self,
+        title: str,
+        duration: int,
+        play_count: int,
+        last_played: str,
+        index: int,
+        video_id: str,
+        channel: str,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.title = title
+        self.duration = duration
+        self.play_count = play_count
+        self.last_played = last_played
+        self.index = index
+        self.video_id = video_id
+        self.channel = channel
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        process_name = self._stealth.get_fake_process_name(self.title)[:32]
+        duration = self._stealth.format_duration(self.duration)
+
+        text = f"{self.index:>2}  {process_name:<34}  {duration:>7}  {self.play_count:>3}x  {self.last_played}"
+        yield Label(text, classes="history-text")

wrkmon/utils/__init__.py

@@ -0,0 +1,6 @@
+"""Utility modules for wrkmon."""
+
+from wrkmon.utils.config import Config
+from wrkmon.utils.stealth import StealthManager
+
+__all__ = ["Config", "StealthManager"]

wrkmon/utils/config.py

@@ -0,0 +1,172 @@
+"""Configuration management for wrkmon."""
+
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+# Use tomllib for Python 3.11+, fall back to tomli
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        tomllib = None
+
+
+class Config:
+    """Manages application configuration."""
+
+    DEFAULT_CONFIG = {
+        "general": {
+            "volume": 80,
+            "shuffle": False,
+            "repeat": False,
+        },
+        "player": {
+            "mpv_path": "mpv",
+            "audio_only": True,
+            "no_video": True,
+        },
+        "cache": {
+            "url_ttl_hours": 6,
+            "max_entries": 1000,
+        },
+        "ui": {
+            "theme": "matrix",  # matrix, minimal, hacker
+            "show_fake_stats": True,
+        },
+    }
+
+    def __init__(self):
+        self._config: dict[str, Any] = {}
+        self._config_dir = self._get_config_dir()
+        self._config_file = self._config_dir / "config.toml"
+        self._data_dir = self._get_data_dir()
+        self._ensure_dirs()
+        self._load()
+
+    def _get_config_dir(self) -> Path:
+        """Get the configuration directory path."""
+        if sys.platform == "win32":
+            base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+        else:
+            base = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+        return base / "wrkmon"
+
+    def _get_data_dir(self) -> Path:
+        """Get the data directory path."""
+        if sys.platform == "win32":
+            base = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+        else:
+            base = Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
+        return base / "wrkmon"
+
+    def _ensure_dirs(self) -> None:
+        """Ensure configuration and data directories exist."""
+        self._config_dir.mkdir(parents=True, exist_ok=True)
+        self._data_dir.mkdir(parents=True, exist_ok=True)
+
+    def _load(self) -> None:
+        """Load configuration from file."""
+        self._config = self.DEFAULT_CONFIG.copy()
+
+        if self._config_file.exists() and tomllib is not None:
+            try:
+                with open(self._config_file, "rb") as f:
+                    user_config = tomllib.load(f)
+                self._merge_config(user_config)
+            except Exception:
+                pass  # Use defaults on error
+
+    def _merge_config(self, user_config: dict[str, Any]) -> None:
+        """Merge user config into default config."""
+        for section, values in user_config.items():
+            if section in self._config and isinstance(values, dict):
+                self._config[section].update(values)
+            else:
+                self._config[section] = values
+
+    def save(self) -> None:
+        """Save current configuration to file."""
+        lines = []
+        for section, values in self._config.items():
+            lines.append(f"[{section}]")
+            for key, value in values.items():
+                if isinstance(value, bool):
+                    lines.append(f"{key} = {str(value).lower()}")
+                elif isinstance(value, str):
+                    lines.append(f'{key} = "{value}"')
+                else:
+                    lines.append(f"{key} = {value}")
+            lines.append("")
+
+        self._config_file.write_text("\n".join(lines))
+
+    def get(self, section: str, key: str, default: Any = None) -> Any:
+        """Get a configuration value."""
+        return self._config.get(section, {}).get(key, default)
+
+    def set(self, section: str, key: str, value: Any) -> None:
+        """Set a configuration value."""
+        if section not in self._config:
+            self._config[section] = {}
+        self._config[section][key] = value
+
+    @property
+    def config_dir(self) -> Path:
+        """Get configuration directory path."""
+        return self._config_dir
+
+    @property
+    def data_dir(self) -> Path:
+        """Get data directory path."""
+        return self._data_dir
+
+    @property
+    def database_path(self) -> Path:
+        """Get database file path."""
+        return self._data_dir / "wrkmon.db"
+
+    @property
+    def cache_path(self) -> Path:
+        """Get cache file path."""
+        return self._data_dir / "cache.db"
+
+    @property
+    def volume(self) -> int:
+        """Get current volume setting."""
+        return self.get("general", "volume", 80)
+
+    @volume.setter
+    def volume(self, value: int) -> None:
+        """Set volume."""
+        self.set("general", "volume", max(0, min(100, value)))
+
+    @property
+    def mpv_path(self) -> str:
+        """Get mpv executable path."""
+        from wrkmon.utils.mpv_installer import get_mpv_path
+        configured = self.get("player", "mpv_path", "mpv")
+        if configured != "mpv":
+            return configured
+        # Auto-detect mpv location
+        return get_mpv_path()
+
+    @property
+    def url_ttl_hours(self) -> int:
+        """Get URL cache TTL in hours."""
+        return self.get("cache", "url_ttl_hours", 6)
+
+
+# Global config instance
+_config: Config | None = None
+
+
+def get_config() -> Config:
+    """Get the global config instance."""
+    global _config
+    if _config is None:
+        _config = Config()
+    return _config

wrkmon/utils/mpv_installer.py

@@ -0,0 +1,190 @@
+"""Auto-installer for mpv on Windows."""
+
+import os
+import sys
+import shutil
+import zipfile
+import tempfile
+import urllib.request
+from pathlib import Path
+
+
+# mpv download URL for Windows (64-bit)
+MPV_DOWNLOAD_URL = "https://sourceforge.net/projects/mpv-player-windows/files/64bit/mpv-x86_64-20240121-git-a39f9b6.7z/download"
+MPV_ZIP_URL = "https://github.com/shinchiro/mpv-winbuild-cmake/releases/download/20240121/mpv-x86_64-20240121-git-a39f9b6.7z"
+
+# Simpler: use a direct zip from a mirror or bundle
+MPV_PORTABLE_URL = "https://sourceforge.net/projects/mpv-player-windows/files/bootstrapper.zip/download"
+
+
+def get_mpv_dir() -> Path:
+    """Get the directory where mpv should be installed."""
+    if sys.platform == "win32":
+        # Install in LocalAppData/wrkmon/mpv
+        local_app_data = os.environ.get("LOCALAPPDATA", os.path.expanduser("~"))
+        return Path(local_app_data) / "wrkmon" / "mpv"
+    else:
+        # On Unix, mpv should be installed via package manager
+        return Path.home() / ".local" / "share" / "wrkmon" / "mpv"
+
+
+def get_mpv_executable() -> Path:
+    """Get the path to the mpv executable."""
+    mpv_dir = get_mpv_dir()
+    if sys.platform == "win32":
+        # Check both possible locations
+        exe_path = mpv_dir / "mpv.exe"
+        if exe_path.exists():
+            return exe_path
+        # Also check in subdirectory (some extractions create this)
+        sub_path = mpv_dir / "mpv" / "mpv.exe"
+        if sub_path.exists():
+            return sub_path
+        return exe_path  # Return default even if not exists
+    return mpv_dir / "mpv"
+
+
+def is_mpv_installed() -> bool:
+    """Check if mpv is available (either in PATH or our local install)."""
+    # Check PATH first
+    if shutil.which("mpv"):
+        return True
+
+    # Check our local install
+    mpv_exe = get_mpv_executable()
+    return mpv_exe.exists()
+
+
+def get_mpv_path() -> str:
+    """Get the path to mpv executable."""
+    # Check PATH first
+    system_mpv = shutil.which("mpv")
+    if system_mpv:
+        return system_mpv
+
+    # Check our local install
+    mpv_exe = get_mpv_executable()
+    if mpv_exe.exists():
+        return str(mpv_exe)
+
+    return "mpv"  # Default, will fail if not installed
+
+
+def download_file(url: str, dest: Path, progress_callback=None) -> bool:
+    """Download a file with optional progress callback."""
+    try:
+        def report_progress(block_num, block_size, total_size):
+            if progress_callback and total_size > 0:
+                progress = min(100, (block_num * block_size * 100) // total_size)
+                progress_callback(progress)
+
+        urllib.request.urlretrieve(url, dest, reporthook=report_progress)
+        return True
+    except Exception as e:
+        print(f"Download failed: {e}")
+        return False
+
+
+def install_mpv_windows(progress_callback=None) -> bool:
+    """Download and install mpv on Windows."""
+    import subprocess
+
+    mpv_dir = get_mpv_dir()
+    mpv_dir.mkdir(parents=True, exist_ok=True)
+
+    # Use winget if available (cleanest option)
+    try:
+        result = subprocess.run(
+            ["winget", "install", "--id", "mpv.net", "-e", "--silent"],
+            capture_output=True,
+            timeout=300
+        )
+        if result.returncode == 0:
+            return True
+    except Exception:
+        pass
+
+    # Try chocolatey
+    try:
+        result = subprocess.run(
+            ["choco", "install", "mpv", "-y"],
+            capture_output=True,
+            timeout=300
+        )
+        if result.returncode == 0:
+            return True
+    except Exception:
+        pass
+
+    # Manual download as fallback
+    # Download portable mpv
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        tmp_path = Path(tmp_dir)
+
+        if progress_callback:
+            progress_callback(0, "Downloading mpv...")
+
+        # Try to download from GitHub releases (more reliable)
+        zip_path = tmp_path / "mpv.zip"
+
+        # Use a known working URL for portable mpv
+        urls_to_try = [
+            "https://github.com/shinchiro/mpv-winbuild-cmake/releases/latest/download/mpv-x86_64-latest.7z",
+            "https://downloads.sourceforge.net/project/mpv-player-windows/64bit-v3/mpv-x86_64-v3-20240114-git-5765e7f.7z",
+        ]
+
+        # For simplicity, let's just tell users to install manually if auto-install fails
+        if progress_callback:
+            progress_callback(100, "Please install mpv manually: winget install mpv")
+
+        return False
+
+
+def install_mpv(progress_callback=None) -> bool:
+    """Install mpv for the current platform."""
+    if sys.platform == "win32":
+        return install_mpv_windows(progress_callback)
+    else:
+        # On Unix, tell user to install via package manager
+        print("Please install mpv using your package manager:")
+        print("  Ubuntu/Debian: sudo apt install mpv")
+        print("  Fedora: sudo dnf install mpv")
+        print("  Arch: sudo pacman -S mpv")
+        print("  macOS: brew install mpv")
+        return False
+
+
+def ensure_mpv_installed() -> tuple[bool, str]:
+    """
+    Ensure mpv is installed, attempting auto-install if needed.
+
+    Returns:
+        tuple: (success: bool, mpv_path_or_error: str)
+    """
+    if is_mpv_installed():
+        return True, get_mpv_path()
+
+    # Try to install
+    print("mpv not found, attempting to install...")
+    if install_mpv():
+        if is_mpv_installed():
+            return True, get_mpv_path()
+
+    # Installation failed
+    if sys.platform == "win32":
+        error_msg = (
+            "mpv not found! Please install it:\n"
+            "  Option 1: winget install mpv\n"
+            "  Option 2: choco install mpv\n"
+            "  Option 3: Download from https://mpv.io/installation/"
+        )
+    else:
+        error_msg = (
+            "mpv not found! Please install it:\n"
+            "  Ubuntu/Debian: sudo apt install mpv\n"
+            "  Fedora: sudo dnf install mpv\n"
+            "  Arch: sudo pacman -S mpv\n"
+            "  macOS: brew install mpv"
+        )
+
+    return False, error_msg