plex-generate-previews 2.0.0__py3-none-any.whl

plex_generate_previews/utils.py

@@ -0,0 +1,135 @@
+"""
+Utility functions for Plex Video Preview Generator.
+
+Contains general-purpose utility functions that can be reused across
+different modules in the application.
+"""
+
+import os
+import shutil
+import time
+import uuid
+
+
+def calculate_title_width():
+    """
+    Calculate optimal title width based on terminal size.
+    
+    Calculates the maximum number of characters that can be used for
+    displaying media titles in the progress bars, accounting for all
+    other UI elements.
+    
+    Returns:
+        int: Maximum characters for title display (20-50 range)
+    """
+    terminal_width = shutil.get_terminal_size().columns
+    
+    worker_prefix = 7  # "GPU 0: " or "CPU 0: "
+    percentage = 6     # " 100% "
+    time_elapsed = 8   # " 00:00:00 "
+    count_display = 12 # " (1/10) "
+    speed_display = 8  # " 2.5x "
+    progress_bar = 20  # Approximate progress bar width
+    
+    reserved_space = worker_prefix + percentage + time_elapsed + count_display + speed_display + progress_bar
+    available_width = terminal_width - reserved_space
+    
+    # Set reasonable limits: minimum 20 chars, maximum 50 chars
+    return max(min(available_width, 50), 20)
+
+
+def format_display_title(title: str, media_type: str, title_max_width: int) -> str:
+    """
+    Format and truncate display title based on media type.
+    
+    Args:
+        title: The media title to format
+        media_type: 'episode' or 'movie'
+        title_max_width: Maximum width for the title
+        
+    Returns:
+        str: Formatted and truncated title
+    """
+    if media_type == 'episode':
+        # For episodes, ensure S01E01 format is always visible
+        if len(title) > title_max_width:
+            # Simple truncation: keep last 6 chars (S01E01) + show title
+            season_episode = title[-6:]  # Last 6 characters (S01E01)
+            available_space = title_max_width - 6 - 3  # 6 for S01E01, 3 for "..."
+            if available_space > 0:
+                show_title = title[:-6].strip()  # Everything except last 6 chars
+                if len(show_title) > available_space:
+                    show_title = show_title[:available_space]
+                display_title = f"{show_title}...{season_episode}"
+            else:
+                # Not enough space, just show the season/episode
+                display_title = f"...{season_episode}"
+        else:
+            display_title = title
+    else:
+        # For movies, use the title as-is
+        display_title = title
+        
+        # Regular truncation for movies
+        if len(display_title) > title_max_width:
+            display_title = display_title[:title_max_width-3] + "..."  # Leave room for "..."
+    
+    # Add padding to prevent progress bar jumping (only if not already truncated)
+    if len(display_title) <= title_max_width:
+        padding_needed = title_max_width - len(display_title)
+        display_title = display_title + " " * padding_needed
+    
+    return display_title
+
+
+def is_docker_environment() -> bool:
+    """Check if running inside a Docker container."""
+    return (
+        os.path.exists('/.dockerenv') or 
+        os.environ.get('container') == 'docker' or
+        os.environ.get('DOCKER_CONTAINER') == 'true' or
+        'docker' in os.environ.get('HOSTNAME', '').lower()
+    )
+
+
+def sanitize_path(path: str) -> str:
+    """
+    Sanitize file path for cross-platform compatibility.
+    
+    Converts forward slashes to backslashes on Windows systems to ensure
+    proper path handling across different operating systems.
+    
+    Args:
+        path: The file path to sanitize
+        
+    Returns:
+        str: Sanitized file path
+    """
+    if os.name == 'nt':
+        path = path.replace('/', '\\')
+    return path
+
+
+def setup_working_directory(tmp_folder: str) -> str:
+    """
+    Create and set up a unique working temporary directory.
+    
+    Args:
+        tmp_folder: Base temporary folder path
+        
+    Returns:
+        str: Path to the created working directory
+        
+    Raises:
+        OSError: If directory creation fails
+    """
+    # Create a unique subfolder for this run to avoid conflicts
+    unique_id = f"plex_previews_{int(time.time())}_{str(uuid.uuid4())[:8]}"
+    working_tmp_folder = os.path.join(tmp_folder, unique_id)
+    
+    # Create our specific working directory
+    os.makedirs(working_tmp_folder, exist_ok=True)
+    
+    return working_tmp_folder
+
+

plex_generate_previews/version_check.py

