"""
app.py
HIFFI Artist Intelligence - Multi-Platform Executive Dashboard
Dual-Engine Production Architecture:
1. HIFFI Hip-Hop 500: Pure Digital Telemetry (45% Spotify, 35% YouTube, 20% Instagram), Evidence Tiers, BVI.
2. Global Master Catalog (17k): Empirical registry verification (CSPC, RIAA, Last.fm).
"""
from pathlib import Path
import sqlite3
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import streamlit as st
try:
from core.ranking_engine import HIFFIRankingEngine
except ImportError:
HIFFIRankingEngine = None
st.set_page_config(
page_title="HIFFI | Multi-Platform Intelligence",
page_icon="⚡",
layout="wide",
initial_sidebar_state="expanded",
)
PATH_DB = Path("data/hiffi_catalog.db")
PATH_500 = Path("data/hiffi_multiplatform_500.csv")
PATH_17K = Path("data/master_artists_intelligence_17k_final.csv")
FALLBACK_PATH = Path("enriched_artists.csv")
st.markdown(
"""
""",
unsafe_allow_html=True,
)
def load_hiffi_500():
df = pd.DataFrame()
if PATH_DB.exists():
try:
conn = sqlite3.connect(PATH_DB)
query = """
WITH latest_telemetry AS (
SELECT t.*, ROW_NUMBER() OVER (
PARTITION BY t.artist_id
ORDER BY t.last_synced_at DESC, t.rowid DESC
) as rn
FROM telemetry_metrics t
),
latest_rankings AS (
SELECT r.*, ROW_NUMBER() OVER (
PARTITION BY r.artist_id
ORDER BY r.rowid DESC
) as rn
FROM rankings r
)
SELECT
a.artist_id,
a.artist_name as name,
r.catalog_rank as hiffi_xp_published_rank,
r.tier_rank,
COALESCE(t.subscribers_count, 0) as subscriber_count,
COALESCE(t.total_views, 0) as lifetime_views,
COALESCE(t.spotify_monthly_listeners, 0) as spotify_monthly_listeners,
COALESCE(t.instagram_followers, 0) as instagram_followers,
COALESCE(t.daily_view_velocity, 0) as daily_view_velocity,
COALESCE(t.growth_velocity_7d, 0.0) as momentum_7d,
COALESCE(t.growth_velocity_30d, 0.0) as momentum_30d,
COALESCE(t.spotify_daily_change, 0) as spotify_daily_change
FROM rankings r
JOIN artists a ON r.artist_id = a.artist_id
LEFT JOIN latest_telemetry t ON a.artist_id = t.artist_id AND t.rn = 1
WHERE r.catalog_rank <= 500
ORDER BY r.catalog_rank ASC;
"""
df = pd.read_sql_query(query, conn)
conn.close()
except Exception:
df = pd.DataFrame()
if df.empty:
target = PATH_500 if PATH_500.exists() else FALLBACK_PATH
if target.exists():
try:
df = pd.read_csv(target)
except Exception:
df = pd.DataFrame()
if df.empty:
return pd.DataFrame()
if "name" not in df.columns and "artist_name" in df.columns:
df["name"] = df["artist_name"]
if "subscriber_count" not in df.columns and "subscribers_count" in df.columns:
df["subscriber_count"] = df["subscribers_count"]
elif "subscriber_count" not in df.columns:
df["subscriber_count"] = 0
if "lifetime_views" not in df.columns and "total_views" in df.columns:
df["lifetime_views"] = df["total_views"]
elif "lifetime_views" not in df.columns:
df["lifetime_views"] = 0
if "spotify_monthly_listeners" not in df.columns:
df["spotify_monthly_listeners"] = 0
if "instagram_followers" not in df.columns:
df["instagram_followers"] = 0
if "hiffi_xp_published_rank" not in df.columns:
df["hiffi_xp_published_rank"] = df.get("catalog_rank", df.get("hiffi_xp_rank", df.index + 1))
has_sp = pd.to_numeric(df["spotify_monthly_listeners"], errors="coerce").fillna(0).gt(0).astype(int)
has_yt = pd.to_numeric(df["subscriber_count"], errors="coerce").fillna(0).gt(0).astype(int)
has_ig = pd.to_numeric(df["instagram_followers"], errors="coerce").fillna(0).gt(0).astype(int)
df["platform_evidence_tier"] = has_sp + has_yt + has_ig
numeric_cols = [
"hiffi_xp_published_rank", "hiffi_xp_rank", "hiffi_xp_score", "platform_evidence_tier",
"subscriber_count", "lifetime_views", "spotify_monthly_listeners", "instagram_followers",
"daily_view_velocity", "momentum_7d", "momentum_30d", "breakout_velocity_index"
]
for col in numeric_cols:
if col in df.columns:
df[col] = pd.to_numeric(df[col], errors="coerce")
if HIFFIRankingEngine is not None and ("breakout_velocity_index" not in df.columns or df["breakout_velocity_index"].isna().all()):
try:
eng = HIFFIRankingEngine()
df["breakout_velocity_index"] = eng.calculate_breakout_velocity(df)
except Exception:
df["breakout_velocity_index"] = 0.0
if "breakout_velocity_index" not in df.columns:
df["breakout_velocity_index"] = 0.0
if HIFFIRankingEngine is not None:
try:
eng = HIFFIRankingEngine()
ranked_df = eng.calculate_hiffi_xp(df)
df["hiffi_xp_score"] = ranked_df["hiffi_xp_score"]
df["effective_weights"] = ranked_df.get("effective_weights", "sp:45.0%,yt:35.0%,ig:20.0%")
df["catalog_rank"] = ranked_df.get("catalog_rank", df["hiffi_xp_published_rank"])
df["hiffi_xp_published_rank"] = df["catalog_rank"]
except Exception:
sp_n = df["spotify_monthly_listeners"].fillna(0) / max(df["spotify_monthly_listeners"].max(), 1)
yt_n = df["subscriber_count"].fillna(0) / max(df["subscriber_count"].max(), 1)
ig_n = df["instagram_followers"].fillna(0) / max(df["instagram_followers"].max(), 1)
df["hiffi_xp_score"] = (sp_n * 45.0 + yt_n * 35.0 + ig_n * 20.0).round(2)
df["effective_weights"] = "sp:45.0%,yt:35.0%,ig:20.0%"
else:
sp_n = df["spotify_monthly_listeners"].fillna(0) / max(df["spotify_monthly_listeners"].max(), 1)
yt_n = df["subscriber_count"].fillna(0) / max(df["subscriber_count"].max(), 1)
ig_n = df["instagram_followers"].fillna(0) / max(df["instagram_followers"].max(), 1)
df["hiffi_xp_score"] = (sp_n * 45.0 + yt_n * 35.0 + ig_n * 20.0).round(2)
df["effective_weights"] = "sp:45.0%,yt:35.0%,ig:20.0%"
if "anomaly_flags" not in df.columns:
df["anomaly_flags"] = "CLEAN"
if "subgenre" not in df.columns:
def infer_subgenre(r):
subs = r.get("subscriber_count", 0) or 0
bvi = r.get("breakout_velocity_index", 0) or 0
if bvi >= 70:
return "Breakout / Emerging"
elif subs >= 15000000:
return "Legends"
else:
return "Trap & Street"
df["subgenre"] = df.apply(infer_subgenre, axis=1)
return df
def load_master_17k():
if not PATH_17K.exists():
return pd.DataFrame()
df = pd.read_csv(PATH_17K)
if "name" not in df.columns and "artist_name" in df.columns:
df["name"] = df["artist_name"]
return df
df_500 = load_hiffi_500()
df_17k = load_master_17k()
with st.sidebar:
st.markdown("### ⚡ HIFFI Intelligence Suite")
st.caption("Hip-Hop 500 & Master Catalog Intelligence")
st.markdown("", unsafe_allow_html=True)
catalog_source = st.selectbox(
"Active Data Scope:",
["Hip-Hop 500 (Executive Telemetry)", "Global Master Catalog (17,000+ Acts)"],
index=0,
)
st.markdown("", unsafe_allow_html=True)
if "Global Master Catalog" in catalog_source:
with st.sidebar:
st.markdown("##### 17k Catalog Filters")
if df_17k.empty:
st.error("Master 17k dataset not found at data/master_artists_intelligence_17k_final.csv")
st.stop()
tier_list = ["All Tiers"] + sorted(df_17k.get("catalog_intelligence_tier", pd.Series(dtype=str)).dropna().unique().tolist())
sel_tier = st.selectbox("Intelligence Tier:", tier_list, index=0)
search_17k = st.text_input("Search Artist Name:", placeholder="e.g. Eminem, The Roots...")
filt_17k = df_17k.copy()
if sel_tier != "All Tiers" and "catalog_intelligence_tier" in filt_17k.columns:
filt_17k = filt_17k[filt_17k["catalog_intelligence_tier"] == sel_tier]
if search_17k and "name" in filt_17k.columns:
filt_17k = filt_17k[filt_17k["name"].str.contains(search_17k, case=False, na=False)]
head1, head2 = st.columns([3, 1])
with head1:
st.markdown("Global Master Artist Catalog (17k)
", unsafe_allow_html=True)
st.markdown("Empirical registry validation via CSPC sales, RIAA certifications, and verified Last.fm global scrobbles.
", unsafe_allow_html=True)
with head2:
st.markdown(f"Filtered: {len(filt_17k):,} / {len(df_17k):,} acts
", unsafe_allow_html=True)
mk1, mk2, mk3, mk4, mk5 = st.columns(5)
with mk1:
st.markdown(f'Universe Size
{len(df_17k):,}
Total Cataloged
Verified Entities
{ver_cnt:,}
Registry Authenticated
Tier 1 Superstars
{t1_cnt:,}
Audited CSPC EAS
Last.fm Verified
{lfm_cnt:,}
Active Platform Entities
Unaudited
{unver_cnt:,}
Zero-Registry Matches
HIFFI Hip-Hop 500 Intelligence Hub
", unsafe_allow_html=True)
st.markdown("Pure multi-platform composite rankings (45% Spotify, 35% YouTube, 20% Instagram) with zero-imputation policy.
", unsafe_allow_html=True)
with head_col2:
st.markdown(
f"Active Cohort: {len(filtered_df)} / {len(df)} artists
",
unsafe_allow_html=True,
)
k1, k2, k3, k4, k5 = st.columns(5)
with k1:
st.markdown(f'Tracked Artists
{len(df)}
Monitored Cohort
Tier 3 (Complete)
{t3_count}
Spotify + YT + IG
YouTube Telemetry
{yt_count}
Verified video channels
Spotify Telemetry
{sp_count}
Verified monthly listeners
Instagram Audience
{ig_count}
Verified public followings
'
f'
'
f'{rank_label}'
f'Tier {tier_val} Evidence'
f'
'
f'
{artist_name}
'
f'
'
f'
'
f'
'
f'
Artist: {artist_disp_name}
'
f'
Evidence Tier: Tier {tier_disp_num}
'
f'
Breakout Velocity Index: {bvi_val:.2f}
'
f'
Telemetry Weighting: {weights_disp}
'
f'
Integrity Audit: {row.get("anomaly_flags", "CLEAN")}
'
f'
'
f'