Initial commit

updates/version.py

@@ -0,0 +1,193 @@
+"""
+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")