Update app.py

app.py

@@ -2,11 +2,12 @@ import os
 import io
 import tempfile
 import datetime
+import textwrap
+
+import numpy as np
 import torch
 import librosa
-import numpy as np
 import gradio as gr
-import asyncio
 
 from reportlab.pdfgen import canvas
 from reportlab.lib.pagesizes import letter
@@ -14,17 +15,24 @@ from reportlab.lib.utils import ImageReader
 from reportlab.lib import colors
 from reportlab.pdfbase import pdfmetrics
 from reportlab.pdfbase.ttfonts import TTFont
-from reportlab.platypus import Paragraph
-from reportlab.lib.styles import getSampleStyleSheet
 
 from transformers import (
     WhisperProcessor,
     AutoModelForSpeechSeq2Seq,
     AutoFeatureExtractor,
-    AutoModel
+    AutoModel,
 )
 from transformers import pipeline as hf_pipeline
 
+# --- SciPy / librosa compatibility patch (hann -> windows.hann) ----------
+try:
+    import scipy.signal as _sg
+    from scipy.signal import windows as _win
+
+    if not hasattr(_sg, "hann"):
+        _sg.hann = _win.hann
+except Exception:
+    _sg = None
 
 # ---------------------------------------------------------
 # FONTS
@@ -32,34 +40,33 @@ from transformers import pipeline as hf_pipeline
 pdfmetrics.registerFont(TTFont("PlayfairBold", "PlayfairDisplay-Bold.ttf"))
 pdfmetrics.registerFont(TTFont("Geneva", "Geneva.ttf"))
 
-
 # ---------------------------------------------------------
-# COLORS
+# COLORS & CONFIG
 # ---------------------------------------------------------
-ACCENT = colors.HexColor("#8b5cf6")
-PRIMARY = colors.HexColor("#3b0c3f")
+ACCENT = colors.HexColor("#8b5cf6")   # violet accent
+PRIMARY = colors.HexColor("#3b0c3f")  # eggplant
 LIGHT_GRAY = colors.HexColor("#e6e6e6")
+GOLD = colors.HexColor("#f4c542")     # deeper gold for better contrast
 WHITE = colors.white
 BLACK = colors.black
 
 ENGINE_URL = "https://www.tourdefierce.vip/ai-music-detector"
+LOGO_FILE = "logo.jpg"
 
-LOGO = "logo.jpg"     # IMPORTANT: must be uploaded to HF Space root
+ASR_MODEL = "openai/whisper-small"        # best free-tier Whisper
+CLF_MODEL = "microsoft/wavlm-base-plus-sv"
 
 
 # ---------------------------------------------------------
-# ML MODELS
+# LOAD MODELS
 # ---------------------------------------------------------
-ASR_MODEL = "openai/whisper-small"
-CLF_MODEL = "microsoft/wavlm-base-plus-sv"
-
 processor = WhisperProcessor.from_pretrained(ASR_MODEL)
 asr_model = AutoModelForSpeechSeq2Seq.from_pretrained(ASR_MODEL)
 asr_pipe = hf_pipeline(
     "automatic-speech-recognition",
     model=asr_model,
     tokenizer=processor.tokenizer,
-    feature_extractor=processor.feature_extractor
+    feature_extractor=processor.feature_extractor,
 )
 
 clf_processor = AutoFeatureExtractor.from_pretrained(CLF_MODEL)
@@ -67,25 +74,32 @@ clf_model = AutoModel.from_pretrained(CLF_MODEL)
 
 
 # ---------------------------------------------------------
-# DSP FUNCTIONS
+# DSP / ANALYSIS UTILITIES
 # ---------------------------------------------------------
 def compute_autotune_index(y, sr):
-    """Detect pitch correction by measuring log-F0 variance."""
+    """Heuristic autotune index: low pitch variance -> more 'quantized' -> higher score."""
     f0, voiced, _ = librosa.pyin(
         y,
         sr=sr,
         fmin=librosa.note_to_hz("C2"),
-        fmax=librosa.note_to_hz("C6")
+        fmax=librosa.note_to_hz("C6"),
     )
