Add title similarity score for sorting entries of same quality. Priority over seed count

Set torrent rename default as true

Author: sonalys

cmd/service/main.go

@@ -63,7 +63,7 @@ func main() {
 			Sources:          config.Sources,
 			Qualitites:       config.Qualities,
 			Category:         config.Category,
-			RenameTorrent:    config.RenameTorrent,
+			RenameTorrent:    *utils.Coalesce(config.RenameTorrent, utils.Pointer(true)),
 			DownloadPath:     config.DownloadPath,
 			CreateShowFolder: config.CreateShowFolder,
 			PollFrequency:    config.PollFrequency,

internal/configs/configs.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/rs/zerolog/log"
+	"github.com/sonalys/animeman/internal/utils"
 	"gopkg.in/yaml.v3"
 )
 
@@ -90,7 +91,7 @@ type TorrentConfig struct {
 	Category         string            `yaml:"category"`
 	DownloadPath     string            `yaml:"downloadPath"`
 	CreateShowFolder bool              `yaml:"createShowFolder"`
-	RenameTorrent    bool              `yaml:"renameTorrent"`
+	RenameTorrent    *bool             `yaml:"renameTorrent,omitempty"`
 }
 
 func (c TorrentConfig) Validate() error {
@@ -144,7 +145,7 @@ func GenerateBoilerplateConfig() {
 			Username:         "admin",
 			Password:         "adminadmin",
 			CreateShowFolder: true,
-			RenameTorrent:    true,
+			RenameTorrent:    utils.Pointer(true),
 			Type:             TorrentClientTypeQBittorrent,
 		},
 	})

internal/discovery/run.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"regexp"
 	"sort"
+	"strings"
 
 	"github.com/rs/zerolog/log"
 	"github.com/sonalys/animeman/integrations/nyaa"
@@ -60,31 +62,80 @@ func episodeFilterNew(list []parser.ParsedNyaa, latestTag string, excludeBatch b
 	return out
 }
 
+var notWordDigitOrSpace = regexp.MustCompile("[^a-zA-Z 0-9]")
+
+// calculateTitleSimilarityScore returns a value between 0 and 1 for how similar the titles are.
+func calculateTitleSimilarityScore(originalTitle, title string) float64 {
+	originalTitle = strings.ToLower(originalTitle)
+	title = strings.ToLower(title)
+	originalTitle = notWordDigitOrSpace.ReplaceAllString(originalTitle, "")
+	title = notWordDigitOrSpace.ReplaceAllString(title, "")
+
+	originalTitleWords := strings.Split(originalTitle, " ")
+	titleWords := strings.Split(title, " ")
+	wordCount := len(titleWords)
+
+	var match int
+outer:
+	for _, curWord := range titleWords {
+		for i, target := range originalTitleWords {
+			if curWord == target {
+				match++
+				originalTitleWords = append(originalTitleWords[:i], originalTitleWords[i+1:]...)
+				continue outer
+			}
+		}
+	}
+	return float64(match) / float64(wordCount)
+}
+
 // parseAndSort will digest the raw data from Nyaa into a parsed metadata struct `ParsedNyaa`.
 // it will also sort the response by season and episode.
 // it's important it returns a crescent season/episode list, so you don't download a recent episode and
 // don't download the oldest ones in case you don't have all episodes since your latestTag.
