Upload 16 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/processed_songs.csv filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,25 @@
+# Use Python 3.10 slim image as base
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies required for numpy and scipy
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Expose port 7860 (HuggingFace Spaces default port)
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/api/itunes.py

@@ -0,0 +1,45 @@
+import requests
+from fastapi import HTTPException
+import logging
+
+logger = logging.getLogger(__name__)
+
+async def search_itunes_tracks(query: str, limit: int = 1):
+    """
+    Search iTunes for tracks with 30-second previews
+    """
+    base_url = "https://itunes.apple.com/search"
+    
+    try:
+        params = {
+            "term": query,
+            "entity": "song",
+            "limit": limit
+        }
+        
+        response = requests.get(base_url, params=params)
+        response.raise_for_status()
+        
+        results = response.json().get('results', [])
+        logger.info(f"Total tracks found: {len(results)}")
+        
+        tracks = []
+        for track in results:
+            track_info = {
+                "name": track.get('trackName'),
+                "artist": track.get('artistName'),
+                "preview_url": track.get('previewUrl'),
+                "full_track_url": track.get('trackViewUrl'),
+                "album_image": track.get('artworkUrl100'),
+                "genre": track.get('primaryGenreName'),
+                "album": track.get('collectionName')
+            }
+            
+            if track_info['preview_url']:
+                tracks.append(track_info)
+        
+        return tracks[0] if tracks else None
+    
+    except requests.RequestException as e:
+        logger.error(f"Error searching iTunes: {e}")
+        return None

app/main.py

