wrkmon 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

wrkmon/utils/config.py

@@ -22,7 +22,8 @@ class Config:
         "general": {
             "volume": 80,
             "shuffle": False,
-            "repeat": False,
+            "repeat_mode": "none",  # none, one, all
+            "show_trending_on_start": True,
         },
         "player": {
             "mpv_path": "mpv",
@@ -34,8 +35,11 @@ class Config:
             "max_entries": 1000,
         },
         "ui": {
-            "theme": "matrix",  # matrix, minimal, hacker
+            "theme": "github_dark",  # github_dark, matrix, dracula, nord
             "show_fake_stats": True,
+            "show_thumbnails": True,
+            "thumbnail_style": "colored_blocks",  # colored_blocks, colored_simple, braille, blocks
+            "thumbnail_width": 45,
         },
     }
 
@@ -70,7 +74,9 @@ class Config:
 
     def _load(self) -> None:
         """Load configuration from file."""
-        self._config = self.DEFAULT_CONFIG.copy()
+        # Deep copy default config
+        import copy
+        self._config = copy.deepcopy(self.DEFAULT_CONFIG)
 
         if self._config_file.exists() and tomllib is not None:
             try:
@@ -134,6 +140,7 @@ class Config:
         """Get cache file path."""
         return self._data_dir / "cache.db"
 
+    # General settings
     @property
     def volume(self) -> int:
         """Get current volume setting."""
@@ -144,6 +151,38 @@ class Config:
         """Set volume."""
         self.set("general", "volume", max(0, min(100, value)))
 
+    @property
+    def repeat_mode(self) -> str:
+        """Get repeat mode (none, one, all)."""
+        return self.get("general", "repeat_mode", "none")
+
+    @repeat_mode.setter
+    def repeat_mode(self, value: str) -> None:
+        """Set repeat mode."""
+        if value in ("none", "one", "all"):
+            self.set("general", "repeat_mode", value)
+
+    @property
+    def shuffle(self) -> bool:
+        """Get shuffle setting."""
+        return self.get("general", "shuffle", False)
+
+    @shuffle.setter
+    def shuffle(self, value: bool) -> None:
+        """Set shuffle."""
+        self.set("general", "shuffle", value)
+
+    @property
+    def show_trending_on_start(self) -> bool:
+        """Whether to show trending videos on startup."""
+        return self.get("general", "show_trending_on_start", True)
+
+    @show_trending_on_start.setter
+    def show_trending_on_start(self, value: bool) -> None:
+        """Set show trending on start."""
+        self.set("general", "show_trending_on_start", value)
+
+    # Player settings
     @property
     def mpv_path(self) -> str:
         """Get mpv executable path."""
@@ -151,14 +190,56 @@ class Config:
         configured = self.get("player", "mpv_path", "mpv")
         if configured != "mpv":
             return configured
-        # Auto-detect mpv location
         return get_mpv_path()
 
+    # Cache settings
     @property
     def url_ttl_hours(self) -> int:
         """Get URL cache TTL in hours."""
         return self.get("cache", "url_ttl_hours", 6)
 
+    # UI settings
+    @property
+    def theme(self) -> str:
+        """Get UI theme."""
+        return self.get("ui", "theme", "github_dark")
+
+    @theme.setter
+    def theme(self, value: str) -> None:
+        """Set UI theme."""
+        self.set("ui", "theme", value)
+
+    @property
+    def show_thumbnails(self) -> bool:
+        """Whether to show thumbnails."""
+        return self.get("ui", "show_thumbnails", True)
+
+    @show_thumbnails.setter
+    def show_thumbnails(self, value: bool) -> None:
+        """Set show thumbnails."""
+        self.set("ui", "show_thumbnails", value)
+
+    @property
+    def thumbnail_style(self) -> str:
+        """Get thumbnail rendering style."""
+        return self.get("ui", "thumbnail_style", "colored_blocks")
+
+    @thumbnail_style.setter
+    def thumbnail_style(self, value: str) -> None:
+        """Set thumbnail style."""
+        if value in ("colored_blocks", "colored_simple", "braille", "blocks"):
+            self.set("ui", "thumbnail_style", value)
+
+    @property
+    def thumbnail_width(self) -> int:
+        """Get thumbnail width in characters."""
+        return self.get("ui", "thumbnail_width", 45)
+
+    @thumbnail_width.setter
+    def thumbnail_width(self, value: int) -> None:
+        """Set thumbnail width."""
+        self.set("ui", "thumbnail_width", max(20, min(80, value)))
+
 
 # Global config instance
 _config: Config | None = None

