profile canvas wip

Author: elisiei

assets/font/Inter_24pt-Bold.ttf

@@ -64,6 +64,31 @@ func Fetch(url string) ([]byte, error) {
 	return data, nil
 }
 
+// FromUrl retrieves an image from the given URL and decodes it.
+func FromUrl(url string) (image.Image, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("failed to fetch image: %s", resp.Status)
+	}
+
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	img, _, err := image.Decode(bytes.NewReader(data))
+	if err != nil {
+		return nil, err
+	}
+
+	return img, nil
+}
+
 // DecodeImage loads and decodes an image from a byte slice and returns it.
 //
 // Usage example:

assets/img/profile_layout.png

@@ -7,8 +7,9 @@ import (
 	"image"
 	"image/color"
 	"image/draw"
-	"image/gif"
 	"net/http"
+	"sync"
+	"time"
 
 	"github.com/nxtgo/arikawa/v3/api"
 	"github.com/nxtgo/arikawa/v3/discord"
@@ -25,20 +26,25 @@ var (
 	maxGridSize   = 10
 	minGridSize   = 3
 	defaultPeriod = "overall"
+	brokenImage   image.Image
+	maxConcurrent = 8
 )
 
+var httpClient = &http.Client{
+	Transport: &http.Transport{
+		MaxIdleConns:        100,
+		MaxIdleConnsPerHost: 10,
+		IdleConnTimeout:     90 * time.Second,
+	},
+	Timeout: 10 * time.Second,
+}
+
 type Entry struct {
 	Image  image.Image
 	Name   string
 	Artist string
 }
 
-type deezerSearchResponse struct {
-	Data []struct {
-		Picture string `json:"picture"`
-	} `json:"data"`
-}
-
 var data = api.CreateCommandData{
 	Name:        "chart",
 	Description: "Your top artists/tracks/albums but with images",
@@ -99,29 +105,7 @@ func handler(c *commands.CommandContext) error {
 			return err
 		}
 
-		brokenImage, _ := imgio.Open("assets/img/broken.png")
-		brokenImage = transform.Resize(brokenImage, 300, 300, transform.Gaussian)
-
-		fetchImage := func(url string) image.Image {
-			resp, err := http.Get(url)
-			if err != nil {
-				return brokenImage
-			}
-			defer resp.Body.Close()
-
-			img, _, err := image.Decode(resp.Body)
-			if err == nil {
-				return img
-			}
-
-			gifImg, err := gif.Decode(resp.Body)
-			if err != nil {
-				return brokenImage
-			}
-			return gifImg
-		}
-
-		var entries []Entry
+		entries := make([]Entry, 0, gridSize*gridSize)
 
 		switch options.Type {
 		case "artist":
@@ -130,51 +114,89 @@ func handler(c *commands.CommandContext) error {
 				return err
 			}
 
-			for _, a := range topArtists.Artists {
+			urls := make([]string, len(topArtists.Artists))
+			names := make([]string, len(topArtists.Artists))
+			for i, a := range topArtists.Artists {
 				imgURL, err := a.GetDeezerImage()
 				if err != nil || imgURL == "" {
-					entries = append(entries, Entry{Image: brokenImage, Name: a.Name})
-					continue
+					urls[i] = ""
+				} else {
+					urls[i] = imgURL
+				}
+				names[i] = a.Name
+			}
+			fetched := fetchEntries(urls)
+			for i, e := range fetched {
+				if e.Image == nil {
+					e.Image = brokenImage
 				}
-				img := fetchImage(imgURL)
-				img = transform.Resize(img, 300, 300, transform.Gaussian)
-				entries = append(entries, Entry{Image: img, Name: a.Name})
+				e.Image = transform.Resize(e.Image, 300, 300, transform.NearestNeighbor)
+				e.Name = names[i]
+				entries = append(entries, e)
 			}
 
 		case "track":
 			topTracks, err := c.Last.User.GetTopTracks(lastfm.P{"user": username, "limit": gridSize * gridSize, "period": period})
 			if err != nil {
 				return err
 			}
-			for _, t := range topTracks.Tracks {
-				img := brokenImage
+
+			urls := make([]string, len(topTracks.Tracks))
+			names := make([]string, len(topTracks.Tracks))
+			artists := make([]string, len(topTracks.Tracks))
+			for i, t := range topTracks.Tracks {
 				if len(t.Images) > 0 {
-					img = fetchImage(t.Images[len(t.Images)-1].URL)
+					urls[i] = t.Images[len(t.Images)-1].URL
+				}
+				names[i] = t.Name
+				artists[i] = t.Artist.Name
+			}
+			fetched := fetchEntries(urls)
+			for i, e := range fetched {
+				if e.Image == nil {
+					e.Image = brokenImage
 				}
-				entries = append(entries, Entry{Image: img, Name: t.Name, Artist: t.Artist.Name})
+				e.Name = names[i]
+				e.Artist = artists[i]
+				entries = append(entries, e)
 			}
 
 		case "album":
 			topAlbums, err := c.Last.User.GetTopAlbums(lastfm.P{"user": username, "limit": gridSize * gridSize, "period": period})
 			if err != nil {
 				return err
 			}
-			for _, a := range topAlbums.Albums {
-				img := brokenImage
+
+			urls := make([]string, len(topAlbums.Albums))
+			names := make([]string, len(topAlbums.Albums))
+			artists := make([]string, len(topAlbums.Albums))
+			for i, a := range topAlbums.Albums {
 				if len(a.Images) > 0 {
-					img = fetchImage(a.Images[len(a.Images)-1].URL)
+					urls[i] = a.Images[len(a.Images)-1].URL
 				}
-				entries = append(entries, Entry{Image: img, Name: a.Name, Artist: a.Artist.Name})
+				names[i] = a.Name
+				artists[i] = a.Artist.Name
+			}
+			fetched := fetchEntries(urls)
+			for i, e := range fetched {
+				if e.Image == nil {
+					e.Image = brokenImage
+				}
+				e.Name = names[i]
+				e.Artist = artists[i]
+				entries = append(entries, e)
 			}
 		}
 
 		if len(entries) == 0 {
 			return errors.New("no entries found")
 		}
 
-		inter := font.LoadFont("assets/font/Inter_24pt-Regular.ttf")
-		labelFace := inter.Face(20, 72)
-		subFace := inter.Face(16, 72)
+		interRegular := font.LoadFont("assets/font/Inter_24pt-Regular.ttf")
+		interBold := font.LoadFont("assets/font/Inter_24pt-Bold.ttf")
+
+		labelFace := interBold.Face(20, 72)
+		subFace := interRegular.Face(16, 72)
 
 		firstBounds := entries[0].Image.Bounds()
 		cellWidth := firstBounds.Dx()
@@ -188,6 +210,9 @@ func handler(c *commands.CommandContext) error {
 			return err
 		}
 
+		labelAscent := labelFace.Metrics().Ascent.Ceil()
+		subAscent := subFace.Metrics().Ascent.Ceil()
+
 		for i, entry := range entries {
 			row := i / gridSize
 			col := i % gridSize
@@ -197,10 +222,11 @@ func handler(c *commands.CommandContext) error {
 
 			draw.Draw(canvas, rect, entry.Image, image.Point{}, draw.Over)
 			draw.Draw(canvas, rect, chartGradient, image.Point{}, draw.Over)
-			font.DrawText(canvas, x+15, y+labelFace.Metrics().Ascent.Ceil()+15, entry.Name, color.White, labelFace)
+
+			font.DrawText(canvas, x+15, y+labelAscent+15, entry.Name, color.White, labelFace)
 
 			if entry.Artist != "" {
-				font.DrawText(canvas, x+15, y+labelFace.Metrics().Ascent.Ceil()+subFace.Metrics().Ascent.Ceil()+25,
+				font.DrawText(canvas, x+15, y+labelAscent+subAscent+20,
 					entry.Artist, color.RGBA{170, 170, 170, 255}, subFace)
 			}
 		}
@@ -210,11 +236,50 @@ func handler(c *commands.CommandContext) error {
 			return err
 		}
 
-		_, err = edit.File(sendpart.File{Name: "chart.png", Reader: bytes.NewReader(result)}).Send()
+		_, err = edit.Contentf("%s %s chart for %s", period, options.Type, username).File(sendpart.File{Name: "chart.png", Reader: bytes.NewReader(result)}).Send()
 		return err
 	})
 }
 
 func init() {
+	// todo: remove this in the future*
+	brokenImage, _ = imgio.Open("assets/img/broken.png")
+	brokenImage = transform.Resize(brokenImage, 300, 300, transform.NearestNeighbor)
 	commands.Register(data, handler)
 }
+
+func fetchImage(url string) image.Image {
+	if url == "" {
+		return nil
+	}
+	resp, err := httpClient.Get(url)
+	if err != nil {
+		return nil
+	}
+	defer resp.Body.Close()
+
+	img, _, err := image.Decode(resp.Body)
+	if err != nil {
+		return nil
+	}
+	return img
+}
+
+func fetchEntries(urls []string) []Entry {
+	entries := make([]Entry, len(urls))
+	var wg sync.WaitGroup
+	sem := make(chan struct{}, maxConcurrent)
+
+	for i, url := range urls {
+		i, url := i, url
+		wg.Go(func() {
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			entries[i].Image = fetchImage(url)
+		})
+	}
+
+	wg.Wait()
+	return entries
+}

bild/imgio/imgio.go

@@ -53,9 +53,8 @@ func RegisterCommands(r *cmdroute.Router, st *state.State, q *db.Queries, c *las
 			start := time.Now()
 			err := h(commandContext)
 			zlog.Log.Debugw("executed command %s", zlog.F{"time": time.Since(start)}, name)
-			// debugging purposes
+
 			if err != nil {
-				zlog.Log.Warn(err.Error())
 				commandContext.Reply.QuickEmbed(reply.ErrorEmbed(err.Error()))
 			}
 

commands/chart/chart.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/nxtgo/arikawa/v3/api"
 	"github.com/nxtgo/arikawa/v3/discord"
+	"go.fm/bild/colors"
 	"go.fm/commands"
 	lastfm "go.fm/last.fm"
 	"go.fm/pkg/components"
@@ -53,12 +54,18 @@ func handler(c *commands.CommandContext) error {
 			text = components.NewTextDisplayf("-# *Last track for %s, scrobbled at %s*", res.User, playtime.Format(time.Kitchen))
 		}
 
-		container := components.NewContainer(703487,
+		thumbnail := lastTrack.GetLargestImage().URL
+		color := 0x703487
+		if dominantColor, err := colors.Dominant(thumbnail); err == nil {
+			color = dominantColor
+		}
+
+		container := components.NewContainer(color,
 			components.NewSection(
 				components.NewTextDisplayf("# %s", lastTrack.Name),
 				components.NewTextDisplayf("**%s** **·** %s", lastTrack.Artist.Name, lastTrack.Album.Name),
 				text,
-			).WithAccessory(components.NewThumbnail(lastTrack.GetLargestImage().URL)),
+			).WithAccessory(components.NewThumbnail(thumbnail)),
 			components.NewActionRow(
 				components.NewButton(components.ButtonStyleLink, "Last.fm", nil).WithEmoji("1418269025959546943").WithURL(lastTrack.URL),
 			),