Update app/main.py

app/main.py

@@ -1,170 +1,179 @@
-from fastapi import FastAPI, Query
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse
-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=["*"],
-)
-
-# Mount static files (frontend)
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-# 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)
-
-# Serve frontend at root
-@app.get("/")
-async def read_root():
-    return FileResponse('static/index.html')
-
-@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
+from fastapi import FastAPI, Query
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+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=["*"],
+)
+
+# Mount static files BEFORE other routes
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# 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)
+
+# Serve individual static files at root level for compatibility
+@app.get("/script.js")
+async def get_script():
+    return FileResponse('static/script.js', media_type='application/javascript')
+
+@app.get("/styles.css")
+async def get_styles():
+    return FileResponse('static/styles.css', media_type='text/css')
+
+# Serve frontend at root
+@app.get("/")
+async def read_root():
+    return FileResponse('static/index.html')
+
+@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=7860)