53284ee7c8
Adds the per-kind generator modules and registers them with the
PlaylistKindRegistry so the manager's `refresh_playlist` can dispatch
to any of them.
Generators (each in its own module under
`core/personalized/generators/`):
Singletons (variant=''):
- hidden_gems -> wraps service.get_hidden_gems
- discovery_shuffle -> wraps service.get_discovery_shuffle
- popular_picks -> wraps service.get_popular_picks
Variant-bearing kinds:
- time_machine -> variant = decade label ('1980s', '1990s', ...).
Variant resolver returns 7 standard decades.
Generator parses '1980s' -> 1980 + delegates
to service.get_decade_playlist.
- genre_playlist -> variant = URL-safe genre key
('electronic_dance', 'hip_hop_rap', ...).
Resolver normalizes parent-genre keys from
service.GENRE_MAPPING; free-form keywords
pass through to service.get_genre_playlist.
- daily_mix -> variant = top-genre rank ('1' / '2' / '3' / '4').
Generator looks up user's Nth-ranked library
genre and returns discovery picks within it.
Library half (was a stub returning []) is
intentionally dropped: tracks table has no
source IDs, so library rows can't sync. Fixed
the stub to return [] cleanly without the
misleading log warning.
- fresh_tape -> Spotify Release Radar. Reads curated track
IDs from discovery_curated_playlists (tries
'release_radar_<source>' first, falls back to
'release_radar') and hydrates against the
discovery pool.
- archives -> Spotify Discover Weekly. Same hydration path
as fresh_tape but uses 'discovery_weekly'.
- seasonal_mix -> variant = season key ('halloween' / 'christmas'
/ 'valentines' / 'summer' / 'spring' / 'autumn').
Reads curated IDs via SeasonalDiscoveryService
then hydrates from seasonal_tracks (which
carries full track_data_json).
Each module:
- Defines `generate(deps, variant, config) -> List[Track]`.
- Defines `SPEC = PlaylistKindSpec(...)` and registers it on import
(idempotent — re-import safe via `if registry.get(...) is None`).
- For variant-bearing kinds, also defines `variant_resolver(deps)`.
Shared helpers in `_common.py`:
- `get_service(deps)` pulls the legacy
`PersonalizedPlaylistsService` instance (deps.service or
deps['service']).
- `coerce_tracks(rows)` runs each dict through `Track.from_dict`,
tolerates None / non-list inputs.
Tests (50 new, total 85 across personalized subsystem):
- Singletons: registration + display name + dispatch + limit
forwarding + empty/None tolerance + missing-deps error +
dict-form deps acceptance (16 tests).
- Variants: variant_resolver listing + label parsing + invalid
variant errors + parent-key normalization + free-form passthrough
(13 tests).
- Curated/hybrid: daily_mix rank-to-genre resolution + rank-out-of-
range empty + invalid-variant error; fresh_tape & archives
hydration order + missing-id skip + source-specific-then-fallback
key dispatch + limit + missing-database-dep error; seasonal_mix
curated-id hydration order + missing-id skip + JSON round-trip +
empty-curated empty + limit + missing-service error (21 tests).
3304+ tests pass. No regression on existing 62 personalized tests.
83 lines
2.9 KiB
Python
83 lines
2.9 KiB
Python
"""Daily Mix generator — top library genre → discovery picks.
|
|
|
|
Variant = rank position as a string ('1' / '2' / '3' / '4'). Each
|
|
mix tracks the user's Nth top library genre and returns discovery
|
|
picks within it. Top genres recompute at refresh time, so as the
|
|
library evolves a mix's underlying genre can shift -- the playlist
|
|
metadata records which genre was used at the most recent refresh
|
|
so the UI can label the mix accurately.
|
|
|
|
Note: previously this kind ambitiously promised 50% library + 50%
|
|
discovery. The library half was a stub (`tracks` table has no
|
|
source IDs to sync), so the new generator is discovery-only.
|
|
A future enhancement can backfill source IDs into library rows
|
|
and re-add the hybrid behavior."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any, List
|
|
|
|
from core.personalized.generators._common import coerce_tracks, get_service
|
|
from core.personalized.specs import PlaylistKindSpec, get_registry
|
|
from core.personalized.types import PlaylistConfig, Track
|
|
|
|
|
|
KIND = 'daily_mix'
|
|
|
|
# Default rank set — UI surfaces 4 daily mixes by default.
|
|
_DEFAULT_RANKS = ('1', '2', '3', '4')
|
|
|
|
# Number of top library genres to consider when ranking.
|
|
_MAX_TOP_GENRES = 8
|
|
|
|
|
|
def _resolve_genre_for_rank(service, rank: int) -> str:
|
|
"""Look up the user's Nth-ranked top library genre. Returns the
|
|
genre key or '' when no genre at that rank.
|
|
|
|
Calls ``service.get_top_genres_from_library(limit=...)`` and
|
|
indexes the resulting (genre, count) tuples by 0-based rank.
|
|
"""
|
|
top = service.get_top_genres_from_library(limit=_MAX_TOP_GENRES) or []
|
|
if rank < 1 or rank > len(top):
|
|
return ''
|
|
pair = top[rank - 1]
|
|
if not pair:
|
|
return ''
|
|
# `top` is List[Tuple[str, int]] per service signature.
|
|
return pair[0] if isinstance(pair, (tuple, list)) else str(pair)
|
|
|
|
|
|
def generate(deps: Any, variant: str, config: PlaylistConfig) -> List[Track]:
|
|
service = get_service(deps)
|
|
try:
|
|
rank = int(variant)
|
|
except (TypeError, ValueError) as exc:
|
|
raise ValueError(f"Daily Mix variant {variant!r} must be a rank int") from exc
|
|
genre = _resolve_genre_for_rank(service, rank)
|
|
if not genre:
|
|
# User's library doesn't have enough genres for this rank.
|
|
return []
|
|
rows = service.get_genre_playlist(genre=genre, limit=config.limit)
|
|
return coerce_tracks(rows)
|
|
|
|
|
|
def variant_resolver(deps: Any) -> List[str]:
|
|
"""Return the standard rank set."""
|
|
return list(_DEFAULT_RANKS)
|
|
|
|
|
|
SPEC = PlaylistKindSpec(
|
|
kind=KIND,
|
|
name_template='Daily Mix {variant}',
|
|
description='Personalized mix based on your top library genres. One mix per top genre rank.',
|
|
default_config=PlaylistConfig(limit=50, max_per_album=2, max_per_artist=3),
|
|
generator=generate,
|
|
variant_resolver=variant_resolver,
|
|
requires_variant=True,
|
|
tags=['discovery', 'personalized'],
|
|
)
|
|
|
|
|
|
if get_registry().get(KIND) is None:
|
|
get_registry().register(SPEC)
|