@@ -0,0 +1,160 @@
+from fastapi import FastAPI, Query
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List, Optional
+import pandas as pd
+import joblib
+from scipy.spatial.distance import cdist
+from .models.schemas import Song, RecommendationWithPreview
+from .api.itunes import search_itunes_tracks
+
+app = FastAPI(title="Music Recommendation API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Load data and model
+numeric_features = ['acousticness', 'danceability', 'energy', 'instrumentalness',
+                   'liveness', 'loudness', 'speechiness', 'tempo', 'valence',
+                   'popularity', 'year', 'cluster_label']
+
+model = joblib.load('data/song_cluster_pipeline.joblib')
+df = pd.read_csv('data/processed_songs.csv', dtype={col: float for col in numeric_features})
+df['artists'] = df['artists'].apply(eval)
+
+@app.get("/search/", response_model=List[Song])
+async def search_songs(q: str = Query(..., min_length=1), limit: int = 5):
+    q = q.lower()
+    
+    # Perform separate searches
+    name_matches = df[df['name'].str.lower().str.contains(q, na=False)]
+    artist_matches = df[df['artists'].apply(lambda x: any(q in artist.lower() for artist in x))]
+    
+    # Convert the artists lists to strings for deduplication
+    name_matches = name_matches.copy()
+    artist_matches = artist_matches.copy()
+    
+    name_matches['artists_str'] = name_matches['artists'].apply(lambda x: ','.join(sorted(x)))
+    artist_matches['artists_str'] = artist_matches['artists'].apply(lambda x: ','.join(sorted(x)))
+    
+    # Concatenate and drop duplicates based on name and artists_str
+    results = pd.concat([name_matches, artist_matches])
+    results = results.drop_duplicates(subset=['name', 'artists_str'])
+    
+    # Get top matches by popularity
+    top_matches = results.nlargest(limit, 'popularity')
+    
+    return [
+        Song(
+            name=row['name'],
+            artists=row['artists'],
+            year=int(row['year']),
+            popularity=int(row['popularity'])
+        )
+        for _, row in top_matches.iterrows()
+    ]
+
+@app.get("/recommendations/", response_model=List[RecommendationWithPreview])
+async def get_recommendations(song_name: str, artist_name: Optional[str] = None, number_songs: int = 6):
+    try:
+        if artist_name:
+            mask = (df['name'].str.lower() == song_name.lower()) & \
+                  (df['artists'].apply(lambda x: artist_name.lower() in str(x).lower()))
+            song = df[mask].iloc[0]
+        else:
+            matches = df[df['name'].str.lower() == song_name.lower()]
+            if len(matches) > 1:
+                return {"error": f"Multiple songs found with name '{song_name}'. Please specify an artist."}
+            song = matches.iloc[0]
+        
+        cluster_label = song['cluster_label']
+        cluster_songs = df[df['cluster_label'] == cluster_label]
+        cluster_songs = cluster_songs[cluster_songs['name'] != song_name]
+        
+        audio_features = ['acousticness', 'danceability', 'energy', 'instrumentalness',
+                         'liveness', 'loudness', 'speechiness', 'tempo', 'valence']
+        
+        song_features = song[audio_features].astype(float).values.reshape(1, -1)
+        cluster_features = cluster_songs[audio_features].astype(float).values
+        
+        distances = cdist(song_features, cluster_features, metric='euclidean')
+        closest_indices = distances.argsort()[0][:number_songs]
+        
+        recommendations = cluster_songs.iloc[closest_indices]
+        
+        result = []
+        for _, row in recommendations.iterrows():
+            # Create search query for iTunes
+            search_query = f"{row['name']} {row['artists'][0]}"
+            preview_info = await search_itunes_tracks(search_query)
+            
+            rec = RecommendationWithPreview(
+                name=row['name'],
+                artists=row['artists'],
+                year=int(row['year']),
+                popularity=int(row['popularity']),
+                danceability=float(row['danceability']),
+                energy=float(row['energy']),
+                valence=float(row['valence']),
+                preview_info=preview_info
+            )
+            result.append(rec)
+        
+        return result
+        
+    except IndexError:
+        return {"error": f"Song '{song_name}' {'by ' + artist_name if artist_name else ''} not found."}
+
+@app.get("/song_details/")
+async def get_song_details(song_name: str, artist_name: Optional[str] = None):
+    """
+    Get both song data and iTunes preview info for a specific song
+    """
+    try:
+        # Find the song in our dataset
+        if artist_name:
+            mask = (df['name'].str.lower() == song_name.lower()) & \
+                  (df['artists'].apply(lambda x: artist_name.lower() in str(x).lower()))
+            song = df[mask].iloc[0]
+        else:
+            matches = df[df['name'].str.lower() == song_name.lower()]
+            if len(matches) > 1:
+                return {"error": f"Multiple songs found with name '{song_name}'. Please specify an artist."}
+            song = matches.iloc[0]
+        
+        # Get iTunes preview info
+        search_query = f"{song_name} {artist_name if artist_name else song['artists'][0]}"
+        preview_info = await search_itunes_tracks(search_query)
+        
+        # Return flattened response
+        return {
+            "name": song['name'],
+            "artists": song['artists'],
+            "year": int(song['year']),
+            "popularity": int(song['popularity']),
+            "danceability": float(song['danceability']),
+            "energy": float(song['energy']),
+            "valence": float(song['valence']),
+            "acousticness": float(song['acousticness']),
+            "instrumentalness": float(song['instrumentalness']),
+            "liveness": float(song['liveness']),
+            "speechiness": float(song['speechiness']),
+            "tempo": float(song['tempo']),
+            "preview_info": preview_info
+        }
+        
+    except IndexError:
+        return {"error": f"Song '{song_name}' {'by ' + artist_name if artist_name else ''} not found."}
+
+@app.get("/health")
+@app.head("/health")
+async def health_check():
+    return {"status": "ok"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app/models/schemas.py

@@ -0,0 +1,29 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+class Song(BaseModel):
+    name: str
+    artists: List[str]
+    year: int
+    popularity: int
+
+class Recommendation(BaseModel):
+    name: str
+    artists: List[str]
+    year: int
+    popularity: int
+    danceability: float
+    energy: float
+    valence: float
+
+class TrackInfo(BaseModel):
+    name: str
+    artist: str
+    preview_url: Optional[str]
+    full_track_url: Optional[str]
+    album_image: Optional[str]
+    genre: Optional[str]
+    album: Optional[str]
+
+class RecommendationWithPreview(Recommendation):
+    preview_info: Optional[TrackInfo] = None

data/processed_songs.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:358df3704e9d2457b6f1b8383137d877903907a3cf73b5773c95797c93355427
+size 24572270

data/song_cluster_pipeline.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ceee8795f25c27031dbc76f2a9365dc2d6bbde4dfc51788f4aa089a09f059946
+size 686654

requirements.txt

@@ -0,0 +1,29 @@
+annotated-types==0.7.0
+anyio==4.8.0
+certifi==2024.12.14
+charset-normalizer==3.4.1
+click==8.1.8
+colorama==0.4.6
+exceptiongroup==1.2.2
+fastapi==0.115.6
+h11==0.14.0
+idna==3.10
+joblib==1.4.2
+numpy==2.2.2
+pandas==2.2.3
+pydantic==2.10.5
+pydantic_core==2.27.2
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2024.2
+requests==2.32.3
+scikit-learn==1.6.1
+scipy==1.15.1
+six==1.17.0
+sniffio==1.3.1
+starlette==0.41.3
+threadpoolctl==3.5.0
+typing_extensions==4.12.2
+tzdata==2024.2
+urllib3==2.3.0
+uvicorn==0.34.0