chrisryn/vynl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
- 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
This commit is contained in:
root
2026-03-31 00:21:58 -05:00
parent 789de25c1a
commit 1eea237c08
17 changed files with 898 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

200
backend/app/api/endpoints/profile.py Normal file
View File

@@ -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),
}

23
backend/app/api/endpoints/recommendations.py
View File

@@ -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}

2
backend/app/core/config.py
View File

@@ -35,7 +35,7 @@ class Settings(BaseSettings):
FRONTEND_URL: str = "http://localhost:5173"
# Rate limits (free tier)
FREE_DAILY_RECOMMENDATIONS: int = 10
FREE_WEEKLY_RECOMMENDATIONS: int = 5
FREE_MAX_PLAYLISTS: int = 1
model_config = {"env_file": ".env", "extra": "ignore"}

3
backend/app/main.py
View File

@@ -2,7 +2,7 @@ from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from app.core.config import settings
from app.api.endpoints import auth, bandcamp, billing, lastfm, manual_import, playlists, recommendations, youtube_music
from app.api.endpoints import auth, bandcamp, billing, lastfm, manual_import, playlists, profile, recommendations, youtube_music
app = FastAPI(title="Vynl API", version="1.0.0")
@@ -22,6 +22,7 @@ app.include_router(youtube_music.router, prefix="/api")
app.include_router(manual_import.router, prefix="/api")
app.include_router(lastfm.router, prefix="/api")
app.include_router(bandcamp.router, prefix="/api")
app.include_router(profile.router, prefix="/api")
@app.get("/api/health")

1
backend/app/models/recommendation.py
View File

@@ -29,6 +29,7 @@ class Recommendation(Base):
# User interaction
saved: Mapped[bool] = mapped_column(Boolean, default=False)
disliked: Mapped[bool] = mapped_column(Boolean, default=False, server_default="false")
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
)

4
backend/app/models/user.py
View File

@@ -22,6 +22,10 @@ class User(Base):
stripe_customer_id: Mapped[str | None] = mapped_column(String(255), nullable=True, unique=True)
stripe_subscription_id: Mapped[str | None] = mapped_column(String(255), nullable=True)
# Personalization
blocked_genres: Mapped[str | None] = mapped_column(Text, nullable=True)
adventurousness: Mapped[int] = mapped_column(default=3, server_default="3")
# Spotify OAuth
spotify_id: Mapped[str | None] = mapped_column(String(255), nullable=True, unique=True)
spotify_access_token: Mapped[str | None] = mapped_column(Text, nullable=True)

6
backend/app/schemas/recommendation.py
View File

@@ -7,6 +7,9 @@ class RecommendationRequest(BaseModel):
playlist_id: int | None = None
query: str | None = None # Manual search/request
bandcamp_mode: bool = False # Prioritize Bandcamp/indie artists
mode: str = "discover" # discover, sonic_twin, era_bridge, deep_cuts, rising
adventurousness: int = 3 # 1-5
exclude: str | None = None # comma-separated genres to exclude
class RecommendationItem(BaseModel):
@@ -21,6 +24,7 @@ class RecommendationItem(BaseModel):
reason: str
score: float | None = None
saved: bool = False
disliked: bool = False
created_at: datetime
model_config = {"from_attributes": True}
@@ -28,7 +32,7 @@ class RecommendationItem(BaseModel):
class RecommendationResponse(BaseModel):
recommendations: list[RecommendationItem]
remaining_today: int | None = None # None = unlimited (pro)
remaining_this_week: int | None = None # None = unlimited (pro)
class TasteProfile(BaseModel):

68
backend/app/services/recommender.py
View File