@@ -0,0 +1,178 @@
+"""
+Version check module for checking if a newer version is available.
+
+Queries GitHub Releases API to compare current version with latest release.
+Handles network failures gracefully without interrupting application startup.
+"""
+
+import re
+import requests
+from typing import Optional, Tuple
+from loguru import logger
+from .utils import is_docker_environment
+
+
+def get_current_version() -> str:
+    """
+    Get the current version from package metadata.
+    
+    Returns:
+        str: Current version string (e.g., "2.0.0")
+    """
+    try:
+        # Try to get version from package metadata first
+        import importlib.metadata
+        return importlib.metadata.version("plex-generate-previews")
+    except Exception:
+        # Fallback to reading from pyproject.toml using regex
+        try:
+            import os
+            
+            # Get the directory containing this file
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            project_root = os.path.dirname(current_dir)
+            pyproject_path = os.path.join(project_root, "pyproject.toml")
+            
+            with open(pyproject_path, 'r') as f:
+                content = f.read()
+                # Simple regex to find version = "X.Y.Z"
+                match = re.search(r'version\s*=\s*["\']([^"\']+)["\']', content)
+                if match:
+                    return match.group(1)
+        except Exception:
+            pass
+            
+    # Final fallback - return a default version
+    logger.debug("Could not determine current version, using fallback")
+    return "0.0.0"
+
+
+def parse_version(version_str: str) -> Tuple[int, int, int]:
+    """
+    Parse a semantic version string into comparable tuple.
+    
+    Args:
+        version_str: Version string like "2.0.0" or "1.5.3"
+        
+    Returns:
+        Tuple of (major, minor, patch) integers
+        
+    Raises:
+        ValueError: If version string format is invalid
+    """
+    # Remove any 'v' prefix and extract version parts
+    clean_version = version_str.lstrip('v')
+    
+    # Match semantic version pattern (major.minor.patch)
+    match = re.match(r'^(\d+)\.(\d+)\.(\d+)(?:-[a-zA-Z0-9.-]+)?(?:\+[a-zA-Z0-9.-]+)?$', clean_version)
+    
+    if not match:
+        raise ValueError(f"Invalid version format: {version_str}")
+    
+    major, minor, patch = match.groups()
+    return (int(major), int(minor), int(patch))
+
+
+def get_latest_github_release() -> Optional[str]:
+    """
+    Query GitHub API for the latest release version.
+    
+    Returns:
+        str: Latest release version string, or None if failed
+    """
+    try:
+        # GitHub API endpoint for latest release
+        url = "https://api.github.com/repos/stevezau/plex_generate_vid_previews/releases/latest"
+        
+        # Set timeout and user agent
+        headers = {
+            'User-Agent': 'plex-generate-previews-version-check'
+        }
+        
+        response = requests.get(url, headers=headers, timeout=3)
+        response.raise_for_status()
+        
+        data = response.json()
+        latest_version = data.get('tag_name', '')
+        
+        if not latest_version:
+            logger.debug("GitHub API returned empty tag_name")
+            return None
+            
+        return latest_version
+        
+    except requests.exceptions.Timeout:
+        logger.debug("Version check timed out - no internet connection or slow response")
+        return None
+    except requests.exceptions.ConnectionError:
+        logger.debug("Version check failed - no internet connection")
+        return None
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 404:
+            logger.debug("Repository or releases not found on GitHub")
+        elif e.response.status_code == 429:
+            logger.debug("GitHub API rate limit exceeded")
+        else:
+            logger.debug(f"GitHub API error: {e.response.status_code}")
+        return None
+    except requests.exceptions.RequestException as e:
+        logger.debug(f"Version check request failed: {e}")
+        return None
+    except (KeyError, ValueError) as e:
+        logger.debug(f"Invalid response from GitHub API: {e}")
+        return None
+    except Exception as e:
+        logger.debug(f"Unexpected error during version check: {e}")
+        return None
+
+
+def check_for_updates(skip_check: bool = False) -> None:
+    """
+    Check for available updates and log appropriate messages.
+    
+    Args:
+        skip_check: If True, skip the version check entirely
+    """
+    if skip_check:
+        logger.debug("Version check skipped by user request")
+        return
+    
+    try:
+        # Get current version
+        current_version = get_current_version()
+        logger.debug(f"Current version: {current_version}")
+        
+        # Get latest version from GitHub
+        latest_version = get_latest_github_release()
+        if not latest_version:
+            logger.debug("Could not determine latest version")
+            return
+            
+        logger.debug(f"Latest version: {latest_version}")
+        
+        # Parse versions for comparison
+        try:
+            current_tuple = parse_version(current_version)
+            latest_tuple = parse_version(latest_version)
+        except ValueError as e:
+            logger.debug(f"Version parsing error: {e}")
+            return
+        
+        # Compare versions
+        if latest_tuple > current_tuple:
+            # Newer version available - show warning
+            logger.warning(f"⚠️  A newer version is available: {latest_version} (you have: {current_version})")
+            
+            # Provide appropriate update instructions based on environment
+            if is_docker_environment():
+                logger.warning("🐳 Update: docker pull stevezzau/plex_generate_vid_previews:latest")
+            else:
+                logger.warning("📦 Update: pip install --upgrade git+https://github.com/stevezau/plex_generate_vid_previews.git")
+            
+            logger.warning("🔗 Release notes: https://github.com/stevezau/plex_generate_vid_previews/releases/latest")
+        else:
+            logger.debug("Version is up to date")
+            
+    except Exception as e:
+        # Catch any unexpected errors and log at debug level
+        logger.debug(f"Version check failed unexpectedly: {e}")