redfetch 1.3.0__py3-none-any.whl

redfetch/meta.py

@@ -0,0 +1,561 @@
+"""Version checking, self-update, and uninstall."""
+
+# Standard
+import os
+import platform
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+# Third-party
+import httpx
+from packaging import version
+
+# Rich library
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.prompt import Confirm
+
+# Local
+from redfetch.__about__ import __version__
+from redfetch import config
+from diskcache import Cache
+
+
+def _get_pypi_url() -> str:
+    """Pick PyPI JSON URL, favouring `REDFETCH_PYPI_URL` if set."""
+    env_url = os.getenv("REDFETCH_PYPI_URL")
+    if env_url:
+        return env_url
+    if "dev" in __version__:
+        return "https://test.pypi.org/pypi/redfetch/json"
+    return "https://pypi.org/pypi/redfetch/json"
+
+
+PYPI_URL = _get_pypi_url()
+
+console = Console()
+
+
+def get_current_version():
+    return __version__
+
+
+_UPDATE_CACHE_TTL_SECONDS = 2 * 60 * 60  # 2 hours
+
+_meta_cache = None
+
+
+def _get_meta_cache():
+    """Lazy-load disk-backed cache under the config directory."""
+    cache_dir = getattr(config, 'config_dir', None) or os.getenv('REDFETCH_CONFIG_DIR')
+    if not cache_dir:
+        cache_dir = os.getcwd()
+    api_cache_dir = os.path.join(cache_dir, '.cache')
+    os.makedirs(api_cache_dir, exist_ok=True)
+    return Cache(api_cache_dir)
+
+
+def clear_pypi_cache() -> None:
+    """Clear cached PyPI metadata."""
+    global _meta_cache
+    if _meta_cache is None:
+        _meta_cache = _get_meta_cache()
+    try:
+        _meta_cache.clear()
+    finally:
+        try:
+            _meta_cache.close()
+        except Exception:
+            pass
+        _meta_cache = None
+
+
+def fetch_latest_version_cached():
+    """Fetch latest PyPI version with a 2-hour disk-backed cache."""
+    global _meta_cache
+    if _meta_cache is None:
+        _meta_cache = _get_meta_cache()
+    cache_key = f"pypi_latest:{PYPI_URL}"
+    cached = _meta_cache.get(cache_key)
+    if cached is not None:
+        return cached
+    latest = fetch_latest_version_from_pypi()
+    _meta_cache.set(cache_key, latest, expire=_UPDATE_CACHE_TTL_SECONDS)
+    return latest
+
+
+def fetch_latest_version_from_pypi():
+    response = httpx.get(PYPI_URL, timeout=10.0)
+    response.raise_for_status()
+    data = response.json()
+    # On TestPyPI, prefer the highest available release (including pre-releases)
+    if "test.pypi.org" in PYPI_URL:
+        releases = list(data.get("releases", {}).keys())
+        if releases:
+            releases.sort(key=version.parse)
+            return releases[-1]
+    # Default: whatever PyPI reports as the latest stable version
+    return data["info"]["version"]
+
+
+def get_executable_path():
+    executable_path = os.environ.get('PYAPP')
+    return executable_path
+
+
+def detect_installation_method():
+    """Detect how the package was installed."""
+    try:
+        # Check for PYAPP first
+        if os.getenv('PYAPP'):
+            return 'pyapp'
+
+        # Get the package location
+        package_location = Path(__file__).parent.absolute()
+
+        location_str = str(package_location)
+        parts_lower = {part.lower() for part in package_location.parts}
+
+        # Check for pipx
+        if 'pipx' in location_str:
+            return 'pipx'
+
+        # uv paths contain ".../uv/.../tools/..."
+        if 'uv' in parts_lower and 'tools' in parts_lower:
+            return 'uv'
+
+        # Default to pip
+        return 'pip'
+    except Exception:
+        return 'pip'
+
+
+def get_update_command():
+    """Get the appropriate update command based on installation method."""
+    method = detect_installation_method()
+
+    # Add TestPyPI index URL to commands if using TestPyPI
+    is_test_pypi = "test.pypi.org" in PYPI_URL
+
+    commands = {
+        'pip': [
+            sys.executable, '-m', 'pip', 'install', '--upgrade',
+            '--index-url', 'https://test.pypi.org/simple/',
+            '--extra-index-url', 'https://pypi.org/simple/',
+            'redfetch'
+        ] if is_test_pypi else [
+            sys.executable, '-m', 'pip', 'install', '--upgrade', 'redfetch'
+        ],
+        'pipx': [
+            'pipx', 'upgrade', 'redfetch', '--pip-args',
+            '--index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/'
+        ] if is_test_pypi else [
+            'pipx', 'upgrade', 'redfetch'
+        ],
+        'uv': [
+            'uv', 'tool', 'upgrade', 'redfetch',
+            '--index-url', 'https://test.pypi.org/simple/',
+            '--extra-index-url', 'https://pypi.org/simple/'
+        ] if is_test_pypi else [
+            'uv', 'tool', 'upgrade', 'redfetch'
+        ],
+        'pyapp': None  # Handle separately with self_update()
+    }
+
+    return commands.get(method)
+
+
+def check_for_update():
+    current_version = get_current_version()
+    
+    try:
+        latest_version = fetch_latest_version_cached()
+        
+        if version.parse(latest_version) > version.parse(current_version):
+            version_info = Panel(
+                Text.assemble(
+                    ("An update for redfetch is available! 🚡\n\n", "bold green"),
+                    ("Local version: ", "dim"),
+                    (f"{current_version}\n", "cyan"),
+                    ("Latest version: ", "dim"),
+                    (f"{latest_version}", "cyan bold")
+                ),
+                title="Update Available",
+                expand=False
+            )
+            console.print(version_info)
+            
+            # Handle PYAPP separately
+            if os.getenv('PYAPP'):
+                if Confirm.ask("Would you like to update now?"):
+                    return self_update()
+                else:
+                    console.print("[yellow]Update skipped. You can manually update later.[/yellow]")
+                return False
+            
+            # Get the appropriate update command
+            update_command = get_update_command()
+            if not update_command:
+                console.print("[red]Could not determine update method.[/red]")
+                return False
+                
+            command_panel = Panel(
+                Text(" ".join(update_command), style="bold cyan"),
+                title="Update Command",
+                expand=False
+            )
+            console.print(command_panel)
+            
+            if Confirm.ask("Would you like to run this command to update?"):
+                return pip_update_redfetch(update_command, latest_version)
+            else:
+                console.print("[yellow]Update skipped. You can manually update later.[/yellow]")
+    except Exception as e:
+        console.print(f"[bold red]Error checking for updates:[/bold red] {e}")
+    return False
+
+
+def pip_update_redfetch(update_command, latest_version):
+    try:
+        console.print(f"\n[bold]Updating redfetch to version {latest_version}...[/bold]\n")
+        
+        # Run the update command and let it print directly to console
+        result = subprocess.run(update_command)
+        returncode = result.returncode
+        
+        if returncode == 0:
+            console.print("\n[bold green]redfetch has been successfully updated. 🫎[/bold green]")
+            console.print("[yellow]Please run redfetch again to use the updated version.[/yellow]")
+            sys.exit(0)
+        else:
+            console.print("\n[bold red]Update failed. See output above for details.[/bold red]")
+            sys.exit(1)
+    except Exception as e:
+        console.print(f"[bold red]Error during update process:[/bold red] {e}")
+        sys.exit(1)
+
+
+def self_update():
+    """Update with PYAPP."""
+    try:
+        console.print("[bold]Performing self-update...[/bold]")
+
+        current_version = get_current_version()
+        latest_version = fetch_latest_version_from_pypi()
+        console.print(f"Current version: {current_version}")
+        console.print(f"Latest version: {latest_version}")
+
+        executable_path = get_executable_path()
+        update_command = [executable_path, 'self', 'update']
+
+        # Start the update process in a new console and exit the current one
+        subprocess.Popen(
+            update_command,
+            creationflags=subprocess.CREATE_NEW_CONSOLE
+        )
+
+        # Exit the current process to allow the update to proceed
+        sys.exit(0)
+
+    except Exception as e:
+        console.print(f"[bold red]Error during self-update process:[/bold red] {e}")
+        sys.exit(1)
+
+
+def self_remove():
+    """Remove with PYAPP."""
+    try:
+        console.print("[bold]Performing self-uninstall...[/bold]")
+
+        executable_path = get_executable_path()
+        console.print(f"[debug]Executable path: {executable_path}[/debug]")
+
+        if not executable_path:
+            console.print("[bold red]Executable path not found. Exiting self-remove.[/bold red]")
+            return
+
+        # Create a batch script to handle the uninstallation
+        batch_script = textwrap.dedent(f"""
+        @echo off
+        timeout /t 2 > nul
+        "{executable_path}" self remove
+        if %errorlevel% neq 0 (
+            echo Uninstallation failed. Press any key to exit.
+            pause > nul
+            exit /b 1
+        )
+        echo Uninstallation successful. Cleaning up...
+        del "{executable_path}"
+        if exist "{executable_path}" (
+            echo Failed to delete the executable. You may need to delete it manually.
+        ) else (
+            echo Executable deleted successfully.
+        )
+        echo Cleanup complete. Press any key to exit.
+        pause > nul
+        (goto) 2>nul & del "%~f0"
+        """).strip()
+
+        batch_file_path = os.path.join(os.path.dirname(executable_path), "uninstall.bat")
+        with open(batch_file_path, 'w') as batch_file:
+            batch_file.write(batch_script)
+
+        console.print(f"[debug]Batch script created at: {batch_file_path}[/debug]")
+    
+        # Run the batch script in a new console
+        subprocess.Popen(
+            ['cmd.exe', '/c', 'start', batch_file_path],
+            creationflags=subprocess.CREATE_NEW_CONSOLE
+        )
+
+        # Exit the current process to allow the uninstall to proceed
+        sys.exit(0)
+
+    except Exception as e:
+        console.print(f"[bold red]Error during self-uninstall process:[/bold red] {e}")
+        input("Press Enter to close this window...")
+        sys.exit(1)
+
+
+def _release_disk_caches() -> None:
+    """Ensure all disk caches are closed before deleting directories."""
+    errors: list[str] = []
+
+    try:
+        clear_pypi_cache()
+    except Exception as exc:
+        errors.append(f"PyPI cache: {exc}")
+
+    try:
+        from redfetch import auth
+    except Exception as exc:
+        errors.append(f"Auth cache import: {exc}")
+    else:
+        try:
+            auth.clear_disk_cache()
+        except Exception as exc:
+            errors.append(f"Disk cache: {exc}")
+
+    try:
+        from redfetch import net
+    except Exception as exc:
+        errors.append(f"Manifest cache import: {exc}")
+    else:
+        try:
+            net.clear_manifest_cache()
+        except Exception as exc:
+            errors.append(f"Manifest cache: {exc}")
+
+    if errors:
+        raise RuntimeError("; ".join(errors))
+
+
+def uninstall():
+    """Guide the user through the uninstallation process."""
+    # Import the logout function from auth module
+    from .auth import logout
+
+    config.initialize_config()
+
+    console.print("\n[bold]Uninstallation Process:[/bold]")
+
+    # Call the logout function to clear stored credentials
+    logout()
+
+    config.remove_breadcrumb()
+
+    # Get executable path and installation method
+    executable_path = get_executable_path()
+    install_method = detect_installation_method()
+
+    # Inform the user of directories that may contain data
+    console.print("\n[bold]Manual Cleanup Instructions:[/bold]\n")
+
+    environments = ['DEFAULT', 'LIVE', 'TEST', 'EMU']  # List of environments to check
+    printed_paths = set()  # To avoid duplicates
+    existing_paths = set()  # Collect existing paths
+
+    def should_print_path(path):
+        """Determine if the path should be printed, avoiding nested paths."""
+        path = os.path.abspath(path)
+        for printed_path in printed_paths:
+            try:
+                if os.path.commonpath([path, printed_path]) == printed_path:
+                    return False
+            except ValueError:
+                # Paths on different drives; can't have a common path
+                continue
+        return True
+
+    for env in environments:
+        env_settings = config.settings.from_env(env)
+
+        # Get download folder
+        download_folder = env_settings.get('DOWNLOAD_FOLDER')
+        if download_folder and os.path.exists(download_folder):
+            download_folder = os.path.normpath(download_folder)
+            if should_print_path(download_folder):
+                existing_paths.add(download_folder)
+                printed_paths.add(download_folder)
+
+        # Get EQPath
+        eq_path = env_settings.get('EQPATH')
+        if eq_path:
+            eq_path = os.path.normpath(os.path.join(eq_path, "maps"))
+            if os.path.exists(eq_path) and should_print_path(eq_path):
+                existing_paths.add(eq_path)
+                printed_paths.add(eq_path)
+
+        # Special resources
+        special_resources = env_settings.get('SPECIAL_RESOURCES', {})
+        for resource_id, resource_info in special_resources.items():
+            # Get paths from special resources
+            custom_path = resource_info.get('custom_path', '')
+            default_path = resource_info.get('default_path', '')
+
+            paths = set()
+
+            if custom_path:
+                paths.add(os.path.normpath(custom_path))
+            if default_path and download_folder:
+                paths.add(os.path.normpath(os.path.join(download_folder, default_path)))
+
+            for path in paths:
+                if os.path.exists(path) and should_print_path(path):
+                    existing_paths.add(path)
+                    printed_paths.add(path)
+
+    # Also inform about the configuration directory
+    config_dir = os.environ.get('REDFETCH_CONFIG_DIR', '')
+    if config_dir and os.path.exists(config_dir):
+        # Delete configuration files
+        files_to_delete = [
+            os.path.join(config_dir, '.env'),
+            os.path.join(config_dir, 'settings.local.toml')
+        ]
+        
+        # Add any .db files from config root (legacy location)
+        db_files = [f for f in os.listdir(config_dir) if f.endswith('.db')]
+        files_to_delete.extend([os.path.join(config_dir, f) for f in db_files])
+        
+        for file_path in files_to_delete:
+            if os.path.exists(file_path):
+                try:
+                    os.remove(file_path)
+                except Exception as e:
+                    console.print(f"[red]Failed to delete {file_path}: {e}[/red]")
+        
+        # Delete the entire .cache directory
+        cache_dir = os.path.join(config_dir, '.cache')
+        if os.path.isdir(cache_dir):
+            try:
+                _release_disk_caches()
+            except Exception as e:
+                console.print(f"[red]Failed to release cache handles: {e}[/red]")
+            try:
+                import shutil
+                shutil.rmtree(cache_dir)
+            except Exception as e:
+                console.print(f"[red]Failed to delete cache directory: {e}[/red]")
+                # Provide extra context for common Windows multi-user / shared-dir scenarios
+                winerror = getattr(e, "winerror", None)
+                if os.name == "nt" and winerror == 32:
+                    console.print(
+                        "[yellow]Windows reports that the cache is in use by another process. "
+                        "This often happens when another redfetch instance is still running, "
+                        "or when multiple Windows user accounts share the same redfetch folder "
+                        "(for example under C:\\Users\\Public\\redfetch).[/yellow]"
+                    )
+        
+        if should_print_path(config_dir):
+            existing_paths.add(config_dir)
+            printed_paths.add(config_dir)
+
+    if existing_paths:
+        console.print("The following directories may contain files downloaded by redfetch:")
+        for path in sorted(existing_paths):
+            console.print(f" - [cyan]{path}[/cyan]")
+
+        # Generate OS-specific commands to remove the directories
+        commands = generate_removal_commands(existing_paths)
+        write_commands_to_file(commands, existing_paths)
+    else:
+        console.print("[green]No existing directories found that need manual cleanup.[/green]\n")
+
+    if executable_path:
+        # Ask the user if they want to proceed with self-uninstall
+        if Confirm.ask("Would you like to uninstall redfetch's little python environment?"):
+            # Now, perform self-remove
+            self_remove()
+        else:
+            console.print("[yellow]Uninstallation canceled.[/yellow]")
+            sys.exit(0)
+    else:
+        # If executable_path is not set, guide the user to uninstall via pip or pipx
+        console.print("\n[bold]To uninstall redfetch, please run the following command:[/bold]")
+        if install_method == 'pipx':
+            console.print("  [cyan]pipx uninstall redfetch[/cyan]")
+        elif install_method == 'uv':
+            console.print("  [cyan]uv tool uninstall redfetch[/cyan]")
+        else:
+            console.print("  [cyan]pip uninstall redfetch[/cyan]")
+        # Optionally, exit the program
+        sys.exit(0)
+
+
+def generate_removal_commands(paths):
+    """Generate OS-specific commands to remove the given directories."""
+    def deepest_first(path: str) -> tuple[int, str]:
+        depth = path.replace("\\", "/").rstrip("/").count("/")
+        return (-depth, path.casefold())
+
+    system = platform.system()
+    if system == 'Windows':
+        # Generate PowerShell commands
+        console.print("[bold]These directories may be removed manually after you make sure there's nothing you need from them, you can do so by running the following PowerShell commands:[/bold]\n")
+        commands = []
+        for path in sorted(paths, key=deepest_first):
+            escaped_path = path.replace("'", "''")
+            command = f"Remove-Item -LiteralPath '{escaped_path}' -Recurse -Force"
+            commands.append(command)
+            console.print(f"  {command}")
+    else:
+        # Assuming Unix-like system
+        console.print("[bold]You can remove these directories by running the following commands in your terminal:[/bold]\n")
+        commands = []
+        for path in sorted(paths, key=deepest_first):
+            escaped_path = path.replace("'", "'\\''")
+            command = f"rm -rf '{escaped_path}'"
+            commands.append(command)
+            console.print(f"  {command}")
+    console.print("\n[bold yellow]These directories must be removed manually.[/bold yellow]")
+    return commands
+
+
+def write_commands_to_file(commands, paths):
+    """Write the removal commands and additional information to a text file and open it on Windows."""
+    # Only write and open the file on Windows
+    if platform.system() == 'Windows':
+        file_path = os.path.join(os.path.expanduser("~"), "redfetch_removal_commands.txt")
+        with open(file_path, 'w') as file:
+            file.write("Manual Cleanup Instructions:\n")
+            file.write("The following directories may contain files downloaded by redfetch. You can remove them manually if you want:\n")
+            for path in sorted(paths):
+                file.write(f" - {path}\n")
+            file.write("\nMake sure there's nothing you want in them. When ready to delete, you can use:\n\n")
+            
+            for command in commands:
+                file.write(command + '\n')
+        
+        # Automatically open the file with the default text editor
+        try:
+            os.startfile(file_path)
+        except Exception as e:
+            console.print(f"[red]Failed to open the file: {e}[/red]")
+            console.print(f"Please open the file manually: [cyan]{file_path}[/cyan]")
+    else:
+        # On non-Windows systems, the important information is already printed to the console
+        console.print("[yellow]After that, you can remove the redfetch package.[/yellow]")