import os
from dotenv import load_dotenv
import spotipy
from spotipy.oauth2 import SpotifyOAuth
from spotipy.exceptions import SpotifyException
import pandas as pd

# Load variables from .env
load_dotenv()

# Access them
client_id = os.getenv("SPOTIFY_CLIENT_ID")
client_secret = os.getenv("SPOTIFY_CLIENT_SECRET")
redirect_uri = os.getenv("SPOTIFY_REDIRECT_URI")



sp = spotipy.Spotify(auth_manager=SpotifyOAuth(client_id=client_id,
                                               client_secret=client_secret,
                                               redirect_uri=redirect_uri,
                                               scope="user-top-read"))

def get_top_tracks_country(sp, artist_name: str, country: str = "DE"):

    if country not in spotipy.Spotify.country_codes:
        raise ValueError("country code is not valid")
    
    # search artist since we need the artist ID for the artist_top_tracks() function
    result = sp.search(q=f"artist:{artist_name}", type="artist", limit=1)
    if len(result["artists"]["items"]) == 0:
        raise ValueError(f"Artist '{artist_name}' not found on Spotify.")
    artist_id = result["artists"]["items"][0]["id"]

    # get top tracks
    top_tracks = sp.artist_top_tracks(artist_id, country=country)["tracks"]

    # get dataframe
    data = []
    for track in top_tracks:
        data.append({
            "track_name": track["name"],
            "artist_name": ", ".join([a["name"] for a in track["artists"]]),
            "album": track["album"]["name"]
        })

    return pd.DataFrame(data)

df_top_tracks = get_top_tracks_country(sp, artist_name = "Boards of Canada", country="US")
display(df_top_tracks)

import os
import re
from typing import List, Dict, Any
from dotenv import load_dotenv
import spotipy
from spotipy.oauth2 import SpotifyClientCredentials
from mcp.server.fastmcp import FastMCP

# Load Spotify keys from .env
load_dotenv()

# Access them from .env
CLIENT_ID = os.getenv("SPOTIFY_CLIENT_ID")
CLIENT_SECRET = os.getenv("SPOTIFY_CLIENT_SECRET")

sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials(
    client_id=CLIENT_ID,
    client_secret=CLIENT_SECRET
))

mcp = FastMCP("Spotify Top Tracks")

# Mapping between country code and country name
_ALIASES = {
    "AD": "Andorra",
    "AR": "Argentina",
    "AU": "Australia",
    "AT": "Austria",
    "BE": "Belgium",
    "BO": "Bolivia",
    "BR": "Brazil",
    "BG": "Bulgaria",
    "CA": "Canada",
    "CL": "Chile",
    "CO": "Colombia",
    "CR": "Costa Rica",
    "CY": "Cyprus",
    "CZ": "Czech Republic",
    "DK": "Denmark",
    "DO": "Dominican Republic",
    "EC": "Ecuador",
    "SV": "El Salvador",
    "EE": "Estonia",
    "FI": "Finland",
    "FR": "France",
    "DE": "Germany",
    "GR": "Greece",
    "GT": "Guatemala",
    "HN": "Honduras",
    "HK": "Hong Kong",
    "HU": "Hungary",
    "IS": "Iceland",
    "ID": "Indonesia",
    "IE": "Ireland",
    "IT": "Italy",
    "JP": "Japan",
    "LV": "Latvia",
    "LI": "Liechtenstein",
    "LT": "Lithuania",
    "LU": "Luxembourg",
    "MY": "Malaysia",
    "MT": "Malta",
    "MX": "Mexico",
    "MC": "Monaco",
    "NL": "Netherlands",
    "NZ": "New Zealand",
    "NI": "Nicaragua",
    "NO": "Norway",
    "PA": "Panama",
    "PY": "Paraguay",
    "PE": "Peru",
    "PH": "Philippines",
    "PL": "Poland",
    "PT": "Portugal",
    "SG": "Singapore",
    "ES": "Spain",
    "SK": "Slovakia",
    "SE": "Sweden",
    "CH": "Switzerland",
    "TW": "Taiwan",
    "TR": "Turkey",
    "GB": "United Kingdom",
    "US": "United States",
    "UY": "Uruguay",
}

_NAME_TO_CODE = {name.lower(): code for code, name in _ALIASES.items()}

def _normalize_country_code(value: str) -> str:
    """
    Normalize an input (2-letter code or country name) to a valid _ALIASES code.
    Raises ValueError if not found or not supported.
    """
    if not value:
        raise ValueError("country must be provided")

    val = str(value).strip()

    # if the user passed a 2-letter code
    if len(val) == 2 and val.isalpha():
        code = val.upper()
        if code in _ALIASES:
            return code
        raise ValueError("country code is not valid")

    # otherwise try to match by country name
    code = _NAME_TO_CODE.get(val.lower())
    if code:
        return code

    # if not found
    raise ValueError("country code or name is not valid or not available in this market")

# Tool for getting top tracks by artist name and country code 
@mcp.tool()
def get_top_tracks_country(artist_name: str, country: str = "DE") -> List[Dict[str, Any]]:
    """
    Return top tracks for an artist in a country.
    - artist_name: artist (string)
    - country: 2-letter code (e.g., 'DE') or country name (e.g., 'Germany')
    Returns list[dict] with keys: track_name, artist_name, album, popularity, track_id
    """
    artist_name = (artist_name or "").strip()
    if not artist_name:
        raise ValueError("artist_name must be provided")

    code = _normalize_country_code(country)

    # search artist to get the artist ID (input for artist_top_tracks())
    res = sp.search(q=f"artist:{artist_name}", type="artist", limit=1)
    artists = res.get("artists", {}).get("items", [])
    if not artists:
        raise ValueError(f"Artist '{artist_name}' not found on Spotify.")
    artist_id = artists[0]["id"]

    top = sp.artist_top_tracks(artist_id, country=code).get("tracks", [])
    out = []
    for t in top:
        out.append({
            "track_name": t.get("name"),
            "artist_name": ", ".join([a.get("name") for a in t.get("artists", []) if a.get("name")]),
            "album": t.get("album", {}).get("name"),
            "popularity": t.get("popularity"),
            "track_id": t.get("id")
        })
    return out


if __name__ == "__main__":
    mcp.run(transport = "stdio")

{
  "mcpServers": {
    "Demo": {
      "command": "C:\\Python\\MCP_server\\.venv\\Scripts\\python.exe",
      "args": ["-u", "C:\\Python\\MCP_server\\main.py"]
    }
  }
}