Add discovery modes, personalization controls, taste profile page, updated pricing

- Discovery modes: Sonic Twin, Era Bridge, Deep Cuts, Rising Artists - Discovery dial (Safe to Adventurous slider) - Block genres/moods exclusion - Thumbs down/dislike on recommendations - My Taste page with Genre DNA breakdown, audio feature meters, listening personality - Updated pricing: Free (5/week), Premium ($6.99/mo), Family ($12.99/mo coming soon) - Weekly rate limiting instead of daily - Alembic migration for new fields
2026-03-31 00:21:58 -05:00
parent 789de25c1a
commit 1eea237c08
17 changed files with 898 additions and 113 deletions
--- a/backend/app/api/endpoints/profile.py
+++ b/backend/app/api/endpoints/profile.py
@@ -0,0 +1,200 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database import get_db
+from app.core.security import get_current_user
+from app.models.user import User
+from app.models.playlist import Playlist
+from app.models.track import Track
+
+router = APIRouter(prefix="/profile", tags=["profile"])
+
+
+def _determine_personality(
+    genre_count: int,
+    avg_energy: float,
+    avg_valence: float,
+    avg_acousticness: float,
+    energy_variance: float,
+    valence_variance: float,
+) -> dict:
+    """Assign a listening personality based on taste data."""
+
+    # High variance in energy/valence = Mood Listener
+    if energy_variance > 0.06 and valence_variance > 0.06:
+        return {
+            "label": "Mood Listener",
+            "description": "Your music shifts with your emotions. You have playlists for every feeling and aren't afraid to go from euphoric highs to contemplative lows.",
+            "icon": "drama",
+        }
+
+    # Many different genres = Genre Explorer
+    if genre_count >= 8:
+        return {
+            "label": "Genre Explorer",
+            "description": "You refuse to be put in a box. Your library is a world tour of sounds, spanning genres most listeners never discover.",
+            "icon": "globe",
+        }
+
+    # High energy = Energy Seeker
+    if avg_energy > 0.7:
+        return {
+            "label": "Energy Seeker",
+            "description": "You crave intensity. Whether it's driving beats, soaring guitars, or thundering bass, your music keeps the adrenaline flowing.",
+            "icon": "zap",
+        }
+
+    # Low energy + high acousticness = Chill Master
+    if avg_energy < 0.4 and avg_acousticness > 0.5:
+        return {
+            "label": "Chill Master",
+            "description": "You've mastered the art of the vibe. Acoustic textures and mellow grooves define your sonic world — your playlists are a warm blanket.",
+            "icon": "cloud",
+        }
+
+    # Very consistent taste, low variance = Comfort Listener
+    if energy_variance < 0.03 and valence_variance < 0.03:
+        return {
+            "label": "Comfort Listener",
+            "description": "You know exactly what you like and you lean into it. Your taste is refined, consistent, and deeply personal.",
+            "icon": "heart",
+        }
+
+    # Default: Catalog Diver
+    return {
+        "label": "Catalog Diver",
+        "description": "You dig deeper than the singles. Album tracks, B-sides, and deep cuts are your territory — you appreciate the full artistic vision.",
+        "icon": "layers",
+    }
+
+
+@router.get("/taste")
+async def get_taste_profile(
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Aggregate all user playlists/tracks into a full taste profile."""
+    result = await db.execute(
+        select(Playlist).where(Playlist.user_id == user.id)
+    )
+    playlists = list(result.scalars().all())
+
+    all_tracks = []
+    for p in playlists:
+        result = await db.execute(select(Track).where(Track.playlist_id == p.id))
+        all_tracks.extend(result.scalars().all())
+
+    if not all_tracks:
+        return {
+            "genre_breakdown": [],
+            "audio_features": {
+                "energy": 0,
+                "danceability": 0,
+                "valence": 0,
+                "acousticness": 0,
+                "avg_tempo": 0,
+            },
+            "personality": {
+                "label": "New Listener",
+                "description": "Import some playlists to discover your listening personality!",
+                "icon": "music",
+            },
+            "top_artists": [],
+            "track_count": 0,
+            "playlist_count": len(playlists),
+        }
+
+    # Genre breakdown
+    genres_count: dict[str, int] = {}
+    for t in all_tracks:
+        if t.genres:
+            for g in t.genres:
+                genres_count[g] = genres_count.get(g, 0) + 1
+
+    total_genre_mentions = sum(genres_count.values()) or 1
+    top_genres = sorted(genres_count.items(), key=lambda x: x[1], reverse=True)[:10]
+    genre_breakdown = [
+        {"name": g, "percentage": round((c / total_genre_mentions) * 100, 1)}
+        for g, c in top_genres
+    ]
+
+    # Audio features averages + variance
+    energies = []
+    danceabilities = []
+    valences = []
+    acousticnesses = []
+    tempos = []
+
+    for t in all_tracks:
+        if t.energy is not None:
+            energies.append(t.energy)
+        if t.danceability is not None:
+            danceabilities.append(t.danceability)
+        if t.valence is not None:
+            valences.append(t.valence)
+        if t.acousticness is not None:
+            acousticnesses.append(t.acousticness)
+        if t.tempo is not None:
+            tempos.append(t.tempo)
+
+    def avg(lst: list[float]) -> float:
+        return round(sum(lst) / len(lst), 3) if lst else 0
+
+    def variance(lst: list[float]) -> float:
+        if len(lst) < 2:
+            return 0
+        m = sum(lst) / len(lst)
+        return sum((x - m) ** 2 for x in lst) / len(lst)
+
+    avg_energy = avg(energies)
+    avg_danceability = avg(danceabilities)
+    avg_valence = avg(valences)
+    avg_acousticness = avg(acousticnesses)
+    avg_tempo = round(avg(tempos), 0)
+
+    # Personality
+    personality = _determine_personality(
+        genre_count=len(genres_count),
+        avg_energy=avg_energy,
+        avg_valence=avg_valence,
+        avg_acousticness=avg_acousticness,
+        energy_variance=variance(energies),
+        valence_variance=variance(valences),
+    )
+
+    # Top artists
+    artist_count: dict[str, int] = {}
+    for t in all_tracks:
+        artist_count[t.artist] = artist_count.get(t.artist, 0) + 1
+    top_artists_sorted = sorted(artist_count.items(), key=lambda x: x[1], reverse=True)[:8]
+
+    # Find a representative genre for each top artist
+    artist_genres: dict[str, str] = {}
+    for t in all_tracks:
+        if t.artist in dict(top_artists_sorted) and t.genres and t.artist not in artist_genres:
+            artist_genres[t.artist] = t.genres[0]
+
+    top_artists = [
+        {
+            "name": name,
+            "track_count": count,
+            "genre": artist_genres.get(name, ""),
+        }
+        for name, count in top_artists_sorted
+    ]
+
+    return {
+        "genre_breakdown": genre_breakdown,
+        "audio_features": {
+            "energy": round(avg_energy * 100),
+            "danceability": round(avg_danceability * 100),
+            "valence": round(avg_valence * 100),
+            "acousticness": round(avg_acousticness * 100),
+            "avg_tempo": avg_tempo,
+        },
+        "personality": personality,
+        "top_artists": top_artists,
+        "track_count": len(all_tracks),
+        "playlist_count": len(playlists),
+    }
--- a/backend/app/api/endpoints/recommendations.py
+++ b/backend/app/api/endpoints/recommendations.py
@@ -22,15 +22,16 @@ async def generate(
        raise HTTPException(status_code=400, detail="Provide a playlist_id or query")

    recs, remaining = await generate_recommendations(
-        db, user, playlist_id=data.playlist_id, query=data.query, bandcamp_mode=data.bandcamp_mode
+        db, user, playlist_id=data.playlist_id, query=data.query, bandcamp_mode=data.bandcamp_mode,
+        mode=data.mode, adventurousness=data.adventurousness, exclude=data.exclude,
    )

    if not recs and remaining == 0:
-        raise HTTPException(status_code=429, detail="Daily recommendation limit reached. Upgrade to Pro for unlimited.")
+        raise HTTPException(status_code=429, detail="Weekly recommendation limit reached. Upgrade to Premium for unlimited.")

    return RecommendationResponse(
        recommendations=[RecommendationItem.model_validate(r) for r in recs],
-        remaining_today=remaining,
+        remaining_this_week=remaining,
    )


@@ -75,3 +76,19 @@ async def save_recommendation(
        raise HTTPException(status_code=404, detail="Recommendation not found")
    rec.saved = not rec.saved
    return {"saved": rec.saved}
+
+
+@router.post("/{rec_id}/dislike")
+async def dislike_recommendation(
+    rec_id: int,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    result = await db.execute(
+        select(Recommendation).where(Recommendation.id == rec_id, Recommendation.user_id == user.id)
+    )
+    rec = result.scalar_one_or_none()
+    if not rec:
+        raise HTTPException(status_code=404, detail="Recommendation not found")
+    rec.disliked = not rec.disliked
+    return {"disliked": rec.disliked}