-func parseAndSort(entries []nyaa.Entry) []parser.ParsedNyaa {
+func parseAndSort(animeListEntry animelist.Entry, entries []nyaa.Entry) []parser.ParsedNyaa {
 	resp := utils.Map(entries, func(entry nyaa.Entry) parser.ParsedNyaa { return parser.NewParsedNyaa(entry) })
 	sort.Slice(resp, func(i, j int) bool {
 		cmp := tagCompare(resp[i].SeasonEpisodeTag, resp[j].SeasonEpisodeTag)
+		if cmp != 0 {
+			return cmp < 0
+		}
 		// For same tag, we compare vertical resolution, prioritizing better quality.
-		if cmp == 0 {
-			cmp = resp[j].Meta.VerticalResolution - resp[i].Meta.VerticalResolution
-			if cmp == 0 {
-				cmp = resp[j].Entry.Seeders - resp[i].Entry.Seeders
+		cmp = resp[j].Meta.VerticalResolution - resp[i].Meta.VerticalResolution
+		if cmp != 0 {
+			return cmp < 0
+		}
+		var scoreI, scoreJ float64
+		// Then we prioritize by title proximity score.
+		for _, title := range animeListEntry.Titles {
+			curScoreI := calculateTitleSimilarityScore(title, resp[i].Meta.Title)
+			curScoreJ := calculateTitleSimilarityScore(title, resp[j].Meta.Title)
+			if curScoreI > scoreI {
+				scoreI = curScoreI
 			}
+			if curScoreJ > scoreJ {
+				scoreJ = curScoreJ
+			}
+		}
+		cmp = int((scoreJ - scoreI) * 100)
+		if cmp != 0 {
+			return cmp < 0
+		}
+		// Then prioritize number of seeds
+		cmp = resp[j].Entry.Seeders - resp[i].Entry.Seeders
+		if cmp != 0 {
+			return cmp < 0
 		}
 		return cmp < 0
 	})
 	return resp
 }
 
 // getDownloadableEntries is responsible for filtering and ordering the raw Nyaa feed into valid downloadable torrents.
-func getDownloadableEntries(entries []nyaa.Entry, latestTag string, animeStatus animelist.AiringStatus) []parser.ParsedNyaa {
+func getDownloadableEntries(animeListEntry animelist.Entry, entries []nyaa.Entry, latestTag string, animeStatus animelist.AiringStatus) []parser.ParsedNyaa {
 	// If we don't have any episodes, and show is released, try to find a batch for all episodes.
 	useBatch := latestTag == "" && animeStatus == animelist.AiringStatusAired
-	parsedEntries := parseAndSort(entries)
+	parsedEntries := parseAndSort(animeListEntry, entries)
 	if useBatch {
 		return utils.Filter(parsedEntries, filterBatchEntries)
 	}
@@ -94,7 +145,7 @@ func getDownloadableEntries(entries []nyaa.Entry, latestTag string, animeStatus
 func (c *Controller) NyaaSearch(ctx context.Context, entry animelist.Entry) ([]nyaa.Entry, error) {
 	// Build search query for Nyaa.
 	// For title we filter for english and original titles.
-	strippedTitles := utils.Map(entry.Titles, parser.TitleStrip)
+	strippedTitles := utils.Map(entry.Titles, func(title string) string { return parser.TitleStrip(title, true) })
 	titleQuery := nyaa.QueryOr(strippedTitles)
 	sourceQuery := nyaa.QueryOr(c.dep.Config.Sources)
 	qualityQuery := nyaa.QueryOr(c.dep.Config.Qualitites)
@@ -118,7 +169,7 @@ func (c *Controller) DigestAnimeListEntry(ctx context.Context, entry animelist.E
 	if err != nil {
 		return fmt.Errorf("getting latest tag: %w", err)
 	}
-	for _, nyaaEntry := range getDownloadableEntries(nyaaEntries, latestTag, entry.AiringStatus) {
+	for _, nyaaEntry := range getDownloadableEntries(entry, nyaaEntries, latestTag, entry.AiringStatus) {
 		if err := c.TorrentDigestNyaa(ctx, entry, nyaaEntry); err != nil {
 			log.Error().Msgf("failed to digest nyaa entry: %s", err)
 			continue

internal/discovery/run_test.go

@@ -86,7 +86,7 @@ func Test_filterEpisodes(t *testing.T) {
 
 func Test_buildTaggedNyaaList(t *testing.T) {
 	t.Run("empty", func(t *testing.T) {
-		got := parseAndSort([]nyaa.Entry{})
+		got := parseAndSort(animelist.Entry{}, []nyaa.Entry{})
 		require.Empty(t, got)
 	})
 	t.Run("sort by tag", func(t *testing.T) {
@@ -96,7 +96,7 @@ func Test_buildTaggedNyaaList(t *testing.T) {
 			{Title: "Show3: S03E01"},
 			{Title: "Show3: S03"},
 		}
-		got := parseAndSort(input)
+		got := parseAndSort(animelist.Entry{}, input)
 		require.Len(t, got, len(input))
 		for i := 1; i < len(got); i++ {
 			require.True(t, tagCompare(got[i-1].SeasonEpisodeTag, got[i].SeasonEpisodeTag) <= 0)
@@ -106,7 +106,7 @@ func Test_buildTaggedNyaaList(t *testing.T) {
 
 func Test_filterNyaaFeed(t *testing.T) {
 	t.Run("empty", func(t *testing.T) {
-		got := getDownloadableEntries([]nyaa.Entry{}, "", animelist.AiringStatusAiring)
+		got := getDownloadableEntries(animelist.Entry{}, []nyaa.Entry{}, "", animelist.AiringStatusAiring)
 		require.Empty(t, got)
 	})
 	t.Run("airing: no latestTag", func(t *testing.T) {
@@ -115,7 +115,7 @@ func Test_filterNyaaFeed(t *testing.T) {
 			{Title: "Show3: S03E02"},
 			{Title: "Show3: S03E01"},
 		}
-		got := getDownloadableEntries(input, "", animelist.AiringStatusAiring)
+		got := getDownloadableEntries(animelist.Entry{}, input, "", animelist.AiringStatusAiring)
 		require.Len(t, got, len(input))
 		for i := 1; i < len(got); i++ {
 			require.True(t, tagCompare(got[i-1].SeasonEpisodeTag, got[i].SeasonEpisodeTag) <= 0)
@@ -127,19 +127,19 @@ func Test_filterNyaaFeed(t *testing.T) {
 			{Title: "Show3: S03E02"},
 			{Title: "Show3: S03E01"},
 		}
-		got := getDownloadableEntries(input, "Show3 S03E02", animelist.AiringStatusAiring)
+		got := getDownloadableEntries(animelist.Entry{}, input, "Show3 S03E02", animelist.AiringStatusAiring)
 		require.Len(t, got, 1)
-		require.Equal(t, parseAndSort(input[:1]), got)
+		require.Equal(t, parseAndSort(animelist.Entry{}, input[:1]), got)
 	})
 	t.Run("airing: with repeated tag", func(t *testing.T) {
 		input := []nyaa.Entry{
 			{Title: "Show3: S03E02"},
 			{Title: "Show3: S03E02"},
 			{Title: "Show3: S03E01"},
 		}
-		got := getDownloadableEntries(input, "Show3 S03E01", animelist.AiringStatusAiring)
+		got := getDownloadableEntries(animelist.Entry{}, input, "Show3 S03E01", animelist.AiringStatusAiring)
 		require.Len(t, got, 1)
-		require.Equal(t, parseAndSort(input[0:1]), got)
+		require.Equal(t, parseAndSort(animelist.Entry{}, input[0:1]), got)
 	})
 
 	t.Run("airing: with latestTag and quality", func(t *testing.T) {
@@ -149,57 +149,71 @@ func Test_filterNyaaFeed(t *testing.T) {
 			{Title: "Show3: S03E02"},
 			{Title: "Show3: S03E01"},
 		}
-		got := getDownloadableEntries(input, "Show3 S03E02", animelist.AiringStatusAiring)
+		got := getDownloadableEntries(animelist.Entry{}, input, "Show3 S03E02", animelist.AiringStatusAiring)
 		require.Len(t, got, 1)
-		require.Equal(t, parseAndSort(input[1:2]), got)
+		require.Equal(t, parseAndSort(animelist.Entry{}, input[1:2]), got)
 	})
 	t.Run("aired: with latestTag", func(t *testing.T) {
 		input := []nyaa.Entry{
 			{Title: "Show3: S03E03"},
 			{Title: "Show3: S03E02"},
 			{Title: "Show3: S03E01"},
 		}
-		got := getDownloadableEntries(input, "Show3 S03E02", animelist.AiringStatusAired)
+		got := getDownloadableEntries(animelist.Entry{}, input, "Show3 S03E02", animelist.AiringStatusAired)
 		require.Len(t, got, 1)
-		require.Equal(t, parseAndSort(input[:1]), got)
+		require.Equal(t, parseAndSort(animelist.Entry{}, input[:1]), got)
 	})
 	t.Run("aired: with batch, no latestTag", func(t *testing.T) {
 		input := []nyaa.Entry{
 			{Title: "Show3: S03E03"},
 			{Title: "Show3: S03E02"},
 			{Title: "Show3: S03"},
 		}
-		got := getDownloadableEntries(input, "", animelist.AiringStatusAired)
+		got := getDownloadableEntries(animelist.Entry{}, input, "", animelist.AiringStatusAired)
 		require.Len(t, got, 1)
-		require.Equal(t, parseAndSort(input[2:]), got)
+		require.Equal(t, parseAndSort(animelist.Entry{}, input[2:]), got)
 	})
 	t.Run("aired: with batch, different qualities", func(t *testing.T) {
 		input := []nyaa.Entry{
 			{Title: "Show3: S03 1220x760"},
 			{Title: "Show3: S03 1080p"},
 		}
-		got := getDownloadableEntries(input, "", animelist.AiringStatusAired)
+		got := getDownloadableEntries(animelist.Entry{}, input, "", animelist.AiringStatusAired)
 		require.Len(t, got, 1)
-		require.Equal(t, parseAndSort(input[1:]), got)
+		require.Equal(t, parseAndSort(animelist.Entry{}, input[1:]), got)
 	})
 	t.Run("aired: with batch, with latestTag", func(t *testing.T) {
 		input := []nyaa.Entry{
 			{Title: "Show3: S03E03"},
 			{Title: "Show3: S03E02"},
 			{Title: "Show3: S03"},
 		}
-		got := getDownloadableEntries(input, "Show3 S03E02", animelist.AiringStatusAired)
+		got := getDownloadableEntries(animelist.Entry{}, input, "Show3 S03E02", animelist.AiringStatusAired)
 		require.Len(t, got, 1)
-		require.Equal(t, parseAndSort(input[:1]), got)
+		require.Equal(t, parseAndSort(animelist.Entry{}, input[:1]), got)
 	})
 	t.Run("same tag and quality, different seeders", func(t *testing.T) {
 		input := []nyaa.Entry{
 			{Title: "Show3: S03E03", Seeders: 1},
 			{Title: "Show3: S03E03", Seeders: 10},
 			{Title: "Show3: S03"},
 		}
-		got := getDownloadableEntries(input, "Show3 S03E02", animelist.AiringStatusAired)
+		got := getDownloadableEntries(animelist.Entry{}, input, "Show3 S03E02", animelist.AiringStatusAired)
 		require.Len(t, got, 1)
-		require.Equal(t, parseAndSort(input[1:2]), got)
+		require.Equal(t, parseAndSort(animelist.Entry{}, input[1:2]), got)
+	})
+}
+
+func Test_calculateTitleSimilarityScore(t *testing.T) {
+	t.Run("exact match in lower case", func(t *testing.T) {
+		score := calculateTitleSimilarityScore("My pony academy: the story continues", "My Pony Academy the story continues")
+		require.EqualValues(t, score, 1)
+	})
+
+	t.Run("closer match should have higher score", func(t *testing.T) {
+		originalTitle := "My pony academy: the battle continues"
+		scoreA := calculateTitleSimilarityScore(originalTitle, "My Pony Academy")
+		scoreB := calculateTitleSimilarityScore(originalTitle, "My Pony Academy 2: second battle")
+		require.Greater(t, scoreA, scoreB)
 	})
 }

internal/discovery/torrent.go

@@ -58,6 +58,7 @@ func (c *Controller) buildTorrentName(entry animelist.Entry, parsedNyaa parser.P
 // It will configure all necessary metadata and send it to your torrent client.
 func (c *Controller) TorrentDigestNyaa(ctx context.Context, entry animelist.Entry, parsedNyaa parser.ParsedNyaa) error {
 	savePath := c.TorrentGetDownloadPath(entry.Titles[0])
+	parsedNyaa.Meta.Title = parser.TitleStrip(parsedNyaa.Meta.Title, true)
 	tags := parsedNyaa.Meta.TagsBuildTorrent()
 	req := &torrentclient.AddTorrentConfig{
 		Tags:     tags,

internal/parser/title.go

@@ -21,15 +21,17 @@ func TitleStripSubtitle(title string) string {
 
 // TitleStrip cleans title from sub-titles, tags and season / episode information.
 // Example: [Source] Show: another story - S03E02 [1080p].mkv -> Show.
-func TitleStrip(title string) string {
+func TitleStrip(title string, cleanSubtitle bool) string {
 	if index := seasonIndexMatch(title); index != -1 {
 		title = title[:index]
 	}
 	if index := episodeIndexMatch(title); index != -1 {
 		title = title[:index]
 	}
 	title = regexp.MustCompile(`\s{2,}`).ReplaceAllString(title, " ")
-	title = TitleStripSubtitle(title)
+	if cleanSubtitle {
+		title = TitleStripSubtitle(title)
+	}
 	title = strings.ReplaceAll(title, ".", " ")
 	title = removeTags(title)
 	return strings.TrimSpace(title)
@@ -45,7 +47,7 @@ func removeTags(title string) string {
 // TitleParse will parse a title into a Metadata, extracting stripped title, tags, season and episode information.
 func TitleParse(title string) Metadata {
 	resp := Metadata{
-		Title:              TitleStrip(title),
+		Title:              TitleStrip(title, false),
 		VerticalResolution: qualityMatch(title),
 	}
 	if tags := tagsExpr.FindAllStringSubmatch(title, -1); len(tags) > 0 {

internal/parser/title_test.go

@@ -17,7 +17,7 @@ func TestTitleStrip(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := TitleStrip(tt.title); got != tt.want {
+			if got := TitleStrip(tt.title, false); got != tt.want {
 				t.Errorf("TitleStrip() = %v, want %v", got, tt.want)
 			}
 		})