wrkmon/utils/updater.py

@@ -0,0 +1,311 @@
+"""Version checker and updater for wrkmon."""
+
+import asyncio
+import json
+import logging
+import shutil
+import subprocess
+import sys
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+from packaging import version
+
+from wrkmon import __version__
+
+logger = logging.getLogger("wrkmon.updater")
+
+PYPI_URL = "https://pypi.org/pypi/wrkmon/json"
+CHECK_INTERVAL_HOURS = 24
+
+
+@dataclass
+class UpdateInfo:
+    """Information about an available update."""
+
+    current_version: str
+    latest_version: str
+    is_update_available: bool
+    release_url: str = "https://pypi.org/project/wrkmon/"
+
+    @property
+    def update_command(self) -> str:
+        """Get the command to update wrkmon."""
+        return "pip install --upgrade wrkmon"
+
+
+def get_current_version() -> str:
+    """Get the current installed version."""
+    return __version__
+
+
+def check_pypi_version() -> Optional[str]:
+    """
+    Check PyPI for the latest version of wrkmon.
+
+    Returns:
+        The latest version string, or None if check failed.
+    """
+    try:
+        req = urllib.request.Request(
+            PYPI_URL,
+            headers={"Accept": "application/json", "User-Agent": "wrkmon-updater"}
+        )
+        with urllib.request.urlopen(req, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            return data.get("info", {}).get("version")
+    except Exception as e:
+        logger.debug(f"Failed to check PyPI version: {e}")
+        return None
+
+
+async def check_pypi_version_async() -> Optional[str]:
+    """Async wrapper for checking PyPI version."""
+    return await asyncio.to_thread(check_pypi_version)
+
+
+def compare_versions(current: str, latest: str) -> bool:
+    """
+    Check if an update is available.
+
+    Returns:
+        True if latest > current (update available).
+    """
+    try:
+        return version.parse(latest) > version.parse(current)
+    except Exception:
+        # Fallback to string comparison
+        return latest != current and latest > current
+
+
+def check_for_updates() -> Optional[UpdateInfo]:
+    """
+    Check if a newer version is available on PyPI.
+
+    Returns:
+        UpdateInfo if check succeeded, None if check failed.
+    """
+    current = get_current_version()
+    latest = check_pypi_version()
+
+    if latest is None:
+        return None
+
+    return UpdateInfo(
+        current_version=current,
+        latest_version=latest,
+        is_update_available=compare_versions(current, latest),
+    )
+
+
+async def check_for_updates_async() -> Optional[UpdateInfo]:
+    """Async version of check_for_updates."""
+    return await asyncio.to_thread(check_for_updates)
+
+
+def perform_update() -> tuple[bool, str]:
+    """
+    Attempt to update wrkmon using pip.
+
+    Returns:
+        tuple: (success, message)
+    """
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", "wrkmon"],
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+
+        if result.returncode == 0:
+            return True, "Update successful! Please restart wrkmon."
+        else:
+            return False, f"Update failed: {result.stderr}"
+    except subprocess.TimeoutExpired:
+        return False, "Update timed out. Try manually: pip install --upgrade wrkmon"
+    except Exception as e:
+        return False, f"Update error: {e}"
+
+
+async def perform_update_async() -> tuple[bool, str]:
+    """Async version of perform_update."""
+    return await asyncio.to_thread(perform_update)
+
+
+# ============================================================
+# Dependency checkers for better compatibility
+# ============================================================
+
+def is_deno_installed() -> bool:
+    """Check if deno is installed."""
+    return shutil.which("deno") is not None
+
+
+def is_nodejs_installed() -> bool:
+    """Check if Node.js is installed."""
+    return shutil.which("node") is not None
+
+
+def get_js_runtime() -> Optional[str]:
+    """Get the available JavaScript runtime for yt-dlp."""
+    if is_deno_installed():
+        return "deno"
+    if is_nodejs_installed():
+        return "nodejs"
+    return None
+
+
+def get_deno_install_command() -> str:
+    """Get the command to install deno for the current platform."""
+    if sys.platform == "win32":
+        return "irm https://deno.land/install.ps1 | iex"
+    else:
+        return "curl -fsSL https://deno.land/install.sh | sh"
+
+
+def install_deno() -> tuple[bool, str]:
+    """
+    Attempt to install deno.
+
+    Returns:
+        tuple: (success, message)
+    """
+    if is_deno_installed():
+        return True, "deno is already installed"
+
+    try:
+        if sys.platform == "win32":
+            # Try winget first
+            try:
+                result = subprocess.run(
+                    ["winget", "install", "--id", "DenoLand.Deno", "-e", "--silent"],
+                    capture_output=True,
+                    timeout=300,
+                )
+                if result.returncode == 0:
+                    return True, "deno installed via winget"
+            except Exception:
+                pass
+
+            # Try scoop
+            try:
+                result = subprocess.run(
+                    ["scoop", "install", "deno"],
+                    capture_output=True,
+                    timeout=300,
+                )
+                if result.returncode == 0:
+                    return True, "deno installed via scoop"
+            except Exception:
+                pass
+
+            # Try chocolatey
+            try:
+                result = subprocess.run(
+                    ["choco", "install", "deno", "-y"],
+                    capture_output=True,
+                    timeout=300,
+                )
+                if result.returncode == 0:
+                    return True, "deno installed via chocolatey"
+            except Exception:
+                pass
+
+            return False, f"Please install deno manually:\n{get_deno_install_command()}"
+
+        else:
+            # Unix - try package managers first
+            if sys.platform == "darwin":
+                # macOS - try brew
+                try:
+                    result = subprocess.run(
+                        ["brew", "install", "deno"],
+                        capture_output=True,
+                        timeout=300,
+                    )
+                    if result.returncode == 0:
+                        return True, "deno installed via homebrew"
+                except Exception:
+                    pass
+            else:
+                # Linux - try snap
+                try:
+                    result = subprocess.run(
+                        ["snap", "install", "deno"],
+                        capture_output=True,
+                        timeout=300,
+                    )
+                    if result.returncode == 0:
+                        return True, "deno installed via snap"
+                except Exception:
+                    pass
+
+            # Try the official install script
+            try:
+                result = subprocess.run(
+                    ["sh", "-c", "curl -fsSL https://deno.land/install.sh | sh"],
+                    capture_output=True,
+                    timeout=300,
+                )
+                if result.returncode == 0:
+                    return True, "deno installed via official script"
+            except Exception:
+                pass
+
+            return False, f"Please install deno manually:\n{get_deno_install_command()}"
+
+    except Exception as e:
+        return False, f"Installation failed: {e}"
+
+
+async def install_deno_async() -> tuple[bool, str]:
+    """Async version of install_deno."""
+    return await asyncio.to_thread(install_deno)
+
+
+def check_dependencies() -> dict:
+    """
+    Check all optional dependencies for optimal functionality.
+
+    Returns:
+        dict with dependency status.
+    """
+    from wrkmon.utils.mpv_installer import is_mpv_installed
+
+    return {
+        "mpv": {
+            "installed": is_mpv_installed(),
+            "required": True,
+            "description": "Media player for audio playback",
+        },
+        "deno": {
+            "installed": is_deno_installed(),
+            "required": False,
+            "description": "JavaScript runtime for better YouTube compatibility",
+        },
+        "nodejs": {
+            "installed": is_nodejs_installed(),
+            "required": False,
+            "description": "Alternative JavaScript runtime",
+        },
+        "js_runtime": {
+            "installed": get_js_runtime() is not None,
+            "required": False,
+            "description": "JavaScript runtime (deno or nodejs) for full YouTube support",
+        },
+    }
+
+
+def get_missing_dependencies() -> list[str]:
+    """Get list of missing recommended dependencies."""
+    deps = check_dependencies()
+    missing = []
+
+    if not deps["mpv"]["installed"]:
+        missing.append("mpv")
+    if not deps["js_runtime"]["installed"]:
+        missing.append("deno (recommended for YouTube)")
+
+    return missing