Improved ListenBrainz ImportLists

Author: Meyn

Tubifarry/ImportLists/ListenBrainz/ListenBrainzCFRecommendations/ListenBrainzCFRecommendationsImportList.cs

@@ -1,78 +1,72 @@
-using FluentValidation.Results;
+using FluentValidation.Results;
 using NLog;
 using NzbDrone.Common.Extensions;
 using NzbDrone.Common.Http;
 using NzbDrone.Core.Configuration;
 using NzbDrone.Core.ImportLists;
 using NzbDrone.Core.ImportLists.Exceptions;
 using NzbDrone.Core.Parser;
+using NzbDrone.Core.Parser.Model;
 using System.Net;
 
 namespace Tubifarry.ImportLists.ListenBrainz.ListenBrainzCFRecommendations
 {
     public class ListenBrainzCFRecommendationsImportList : HttpImportListBase<ListenBrainzCFRecommendationsSettings>
     {
-        private readonly IHttpClient _httpClient;
-
         public override string Name => "ListenBrainz Recording Recommend";
         public override ImportListType ListType => ImportListType.Other;
         public override TimeSpan MinRefreshInterval => TimeSpan.FromDays(1);
-        public override int PageSize => 0; // No pagination
+        public override int PageSize => 0;
         public override TimeSpan RateLimit => TimeSpan.FromMilliseconds(200);
 
         public ListenBrainzCFRecommendationsImportList(IHttpClient httpClient,
                                            IImportListStatusService importListStatusService,
                                            IConfigService configService,
                                            IParsingService parsingService,
                                            Logger logger)
-            : base(httpClient, importListStatusService, configService, parsingService, logger)
-        {
-            _httpClient = httpClient;
-        }
+            : base(httpClient, importListStatusService, configService, parsingService, logger) { }
 
-        public override IImportListRequestGenerator GetRequestGenerator()
-        {
-            return new ListenBrainzCFRecommendationsRequestGenerator(Settings);
-        }
+        public override IImportListRequestGenerator GetRequestGenerator() =>
+            new ListenBrainzCFRecommendationsRequestGenerator(Settings);
 
-        public override IParseImportListResponse GetParser()
-        {
-            return new ListenBrainzCFRecommendationsParser(Settings, _httpClient);
-        }
+        public override IParseImportListResponse GetParser() =>
+            new ListenBrainzCFRecommendationsParser();
 
-        protected override void Test(List<ValidationFailure> failures)
-        {
+        protected override bool IsValidRelease(ImportListItemInfo release) =>
+            release.AlbumMusicBrainzId.IsNotNullOrWhiteSpace() ||
+            release.ArtistMusicBrainzId.IsNotNullOrWhiteSpace() ||
+            (!release.Album.IsNullOrWhiteSpace() || !release.Artist.IsNullOrWhiteSpace());
+
+        protected override void Test(List<ValidationFailure> failures) =>
             failures.AddIfNotNull(TestConnection());
-        }
 
         protected override ValidationFailure TestConnection()
         {
             try
             {
-                IImportListRequestGenerator generator = GetRequestGenerator();
-                ImportListPageableRequest requests = generator.GetListItems().GetAllTiers().First();
+                ImportListRequest? firstRequest = GetRequestGenerator()
+                    .GetListItems()
+                    .GetAllTiers()
+                    .FirstOrDefault()?
+                    .FirstOrDefault();
 
-                if (!requests.Any())
+                if (firstRequest == null)
                 {
-                    return new ValidationFailure(string.Empty, "No requests generated. Check your configuration.");
+                    return new ValidationFailure(string.Empty, "No requests generated, check your configuration");
                 }
 
-                ImportListRequest firstRequest = requests.First();
                 ImportListResponse response = FetchImportListResponse(firstRequest);
 
                 if (response.HttpResponse.StatusCode == HttpStatusCode.NoContent)
                 {
-                    return new ValidationFailure(string.Empty, "No recording recommendations available for this user. These are generated based on collaborative filtering and may not be available for all users.");
+                    return new ValidationFailure(string.Empty, "No recording recommendations available for this user. These are generated based on collaborative filtering and may not be available for all users");
                 }
 
                 if (response.HttpResponse.StatusCode != HttpStatusCode.OK)
                 {
-                    return new ValidationFailure(string.Empty,
-                        $"Connection failed: HTTP {(int)response.HttpResponse.StatusCode} ({response.HttpResponse.StatusCode})");
+                    return new ValidationFailure(string.Empty, $"Connection failed with HTTP {(int)response.HttpResponse.StatusCode} ({response.HttpResponse.StatusCode})");
                 }
-
-                _logger.Info("Test successful - recording recommendations endpoint accessible");
-                return null;
+                return null!;
             }
             catch (ImportListException ex)
             {
@@ -82,8 +76,8 @@ protected override ValidationFailure TestConnection()
             catch (Exception ex)
             {
                 _logger.Error(ex, "Test connection failed");
-                return new ValidationFailure(string.Empty, "Configuration error - check logs for details");
+                return new ValidationFailure(string.Empty, "Configuration error, check logs for details");
             }
         }
     }
-}
+}

