AccountForger-neuerUpload/updates/version.py

"""
Version-Verwaltung - Enthält Versionsinformationen und Hilfsfunktionen
"""

import os
import logging
import json
from typing import Dict, Any, Tuple

# Konfiguriere Logger
logger = logging.getLogger("version")

# Aktuelle Version der Software
CURRENT_VERSION = "1.0.0"

# Build-Informationen
BUILD_DATE = "2025-04-30"
BUILD_NUMBER = "1001"

# Versionsinformationen
VERSION_INFO = {
    "version": CURRENT_VERSION,
    "build_date": BUILD_DATE,
    "build_number": BUILD_NUMBER,
    "channel": "stable",
    "min_platform_version": "10.0.0",
    "compatible_versions": ["0.9.0", "0.9.1", "0.9.2"]
}

def get_version() -> str:
    """
    Gibt die aktuelle Version der Software zurück.
    
    Returns:
        str: Aktuelle Version
    """
    return CURRENT_VERSION

def get_version_info() -> Dict[str, Any]:
    """
    Gibt detaillierte Versionsinformationen zurück.
    
    Returns:
        Dict[str, Any]: Versionsinformationen
    """
    return VERSION_INFO.copy()

def parse_version(version_str: str) -> Tuple[int, ...]:
    """
    Parst eine Versionszeichenfolge in ein vergleichbares Tupel.
    
    Args:
        version_str: Versionszeichenfolge im Format x.y.z
        
    Returns:
        Tuple[int, ...]: Geparste Version als Tupel
    """
    try:
        return tuple(map(int, version_str.split('.')))
    except ValueError:
        # Fallback bei ungültigem Format
        logger.warning(f"Ungültiges Versionsformat: {version_str}")
        return (0, 0, 0)

def is_newer_version(version_a: str, version_b: str) -> bool:
    """
    Prüft, ob Version A neuer ist als Version B.
    
    Args:
        version_a: Erste Version
        version_b: Zweite Version
        
    Returns:
        bool: True, wenn Version A neuer ist als Version B, False sonst
    """
    version_a_tuple = parse_version(version_a)
    version_b_tuple = parse_version(version_b)
    
    return version_a_tuple > version_b_tuple

def is_compatible_version(version: str) -> bool:
    """
    Prüft, ob die angegebene Version mit der aktuellen Version kompatibel ist.
    
    Args:
        version: Zu prüfende Version
        
    Returns:
        bool: True, wenn die Version kompatibel ist, False sonst
    """
    # Wenn es die gleiche Version ist, ist sie kompatibel
    if version == CURRENT_VERSION:
        return True
    
    # Prüfe, ob die Version in der Liste der kompatiblen Versionen ist
    if version in VERSION_INFO.get("compatible_versions", []):
        return True
    
    # Wenn es eine neuere Version ist, nehmen wir an, sie ist kompatibel
    if is_newer_version(version, CURRENT_VERSION):
        return True
    
    # Ansonsten ist die Version nicht kompatibel
    return False

def get_version_description() -> str:
    """
    Gibt eine menschenlesbare Beschreibung der Versionsinfos zurück.
    
    Returns:
        str: Versionsbeschreibung
    """
    info = get_version_info()
    
    description = [
        f"Version: {info['version']}",
        f"Build: {info['build_number']} ({info['build_date']})",
        f"Kanal: {info['channel']}"
    ]
    
    return "\n".join(description)

def save_version_info(file_path: str = "version_info.json") -> bool:
    """
    Speichert die Versionsinformationen in einer Datei.
    
    Args:
        file_path: Pfad zur Datei
        
    Returns:
        bool: True bei Erfolg, False bei Fehler
    """
    try:
        with open(file_path, 'w') as f:
            json.dump(VERSION_INFO, f, indent=2)
        logger.info(f"Versionsinformationen gespeichert in {file_path}")
        return True
    except Exception as e:
        logger.error(f"Fehler beim Speichern der Versionsinformationen: {e}")
        return False

def load_version_info(file_path: str = "version_info.json") -> Dict[str, Any]:
    """
    Lädt Versionsinformationen aus einer Datei.
    
    Args:
        file_path: Pfad zur Datei
        
    Returns:
        Dict[str, Any]: Geladene Versionsinformationen oder Standardwerte
    """
    try:
        if os.path.exists(file_path):
            with open(file_path, 'r') as f:
                return json.load(f)
        else:
            logger.warning(f"Versionsinformationsdatei nicht gefunden: {file_path}")
            return VERSION_INFO.copy()
    except Exception as e:
        logger.error(f"Fehler beim Laden der Versionsinformationen: {e}")
        return VERSION_INFO.copy()


# Beispielnutzung, wenn direkt ausgeführt
if __name__ == "__main__":
    # Konfiguriere Logging
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    )
    
    # Versionsinformationen anzeigen
    print("Aktuelle Version:", get_version())
    print("\nVersionsinformationen:")
    info = get_version_info()
    for key, value in info.items():
        print(f"  {key}: {value}")
    
    # Versionsbeschreibung
    print("\nVersionsbeschreibung:")
    print(get_version_description())
    
    # Versionsvergleich
    test_versions = ["0.9.0", "1.0.0", "1.0.1", "1.1.0", "2.0.0"]
    print("\nVersionsvergleiche:")
    for version in test_versions:
        is_newer = is_newer_version(version, CURRENT_VERSION)
        is_compat = is_compatible_version(version)
        print(f"  {version}: Neuer als aktuell: {is_newer}, Kompatibel: {is_compat}")
    
    # Versionsinformationen speichern
    save_version_info("test_version_info.json")
    print("\nVersionsinformationen gespeichert in test_version_info.json")