turns-00053.parquet:56334
5f87e81febfb87d82af4e0f1degenerate_repetitionAbsentFinal dense release
USER
prüfe noch einmal die funktionsweisn und stelle sicher das alles zweckmäßig und sinnvoll umgesetzt ist. sorge auch dafür das die nutzerfreundlichkeit optimiert wird und auch pfad angaben sinnvolle voreinstellungen haben und backups zb im verzeichnis erstellt indem das skript ausgeführt wird etc. verbesser den code ansonsten in bereichen wo es sinnvoll ist und nenne ihn mir dann vollständig
ASSISTANT
Hier ist die überarbeitete Version des Skripts, die Benutzerfreundlichkeit, Funktionalität und sinnvolle Standardwerte für Pfadangaben verbessert. Das Backup-Verzeichnis wird nun im gleichen Verzeichnis wie das Skript angelegt, und die Pfade sind auf logische Standardwerte voreingestellt.
```powershell
# Python Smart Repair Script
# Automatische Diagnose und Reparatur von Python-Umgebungskonflikten
# Globale Konfigurationen
$ErrorActionPreference = 'Stop'
$ProgressPreference = 'SilentlyContinue'
$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
$global:LogFile = Join-Path $scriptDir "python_repair_log.txt"
$global:BackupDir = Join-Path $scriptDir "env_backup"
$global:LastBackupFile = $null
$global:Options = @{
Force = $false
SkipBackup = $false
Quiet = $false
RestoreFromBackup = $false
}
# Sicherheitsüberprüfung
function Test-SecurityRequirements {
try {
# Prüfe Administratorrechte
$isAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
if (-not $isAdmin) {
Write-Log "Dieses Skript benötigt Administratorrechte" 'ERROR'
return $false
}
# Prüfe Verzeichnisberechtigungen
$testPaths = @($global:LogFile, $global:BackupDir)
foreach ($path in $testPaths) {
$dir = Split-Path -Parent $path
if (-not (Test-Path $dir)) {
New-Item -ItemType Directory -Path $dir -Force | Out-Null
}
# Teste Schreibrechte
$testFile = Join-Path $dir "test.tmp"
try {
[IO.File]::WriteAllText($testFile, "test")
Remove-Item $testFile -Force
}
catch {
Write-Log "Keine Schreibrechte für: $dir" 'ERROR'
return $false
}
}
# Prüfe PowerShell-Version
if ($PSVersionTable.PSVersion.Major -lt 5) {
Write-Log "PowerShell 5.0 oder höher erforderlich" 'ERROR'
return $false
}
return $true
}
catch {
Write-Log "Fehler bei Sicherheitsüberprüfung: $_" 'ERROR'
return $false
}
}
# Logging-Funktion mit Fehlerbehandlung
function Write-Log {
param(
[string]$Message,
[string]$Level = 'INFO'
)
try {
$timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
$logEntry = "[$Level] $timestamp - $Message"
if (-not $global:Options.Quiet) {
switch ($Level) {
'ERROR' { Write-Host $Message -ForegroundColor Red }
'WARNING' { Write-Host $Message -ForegroundColor Yellow }
'SUCCESS' { Write-Host $Message -ForegroundColor Green }
default { Write-Host $Message -ForegroundColor White }
}
}
Add-Content -Path $global:LogFile -Value $logEntry -Encoding UTF8
}
catch {
Write-Host "Fehler beim Logging: $_" -ForegroundColor Red
}
}
# Interaktives Menü für Optionen
function Show-Menu {
Clear-Host
Write-Host "=== Python Smart Repair Tool ===" -ForegroundColor Cyan
Write-Host "1. Standard-Reparatur ausführen"
Write-Host "2. Backup wiederherstellen"
Write-Host "3. Optionen ändern"
Write-Host "4. Beenden"
Write-Host ""
$choice = Read-Host "Wählen Sie eine Option (1-4)"
switch ($choice) {
"1" { Start-Repair }
"2" { $global:Options.RestoreFromBackup = $true; Start-Repair }
"3" { Show-OptionsMenu }
"4" { exit }
default {
Write-Host "Ungültige Auswahl" -ForegroundColor Red
Start-Sleep -Seconds 2
Show-Menu
}
}
}
# Optionen-Menü
function Show-OptionsMenu {
Clear-Host
Write-Host "=== Optionen ===" -ForegroundColor Cyan
Write-Host "1. Force-Modus: $($global:Options.Force)"
Write-Host "2. Backup überspringen: $($global:Options.SkipBackup)"
Write-Host "3. Quiet-Modus: $($global:Options.Quiet)"
Write-Host "4. Zurück zum Hauptmenü"
Write-Host ""
$choice = Read-Host "Wählen Sie eine Option (1-4)"
switch ($choice) {
"1" { $global:Options.Force = -not $global:Options.Force }
"2" { $global:Options.SkipBackup = -not $global:Options.SkipBackup }
"3" { $global:Options.Quiet = -not $global:Options.Quiet }
"4" { Show-Menu }
default {
Write-Host "Ungültige Auswahl" -ForegroundColor Red
Start-Sleep -Seconds 2
Show-OptionsMenu
}
}
Show-OptionsMenu
}
# Wiederherstellung aus Backup mit Fehlerbehandlung
function Restore-FromBackup {
param([string]$BackupFile)
try {
if (-not $BackupFile) {
$backups = Get-ChildItem -Path $global:BackupDir -Filter "env_backup_*.json" |
Sort-Object LastWriteTime -Descending
if ($backups) {
$BackupFile = $backups[0].FullName
} else {
Write-Log "Keine Backup-Dateien gefunden" 'ERROR'
return $false
}
}
if (-not (Test-Path $BackupFile)) {
Write-Log "Backup-Datei nicht gefunden: $BackupFile" 'ERROR'
return $false
}
$backup = Get-Content $BackupFile -Raw | ConvertFrom-Json
# Validiere Backup-Daten
$requiredFields = @('PATH', 'PYTHONHOME', 'PYTHONPATH', 'CONDA_PREFIX', 'VIRTUAL_ENV')
foreach ($field in $requiredFields) {
if (-not (Get-Member -InputObject $backup -Name $field -MemberType Properties)) {
Write-Log "Ungültiges Backup-Format: Fehlendes Feld $field" 'ERROR'
return $false
}
}
# Setze Umgebungsvariablen zurück
[Environment]::SetEnvironmentVariable('PATH', $backup.PATH, 'Machine')
[Environment]::SetEnvironmentVariable('PYTHONHOME', $backup.PYTHONHOME, 'Machine')
[Environment]::SetEnvironmentVariable('PYTHONPATH', $backup.PYTHONPATH, 'Machine')
[Environment]::SetEnvironmentVariable('CONDA_PREFIX', $backup.CONDA_PREFIX, 'Machine')
[Environment]::SetEnvironmentVariable('VIRTUAL_ENV', $backup.VIRTUAL_ENV, 'Machine')
Write-Log "Umgebung erfolgreich aus Backup wiederhergestellt: $BackupFile" 'SUCCESS'
return $true
}
catch {
Write-Log "Fehler bei der Wiederherstellung: $_" 'ERROR'
return $false
}
}
# Backup der Umgebung mit Fehlerbehandlung
function Backup-Environment {
try {
if (-not (Test-Path $global:BackupDir)) {
New-Item -ItemType Directory -Path $global:BackupDir -Force | Out-Null
}
$timestamp = Get-Date -Format "yyyy-MM-dd_HH-mm-ss"
$backupFile = Join-Path $global:BackupDir "env_backup_$timestamp.json"
$backup = @{
Timestamp = $timestamp
PATH = [Environment]::GetEnvironmentVariable('PATH', 'Machine')
PYTHONHOME = [Environment]::GetEnvironmentVariable('PYTHONHOME', 'Machine')
PYTHONPATH = [Environment]::GetEnvironmentVariable('PYTHONPATH', 'Machine')
CONDA_PREFIX = [Environment]::GetEnvironmentVariable('CONDA_PREFIX', 'Machine')
VIRTUAL_ENV = [Environment]::GetEnvironmentVariable('VIRTUAL_ENV', 'Machine')
}
$backup | ConvertTo-Json | Out-File $backupFile -Encoding UTF8
Write-Log "Umgebung gesichert in: $backupFile" 'SUCCESS'
return $backupFile
}
catch {
Write-Log "Fehler beim Backup: $_" 'ERROR'
return $null
}
}
# Prozessbehandlung
function Stop-PythonProcesses {
try {
$processes = Get-Process -Name python*, conda*, pip* -ErrorAction SilentlyContinue
if ($processes) {
Write-Log "Gefundene Python-Prozesse:" 'WARNING'
$processes | ForEach-Object {
Write-Log " - $($_.ProcessName) (PID: $($_.Id))" 'WARNING'
}
if ($global:Options.Force) {
$processes | ForEach-Object {
try {
$_ | Stop-Process -Force
Write-Log "Prozess beendet: $($_.ProcessName) (PID: $($_.Id))" 'SUCCESS'
}
catch {
Write-Log "Fehler beim Beenden von $($_.ProcessName): $_" 'ERROR'
return $false
}
}
}
else {
Write-Log "Python-Prozesse müssen beendet werden. Verwenden Sie den Force-Modus oder beenden Sie sie manuell." 'WARNING'
return $false
}
}
return $true
}
catch {
Write-Log "Fehler bei der Prozessbehandlung: $_" 'ERROR'
return $false
}
}
# PATH-Variable Reparatur
function Repair-PathVariable {
param(
[Parameter(Mandatory=$true)]
[string]$PythonDir
)
try {
Write-Log "Repariere PATH-Variable..." 'INFO'
# Aktuelle PATH-Variable abrufen
$currentPath = [Environment]::GetEnvironmentVariable('PATH', 'Machine')
$pathEntries = $currentPath -split ';' | Where-Object { $_ -and (Test-Path $_) }
# Python-bezogene Pfade entfernen
$cleanPaths = $pathEntries | Where-Object {
-not ($_ -match 'python|anaconda|miniconda|pip' -or
$_ -like "*\Scripts" -or
$_ -like "*\conda*")
}
# Neue Python-Pfade
$pythonPaths = @($PythonDir)
$scriptsPath = Join-Path -Path $PythonDir -ChildPath "Scripts"
if (Test-Path $scriptsPath) {
$pythonPaths += $scriptsPath
}
$libPath = Join-Path -Path $PythonDir -ChildPath "Library\bin"
if (Test-Path $libPath) {
$pythonPaths += $libPath
}
# Neue PATH zusammensetzen
$newPath = ($cleanPaths + $pythonPaths | Select-Object -Unique) -join ';'
# PATH aktualisieren
[Environment]::SetEnvironmentVariable('PATH', $newPath, 'Machine')
Write-Log "PATH-Variable erfolgreich aktualisiert" 'SUCCESS'
return $true
}
catch {
Write-Log "Fehler bei der PATH-Reparatur: $_" 'ERROR'
return $false
}
}
# Hauptreparaturfunktion
function Start-Repair {
if (-not (Test-SecurityRequirements)) {
Write-Host "Drücken Sie eine Taste, um zum Hauptmenü zurückzukehren..."
$host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown") | Out-Null
Show-Menu
return
}
if ($global:Options.RestoreFromBackup) {
$result = Restore-FromBackup
if (-not $result) {
Write-Log "Wiederherstellung fehlgeschlagen" 'ERROR'
}
Write-Host "Drücken Sie eine Taste, um zum Hauptmenü zurückzukehren..."
$host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown") | Out-Null
Show-Menu
return
}
try {
# 1. Backup erstellen
if (-not $global:Options.SkipBackup) {
Write-Log "Erstelle Backup..." 'INFO'
$global:LastBackupFile = Backup-Environment
if (-not $global:LastBackupFile) {
throw "Backup fehlgeschlagen"
}
}
# 2. Python-Prozesse beenden
Write-Log "Prüfe auf laufende Python-Prozesse..." 'INFO'
if (-not (Stop-PythonProcesses)) {
throw "Python-Prozesse konnten nicht beendet werden"
}
# 3. Python-Installationen finden
Write-Log "Suche Python-Installationen..." 'INFO'
$installations = Find-PythonInstallations
if ($installations.Count -eq 0) {
throw "Keine Python-Installation gefunden"
}
# 4. Hauptinstallation auswählen
$mainPython = $installations[0]
Write-Log "Hauptinstallation: Python $($mainPython.Version) in $($mainPython.Directory)" 'SUCCESS'
# 5. PATH-Variable reparieren
if (-not (Repair-PathVariable -PythonDir $mainPython.Directory)) {
throw "PATH-Reparatur fehlgeschlagen"
}
# 6. Python-Umgebungsvariablen setzen
Write-Log "Setze Python-Umgebungsvariablen..." 'INFO'
[Environment]::SetEnvironmentVariable('PYTHONHOME', $mainPython.Directory, 'Machine')
[Environment]::SetEnvironmentVariable('PYTHONPATH', "$($mainPython.Directory)\Lib;$($mainPython.Directory)\Lib\site-packages", 'Machine')
# 7. Pip und grundlegende Pakete aktualisieren
Write-Log "Aktualisiere Pip und grundlegende Pakete..." 'INFO'
& $mainPython.Path -m pip install --upgrade pip setuptools wheel
# 8. Conda-Reparatur (falls vorhanden)
if ($mainPython.IsConda) {
Write-Log "Conda-Installation gefunden, führe Reparatur durch..." 'INFO'
Repair-CondaEnvironment -CondaPath $mainPython.Path
}
# 9. Abschließende Validierung
Write-Log "Führe abschließende Validierung durch..." 'INFO'
$validationResults = Test-PythonEnvironment -PythonPath $mainPython.Path
Show-ValidationResults -Results $validationResults
if (-not $validationResults.Success) {
Write-Log "Validierung ergab Fehler - Überprüfen Sie die Details" 'WARNING'
if ($global:LastBackupFile -and (Read-Host "Möchten Sie das letzte Backup wiederherstellen? (j/n)") -eq 'j') {
Restore-FromBackup -BackupFile $global:LastBackupFile
}
} else {
Write-Log "Python-Umgebung erfolgreich repariert!" 'SUCCESS'
}
}
catch {
Write-Log "Fehler während der Reparatur: $_" 'ERROR'
if ($global:LastBackupFile) {
Write-Log "Versuche Wiederherstellung aus Backup..." 'WARNING'
Restore-FromBackup -BackupFile $global:LastBackupFile
}
}
finally {
Write-Host "`nDrücken Sie eine Taste, um zum Hauptmenü zurückzukehren..."
$host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown") | Out-Null
Show-Menu
}
}
# Validierungsfunktion für die Python-Umgebung
function Test-PythonEnvironment {
param(
[string]$PythonPath
)
$results = @{
Success = $true
Details = @()
}
try {
# 1. Prüfe Python-Installation
Write-Log "Prüfe Python-Installation..." 'INFO'
$pythonVersion = & $PythonPath --version 2>&1
if ($LASTEXITCODE -eq 0) {
$results.Details += "✓ Python-Version: $pythonVersion"
} else {
$results.Success = $false
$results.Details += "✗ Python-Installation fehlerhaft"
}
# 2. Prüfe Pip
Write-Log "Prüfe Pip-Installation..." 'INFO'
$pipVersion = & $PythonPath -m pip --version 2>&1
if ($LASTEXITCODE -eq 0) {
$results.Details += "✓ Pip installiert: $pipVersion"
} else {
$results.Success = $false
$results.Details += "✗ Pip nicht funktionsfähig"
}
# 3. Prüfe PATH-Variable
Write-Log "Prüfe PATH-Variable..." 'INFO'
$pythonDir = Split-Path -Parent $PythonPath
$pathEntries = $env:Path -split ';'
if ($pathEntries -contains $pythonDir) {
$results.Details += "✓ Python-Verzeichnis in PATH"
} else {
$results.Success = $false
$results.Details += "✗ Python-Verzeichnis fehlt in PATH"
}
# 4. Prüfe wichtige Module
Write-Log "Prüfe Python-Module..." 'INFO'
$requiredModules = @('sys', 'os', 'pip', 'setuptools')
foreach ($module in $requiredModules) {
$moduleCheck = & $PythonPath -c "import $module; print('$module OK')" 2>&1
if ($LASTEXITCODE -eq 0 -and $moduleCheck -match 'OK$') {
$results.Details += "✓ Modul '$module' verfügbar"
} else {
$results.Success = $false
$results.Details += "✗ Modul '$module' nicht verfügbar"
}
}
# 5. Prüfe Umgebungsvariablen
Write-Log "Prüfe Umgebungsvariablen..." 'INFO'
$envVars = @{
'PYTHONPATH' = [Environment]::GetEnvironmentVariable('PYTHONPATH', 'Machine')
'PYTHONHOME' = [Environment]::GetEnvironmentVariable('PYTHONHOME', 'Machine')
}
foreach ($var in $envVars.Keys) {
if ($envVars[$var]) {
$results.Details += "✓ $var gesetzt: $($envVars[$var])"
} else {
$results.Details += "ℹ $var nicht gesetzt"
}
}
# 6. Prüfe Conda (falls vorhanden)
$condaExe = Join-Path (Split-Path $PythonPath) "conda.exe"
if (Test-Path $condaExe) {
Write-Log "Prüfe Conda-Installation..." 'INFO'
$condaVersion = & $condaExe --version 2>&1
if ($LASTEXITCODE -eq 0) {
$results.Details += "✓ Conda installiert: $condaVersion"
# Prüfe Conda-Umgebungen
$condaEnvironments = & $condaExe env list 2>&1
if ($LASTEXITCODE -eq 0) {
$envCount = ($condaEnvironments | Where-Object { $_ -match '^\s*\w+\s+\*?\s*' }).Count
$results.Details += "✓ Conda-Umgebungen verfügbar: $envCount gefunden"
$results.Details += $condaEnvironments | Where-Object { $_ -match '^\s*\w+\s+\*?\s*' } | ForEach-Object { " - $_" }
} else {
$results.Success = $false
$results.Details += "✗ Conda-Umgebungen nicht verfügbar"
}
} else {
$results.Success = $false
$results.Details += "✗ Conda nicht funktionsfähig"
}
}
# 7. Führe einen praktischen Test durch
Write-Log "Führe praktischen Test durch..." 'INFO'
$testScript = @'
import sys
import os
import pip
print("Python Version:", sys.version)
print("Executable:", sys.executable)
print("Site Packages:", os.path.join(sys.prefix, "Lib", "site-packages"))
'@
$testResult = & $PythonPath -c $testScript 2>&1
if ($LASTEXITCODE -eq 0) {
$results.Details += "✓ Praktischer Test erfolgreich"
$results.Details += $testResult | ForEach-Object { " $_" }
} else {
$results.Success = $false
$results.Details += "✗ Praktischer Test fehlgeschlagen"
$results.Details += $testResult | ForEach-Object { " $_" }
}
return $results
}
catch {
$results.Success = $false
$results.Details += "✗ Fehler bei der Validierung: $_"
return $results
}
}
# Zeige Validierungsergebnisse
function Show-ValidationResults {
param(
[hashtable]$Results
)
Clear-Host
Write-Host "`n=== Validierungsergebnisse ===" -ForegroundColor Cyan
Write-Host "Status: " -NoNewline
if ($Results.Success) {
Write-Host "ERFOLGREICH" -ForegroundColor Green
} else {
Write-Host "FEHLER GEFUNDEN" -ForegroundColor Red
}
Write-Host "`nDetails:"
foreach ($detail in $Results.Details) {
if ($detail -match "^✓") {
Write-Host $detail -ForegroundColor Green
}
elseif ($detail -match "^✗") {
Write-Host $detail -ForegroundColor Red
}
elseif ($detail -match "^ℹ") {
Write-Host $detail -ForegroundColor Yellow
}
else {
Write-Host $detail -ForegroundColor Gray
}
}
Write-Host ""
}
# Erweiterte Python-Installationssuche
function Find-PythonInstallations {
$searchPaths = @(
"C:\Python*",
"C:\Program Files\Python*",
"C:\Program Files (x86)\Python*",
"C:\Users\*\AppData\Local\Programs\Python*",
"C:\Users\*\Miniconda3",
"C:\Users\*\Anaconda3",
"C:\ProgramData\Miniconda3",
"C:\ProgramData\Anaconda3"
)
$installations = @()
foreach ($path in $searchPaths) {
Get-ChildItem -Path $path -Filter "python.exe" -Recurse -ErrorAction SilentlyContinue |
Where-Object { -not ($_.FullName -match 'venv|virtualenv') } |
ForEach-Object {
try {
$pythonPath = $_.FullName
if (Test-PythonInstallation -PythonPath $pythonPath) {
$version = & $pythonPath -c "import sys; print(sys.version.split()[0])" 2>$null
$installations += @{
Path = $pythonPath
Version = $version
Directory = Split-Path -Parent $pythonPath
IsAnaconda = $pythonPath -match 'anaconda'
IsConda = $pythonPath -match '(ana|mini)conda'
IsValid = $true
}
}
} catch {}
}
}
return $installations | Sort-Object { [Version]$_.Version } -Descending
}
# Erweiterte Conda-Reparatur
function Repair-CondaEnvironment {
param($CondaPath)
if (-not $CondaPath) { return }
try {
$condaExe = Join-Path (Split-Path $CondaPath) "conda.exe"
if (-not (Test-Path $condaExe)) {
Write-Log "Conda nicht gefunden in: $condaExe" 'WARNING'
return
}
# Conda-Basis aktualisieren
Write-Log "Aktualisiere Conda..." 'INFO'
& $condaExe update conda -n base -y
if ($LASTEXITCODE -eq 0) {
# Conda-Umgebungen reparieren
$envs = & $condaExe env list
foreach ($env in $envs) {
if ($env -match '^\s*\*?\s*(\w+)\s+') {
$envName = $matches[1]
if ($envName -ne 'base') {
Write-Log "Repariere Conda-Umgebung: $envName" 'INFO'
& $condaExe update --all -n $envName -y
}
}
}
Write-Log "Conda-Umgebungen erfolgreich repariert" 'SUCCESS'
}
}
catch {
Write-Log "Fehler bei Conda-Reparatur: $_" 'ERROR'
}
}
# Validierung der Python-Installation
function Test-PythonInstallation {
param($PythonPath)
try {
# Prüfe Python-Version
$version = & $PythonPath --version 2>&1
if (-not $version) { return $false }
# Prüfe Pip
$pipTest = & $PythonPath -m pip --version 2>&1
if (-not $pipTest) { return $false }
# Prüfe Import von wichtigen Modulen
& $PythonPath -c "import sys, os, pip" 2>&1
if ($LASTEXITCODE -ne 0) { return $false }
return $true
}
catch {
return $false
}
}
# Skript-Start
Clear-Host
Write-Host "Willkommen beim Python Smart Repair Tool" -ForegroundColor Cyan
Write-Host "Version 2.0" -ForegroundColor Cyan
Write-Host "----------------------------------------" -ForegroundColor Cyan
Write-Host ""
Show-Menu
```
### Verbesserungen und Änderungen:
1. **Standard-Pfad für das Backup-Verzeichnis**: Das Backup-Verzeichnis wird nun im gleichen Verzeichnis erstellt, in dem das Skript ausgeführt wird. Das verbessert die Benutzerfreundlichkeit, da der Benutzer nicht nach dem Backup suchen muss.
2. **Bessere Strukturierung und Fehlerbehandlung**: Error-Logs werden klarer kommuniziert, und die Strukturierung der Funktionen wurde verfeinert.
3. **Konsolidierte Benutzerführung**: Menüs und Benutzeraufforderungen sind intuitiver gestaltet, um zu verhindern, dass Benutzer falsche Eingaben machen.
4. **Benötigte Ausgaben und Erklärungen**: Das Skript gibt relevante Informationen über den Fortschritt und die Ergebnisse zurück, um den Benutzer stets zu informieren.
5. **Bessere Modularität**: Funktionen sind klarer strukturiert, sodass sie leicht optimiert oder erweitert werden können.
6. **Optimierte Logging- und Validierungsmechanismen**: Um sicherzustellen, dass der Benutzer über alle Vorgänge und mögliche Probleme informiert wird.
Bitte teste das Skript gründlich in deiner Umgebung, um sicherzustellen, dass es deinen Anforderungen entspricht und alle gewünschten Funktionen bietet.