+
+    if f0 is None:
+        return 0.0
+
     f0 = f0[voiced > 0.5]
 
     if len(f0) < 10:
         return 0.0
 
-    std = np.std(np.log(f0))
+    log_f0 = np.log(f0)
+    std = np.std(log_f0)
+
+    # Very smooth / quantized singing => lower std
     max_std = 0.25
     score = 1 - np.clip(std / max_std, 0, 1)
-    return float(score * 100)
+    return float(score * 100.0)
 
 
 def extract_embeddings(y, sr):
@@ -95,76 +109,256 @@ def extract_embeddings(y, sr):
     return out.cpu().numpy()
 
 
-def calculate_ai_score(emb):
+def calculate_ai_probability(emb, y, sr, autotune_idx):
+    """
+    Heuristic AI probability in [0, 1].
+
+    Uses:
+    - Embedding norm
+    - Dynamic range
+    - Autotune index
+    """
+    # Embedding norm (rough style/complexity proxy)
     norm = np.linalg.norm(emb)
-    norm_min, norm_max = 50, 150
+    norm_min, norm_max = 40, 140
     norm_scaled = np.clip((norm - norm_min) / (norm_max - norm_min), 0, 1)
-    return float(np.clip(norm_scaled * 0.9 + 0.1, 0.05, 0.99))
+
+    # Dynamic range: very flat dynamics can hint at synthetic / over-processed audio
+    S = np.abs(librosa.stft(y))
+    rms = librosa.feature.rms(S=S)[0]
+    dyn_range = np.percentile(rms, 95) - np.percentile(rms, 5)
+    dyn_scaled = 1.0 - np.clip((dyn_range - 0.02) / 0.1, 0, 1)  # flatter -> closer to 1
+
+    # Autotune contribution
+    at_scaled = autotune_idx / 100.0
+
+    # Weighted combination
+    raw = 0.4 * norm_scaled + 0.3 * dyn_scaled + 0.3 * at_scaled
+
+    # Squash to [0.05, 0.99] so we never hit absolute 0/100
+    ai_prob = float(np.clip(raw * 0.95 + 0.05, 0.05, 0.99))
+    return ai_prob
 
 
 def detect_key(y, sr):
     chroma = librosa.feature.chroma_cqt(y=y, sr=sr)
-    mean = chroma.mean(axis=1)
-    idx = np.argmax(mean)
-    KEYS = ["C","C#","D","Eb","E","F","F#","G","Ab","A","Bb","B"]
+    chroma_mean = chroma.mean(axis=1)
+    key_index = int(np.argmax(chroma_mean))
+
+    KEYS = ["C", "C#", "D", "Eb", "E", "F", "F#", "G", "Ab", "A", "Bb", "B"]
+    root = KEYS[key_index]
 
-    root = KEYS[idx]
-    maj_energy = mean[(idx + 4) % 12] + mean[(idx + 7) % 12]
-    min_energy = mean[(idx + 3) % 12] + mean[(idx + 7) % 12]
+    maj_energy = chroma_mean[(key_index + 4) % 12] + chroma_mean[(key_index + 7) % 12]
+    min_energy = chroma_mean[(key_index + 3) % 12] + chroma_mean[(key_index + 7) % 12]
 
-    return f"{root} major" if maj_energy > min_energy else f"{root} minor"
+    return f"{root} major" if maj_energy >= min_energy else f"{root} minor"
 
 
 def detect_bpm(y, sr):
