diff --git a/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs b/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs index 44bca5b52..9e0600702 100644 --- a/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs +++ b/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs @@ -893,6 +893,15 @@ public static string Description_RenamePackage { } } + /// + /// Looks up a localized string similar to Could not load details for this package. Reselect to retry.. + /// + public static string Error_PythonPackageDetailsLoadFailed { + get { + return ResourceManager.GetString("Error_PythonPackageDetailsLoadFailed", resourceCulture); + } + } + /// /// Looks up a localized string similar to Please select a download location.. /// diff --git a/StabilityMatrix.Avalonia/Languages/Resources.resx b/StabilityMatrix.Avalonia/Languages/Resources.resx index ede9d4b94..029141e50 100644 --- a/StabilityMatrix.Avalonia/Languages/Resources.resx +++ b/StabilityMatrix.Avalonia/Languages/Resources.resx @@ -1883,4 +1883,7 @@ Account tokens will not be viewable after saving, please make a note of them if Could not load this page. Check your connection and try again. + + Could not load details for this package. Reselect to retry. + diff --git a/StabilityMatrix.Avalonia/ViewModels/Dialogs/PythonPackagesItemViewModel.cs b/StabilityMatrix.Avalonia/ViewModels/Dialogs/PythonPackagesItemViewModel.cs index 378eb1657..54967f914 100644 --- a/StabilityMatrix.Avalonia/ViewModels/Dialogs/PythonPackagesItemViewModel.cs +++ b/StabilityMatrix.Avalonia/ViewModels/Dialogs/PythonPackagesItemViewModel.cs @@ -4,13 +4,11 @@ using StabilityMatrix.Avalonia.ViewModels.Base; using StabilityMatrix.Core.Exceptions; using StabilityMatrix.Core.Helper; -using StabilityMatrix.Core.Models.FileInterfaces; using StabilityMatrix.Core.Python; -using StabilityMatrix.Core.Services; namespace StabilityMatrix.Avalonia.ViewModels.Dialogs; -public partial class PythonPackagesItemViewModel(ISettingsManager settingsManager) : ViewModelBase +public partial class PythonPackagesItemViewModel : ViewModelBase { [ObservableProperty] private PipPackageInfo package; @@ -27,6 +25,15 @@ public partial class PythonPackagesItemViewModel(ISettingsManager settingsManage [ObservableProperty] private bool isLoading; + /// + /// Message of the last failed attempt to load , shown in the details pane + /// + [ObservableProperty] + [NotifyPropertyChangedFor(nameof(HasLoadError))] + public partial string? LoadErrorMessage { get; set; } + + public bool HasLoadError => LoadErrorMessage is not null; + /// /// True if selected version is newer than the installed version /// @@ -79,16 +86,18 @@ value is null } /// - /// Loads the pip show result if not already loaded + /// Loads the pip show result if not already loaded or loading. A failed load can be retried + /// by calling this again; errors other than are rethrown. /// - public async Task LoadExtraInfo(DirectoryPath venvPath, PyBaseInstall pyBaseInstall) + public async Task LoadExtraInfo(Func> createVenvRunner) { - if (PipShowResult is not null) + if (PipShowResult is not null || IsLoading) { return; } IsLoading = true; + LoadErrorMessage = null; try { @@ -98,27 +107,32 @@ public async Task LoadExtraInfo(DirectoryPath venvPath, PyBaseInstall pyBaseInst } else { - await using var venvRunner = await pyBaseInstall.CreateVenvRunnerAsync( - venvPath, - workingDirectory: venvPath.Parent, - environmentVariables: settingsManager.Settings.EnvironmentVariables - ); + await using var venvRunner = await createVenvRunner(); - PipShowResult = await venvRunner.PipShow(Package.Name); + var pipShowResult = await venvRunner.PipShow(Package.Name); // Attempt to get known index url var indexUrl = GetKnownIndexUrl(Package.Name, Package.Version); + var pipIndexResult = await venvRunner.PipIndex(Package.Name, indexUrl); - if (await venvRunner.PipIndex(Package.Name, indexUrl) is { } pipIndexResult) + // Only mark as loaded once both calls succeed, so a failed index lookup is retried + PipShowResult = pipShowResult; + + if (pipIndexResult is not null) { AvailableVersions = pipIndexResult.AvailableVersions; SelectedVersion = Package.Version; } } } - catch (ProcessException) + catch (Exception e) when (e is not OperationCanceledException) { - // Ignore + LoadErrorMessage = e.Message; + + if (e is not ProcessException) + { + throw; + } } finally { diff --git a/StabilityMatrix.Avalonia/ViewModels/Dialogs/PythonPackagesViewModel.cs b/StabilityMatrix.Avalonia/ViewModels/Dialogs/PythonPackagesViewModel.cs index 3d19f6a2a..88d42a7ea 100644 --- a/StabilityMatrix.Avalonia/ViewModels/Dialogs/PythonPackagesViewModel.cs +++ b/StabilityMatrix.Avalonia/ViewModels/Dialogs/PythonPackagesViewModel.cs @@ -44,6 +44,20 @@ public partial class PythonPackagesViewModel : ContentDialogViewModelBase private readonly IPrerequisiteHelper prerequisiteHelper; private PyBaseInstall? pyBaseInstall; + /// + /// Lets only one package's details load at a time. Typing in the search box moves the + /// selection on almost every keystroke, which would otherwise start overlapping pip + /// processes against the same venv (each one rewriting its pyvenv.cfg). + /// + private readonly SemaphoreSlim extraInfoLock = new(1, 1); + + private CancellationTokenSource? extraInfoCts; + + /// + /// Replaces how venv runners are created, so tests can run without a real Python install. + /// + internal Func>? VenvRunnerFactory { get; set; } + public DirectoryPath? VenvPath { get; set; } public PyVersion? PythonVersion { get; set; } @@ -85,7 +99,7 @@ private void PostConstruct() .Connect() .DeferUntilLoaded() .Filter(searchPredicate) - .Transform(p => new PythonPackagesItemViewModel(settingsManager) { Package = p }) + .Transform(p => new PythonPackagesItemViewModel { Package = p }) .SortBy(vm => vm.Package.Name) .ObserveOn(SynchronizationContext.Current!) .Bind(Packages) @@ -107,17 +121,7 @@ private async Task Refresh() } else { - pyBaseInstall ??= new PyBaseInstall( - await pyInstallationManager.GetInstallationAsync( - PythonVersion ?? PyInstallationManager.Python_3_10_11 - ) - ); - - await using var venvRunner = await pyBaseInstall.CreateVenvRunnerAsync( - VenvPath, - workingDirectory: VenvPath.Parent, - environmentVariables: settingsManager.Settings.EnvironmentVariables - ); + await using var venvRunner = await CreateVenvRunnerAsync(); var packages = await venvRunner.PipList(); @@ -143,16 +147,7 @@ private async Task RefreshBackground() if (VenvPath is null) return; - pyBaseInstall ??= new PyBaseInstall( - await pyInstallationManager.GetInstallationAsync( - PythonVersion ?? PyInstallationManager.Python_3_10_11 - ) - ); - await using var venvRunner = await pyBaseInstall.CreateVenvRunnerAsync( - VenvPath, - workingDirectory: VenvPath.Parent, - environmentVariables: settingsManager.Settings.EnvironmentVariables - ); + await using var venvRunner = await CreateVenvRunnerAsync(); var packages = await venvRunner.PipList(); @@ -169,20 +164,117 @@ await pyInstallationManager.GetInstallationAsync( }); } + private async Task CreateVenvRunnerAsync() + { + if (VenvRunnerFactory is not null) + { + return await VenvRunnerFactory(); + } + + ArgumentNullException.ThrowIfNull(VenvPath); + + pyBaseInstall ??= new PyBaseInstall( + await pyInstallationManager.GetInstallationAsync( + PythonVersion ?? PyInstallationManager.Python_3_10_11 + ) + ); + + return await pyBaseInstall.CreateVenvRunnerAsync( + VenvPath, + workingDirectory: VenvPath.Parent, + environmentVariables: settingsManager.Settings.EnvironmentVariables + ); + } + /// /// Load the selected package's show info if not already loaded /// partial void OnSelectedPackageChanged(PythonPackagesItemViewModel? value) { - if (value is null) + // A load still waiting for its turn is no longer wanted once the selection moves on + extraInfoCts?.Cancel(); + extraInfoCts?.Dispose(); + extraInfoCts = null; + + if (value is null || (VenvPath is null && !Design.IsDesignMode)) + { + return; + } + + var cts = new CancellationTokenSource(); + extraInfoCts = cts; + + LoadExtraInfoAsync(value, cts.Token) + .SafeFireAndForget(ex => + logger.LogWarning(ex, "Failed to load details for Python package {Name}", value.Package.Name) + ); + } + + private async Task LoadExtraInfoAsync( + PythonPackagesItemViewModel item, + CancellationToken cancellationToken + ) + { + try + { + await extraInfoLock.WaitAsync(cancellationToken); + } + catch (OperationCanceledException) { return; } - if (value.PipShowResult is null) + try + { + // Skip if the selection moved on while waiting; the item itself skips if already loaded + if (!ReferenceEquals(SelectedPackage, item)) + { + return; + } + + await item.LoadExtraInfo(CreateVenvRunnerAsync); + } + finally + { + ReleaseExtraInfoLock(); + } + } + + private void ReleaseExtraInfoLock() + { + try { - value.LoadExtraInfo(VenvPath!, pyBaseInstall!).SafeFireAndForget(); + extraInfoLock.Release(); } + catch (ObjectDisposedException) + { + // The dialog was closed and disposed while a load was still running + } + } + + /// + public override void OnUnloaded() + { + base.OnUnloaded(); + + // Drop any load still waiting for its turn once the dialog closes + extraInfoCts?.Cancel(); + extraInfoCts?.Dispose(); + extraInfoCts = null; + } + + /// + protected override void Dispose(bool disposing) + { + if (disposing) + { + extraInfoCts?.Cancel(); + extraInfoCts?.Dispose(); + extraInfoCts = null; + extraInfoLock.Dispose(); + } + + base.Dispose(disposing); } /// diff --git a/StabilityMatrix.Avalonia/ViewModels/PackageManager/PackageCardViewModel.cs b/StabilityMatrix.Avalonia/ViewModels/PackageManager/PackageCardViewModel.cs index b8be9d5af..31fd42604 100644 --- a/StabilityMatrix.Avalonia/ViewModels/PackageManager/PackageCardViewModel.cs +++ b/StabilityMatrix.Avalonia/ViewModels/PackageManager/PackageCardViewModel.cs @@ -741,7 +741,7 @@ public async Task OpenPythonPackagesDialog() if (Package is not { FullPath: not null }) return; - var vm = vmFactory.Get(vm => + using var vm = vmFactory.Get(vm => { vm.VenvPath = new DirectoryPath(Package.FullPath, "venv"); vm.PythonVersion = PyVersion.Parse(Package.PythonVersion); diff --git a/StabilityMatrix.Avalonia/Views/Dialogs/PythonPackagesDialog.axaml b/StabilityMatrix.Avalonia/Views/Dialogs/PythonPackagesDialog.axaml index 9cb70438c..4f3a366f6 100644 --- a/StabilityMatrix.Avalonia/Views/Dialogs/PythonPackagesDialog.axaml +++ b/StabilityMatrix.Avalonia/Views/Dialogs/PythonPackagesDialog.axaml @@ -192,6 +192,12 @@ + diff --git a/StabilityMatrix.Core/Python/PipIndexResult.cs b/StabilityMatrix.Core/Python/PipIndexResult.cs index ea9e62f70..60b73efad 100644 --- a/StabilityMatrix.Core/Python/PipIndexResult.cs +++ b/StabilityMatrix.Core/Python/PipIndexResult.cs @@ -10,14 +10,20 @@ public partial record PipIndexResult public static PipIndexResult Parse(string output) { - var match = AvailableVersionsRegex().Matches(output); - - var versions = output + var versionsMatch = output .SplitLines() .Select(line => AvailableVersionsRegex().Match(line)) - .First(m => m.Success) - .Groups["versions"].Value - .Split( + .FirstOrDefault(m => m.Success); + + // Output without an "Available versions:" line (e.g. only warnings) has no versions to offer + if (versionsMatch is null) + { + return new PipIndexResult { AvailableVersions = [] }; + } + + var versions = versionsMatch + .Groups["versions"] + .Value.Split( new[] { ',' }, StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries ) diff --git a/StabilityMatrix.Core/Python/PipShowResult.cs b/StabilityMatrix.Core/Python/PipShowResult.cs index 3df5ed388..8a2f6f865 100644 --- a/StabilityMatrix.Core/Python/PipShowResult.cs +++ b/StabilityMatrix.Core/Python/PipShowResult.cs @@ -37,12 +37,15 @@ public static PipShowResult Parse(string output) var indexOfLicense = GetIndexBySubstring(lines, "License:"); var indexOfLocation = GetIndexBySubstring(lines, "Location:"); - var licenseText = - indexOfLicense == -1 ? null : string.Join('\n', lines[indexOfLicense..indexOfLocation]); + // A multi-line license runs up to the "Location:" line. If that line is missing or comes + // first, only take the "License:" line itself. + var licenseEnd = indexOfLocation > indexOfLicense ? indexOfLocation : indexOfLicense + 1; + + var licenseText = indexOfLicense == -1 ? null : string.Join('\n', lines[indexOfLicense..licenseEnd]); if (indexOfLicense != -1) { - lines.RemoveRange(indexOfLicense, indexOfLocation - indexOfLicense); + lines.RemoveRange(indexOfLicense, licenseEnd - indexOfLicense); } var linesDict = new Dictionary(); diff --git a/StabilityMatrix.Tests/Core/PipIndexResultTests.cs b/StabilityMatrix.Tests/Core/PipIndexResultTests.cs new file mode 100644 index 000000000..b84c705a0 --- /dev/null +++ b/StabilityMatrix.Tests/Core/PipIndexResultTests.cs @@ -0,0 +1,35 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using StabilityMatrix.Core.Python; + +namespace StabilityMatrix.Tests.Core; + +[TestClass] +public class PipIndexResultTests +{ + [TestMethod] + public void Parse_ReadsAvailableVersions() + { + var output = """ + jax (0.4.30) + Available versions: 0.4.30, 0.4.29, 0.4.28 + INSTALLED: 0.4.26 + LATEST: 0.4.30 + """; + + var result = PipIndexResult.Parse(output); + + CollectionAssert.AreEqual(new[] { "0.4.30", "0.4.29", "0.4.28" }, result.AvailableVersions.ToArray()); + } + + [TestMethod] + public void Parse_WithoutAvailableVersionsLine_ReturnsNoVersions() + { + var output = """ + WARNING: pip index is currently an experimental command. It may be removed/changed in a future release without prior warning. + """; + + var result = PipIndexResult.Parse(output); + + Assert.AreEqual(0, result.AvailableVersions.Count); + } +} diff --git a/StabilityMatrix.Tests/Core/PipShowResultsTests.cs b/StabilityMatrix.Tests/Core/PipShowResultsTests.cs index 08ebf4d56..8e30508ab 100644 --- a/StabilityMatrix.Tests/Core/PipShowResultsTests.cs +++ b/StabilityMatrix.Tests/Core/PipShowResultsTests.cs @@ -181,4 +181,40 @@ public void TestEmptyInputThrowsFormatException() var input = ""; Assert.ThrowsException(() => PipShowResult.Parse(input)); } + + [TestMethod] + public void TestLicenseWithoutLocation() + { + var input = """ + Name: package-a + Version: 1.0.0 + License: MIT + Requires: numpy + """; + + var result = PipShowResult.Parse(input); + + Assert.AreEqual("package-a", result.Name); + Assert.AreEqual("License: MIT", result.License); + Assert.IsNull(result.Location); + CollectionAssert.AreEqual(new[] { "numpy" }, result.Requires); + } + + [TestMethod] + public void TestLocationBeforeLicense() + { + var input = """ + Name: package-a + Version: 1.0.0 + Location: /path/to/package + License: MIT + Requires: numpy + """; + + var result = PipShowResult.Parse(input); + + Assert.AreEqual("License: MIT", result.License); + Assert.AreEqual("/path/to/package", result.Location); + CollectionAssert.AreEqual(new[] { "numpy" }, result.Requires); + } } diff --git a/StabilityMatrix.UITests/PythonPackagesDialogTests.cs b/StabilityMatrix.UITests/PythonPackagesDialogTests.cs new file mode 100644 index 000000000..f4dcd20a7 --- /dev/null +++ b/StabilityMatrix.UITests/PythonPackagesDialogTests.cs @@ -0,0 +1,251 @@ +using Avalonia.Controls; +using Avalonia.Threading; +using Avalonia.VisualTree; +using Microsoft.Extensions.Logging.Abstractions; +using NSubstitute; +using StabilityMatrix.Avalonia.Languages; +using StabilityMatrix.Avalonia.ViewModels.Dialogs; +using StabilityMatrix.Avalonia.Views.Dialogs; +using StabilityMatrix.Core.Exceptions; +using StabilityMatrix.Core.Helper; +using StabilityMatrix.Core.Models.FileInterfaces; +using StabilityMatrix.Core.Python; +using StabilityMatrix.Core.Services; + +namespace StabilityMatrix.UITests; + +/// +/// The Python Packages dialog loads a package's details (pip show / pip index) whenever the +/// selection changes, and searching moves the selection on almost every keystroke. +/// +public class PythonPackagesDialogTests +{ + private static readonly string[] PackageNames = + [ + "absl-py", + "accelerate", + "aiohttp", + "certifi", + "einops", + "filelock", + "idna", + "jax", + "jaxlib", + "jinja2", + "jsonmerge", + "jsonschema", + "kornia", + "lark", + "ml-dtypes", + "numpy", + "opt-einsum", + "pillow", + "pip", + "safetensors", + "scipy", + "torch", + "torchvision", + "transformers", + ]; + + [AvaloniaFact] + public async Task TypingInSearch_WhenPackageDetailsFailToLoad_DoesNotCrash() + { + var dialog = await PackagesDialog.OpenAsync(pipShow: name => + name.StartsWith('j') + ? throw new FileNotFoundException("uv not found") + : Task.FromResult(new PipShowResult { Name = name, Version = "1.0.0" }) + ); + + // Any exception escaping the details load is rethrown on the UI thread, which ends the app + await dialog.TypeSearchAsync("j", "ja", "jax", "ja", "j", ""); + + Assert.Equal("jax", dialog.Vm.SelectedPackage?.Package.Name); + Assert.All(dialog.Vm.Packages, p => Assert.False(p.IsLoading)); + dialog.Close(); + } + + [AvaloniaFact] + public async Task FailedDetailsLoad_ShowsErrorAndRetriesWhenSelectedAgain() + { + var fail = true; + var dialog = await PackagesDialog.OpenAsync(pipShow: name => + fail && name == "jax" + ? throw new FileNotFoundException("uv not found") + : Task.FromResult(new PipShowResult { Name = name, Version = "1.0.0" }) + ); + + await dialog.TypeSearchAsync("jax"); + var jax = dialog.Vm.SelectedPackage; + Assert.Equal("jax", jax?.Package.Name); + Assert.True(jax!.HasLoadError); + Assert.Equal("uv not found", jax.LoadErrorMessage); + Assert.True(dialog.IsTextVisible(Resources.Error_PythonPackageDetailsLoadFailed)); + + fail = false; + dialog.Vm.SelectedPackage = dialog.Vm.Packages.Single(p => p.Package.Name == "jaxlib"); + await dialog.SettleAsync(); + dialog.Vm.SelectedPackage = jax; + await dialog.SettleAsync(); + + Assert.False(jax.HasLoadError); + Assert.NotNull(jax.PipShowResult); + dialog.Close(); + } + + [AvaloniaFact] + public async Task FailedIndexLookup_RetriesWhenSelectedAgain() + { + var fail = true; + var dialog = await PackagesDialog.OpenAsync( + pipShow: name => + Task.FromResult(new PipShowResult { Name = name, Version = "1.0.0" }), + pipIndex: name => + fail && name == "jax" + ? throw new ProcessException("index unavailable") + : Task.FromResult(new PipIndexResult { AvailableVersions = ["1.0.0"] }) + ); + + await dialog.TypeSearchAsync("jax"); + var jax = dialog.Vm.SelectedPackage; + Assert.Equal("jax", jax?.Package.Name); + Assert.True(jax!.HasLoadError); + Assert.Null(jax.PipShowResult); + + fail = false; + dialog.Vm.SelectedPackage = dialog.Vm.Packages.Single(p => p.Package.Name == "jaxlib"); + await dialog.SettleAsync(); + dialog.Vm.SelectedPackage = jax; + await dialog.SettleAsync(); + + Assert.False(jax.HasLoadError); + Assert.NotNull(jax.PipShowResult); + Assert.NotNull(jax.AvailableVersions); + dialog.Close(); + } + + [AvaloniaFact] + public async Task ClosingDialog_WithLoadInProgress_DoesNotThrow() + { + var release = new TaskCompletionSource(); + var dialog = await PackagesDialog.OpenAsync(pipShow: async name => + { + await release.Task; + return new PipShowResult { Name = name, Version = "1.0.0" }; + }); + + await dialog.TypeSearchAsync("j", "jax"); + dialog.Close(); + dialog.Vm.Dispose(); + + release.SetResult(); + await dialog.SettleAsync(); + } + + [AvaloniaFact] + public async Task TypingInSearch_LoadsOnePackagesDetailsAtATime() + { + var running = 0; + var maxRunning = 0; + var dialog = await PackagesDialog.OpenAsync(pipShow: async name => + { + maxRunning = Math.Max(maxRunning, ++running); + await Task.Delay(150); + running--; + return new PipShowResult { Name = name, Version = "1.0.0" }; + }); + + await dialog.TypeSearchAsync("j", "js", "t", "to", "a"); + await dialog.SettleAsync(rounds: 20); + + Assert.Equal(1, maxRunning); + Assert.NotNull(dialog.Vm.SelectedPackage?.PipShowResult); + dialog.Close(); + } + + private sealed class PackagesDialog + { + private readonly Window window; + private readonly TextBox searchBox; + + public PythonPackagesViewModel Vm { get; } + + private PackagesDialog(PythonPackagesViewModel vm, Window window, TextBox searchBox) + { + Vm = vm; + this.window = window; + this.searchBox = searchBox; + } + + public static async Task OpenAsync( + Func> pipShow, + Func>? pipIndex = null + ) + { + pipIndex ??= _ => + Task.FromResult(new PipIndexResult { AvailableVersions = ["1.0.0"] }); + + var runner = Substitute.For(); + runner.PipList().Returns(PackageNames.Select(n => new PipPackageInfo(n, "1.0.0")).ToList()); + runner.PipShow(Arg.Any()).Returns(call => pipShow(call.Arg())); + runner + .PipIndex(Arg.Any(), Arg.Any(), Arg.Any()) + .Returns(call => pipIndex(call.ArgAt(0))); + + var vm = new PythonPackagesViewModel( + NullLogger.Instance, + Substitute.For(), + Substitute.For(), + Substitute.For() + ) + { + VenvPath = new DirectoryPath(Path.GetTempPath(), "venv"), + VenvRunnerFactory = () => Task.FromResult(runner), + }; + + var view = new PythonPackagesDialog { DataContext = vm }; + var window = new Window + { + Width = 1000, + Height = 700, + Content = view, + }; + window.Show(); + await vm.OnLoadedAsync(); + + var dialog = new PackagesDialog( + vm, + window, + view.GetVisualDescendants().OfType().First() + ); + await dialog.SettleAsync(); + return dialog; + } + + public async Task TypeSearchAsync(params string[] texts) + { + foreach (var text in texts) + { + searchBox.Text = text; + await SettleAsync(); + } + } + + public async Task SettleAsync(int rounds = 6) + { + for (var i = 0; i < rounds; i++) + { + await Task.Delay(50); + Dispatcher.UIThread.RunJobs(); + } + } + + public bool IsTextVisible(string text) => + window + .GetVisualDescendants() + .OfType() + .Any(t => t.Text == text && t.IsEffectivelyVisible); + + public void Close() => window.Close(); + } +}