sonda/internal/smart/smart.go
tgiachi bf5c108785 feat(smart): the songs I play most, in rotation lately and over the year
- A smart playlist rule, plays_within_days, that counts only the plays of the last N days where plays are counted: the minimum of plays and the most and least played orders. The other listening rules are not changed.
- Two more suggested smart playlists on it: on-rotation (the most played of the last 30 days, at least twice) and top-year (the same over 365 days). most-played stays as the plays of all time.
- The editor has the new rule and the page says it in words. Texts in English and Italian.
2026-11-13 10:44:55 +01:00

691 lines
23 KiB
Go

// Package smart keeps the smart playlists of each user: playlists that are a set of rules instead of a
// list of songs, worked out again every time they are opened, so the songs that arrive and what the
// listener plays change them by themselves.
//
// A smart playlist is made of Rules (every rule that is set must hold), an order and a limit. Only that is
// stored. The songs come from the playable songs of the library, then from the history and the taste of the
// owner, the way the mixes are made (see package mixes): nothing here contacts anyone, and a smart playlist
// that belongs to somebody else is as if it did not exist (ErrNotFound).
//
// "Random" is not new at every request: like a mix it stays the same for a day, and a variant number asks
// for another.
package smart
import (
"context"
"errors"
"fmt"
"hash/fnv"
"regexp"
"slices"
"sort"
"strings"
"time"
"unicode/utf8"
"codeberg.org/squidd/sonda/internal/catalog"
"codeberg.org/squidd/sonda/internal/mixes"
"codeberg.org/squidd/sonda/internal/taste"
)
// Limits. They keep one user from filling the database and one request from doing too much.
const (
MaxNameLen = 200
MaxDescriptionLen = 2000
MaxListed = 50 // genres, artists, albums or formats in one rule
MaxDays = 36_500
MaxPlays = 1_000_000
MaxBitrateKbps = 100_000
MaxDurationSec = 86_400
DefaultLimit = 50
MaxLimit = 500
MaxPlaylists = 200 // smart playlists of one user
MaxVariant = mixes.MaxVariant
DefaultPageLimit = 50
MaxPageLimit = 200
)
// Errors returned by the service and the store.
var (
ErrInvalidInput = errors.New("invalid input")
ErrNotFound = errors.New("smart playlist not found")
ErrTooMany = errors.New("limit reached")
)
// Sort is the order of the songs of a smart playlist, before the limit cuts the end.
type Sort string
// The orders. A tie always goes to the lower song id.
const (
SortRandom Sort = "random"
SortMostPlayed Sort = "most_played"
SortLeastPlayed Sort = "least_played"
SortRecentlyAdded Sort = "recently_added"
SortTitle Sort = "title"
)
func (s Sort) valid() bool {
switch s {
case SortRandom, SortMostPlayed, SortLeastPlayed, SortRecentlyAdded, SortTitle:
return true
}
return false
}
// Rules say which songs a smart playlist takes. A rule that is not set (empty, false or 0) does not count;
// every rule that is set must hold. The songs of a list rule match when they are by one of the artists, in
// one of the albums, have one of the genres or are in one of the formats.
type Rules struct {
// Genres are kept as they are compared: lower case, with "+", "-", "_" and "/" taken for spaces
// ("jazz+funk" and "jazz-funk" are the same genre).
Genres []string `json:"genres,omitempty"`
NotGenres []string `json:"not_genres,omitempty"`
// Artists are the main artists of the song.
ArtistIDs []int64 `json:"artist_ids,omitempty"`
NotArtistIDs []int64 `json:"not_artist_ids,omitempty"`
AlbumIDs []int64 `json:"album_ids,omitempty"`
NotAlbumIDs []int64 `json:"not_album_ids,omitempty"`
// Formats are those of the files ("flac", "mpeg"), in lower case. A song counts when a file of it, that is
// not missing, has one of them (and, with MinBitrateKbps, that bitrate or more).
Formats []string `json:"formats,omitempty"`
MinBitrateKbps int `json:"min_bitrate_kbps,omitempty"`
// AddedWithinDays is about the date of the file, which is the best the index knows.
AddedWithinDays int `json:"added_within_days,omitempty"`
// The listening rules are about the owner's history: a listen counts when the play was completed or lasted
// the minimum listen of the server, and a skip when it came before that.
NeverPlayed bool `json:"never_played,omitempty"`
PlayedWithinDays int `json:"played_within_days,omitempty"`
NotPlayedWithinDays int `json:"not_played_within_days,omitempty"`
MinPlays int `json:"min_plays,omitempty"`
// PlaysWithinDays counts only the plays of the last N days where plays are counted: the minimum of plays and
// the most and least played orders. It does not change the other listening rules.
PlaysWithinDays int `json:"plays_within_days,omitempty"`
SkippedWithinDays int `json:"skipped_within_days,omitempty"`
NotSkippedWithinDays int `json:"not_skipped_within_days,omitempty"`
// LikedArtistsOnly keeps the songs of artists the owner likes; WithoutAvoidedArtists leaves out the ones
// the owner avoids (see package taste).
LikedArtistsOnly bool `json:"liked_artists_only,omitempty"`
WithoutAvoidedArtists bool `json:"without_avoided_artists,omitempty"`
MinDurationSec int `json:"min_duration_sec,omitempty"`
MaxDurationSec int `json:"max_duration_sec,omitempty"`
}
// SmartPlaylist is a smart playlist.
type SmartPlaylist struct {
ID int64
Name string
Description string
Rules Rules
Sort Sort
Limit int
CreatedAt time.Time
UpdatedAt time.Time
}
// Input is what makes a smart playlist, or the preview of one. A zero Sort is random and a zero Limit is
// DefaultLimit.
type Input struct {
Name string
Description string
Rules Rules
Sort Sort
Limit int
}
// Patch changes the smart playlist in the fields that are not nil. Rules replace the old ones whole.
type Patch struct {
Name *string
Description *string
Rules *Rules
Sort *Sort
Limit *int
}
// History is what one listener did with one song.
type History = mixes.History
// Candidate is a playable song the rules may take, with what they need to know of it.
type Candidate struct {
TrackID int64
ArtistID int64 // the main artist, 0 when there is none
Title string
DurationMs int64
AddedAt time.Time // the date of its newest file that is not missing
}
// Filter is the part of the rules that the index answers: every list that is set narrows the songs.
// Genres are spelled as the files have them.
type Filter struct {
Genres, NotGenres []string
ArtistIDs, NotArtistIDs []int64
AlbumIDs, NotAlbumIDs []int64
Formats []string
MinBitrateKbps int
}
// Store keeps the smart playlists and reads what they are made of. Every call that is about one playlist is
// for one user and gives ErrNotFound for a playlist that does not exist or is not theirs.
type Store interface {
// Create keeps a playlist (its ID is ignored), or gives ErrTooMany when the user has MaxPlaylists.
Create(ctx context.Context, userID int64, p SmartPlaylist, now time.Time) (SmartPlaylist, error)
// List returns a page of the user's smart playlists, the one changed last first, and how many there are.
List(ctx context.Context, userID int64, limit, offset int) ([]SmartPlaylist, int, error)
Get(ctx context.Context, userID, id int64) (SmartPlaylist, error)
// Update replaces name, description, rules, order and limit.
Update(ctx context.Context, userID, id int64, p SmartPlaylist, now time.Time) (SmartPlaylist, error)
Delete(ctx context.Context, userID, id int64) error
// Genres returns every genre of the playable songs, as spelled in the files.
Genres(ctx context.Context) ([]mixes.Genre, error)
// Candidates returns the playable songs of the filter.
Candidates(ctx context.Context, f Filter) ([]Candidate, error)
// History returns what the user did with the songs they did anything with; minListen is how long a
// play must last to count as a listen.
History(ctx context.Context, userID int64, minListen time.Duration) (map[int64]History, error)
// Plays returns how many listens the user has of each song since a moment, for the songs they listened to.
Plays(ctx context.Context, userID int64, minListen time.Duration, since time.Time) (map[int64]int, error)
// Tracks returns the songs in the order given, leaving out any that cannot be played.
Tracks(ctx context.Context, ids []int64) ([]catalog.Track, error)
}
// Taster says what the listener likes: *taste.Service.
type Taster interface {
Learn(ctx context.Context, userID int64) (taste.Learned, error)
}
// Service validates what it is given, keeps the smart playlists and works their songs out.
type Service struct {
store Store
taster Taster
minListen time.Duration
now func() time.Time
}
// NewService builds a Service. minListen is how long a play must last to count as a listen.
func NewService(store Store, taster Taster, minListen time.Duration) *Service {
return &Service{store: store, taster: taster, minListen: minListen, now: time.Now}
}
func invalid(format string, a ...any) error {
return fmt.Errorf("%w: %s", ErrInvalidInput, fmt.Sprintf(format, a...))
}
func cleanName(name string) (string, error) {
name = strings.TrimSpace(name)
if name == "" || utf8.RuneCountInString(name) > MaxNameLen {
return "", invalid("the name must have 1 to %d characters", MaxNameLen)
}
return name, nil
}
func cleanDescription(d string) (string, error) {
d = strings.TrimSpace(d)
if utf8.RuneCountInString(d) > MaxDescriptionLen {
return "", invalid("the description can have up to %d characters", MaxDescriptionLen)
}
return d, nil
}
var formatRe = regexp.MustCompile(`^[a-z0-9]{1,16}$`)
func cleanGenres(rule string, in []string) ([]string, error) {
if len(in) > MaxListed {
return nil, invalid("%s can have up to %d genres", rule, MaxListed)
}
var out []string
for _, g := range in {
n := mixes.NormalizeGenre(g)
if n == "" {
return nil, invalid("%q is not a genre", g)
}
if !slices.Contains(out, n) {
out = append(out, n)
}
}
return out, nil
}
func cleanFormats(in []string) ([]string, error) {
if len(in) > MaxListed {
return nil, invalid("formats can have up to %d items", MaxListed)
}
var out []string
for _, f := range in {
f = strings.ToLower(strings.TrimSpace(f))
if !formatRe.MatchString(f) {
return nil, invalid("%q is not a format", f)
}
if !slices.Contains(out, f) {
out = append(out, f)
}
}
return out, nil
}
func cleanIDs(rule string, in []int64) ([]int64, error) {
if len(in) > MaxListed {
return nil, invalid("%s can have up to %d ids", rule, MaxListed)
}
var out []int64
for _, id := range in {
if id < 1 {
return nil, invalid("%s must be ids, from 1", rule)
}
if !slices.Contains(out, id) {
out = append(out, id)
}
}
return out, nil
}
func inRange(rule string, n, max int) error {
if n < 0 || n > max {
return invalid("%s must be from 0 to %d", rule, max)
}
return nil
}
// cleanRules checks the rules and returns them in the form they are kept in.
func cleanRules(r Rules) (Rules, error) {
var err error
if r.Genres, err = cleanGenres("genres", r.Genres); err != nil {
return Rules{}, err
}
if r.NotGenres, err = cleanGenres("not_genres", r.NotGenres); err != nil {
return Rules{}, err
}
for _, l := range []struct {
name string
ids *[]int64
}{{"artist_ids", &r.ArtistIDs}, {"not_artist_ids", &r.NotArtistIDs}, {"album_ids", &r.AlbumIDs}, {"not_album_ids", &r.NotAlbumIDs}} {
if *l.ids, err = cleanIDs(l.name, *l.ids); err != nil {
return Rules{}, err
}
}
if r.Formats, err = cleanFormats(r.Formats); err != nil {
return Rules{}, err
}
for _, n := range []struct {
name string
got, max int
}{
{"min_bitrate_kbps", r.MinBitrateKbps, MaxBitrateKbps},
{"added_within_days", r.AddedWithinDays, MaxDays},
{"played_within_days", r.PlayedWithinDays, MaxDays},
{"not_played_within_days", r.NotPlayedWithinDays, MaxDays},
{"skipped_within_days", r.SkippedWithinDays, MaxDays},
{"not_skipped_within_days", r.NotSkippedWithinDays, MaxDays},
{"min_plays", r.MinPlays, MaxPlays},
{"plays_within_days", r.PlaysWithinDays, MaxDays},
{"min_duration_sec", r.MinDurationSec, MaxDurationSec},
{"max_duration_sec", r.MaxDurationSec, MaxDurationSec},
} {
if err := inRange(n.name, n.got, n.max); err != nil {
return Rules{}, err
}
}
if r.MaxDurationSec > 0 && r.MinDurationSec > r.MaxDurationSec {
return Rules{}, invalid("min_duration_sec is more than max_duration_sec")
}
return r, nil
}
// cleanShape checks the order and the limit and gives them their defaults.
func cleanShape(sortBy Sort, limit int) (Sort, int, error) {
if sortBy == "" {
sortBy = SortRandom
}
if !sortBy.valid() {
return "", 0, invalid("sort must be random, most_played, least_played, recently_added or title")
}
if limit == 0 {
limit = DefaultLimit
}
if limit < 1 || limit > MaxLimit {
return "", 0, invalid("limit must be from 1 to %d", MaxLimit)
}
return sortBy, limit, nil
}
// clean checks everything but the name, which a preview does not have.
func clean(in Input) (Input, error) {
var err error
if in.Description, err = cleanDescription(in.Description); err != nil {
return Input{}, err
}
if in.Rules, err = cleanRules(in.Rules); err != nil {
return Input{}, err
}
if in.Sort, in.Limit, err = cleanShape(in.Sort, in.Limit); err != nil {
return Input{}, err
}
return in, nil
}
// Create keeps a smart playlist for the user.
func (s *Service) Create(ctx context.Context, userID int64, in Input) (SmartPlaylist, error) {
name, err := cleanName(in.Name)
if err != nil {
return SmartPlaylist{}, err
}
in, err = clean(in)
if err != nil {
return SmartPlaylist{}, err
}
return s.store.Create(ctx, userID, SmartPlaylist{Name: name, Description: in.Description, Rules: in.Rules, Sort: in.Sort, Limit: in.Limit}, s.now())
}
// Listing is a page of smart playlists.
type Listing struct {
Items []SmartPlaylist
Total int
Limit int
Offset int
}
// List returns a page of the user's smart playlists, the one changed last first. A limit of 0 is
// DefaultPageLimit, and one above MaxPageLimit is lowered to it, as for the playlists.
func (s *Service) List(ctx context.Context, userID int64, limit, offset int) (Listing, error) {
if limit < 0 || offset < 0 {
return Listing{}, invalid("limit and offset cannot be negative")
}
switch {
case limit == 0:
limit = DefaultPageLimit
case limit > MaxPageLimit:
limit = MaxPageLimit
}
items, total, err := s.store.List(ctx, userID, limit, offset)
if err != nil {
return Listing{}, err
}
return Listing{Items: items, Total: total, Limit: limit, Offset: offset}, nil
}
// Get returns a smart playlist of the user, without its songs.
func (s *Service) Get(ctx context.Context, userID, id int64) (SmartPlaylist, error) {
return s.store.Get(ctx, userID, id)
}
// Update changes the fields of the patch that are not nil.
func (s *Service) Update(ctx context.Context, userID, id int64, p Patch) (SmartPlaylist, error) {
cur, err := s.store.Get(ctx, userID, id)
if err != nil {
return SmartPlaylist{}, err
}
in := Input{Name: cur.Name, Description: cur.Description, Rules: cur.Rules, Sort: cur.Sort, Limit: cur.Limit}
if p.Name != nil {
in.Name = *p.Name
}
if p.Description != nil {
in.Description = *p.Description
}
if p.Rules != nil {
in.Rules = *p.Rules
}
if p.Sort != nil {
in.Sort = *p.Sort
}
if p.Limit != nil {
in.Limit = *p.Limit
}
if in.Name, err = cleanName(in.Name); err != nil {
return SmartPlaylist{}, err
}
if in, err = clean(in); err != nil {
return SmartPlaylist{}, err
}
return s.store.Update(ctx, userID, id, SmartPlaylist{Name: in.Name, Description: in.Description, Rules: in.Rules, Sort: in.Sort, Limit: in.Limit}, s.now())
}
// GenreCount is a genre as it is compared (see Rules) with the number of playable songs that have it.
type GenreCount struct {
Name string
Tracks int
}
// Genres returns the genres of the library to choose from in a rule, the one with most songs first, and
// by name among equals. The spellings the files have are one genre; "other" and the like are left out.
func (s *Service) Genres(ctx context.Context) ([]GenreCount, error) {
all, err := s.store.Genres(ctx)
if err != nil {
return nil, fmt.Errorf("read genres: %w", err)
}
byName := map[string]int{}
for _, g := range all {
if n := mixes.NormalizeGenre(g.Name); n != "" {
byName[n] += g.Tracks
}
}
out := make([]GenreCount, 0, len(byName))
for n, c := range byName {
out = append(out, GenreCount{n, c})
}
sort.Slice(out, func(i, j int) bool {
if out[i].Tracks != out[j].Tracks {
return out[i].Tracks > out[j].Tracks
}
return out[i].Name < out[j].Name
})
return out, nil
}
// Delete removes a smart playlist of the user.
func (s *Service) Delete(ctx context.Context, userID, id int64) error {
return s.store.Delete(ctx, userID, id)
}
// Tracks works the songs of a smart playlist out. variant 0 is the one of the day; with a random order,
// another number gives other songs.
func (s *Service) Tracks(ctx context.Context, userID, id int64, variant int) (SmartPlaylist, []catalog.Track, error) {
if err := checkVariant(variant); err != nil {
return SmartPlaylist{}, nil, err
}
p, err := s.store.Get(ctx, userID, id)
if err != nil {
return SmartPlaylist{}, nil, err
}
tracks, err := s.run(ctx, userID, p.ID, p.Rules, p.Sort, p.Limit, variant)
return p, tracks, err
}
// Preview works the songs out for rules that are not kept, to try them before saving.
func (s *Service) Preview(ctx context.Context, userID int64, in Input, variant int) ([]catalog.Track, error) {
if err := checkVariant(variant); err != nil {
return nil, err
}
in, err := clean(in)
if err != nil {
return nil, err
}
return s.run(ctx, userID, 0, in.Rules, in.Sort, in.Limit, variant)
}
func checkVariant(v int) error {
if v < 0 || v > MaxVariant {
return invalid("variant must be from 0 to %d", MaxVariant)
}
return nil
}
// spellings returns the spellings the files have of the genres (all compared as normalized).
func spellings(all []mixes.Genre, genres []string) []string {
var out []string
for _, g := range all {
if slices.Contains(genres, mixes.NormalizeGenre(g.Name)) {
out = append(out, g.Name)
}
}
return out
}
func (s *Service) run(ctx context.Context, userID, id int64, r Rules, order Sort, limit, variant int) ([]catalog.Track, error) {
f := Filter{
ArtistIDs: r.ArtistIDs, NotArtistIDs: r.NotArtistIDs, AlbumIDs: r.AlbumIDs, NotAlbumIDs: r.NotAlbumIDs,
Formats: r.Formats, MinBitrateKbps: r.MinBitrateKbps,
}
if len(r.Genres) > 0 || len(r.NotGenres) > 0 {
all, err := s.store.Genres(ctx)
if err != nil {
return nil, fmt.Errorf("read genres: %w", err)
}
f.Genres, f.NotGenres = spellings(all, r.Genres), spellings(all, r.NotGenres)
if len(r.Genres) > 0 && len(f.Genres) == 0 {
return []catalog.Track{}, nil // no file has any of the genres
}
}
cands, err := s.store.Candidates(ctx, f)
if err != nil {
return nil, fmt.Errorf("read the songs: %w", err)
}
countsPlays := order == SortMostPlayed || order == SortLeastPlayed || r.MinPlays > 0
var history map[int64]History
if (countsPlays && r.PlaysWithinDays == 0) || r.NeverPlayed ||
r.PlayedWithinDays > 0 || r.NotPlayedWithinDays > 0 || r.SkippedWithinDays > 0 || r.NotSkippedWithinDays > 0 {
if history, err = s.store.History(ctx, userID, s.minListen); err != nil {
return nil, fmt.Errorf("read history: %w", err)
}
}
// The plays that are counted: all of them, or only those of the window.
plays := func(id int64) int { return history[id].Plays }
if countsPlays && r.PlaysWithinDays > 0 {
window, err := s.store.Plays(ctx, userID, s.minListen, s.now().Add(-time.Duration(r.PlaysWithinDays)*24*time.Hour))
if err != nil {
return nil, fmt.Errorf("read plays: %w", err)
}
plays = func(id int64) int { return window[id] }
}
var learned taste.Learned
if r.LikedArtistsOnly || r.WithoutAvoidedArtists {
if learned, err = s.taster.Learn(ctx, userID); err != nil {
return nil, fmt.Errorf("learn taste: %w", err)
}
}
now := s.now()
within := func(t time.Time, days int) bool {
return !t.IsZero() && now.Sub(t) <= time.Duration(days)*24*time.Hour
}
kept := make([]Candidate, 0, len(cands))
for _, c := range cands {
h := history[c.TrackID]
switch {
case r.AddedWithinDays > 0 && !within(c.AddedAt, r.AddedWithinDays),
r.MinDurationSec > 0 && c.DurationMs < int64(r.MinDurationSec)*1000,
r.MaxDurationSec > 0 && c.DurationMs > int64(r.MaxDurationSec)*1000,
r.NeverPlayed && h.Plays > 0,
r.PlayedWithinDays > 0 && !within(h.LastPlayed, r.PlayedWithinDays),
r.NotPlayedWithinDays > 0 && within(h.LastPlayed, r.NotPlayedWithinDays),
r.MinPlays > 0 && plays(c.TrackID) < r.MinPlays,
r.SkippedWithinDays > 0 && !within(h.SkippedAt, r.SkippedWithinDays),
r.NotSkippedWithinDays > 0 && within(h.SkippedAt, r.NotSkippedWithinDays),
r.LikedArtistsOnly && learned.Prefs[c.ArtistID].Preference <= 0,
r.WithoutAvoidedArtists && learned.Prefs[c.ArtistID].Preference < 0:
continue
}
kept = append(kept, c)
}
sortCandidates(kept, order, plays, func(c Candidate) uint64 {
h := fnv.New64a()
fmt.Fprintf(h, "%d|%d|%d|%d|%d", userID, id, now.Unix()/86400, variant, c.TrackID)
return h.Sum64()
})
if len(kept) > limit {
kept = kept[:limit]
}
picked := make([]int64, len(kept))
for i, c := range kept {
picked[i] = c.TrackID
}
tracks, err := s.store.Tracks(ctx, picked)
if err != nil {
return nil, fmt.Errorf("read songs: %w", err)
}
return tracks, nil
}
// sortCandidates puts the songs in the order; a tie goes to the lower id. A random order sorts by the
// hash of the song with the seed of the day, which is the same until the day or the variant changes.
func sortCandidates(c []Candidate, order Sort, plays func(int64) int, hash func(Candidate) uint64) {
var keys map[int64]uint64
if order == SortRandom {
keys = make(map[int64]uint64, len(c))
for _, x := range c {
keys[x.TrackID] = hash(x)
}
}
less := func(a, b Candidate) int {
switch order {
case SortRandom:
if ka, kb := keys[a.TrackID], keys[b.TrackID]; ka != kb {
if ka < kb {
return -1
}
return 1
}
case SortMostPlayed, SortLeastPlayed:
pa, pb := plays(a.TrackID), plays(b.TrackID)
if order == SortLeastPlayed {
pa, pb = pb, pa
}
if pa != pb {
if pa > pb {
return -1
}
return 1
}
case SortRecentlyAdded:
if !a.AddedAt.Equal(b.AddedAt) {
if a.AddedAt.After(b.AddedAt) {
return -1
}
return 1
}
case SortTitle:
if a.Title != b.Title {
if a.Title < b.Title {
return -1
}
return 1
}
}
switch {
case a.TrackID < b.TrackID:
return -1
case a.TrackID > b.TrackID:
return 1
}
return 0
}
sort.SliceStable(c, func(i, j int) bool { return less(c[i], c[j]) < 0 })
}
// Summary says the rules in a few words of English, for the facts about a list that a name is made from. Artists
// and albums are ids and say nothing to a reader, so they are left out.
func (r Rules) Summary() string {
var parts []string
add := func(cond bool, format string, a ...any) {
if cond {
parts = append(parts, fmt.Sprintf(format, a...))
}
}
add(len(r.Genres) > 0, "genres: %s", strings.Join(r.Genres, ", "))
add(len(r.NotGenres) > 0, "not genres: %s", strings.Join(r.NotGenres, ", "))
add(len(r.Formats) > 0, "formats: %s", strings.Join(r.Formats, ", "))
add(r.MinBitrateKbps > 0, "at least %d kbps", r.MinBitrateKbps)
add(r.AddedWithinDays > 0, "added in the last %d days", r.AddedWithinDays)
add(r.NeverPlayed, "never played")
add(r.PlayedWithinDays > 0, "played in the last %d days", r.PlayedWithinDays)
add(r.NotPlayedWithinDays > 0, "not played for %d days", r.NotPlayedWithinDays)
add(r.MinPlays > 0, "played at least %d times", r.MinPlays)
add(r.PlaysWithinDays > 0, "plays counted over the last %d days", r.PlaysWithinDays)
add(r.SkippedWithinDays > 0, "skipped in the last %d days", r.SkippedWithinDays)
add(r.NotSkippedWithinDays > 0, "not skipped in the last %d days", r.NotSkippedWithinDays)
add(r.LikedArtistsOnly, "only liked artists")
add(r.WithoutAvoidedArtists, "without avoided artists")
add(r.MinDurationSec > 0, "at least %d minutes long", r.MinDurationSec/60)
add(r.MaxDurationSec > 0, "at most %d minutes long", r.MaxDurationSec/60)
return strings.Join(parts, "; ")
}