@@ -50,32 +50,54 @@ def build_taste_profile(tracks: list[Track]) -> dict:
}
async def get_daily_rec_count(db: AsyncSession, user_id: int) -> int:
"""Count recommendations generated today for rate limiting."""
today_start = datetime.now(timezone.utc).replace(hour=0, minute=0, second=0, microsecond=0)
async def get_weekly_rec_count(db: AsyncSession, user_id: int) -> int:
"""Count recommendations generated this week (since Monday) for rate limiting."""
now = datetime.now(timezone.utc)
week_start = (now - timedelta(days=now.weekday())).replace(hour=0, minute=0, second=0, microsecond=0)
result = await db.execute(
select(func.count(Recommendation.id)).where(
Recommendation.user_id == user_id,
Recommendation.created_at >= today_start,
Recommendation.created_at >= week_start,
)
)
return result.scalar() or 0
MODE_PROMPTS = {
"discover": "Find music they'll love. Mix well-known and underground artists.",
"sonic_twin": "Find underground or lesser-known artists who sound nearly identical to their favorites. Focus on artists under 100K monthly listeners who share the same sonic qualities — similar vocal style, production approach, tempo, and energy.",
"era_bridge": "Suggest classic artists from earlier eras who directly inspired their current favorites. Trace musical lineage — if they love Tame Impala, suggest the 70s psych rock that influenced him. Bridge eras.",
"deep_cuts": "Find B-sides, album tracks, rarities, and lesser-known songs from artists already in their library. Focus on tracks they probably haven't heard even from artists they already know.",
"rising": "Find artists with under 50K monthly listeners who match their taste. Focus on brand new, up-and-coming artists who haven't broken through yet. Think artists who just released their debut album or EP.",
}
def build_adventurousness_prompt(level: int) -> str:
if level <= 2:
return "Stick very close to their existing taste. Recommend artists who are very similar to what they already listen to."
elif level == 3:
return "Balance familiar and new. Mix artists similar to their taste with some that push boundaries."
else:
return "Be adventurous. Recommend artists that are different from their usual taste but share underlying qualities they'd appreciate. Push boundaries."
async def generate_recommendations(
db: AsyncSession,
user: User,
playlist_id: int | None = None,
query: str | None = None,
bandcamp_mode: bool = False,
mode: str = "discover",
adventurousness: int = 3,
exclude: str | None = None,
) -> tuple[list[Recommendation], int | None]:
"""Generate AI music recommendations using Claude."""
# Rate limit check for free users
remaining = None
if not user.is_pro:
used_today = await get_daily_rec_count(db, user.id)
remaining = max(0, settings.FREE_DAILY_RECOMMENDATIONS - used_today)
used_this_week = await get_weekly_rec_count(db, user.id)
remaining = max(0, settings.FREE_WEEKLY_RECOMMENDATIONS - used_this_week)
if remaining <= 0:
return [], 0
@@ -111,6 +133,15 @@ async def generate_recommendations(
profile = build_taste_profile(all_tracks)
taste_context = f"Taste profile from {len(all_tracks)} tracks:\n{json.dumps(profile, indent=2)}"
# Load disliked artists to exclude
disliked_result = await db.execute(
select(Recommendation.artist).where(
Recommendation.user_id == user.id,
Recommendation.disliked == True,
)
)
disliked_artists = list({a for a in disliked_result.scalars().all()})
# Build prompt
user_request = query or "Find me music I'll love based on my taste profile. Prioritize lesser-known artists and hidden gems."
@@ -119,14 +150,39 @@ async def generate_recommendations(
else:
focus_instruction = "Focus on discovery - prioritize lesser-known artists, deep cuts, and hidden gems over obvious popular choices."
# Mode-specific instruction
mode_instruction = MODE_PROMPTS.get(mode, MODE_PROMPTS["discover"])
# Adventurousness instruction
adventurousness_instruction = build_adventurousness_prompt(adventurousness)
# Exclude genres instruction
exclude_instruction = ""
combined_exclude = exclude or ""
if user.blocked_genres:
combined_exclude = f"{user.blocked_genres}, {combined_exclude}" if combined_exclude else user.blocked_genres
if combined_exclude.strip():
exclude_instruction = f"\nDo NOT recommend anything in these genres/moods: {combined_exclude}"
# Disliked artists exclusion
disliked_instruction = ""
if disliked_artists:
disliked_instruction = f"\nDo NOT recommend anything by these artists (user disliked them): {', '.join(disliked_artists[:30])}"
prompt = f"""You are Vynl, an AI music discovery assistant. You help people discover new music they'll love.
{taste_context}
User request: {user_request}
Discovery mode: {mode_instruction}
{adventurousness_instruction}
Already in their library (do NOT recommend these):
{', '.join(list(existing_tracks)[:50]) if existing_tracks else 'None provided'}
{disliked_instruction}
{exclude_instruction}
Respond with exactly {"15" if bandcamp_mode else "5"} music recommendations as a JSON array. Each item should have:
- "title": song title