Added Spotify API to print out top 10 artist tracks

app.py

@@ -1,43 +1,117 @@
 from smolagents import CodeAgent, HfApiModel, load_tool, tool
+from dotenv import load_dotenv
 import datetime
 import requests
+import base64
+from requests import post, get
+import os
 import pytz
 import yaml
+import json
 from typing import List, Dict
 from tools.final_answer import FinalAnswerTool
 from tools.web_search import DuckDuckGoSearchTool
 from Gradio_UI import GradioUI
 
 @tool
-def get_coordinates_osm(location_name:str) -> str:
-
-    """A tool that fetches gps coordinates of a given place in the world 
+def get_artist_top_tracks(artist_name: str) -> List[Dict[str, Any]]:
+    """A tool that fetches the top 10 tracks of an artist from Spotify
+    
     Args:
-            location_name: the name of the location (e.g., 'Kinshasa, Gombe').
+        artist_name: the name of the artist to search for (e.g., 'The Beatles').
+        
+    Returns:
+        List of dictionaries containing track information with the following fields:
+        - name: Track name
     """
+    load_dotenv()
+    client_id = os.getenv("CLIENT_ID")
+    client_secret = os.getenv("CLIENT_SECRET")
+    
+    if not client_id or not client_secret:
+        return {"error": "Spotify API credentials not found in environment variables"}
+    
+    try:
+        # Get token
+        token = get_spotify_token(client_id, client_secret)
+        
+        # Search for artist
+        artist_data = search_for_artist(token, artist_name)
+        if not artist_data:
+            return {"error": f"No artist found with name: {artist_name}"}
+            
+        # Get artist's top tracks
+        artist_id = artist_data["id"]
+        artist_name = artist_data["name"]  # Use official name from Spotify
+        top_tracks = get_songs_by_artist(token, artist_id)
+        
+        # Format results
+        formatted_tracks = []
+        for idx, track in enumerate(top_tracks[:10]):  # Limit to top 10
+            formatted_track = {
+                "position": idx + 1,
+                "name": track["name"],
+            }
+            formatted_tracks.append(formatted_track)
+            
+        return {
+            "artist": artist_name,
+            "tracks": formatted_tracks
+        }
+        
+    except Exception as e:
+        return {"error": f"Error fetching artist data: {str(e)}"}
+
+
+def get_spotify_token(client_id: str, client_secret: str) -> str:
+    """Get an access token from Spotify API"""
+    auth_string = client_id + ":" + client_secret
+    auth_bytes = auth_string.encode("utf-8")
+    auth_base64 = str(base64.b64encode(auth_bytes), "utf-8")
+    
+    url = "https://accounts.spotify.com/api/token"
     headers = {
-        'User-Agent': 'MyGeocodingApp/1.0 (youremail@example.com)'
+        "Authorization": "Basic " + auth_base64,
+        "Content-Type": "application/x-www-form-urlencoded"
     }
+    data = {"grant_type": "client_credentials"}
     
-    location_name = location_name.replace(" ", "+")
-    base_url = "https://nominatim.openstreetmap.org/search"
-    full_url = f"{base_url}?q={requests.utils.quote(location_name)}&format=json&limit=5"
+    result = post(url, headers=headers, data=data)
+    json_result = json.loads(result.content)
+    token = json_result["access_token"]
+    return token
 
-    response = requests.get(full_url, headers=headers)
 
-    if response.status_code != 200:
-        raise Exception("Erreur lors de la requête à l'API OpenStreetMap")
+def get_auth_header(token: str) -> Dict[str, str]:
+    """Create authorization header with token"""
+    return {"Authorization": "Bearer " + token}
 
-    response_list = response.json()
 
-    if len(response_list) == 0:
-        raise Exception("Aucune réponse trouvée pour cette recherche")
-
-    latitude = float(response_list[0]['lat'])
-    longitude = float(response_list[0]['lon'])
+def search_for_artist(token: str, artist_name: str) -> Optional[Dict[str, Any]]:
+    """Search for an artist by name"""
+    url = "https://api.spotify.com/v1/search"
+    headers = get_auth_header(token)
+    query = f"?q={artist_name}&type=artist&limit=1"
+    query_url = url + query 
+    
+    result = get(query_url, headers=headers)
+    json_result = json.loads(result.content)["artists"]["items"]
+    
+    if len(json_result) == 0:
+        return None
+    
+    return json_result[0]
 
-    return {'latitude': latitude, 'longitude': longitude}  
 
+def get_songs_by_artist(token: str, artist_id: str) -> List[Dict[str, Any]]:
+    """Get top tracks by artist ID"""
+    url = f"https://api.spotify.com/v1/artists/{artist_id}/top-tracks?country=US"
+    headers = get_auth_header(token)
+    
+    result = get(url, headers=headers)
+    json_result = json.loads(result.content)["tracks"]
+    
+    return json_result
 # Initialize tools
 final_answer = FinalAnswerTool()