SetupManager.cs

using System.Diagnostics;
using System.IO.Compression;
using System.Net.Http;

namespace WhisperTranscriber;

public class SetupManager
{
    private const string PythonVersion = "3.11.9";
    private static readonly string PythonZipUrl =
        $"https://www.python.org/ftp/python/{PythonVersion}/python-{PythonVersion}-embed-amd64.zip";
    private const string GetPipUrl = "https://bootstrap.pypa.io/get-pip.py";

    private readonly string _baseDir;
    public string PythonDir => Path.Combine(_baseDir, "python");
    public string PythonExe => Path.Combine(PythonDir, "python.exe");
    public string ModelsDir => Path.Combine(_baseDir, "models");

    public event Action<string, int>? Progress;

    public SetupManager(string baseDir)
    {
        _baseDir = baseDir;
        Directory.CreateDirectory(_baseDir);
        Directory.CreateDirectory(ModelsDir);
    }

    private string BaseMarker => Path.Combine(_baseDir, ".setup_complete");
    private string DiarizeMarker => Path.Combine(_baseDir, ".setup_diarize");

    public bool IsReady() => File.Exists(PythonExe) && File.Exists(BaseMarker);
    public bool IsDiarizeReady() => File.Exists(DiarizeMarker);

    public async Task EnsureInstalledAsync(bool installCuda, bool installDiarize, CancellationToken ct = default)
    {
        if (!File.Exists(PythonExe))
        {
            await DownloadPythonAsync(ct);
        }

        if (!IsReady())
        {
            EnableSitePackages();
            await InstallPipAsync(ct);
            await InstallPackageAsync("faster-whisper", ct, weight: 50);

            if (installCuda)
            {
                await InstallPackageAsync("nvidia-cublas-cu12", ct, weight: 15);
                await InstallPackageAsync("nvidia-cudnn-cu12", ct, weight: 15);
            }
            File.WriteAllText(BaseMarker, DateTime.UtcNow.ToString("o"));
        }

        if (installDiarize && !IsDiarizeReady())
        {
            Report("Installazione pyannote.audio (questo richiede qualche minuto)...", -1);
            await InstallPackageAsync("torch", ct, weight: 30);
            await InstallPackageAsync("torchaudio", ct, weight: 15);
            await InstallPackageAsync("pyannote.audio", ct, weight: 30);
            File.WriteAllText(DiarizeMarker, DateTime.UtcNow.ToString("o"));
        }

        Report("Ambiente pronto", 100);
    }

    private async Task DownloadPythonAsync(CancellationToken ct)
    {
        Report("Download Python embedded...", 5);
        Directory.CreateDirectory(PythonDir);
        var zipPath = Path.Combine(_baseDir, "python.zip");

        using (var http = new HttpClient { Timeout = TimeSpan.FromMinutes(5) })
        using (var response = await http.GetAsync(PythonZipUrl, HttpCompletionOption.ResponseHeadersRead, ct))
        {
            response.EnsureSuccessStatusCode();
            var total = response.Content.Headers.ContentLength ?? 30_000_000;
            await using var src = await response.Content.ReadAsStreamAsync(ct);
            await using var dst = File.Create(zipPath);
            var buf = new byte[81920];
            long readTotal = 0;
            int n;
            while ((n = await src.ReadAsync(buf, ct)) > 0)
            {
                await dst.WriteAsync(buf.AsMemory(0, n), ct);
                readTotal += n;
                var pct = (int)(5 + readTotal * 15.0 / total);
                Report($"Download Python: {readTotal / 1024 / 1024} / {total / 1024 / 1024} MB", pct);
            }
        }

        Report("Estrazione Python...", 22);
        ZipFile.ExtractToDirectory(zipPath, PythonDir, overwriteFiles: true);
        File.Delete(zipPath);
    }

    private void EnableSitePackages()
    {
        var pthFile = Directory.GetFiles(PythonDir, "python*._pth").FirstOrDefault();
        if (pthFile is null) return;
        var content = File.ReadAllText(pthFile);
        if (content.Contains("#import site"))
        {
            content = content.Replace("#import site", "import site");
            File.WriteAllText(pthFile, content);
        }
    }

    private async Task InstallPipAsync(CancellationToken ct)
    {
        var getPipPath = Path.Combine(_baseDir, "get-pip.py");
        if (!File.Exists(Path.Combine(PythonDir, "Scripts", "pip.exe")))
        {
            Report("Download get-pip.py...", 25);
            using var http = new HttpClient { Timeout = TimeSpan.FromMinutes(2) };
            var bytes = await http.GetByteArrayAsync(GetPipUrl, ct);
            await File.WriteAllBytesAsync(getPipPath, bytes, ct);

            Report("Installazione pip...", 30);
            await RunPythonAsync(new[] { getPipPath, "--no-warn-script-location" }, ct);
            File.Delete(getPipPath);
        }
    }

    private async Task InstallPackageAsync(string package, CancellationToken ct, int weight)
    {
        Report($"Installazione {package}...", -1);
        await RunPythonAsync(
            new[] { "-m", "pip", "install", "--no-warn-script-location", "--upgrade", package },
            ct,
            line => Report($"{package}: {line}", -1));
    }

    private async Task RunPythonAsync(string[] args, CancellationToken ct, Action<string>? onLine = null)
    {
        var psi = new ProcessStartInfo
        {
            FileName = PythonExe,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
            CreateNoWindow = true
        };
        foreach (var a in args) psi.ArgumentList.Add(a);

        using var proc = new Process { StartInfo = psi };
        proc.OutputDataReceived += (_, e) => { if (e.Data is not null) onLine?.Invoke(e.Data); };
        proc.ErrorDataReceived += (_, e) => { if (e.Data is not null) onLine?.Invoke(e.Data); };

        proc.Start();
        proc.BeginOutputReadLine();
        proc.BeginErrorReadLine();

        await proc.WaitForExitAsync(ct);
        if (proc.ExitCode != 0)
            throw new InvalidOperationException($"python ha terminato con exit code {proc.ExitCode}");
    }

    private void Report(string message, int percent) => Progress?.Invoke(message, percent);
}