Tubifarry/ImportLists/ListenBrainz/ListenBrainzCFRecommendations/ListenBrainzCFRecommendationsParser.cs

@@ -1,5 +1,4 @@
-using NLog;
-using NzbDrone.Common.Http;
+using NLog;
 using NzbDrone.Common.Instrumentation;
 using NzbDrone.Core.ImportLists;
 using NzbDrone.Core.ImportLists.Exceptions;
@@ -11,146 +10,58 @@ namespace Tubifarry.ImportLists.ListenBrainz.ListenBrainzCFRecommendations
 {
     public class ListenBrainzCFRecommendationsParser : IParseImportListResponse
     {
-        private readonly ListenBrainzCFRecommendationsSettings _settings;
-        private readonly IHttpClient _httpClient;
         private readonly Logger _logger;
 
-        public ListenBrainzCFRecommendationsParser(ListenBrainzCFRecommendationsSettings settings, IHttpClient httpClient)
+        public ListenBrainzCFRecommendationsParser()
         {
-            _settings = settings;
-            _httpClient = httpClient;
             _logger = NzbDroneLogger.GetLogger(this);
         }
 
         public IList<ImportListItemInfo> ParseResponse(ImportListResponse importListResponse)
         {
-            List<ImportListItemInfo> items = new();
-
             if (!PreProcess(importListResponse))
-                return items;
+                return new List<ImportListItemInfo>();
 
             try
             {
-                items.AddRange(ParseRecordingRecommendations(importListResponse.Content));
+                IList<ImportListItemInfo> items = ParseRecordingRecommendations(importListResponse.Content);
+                _logger.Trace("Successfully parsed {0} recording recommendations", items.Count);
+                return items;
             }
             catch (Exception ex)
             {
-                _logger.Error(ex, "Error parsing ListenBrainz recording recommendations response");
-                throw new ImportListException(importListResponse, "Error parsing response", ex);
+                _logger.Error(ex, "Failed to parse ListenBrainz recording recommendations");
+                throw new ImportListException(importListResponse, "Failed to parse response", ex);
             }
-
-            _logger.Debug($"Parsed {items.Count} items from ListenBrainz recording recommendations");
-            return items;
         }
 
         private IList<ImportListItemInfo> ParseRecordingRecommendations(string content)
         {
-            List<ImportListItemInfo> items = new();
             RecordingRecommendationResponse? response = JsonSerializer.Deserialize<RecordingRecommendationResponse>(content, GetJsonOptions());
+            IReadOnlyList<RecordingRecommendation>? recommendations = response?.Payload?.Mbids;
 
-            if (response?.Payload?.Mbids == null)
+            if (recommendations?.Any() != true)
             {
-                _logger.Debug("No recording recommendations found");
-                return items;
+                _logger.Debug("No recording recommendations available");
+                return new List<ImportListItemInfo>();
             }
 
-            _logger.Debug($"Found {response.Payload.Mbids.Count} recording recommendations");
+            _logger.Trace("Processing {0} recording recommendations", recommendations.Count);
 
-            // Group recordings by their MBIDs to batch the MusicBrainz lookup
-            List<string> recordingMbids = response.Payload.Mbids.Select(r => r.RecordingMbid).ToList();
-
-            // We need to look up the artist information for each recording via MusicBrainz API
-            // Since we can't use the MusicBrainz API directly here, we'll use ListenBrainz's lookup
-            HashSet<string> artistMbids = new();
-
-            foreach (RecordingRecommendation recommendation in response.Payload.Mbids)
-            {
-                try
+            return recommendations
+                .Where(r => !string.IsNullOrWhiteSpace(r.RecordingMbid))
+                .Select(r => new ImportListItemInfo
                 {
-                    List<string> artistInfo = LookupRecordingArtist(recommendation.RecordingMbid);
-                    if (artistInfo != null)
-                    {
-                        foreach (string artistId in artistInfo)
-                        {
-                            artistMbids.Add(artistId);
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.Debug(ex, $"Error looking up artist for recording {recommendation.RecordingMbid}");
-                }
-            }
-
-            // Convert artist MBIDs to ImportListItemInfo
-            foreach (string artistMbid in artistMbids)
-            {
-                items.Add(new ImportListItemInfo
-                {
-                    ArtistMusicBrainzId = artistMbid
-                });
-            }
-
-            return items;
+                    AlbumMusicBrainzId = r.RecordingMbid,
+                    Album = r.RecordingMbid
+                })
+                .ToList();
         }
 
-        private List<string> LookupRecordingArtist(string recordingMbid)
+        private static JsonSerializerOptions GetJsonOptions() => new()
         {
-            List<string> artistMbids = new();
-
-            try
-            {
-                // Use MusicBrainz API to look up recording details
-                HttpRequestBuilder request = new HttpRequestBuilder("https://musicbrainz.org")
-                    .AddQueryParam("fmt", "json")
-                    .AddQueryParam("inc", "artist-credits")
-                    .Accept(HttpAccept.Json);
-
-                HttpRequest httpRequest = request.Build();
-                httpRequest.Url = new HttpUri($"https://musicbrainz.org/ws/2/recording/{recordingMbid}?fmt=json&inc=artist-credits");
-
-                // Add User-Agent as required by MusicBrainz
-                httpRequest.Headers.Add("User-Agent", "Lidarr-ListenBrainz-Plugin/1.0 (https://github.com/Lidarr/Lidarr)");
-
-                // Rate limit for MusicBrainz (1 request per second)
-                Thread.Sleep(1000);
-
-                HttpResponse response = _httpClient.Execute(httpRequest);
-
-                if (response.StatusCode != HttpStatusCode.OK)
-                {
-                    _logger.Debug($"Failed to lookup recording {recordingMbid}: HTTP {response.StatusCode}");
-                    return artistMbids;
-                }
-
-                MusicBrainzRecordingResponse? recordingData = JsonSerializer.Deserialize<MusicBrainzRecordingResponse>(response.Content, GetJsonOptions());
-
-                if (recordingData?.ArtistCredits != null)
-                {
-                    foreach (MusicBrainzArtistCredit credit in recordingData.ArtistCredits)
-                    {
-                        if (!string.IsNullOrEmpty(credit.Artist?.Id))
-                        {
-                            artistMbids.Add(credit.Artist.Id);
-                        }
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.Debug(ex, $"Error looking up recording {recordingMbid} in MusicBrainz");
-            }
-
-            return artistMbids;
-        }
-
-        private JsonSerializerOptions GetJsonOptions()
-        {
-            return new JsonSerializerOptions
-            {
-                PropertyNameCaseInsensitive = true
-            };
-        }
+            PropertyNameCaseInsensitive = true
+        };
 
         private bool PreProcess(ImportListResponse importListResponse)
         {
@@ -162,10 +73,10 @@ private bool PreProcess(ImportListResponse importListResponse)
 
             if (importListResponse.HttpResponse.StatusCode != HttpStatusCode.OK)
             {
-                throw new ImportListException(importListResponse, "Unexpected StatusCode [{0}]", importListResponse.HttpResponse.StatusCode);
+                throw new ImportListException(importListResponse, "Unexpected status code {0}", importListResponse.HttpResponse.StatusCode);
             }
 
             return true;
         }
     }
-}
+}

Tubifarry/ImportLists/ListenBrainz/ListenBrainzCFRecommendations/ListenBrainzCFRecommendationsRequestGenerator.cs

@@ -1,12 +1,12 @@
-using NzbDrone.Common.Http;
+using NzbDrone.Common.Http;
 using NzbDrone.Core.ImportLists;
 
 namespace Tubifarry.ImportLists.ListenBrainz.ListenBrainzCFRecommendations
 {
     public class ListenBrainzCFRecommendationsRequestGenerator : IImportListRequestGenerator
     {
         private readonly ListenBrainzCFRecommendationsSettings _settings;
-        private const int MAX_ITEMS_PER_REQUEST = 100; // ListenBrainz API limit
+        private const int MaxItemsPerRequest = 100;
 
         public ListenBrainzCFRecommendationsRequestGenerator(ListenBrainzCFRecommendationsSettings settings)
         {
@@ -22,34 +22,30 @@ public virtual ImportListPageableRequestChain GetListItems()
 
         private IEnumerable<ImportListRequest> GetPagedRequests()
         {
-            int totalToFetch = _settings.Count;
-            int totalRequested = 0;
-            int offset = 0;
+            int requestsNeeded = (_settings.Count + MaxItemsPerRequest - 1) / MaxItemsPerRequest;
 
-            // Generate multiple paginated requests if count > MAX_ITEMS_PER_REQUEST
-            while (totalRequested < totalToFetch)
-            {
-                int currentPageSize = Math.Min(totalToFetch - totalRequested, MAX_ITEMS_PER_REQUEST);
-
-                HttpRequestBuilder requestBuilder = new HttpRequestBuilder(_settings.BaseUrl)
-                    .Accept(HttpAccept.Json);
+            return Enumerable.Range(0, requestsNeeded)
+                .Select(page => CreateRequest(page * MaxItemsPerRequest, Math.Min(MaxItemsPerRequest, _settings.Count - (page * MaxItemsPerRequest))))
+                .Where(request => request != null);
+        }
 
-                if (!string.IsNullOrEmpty(_settings.UserToken))
-                {
-                    requestBuilder.SetHeader("Authorization", $"Token {_settings.UserToken}");
-                }
+        private ImportListRequest CreateRequest(int offset, int count)
+        {
+            if (count <= 0)
+                return null!;
 
-                HttpRequest request = requestBuilder.Build();
-                request.Url = new HttpUri($"{_settings.BaseUrl}/1/cf/recommendation/user/{_settings.UserName}/recording?count={currentPageSize}&offset={offset}");
+            HttpRequestBuilder requestBuilder = new HttpRequestBuilder(_settings.BaseUrl)
+                .Accept(HttpAccept.Json);
 
-                yield return new ImportListRequest(request);
+            if (!string.IsNullOrEmpty(_settings.UserToken))
+            {
+                requestBuilder.SetHeader("Authorization", $"Token {_settings.UserToken}");
+            }
 
-                totalRequested += currentPageSize;
-                offset += currentPageSize;
+            HttpRequest request = requestBuilder.Build();
+            request.Url = new HttpUri($"{_settings.BaseUrl}/1/cf/recommendation/user/{_settings.UserName}/recording?count={count}&offset={offset}");
 
-                if (currentPageSize < MAX_ITEMS_PER_REQUEST)
-                    break;
-            }
+            return new ImportListRequest(request);
         }
     }
-}
+}

Tubifarry/ImportLists/ListenBrainz/ListenBrainzCFRecommendations/ListenBrainzCFRecommendationsSettings.cs

@@ -1,5 +1,4 @@
-// ListenBrainzCFRecommendationsSettings.cs
-using FluentValidation;
+using FluentValidation;
 using NzbDrone.Core.Annotations;
 using NzbDrone.Core.ImportLists;
 using NzbDrone.Core.Validation;