Merge pull request #24 from tphoney/spotify_similar_artists

(feat) improve search spotify speed

Dockerfile

@@ -26,7 +26,9 @@ COPY web/tv/*.go web/tv/
 COPY web/tv/*.html web/tv/
 COPY web/settings/*.go web/settings/
 COPY web/settings/*.html web/settings/
-COPY web/server.go web/index.html web/static/ /web/
+COPY web/server.go web/
+COPY web/index.html web/
+COPY web/static/ web/static/
 
 # Build
 RUN CGO_ENABLED=0 GOOS=linux go build -o /plex-lookup

TODO

@@ -2,13 +2,13 @@
 
 ## features
 
-- similar artist search for music
-
 ## bugs
 
+- allow amazon tv search for indivdual series
 - allow amazon tv search for newer series
 - update movies to use tv like search
-- allow amazon tv search for indivdual series
+- update movies, remove the plex resolution filter add plex resolution as a column
+- music, a-ha/ash doesnt match as an artist why ?
 
 ## done
 
@@ -28,3 +28,5 @@
 - remove dead fields from the tv data types
 - remove links to tv series we already have in plex. eg dont show adventure time series 1 and 2 ?
 - write a function to calculate plex dates
+- similar artist search for music
+- parallel requests for spotify search

musicbrainz/musicbrainz.go

@@ -68,7 +68,7 @@ func SearchMusicBrainzArtist(plexArtist *types.PlexMusicArtist) (artist types.Se
 		if resp.Artists[i].Name != plexArtist.Name {
 			continue
 		}
-		found := types.MusicSearchResult{
+		found := types.MusicArtistSearchResult{
 			Name: resp.Artists[i].Name,
 			ID:   fmt.Sprintf("%v", resp.Artists[i].ID),
 		}
@@ -85,7 +85,7 @@ func SearchMusicBrainzArtist(plexArtist *types.PlexMusicArtist) (artist types.Se
 	return artist, err
 }
 
-func SearchMusicBrainzAlbums(artistID string) (albums []types.MusicSearchAlbumResult, err error) {
+func SearchMusicBrainzAlbums(artistID string) (albums []types.MusicAlbumSearchResult, err error) {
 	client, err := gomusicbrainz.NewWS2Client(
 		musicBrainzURL, agent, agentVersion, "")
 
@@ -106,7 +106,7 @@ func SearchMusicBrainzAlbums(artistID string) (albums []types.MusicSearchAlbumRe
 	for i := range resp.ReleaseGroups {
 		if resp.ReleaseGroups[i].Type == "Album" {
 			year := resp.ReleaseGroups[i].FirstReleaseDate.Year()
-			albums = append(albums, types.MusicSearchAlbumResult{
+			albums = append(albums, types.MusicAlbumSearchResult{
 				Title: resp.ReleaseGroups[i].Title,
 				ID:    fmt.Sprintf("%v", resp.ReleaseGroups[i].ID),
 				Year:  fmt.Sprintf("%v", year),

musicbrainz/musicbrainz_test.go

@@ -18,12 +18,12 @@ func TestSearchMusicBrainzArtist(t *testing.T) {
 			args: &types.PlexMusicArtist{Name: "The Beatles"},
 			wantArtist: types.SearchResults{
 				SearchURL: "https://musicbrainz.org/artist/b10bbbfc-cf9e-42e0-be17-e2c3e1d2600d",
-				MusicSearchResults: []types.MusicSearchResult{
+				MusicSearchResults: []types.MusicArtistSearchResult{
 
 					{
 						Name:   "The Beatles",
 						ID:     "b10bbbfc-cf9e-42e0-be17-e2c3e1d2600d",
-						Albums: make([]types.MusicSearchAlbumResult, 16),
+						Albums: make([]types.MusicAlbumSearchResult, 16),
 					},
 				},
 			},
@@ -34,11 +34,11 @@ func TestSearchMusicBrainzArtist(t *testing.T) {
 			args: &types.PlexMusicArtist{Name: "AC/DC"},
 			wantArtist: types.SearchResults{
 				SearchURL: "https://musicbrainz.org/artist/66c662b6-6e2f-4930-8610-912e24c63ed1",
-				MusicSearchResults: []types.MusicSearchResult{
+				MusicSearchResults: []types.MusicArtistSearchResult{
 					{
 						Name:   "AC/DC",
 						ID:     "66c662b6-6e2f-4930-8610-912e24c63ed1",
-						Albums: make([]types.MusicSearchAlbumResult, 18),
+						Albums: make([]types.MusicAlbumSearchResult, 17),
 					},
 				},
 			},

spotify/spotify.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 	"time"
 
@@ -93,44 +94,72 @@ type AlbumsResponse struct {
 	Total    int64 `json:"total"`
 }
 
-func SearchSpotifyArtist(plexArtist *types.PlexMusicArtist, clientID, clientSecret string) (artist types.SearchResults, err error) {
-	artist.PlexMusicArtist = *plexArtist
+type SimilarArtistsResponse struct {
+	Artists []struct {
+		Name string `json:"name"`
+		ID   string `json:"id"`
+	}
+}
+
+func SearchSpotifyArtist(plexArtist *types.PlexMusicArtist, clientID, clientSecret string, ch chan<- *types.SearchResults) {
+	// context with a timeout of 30 seconds
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(lookupTimeout))
+	defer cancel()
+	searchResults := types.SearchResults{}
+	searchResults.PlexMusicArtist = *plexArtist
 	// get oauth token
-	if oauthToken == "" {
-		oauthToken, err = spotifyOauthToken(context.Background(), clientID, clientSecret)
-		if err != nil {
-			return artist, fmt.Errorf("SearchSpotifyArtist: unable to get oauth token: %s", err.Error())
-		}
+	err := SpotifyOauthToken(ctx, clientID, clientSecret)
+	if err != nil {
+		fmt.Printf("SearchSpotifyArtist: unable to get oauth token: %s\n", err.Error())
+		ch <- &searchResults
+		return
 	}
 	urlEncodedArtist := url.QueryEscape(plexArtist.Name)
 	artistURL := fmt.Sprintf("%s/search?q=%s&type=artist&limit=10", spotifyAPIURL, urlEncodedArtist)
 	client := &http.Client{
 		Timeout: time.Second * lookupTimeout,
 	}
-	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, artistURL, http.NoBody)
+	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, artistURL, http.NoBody)
 	bearer := fmt.Sprintf("Bearer %s", oauthToken)
 	req.Header.Add("Authorization", bearer)
-	response, err := client.Do(req)
-	if err != nil {
-		return artist, fmt.Errorf("lookupArtist: get failed from spotify: %s", err.Error())
-	}
-	if response.StatusCode == http.StatusTooManyRequests {
-		return artist, fmt.Errorf("lookupArtist: rate limited by spotify")
+	var response *http.Response
+	for {
+		response, err = client.Do(req)
+		if err != nil {
+			response.Body.Close()
+			fmt.Printf("lookupArtist: get failed from spotify: %s\n", err.Error())
+			ch <- &searchResults
+			return
+		}
+		if response.StatusCode == http.StatusTooManyRequests {
+			// rate limited
+			wait := response.Header.Get("Retry-After")
+			waitSeconds, _ := strconv.Atoi(wait)
+			time.Sleep(time.Duration(waitSeconds) * time.Second)
+			continue
+		}
+		if response.StatusCode == http.StatusOK {
+			break
+		}
 	}
 	defer response.Body.Close()
 	body, err := io.ReadAll(response.Body)
 	if err != nil {
-		return artist, fmt.Errorf("lookupArtist: unable to parse response from spotify: %s", err.Error())
+		fmt.Printf("lookupArtist: unable to read response from spotify: %s\n", err.Error())
+		ch <- &searchResults
+		return
 	}
 	var artistResponse ArtistResponse
 	jsonErr := json.Unmarshal(body, &artistResponse)
 	if jsonErr != nil {
-		return artist, fmt.Errorf("lookupArtist: unable to parse response from spotify: %s", jsonErr.Error())
+		fmt.Printf("lookupArtist: unable to parse response from spotify: %s\n", jsonErr.Error())
+		ch <- &searchResults
+		return
 	}
 	for i := range artistResponse.Artists.Items {
 		if artistStringMatcher(plexArtist.Name, artistResponse.Artists.Items[i].Name) {
 			// only get the first match
-			artist.MusicSearchResults = append(artist.MusicSearchResults, types.MusicSearchResult{
+			searchResults.MusicSearchResults = append(searchResults.MusicSearchResults, types.MusicArtistSearchResult{
 				Name: artistResponse.Artists.Items[i].Name,
 				ID:   artistResponse.Artists.Items[i].ID,
 				URL:  artistResponse.Artists.Items[i].ExternalUrls.Spotify,
@@ -139,57 +168,149 @@ func SearchSpotifyArtist(plexArtist *types.PlexMusicArtist, clientID, clientSecr
 			break
 		}
 	}
-	if len(artist.MusicSearchResults) == 0 {
-		return artist, err
-	}
-	// get the albums
-	artist.MusicSearchResults[0].Albums, err = SearchSpotifyAlbums(artist.MusicSearchResults[0].ID, clientID, clientSecret)
-	return artist, nil
+	ch <- &searchResults
 }
 
-func SearchSpotifyAlbums(artistID, clientID, clientSecret string) (albums []types.MusicSearchAlbumResult, err error) {
-	if oauthToken == "" {
-		oauthToken, err = spotifyOauthToken(context.Background(), clientID, clientSecret)
-		if err != nil {
-			return albums, fmt.Errorf("SearchSpotifyAlbums: unable to get oauth token: %s", err.Error())
-		}
+func SearchSpotifyAlbum(m *types.SearchResults, clientID, clientSecret string, ch chan<- *types.SearchResults) {
+	// get oauth token
+	err := SpotifyOauthToken(context.Background(), clientID, clientSecret)
+	if err != nil {
+		fmt.Printf("SearchSpotifyAlbums: unable to get oauth token: %s\n", err.Error())
+		ch <- m
+		return
+	}
+	if len(m.MusicSearchResults) == 0 {
+		// no artist found for the plex artist
+		fmt.Printf("SearchSpotifyAlbums: no artist found for %s\n", m.PlexMusicArtist.Name)
+		ch <- m
+		return
 	}
-	albumURL := fmt.Sprintf("%s/artists/%s/albums?include_groups=album&limit=50&", spotifyAPIURL, artistID)
+	albumURL := fmt.Sprintf("%s/artists/%s/albums?include_groups=album&limit=50&", spotifyAPIURL, m.MusicSearchResults[0].ID)
 	client := &http.Client{
 		Timeout: time.Second * lookupTimeout,
 	}
 	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, albumURL, http.NoBody)
 	bearer := fmt.Sprintf("Bearer %s", oauthToken)
 	req.Header.Add("Authorization", bearer)
-	response, err := client.Do(req)
-	if err != nil {
-		return albums, fmt.Errorf("lookupArtistAlbums: get failed from spotify: %s", err.Error())
+	var response *http.Response
+	for {
+		response, err = client.Do(req)
+		if err != nil {
+			response.Body.Close()
+			fmt.Printf("lookupArtistAlbums: get failed from spotify: %s\n", err.Error())
+			ch <- m
+			return
+		}
+		if response.StatusCode == http.StatusTooManyRequests {
+			wait := response.Header.Get("Retry-After")
+			waitSeconds, _ := strconv.Atoi(wait)
+			if waitSeconds > lookupTimeout {
+				fmt.Printf("lookupArtistAlbums: rate limited for %d seconds\n", waitSeconds)
+			}
+			time.Sleep(time.Duration(waitSeconds) * time.Second)
+			continue
+		}
+		if response.StatusCode == http.StatusOK {
+			break
+		}
 	}
 	defer response.Body.Close()
 	body, err := io.ReadAll(response.Body)
 	if err != nil {
-		return albums, fmt.Errorf("lookupArtistAlbums: unable to parse response from spotify: %s", err.Error())
+		fmt.Printf("lookupArtistAlbums: unable to parse response from spotify: %s\n", err.Error())
+		ch <- m
+		return
 	}
 	var albumsResponse AlbumsResponse
 	_ = json.Unmarshal(body, &albumsResponse)
 
+	albums := make([]types.MusicAlbumSearchResult, 0)
 	for i := range albumsResponse.Items {
 		// convert "2022-06-03" to "2022"
 		year := strings.Split(albumsResponse.Items[i].ReleaseDate, "-")[0]
-		albums = append(albums, types.MusicSearchAlbumResult{
+		albums = append(albums, types.MusicAlbumSearchResult{
 			Title: albumsResponse.Items[i].Name,
 			ID:    albumsResponse.Items[i].ID,
 			URL:   albumsResponse.Items[i].ExternalUrls.Spotify,
 			Year:  year,
 		})
 	}
 
-	return albums, err
+	m.MusicSearchResults[0].Albums = albums
+	ch <- m
+}
+
+func SearchSpotifySimilarArtist(m *types.SearchResults, clientID, clientSecret string, ch chan<- SimilarArtistsResponse) {
+	err := SpotifyOauthToken(context.Background(), clientID, clientSecret)
+	if err != nil {
+		fmt.Printf("SearchSpotifySimilarArtist: unable to get oauth token: %s\n", err.Error())
+		ch <- SimilarArtistsResponse{}
+		return
+	}
+	if len(m.MusicSearchResults) == 0 {
+		// no artist found for the plex artist
+		fmt.Printf("SearchSpotifySimilarArtist: no artist found for %s\n", m.PlexMusicArtist.Name)
+		ch <- SimilarArtistsResponse{}
+		return
+	}
+	similarArtistURL := fmt.Sprintf("%s/artists/%s/related-artists", spotifyAPIURL, m.MusicSearchResults[0].ID)
+	client := &http.Client{
+		Timeout: time.Second * lookupTimeout,
+	}
+	req, httpErr := http.NewRequestWithContext(context.Background(), http.MethodGet, similarArtistURL, http.NoBody)
+	if httpErr != nil {
+		fmt.Printf("SearchSpotifySimilarArtist: get failed from spotify: %s\n", httpErr.Error())
+		ch <- SimilarArtistsResponse{}
+		return
+	}
+	bearer := fmt.Sprintf("Bearer %s", oauthToken)
+	req.Header.Add("Authorization", bearer)
+	var response *http.Response
+	for {
+		response, err = client.Do(req)
+		if err != nil {
+			response.Body.Close()
+			fmt.Printf("SearchSpotifySimilarArtist: get failed from spotify: %s\n", err.Error())
+			ch <- SimilarArtistsResponse{}
+			return
+		}
+		if response.StatusCode == http.StatusTooManyRequests {
+			wait := response.Header.Get("Retry-After")
+			waitSeconds, _ := strconv.Atoi(wait)
+			if waitSeconds > lookupTimeout {
+				fmt.Printf("SearchSpotifySimilarArtist: rate limited for %d seconds\n", waitSeconds)
+			}
+			time.Sleep(time.Duration(waitSeconds) * time.Second)
+			continue
+		}
+		if response.StatusCode == http.StatusOK {
+			break
+		}
+	}
+
+	defer response.Body.Close()
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		fmt.Printf("SearchSpotifySimilarArtist: unable to parse response from spotify: %s\n", err.Error())
+		ch <- SimilarArtistsResponse{}
+		return
+	}
+	var similarArtistsResponse SimilarArtistsResponse
+	jsonErr := json.Unmarshal(body, &similarArtistsResponse)
+	if jsonErr != nil {
+		fmt.Printf("SearchSpotifySimilarArtist: unable to unmarshal response from spotify: %s\n", jsonErr.Error())
+		ch <- SimilarArtistsResponse{}
+		return
+	}
+	ch <- similarArtistsResponse
 }
 
 // function that gets an oauth token from spotify from the client id and secret
-func spotifyOauthToken(ctx context.Context, clientID, clientSecret string) (oauth string, err error) {
+func SpotifyOauthToken(ctx context.Context, clientID, clientSecret string) (err error) {
 	// get oauth token
+	if oauthToken != "" {
+		return nil
+	}
 	oauthURL := "https://accounts.spotify.com/api/token"
 	client := &http.Client{
 		Timeout: time.Second * lookupTimeout,
@@ -202,22 +323,23 @@ func spotifyOauthToken(ctx context.Context, clientID, clientSecret string) (oaut
 	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
 	response, err := client.Do(req)
 	if err != nil {
-		return "", fmt.Errorf("spotifyOauthToken: get failed from spotify: %s", err.Error())
+		return fmt.Errorf("spotifyOauthToken: get failed from spotify: %s", err.Error())
 	}
 	defer response.Body.Close()
 	body, err := io.ReadAll(response.Body)
 	if err != nil {
-		return "", fmt.Errorf("spotifyOauthToken: unable to read response from spotify: %s", err.Error())
+		return fmt.Errorf("spotifyOauthToken: unable to read response from spotify: %s", err.Error())
 	}
 	var oauthResponse struct {
 		AccessToken string `json:"access_token"`
 		TokenType   string `json:"token_type"`
 	}
 	err = json.Unmarshal(body, &oauthResponse)
 	if err != nil {
-		return "", fmt.Errorf("getOauthToken: unable to parse response from spotify: %s", err.Error())
+		return fmt.Errorf("getOauthToken: unable to parse response from spotify: %s", err.Error())
 	}
-	return oauthResponse.AccessToken, nil
+	oauthToken = oauthResponse.AccessToken
+	return nil
 }
 
 func artistStringMatcher(dbName, webName string) bool {