analysisold.py

import json
import statistics
import math
from collections import Counter

with open("feature.json", "r") as f:
    cache = json.load(f)

songs = [
    song for song in cache.values()
    if "status" not in song
]

songs = list(songs)  # ensure it's a list

for i in range(len(songs)):
    songs[i]["serial_no"] = i + 1

from collections import Counter

def compute_mood_distribution(songs):
    mood_counts = Counter(song["mood"] for song in songs)
    total = len(songs)

    mood_distribution = {
        mood: round((count / total) * 100, 1)
        for mood, count in mood_counts.items()
    }

    dominant_mood = max(mood_distribution, key=mood_distribution.get)

    return mood_distribution, dominant_mood

def compute_arousal(song):
    energy = song["energy"]
    tempo = song["tempo"]
    loudness = song["loudness"]

    # normalize tempo (40–200 BPM)
    tempo_norm = min(max((tempo - 40) / (200 - 40), 0), 1)

    # normalize loudness (-60 to 0 dB)
    loudness_norm = min(max((loudness + 60) / 60, 0), 1)

    arousal = (
        0.5 * energy +
        0.3 * tempo_norm +
        0.2 * loudness_norm
    )
    aggression = (
            0.4 * song["energy"] +
            0.3 * loudness_norm +
            0.2 * (1 - song["valence"]) +
            0.1 * song["speechiness"]
    )

    return arousal, aggression
def moodclassify(song, mean_valence, mean_arousal):
    v = song["valence"]
    a = song["arousal"]
    neutral = 0.1
    intense_threshold = 0.8
    if abs(v - 0.5) <= neutral and abs(a - 0.5) <= neutral:
        return "Neutral / Mixed"

    if a >= intense_threshold:
        return "Intense / Angry"

    if v >= 0.5 and a >= 0.5:
        return "Happy / Energetic"
    elif v >= 0.5 and a < 0.5:
        return "Calm / Content"
    elif v < 0.5 and a >= 0.5:
        return "Intense / Angry"
    else:
        return "Sad / Melancholic"

def compute_emotional_diversity(mood_distribution):
    entropy = 0.0
    for percentage in mood_distribution.values():
        p = percentage / 100
        entropy -= p * math.log2(p)
    return round(entropy, 2)

def determine_playlist_personality(
    dominant_mood,
    mood_distribution,
    diversity_score,
    avg_arousal,
    avg_valence
):
    # Rollercoaster: high diversity overrides everything
    if diversity_score >= 1.7:
        return "The Emotional Rollercoaster"

    # Intense personality
    if dominant_mood == "Intense / Angry" and avg_arousal >= 0.6:
        return "The Rebel Manifesto"

    # Feel-good personality
    if dominant_mood == "Happy / Energetic" and avg_valence >= 0.55:
        return "The Feel-Good Mix"

    # Chill personality
    if dominant_mood == "Calm / Content" and avg_arousal <= 0.45:
        return "The Chill Companion"
    if dominant_mood == "Sad / Melancholic":
        return "The In the feels mix"

    # Fallback (balanced playlists)
    return "🎧 The Balanced Listener"
for song in songs:
    song["arousal"], song["aggression"]= compute_arousal(song)

mean_arousal = statistics.mean(song["arousal"] for song in songs)
mean_valence = statistics.mean(song["valence"] for song in songs)
std_arousal = statistics.stdev(song["arousal"] for song in songs)
print("Mean valence:", round(mean_valence, 3))
print("Mean arousal:", round(mean_arousal, 3))
print("Std arousal:", round(std_arousal, 3))

for song in songs:
    song["mood"] = moodclassify(song, mean_valence, mean_arousal)

mood_distribution, dominant_mood = compute_mood_distribution(songs)

diversity_score = compute_emotional_diversity(mood_distribution)
with open("feature.json", "w") as f:
    json.dump(cache, f, indent=2)

print(mood_distribution)
print(diversity_score)
print(dominant_mood)
print(determine_playlist_personality(
    dominant_mood,
    mood_distribution,
    diversity_score,
    mean_arousal,
    mean_valence
))