Upload 17 files

.gitattributes

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

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,12 @@
+# Create this file in your server/ directory
+import sys
+import os
+
+# Add the current directory to the Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from app.main import app
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

app/__init__.py

@@ -0,0 +1 @@
+ 

app/api/__init__.py

@@ -0,0 +1 @@
+ 

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,232 @@
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+from sklearn.cluster import KMeans
+import joblib
+import requests
+import urllib.parse
+from typing import List, Optional
+import os
+
+app = FastAPI(
+    title="Vibe ML API",
+    description="🎵 AI-powered music recommendation system using K-means clustering",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Configure CORS for Vercel frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:3000",
+        "http://localhost:8000", 
+        "https://*.vercel.app",
+        "https://your-frontend-url.vercel.app",  # Replace with your actual Vercel URL
+        "*"  # For development - remove in production
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables for ML models and data
+songs_df = None
+scaler = None
+kmeans_model = None
+
+@app.on_event("startup")
+async def startup_event():
+    """Load ML models and data on startup"""
+    global songs_df, scaler, kmeans_model
+    
+    try:
+        # Load your data and models here
+        # For now, we'll create a sample dataset
+        # Replace this with your actual data loading logic
+        print("Loading ML models and data...")
+        
+        # Sample data structure - replace with your actual data
+        songs_df = pd.DataFrame({
+            'name': ['Blinding Lights', 'Shape of You', 'Bad Guy', 'Levitating'],
+            'artists': [['The Weeknd'], ['Ed Sheeran'], ['Billie Eilish'], ['Dua Lipa']],
+            'year': [2019, 2017, 2019, 2020],
+            'popularity': [95, 94, 93, 92],
+            'danceability': [0.514, 0.825, 0.711, 0.702],
+            'energy': [0.73, 0.652, 0.430, 0.815],
+            'valence': [0.334, 0.931, 0.436, 0.915]
+        })
+        
+        # Initialize scaler and kmeans (replace with your trained models)
+        scaler = StandardScaler()
+        kmeans_model = KMeans(n_clusters=20, random_state=42)
+        
+        print("✅ Models loaded successfully!")
+        
+    except Exception as e:
+        print(f"❌ Error loading models: {e}")
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {
+        "message": "🎵 Vibe ML API is running!",
+        "status": "healthy",
+        "version": "1.0.0",
+        "endpoints": {
+            "docs": "/docs",
+            "search": "/search/",
+            "recommendations": "/recommendations/",
+            "song_details": "/song_details/"
+        }
+    }
+
+@app.get("/search/")
+async def search_songs(
+    q: str = Query(..., description="Search query (song name or artist)"),
+    limit: int = Query(10, ge=1, le=50, description="Number of results to return")
+):
+    """Search for songs by name or artist"""
+    try:
+        if not q or len(q.strip()) < 2:
+            raise HTTPException(status_code=400, detail="Query must be at least 2 characters long")
+        
+        # iTunes API search
+        encoded_query = urllib.parse.quote(q)
+        itunes_url = f"https://itunes.apple.com/search?term={encoded_query}&media=music&entity=song&limit={limit}"
+        
+        response = requests.get(itunes_url, timeout=10)
+        response.raise_for_status()
+        
+        data = response.json()
+        results = data.get('results', [])
+        
+        # Format results
+        formatted_results = []
+        for item in results:
+            formatted_results.append({
+                "name": item.get('trackName', 'Unknown'),
+                "artists": [item.get('artistName', 'Unknown Artist')],
+                "year": int(item.get('releaseDate', '2000')[:4]) if item.get('releaseDate') else 2000,
+                "popularity": 50,  # Default popularity
+                "preview_info": {
+                    "preview_url": item.get('previewUrl'),
+                    "album_image": item.get('artworkUrl100', '').replace('100x100', '600x600') if item.get('artworkUrl100') else None
+                }
+            })
+        
+        return formatted_results
+        
+    except requests.RequestException as e:
+        raise HTTPException(status_code=503, detail=f"External API error: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Search error: {str(e)}")
+
+@app.get("/song_details/")
+async def get_song_details(
+    song_name: str = Query(..., description="Song name"),
+    artist_name: str = Query(..., description="Artist name")
+):
+    """Get detailed information about a specific song"""
+    try:
+        # Search iTunes for the specific song
+        query = f"{song_name} {artist_name}"
+        encoded_query = urllib.parse.quote(query)
+        itunes_url = f"https://itunes.apple.com/search?term={encoded_query}&media=music&entity=song&limit=1"
+        
+        response = requests.get(itunes_url, timeout=10)
+        response.raise_for_status()
+        
+        data = response.json()
+        results = data.get('results', [])
+        
+        if not results:
+            raise HTTPException(status_code=404, detail="Song not found")
+        
+        item = results[0]
+        
+        song_details = {
+            "name": item.get('trackName', song_name),
+            "artists": [item.get('artistName', artist_name)],
+            "year": int(item.get('releaseDate', '2000')[:4]) if item.get('releaseDate') else 2000,
+            "popularity": 75,  # Default popularity
+            "preview_info": {
+                "preview_url": item.get('previewUrl'),
+                "album_image": item.get('artworkUrl100', '').replace('100x100', '600x600') if item.get('artworkUrl100') else None
+            }
+        }
+        
+        return song_details
+        
+    except requests.RequestException as e:
+        raise HTTPException(status_code=503, detail=f"External API error: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Song details error: {str(e)}")
+
+@app.get("/recommendations/")
+async def get_recommendations(
+    song_name: str = Query(..., description="Song name for recommendations"),
+    artist_name: str = Query(..., description="Artist name"),
+    number_songs: int = Query(8, ge=1, le=20, description="Number of recommendations")
+):
+    """Get AI-powered song recommendations"""
+    try:
+        # For now, return similar songs from iTunes
+        # In production, this would use your ML model
+        
+        # Get genre/style from the input song
+        query = f"{song_name} {artist_name}"
+        encoded_query = urllib.parse.quote(query)
+        
+        # Search for similar songs
+        similar_query = urllib.parse.quote(artist_name)  # Search by artist for similar style
+        itunes_url = f"https://itunes.apple.com/search?term={similar_query}&media=music&entity=song&limit={number_songs + 5}"
+        
+        response = requests.get(itunes_url, timeout=10)
+        response.raise_for_status()
+        
+        data = response.json()
+        results = data.get('results', [])
+        
+        # Filter out the original song and format results
+        recommendations = []
+        for item in results:
+            if item.get('trackName', '').lower() != song_name.lower():
+                recommendations.append({
+                    "name": item.get('trackName', 'Unknown'),
+                    "artists": [item.get('artistName', 'Unknown Artist')],
+                    "year": int(item.get('releaseDate', '2000')[:4]) if item.get('releaseDate') else 2000,
+                    "popularity": 70,  # Default popularity
+                    "preview_info": {
+                        "preview_url": item.get('previewUrl'),
+                        "album_image": item.get('artworkUrl100', '').replace('100x100', '600x600') if item.get('artworkUrl100') else None
+                    }
+                })
+                
+                if len(recommendations) >= number_songs:
+                    break
+        
+        return recommendations[:number_songs]
+        
+    except requests.RequestException as e:
+        raise HTTPException(status_code=503, detail=f"External API error: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Recommendations error: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    """Detailed health check"""
+    return {
+        "status": "healthy",
+        "timestamp": "2025-06-19T06:13:28Z",
+        "models_loaded": songs_df is not None,
+        "api_version": "1.0.0"
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

app/models/__init__.py

@@ -0,0 +1 @@
+ 

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