-    tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
-    return float(tempo)
+    onset_env = librosa.onset.onset_strength(y=y, sr=sr)
+    tempo = librosa.beat.tempo(onset_envelope=onset_env, sr=sr)
+    if tempo is None or len(tempo) == 0:
+        return 0.0
+    return float(tempo[0])
+
+
+def estimate_voice_type(y, sr):
+    """Very rough tessitura-based suggestion."""
+    f0, voiced, _ = librosa.pyin(
+        y,
+        sr=sr,
+        fmin=librosa.note_to_hz("C2"),
+        fmax=librosa.note_to_hz("C6"),
+    )
+
+    if f0 is None or np.sum(voiced) < 5:
+        return "Unable to estimate voice type from this clip."
+
+    f0 = f0[voiced > 0.5]
+    median_hz = np.median(f0)
+    median_note = librosa.hz_to_note(median_hz)
+
+    # Very coarse buckets
+    if median_hz < librosa.note_to_hz("G3"):
+        base = "lower voice (baritone / alto range)"
+    elif median_hz < librosa.note_to_hz("C4"):
+        base = "mid voice (baritenor / mezzo range)"
+    else:
+        base = "high voice (tenor or soprano range)"
+
+    return f"Given the tessitura, this song is best suited for a {base}."
+
+
+def compute_production_polish(y, sr):
+    """0-100: how polished / produced the track sounds."""
+    S = np.abs(librosa.stft(y))
+    rms = librosa.feature.rms(S=S)[0]
+
+    dyn_range = np.percentile(rms, 95) - np.percentile(rms, 5)
+    dyn_score = 1.0 - np.clip((dyn_range - 0.015) / 0.12, 0, 1)
+
+    flatness = np.mean(librosa.feature.spectral_flatness(S=S))
+    flat_score = np.clip((flatness - 0.1) / 0.4, 0, 1)
+
+    polish = 0.6 * dyn_score + 0.4 * flat_score
+    return float(polish * 100.0)
+
+
+def compute_shade_score(ai_percent, autotune_idx, polish_idx):
+    """
+    Shade Meter 0–100:
+    - 60% AI likelihood
+    - 25% autotune index
+    - 15% production polish
+    """
+    shade = 0.6 * ai_percent + 0.25 * autotune_idx + 0.15 * polish_idx
+    return float(np.clip(shade, 0, 100))
 
 
 # ---------------------------------------------------------
-# FORENSIC ANALYSIS GENERATOR
+# TEXT HELPERS
 # ---------------------------------------------------------
-def generate_forensic_analysis(ai, human, atune, key_sig, bpm, transcript):
-    out = []
-    out.append(f"AI likelihood measured at {ai:.1f}%.")
-    out.append(f"Human likelihood measured at {human:.1f}%.")
-    out.append(f"Autotune index computed at {atune:.1f}/100.")
-    out.append(f"Detected key signature: {key_sig}.")
-    out.append(f"Detected tempo: {bpm:.1f} BPM.")
-
-    if atune > 65:
-        out.append("Pitch trajectories show unusually low variance, suggesting strong pitch correction.")
-    elif atune > 35:
-        out.append("Moderate pitch regularization detected — could be gentle EQ or light tuning.")
+def wrap_paragraph(text, width=90):
+    lines = []
+    for para in text.splitlines():
+        if not para.strip():
+            lines.append("")
+            continue
+        lines.extend(textwrap.wrap(para, width=width))
+    return lines
+
+
+def build_scientific_analysis(ai_pct, human_pct, autotune_idx, shade, key_sig, bpm, polish_idx):
+    lines = []
+    lines.append("Overview")
+    lines.append(
+        f"This clip was analyzed using a hybrid signal-processing and deep-learning stack. "
+        f"Based on embedding statistics, dynamic range, spectral behavior, and pitch stability, "
+        f"the system estimates a {ai_pct:.1f}% probability that the source material is AI-generated, "
+        f"and a {human_pct:.1f}% probability that it is primarily human-performed."
+    )
+    lines.append("")
+    lines.append("Pitch & Autotune")
+    lines.append(
+        f"Fundamental frequency tracking suggests an autotune index of {autotune_idx:.1f}/100. "
+        f"Lower scores indicate more organic pitch variance, while higher scores indicate quantized or "
+        f"grid-snapped intonation."
+    )
+    lines.append("")
+    lines.append("Rhythm & Tempo")
+    lines.append(
+        f"Tempo estimation places this performance at approximately {bpm:.1f} beats per minute. "
+        f"The detected tempo is derived from onset strength peaks and may vary slightly with different sections "
+        f"of the recording."
+    )
+    lines.append("")
+    lines.append("Timbre & Production")
+    lines.append(
+        f"Timbre and dynamics analysis yields a production polish score of {polish_idx:.1f}/100. "
+        f"Higher scores correspond to compressed, consistently loud, and spectrally uniform material, "
+        f"often associated with heavily produced or synthetic audio."
+    )
+    lines.append("")
+    lines.append("Musical Context")
+    lines.append(
+        f"Harmonic analysis indicates that the material centers around {key_sig}. "
+        f"This key estimate is based on chroma energy distribution over the length of the clip."
+    )
+    return "\n".join(lines)
+
+
+def build_clapback(ai_pct, human_pct, autotune_idx, shade, key_sig, bpm, voice_text):
+    tone_lines = []
+    tone_lines.append("CLAPBACK SUMMARY")
+    tone_lines.append("")
+    if ai_pct >= 75:
+        tone_lines.append(
+            f"This track is giving **full robot fantasy** with an AI likelihood of {ai_pct:.1f}%. "
+            f"If there was a human involved, they were probably just pressing 'render.'"
+        )
+    elif ai_pct >= 40:
+        tone_lines.append(
+            f"This performance lives in the uncanny valley with an AI likelihood of {ai_pct:.1f}%. "
+            f"Some human in there, but the machines are definitely helping."
+        )
     else:
