def get_full_trending_playlists(request, args, strategy):
offset, limit = format_offset(args), format_limit(args, TRENDING_LIMIT)
current_user_id, time = args.get("user_id"), args.get("time", "week")
time = "week" if time not in ["week", "month", "year"] else time
# If we have a user_id, we call into `get_trending_playlist`
# which fetches the cached unpopulated tracks and then
# populates metadata. Otherwise, just
# retrieve the last cached value.
#
# If current_user_id,
# apply limit + offset inside the cached calculation.
# Otherwise, apply it here.
if current_user_id:
args = {
'time': time,
'with_tracks': True,
'limit': limit,
'offset': offset
}
decoded = decode_string_id(current_user_id)
args["current_user_id"] = decoded
playlists = get_trending_playlists(args, strategy)
else:
args = {
'time': time,
'with_tracks': True,
}
key = get_trending_cache_key(to_dict(request.args), request.path)
playlists = use_redis_cache(
key, TRENDING_TTL_SEC,
lambda: get_trending_playlists(args, strategy))
playlists = playlists[offset:limit + offset]
return playlists
def get(self, id):
decoded_id = decode_with_abort(id, ns)
args = pagination_with_current_user_parser.parse_args()
current_user_id = get_current_user_id(args)
offset = format_offset(args)
limit = format_limit(args)
args = {
"current_user_id": current_user_id,
"with_users": True,
"filter_deleted": True,
"limit": limit,
"offset": offset,
}
reposts = get_repost_feed_for_user(decoded_id, args)
for repost in reposts:
if "playlist_id" in repost:
repost["tracks"] = get_tracks_for_playlist(
repost["playlist_id"], current_user_id
)
activities = list(map(extend_activity, reposts))
return success_response(activities)
def get(self, user_id):
"""Fetch most used tags in a user's tracks."""
decoded_id = decode_with_abort(user_id, ns)
args = tags_route_parser.parse_args()
limit = format_limit(args)
tags = get_top_user_track_tags({'user_id': decoded_id, 'limit': limit})
return success_response(tags)
def get(self, time_range):
"""Gets aggregated app metrics based on time range and bucket size"""
if time_range not in valid_bucket_sizes:
abort_bad_path_param('time_range', ns)
args = aggregate_app_metrics_parser.parse_args()
limit = format_limit(args, max_limit=100)
metrics = get_aggregate_app_metrics(time_range, limit)
response = success_response(metrics)
return response
def get(self):
request_args = best_new_releases_parser.parse_args()
window = request_args.get("window")
args = {
"with_users": request_args.get("with_users"),
"limit": format_limit(request_args, 100),
"user_id": get_current_user_id(request_args),
}
tracks = get_top_followee_windowed("track", window, args)
tracks = list(map(extend_track, tracks))
return success_response(tracks)
def get(self, version):
trending_track_versions = trending_strategy_factory.get_versions_for_type(TrendingType.TRACKS).keys()
version_list = list(filter(lambda v: v.name == version, trending_track_versions))
if not version_list:
abort_bad_path_param('version', full_ns)
args = full_recommended_track_parser.parse_args()
limit = format_limit(args, default_limit=DEFAULT_RECOMMENDED_LIMIT)
args['limit'] = max(TRENDING_LIMIT, limit)
strategy = trending_strategy_factory.get_strategy(TrendingType.TRACKS, version_list[0])
full_recommended_tracks = get_full_recommended_tracks(request, args, strategy)
return success_response(full_recommended_tracks[:limit])
def get(self):
request_args = most_loved_parser.parse_args()
args = {
"with_users": request_args.get("with_users"),
"limit": format_limit(request_args,
max_limit=100,
default_limit=25),
"user_id": get_current_user_id(request_args),
}
tracks = get_top_followee_saves("track", args)
tracks = list(map(extend_track, tracks))
return success_response(tracks)
def get_full_trending(request, args, strategy):
offset = format_offset(args)
limit = format_limit(args, TRENDING_LIMIT)
key = get_trending_cache_key(to_dict(request.args), request.path)
# Attempt to use the cached tracks list
if args['user_id'] is not None:
full_trending = get_trending(args, strategy)
else:
full_trending = use_redis_cache(key, TRENDING_TTL_SEC,
lambda: get_trending(args, strategy))
trending_tracks = full_trending[offset:limit + offset]
return trending_tracks
def get(self):
request_args = under_the_radar_parser.parse_args()
args = {
"tracks_only": request_args.get("tracks_only"),
"with_users": request_args.get("with_users"),
"limit": format_limit(request_args, 100, 25),
"offset": format_offset(request_args),
"user_id": get_current_user_id(request_args),
"filter": request_args.get("filter"),
}
feed_results = get_feed(args)
feed_results = list(map(extend_track, feed_results))
return success_response(feed_results)
def get(self):
args = full_random_track_parser.parse_args()
limit = format_limit(args, default_limit=DEFAULT_RANDOM_LIMIT)
args['limit'] = max(TRENDING_LIMIT, limit)
key = self.get_cache_key()
# Attempt to use the cached tracks list
if args['user_id'] is not None:
full_random = get_random_tracks(args)
else:
full_random = use_redis_cache(key, TRENDING_TTL_SEC,
lambda: get_random_tracks(args))
random = full_random[:limit]
return success_response(random)
def get(self):
args = full_trending_parser.parse_args()
offset = format_offset(args)
limit = format_limit(args, TRENDING_LIMIT)
key = self.get_cache_key()
# Attempt to use the cached tracks list
if args['user_id'] is not None:
full_trending = get_trending(args)
else:
full_trending = use_redis_cache(key, TRENDING_TTL_SEC,
lambda: get_trending(args))
trending = full_trending[offset:limit + offset]
return success_response(trending)
def get(self, track_id):
decoded_id = decode_with_abort(track_id, full_ns)
request_args = pagination_with_current_user_parser.parse_args()
current_user_id = get_current_user_id(request_args)
args = {
"with_users": True,
"track_id": decoded_id,
"current_user_id": current_user_id,
"limit": format_limit(request_args, default_limit=10),
"offset": format_offset(request_args),
}
response = get_remixes_of(args)
response["tracks"] = list(map(extend_track, response["tracks"]))
return success_response(response)
def get(self, id):
args = pagination_with_current_user_parser.parse_args()
decoded_id = decode_with_abort(id, ns)
current_user_id = get_current_user_id(args)
offset = format_offset(args)
limit = format_limit(args)
get_tracks_args = GetUserListeningHistoryArgs(
user_id=decoded_id,
current_user_id=current_user_id,
limit=limit,
offset=offset,
)
track_history = get_user_listening_history(get_tracks_args)
tracks = list(map(extend_activity, track_history))
return success_response(tracks)
def get(self, track_id):
decoded_id = decode_with_abort(track_id, full_ns)
request_args = remixing_parser.parse_args()
current_user_id = get_current_user_id(request_args)
args = {
"with_users": True,
"track_id": decoded_id,
"current_user_id": current_user_id,
"limit": format_limit(request_args),
"offset": format_offset(request_args)
}
tracks = get_remix_track_parents(args)
tracks = list(map(extend_track, tracks))
return success_response(tracks)
def get(self):
args = full_search_parser.parse_args()
offset = format_offset(args)
limit = format_limit(args)
current_user_id = get_current_user_id(args)
search_args = {
"is_auto_complete": False,
"kind": args.get("kind", "all"),
"query": args.get("query"),
"current_user_id": current_user_id,
"with_users": True,
"limit": limit,
"offset": offset,
"only_downloadable": False,
}
resp = search(search_args)
return success_response(resp)
def get(self, user_id):
"""Fetch favorited tracks for a user."""
args = favorite_route_parser.parse_args()
decoded_id = decode_with_abort(user_id, ns)
current_user_id = get_current_user_id(args)
offset = format_offset(args)
limit = format_limit(args)
get_tracks_args = {
"filter_deleted": False,
"user_id": decoded_id,
"current_user_id": current_user_id,
"limit": limit,
"offset": offset,
"with_users": True
}
track_saves = get_save_tracks(get_tracks_args)
tracks = list(map(extend_activity, track_saves))
return success_response(tracks)
def get(self, user_id):
decoded_id = decode_with_abort(user_id, ns)
args = user_reposts_route_parser.parse_args()
current_user_id = get_current_user_id(args)
offset = format_offset(args)
limit = format_limit(args)
args = {
"user_id": decoded_id,
"current_user_id": current_user_id,
"with_users": True,
"filter_deleted": True,
"limit": limit,
"offset": offset
}
reposts = get_repost_feed_for_user(decoded_id, args)
activities = list(map(extend_activity, reposts))
return success_response(activities)
def get_underground_trending(request, args, strategy):
offset, limit = format_offset(args), format_limit(args, TRENDING_LIMIT)
current_user_id = args.get("user_id")
args = {'limit': limit, 'offset': offset}
# If user ID, let _get_underground_trending
# handle caching + limit + offset
if current_user_id:
decoded = decode_string_id(current_user_id)
args["current_user_id"] = decoded
trending = _get_underground_trending(args, strategy)
else:
# If no user ID, fetch all cached tracks
# and perform pagination here, passing
# no args so we get the full list of tracks.
key = get_trending_cache_key(to_dict(request.args), request.path)
trending = use_redis_cache(
key, TRENDING_TTL_SEC,
lambda: _get_underground_trending({}, strategy))
trending = trending[offset:limit + offset]
return trending
def get(self, handle):
args = user_reposts_route_parser.parse_args()
current_user_id = get_current_user_id(args)
offset = format_offset(args)
limit = format_limit(args)
args = {
"handle": handle,
"current_user_id": current_user_id,
"with_users": True,
"filter_deleted": True,
"limit": limit,
"offset": offset
}
reposts = get_repost_feed_for_user(None, args)
for repost in reposts:
if "playlist_id" in repost:
repost["tracks"] = get_tracks_for_playlist(repost["playlist_id"], current_user_id)
activities = list(map(extend_activity, reposts))
return success_response(activities)
def get(self, handle):
"""Fetch a list of tracks for a user."""
args = user_tracks_route_parser.parse_args()
current_user_id = get_current_user_id(args)
sort = args.get("sort", None)
offset = format_offset(args)
limit = format_limit(args)
args = {
"handle": handle,
"current_user_id": current_user_id,
"with_users": True,
"filter_deleted": True,
"sort": sort,
"limit": limit,
"offset": offset
}
tracks = get_tracks(args)
tracks = list(map(extend_track, tracks))
return success_response(tracks)
def get(self, id, authed_user_id=None):
decoded_id = decode_with_abort(id, ns)
args = user_tracks_route_parser.parse_args()
current_user_id = get_current_user_id(args)
sort = args.get("sort", None)
offset = format_offset(args)
limit = format_limit(args)
args = {
"user_id": decoded_id,
"current_user_id": current_user_id,
"authed_user_id": authed_user_id,
"with_users": True,
"filter_deleted": True,
"sort": sort,
"limit": limit,
"offset": offset,
}
tracks = get_tracks(args)
tracks = list(map(extend_track, tracks))
return success_response(tracks)
def get(self):
"""
Get Users/Tracks/Playlists/Albums that best match the search query
Same as search but optimized for quicker response at the cost of some entity information.
"""
args = full_search_parser.parse_args()
offset = format_offset(args)
limit = format_limit(args)
current_user_id = get_current_user_id(args)
search_args = {
"is_auto_complete": True,
"kind": args.get("kind", "all"),
"query": args.get("query"),
"current_user_id": current_user_id,
"with_users": False,
"limit": limit,
"offset": offset,
"only_downloadable": False,
}
resp = search(search_args)
return success_response(resp)
def get(self):
args = random_track_parser.parse_args()
limit = format_limit(args, default_limit=DEFAULT_RANDOM_LIMIT)
args['limit'] = max(TRENDING_LIMIT, limit)
tracks = get_random_tracks(args)
return success_response(tracks[:limit])
