Improved Slskd path, priority and timeout handling

squash

squash

Author: Meyn

Tubifarry/Download/Clients/Soulseek/SlskdClient.cs

@@ -126,7 +126,7 @@ private async Task CleanStaleDirectoriesAsync(string directoryPath)
         {
             try
             {
-                string localPath = _remotePathMappingService.RemapRemoteToLocal(Settings.Host, new OsPath(directoryPath)).FullPath;
+                string localPath = _remotePathMappingService.RemapRemoteToLocal(Settings.Host, new OsPath(Path.Combine(Settings.DownloadPath, directoryPath))).FullPath;
                 await Task.Delay(1000);
                 HttpRequest request = BuildHttpRequest("/api/v0/transfers/downloads/");
                 HttpResponse response = await ExecuteAsync(request);
@@ -226,7 +226,7 @@ private static ReleaseInfo CreateReleaseInfoFromDownloadDirectory(string usernam
 
             IGrouping<string, SlskdFileData> directory = dir.ToSlskdFileDataList().GroupBy(_ => dir.Directory).First();
 
-            AlbumData albumData = SlskdItemsParser.CreateAlbumData(null!, directory, searchData, folderData);
+            AlbumData albumData = SlskdItemsParser.CreateAlbumData(null!, directory, searchData, folderData, null, 0);
             ReleaseInfo release = albumData.ToReleaseInfo();
             release.DownloadProtocol = null;
             return release;

Tubifarry/Download/Clients/Soulseek/SlskdModels.cs

@@ -118,12 +118,25 @@ public DownloadClientItem GetDownloadClientItem(OsPath downloadPath, TimeSpan? t
                 .Select(file => Path.GetFileName(file.File.Filename)).ToList();
 
             DownloadItemStatus status = DownloadItemStatus.Queued;
-            DateTime lastTime = SlskdDownloadDirectory.Files.Max(x => x.EnqueuedAt > x.StartedAt ? x.EnqueuedAt : x.StartedAt + x.ElapsedTime);
 
-            if (now - lastTime > timeout)
+            bool anyActiveDownload = SlskdDownloadDirectory.Files.Any(f =>
+                f.State == "InProgress" || f.State == "Queued, Locally" || f.State == "Initializing");
+
+            List<SlskdDownloadFile> incompleteFiles = SlskdDownloadDirectory.Files.Where(f => !f.State.StartsWith("Completed")).ToList();
+
+            bool allStuckInRemoteQueue = incompleteFiles.Count != 0 && incompleteFiles.All(f =>
+                f.State == "Queued, Remotely" && (now - f.EnqueuedAt) > timeout);
+
+            if (allStuckInRemoteQueue && !anyActiveDownload)
             {
                 status = DownloadItemStatus.Failed;
             }
+            else if (!anyActiveDownload && incompleteFiles.Count != 0)
+            {
+                DateTime lastActivity = incompleteFiles.SelectMany(f => new[] { f.EnqueuedAt, f.StartedAt, f.StartedAt + f.ElapsedTime }).Max();
+                if ((now - lastActivity) > (timeout * 2))
+                    status = DownloadItemStatus.Failed;
+            }
             else if ((double)failedFiles.Count / fileStatuses.Count * 100 > 20)
             {
                 status = DownloadItemStatus.Failed;

Tubifarry/Indexers/Soulseek/SlsdkRecords.cs

@@ -65,29 +65,64 @@ public record SlskdFolderData(
         [property: JsonPropertyName("fileCount")] int FileCount,
         [property: JsonPropertyName("files")] List<SlskdFileData> Files)
     {
-        public int CalculatePriority()
+        public int CalculatePriority(int expectedTrackCount = 0)
         {
+            // Early exit: completely locked folders
             if (LockedFileCount >= FileCount && FileCount > 0)
                 return 0;
 
+            // Early exit: more than 50% locked = useless source
+            double availabilityRatio = FileCount > 0 ? (FileCount - LockedFileCount) / (double)FileCount : 1.0;
+            if (availabilityRatio <= 0.5)
+                return 0;
+
             int score = 0;
-            if (FileCount > 0)
+
+            // Get actual track count
+            int actualTrackCount = 0;
+            if (expectedTrackCount > 0)
             {
-                double availabilityRatio = (FileCount - LockedFileCount) / (double)FileCount;
-                score += (int)(Math.Pow(availabilityRatio, 0.6) * 4000);
+                actualTrackCount = Files.Count(f =>
+                    AudioFormatHelper.GetAudioCodecFromExtension(
+                        f.Extension ?? System.IO.Path.GetExtension(f.Filename) ?? "") != AudioFormat.Unknown);
             }
 
+            // Early exit: Missing 50%+ of expected tracks
+            if (expectedTrackCount > 0 && actualTrackCount > 0 && actualTrackCount <= expectedTrackCount * 0.5)
+                return 0;
+
+            // ===== TRACK COUNT MATCHING (0 to +2500) =====
+            if (expectedTrackCount > 0 && actualTrackCount > 0)
+            {
+                int trackDiff = actualTrackCount - expectedTrackCount;
+
+                if (trackDiff < 0) // -1: ~500 pts, -2: ~60 pts, -3+: near 0
+                    score += (int)(2500 * Math.Exp(-Math.Pow(Math.Abs(trackDiff), 2) * 5));
+                else if (trackDiff == 0)  // PERFECT MATCH
+                    score += 2500;
+                else   // EXTRA TRACKS: Less critical, just penalized: +1: ~1600 pts, +2: ~600 pts, +3: ~100 pts, +15: near 0
+                    score += (int)(2500 * Math.Exp(-Math.Pow(trackDiff, 2) * 1.5));
+            }
+
+            // ===== AVAILABILITY RATIO (0 to +2000) =====
+            score += (int)(Math.Pow(availabilityRatio, 2.0) * 2000);
+
+            // ===== UPLOAD SPEED (0 to +1800) =====
             if (UploadSpeed > 0)
             {
                 double speedMbps = UploadSpeed / (1024.0 * 1024.0 / 8.0);
-                score += (int)(Math.Log10(Math.Max(0.1, speedMbps) + 1) * 1200);
+                score += Math.Min(1800, (int)(Math.Log10(Math.Max(0.1, speedMbps) + 1) * 1100));
             }
-            double queuePenalty = Math.Pow(0.9, Math.Min(QueueLength, 30));
-            score += (int)(queuePenalty * 2000);
-            if (HasFreeUploadSlot)
-                score += 1000;
-            if (FileCount >= 15)
-                score += 200;
+
+            // ===== QUEUE LENGTH (50 to +1500) =====
+            double queueFactor = Math.Pow(0.94, Math.Min(QueueLength, 40));
+            score += (int)(queueFactor * 1500);
+
+            // ===== FREE UPLOAD SLOT (0 or +800) =====
+            score += HasFreeUploadSlot ? 800 : 0;
+
+            // ===== COLLECTION SIZE (0 to +300) =====
+            score += Math.Min(300, (int)(Math.Log10(Math.Max(1, FileCount) + 1) * 150));
 
             return Math.Clamp(score, 0, 10000);
         }
@@ -100,7 +135,7 @@ public record SlskdSearchData(
         [property: JsonPropertyName("expandDirectory")] bool ExpandDirectory,
         [property: JsonPropertyName("mimimumFiles")] int MinimumFiles)
     {
-        private readonly static JsonSerializerOptions _jsonOptions = new() { PropertyNameCaseInsensitive = true };
+        private static readonly JsonSerializerOptions _jsonOptions = new() { PropertyNameCaseInsensitive = true };
         public static SlskdSearchData FromJson(string jsonString) => JsonSerializer.Deserialize<SlskdSearchData>(jsonString, _jsonOptions)!;
     }
 

Tubifarry/Indexers/Soulseek/SlskdIndexerParser.cs

@@ -52,7 +52,7 @@ public IList<ReleaseInfo> ParseResponse(IndexerResponse indexerResponse)
 
                 foreach (SlskdFolderData response in searchResponse.Responses)
                 {
-                    if (response.FileCount < searchTextData.MinimumFiles || ignoredUsers?.Contains(response.Username) == true)
+                    if (ignoredUsers?.Contains(response.Username) == true)
                         continue;
 
                     IEnumerable<SlskdFileData> filteredFiles = SlskdFileData.GetFilteredFiles(response.Files, Settings.OnlyAudioFiles, Settings.IncludeFileExtensions);
@@ -62,6 +62,13 @@ public IList<ReleaseInfo> ParseResponse(IndexerResponse indexerResponse)
                         if (string.IsNullOrEmpty(directoryGroup.Key))
                             continue;
 
+                        int actualTrackCount = directoryGroup.Count();
+                        if (Settings.FilterLessFilesThanAlbum && searchTextData.MinimumFiles > 0 && actualTrackCount < searchTextData.MinimumFiles)
+                        {
+                            _logger.Trace($"Filtered: {directoryGroup.Key} ({actualTrackCount}/{searchTextData.MinimumFiles} tracks)");
+                            continue;
+                        }
+
                         SlskdFolderData folderData = SlskdItemsParser.ParseFolderName(directoryGroup.Key) with
                         {
                             Username = response.Username,
@@ -77,7 +84,7 @@ public IList<ReleaseInfo> ParseResponse(IndexerResponse indexerResponse)
                         if (searchTextData.ExpandDirectory && ShouldExpandDirectory(albumDatas, searchResponse, searchTextData, directoryGroup, folderData))
                             continue;
 
-                        AlbumData originalAlbumData = SlskdItemsParser.CreateAlbumData(searchResponse.Id, directoryGroup, searchTextData, folderData, Settings);
+                        AlbumData originalAlbumData = SlskdItemsParser.CreateAlbumData(searchResponse.Id, directoryGroup, searchTextData, folderData, Settings, searchTextData.MinimumFiles);
                         albumDatas.Add(originalAlbumData);
                     }
                 }
@@ -116,7 +123,7 @@ private bool ShouldExpandDirectory(List<AlbumData> albumDatas, SlskdSearchRespon
             if (expandedGroup != null)
             {
                 _logger.Debug($"Successfully expanded directory to {expandedGroup.Count()} files");
-                AlbumData albumData = SlskdItemsParser.CreateAlbumData(searchResponse.Id, expandedGroup, searchTextData, folderData, Settings);
+                AlbumData albumData = SlskdItemsParser.CreateAlbumData(searchResponse.Id, expandedGroup, searchTextData, folderData, Settings, searchTextData.MinimumFiles);
                 albumDatas.Add(albumData);
                 return true;
             }

Tubifarry/Indexers/Soulseek/SlskdItemsParser.cs

@@ -3,6 +3,9 @@
 using NLog;
 using NzbDrone.Common.Instrumentation;
 using NzbDrone.Core.Indexers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Text.RegularExpressions;
 using Tubifarry.Core.Model;
 using Tubifarry.Core.Utilities;
@@ -60,7 +63,7 @@ public static SlskdFolderData ParseFolderName(string folderPath)
                 Files: []);
         }
 
-        public static AlbumData CreateAlbumData(string searchId, IGrouping<string, SlskdFileData> directory, SlskdSearchData searchData, SlskdFolderData folderData, SlskdSettings? settings = null)
+        public static AlbumData CreateAlbumData(string searchId, IGrouping<string, SlskdFileData> directory, SlskdSearchData searchData, SlskdFolderData folderData, SlskdSettings? settings = null, int expectedTrackCount = 0)
         {
             string dirNameNorm = NormalizeString(directory.Key);
             string searchArtistNorm = NormalizeString(searchData.Artist ?? "");
@@ -111,7 +114,8 @@ public static AlbumData CreateAlbumData(string searchId, IGrouping<string, Slskd
                           : BitRate) ?? 0,
                 Size = TotalSize,
                 InfoUrl = infoUrl,
-                Priotity = folderData.CalculatePriority(),
+                ExplicitContent = ExtractExplicitTag(folderData.Path),
+                Priotity = folderData.CalculatePriority(expectedTrackCount),
                 CustomString = JsonConvert.SerializeObject(filesToDownload),
                 ExtraInfo = [$"👤 {folderData.Username} ", $"{(folderData.HasFreeUploadSlot ? "⚡" : "❌")} {folderData.UploadSpeed / 1024.0 / 1024.0:F2}MB/s ", folderData.QueueLength == 0 ? "" : $"📋 {folderData.QueueLength}"],
                 Duration = TotalDuration
@@ -283,6 +287,23 @@ private static string CleanComponent(string component)
             return ReduceWhitespaceRegex().Replace(component.Trim(), " ");
         }
 
+        private static bool ExtractExplicitTag(string path)
+        {
+            Match match = ExplicitTagRegex().Match(path);
+            if (match.Success)
+            {
+                if (match.Groups["negation"].Success && !string.IsNullOrWhiteSpace(match.Groups["negation"].Value))
+                {
+                    Logger.Trace($"Found negated explicit tag in path, skipping: {match.Value}");
+                    return false;
+                }
+
+                Logger.Trace($"Extracted explicit tag from path: {path}");
+                return true;
+            }
+            return false;
+        }
+
         private static string? ExtractYearFromPath(string path)
         {
             Match yearMatch = YearExtractionRegex().Match(path);