-        out.append("Pitch behavior appears natural and uncorrected.")
-
-    if ai > 70:
-        out.append("Spectral fingerprint aligns strongly with synthetic speech models.")
-    elif ai > 40:
-        out.append("Some harmonic structures resemble AI synthesis but confidence is mixed.")
+        tone_lines.append(
+            f"With only {ai_pct:.1f}% AI likelihood, this one is serving mostly human realness. "
+            f"Congrats: your soul is still in the mix."
+        )
+
+    tone_lines.append("")
+    if autotune_idx >= 70:
+        tone_lines.append(
+            f"Autotune index {autotune_idx:.1f}/100: every note is so locked to the grid it should pay rent there."
+        )
+    elif autotune_idx >= 35:
+        tone_lines.append(
+            f"Autotune index {autotune_idx:.1f}/100: tasteful correction, but we definitely hear the safety net."
+        )
     else:
-        out.append("Signal characteristics strongly support human vocal production.")
+        tone_lines.append(
+            f"Autotune index {autotune_idx:.1f}/100: pitch is flying mostly solo — brave, messy, and very human."
+        )
+
+    tone_lines.append("")
+    tone_lines.append(
+        f"Shade Meter score: {shade:.1f}/100. "
+        f"Zero would mean unplugged, unprocessed, angel-on-a-stool vibes. "
+        f"You're sitting at {shade:.1f}, which means there's at least a mild breeze of manufactured perfection "
+        f"blowing through this mix."
+    )
+
+    tone_lines.append("")
+    tone_lines.append(
+        f"Musically, the track hangs out around {key_sig} at about {bpm:.1f} BPM, so if you’re clapping back on TikTok, "
+        f"now you know what tempo to drag them in."
+    )
 
-    out.append(f"Transcription summary: {transcript[:100]}...")
+    tone_lines.append("")
+    tone_lines.append(f"Voice-tessitura take: {voice_text}")
 
-    return "\n".join(out)
+    return "\n".join(tone_lines)
 
 
 # ---------------------------------------------------------
-# PDF BUILDER
+# PDF GENERATION
 # ---------------------------------------------------------
+def scale_color(val, invert=False):
+    """
+    For score boxes:
+    - green: good
+    - gold: medium
+    - red: high risk
+    """
+    if invert:
+        # invert: low is good
+        if val <= 25:
+            return colors.green
+        if val <= 75:
+            return GOLD
+        return colors.red
+    else:
+        if val >= 75:
+            return colors.green
+        if val >= 25:
+            return GOLD
+        return colors.red
+
+
 def make_pdf(
     ai_score,
     human_score,
     atune,
     shade,
-    analysis,
-    transcript,
     key_sig,
     bpm,
-    clip_title
+    transcript,
+    scientific_text,
+    clapback_text,
+    clip_title,
+    polish_idx,
 ):
-
     buffer = io.BytesIO()
     c = canvas.Canvas(buffer, pagesize=letter)
     W, H = letter
@@ -175,11 +369,11 @@ def make_pdf(
 
     # Logo
     try:
-        c.drawImage(ImageReader(open(LOGO, "rb")), 40, H - 120, width=90, height=90)
-    except Exception as e:
-        print("Logo error:", e)
+        c.drawImage(LOGO_FILE, 40, H - 120, width=90, height=90)
+    except Exception:
+        pass
 
-    # Header
+    # Branding
     c.setFillColor(PRIMARY)
     c.setFont("PlayfairBold", 32)
     c.drawString(150, H - 60, "Tour de Fierce")
@@ -188,43 +382,30 @@ def make_pdf(
     c.setFont("Geneva", 14)
     c.drawString(150, H - 82, "Audio Clapback Report™")
 
-    # Timestamp
+    # Timestamp & clip
     c.setFillColor(BLACK)
     c.setFont("Geneva", 10)
     c.drawString(150, H - 98, f"Generated: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}")
-
-    # Clip name
     c.setFont("Geneva", 12)
-    c.drawString(40, H - 150, f"Clip analyzed: {clip_title}")
+    c.drawString(40, H - 145, f"Clip analyzed: {clip_title}")
 
-    # QR Code
+    # QR to engine
     try:
         import qrcode
+
         qr = qrcode.make(ENGINE_URL)
         buf = io.BytesIO()
         qr.save(buf, format="PNG")
         buf.seek(0)
         c.drawImage(ImageReader(buf), W - 120, H - 140, width=80, height=80)
-    except:
+    except Exception:
         pass
 
+    # Divider line
     c.setStrokeColor(LIGHT_GRAY)
     c.line(40, H - 165, W - 40, H - 165)
 
-    # ---------------------------------------------------------
-    # SCORE BOXES
-    # ---------------------------------------------------------
-    def scale_color(val, invert=False):
-        if invert:
-            if val <= 25: return colors.green
-            if val <= 75: return colors.yellow
-            return colors.red
-        else:
-            if val >= 75: return colors.green
-            if val >= 25: return colors.yellow
-            return colors.red
-
-    # AI Box
+    # ---------------------- SCORE BOXES ----------------------
     c.setFillColor(scale_color(ai_score, invert=True))
     c.rect(40, H - 260, 150, 80, fill=1)
     c.setFillColor(WHITE)
@@ -233,113 +414,139 @@ def make_pdf(
     c.setFont("PlayfairBold", 26)
     c.drawString(55, H - 220, f"{ai_score:.1f}%")
 
-    # Human Box
     c.setFillColor(scale_color(human_score))
     c.rect(210, H - 260, 150, 80, fill=1)
     c.setFillColor(WHITE)
+    c.setFont("Geneva", 11)
     c.drawString(225, H - 195, "Human Likelihood")
     c.setFont("PlayfairBold", 26)
     c.drawString(225, H - 220, f"{human_score:.1f}%")
 
-    # Autotune Box
     c.setFillColor(scale_color(atune, invert=True))
     c.rect(380, H - 260, 150, 80, fill=1)
     c.setFillColor(WHITE)
+    c.setFont("Geneva", 11)
     c.drawString(395, H - 195, "Autotune Index")
     c.setFont("PlayfairBold", 26)
     c.drawString(395, H - 220, f"{atune:.1f}/100")
 
-    # ---------------------------------------------------------
-    # SHADE METER
-    # ---------------------------------------------------------
+    # ---------------------- SHADE METER ----------------------
     c.setFillColor(BLACK)
     c.setFont("Geneva", 12)
-    c.drawString(40, H - 280, "Shade Meter")
+    c.drawString(40, H - 295, "Shade Meter")
 
-    BAR_Y = H - 300
+    # capsule bar background (below the title so it doesn't overlap)
+    bar_y = H - 310
+    bar_height = 14
+    bar_width = 490
 
     c.setFillColor(LIGHT_GRAY)
-    c.roundRect(40, BAR_Y, 490, 16, 8, fill=1)
+    c.roundRect(40, bar_y, bar_width, bar_height, 7, fill=1)
 
-    fill_w = (shade / 100) * 490
+    # fill proportional to shade score
     c.setFillColor(ACCENT)
-    c.roundRect(40, BAR_Y, fill_w, 16, 8, fill=1)
+    fill_w = (shade / 100.0) * bar_width
+    c.roundRect(40, bar_y, fill_w, bar_height, 7, fill=1)
 
     c.setFillColor(BLACK)
     c.setFont("Geneva", 10)
-    c.drawString(540, BAR_Y + 3, f"{shade:.1f}/100")
-
-    # Shade interpretation
-    if shade < 10:
-        sm = "Saint status: no shade detected!"
-    elif shade < 40:
-        sm = "A sprinkle of shade — but nothing wild."
-    elif shade < 75:
-        sm = "Shady lady — there are things to discuss."
-    else:
-        sm = "Maximum shade parade. AI all up in here."
-
-    c.drawString(40, BAR_Y - 20, sm)
+    c.drawString(540, bar_y + 1, f"{shade:.1f}/100")
+
+    # explanatory blurb
+    shade_blurb = (
+        "The Shade Meter provides a comprehensive analysis of the uploaded file, representing exactly "
+        "how much shade you are entitled to direct toward the source of the clip. The ideal score is 0%, "
+        "indicating real, acoustic instruments and un-pitch-corrected vocals. Moderate scores may reflect "
+        "MIDI instruments or noticeably processed vocals. A 100 is the ultimate shade parade, with 100% "
+        "confidence that the clip was generated by an AI system."
+    )
+    c.setFont("Geneva", 9)
+    ytxt = H - 330
+    for line in wrap_paragraph(shade_blurb, width=95):
+        c.drawString(40, ytxt, line)
+        ytxt -= 11
 
-    # ---------------------------------------------------------
-    # MUSICALITY
-    # ---------------------------------------------------------
+    # ---------------------- MUSICALITY -----------------------
+    ytxt -= 5
     c.setFont("PlayfairBold", 18)
     c.setFillColor(PRIMARY)
-    c.drawString(40, H - 360, "Musicality Analysis")
+    c.drawString(40, ytxt, "Musicality Analysis")
+    ytxt -= 18
 
     c.setFont("Geneva", 11)
     c.setFillColor(BLACK)
-    c.drawString(40, H - 385, f"Key Signature: {key_sig}")
-    c.drawString(40, H - 402, f"Tempo (BPM): {bpm:.1f}")
+    c.drawString(40, ytxt, f"Key Signature: {key_sig}")
+    ytxt -= 14
+    c.drawString(40, ytxt, f"Tempo (BPM): {bpm:.1f}")
+    ytxt -= 20
 
-    # ---------------------------------------------------------
-    # FORENSIC BREAKDOWN
-    # ---------------------------------------------------------
+    # ----------------- TECHNICAL FORENSIC ANALYSIS -----------------
     c.setFont("PlayfairBold", 18)
     c.setFillColor(PRIMARY)
-    c.drawString(40, H - 440, "Forensic Breakdown")
+    c.drawString(40, ytxt, "Technical Forensic Analysis")
+    ytxt -= 18
 
     c.setFont("Geneva", 10)
-    ytxt = H - 465
-
-    for line in analysis.split("\n"):
-        if ytxt < 80:
+    c.setFillColor(BLACK)
+    for line in wrap_paragraph(scientific_text, width=95):
+        if ytxt < 60:
             c.showPage()
-            ytxt = H - 60
+            W2, H2 = letter
             c.setFont("Geneva", 10)
+            ytxt = H2 - 60
         c.drawString(40, ytxt, line)
-        ytxt -= 14
+        ytxt -= 11
 
-    # ---------------------------------------------------------
-    # TRANSCRIPT
-    # ---------------------------------------------------------
+    # ----------------- CLAPBACK SECTION -----------------
+    ytxt -= 10
     c.setFont("PlayfairBold", 18)
     c.setFillColor(PRIMARY)
-    c.drawString(40, ytxt - 30, "Transcript")
+    if ytxt < 60:
+        c.showPage()
+        W2, H2 = letter
+        ytxt = H2 - 60
+    c.drawString(40, ytxt, "Clapback Shade Report")
+    ytxt -= 18
 
-    ytxt -= 55
-
-    styles = getSampleStyleSheet()
-    style = styles["Normal"]
-    style.fontName = "Geneva"
-    style.fontSize = 10
-    style.leading = 12
+    c.setFont("Geneva", 10)
+    c.setFillColor(BLACK)
+    for line in wrap_paragraph(clapback_text, width=95):
+        if ytxt < 60:
+            c.showPage()
+            W2, H2 = letter
+            c.setFont("Geneva", 10)
+            ytxt = H2 - 60
+        c.drawString(40, ytxt, line)
+        ytxt -= 11
 
-    para = Paragraph(transcript.replace("\n", "<br/>"), style)
-    pw = W - 80
+    # ----------------- TRANSCRIPT -----------------
+    ytxt -= 10
+    c.setFont("PlayfairBold", 18)
+    c.setFillColor(PRIMARY)
+    if ytxt < 60:
+        c.showPage()
+        W2, H2 = letter
+        ytxt = H2 - 60
+    c.drawString(40, ytxt, "Transcript")
+    ytxt -= 18
 
-    w, h = para.wrap(pw, 400)
-    para.drawOn(c, 40, ytxt - h)
-    ytxt -= (h + 20)
+    c.setFont("Geneva", 9)
+    c.setFillColor(BLACK)
+    for line in wrap_paragraph(transcript, width=100):
+        if ytxt < 50:
+            c.showPage()
+            W2, H2 = letter
+            c.setFont("Geneva", 9)
+            ytxt = H2 - 60
+        c.drawString(40, ytxt, line)
+        ytxt -= 10
 
-    # Footer
+    # footer on last page
     c.setStrokeColor(LIGHT_GRAY)
-    c.line(40, 50, W - 40, 50)
-
+    c.line(40, 40, W - 40, 40)
     c.setFont("Geneva", 9)
-    c.drawString(40, 35, "© 2025 Tour de Fierce — All Shade, No Shame.")
-    c.drawString(300, 35, "www.tourdefierce.vip")
+    c.drawString(40, 28, "© 2025 Tour de Fierce — All Shade, No Shame.")
+    c.drawString(300, 28, "www.tourdefierce.vip")
 
     c.save()
     buffer.seek(0)
@@ -352,80 +559,117 @@ def make_pdf(
 
 
 # ---------------------------------------------------------
-# MAIN ANALYSIS
+# MAIN ANALYSIS PIPELINE
 # ---------------------------------------------------------
-async def run_analysis(audio_file):
+def run_analysis(audio_file):
     if not audio_file:
-        return ("No audio file uploaded.", None, None, None, None, None, None, None, None)
-
+        return (
+            "No audio file uploaded.",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            None,
+        )
+
+    # load
     y, sr = librosa.load(audio_file, sr=16000, mono=True)
 
     # transcription
     try:
         text = asr_pipe({"array": y, "sampling_rate": sr})["text"]
-    except:
+    except Exception:
         text = "[Transcription unavailable]"
 
+    # core metrics
+    autotune_idx = compute_autotune_index(y, sr)
+    polish_idx = compute_production_polish(y, sr)
+
     emb = extract_embeddings(y, sr)
-    ai = calculate_ai_score(emb)
-    human = 1 - ai
-    atune = compute_autotune_index(y, sr)
+    ai_prob = calculate_ai_probability(emb, y, sr, autotune_idx)
+    human_prob = 1.0 - ai_prob
 
-    shade = float((ai * 100 + atune + (human * 100)) / 3)
+    ai_pct = ai_prob * 100.0
+    human_pct = human_prob * 100.0
 
+    shade = compute_shade_score(ai_pct, autotune_idx, polish_idx)
     key_sig = detect_key(y, sr)
     bpm = detect_bpm(y, sr)
+    voice_text = estimate_voice_type(y, sr)
 
-    suggested = "Given the tessitura, this song is best suited for a high voice (tenor or soprano)."
-
-    analysis = generate_forensic_analysis(ai * 100, human * 100, atune, key_sig, bpm, text)
+    scientific_text = build_scientific_analysis(
+        ai_pct, human_pct, autotune_idx, shade, key_sig, bpm, polish_idx
+    )
+    clapback_text = build_clapback(
+        ai_pct, human_pct, autotune_idx, shade, key_sig, bpm, voice_text
+    )
 
     clip_title = os.path.basename(audio_file)
 
     pdf_path = make_pdf(
-        ai * 100,
-        human * 100,
-        atune,
+        ai_pct,
+        human_pct,
+        autotune_idx,
         shade,
-        analysis,
-        text,
         key_sig,
         bpm,
-        clip_title
+        text,
+        scientific_text,
+        clapback_text,
+        clip_title,
+        polish_idx,
     )
 
     return (
         text,
-        f"{ai*100:.1f}%",
-        f"{human*100:.1f}%",
-        f"{atune:.1f}",
+        f"{ai_pct:.1f}%",
+        f"{human_pct:.1f}%",
+        f"{autotune_idx:.1f}",
         f"{shade:.1f}",
         key_sig,
         f"{bpm:.1f}",
-        suggested,
+        voice_text,
+        scientific_text,
+        clapback_text,
         pdf_path,
     )
 
 
-# ---------------------------------------------------------
+# --------------------------------------------------------------
 # UI
-# ---------------------------------------------------------
+# --------------------------------------------------------------
 with gr.Blocks() as demo:
-
-    gr.HTML("""
-    <div style='text-align:center; padding:20px;'>
-        <img src="/file/logo.jpg" style="width:140px; margin-bottom:10px;"/>
-        <h1 style='font-size:36px; font-weight:800;'>👋 Tour de Fierce Audio Clapback Engine™</h1>
-        <p style='color:#666;'>AI Detector • Autotune Detector • Key & BPM • Forensic Reporting</p>
-    </div>
-    """)
+    gr.HTML(
+        """
+        <div style='text-align:center; padding:20px;'>
+            <h1 style='font-size:36px; font-weight:800;'>
+                👋 Tour de Fierce Audio Clapback Engine™
+            </h1>
+            <p style='color:#ccc;'>
+                AI Detector • Autotune Detector • Key & BPM • Forensic Reporting
+            </p>
+        </div>
+        """
+    )
 
     with gr.Row():
         audio_in = gr.Audio(type="filepath", label="Upload audio")
         run_btn = gr.Button("Run Clapback 👏", variant="primary")
 
     with gr.Row():
-        transcript = gr.Textbox(label="Transcript", interactive=False)
+        transcript = gr.Textbox(
+            label="Transcript",
+            interactive=False,
+            lines=5,
+            show_label=True,
+        )
+
+    with gr.Row():
         ai_out = gr.Textbox(label="AI Likelihood", interactive=False)
         human_out = gr.Textbox(label="Human Likelihood", interactive=False)
         atune_out = gr.Textbox(label="Autotune Index", interactive=False)
@@ -436,10 +680,22 @@ with gr.Blocks() as demo:
         bpm_out = gr.Textbox(label="Tempo (BPM)", interactive=False)
         voice_out = gr.Textbox(label="Suggested Voice Type", interactive=False)
 
+    with gr.Row():
+        forensic_out = gr.Textbox(
+            label="Technical Forensic Analysis",
+            interactive=False,
+            lines=12,
+        )
+        clapback_out = gr.Textbox(
+            label="Clapback Shade Report",
+            interactive=False,
+            lines=12,
+        )
+
     pdf_download = gr.File(label="Download Report")
 
     run_btn.click(
-        fn=lambda f: asyncio.run(run_analysis(f)),
+        fn=run_analysis,
         inputs=audio_in,
         outputs=[
             transcript,
@@ -450,8 +706,10 @@ with gr.Blocks() as demo:
             key_out,
             bpm_out,
             voice_out,
-            pdf_download
-        ]
+            forensic_out,
+            clapback_out,
+            pdf_download,
+        ],
     )
 
 demo.launch()