Spaces:

Sina1138
/

ReView

Paused

Sina1138

Fix title and rebuttal passing via gr.State instead of hidden textboxes

4827e31 about 2 months ago

125 kB

	import sys, os.path
	import threading
	import time
	import uuid
	from pathlib import Path
	from typing import Tuple, Dict, List, Optional
	from collections import defaultdict
	import hashlib
	import json
	import math
	import re as _re
	import html as _html
	import torch
	import numpy as np
	import gradio as gr
	import pandas as pd
	import ast
	from tqdm import tqdm

	# ZeroGPU support for HuggingFace Spaces
	try:
	import spaces
	_gpu = spaces.GPU
	except ImportError:
	_gpu = lambda f: f # no-op when not on HF Spaces

	sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../')))

	BASE_DIR = Path(__file__).resolve().parent.parent

	# Controls how aggressively agreement colors are amplified.
	# Lower = more vivid colors (0.2 = very strong, 1.0 = no amplification).
	# Asymmetric: unique/red (positive) is amplified less than common/blue (negative)
	# to avoid overwhelming red when most sentences are unique.
	# Module-level storage for background thread state (avoids pickling issues with ZeroGPU)
	_thread_states = {}

	AGREEMENT_AMP_UNIQUE = 1.0 # exponent for positive scores (red = unique)
	AGREEMENT_AMP_COMMON = 1.0 # exponent for negative scores (blue = common)
	MAX_PREPROCESSED_REVIEWS = 10 # Number of review/agreement/rebuttal slots in pre-processed tab
	LISTENER_CONCENTRATION_THRESHOLD = 0.70 # Above this, listener "wins" over uniqueness score
	INFORMATIVENESS_MULTIPLIER = 2.0 # Multiplied by uniform baseline (1/K) for informativeness threshold


	def _make_sentence_id(sentence: str) -> str:
	"""Deterministic DOM ID for a sentence, used by click-to-scroll."""
	return "sent_" + hashlib.md5(sentence.encode("utf-8")).hexdigest()[:12]


	def _click_to_scroll_js(sent_id: str, color: str = "#3b82f6") -> str:
	"""Return inline onclick JS for smooth-scroll + outline flash."""
	return (
	f"(function(){{var el=document.getElementById('{sent_id}');"
	f"if(el){{el.scrollIntoView({{behavior:'smooth',block:'center'}});"
	f"el.style.outline='3px solid {color}';"
	f"setTimeout(function(){{el.style.outline='';}},2500);}}}})();"
	)


	def _source_badges_html(sent: str, sentence_lists: list) -> str:
	"""Return R# badge HTML for all reviews containing the sentence."""
	source = [r_idx + 1 for r_idx, sl in enumerate(sentence_lists) if sent in sl]
	return " ".join(
	f'<span style="background:#f3f4f6;color:#374151;padding:2px 6px;'
	f'border-radius:4px;font-size:0.72em;font-weight:600;">R{n}</span>'
	for n in source
	)


	def _listener_dist_bars(sent: str, listener: dict, source_badges: str,
	badge_fg: str = "#1e40af") -> str:
	"""Render L_t(d\|s) distribution bars or plain badge row."""
	if listener and sent in listener:
	dist = listener[sent]
	bar_parts = []
	for label, prob in sorted(dist.items()):
	pct = int(round(prob * 100))
	bar_w = max(2, int(prob * 80))
	bar_parts.append(
	f'<span style="display:inline-flex;align-items:center;gap:2px;margin-right:6px;">'
	f'<span style="font-size:0.7em;font-weight:600;color:{badge_fg};">{label}</span>'
	f'<span style="display:inline-block;width:{bar_w}px;height:5px;'
	f'background:#3b82f6;border-radius:3px;"></span>'
	f'<span style="font-size:0.7em;color:#6b7280;">{pct}%</span>'
	f'</span>'
	)
	return (
	f'<div style="display:flex;flex-wrap:wrap;align-items:center;gap:3px;margin-bottom:3px;">'
	f'{source_badges}'
	f'<span style="color:#d1d5db;font-size:0.75em;">\u2192</span> '
	+ "".join(bar_parts) + "</div>"
	)
	return f'<div style="display:flex;gap:4px;margin-bottom:3px;">{source_badges}</div>'


	def _get_context(sentence: str, sentence_lists: list):
	"""Return (context_before, context_after) strings for the first review containing sentence."""
	for sl in sentence_lists:
	if sentence in sl:
	idx = sl.index(sentence)
	before = _html.escape(sl[idx - 1]) if idx > 0 else ""
	after = _html.escape(sl[idx + 1]) if idx < len(sl) - 1 else ""
	return before, after
	return "", ""


	_TOGGLE_BTN_STYLE = (
	'background:none;border:1px solid #d1d5db;border-radius:6px;padding:4px 12px;'
	'font-size:0.78em;color:#6b7280;cursor:pointer;white-space:nowrap;'
	'line-height:1;height:28px;box-sizing:border-box;vertical-align:middle;'
	'display:inline-flex;align-items:center;justify-content:center;flex-shrink:0;'
	)

	def _toggle_html(selector: str, text_when_all_open: str,
	text_when_not_all_open: str, initial_label: str) -> str:
	"""Generate a toggle button for expanding/collapsing details elements."""
	return (
	'<button onclick="'
	f"let tab=this.closest('.tabitem')\|\|this.closest('.gradio-container');"
	f"let details=tab.querySelectorAll('{selector}');"
	"if(!details.length)return;"
	"let allOpen=Array.from(details).every(d=>d.open);"
	"details.forEach(d=>d.open=!allOpen);"
	f"this.textContent=allOpen?'{text_when_all_open}':'{text_when_not_all_open}';"
	f'" style="{_TOGGLE_BTN_STYLE}"'
	f'>{initial_label}</button>'
	)


	def _rebuttal_toggle_html() -> str:
	"""Generate an Expand/Collapse All Responses toggle button with inline JS."""
	return _toggle_html("details:not(.review-collapse)",
	"Expand All Responses", "Collapse All Responses",
	"Expand All Responses")


	def _review_toggle_html() -> str:
	"""Generate a Collapse/Expand All Reviews toggle button with inline JS."""
	return _toggle_html("details.review-collapse",
	"Expand All Reviews", "Collapse All Reviews",
	"Collapse All Reviews")


	def _jump_buttons_html(active_count: int, prefix: str = "int") -> str:
	"""Generate jump-to buttons [R1] [R2] ... that scroll to each review.
	prefix: 'int' for interactive tab, 'pre' for pre-processed tab."""
	buttons = []
	for i in range(1, active_count + 1):
	anchor_id = f"{prefix}-review-anchor-{i}"
	js = (
	f"(function(){{var el=document.getElementById('{anchor_id}');"
	f"if(el)el.scrollIntoView({{behavior:'smooth',block:'start'}});"
	f"}})()"
	)
	buttons.append(
	f'<button onclick="{js}" '
	f'style="{_TOGGLE_BTN_STYLE}font-weight:600;">'
	f'R{i}</button>'
	)
	return "".join(buttons)



	def _should_break_before(sent: str) -> bool:
	"""Detect if a paragraph break should be inserted before this sentence."""
	s = sent.strip()
	# Numbered items: 1), 2., (1), 1:, etc.
	if _re.match(r'^[\(\[]?\d+[\)\]\.:]', s):
	return True
	# Dash/bullet items
	if len(s) > 2 and s[0] in ('-', '•', '*', '–', '—') and s[1] == ' ':
	return True
	# Markdown separators / headers
	if s.startswith('##') or s.startswith('---'):
	return True
	# Common review section headers
	if _re.match(
	r'^\*{0,2}(Rating\|Strengths?\|Weaknesses?\|Questions?\|Limitations?\|Summary\|'
	r'Soundness\|Presentation\|Contribution\|Confidence\|Experience\|Review Assessment\|'
	r'Recommendation\|Overall\|Minor\|Major\|Typos?\|Suggestions?\|Comments?\|'
	r'Detailed\s+Comments?\|Pros?\|Cons?\|Flag\|Clarity\|Significance\|Originality)',
	s, _re.IGNORECASE,
	):
	return True
	return False


	def _is_review_header(sent: str) -> bool:
	"""Detect if a sentence is a review metadata header (Rating:, Experience:, etc.)."""
	return bool(_re.match(
	r'^\*{0,2}(Rating\|Confidence\|Experience\|Review Assessment\|Recommendation\|Flag)\b',
	sent.strip(), _re.IGNORECASE,
	))


	# ---- Polarity / Topic color maps for HTML rendering ----
	_POLARITY_COLORS = {
	2: "#d4fcd6", 0: "#fcd6d6", # integer keys (pre-processed tab)
	"➕": "#d4fcd6", "➖": "#fcd6d6", # emoji keys (interactive tab)
	} # positive=green, negative=red
	_TOPIC_HTML_COLORS = {
	"Substance": "#b3e5fc",
	"Clarity": "#c8e6c9",
	"Soundness/Correctness": "#fff9c4",
	"Originality": "#f8bbd0",
	"Motivation/Impact": "#d1c4e9",
	"Meaningful Comparison": "#ffe0b2",
	"Replicability": "#b2dfdb",
	}


	def _wrap_review_card(label: str, inner_html: str, collapsible: bool = True) -> str:
	"""Wrap review content in a styled card with gray header. Single source of truth for review card styling."""
	escaped = _html.escape(label) if label else ""
	if collapsible:
	return (
	f'<details open class="review-collapse" style="border:1px solid #d1d5db;'
	f'border-radius:8px;padding:0;margin-bottom:10px;overflow:hidden;">'
	f'<summary style="font-weight:600;font-size:0.9em;color:#374151;cursor:pointer;'
	f'list-style:none;display:flex;align-items:center;gap:6px;'
	f'background:#f9fafb;padding:8px 14px;border-bottom:1px solid #e5e7eb;">'
	f'<span style="transition:transform 0.2s;font-size:0.7em;">▶</span> '
	f'{escaped}</summary>'
	f'<div style="padding:12px 16px;">{inner_html}</div>'
	f'</details>'
	)
	else:
	if not label:
	return inner_html
	return (
	f'<div style="border:1px solid #d1d5db;border-radius:8px;padding:0;margin-bottom:10px;overflow:hidden;">'
	f'<div style="background:#f9fafb;padding:8px 14px;border-bottom:1px solid #e5e7eb;'
	f'font-weight:600;font-size:0.85em;color:#374151;">{escaped}</div>'
	f'<div style="padding:12px 16px;">{inner_html}</div>'
	f'</div>'
	)


	def render_review_html(
	review_items: list,
	mode: str = "plain",
	label: str = "Review",
	wrap: bool = False,
	) -> str:
	"""
	Render a review as HTML with proper paragraph formatting.

	Args:
	review_items: list of (sentence, metadata_dict) tuples
	mode: "plain", "polarity", or "topic"
	label: header label
	wrap: if False, return bare content (caller handles outer wrapper)
	"""
	if not review_items:
	return ""

	parts = []
	parts.append('<div style="line-height:1.8;font-size:0.95em;margin-top:6px;">')

	for i, (sent, metadata) in enumerate(review_items):
	# Paragraph break detection
	if i > 0 and _should_break_before(sent):
	parts.append('<br>')

	# Header styling (Rating:, Experience:, etc.)
	is_header = _is_review_header(sent)

	bg = ""
	label_text = ""
	if mode == "polarity":
	polarity = metadata.get("polarity")
	if polarity in _POLARITY_COLORS:
	bg = f"background:{_POLARITY_COLORS[polarity]};"
	elif mode == "topic":
	topic = metadata.get("topic")
	if topic and topic != "NONE" and topic in _TOPIC_HTML_COLORS:
	bg = f"background:{_TOPIC_HTML_COLORS[topic]};"
	label_text = topic

	style = f"padding:1px 3px;border-radius:3px;{bg}"
	if is_header:
	style += "font-weight:600;color:#92400e;"

	sent_id = _make_sentence_id(sent)
	escaped = _html.escape(sent)

	if label_text:
	# Show topic label as a small tag
	parts.append(
	f'<span id="{sent_id}" style="{style}" title="{_html.escape(label_text)}">'
	f'{escaped} </span>'
	)
	else:
	parts.append(f'<span id="{sent_id}" style="{style}">{escaped} </span>')

	parts.append('</div>')
	content = "".join(parts)
	if wrap:
	return _wrap_review_card(label, content, collapsible=True)
	elif label:
	return _wrap_review_card(label, content, collapsible=False)
	return content


	def format_summary_cards(
	sentences: list,
	scores: dict,
	sentence_lists: list,
	card_type: str = "common",
	listener: dict = None,
	speaker: dict = None,
	) -> str:
	"""
	Most Common Opinions hub.

	Selection: When listener/speaker data is available, re-ranks candidates by
	informativeness × (1 − normalized_uniqueness) so substantive agreements
	surface above generic filler. Falls back to the raw score order when the
	full RSA data is not available (pre-processed tab).

	Each card shows:
	- L_t(d\|s) distribution bars (R1 40% · R2 45% · R3 15%) when data is available
	- Context snippet (1 sentence before / after)
	- Clickable to scroll to the sentence in the full review below
	"""
	if not sentences:
	return ""

	border_color = "#93c5fd"
	badge_bg = "#dbeafe"
	badge_fg = "#1e40af"

	# Pre-compute expected listener share per reviewer from review lengths.
	# Used for bar chart normalization (bar width = deviation from expected, not raw prob).
	num_reviews = len(sentence_lists)
	total_sents = sum(len(sl) for sl in sentence_lists) or 1
	expected_share = {
	f"R{i+1}": len(sl) / total_sents
	for i, sl in enumerate(sentence_lists)
	}

	# Render in the order given — selection and filtering happens in compute_rsa_in_background.
	ctx_style = "color:#b0b0b0;font-size:0.85em;font-style:italic;"
	cards_parts = []

	for sent in sentences:
	sent_id = _make_sentence_id(sent)
	context_before, context_after = _get_context(sent, sentence_lists)

	# --- Source badge: which review(s) this sentence physically appears in ---
	source_badge = _source_badges_html(sent, sentence_lists)

	# --- L_t(d\|s) distribution bars ---
	dist_html = _listener_dist_bars(sent, listener, source_badge, badge_fg=badge_fg)

	onclick = _click_to_scroll_js(sent_id)

	# Inline context: ...before SENTENCE after... (all one line)
	before_span = f'<span style="{ctx_style}">...{_html.escape(context_before)} </span>' if context_before else ""
	after_span = f'<span style="{ctx_style}"> {_html.escape(context_after)}...</span>' if context_after else ""

	cards_parts.append(
	f'<div style="border:1px solid #e5e7eb;border-left:3px solid {border_color};'
	f'border-radius:6px;padding:8px 12px;margin-bottom:5px;cursor:pointer;" '
	f'onclick="{_html.escape(onclick)}">'
	f'{dist_html}'
	f'<div style="color:#111827;line-height:1.5;">'
	f'{before_span}'
	f'<span style="font-weight:500;">{_html.escape(sent)}</span>'
	f'{after_span}'
	f'</div>'
	f'</div>'
	)

	# Wrap in collapsible <details> (open by default)
	inner = "".join(cards_parts)
	return (
	f'<details open style="margin-bottom:8px;">'
	f'<summary style="cursor:pointer;font-weight:600;font-size:0.9em;color:#374151;'
	f'margin-bottom:6px;list-style:none;">'
	f'<span style="margin-right:4px;">▸</span>Most Common Opinions</summary>'
	f'{inner}'
	f'</details>'
	)


	def _normalize_polarity(val) -> Optional[str]:
	"""Normalize polarity from any format to 'positive'/'negative'/None."""
	if val == "➕" or val == 2 or val == "positive":
	return "positive"
	if val == "➖" or val == 0 or val == "negative":
	return "negative"
	return None # neutral or unknown


	def format_common_themes(
	sentence_lists: list,
	polarity_map: dict,
	topic_map: dict,
	speaker: dict = None,
	uniqueness: dict = None,
	listener: dict = None,
	) -> str:
	"""
	Common Themes Across Reviews — groups sentences by topic, then shows
	polarity breakdown within each topic.

	A topic is "common" if sentences from ≥2 different reviewers share it.
	Each topic card shows a polarity percentage bar and representative
	sentences per reviewer under each polarity sub-group.

	Falls back to RSA-based generic sentences if no common themes are found.
	"""
	num_reviews = len(sentence_lists)
	if num_reviews < 2:
	return ""

	# --- Step 1: Build per-sentence (topic, polarity) index ---
	# topic_data[topic][polarity][r_idx] = [sentences]
	topic_data = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))

	for r_idx, sl in enumerate(sentence_lists):
	for sent in sl:
	if _should_break_before(sent) or _is_review_header(sent):
	continue
	if len(sent.split()) < 5:
	continue
	topic = topic_map.get(sent)
	polarity = _normalize_polarity(polarity_map.get(sent))
	if topic is None and polarity is None:
	continue
	topic_key = topic if topic else "Other"
	polarity_key = polarity if polarity else "neutral"
	topic_data[topic_key][polarity_key][r_idx].append(sent)

	# --- Step 2: Filter to topics with ≥2 unique reviewers ---
	common_topics = []
	for topic, pol_dict in topic_data.items():
	all_reviewers = set()
	total_sents = 0
	for pol, rev_dict in pol_dict.items():
	all_reviewers.update(rev_dict.keys())
	total_sents += sum(len(s) for s in rev_dict.values())
	if len(all_reviewers) < 2:
	continue
	common_topics.append((topic, len(all_reviewers), total_sents, pol_dict))

	# Prefer topics that have non-neutral polarity entries
	has_sentiment = [t for t in common_topics
	if any(p in t[3] for p in ("positive", "negative"))]
	if len(has_sentiment) >= 1:
	common_topics = has_sentiment

	# Rank by reviewer count (desc), then sentence count (desc); push "Other" to bottom
	common_topics.sort(key=lambda t: (0 if t[0] == "Other" else 1, t[1], t[2]), reverse=True)

	# --- Fallback: Generic Sentences ---
	if not common_topics:
	if not uniqueness:
	return ""
	scores_series = pd.Series(uniqueness)
	n_seed = min(5, len(scores_series))
	fallback = scores_series.nsmallest(n_seed).index.tolist()
	if not fallback:
	return ""

	parts = [
	'<details open style="margin-bottom:10px;border:1px solid #d1d5db;border-radius:8px;'
	'padding:0;overflow:hidden;">',
	'<summary style="cursor:pointer;font-weight:700;font-size:0.92em;color:#1f2937;'
	'padding:10px 14px;list-style:none;background:#f9fafb;border-bottom:1px solid #e5e7eb;'
	'user-select:none;display:flex;align-items:center;gap:6px;">'
	'<span class="collapse-arrow" style="display:inline-block;transition:transform 0.2s;'
	'font-size:0.75em;">▼</span>'
	'Generic Sentences</summary>',
	'<div style="padding:8px 10px;">',
	'<div style="background:#fefce8;border:1px solid #fde68a;border-radius:6px;'
	'padding:8px 12px;margin-bottom:8px;font-size:0.82em;color:#92400e;">'
	'No shared themes detected across reviewers. Showing sentences with lowest '
	'RSA uniqueness score (most generic across reviews).</div>',
	]
	for sent in fallback:
	sent_id = _make_sentence_id(sent)
	badges = _source_badges_html(sent, sentence_lists)
	dist_html = _listener_dist_bars(sent, listener, badges)

	onclick = _click_to_scroll_js(sent_id)
	parts.append(
	f'<div style="border:1px solid #e5e7eb;border-left:3px solid #d1d5db;'
	f'border-radius:6px;padding:6px 10px;margin-bottom:4px;cursor:pointer;" '
	f'onclick="{_html.escape(onclick)}">'
	f'{dist_html}'
	f'<span style="color:#111827;">{_html.escape(sent)}</span>'
	f'</div>'
	)
	parts.append('</div></details>')
	return "".join(parts)

	# --- Step 3: Render topic cards with polarity breakdown ---
	_pol_colors = {"negative": "#ef4444", "positive": "#22c55e", "neutral": "#9ca3af"}
	_pol_labels = {"negative": "Negative", "positive": "Positive", "neutral": "Neutral"}
	# Render order: negative first (concerns), then positive, then neutral
	_pol_order = ["negative", "positive", "neutral"]

	def _pick_best(sents, r_idx):
	"""Pick best sentence by speaker score for this reviewer."""
	r_label = f"R{r_idx + 1}"
	if speaker and r_label in speaker:
	sp = speaker[r_label]
	scored = [(s, sp.get(s, 0.0)) for s in sents]
	scored.sort(key=lambda x: x[1], reverse=True)
	return scored[0][0]
	return sents[0]

	def _sent_row(sent, r_idx):
	"""Render a single sentence row with R# badge and click-to-scroll."""
	r_label = f"R{r_idx + 1}"
	sent_id = _make_sentence_id(sent)
	onclick = _click_to_scroll_js(sent_id)
	return (
	f'<div style="display:flex;align-items:baseline;gap:6px;padding:2px 0;'
	f'padding-left:8px;cursor:pointer;" '
	f'onclick="{_html.escape(onclick)}">'
	f'<span style="background:#f3f4f6;color:#374151;padding:1px 5px;'
	f'border-radius:3px;font-size:0.7em;font-weight:600;flex-shrink:0;">{r_label}</span>'
	f'<span style="color:#374151;font-size:0.85em;line-height:1.4;">{_html.escape(sent)}</span>'
	f'</div>'
	)

	cards = []
	for topic, n_reviewers, total_sents, pol_dict in common_topics:
	border_color = _TOPIC_HTML_COLORS.get(topic, "#d1d5db")
	reviewer_text = (
	f"All {num_reviews} reviewers" if n_reviewers == num_reviews
	else f"{n_reviewers} of {num_reviews} reviewers"
	)

	# --- Polarity percentage bar ---
	pol_counts = {}
	for pol in _pol_order:
	if pol in pol_dict:
	pol_counts[pol] = sum(len(s) for s in pol_dict[pol].values())
	total = sum(pol_counts.values()) or 1

	# Inline polarity bar + labels (compact, on one line)
	_pol_colors_soft = {"negative": "#f87171", "positive": "#4ade80", "neutral": "#d1d5db"}
	bar_segments = []
	bar_labels = []
	for pol in _pol_order:
	cnt = pol_counts.get(pol, 0)
	if cnt == 0:
	continue
	pct = round(cnt / total * 100)
	color = _pol_colors_soft[pol]
	bar_segments.append(
	f'<span style="display:inline-block;height:6px;width:{max(pct, 4)}%;'
	f'background:{color};opacity:0.75;"></span>'
	)
	bar_labels.append(
	f'<span style="font-size:0.7em;color:#6b7280;">'
	f'{pct}% {_pol_labels[pol]}</span>'
	)

	# Skip polarity bar for "Other" — unclassified sentences aren't necessarily related
	if topic == "Other":
	polarity_bar = ""
	else:
	polarity_bar = (
	f'<div style="display:flex;align-items:center;gap:6px;margin-left:8px;">'
	f'<div style="display:flex;width:80px;height:6px;border-radius:3px;overflow:hidden;'
	f'background:#f3f4f6;flex-shrink:0;">'
	+ "".join(bar_segments)
	+ '</div>'
	+ " ".join(bar_labels)
	+ '</div>'
	)

	# --- Header (polarity bar inline after reviewer count) ---
	header = (
	f'<div style="display:flex;align-items:center;gap:6px;flex-wrap:wrap;">'
	f'<span style="font-weight:600;font-size:0.88em;color:#1f2937;">{_html.escape(topic)}</span>'
	f'<span style="color:#9ca3af;font-size:0.75em;">·</span>'
	f'<span style="font-size:0.75em;color:#6b7280;">{reviewer_text}</span>'
	f'{polarity_bar}'
	f'</div>'
	)

	# --- Polarity sub-groups ---
	sub_groups_html = []
	for pol in _pol_order:
	if pol not in pol_dict:
	continue
	rev_dict = pol_dict[pol]
	cnt = pol_counts.get(pol, 0)
	color = _pol_colors[pol]

	sub_header = (
	f'<div style="font-size:0.78em;font-weight:600;color:{color};'
	f'margin:4px 0 2px 0;">'
	f'{_pol_labels[pol]} ({cnt} sentence{"s" if cnt != 1 else ""})</div>'
	)

	rows = []
	for r_idx in sorted(rev_dict.keys()):
	best = _pick_best(rev_dict[r_idx], r_idx)
	rows.append(_sent_row(best, r_idx))

	sub_groups_html.append(sub_header + "".join(rows))

	cards.append(
	f'<div style="border:1px solid #e5e7eb;border-left:3px solid {border_color};'
	f'border-radius:6px;padding:8px 12px;margin-bottom:5px;">'
	f'{header}{"".join(sub_groups_html)}'
	f'</div>'
	)

	inner = "".join(cards)
	return (
	f'<details open style="margin-bottom:10px;border:1px solid #d1d5db;border-radius:8px;'
	f'padding:0;overflow:hidden;">'
	f'<summary style="cursor:pointer;font-weight:700;font-size:0.92em;color:#1f2937;'
	f'padding:10px 14px;list-style:none;background:#f9fafb;border-bottom:1px solid #e5e7eb;'
	f'user-select:none;display:flex;align-items:center;gap:6px;">'
	f'<span class="collapse-arrow" style="display:inline-block;transition:transform 0.2s;'
	f'font-size:0.75em;">▶</span>'
	f'Common Themes Across Reviews</summary>'
	f'<div style="padding:8px 10px;">{inner}</div>'
	f'</details>'
	)


	def format_divergent_cards(
	uniqueness: dict,
	sentence_lists: list,
	listener: dict,
	speaker: dict,
	) -> Dict[int, str]:
	"""
	Most Divergent Opinions — returns per-review HTML dict {review_index: html}.

	For each review, finds the sentences where argmax(L_t(d\|s)) points to that
	review (i.e., the listener assigns it most strongly to that reviewer) AND
	the uniqueness score is above the median. Ranks within each reviewer's set
	by their Speaker score S_t(s\|d) (how characteristic of that reviewer).
	Shows the top 2 per reviewer.
	"""
	if not uniqueness or not listener or not speaker:
	return {}

	num_reviews = len(speaker)
	if num_reviews == 0:
	return {}

	median_u = float(np.median(list(uniqueness.values())))
	review_labels = [f"R{i+1}" for i in range(num_reviews)]

	# Minimum speaker score to suppress generic filler.
	k = max(sum(len(v) for v in speaker.values()) // max(len(speaker), 1), 1)
	min_speaker_score = INFORMATIVENESS_MULTIPLIER / k

	# Group sentences by their argmax review
	grouped: dict = {label: [] for label in review_labels}
	for sent, u_score in uniqueness.items():
	if u_score <= median_u:
	continue
	if sent not in listener:
	continue
	dist = listener[sent]
	if not dist:
	continue
	argmax_label = max(dist, key=lambda k: dist[k])
	if argmax_label not in grouped:
	continue
	s_score = speaker.get(argmax_label, {}).get(sent, 0.0)
	if s_score < min_speaker_score:
	continue
	grouped[argmax_label].append((sent, u_score, s_score))

	# Sort each group by speaker score descending and take top 2
	for label in review_labels:
	grouped[label].sort(key=lambda x: x[2], reverse=True)
	grouped[label] = grouped[label][:2]

	border_color = "#fca5a5"
	result: Dict[int, str] = {}

	for i, label in enumerate(review_labels):
	items = grouped[label]
	if not items:
	continue

	ctx_style = "color:#b0b0b0;font-size:0.85em;font-style:italic;"
	html_parts = [
	'<div style="margin-top:10px;margin-bottom:6px;font-weight:600;font-size:0.82em;color:#7f1d1d;">'
	f'Unique Points in This Review</div>'
	]
	for sent, u_score, s_score in items:
	sent_id = _make_sentence_id(sent)
	context_before, context_after = _get_context(sent, sentence_lists)

	dom_pct = 0
	if sent in listener:
	dom_pct = int(round(max(listener[sent].values(), default=0.0) * 100))
	uniqueness_badge = (
	f'<span style="background:#fee2e2;color:#991b1b;padding:2px 6px;'
	f'border-radius:4px;font-size:0.7em;font-weight:600;display:inline-block;margin-bottom:3px;">'
	f'{dom_pct}% listener share</span>'
	)

	onclick = _click_to_scroll_js(sent_id, "#ef4444")

	before_span = f'<span style="{ctx_style}">...{_html.escape(context_before)} </span>' if context_before else ""
	after_span = f'<span style="{ctx_style}"> {_html.escape(context_after)}...</span>' if context_after else ""

	html_parts.append(
	f'<div style="border:1px solid #e5e7eb;border-left:3px solid {border_color};'
	f'border-radius:6px;padding:8px 12px;margin-bottom:5px;cursor:pointer;" '
	f'onclick="{_html.escape(onclick)}">'
	f'{uniqueness_badge}'
	f'<div style="color:#111827;line-height:1.5;">'
	f'{before_span}'
	f'<span style="font-weight:500;">{_html.escape(sent)}</span>'
	f'{after_span}'
	f'</div>'
	f'</div>'
	)

	result[i] = "".join(html_parts)

	return result


	def render_agreement_html(
	sentences: List[str],
	uniqueness: Dict[str, float],
	listener: Dict[str, Dict[str, float]],
	speaker: Dict[str, Dict[str, float]],
	num_reviews: int,
	label: str = "Agreement",
	wrap: bool = False,
	) -> str:
	"""
	Custom HTML renderer for Agreement mode (replaces gr.HighlightedText).

	Each sentence gets:
	- Continuous opacity from score magnitude (strongest opinions most vivid)
	- CSS hover tooltip showing L_t(d\|s): "R1 (40%) · R2 (45%)"
	- Informativeness dimming for generic common filler
	- Sentence ID for click-to-scroll from summary cards
	"""
	if not sentences:
	return ""

	# Color scale legend bar
	legend_html = (
	'<div style="display:flex;align-items:center;gap:8px;margin-bottom:8px;'
	'font-size:0.75em;color:#6b7280;">'
	'<span style="background:linear-gradient(to right,rgba(59,130,246,0.7),rgba(209,213,219,0.3),rgba(239,68,68,0.7));'
	'width:120px;height:8px;border-radius:4px;display:inline-block;"></span>'
	'<span>← Common  \|  Unique →</span>'
	'</div>'
	)

	parts = []
	parts.append(legend_html)
	parts.append('<div style="line-height:1.8;font-size:0.95em;margin-top:6px;">')

	# Compute informativeness threshold: 2 / K (twice uniform baseline)
	k = max(len(uniqueness), 1)
	info_threshold = INFORMATIVENESS_MULTIPLIER / k

	for idx, sent in enumerate(sentences):
	# Paragraph break detection
	if idx > 0 and _should_break_before(sent):
	parts.append('<br>')

	sent_id = _make_sentence_id(sent)
	score = uniqueness.get(sent)

	# Header styling (Rating:, Experience:, etc.)
	header_style = "font-weight:600;color:#92400e;" if _is_review_header(sent) else ""

	if score is None or abs(score) < HIGHLIGHT_THRESHOLD:
	# No highlight
	parts.append(f'<span id="{sent_id}" style="{header_style}">{_html.escape(sent)} </span>')
	continue

	# --- Color and opacity ---
	if score < 0:
	# Common: blue — opacity from listener ENTROPY so more balanced = more vivid.
	r, g, b = 59, 130, 246
	if listener and sent in listener:
	dist = listener[sent]
	max_prob = max(dist.values(), default=0.0)
	max_entropy = math.log(max(num_reviews, 2))
	entropy = sum(-p * math.log(p) for p in dist.values() if p > 0)

	# If listener is highly concentrated on one reviewer (>70%), the RSA
	# uniqueness score and listener disagree — trust the listener and
	# suppress blue. This prevents e.g. R2 91% sentences from appearing blue.
	if max_prob > LISTENER_CONCENTRATION_THRESHOLD:
	opacity = 0.0
	else:
	opacity = (entropy / max_entropy) ** AGREEMENT_AMP_COMMON if max_entropy > 0 else 0.0
	else:
	opacity = abs(score) ** AGREEMENT_AMP_COMMON

	# Informativeness dimming for generic filler
	if speaker:
	info = compute_informativeness(sent, speaker, num_reviews)
	if info < info_threshold:
	opacity *= 0.3
	else:
	# Unique: red — opacity from score magnitude (as before)
	r, g, b = 239, 68, 68
	opacity = abs(score) ** AGREEMENT_AMP_UNIQUE

	bg_color = f"rgba({r},{g},{b},{opacity:.3f})"

	# --- Tooltip content from L_t(d\|s) ---
	tooltip_text = ""
	if listener and sent in listener:
	dist = listener[sent]
	parts_tooltip = " · ".join(
	f"{lbl} {int(round(p * 100))}%"
	for lbl, p in sorted(dist.items())
	)
	tooltip_text = f"{parts_tooltip}"
	else:
	tooltip_text = f"Score: {score:+.2f}"

	# Inline JS positions the tooltip near the cursor using fixed positioning
	hover_js = (
	"var t=this.querySelector('.rsa-tooltip');var r=this.getBoundingClientRect();"
	"t.style.display='block';"
	"t.style.left=Math.min(r.left,window.innerWidth-290)+'px';"
	"t.style.top=(r.top-t.offsetHeight-6)+'px';"
	)
	leave_js = "this.querySelector('.rsa-tooltip').style.display='none';"
	parts.append(
	f'<span id="{sent_id}" class="rsa-sentence" style="background:{bg_color};" '
	f'onmouseenter="{hover_js}" onmouseleave="{leave_js}">'
	f'{_html.escape(sent)} '
	f'<span class="rsa-tooltip">{_html.escape(tooltip_text)}</span>'
	f'</span>'
	)

	parts.append("</div>") # close sentence container
	content = "".join(parts)
	if wrap:
	return _wrap_review_card(label, content, collapsible=True)
	elif label:
	return _wrap_review_card(label, content, collapsible=False)
	return content


	def build_review_card(
	label: str,
	*,
	review_items: list = None,
	mode: str = "plain",
	sentences: List[str] = None,
	uniqueness: Dict = None,
	listener: dict = None,
	speaker: dict = None,
	num_reviews: int = 0,
	divergent_html: str = "",
	rebuttal_html: str = "",
	collapsible: bool = True,
	) -> str:
	"""Unified review card builder — single entry point for both tabs.

	For plain/polarity/topic: pass review_items + mode.
	For agreement: pass sentences + RSA dicts (uniqueness, listener, speaker, num_reviews).
	Optional divergent_html and rebuttal_html are appended inside the card.
	"""
	if sentences is not None:
	inner = render_agreement_html(
	sentences, uniqueness or {}, listener, speaker,
	num_reviews=num_reviews, label="",
	)
	elif review_items is not None:
	inner = render_review_html(review_items, mode=mode, label="")
	else:
	inner = ""
	return _wrap_review_card(label, f"{inner}{divergent_html}{rebuttal_html}", collapsible=collapsible)


	# Auto-detect the preprocessed dataset CSV
	def _find_preprocessed_csv() -> Path:
	"""Find the most recent preprocessed_scored_reviews_*.csv in the data dir."""
	data_dir = BASE_DIR / "data"
	candidates = sorted(data_dir.glob("preprocessed_scored_reviews_*.csv"))
	if candidates:
	return candidates[-1] # Last alphabetically = latest year range
	return data_dir / "preprocessed_scored_reviews.csv"


	def load_scored_reviews_with_rebuttals(csv_path: Path = None):
	"""Load dataset with rebuttal metadata. Auto-detects CSV if no path given."""
	if csv_path is None:
	csv_path = _find_preprocessed_csv()

	if not csv_path.exists():
	return [], pd.DataFrame()

	df = pd.read_csv(csv_path)
	tqdm.pandas(desc="Parsing scored_dict")
	df["scored_dict"] = df["scored_dict"].progress_apply(ast.literal_eval)

	# Parse metadata column
	if "metadata" in df.columns:
	df["metadata"] = df["metadata"].progress_apply(
	lambda x: ast.literal_eval(x) if pd.notna(x) and x != '{}' else {}
	)
	else:
	df["metadata"] = [{}] * len(df)

	years = df["year"].tolist()
	return years, df

	years_new, df_new = load_scored_reviews_with_rebuttals()

	if df_new.empty:
	raise FileNotFoundError(
	f"No preprocessed dataset found. Run the pipeline first (./pipeline/process_new_data.sh)."
	)

	# Use new data only
	years, all_scored_reviews_df = years_new, df_new

	# Build a {forum_url: paper_title} lookup from raw data CSVs (processed CSVs lack paper_title)
	def _load_paper_titles() -> dict:
	titles = {}
	for csv in sorted((BASE_DIR / "data").glob("all_reviews_*.csv")):
	try:
	df = pd.read_csv(csv, usecols=["id", "paper_title"])
	for _, row in df.iterrows():
	if row["id"] not in titles and pd.notna(row.get("paper_title", "")):
	titles[row["id"]] = str(row["paper_title"])
	except Exception:
	pass
	return titles

	_paper_titles = _load_paper_titles()
	year_range_str = f"{min(years)}–{max(years)}" if years else "N/A"

	# -----------------------------------
	# Pre-processed Tab
	# -----------------------------------

	def get_preprocessed_scores(year):
	scored_reviews = all_scored_reviews_df[all_scored_reviews_df["year"] == year]["scored_dict"].iloc[0]
	return scored_reviews


	def get_preprocessed_metadata(year):
	row = all_scored_reviews_df[all_scored_reviews_df["year"] == year]
	if "metadata" in row.columns and not row.empty:
	meta = row["metadata"].iloc[0]
	return meta if isinstance(meta, dict) else {}
	return {}


	# -----------------------------------
	# Interactive Tab Configuration
	# -----------------------------------

	# Define the manual color map for topics
	topic_color_map = {
	"Substance": "#cce0ff", # lighter blue
	"Clarity": "#e6ee9c", # lighter yellow-green
	"Soundness/Correctness": "#ffcccc", # lighter red
	"Originality": "#d1c4e9", # lighter purple
	"Motivation/Impact": "#b2ebf2", # lighter teal
	"Meaningful Comparison": "#fff9c4", # lighter yellow
	"Replicability": "#c8e6c9", # lighter green
	}


	# GLIMPSE Home/Description Page
	glimpse_description = f"""
	# ReView: A Tool for Visualizing and Analyzing Scientific Reviews
	## Overview
	ReView is a visualization tool designed to assist area chairs and researchers in efficiently analyzing scholarly reviews. The interface offers two main ways to explore scholarly reviews:
	- Pre-Processed Reviews: Explore real peer reviews from ICLR ({year_range_str}) with structured visualizations of sentiment, topics, and reviewer agreement.
	- Interactive Tab: Enter your own reviews and view them analyzed in real time using the same NLP-powered highlighting options.
	All reviews are shown in their original, unaltered form, with visual overlays to help identify key insights such as disagreements, sentiment and common themes—reducing cognitive load and scrolling effort.
	---
	## Key Features
	- Traceability and Transparency: The tool preserves the original text of each review and overlays highlights for key aspects (e.g., sentiment, topic, agreement), allowing area chairs to trace back every insight to its source without modifying or summarizing the content.
	- Structured Overview: All reviews are displayed in one interface and with radio buttons, one can navigate from one highlighting option to the other.
	- Interactive: The tool allows users to input their own reviews and, within seconds, view them annotated with highlighted aspects
	---
	## Highlighting Options
	- Agreement: Identifies both shared and conflicting points across reviews, helping to surface consensus and disagreement.
	- Polarity: Highlights positive and negative sentiments within the reviews to reveal tone and stance.
	- Topic: Organizes the review sentences by their discussed topics, ensuring coverage of diverse reviewer perspectives and improving clarity.
	---
	### How to Use ReView
	ReView offers two main ways to explore peer reviews: using pre-processed reviews or by entering your own.
	#### Pre-Processed Reviews Tab
	Use this tab to explore reviews from ICLR ({year_range_str}):
	1. Select a conference year from the dropdown menu on the right.
	2. Navigate between submissions using the Next and Previous buttons on the left.
	3. Choose a highlighting view using the radio buttons:
	- Original: Displays unmodified review text.
	- Agreement: Highlights consensus points in red and disagreements in purple.
	- Polarity: Highlights positive sentiment in green and negative sentiment in red.
	- Topic: Highlights comments by discussion topic using color-coded labels.
	#### Interactive Tab
	Use this tab to analyze your own review text:
	1. Enter 2–6 reviews in the input fields. Use the ➕ Add Review button to add up to 6 reviews.
	2. Click "Process" to analyze the input (average processing time: ~42 seconds).
	3. Explore the results using the same highlighting options as above (Agreement, Polarity, Topic).
	"""


	EXAMPLES = [
	"The paper gives really interesting insights on the topic of transfer learning. It is well presented and the experiment are extensive. I believe the authors missed Jane and al 2021. In addition, I think, there is a mistake in the math.",
	"The paper gives really interesting insights on the topic of transfer learning. It is well presented and the experiment are extensive. Some parts remain really unclear and I would like to see a more detailed explanation of the proposed method.",
	"The paper gives really interesting insights on the topic of transfer learning. It is not well presented and lack experiments. Some parts remain really unclear and I would like to see a more detailed explanation of the proposed method.",
	]

	PROCESSING_TIMER_HTML = """
	<div style="display:flex;align-items:center;gap:12px;padding:16px;background:#f0f4ff;border-radius:8px;border:1px solid #c7d2fe;margin:8px 0;">
	<div style="width:24px;height:24px;border:3px solid #e0e7ff;border-top:3px solid #4f46e5;border-radius:50%;animation:procspin 1s linear infinite;flex-shrink:0;"></div>
	<div>
	<div style="font-weight:600;color:#312e81;">Processing reviews...</div>
	</div>
	</div>
	<style>@keyframes procspin{to{transform:rotate(360deg);}}</style>
	"""

	FETCHING_HTML = """
	<div style="display:flex;align-items:center;gap:12px;padding:16px;background:#f0f4ff;border-radius:8px;border:1px solid #c7d2fe;margin:8px 0;">
	<div style="width:24px;height:24px;border:3px solid #e0e7ff;border-top:3px solid #4f46e5;border-radius:50%;animation:procspin 1s linear infinite;flex-shrink:0;"></div>
	<div>
	<div style="font-weight:600;color:#312e81;">Fetching reviews from OpenReview...</div>
	</div>
	</div>
	<style>@keyframes procspin{to{transform:rotate(360deg);}}</style>
	"""

	POLARITY_PROGRESS_HTML = """
	<div style="padding:10px 16px;background:#f0fff4;border-radius:8px;border:1px solid #bbf7d0;margin:0;">
	<div style="display:flex;align-items:center;gap:10px;">
	<div style="width:18px;height:18px;border:3px solid #dcfce7;border-top:3px solid #16a34a;border-radius:50%;animation:procspin 1s linear infinite;flex-shrink:0;"></div>
	<span style="font-weight:600;color:#14532d;font-size:0.9em;white-space:nowrap;">Computing polarity & topic... </span>
	<div style="flex:1;background:#dcfce7;border-radius:4px;height:6px;overflow:hidden;">
	<div style="background:linear-gradient(90deg,#4ade80,#16a34a);height:100%;border-radius:4px;animation:agrslide 2s ease-in-out infinite;"></div>
	</div>
	</div>
	</div>
	"""

	AGREEMENT_PROGRESS_HTML = """
	<div style="padding:10px 16px;background:#f0f4ff;border-radius:8px;border:1px solid #c7d2fe;margin:0;">
	<div style="display:flex;align-items:center;gap:10px;">
	<div style="width:18px;height:18px;border:3px solid #e0e7ff;border-top:3px solid #4f46e5;border-radius:50%;animation:procspin 1s linear infinite;flex-shrink:0;"></div>
	<span style="font-weight:600;color:#312e81;font-size:0.9em;white-space:nowrap;">Computing agreement in background...</span>
	<div style="flex:1;background:#e0e7ff;border-radius:4px;height:6px;overflow:hidden;">
	<div style="background:linear-gradient(90deg,#818cf8,#4f46e5);height:100%;border-radius:4px;animation:agrslide 2s ease-in-out infinite;"></div>
	</div>
	</div>
	</div>
	"""


	def _status_html(msg, kind="success"):
	"""Generate styled HTML for status messages."""
	styles = {
	"success": ("✅", "#f0fdf4", "#16a34a", "#166534", "#bbf7d0"),
	"error": ("❌", "#fef2f2", "#dc2626", "#991b1b", "#fecaca"),
	"warning": ("⚠️", "#fffbeb", "#d97706", "#92400e", "#fde68a"),
	}
	icon, bg, _, text_color, border_color = styles.get(kind, styles["success"])
	return f'''<div style="display:flex;align-items:center;gap:10px;padding:12px 16px;background:{bg};border-radius:8px;border:1px solid {border_color};margin:8px 0;">
	<span style="font-size:1.2em;">{icon}</span>
	<span style="color:{text_color};font-weight:500;">{msg}</span>
	</div>'''

	# ===== INTERACTIVE TAB: GLOBAL PROCESSOR INITIALIZATION =====
	# Initialize once at module load to avoid reloading models
	from interface.interactive_processor import InteractiveReviewProcessor
	from dependencies.sentence_filter import (
	is_noise_sentence, filter_and_clean_sentences, strip_header_prefix,
	HIGHLIGHT_THRESHOLD, compute_informativeness,
	)
	_interactive_processor = None

	def get_interactive_processor():
	"""Lazy-load the processor to avoid duplicate model loading."""
	global _interactive_processor
	if _interactive_processor is None:
	device = "cuda" if torch.cuda.is_available() else "cpu"
	_interactive_processor = InteractiveReviewProcessor(device=device)
	return _interactive_processor


	@_gpu
	def _gpu_predict_polarity_topic(sentences: List[str]) -> Tuple[Dict, Dict]:
	"""Run polarity + topic inference on GPU. Decorated with @spaces.GPU for ZeroGPU."""
	processor = get_interactive_processor()
	processor.ensure_device()
	polarity_map = processor.predict_polarity(sentences)
	topic_map = processor.predict_topic(sentences)
	return polarity_map, topic_map


	@_gpu
	def _gpu_predict_rsa(active_texts: List[str], progress_callback=None) -> Dict:
	"""Run RSA inference on GPU. Decorated with @spaces.GPU for ZeroGPU."""
	processor = get_interactive_processor()
	processor.ensure_device()
	return processor.predict_rsa_full(*active_texts, progress_callback=progress_callback)


	MAX_INTERACTIVE_REVIEWS = 6


	def fetch_openreview_reviews(link: str):
	"""
	Fetch reviews from OpenReview link and populate the textboxes.

	Returns:
	Tuple of (review1..6, title, status_html)
	"""
	print(f"\n[DEMO] fetch_openreview_reviews called with link: {link}")

	if not link.strip():
	raise gr.Error("Please paste a valid OpenReview link before fetching.")

	try:
	from interface.interactive_processor import fetch_reviews_from_openreview_link
	reviews, title, rebuttal = fetch_reviews_from_openreview_link(link)
	print(f"[DEMO] Got {len(reviews)} reviews from fetch function")

	while len(reviews) < MAX_INTERACTIVE_REVIEWS:
	reviews.append("")
	reviews = reviews[:MAX_INTERACTIVE_REVIEWS]

	num_reviews = len([r for r in reviews if r.strip()])
	status = _status_html(f"Fetched {num_reviews} reviews for: {title}", "success")
	return (*reviews, title, rebuttal, status)

	except gr.Error:
	raise
	except ValueError as e:
	raise gr.Error(str(e))
	except Exception as e:
	error_msg = str(e)
	print(f"[DEMO] Exception caught: {type(e).__name__}: {error_msg}")

	if "openreview" in error_msg.lower():
	suggestion = " Try: pip install openreview-py"
	elif "connection" in error_msg.lower() or "timeout" in error_msg.lower():
	suggestion = " Check your internet connection."
	else:
	suggestion = ""

	raise gr.Error(f"{error_msg}{suggestion}")


	def _parse_rebuttal_json(rebuttal: str) -> Optional[list]:
	"""Parse rebuttal JSON string, returning list of items or None."""
	if not rebuttal or not rebuttal.strip():
	return None
	try:
	items = json.loads(rebuttal)
	return items if items else None
	except (json.JSONDecodeError, TypeError, AttributeError):
	return None


	_REBUTTAL_PER_REVIEW_STYLE = (
	"margin-top:8px;margin-bottom:12px;border-radius:6px;overflow:hidden;"
	"border:1px solid #fde68a;background:#fffef5;"
	)
	_REBUTTAL_GENERAL_STYLE = (
	"margin-top:16px;border-radius:8px;overflow:hidden;"
	"border:1px solid #fde68a;"
	)


	def format_rebuttal_plain(text: str) -> str:
	"""Format a plain text rebuttal as collapsible HTML.
	For pre-processed data where each review has its own rebuttal string."""
	if not text or not text.strip():
	return ""
	return (
	f'<details style="{_REBUTTAL_PER_REVIEW_STYLE}">'
	'<summary style="padding:10px 14px;cursor:pointer;font-size:0.75em;color:#92400e;'
	'font-weight:600;list-style:none;display:flex;align-items:center;gap:6px;">'
	'<span style="transition:transform 0.2s;">▶</span> Author Response</summary>'
	'<div style="padding:10px 14px;">'
	f'<div style="white-space:pre-wrap;color:#1f2937;font-size:0.85em;line-height:1.5;">{text}</div>'
	'</div></details>'
	)


	def format_rebuttal_for_review(rebuttal: str, review_num: int) -> str:
	"""Format rebuttals that reply to a specific review number."""
	if not rebuttal or not rebuttal.strip():
	return ""

	items = _parse_rebuttal_json(rebuttal)
	if items is not None:
	# Filter to only rebuttals for this review
	relevant = [item for item in items if item.get("reply_to") == review_num]
	if not relevant:
	return ""

	response_parts = []
	for i, item in enumerate(relevant):
	text = item.get("text", "").strip()
	if not text:
	continue

	response_parts.append(
	f'<div style="padding:10px 14px;">'
	f'<div style="white-space:pre-wrap;color:#1f2937;font-size:0.85em;line-height:1.5;">{text}</div>'
	f'</div>'
	)

	if not response_parts:
	return ""

	return (
	f'<details style="{_REBUTTAL_PER_REVIEW_STYLE}">'
	f'<summary style="padding:10px 14px;cursor:pointer;font-size:0.75em;color:#92400e;'
	f'font-weight:600;list-style:none;display:flex;align-items:center;gap:6px;">'
	f'<span style="transition:transform 0.2s;">▶</span> Author Response</summary>'
	+ "".join(response_parts)
	+ "</details>"
	)

	# Plain text - show under first review only
	if review_num == 1:
	text = rebuttal.strip()
	return (
	f'<details style="{_REBUTTAL_PER_REVIEW_STYLE}">'
	f'<summary style="padding:10px 14px;cursor:pointer;font-size:0.75em;color:#92400e;'
	f'font-weight:600;list-style:none;display:flex;align-items:center;gap:6px;">'
	f'<span style="transition:transform 0.2s;">▶</span> Author Response</summary>'
	f'<div style="padding:10px 14px;">'
	f'<div style="white-space:pre-wrap;color:#1f2937;font-size:0.85em;line-height:1.5;">{text}</div>'
	f'</div></details>'
	)
	return ""


	def format_general_rebuttals(rebuttal: str) -> str:
	"""Format general rebuttals (those not replying to a specific review)."""
	if not rebuttal or not rebuttal.strip():
	return ""

	HEADER_STYLE = "background:#fffbeb;padding:10px 16px;border-bottom:1px solid #fde68a;display:flex;align-items:center;gap:8px;"
	TITLE_STYLE = "font-weight:600;color:#92400e;"

	items = _parse_rebuttal_json(rebuttal)
	if items is not None:
	# Filter to only general rebuttals (no specific reply_to)
	general = [item for item in items if item.get("reply_to") is None]
	if not general:
	return ""

	response_parts = []
	for i, item in enumerate(general):
	text = item.get("text", "").strip()
	if not text:
	continue

	bg = "white" if i % 2 == 0 else "#fafafa"
	sep = "border-top:1px solid #fde68a;" if i > 0 else ""
	response_parts.append(
	f'<div style="padding:14px 16px;background:{bg};{sep}">'
	f'<div style="white-space:pre-wrap;color:#1f2937;font-size:0.9em;line-height:1.6;">{text}</div>'
	f'</div>'
	)

	if not response_parts:
	return ""

	count_label = f"{len(response_parts)} general response{'s' if len(response_parts) > 1 else ''}"
	return (
	f'<details style="{_REBUTTAL_GENERAL_STYLE}">'
	f'<summary style="{HEADER_STYLE}cursor:pointer;list-style:none;">'
	f'<span style="font-size:1.1em;">💬</span>'
	f'<span style="{TITLE_STYLE}">General Author Response</span>'
	f'<span style="margin-left:auto;font-size:0.8em;color:#78716c;">{count_label}</span>'
	f'</summary>'
	+ "".join(response_parts) +
	'</details>'
	)

	# Plain text - treat as general response
	text = rebuttal.strip()
	return (
	f'<details style="{_REBUTTAL_GENERAL_STYLE}">'
	f'<summary style="{HEADER_STYLE}cursor:pointer;list-style:none;">'
	f'<span style="font-size:1.1em;">💬</span>'
	f'<span style="{TITLE_STYLE}">General Author Response</span></summary>'
	f'<div style="padding:14px 16px;background:white;">'
	f'<div style="white-space:pre-wrap;color:#1f2937;font-size:0.9em;line-height:1.6;">{text}</div>'
	f'</div></details>'
	)


	def process_interactive_reviews_fast(text1: str, text2: str, text3: str, text4: str, text5: str, text6: str, focus: str, rebuttal_str: str = "", thread_state=None, progress=gr.Progress()) -> Tuple:
	"""
	Fast processing: Polarity + Topic only (~3-5 sec on CPU).
	RSA (agreement) runs in background.
	If thread_state is provided, polarity+topic was already started during page transition —
	just wait for it instead of re-computing.
	"""
	import time as _time
	from dependencies.Glimpse_tokenizer import glimpse_tokenizer

	t_start = _time.time()

	# Check if polarity+topic was already started in background by _show_raw_and_switch
	# thread_state is a string key into _thread_states dict (avoids pickling issues with ZeroGPU)
	_bg_state = _thread_states.pop(thread_state, None) if isinstance(thread_state, str) else None
	if _bg_state and _bg_state.get("thread"):
	bg_thread = _bg_state["thread"]
	_result = _bg_state["result"]
	sentence_lists = _bg_state["sentence_lists"]
	active_texts = _bg_state["active_texts"]
	all_sentences = _bg_state["all_sentences"]

	progress(0.30, desc="Predicting polarity and topics...")

	# Wait for the background thread (may already be done!)
	bg_thread.join()

	if _result.get("error"):
	raise _result["error"]

	polarity_map = _result["polarity"]
	topic_map = _result["topic"]
	print(f"[TIMING] Polarity+Topic (from early-start thread): {_time.time() - t_start:.1f}s wait")
	else:
	# Fallback: compute from scratch (e.g. if thread_state was not passed)
	all_texts = [text1, text2, text3, text4, text5, text6]
	active_texts = [t for t in all_texts if t and t.strip()]

	if len(active_texts) < 2:
	raise ValueError("Please enter at least two reviews")

	progress(0.0, desc="Loading models...")
	t0 = _time.time()
	processor = get_interactive_processor()
	print(f"[TIMING] get_interactive_processor: {_time.time() - t0:.1f}s")

	progress(0.10, desc="Tokenizing reviews...")
	t0 = _time.time()
	sentence_lists = [[s for s in glimpse_tokenizer(t) if s.strip()] for t in active_texts]
	sentence_lists = [sl for sl in sentence_lists if sl]
	print(f"[TIMING] Tokenization: {_time.time() - t0:.1f}s ({sum(len(sl) for sl in sentence_lists)} total sentences)")

	if len(sentence_lists) < 2:
	raise ValueError("At least two reviews must have valid sentences")

	t0 = _time.time()
	all_sentences = filter_and_clean_sentences(
	list(set(s for sl in sentence_lists for s in sl))
	)
	print(f"[TIMING] filter_and_clean: {_time.time() - t0:.1f}s ({len(all_sentences)} unique sentences)")

	progress(0.30, desc="Predicting polarity and topics...")
	t0 = _time.time()
	polarity_map, topic_map = _gpu_predict_polarity_topic(all_sentences)
	print(f"[TIMING] Polarity+Topic (sequential): {_time.time() - t0:.1f}s")

	print(f"[TIMING] Fast processing total: {_time.time() - t_start:.1f}s")

	# Step 5: Format results as HTML with collapsible review cards
	progress(0.90, desc="Formatting results...")

	# Pre-compute per-review rebuttal HTML (embedded inside each card, like pre-processed tab)
	rebuttal_htmls = [format_rebuttal_for_review(rebuttal_str or "", i + 1) for i in range(MAX_INTERACTIVE_REVIEWS)]

	# Build per-review outputs as HTML (same format as pre-processed tab)
	none_out, agree_out, polar_out, topic_out = [], [], [], []
	for i in range(MAX_INTERACTIVE_REVIEWS):
	if i < len(sentence_lists):
	review_label = f"Review {i + 1}"
	reb = rebuttal_htmls[i]
	# Build (sentence, metadata) tuples for render_review_html
	plain_items = [(s, {}) for s in sentence_lists[i]]
	polar_items = [(s, {"polarity": polarity_map.get(s)}) for s in sentence_lists[i]]
	topic_items = [(s, {"topic": topic_map.get(s)}) for s in sentence_lists[i]]

	none_html = build_review_card(review_label, review_items=plain_items, mode="plain", rebuttal_html=reb)
	polar_html = build_review_card(review_label, review_items=polar_items, mode="polarity", rebuttal_html=reb)
	topic_html = build_review_card(review_label, review_items=topic_items, mode="topic", rebuttal_html=reb)

	none_out.append(gr.update(visible=True, value=none_html))
	agree_out.append(gr.update(visible=False, value=""))
	polar_out.append(gr.update(visible=False, value=polar_html))
	topic_out.append(gr.update(visible=False, value=topic_html))
	else:
	none_out.append(gr.update(visible=False, value=""))
	agree_out.append(gr.update(visible=False, value=""))
	polar_out.append(gr.update(visible=False, value=""))
	topic_out.append(gr.update(visible=False, value=""))

	progress(1.0, desc="Done! Computing agreement in background...")

	# Store sentence lists and texts in state for async RSA
	rsa_state = {
	"sentence_lists": sentence_lists,
	"active_texts": active_texts,
	"polarity_map": polarity_map,
	"topic_map": topic_map,
	"rebuttal_str": rebuttal_str or "",
	}

	return (
	*none_out,
	*agree_out,
	"", "", # most_common, most_unique (will be filled when RSA done)
	*polar_out,
	*topic_out,
	len(sentence_lists), # active review count
	rsa_state, # state for async RSA
	)


	def _fmt_time(sec: float) -> str:
	"""Format seconds as MM:SS or HH:MM:SS like tqdm."""
	if sec is None:
	return "?"
	sec = int(sec)
	if sec < 3600:
	return f"{sec // 60:02d}:{sec % 60:02d}"
	return f"{sec // 3600}:{(sec % 3600) // 60:02d}:{sec % 60:02d}"


	def _agreement_progress_html(pct: int, done: int, total: int,
	eta_sec: float = None, elapsed: float = None,
	rate: float = None) -> str:
	"""Progress bar HTML for the agreement computation, tqdm-style [elapsed<eta, rate s/it]."""
	if done > 0 and elapsed is not None:
	info = f"{done}/{total} [{_fmt_time(elapsed)}<{_fmt_time(eta_sec)}, {rate:.1f}s/it]"
	else:
	info = f"{done}/{total}"
	return f"""
	<div style="padding:10px 16px;background:#f0f4ff;border-radius:8px;border:1px solid #c7d2fe;margin:0;">
	<div style="display:flex;align-items:center;gap:10px;">
	<span style="font-weight:600;color:#312e81;font-size:0.9em;white-space:nowrap;">Computing agreement: {pct}%</span>
	<div style="flex:1;background:#e0e7ff;border-radius:4px;height:6px;overflow:hidden;">
	<div style="background:linear-gradient(90deg,#818cf8,#4f46e5);height:100%;width:{pct}%;border-radius:4px;transition:width 0.4s ease;"></div>
	</div>
	<span style="font-size:0.78em;color:#6b7280;white-space:nowrap;">{info}</span>
	</div>
	</div>
	"""


	def compute_rsa_in_background(rsa_state: Dict, current_focus: str):
	"""
	Generator: streams real progress to agreement_progress_html while RSA runs in a thread,
	then yields final agreement HTML + summary cards.
	Outputs: agreement_text1..6, most_common, most_divergent, agreement_progress_html, focus_radio
	"""
	_empty = tuple([gr.update(visible=False, value="")] * (MAX_INTERACTIVE_REVIEWS + 2)
	+ [gr.update(visible=False, value=""),
	gr.update(choices=["No Highlighting", "Polarity", "Topic", "Agreement"], interactive=True)])

	if not rsa_state or not rsa_state.get("sentence_lists"):
	yield _empty
	return

	processor = get_interactive_processor()
	sentence_lists = rsa_state["sentence_lists"]
	active_texts = rsa_state["active_texts"]

	# Shared progress state updated by progress_callback from the RSA thread
	_prog = {"done": 0, "total": 1, "result": None, "error": None, "start_time": None}

	def _progress_callback(done, total):
	if _prog["start_time"] is None:
	_prog["start_time"] = time.time()
	_prog["done"] = done
	_prog["total"] = total

	def _run():
	try:
	_prog["result"] = processor.predict_rsa_full(*active_texts, progress_callback=_progress_callback)
	except Exception as e:
	_prog["error"] = e

	t = threading.Thread(target=_run, daemon=True)
	t.start()

	# Yield progress updates while RSA thread is running
	_no_op_8 = [gr.update()] * (MAX_INTERACTIVE_REVIEWS + 2)
	while t.is_alive():
	done, total = _prog["done"], _prog["total"]
	pct = int(done / total * 100) if total > 0 else 0
	# tqdm-style ETA: elapsed/done * remaining
	eta_sec = None
	elapsed = None
	rate = None
	t0 = _prog.get("start_time")
	if t0 and done > 0:
	elapsed = time.time() - t0
	rate = elapsed / done # seconds per batch
	eta_sec = rate * (total - done)
	yield (*_no_op_8, gr.update(visible=True, value=_agreement_progress_html(pct, done, total, eta_sec, elapsed, rate)), gr.update())
	time.sleep(0.4)

	t.join()

	if _prog["error"]:
	print(f"[RSA ERROR] {type(_prog['error']).__name__}: {_prog['error']}")
	error_msg = f"❌ Agreement computation failed: {str(_prog['error'])[:100]}"
	yield (
	[gr.update(visible=False, value="")] MAX_INTERACTIVE_REVIEWS,
	error_msg, "",
	gr.update(visible=False, value=""),
	gr.update(choices=["No Highlighting", "Polarity", "Topic", "Agreement"], interactive=True),
	)
	return

	rsa_result = _prog["result"] or {}
	uniqueness = rsa_result.get("uniqueness", {})
	listener = rsa_result.get("listener", {})
	speaker = rsa_result.get("speaker", {})

	polarity_map = rsa_state.get("polarity_map", {})
	topic_map = rsa_state.get("topic_map", {})
	most_common_text = format_common_themes(
	sentence_lists, polarity_map, topic_map,
	speaker=speaker, uniqueness=uniqueness, listener=listener,
	)

	if uniqueness:
	divergent_per_review = format_divergent_cards(uniqueness, sentence_lists, listener, speaker)
	else:
	divergent_per_review = {}

	show_agreement = current_focus in ("Agreement", "Agreement (Processing)")
	num_reviews = len(active_texts)

	# Pre-compute per-review rebuttal HTML (embedded inside agreement cards)
	rebuttal_str = rsa_state.get("rebuttal_str", "")
	rebuttal_htmls = [format_rebuttal_for_review(rebuttal_str, i + 1) for i in range(MAX_INTERACTIVE_REVIEWS)]

	agree_out = []
	for i in range(MAX_INTERACTIVE_REVIEWS):
	if i < len(sentence_lists):
	html_val = build_review_card(
	f"Agreement in Review {i + 1}",
	sentences=sentence_lists[i],
	uniqueness=uniqueness, listener=listener, speaker=speaker,
	num_reviews=num_reviews,
	divergent_html=divergent_per_review.get(i, ""),
	rebuttal_html=rebuttal_htmls[i],
	)
	agree_out.append(gr.update(visible=show_agreement, value=html_val))
	else:
	agree_out.append(gr.update(visible=False, value=""))

	yield (
	*agree_out,
	most_common_text, "",
	gr.update(visible=False, value=""),
	gr.update(choices=["No Highlighting", "Polarity", "Topic", "Agreement"], interactive=True),
	)




	CUSTOM_CSS = """
	.review-section-header h3 {
	color: #1e40af;
	border-left: 4px solid #3b82f6;
	padding-left: 10px;
	margin-top: 16px;
	}
	.rebuttal-section-header h3 {
	color: #92400e;
	border-left: 4px solid #f59e0b;
	padding-left: 10px;
	margin-top: 16px;
	}

	/* RSA sentence tooltip styles — uses JS positioning via onmouseenter */
	.rsa-sentence {
	position: relative;
	cursor: help;
	padding: 1px 3px;
	border-radius: 2px;
	display: inline;
	}
	.rsa-tooltip {
	display: none;
	position: fixed;
	background: #1f2937;
	color: white;
	padding: 6px 10px;
	border-radius: 6px;
	font-size: 0.78em;
	z-index: 10000;
	pointer-events: none;
	max-width: 280px;
	width: max-content;
	white-space: normal;
	box-shadow: 0 2px 8px rgba(0,0,0,0.25);
	}

	/* Collapsible author response toggle */
	details summary::-webkit-details-marker { display: none; }
	details[open] summary span:first-child { display: inline-block; transform: rotate(90deg); }

	/* Smooth scrolling everywhere */
	html, body, .gradio-container, main, .contain { scroll-behavior: smooth !important; }

	/* Back to top button */
	#back-to-top-btn {
	position: fixed;
	bottom: 24px;
	right: 24px;
	z-index: 9999;
	padding: 8px 14px;
	border: 1px solid #d1d5db;
	border-radius: 8px;
	background: white;
	color: #374151;
	font-size: 0.82em;
	font-weight: 500;
	cursor: pointer;
	box-shadow: 0 2px 8px rgba(0,0,0,0.12);
	display: none;
	transition: opacity 0.2s;
	}
	#back-to-top-btn:hover { background: #f3f4f6; }

	/* Paper title heading style for interactive tab */
	.paper-title-heading textarea {
	font-size: 1.17em !important;
	font-weight: 700 !important;
	color: #1f2937 !important;
	border: none !important;
	background: transparent !important;
	padding: 0 !important;
	line-height: 1.3 !important;
	min-height: 0 !important;
	}
	.paper-title-heading { padding: 0 !important; margin: 0 !important; min-height: 0 !important; }

	/* Zero-height review anchor elements for jump navigation */
	.review-anchor { height: 0 !important; overflow: hidden !important; margin: 0 !important; padding: 0 !important; min-height: 0 !important; border: none !important; }
	.review-anchor > * { height: 0 !important; margin: 0 !important; padding: 0 !important; }

	/* Tighter vertical spacing in results section */
	.results-compact { gap: 4px !important; }


	/* Progress bar group — zero internal spacing, collapses when both children hidden */
	.progress-group, .progress-group > * {
	gap: 0 !important; padding: 0 !important; margin: 0 !important;
	border: none !important; box-shadow: none !important;
	border-radius: 0 !important; min-height: 0 !important;
	}
	/* Remove Gradio wrapper spacing around individual progress bars */
	.progress-compact { margin: 0 !important; padding: 0 !important; width: 100% !important; min-height: 0 !important; }
	/* Suppress Gradio's loading/progress indicator on progress bar components */
	.progress-compact .progress-bar, .progress-compact .eta-bar,
	.progress-compact > .wrap, .progress-compact .generating { display: none !important; }

	/* Suppress Gradio's orange "pending update" pulsing border */
	.generating { animation: none !important; border-color: #e5e7eb !important; box-shadow: none !important; }

	/* Remove the border/separator line around the display mode radio row */
	.no-border-row { border: none !important; box-shadow: none !important; padding: 0 !important; margin-bottom: 0 !important; }

	/* Progress bar animations — global so they survive HTML replacement in generators */
	@keyframes procspin { to { transform: rotate(360deg); } }
	@keyframes agrslide { 0% { width:15%; margin-left:0; } 50% { width:35%; margin-left:50%; } 100% { width:15%; margin-left:85%; } }
	"""

	# Build a theme where dark mode looks identical to light mode
	_theme = gr.themes.Default()
	_dark_overrides = {}
	for _attr in dir(_theme):
	if _attr.endswith('_dark') and not _attr.startswith('_'):
	_light_attr = _attr[:-5]
	_light_val = getattr(_theme, _light_attr, None)
	if _light_val is not None:
	_dark_overrides[_attr] = _light_val
	_theme.set(**_dark_overrides)

	with gr.Blocks(
	title="ReView",
	css=CUSTOM_CSS,
	theme=_theme,
	js="""() => {
	var btn = document.createElement('button');
	btn.id = 'back-to-top-btn';
	btn.textContent = '\\u2191 Top';
	btn.onclick = function() {
	window.scrollTo({top: 0, behavior: 'smooth'});
	document.documentElement.scrollTop = 0;
	document.body.scrollTop = 0;
	var els = document.querySelectorAll('.gradio-container, main, .contain, .main');
	for (var i = 0; i < els.length; i++) els[i].scrollTop = 0;
	};
	document.body.appendChild(btn);
	function getMaxScroll() {
	var y = window.pageYOffset \|\| document.documentElement.scrollTop \|\| document.body.scrollTop \|\| 0;
	var els = document.querySelectorAll('.gradio-container, main, .contain, .main');
	for (var i = 0; i < els.length; i++) {
	if (els[i].scrollTop > y) y = els[i].scrollTop;
	}
	return y;
	}
	document.addEventListener('scroll', function() {
	btn.style.display = getMaxScroll() > 400 ? '' : 'none';
	}, true);
	setInterval(function() {
	btn.style.display = getMaxScroll() > 400 ? '' : 'none';
	}, 500);

	/* Gray-out and prevent selection of radio choices containing ⏳ */
	var _prevRadio = 'No Highlighting';
	setInterval(function() {
	var labels = document.querySelectorAll('.no-border-row label input[type=radio]');
	labels.forEach(function(inp) {
	var lbl = inp.closest('label') \|\| inp.parentElement;
	var txt = (lbl && lbl.textContent) \|\| '';
	if (txt.indexOf('⏳') !== -1) {
	lbl.style.opacity = '0.4';
	lbl.style.pointerEvents = 'none';
	lbl.title = 'Still computing…';
	} else {
	lbl.style.opacity = '';
	lbl.style.pointerEvents = '';
	lbl.title = '';
	}
	});
	}, 300);
	}""",
	) as demo:
	# gr.Markdown("# ReView Interface")

	# TODO: Uncomment this for home/description tab once finished with testing.
	# with gr.Tab("Introduction"):
	# gr.Markdown(glimpse_description)

	# -----------------------------------
	# Pre-processed Tab
	# -----------------------------------
	with gr.Tab("Pre-processed Reviews", elem_classes=["results-compact"]):
	# Initialize state for this session.
	if not years:
	raise ValueError("No years available in new dataset")
	initial_year = years[0]
	initial_scored_reviews = get_preprocessed_scores(initial_year)
	initial_review_ids = list(initial_scored_reviews.keys())
	initial_review = initial_scored_reviews[initial_review_ids[0]]
	number_of_displayed_reviews = len(initial_scored_reviews[initial_review_ids[0]])
	initial_metadata = get_preprocessed_metadata(initial_year)
	initial_state = {
	"year_choice": initial_year,
	"scored_reviews_for_year": initial_scored_reviews,
	"review_ids": initial_review_ids,
	"current_review_index": 0,
	"current_review": initial_review,
	"number_of_displayed_reviews": number_of_displayed_reviews,
	"metadata_for_year": initial_metadata,
	}
	state = gr.State(initial_state)

	def update_review_display(state, score_type):

	review_ids = state["review_ids"]
	current_index = state["current_review_index"]
	current_review = state["scored_reviews_for_year"][review_ids[current_index]]

	show_polarity = score_type == "Polarity"
	show_consensuality = score_type == "Agreement"
	show_topic = score_type == "Topic"


	if show_polarity:
	color_map = {"➕": "#d4fcd6", "➖": "#fcd6d6"}
	legend = False
	elif show_topic:
	color_map = topic_color_map # No color map for topics
	legend = False
	elif show_consensuality:
	color_map = None # Continuous scale, no predefined colors
	legend = True
	else:
	color_map = {} # Default to empty map
	legend = False

	current_id = review_ids[current_index]
	# Primary source: raw CSV lookup (processed CSVs lack paper_title)
	paper_title = _paper_titles.get(current_id, "")
	# Fallback: metadata column in preprocessed CSV
	if not paper_title:
	paper_meta = state.get("metadata_for_year", {}).get(current_id, {})
	paper_title = paper_meta.get("paper_title", "") if isinstance(paper_meta, dict) else ""
	if paper_title:
	new_review_id = (
	f"### {paper_title}\n\n"
	f"[View on OpenReview]({current_id})  ·  "
	f"({current_index + 1} of {len(state['review_ids'])} submissions)"
	)
	else:
	new_review_id = (
	f"### [View on OpenReview]({current_id})\n\n"
	f"({current_index + 1} of {len(state['review_ids'])} submissions)"
	)

	number_of_displayed_reviews = len(current_review)
	review_updates = []
	rebuttal_updates = []
	consensuality_dict = {}

	# Pre-compute robust normalization stats (median + IQR) for raw KL scores
	_kl_median, _kl_iqr = 0.0, 0.0
	if show_consensuality:
	all_raw_scores = []
	for review_data in current_review:
	if isinstance(review_data, dict) and "sentences" in review_data:
	items = review_data["sentences"].items()
	else:
	items = review_data.items() if isinstance(review_data, dict) else []
	for _, metadata in items:
	all_raw_scores.append(metadata.get("consensuality", 0.0))
	if all_raw_scores:
	arr = np.array(all_raw_scores)
	_kl_median = float(np.median(arr))
	q25, q75 = float(np.percentile(arr, 25)), float(np.percentile(arr, 75))
	_kl_iqr = q75 - q25

	# Build per-review sentence lists, cache, and polarity/topic maps in a single pass
	review_sentence_lists = []
	review_items_cache = [] # Cache (review_item, rebuttal_html) per review
	prep_polarity_map = {}
	prep_topic_map = {}
	for idx in range(number_of_displayed_reviews):
	review_data = current_review[idx]
	rebuttal_html = ""
	if isinstance(review_data, dict) and "sentences" in review_data:
	review_item = list(review_data["sentences"].items())
	rebuttal_html = format_rebuttal_plain(review_data.get("rebuttal", ""))
	else:
	review_item = list(review_data.items())
	review_sentence_lists.append([s for s, _ in review_item])
	review_items_cache.append((review_item, rebuttal_html))

	# Build polarity/topic maps from pre-processed metadata
	for sent, meta in review_item:
	if not isinstance(meta, dict):
	continue
	pol_val = meta.get("polarity")
	if pol_val == 0:
	prep_polarity_map[sent] = "➖"
	elif pol_val == 2:
	prep_polarity_map[sent] = "➕"
	topic = meta.get("topic")
	if topic and topic != "NONE":
	prep_topic_map[sent] = topic

	# For agreement mode, build uniqueness dict and extract RSA distributions
	# RSA listener/speaker come from metadata (if pipeline saved them)
	prep_listener = None
	prep_speaker = None
	if show_consensuality:
	for idx in range(number_of_displayed_reviews):
	review_item, _ = review_items_cache[idx]
	for sentence, metadata in review_item:
	raw = metadata.get("consensuality", 0.0)
	if _kl_iqr > 0:
	score = max(-1.0, min(1.0, (raw - _kl_median) / (_kl_iqr * 2)))
	else:
	score = 0.0
	if not is_noise_sentence(sentence) and abs(score) >= HIGHLIGHT_THRESHOLD:
	consensuality_dict[sentence] = score

	# Extract listener/speaker from metadata (saved by pipeline)
	meta_for_year = state.get("metadata_for_year", {})
	submission_meta = meta_for_year.get(current_id, {})
	if isinstance(submission_meta, dict):
	rsa_data = submission_meta.get("rsa", {})
	if rsa_data:
	prep_listener = rsa_data.get("listener")
	prep_speaker = rsa_data.get("speaker")

	agreement_updates = []
	divergent_per_review = {}
	# Pre-compute per-review divergent cards if we have RSA data
	if show_consensuality and prep_listener and prep_speaker and consensuality_dict:
	divergent_per_review = format_divergent_cards(
	consensuality_dict, review_sentence_lists, prep_listener, prep_speaker,
	)

	for i in range(MAX_PREPROCESSED_REVIEWS):
	if i < number_of_displayed_reviews:
	review_item, rebuttal_html = review_items_cache[i]

	# All modes now use HTML rendering for proper paragraph formatting.
	# HighlightedText is always hidden; prep_agreement HTML is always shown.
	review_updates.append(
	gr.update(
	visible=False,
	value=[],
	show_legend=False,
	color_map=color_map,
	key=f"updated_{score_type}_{i}"
	)
	)

	review_label = f"Review {i + 1}"
	if show_consensuality:
	html_content = build_review_card(
	review_label,
	sentences=[s for s, _ in review_item],
	uniqueness=consensuality_dict,
	listener=prep_listener, speaker=prep_speaker,
	num_reviews=number_of_displayed_reviews,
	divergent_html=divergent_per_review.get(i, ""),
	rebuttal_html=rebuttal_html,
	)
	else:
	m = "polarity" if show_polarity else ("topic" if show_topic else "plain")
	html_content = build_review_card(
	review_label, review_items=review_item, mode=m,
	rebuttal_html=rebuttal_html,
	)

	agreement_updates.append(gr.update(visible=True, value=html_content))
	# Rebuttal is now embedded in the review card, so hide the separate component
	rebuttal_updates.append(gr.update(visible=False, value=""))
	else:
	review_updates.append(
	gr.update(
	visible=False,
	value=[],
	show_legend=False,
	color_map=color_map,
	key=f"updated_{score_type}_{i}"
	)
	)
	agreement_updates.append(gr.update(visible=False, value=""))
	rebuttal_updates.append(gr.update(visible=False, value=""))

	# General rebuttal display (currently unused in new format, kept for backward compat)
	general_rebuttal_update = gr.update(visible=False, value="")

	# Common Themes (topic+polarity grouping) — consistent with interactive tab
	if show_consensuality:
	most_common_html = format_common_themes(
	review_sentence_lists, prep_polarity_map, prep_topic_map,
	speaker=prep_speaker, uniqueness=consensuality_dict if consensuality_dict else None,
	listener=prep_listener,
	)

	most_common_visibility = gr.update(visible=True, value=most_common_html)
	most_unique_visibility = gr.update(visible=False, value="")
	else:
	most_common_visibility = gr.update(visible=False, value="")
	most_unique_visibility = gr.update(visible=False, value="")

	# update color legend (topic or polarity)
	if show_polarity:
	polarity_legend = (
	'<div style="display:flex;gap:12px;align-items:center;padding:8px 0;font-size:0.8em;">'
	'<span style="background:#d4fcd6;padding:2px 8px;border-radius:4px;">Positive</span>'
	'<span style="background:#fcd6d6;padding:2px 8px;border-radius:4px;">Negative</span>'
	'<span style="color:#9ca3af;">Neutral (no highlight)</span>'
	'</div>'
	)
	topic_color_map_visibility = gr.update(visible=True, value=polarity_legend)
	elif show_topic:
	legend_items = " ".join(
	f'<span style="background:{color};padding:2px 8px;border-radius:4px;'
	f'font-size:0.8em;margin-right:4px;">{_html.escape(name)}</span>'
	for name, color in _TOPIC_HTML_COLORS.items()
	)
	topic_legend_html = (
	f'<div style="display:flex;flex-wrap:wrap;gap:4px;align-items:center;'
	f'padding:8px 0;">{legend_items}</div>'
	)
	topic_color_map_visibility = gr.update(visible=True, value=topic_legend_html)
	else:
	topic_color_map_visibility = gr.update(visible=False, value="")

	# Toggle bar: review collapse + rebuttal expand buttons
	has_any_rebuttal = any(
	rebuttal_html
	for _, rebuttal_html in review_items_cache
	)
	toggle_buttons = [_review_toggle_html()]
	if has_any_rebuttal:
	toggle_buttons.append(_rebuttal_toggle_html())
	jump_html = _jump_buttons_html(number_of_displayed_reviews, prefix="pre")
	toggle_bar_html = (
	'<div style="display:flex;align-items:center;gap:8px;">'
	f'<span style="font-size:0.78em;color:#6b7280;white-space:nowrap;">Jump to:</span>'
	+ jump_html
	+ '<span style="flex:1;"></span>'
	+ "".join(toggle_buttons) + '</div>'
	)
	toggle_bar_update = gr.update(visible=True, value=toggle_bar_html)

	return (
	new_review_id,
	*review_updates,
	*agreement_updates, # 10 agreement HTML sections
	most_common_visibility,
	most_unique_visibility,
	topic_color_map_visibility,
	toggle_bar_update, # Review collapse + rebuttal expand buttons
	*rebuttal_updates, # 10 per-review rebuttals
	general_rebuttal_update, # General rebuttal section
	state
	)



	# Precompute the initial outputs so something is shown on load.
	init_display = update_review_display(initial_state, score_type="Original")
	# init_display returns: (review_id, review1..10, agreement1..10, most_common, most_unique, topic_box, prep_rebuttal1..10, prep_general_rebuttal, state)

	with gr.Row():

	with gr.Column(scale=1):
	review_id = gr.Markdown(value=init_display[0], container=True)
	with gr.Row():
	previous_button = gr.Button("Previous", variant="secondary", interactive=True)
	next_button = gr.Button("Next", variant="primary", interactive=True)


	with gr.Column(scale=1):
	# Input controls.
	year = gr.Dropdown(choices=years, label="Select Year", interactive=True, value=initial_year)
	score_type = gr.Radio(
	choices=["No Highlighting", "Polarity", "Topic", "Agreement"],
	label="Display Mode:",
	value="No Highlighting",
	interactive=True
	)

	# Output display.
	with gr.Row():
	most_common_sentences = gr.HTML(
	visible=False,
	value="",
	label="Most Common Opinions",
	)
	most_unique_sentences = gr.HTML(
	visible=False,
	value="",
	label="Most Divergent Opinions",
	)

	# Topic color legend (HTML version)
	topic_text_box = gr.HTML(visible=False, value="")

	prep_toggle_bar = gr.HTML(visible=False, value="")
	gr.HTML(value='<div id="pre-review-anchor-1"></div>', elem_classes=["review-anchor"])
	review1 = gr.HighlightedText(show_legend=False, label="📝 Review 1", visible=number_of_displayed_reviews >= 1, key="initial_review1")
	prep_agreement1 = gr.HTML(visible=False, value="")
	prep_rebuttal1 = gr.HTML(visible=False, value="")
	gr.HTML(value='<div id="pre-review-anchor-2"></div>', elem_classes=["review-anchor"])
	review2 = gr.HighlightedText(show_legend=False, label="📝 Review 2", visible=number_of_displayed_reviews >= 2, key="initial_review2")
	prep_agreement2 = gr.HTML(visible=False, value="")
	prep_rebuttal2 = gr.HTML(visible=False, value="")
	gr.HTML(value='<div id="pre-review-anchor-3"></div>', elem_classes=["review-anchor"])
	review3 = gr.HighlightedText(show_legend=False, label="📝 Review 3", visible=number_of_displayed_reviews >= 3, key="initial_review3")
	prep_agreement3 = gr.HTML(visible=False, value="")
	prep_rebuttal3 = gr.HTML(visible=False, value="")
	gr.HTML(value='<div id="pre-review-anchor-4"></div>', elem_classes=["review-anchor"])
	review4 = gr.HighlightedText(show_legend=False, label="📝 Review 4", visible=number_of_displayed_reviews >= 4, key="initial_review4")
	prep_agreement4 = gr.HTML(visible=False, value="")
	prep_rebuttal4 = gr.HTML(visible=False, value="")
	gr.HTML(value='<div id="pre-review-anchor-5"></div>', elem_classes=["review-anchor"])
	review5 = gr.HighlightedText(show_legend=False, label="📝 Review 5", visible=number_of_displayed_reviews >= 5, key="initial_review5")
	prep_agreement5 = gr.HTML(visible=False, value="")
	prep_rebuttal5 = gr.HTML(visible=False, value="")
	gr.HTML(value='<div id="pre-review-anchor-6"></div>', elem_classes=["review-anchor"])
	review6 = gr.HighlightedText(show_legend=False, label="📝 Review 6", visible=number_of_displayed_reviews >= 6, key="initial_review6")
	prep_agreement6 = gr.HTML(visible=False, value="")
	prep_rebuttal6 = gr.HTML(visible=False, value="")
	gr.HTML(value='<div id="pre-review-anchor-7"></div>', elem_classes=["review-anchor"])
	review7 = gr.HighlightedText(show_legend=False, label="📝 Review 7", visible=number_of_displayed_reviews >= 7, key="initial_review7")
	prep_agreement7 = gr.HTML(visible=False, value="")
	prep_rebuttal7 = gr.HTML(visible=False, value="")
	gr.HTML(value='<div id="pre-review-anchor-8"></div>', elem_classes=["review-anchor"])
	review8 = gr.HighlightedText(show_legend=False, label="📝 Review 8", visible=number_of_displayed_reviews >= 8, key="initial_review8")
	prep_agreement8 = gr.HTML(visible=False, value="")
	prep_rebuttal8 = gr.HTML(visible=False, value="")
	gr.HTML(value='<div id="pre-review-anchor-9"></div>', elem_classes=["review-anchor"])
	review9 = gr.HighlightedText(show_legend=False, label="📝 Review 9", visible=number_of_displayed_reviews >= 9, key="initial_review9")
	prep_agreement9 = gr.HTML(visible=False, value="")
	prep_rebuttal9 = gr.HTML(visible=False, value="")
	gr.HTML(value='<div id="pre-review-anchor-10"></div>', elem_classes=["review-anchor"])
	review10 = gr.HighlightedText(show_legend=False, label="📝 Review 10", visible=number_of_displayed_reviews >= 10, key="initial_review10")
	prep_agreement10 = gr.HTML(visible=False, value="")
	prep_rebuttal10 = gr.HTML(visible=False, value="")

	# General rebuttal section (for rebuttals not tied to specific reviews)
	prep_general_rebuttal = gr.HTML(visible=False, value="")

	# Callback functions that update state.
	def year_change(year, state, score_type):
	state["year_choice"] = year
	state["scored_reviews_for_year"] = get_preprocessed_scores(year)
	state["metadata_for_year"] = get_preprocessed_metadata(year)
	state["review_ids"] = list(state["scored_reviews_for_year"].keys())
	state["current_review_index"] = 0
	state["current_review"] = state["scored_reviews_for_year"][state["review_ids"][0]]
	return update_review_display(state, score_type)

	def next_review(state, score_type):
	state["current_review_index"] = (state["current_review_index"] + 1) % len(state["review_ids"])
	state["current_review"] = state["scored_reviews_for_year"][state["review_ids"][state["current_review_index"]]]
	return update_review_display(state, score_type)

	def previous_review(state, score_type):
	state["current_review_index"] = (state["current_review_index"] - 1) % len(state["review_ids"])
	state["current_review"] = state["scored_reviews_for_year"][state["review_ids"][state["current_review_index"]]]
	return update_review_display(state, score_type)

	# Hook up the callbacks with the session state.
	_review_outputs = [review_id, review1, review2, review3, review4, review5, review6, review7, review8, review9, review10, prep_agreement1, prep_agreement2, prep_agreement3, prep_agreement4, prep_agreement5, prep_agreement6, prep_agreement7, prep_agreement8, prep_agreement9, prep_agreement10, most_common_sentences, most_unique_sentences, topic_text_box, prep_toggle_bar, prep_rebuttal1, prep_rebuttal2, prep_rebuttal3, prep_rebuttal4, prep_rebuttal5, prep_rebuttal6, prep_rebuttal7, prep_rebuttal8, prep_rebuttal9, prep_rebuttal10, prep_general_rebuttal, state]
	year.change(fn=year_change, inputs=[year, state, score_type], outputs=_review_outputs)
	score_type.change(fn=update_review_display, inputs=[state, score_type], outputs=_review_outputs)
	next_button.click(fn=next_review, inputs=[state, score_type], outputs=_review_outputs)
	previous_button.click(fn=previous_review, inputs=[state, score_type], outputs=_review_outputs)




	# -----------------------------------
	# Interactive Tab
	# -----------------------------------
	with gr.Tab("Interactive", interactive=True):

	# ---- TOP TOGGLE BAR (always visible) ----
	with gr.Row():
	paper_title_html = gr.Textbox("", visible=False, interactive=False, show_label=False, container=False, elem_classes=["paper-title-heading"])
	back_to_input_btn = gr.Button("✏️ Edit Reviews / New Input", visible=False, variant="secondary")
	view_results_btn = gr.Button("📊 View Results", visible=False, variant="secondary")

	# ---- INPUT SECTION (full-width, visible initially) ----
	with gr.Column(visible=True) as input_section:

	with gr.Tabs():
	with gr.Tab("OpenReview Link"):
	gr.Markdown("""
	Paste an OpenReview forum link to automatically fetch and process its reviews.

	Example link:
	https://openreview.net/forum?id=...
	""")
	openreview_link_input = gr.Textbox(
	label="OpenReview Forum Link",
	placeholder="https://openreview.net/forum?id=...",
	interactive=True
	)
	fetch_reviews_button = gr.Button("Fetch & Process", variant="primary", interactive=True)
	openreview_title = gr.State("")
	openreview_rebuttal = gr.State("")

	with gr.Tab("Paste Reviews Manually"):
	review1_textbox = gr.Textbox(lines=5, value=EXAMPLES[0], label="📝 Review 1", interactive=True)
	review2_textbox = gr.Textbox(lines=5, value=EXAMPLES[1], label="📝 Review 2", interactive=True)
	review3_textbox = gr.Textbox(lines=5, value=EXAMPLES[2], label="📝 Review 3", interactive=True)
	review4_textbox = gr.Textbox(lines=5, value="", label="📝 Review 4", interactive=True, visible=False)
	review5_textbox = gr.Textbox(lines=5, value="", label="📝 Review 5", interactive=True, visible=False)
	review6_textbox = gr.Textbox(lines=5, value="", label="📝 Review 6", interactive=True, visible=False)
	paste_rebuttal = gr.Textbox(label="💬 Author Rebuttal (optional)", interactive=True, lines=3, placeholder="Paste the author rebuttal here (optional)...")
	interactive_review_count = gr.State(3)
	with gr.Row():
	add_review_btn = gr.Button("➕ Add Review", variant="secondary", interactive=True)
	submit_button = gr.Button("Process", variant="primary", interactive=True)
	clear_button = gr.Button("Clear", variant="secondary", interactive=True)

	status_html = gr.HTML("", visible=False)

	# ---- RESULTS SECTION (full-width, hidden initially) ----
	with gr.Column(visible=False, elem_classes=["results-compact"]) as results_section:
	with gr.Row(elem_classes=["no-border-row"]):
	focus_radio = gr.Radio(
	choices=["No Highlighting", "Polarity", "Topic", "Agreement (Processing)"],
	value="No Highlighting",
	label="Display Mode:",
	interactive=True
	)

	# Progress bars in a zero-gap group so they sit flush against each other
	with gr.Group(elem_classes=["progress-group"]):
	polarity_progress_html = gr.HTML("", visible=False, elem_classes=["progress-compact"])
	agreement_progress_html = gr.HTML("", visible=False, elem_classes=["progress-compact"])

	# Color legend for polarity/topic modes (hidden by default, shown by toggle_display_mode)
	interactive_legend_html = gr.HTML("", visible=False)

	with gr.Row():
	most_divergent = gr.HTML(
	visible=False, value="", label="Most Divergent Opinions",
	)
	most_common = gr.HTML(
	visible=False, value="", label="Most Common Opinions",
	)

	interactive_rebuttal_toggle = gr.HTML(visible=False, value="")

	# Review 1 (all display modes as HTML + rebuttal)
	gr.HTML(value='<div id="int-review-anchor-1"></div>', elem_classes=["review-anchor"])
	none_text1 = gr.HTML(visible=True, value="", elem_id="int-review-1")
	agreement_text1 = gr.HTML(visible=False, value="")
	polarity_text1 = gr.HTML(visible=False, value="")
	topic_text1 = gr.HTML(visible=False, value="")
	rebuttal_for_review1 = gr.HTML(visible=False, value="")

	# Review 2
	gr.HTML(value='<div id="int-review-anchor-2"></div>', elem_classes=["review-anchor"])
	none_text2 = gr.HTML(visible=False, value="", elem_id="int-review-2")
	agreement_text2 = gr.HTML(visible=False, value="")
	polarity_text2 = gr.HTML(visible=False, value="")
	topic_text2 = gr.HTML(visible=False, value="")
	rebuttal_for_review2 = gr.HTML(visible=False, value="")

	# Review 3
	gr.HTML(value='<div id="int-review-anchor-3"></div>', elem_classes=["review-anchor"])
	none_text3 = gr.HTML(visible=False, value="", elem_id="int-review-3")
	agreement_text3 = gr.HTML(visible=False, value="")
	polarity_text3 = gr.HTML(visible=False, value="")
	topic_text3 = gr.HTML(visible=False, value="")
	rebuttal_for_review3 = gr.HTML(visible=False, value="")

	# Review 4
	gr.HTML(value='<div id="int-review-anchor-4"></div>', elem_classes=["review-anchor"])
	none_text4 = gr.HTML(visible=False, value="", elem_id="int-review-4")
	agreement_text4 = gr.HTML(visible=False, value="")
	polarity_text4 = gr.HTML(visible=False, value="")
	topic_text4 = gr.HTML(visible=False, value="")
	rebuttal_for_review4 = gr.HTML(visible=False, value="")

	# Review 5
	gr.HTML(value='<div id="int-review-anchor-5"></div>', elem_classes=["review-anchor"])
	none_text5 = gr.HTML(visible=False, value="", elem_id="int-review-5")
	agreement_text5 = gr.HTML(visible=False, value="")
	polarity_text5 = gr.HTML(visible=False, value="")
	topic_text5 = gr.HTML(visible=False, value="")
	rebuttal_for_review5 = gr.HTML(visible=False, value="")

	# Review 6
	gr.HTML(value='<div id="int-review-anchor-6"></div>', elem_classes=["review-anchor"])
	none_text6 = gr.HTML(visible=False, value="", elem_id="int-review-6")
	agreement_text6 = gr.HTML(visible=False, value="")
	polarity_text6 = gr.HTML(visible=False, value="")
	topic_text6 = gr.HTML(visible=False, value="")
	rebuttal_for_review6 = gr.HTML(visible=False, value="")

	# General rebuttal display (for rebuttals not tied to specific reviews)
	interactive_rebuttal_display = gr.HTML(visible=False, value="")

	# ---- CALLBACKS ----

	# State to hold raw rebuttal string (set by _show_raw_and_switch, consumed by process_interactive_reviews_fast)
	interactive_rebuttal_state = gr.State("")

	# State to hold background processing thread (polarity+topic starts during page transition)
	processing_thread_state = gr.State(None)

	_interactive_inputs = [review1_textbox, review2_textbox, review3_textbox, review4_textbox, review5_textbox, review6_textbox, focus_radio, interactive_rebuttal_state, processing_thread_state]

	# State to hold RSA computation results for async updates
	rsa_computation_state = gr.State({})

	# Sink states: absorb none_textN outputs from process_interactive_reviews_fast
	# (none_texts are already set by _show_raw_and_switch; routing them to states
	# prevents Gradio from showing a "pending" loading spinner on the review cards)
	_none_sinks = [gr.State(None) for _ in range(6)]

	_interactive_outputs = [
	*_none_sinks, # absorb none_text1..6 — already populated, no spinner wanted
	agreement_text1, agreement_text2, agreement_text3, agreement_text4, agreement_text5, agreement_text6,
	most_common, most_divergent,
	polarity_text1, polarity_text2, polarity_text3, polarity_text4, polarity_text5, polarity_text6,
	topic_text1, topic_text2, topic_text3, topic_text4, topic_text5, topic_text6,
	interactive_review_count,
	rsa_computation_state,
	]

	# Outputs for RSA async computation (updates agreement sections + most common/unique)
	_rsa_outputs = [
	agreement_text1, agreement_text2, agreement_text3, agreement_text4, agreement_text5, agreement_text6,
	most_common, most_divergent,
	agreement_progress_html,
	focus_radio,
	]

	# Fetch OpenReview reviews → show timer → fast process → swap to results → async RSA
	def _validate_and_start_fetch(link):
	if not link or not link.strip():
	raise gr.Error("Please paste a valid OpenReview link before fetching.")
	return gr.update(value=FETCHING_HTML, visible=True), gr.update(interactive=False)

	no_title_state = gr.State("")

	def _show_raw_and_switch(r1, r2, r3, r4, r5, r6, rebuttal, title=""):
	"""Immediately switch to results view with raw tokenized reviews.
	Also kicks off polarity+topic in a background thread so processing
	overlaps with page transition rendering."""
	import time as _time
	from dependencies.Glimpse_tokenizer import glimpse_tokenizer
	texts = [r1, r2, r3, r4, r5, r6]
	active_count = sum(1 for t in texts if t and t.strip())

	# Pre-compute per-review rebuttal HTML (to embed inside review cards)
	rebuttal_htmls = [format_rebuttal_for_review(rebuttal or "", i + 1) for i in range(6)]
	has_per_review = any(rebuttal_htmls)

	# Tokenize each review and render as HTML with collapsible cards (fast, no ML)
	# Rebuttal is embedded INSIDE the card (like the pre-processed tab)
	none_out = []
	for idx, t in enumerate(texts):
	if t and t.strip():
	sentences = [s for s in glimpse_tokenizer(t) if s.strip()]
	plain_items = [(s, {}) for s in sentences]
	html = build_review_card(f"Review {idx + 1}", review_items=plain_items, mode="plain", rebuttal_html=rebuttal_htmls[idx])
	none_out.append(gr.update(visible=True, value=html))
	else:
	none_out.append(gr.update(visible=False, value=""))

	# Per-review rebuttal components are now hidden (content embedded in cards above)
	per_review = [gr.update(visible=False, value="") for _ in range(6)]

	general_formatted = format_general_rebuttals(rebuttal or "")
	has_any = has_per_review or bool(general_formatted)

	# Toggle bar
	right_buttons = [_review_toggle_html()]
	if has_any:
	right_buttons.append(_rebuttal_toggle_html())
	toggle_bar = (
	'<div style="display:flex;align-items:center;gap:8px;">'
	'<span style="font-size:0.78em;color:#6b7280;white-space:nowrap;">Jump to:</span>'
	+ _jump_buttons_html(active_count)
	+ '<span style="flex:1;"></span>'
	+ "".join(right_buttons) + '</div>'
	)

	title_text = title.strip() if title and title.strip() else ""

	# Start polarity+topic in background thread NOW, so processing
	# overlaps with Gradio rendering the page transition to the user.
	# By the time process_interactive_reviews_fast runs, work is already underway.
	active_texts = [t for t in texts if t and t.strip()]
	sentence_lists = []
	for t in active_texts:
	sents = [s for s in glimpse_tokenizer(t) if s.strip()]
	if sents:
	sentence_lists.append(sents)
	all_sentences = filter_and_clean_sentences(
	list(set(s for sl in sentence_lists for s in sl))
	)

	processor = get_interactive_processor()
	_thread_result = {"polarity": None, "topic": None, "error": None}

	def _run_polarity_topic():
	try:
	t0 = _time.time()
	_thread_result["polarity"] = processor.predict_polarity(all_sentences)
	_thread_result["topic"] = processor.predict_topic(all_sentences)
	print(f"[TIMING] Early polarity+topic thread done in {_time.time() - t0:.1f}s")
	except Exception as e:
	_thread_result["error"] = e

	bg_thread = threading.Thread(target=_run_polarity_topic, daemon=True)
	bg_thread.start()
	print(f"[TIMING] Background polarity+topic thread started (page transitioning...)")

	thread_key = str(uuid.uuid4())
	_thread_states[thread_key] = {
	"thread": bg_thread,
	"result": _thread_result,
	"sentence_lists": sentence_lists,
	"active_texts": active_texts,
	"all_sentences": all_sentences,
	}

	return (
	*none_out, # none_text1..6
	gr.update(visible=False), # input_section
	gr.update(visible=True), # results_section
	gr.update(visible=True), # back_to_input_btn
	gr.update(visible=bool(title_text), value=title_text), # paper_title_html
	gr.update(visible=False), # view_results_btn
	gr.update(choices=["No Highlighting", "Polarity ⏳", "Topic ⏳", "Agreement ⏳"],
	value="No Highlighting", interactive=True), # focus_radio
	gr.update(visible=True, value=POLARITY_PROGRESS_HTML), # polarity_progress_html
	gr.update(visible=True, value=AGREEMENT_PROGRESS_HTML),# agreement_progress_html
	gr.update(visible=True, value=toggle_bar), # interactive_rebuttal_toggle
	*per_review, # rebuttal_for_review1..6 (hidden, embedded in cards)
	gr.update(visible=bool(general_formatted), value=general_formatted), # interactive_rebuttal_display
	active_count, # interactive_review_count
	rebuttal or "", # interactive_rebuttal_state
	gr.update(visible=False, value=""), # interactive_legend_html (reset on new submission)
	thread_key, # processing_thread_state (just a string key now)
	)

	def _show_results_with_rebuttal(rebuttal, active_count):
	# Generate per-review rebuttals
	per_review = []
	has_per_review = False
	for i in range(1, 7):
	formatted = format_rebuttal_for_review(rebuttal or "", i)
	if formatted:
	has_per_review = True
	per_review.append(gr.update(visible=bool(formatted), value=formatted))

	# Generate general rebuttal section (only for rebuttals not tied to specific reviews)
	general_formatted = format_general_rebuttals(rebuttal or "")
	has_general = bool(general_formatted)

	# Toggle bar: jump buttons (left) + collapse toggles (right)
	has_any = has_per_review or has_general
	right_buttons = [_review_toggle_html()]
	if has_any:
	right_buttons.append(_rebuttal_toggle_html())
	toggle_bar = (
	'<div style="display:flex;align-items:center;gap:8px;">'
	'<span style="font-size:0.78em;color:#6b7280;white-space:nowrap;">Jump to:</span>'
	+ _jump_buttons_html(active_count)
	+ '<span style="flex:1;"></span>'
	+ "".join(right_buttons) + '</div>'
	)
	toggle_update = gr.update(visible=True, value=toggle_bar)

	return (
	gr.update(visible=False), # input_section
	gr.update(visible=True), # results_section
	gr.update(value=AGREEMENT_PROGRESS_HTML, visible=True), # agreement_progress_html (in results_section)
	gr.update(visible=True), # back_to_input_btn
	gr.update(visible=False), # view_results_btn
	gr.update(choices=["No Highlighting", "Polarity", "Topic", "Agreement (Processing)"], value="No Highlighting"),
	toggle_update, # rebuttal toggle button
	*per_review, # 6 per-review rebuttal components
	gr.update(visible=has_general, value=general_formatted), # general rebuttal display (only if exists)
	)

	# Toggle display mode (No Highlighting / Polarity / Topic / Agreement[Processing])
	def toggle_display_mode(focus, active_count):
	# Strip ⏳ loading suffix — treat "Polarity ⏳" as "Polarity", etc.
	effective_focus = focus.split(" ⏳")[0] if " ⏳" in focus else focus
	# Legacy compat
	if effective_focus == "Agreement (Processing)":
	effective_focus = "Agreement"

	updates = []
	for mode in ["No Highlighting", "Polarity", "Topic", "Agreement"]:
	for i in range(MAX_INTERACTIVE_REVIEWS):
	updates.append(gr.update(visible=(mode == effective_focus and i < active_count)))

	# Most common shows in Agreement mode; most_divergent is now per-review (always hidden here)
	show_opinions = effective_focus == "Agreement" and focus != "Agreement (Processing)"
	updates.append(gr.update(visible=False)) # most_divergent (per-review now, always hidden)
	updates.append(gr.update(visible=show_opinions)) # most_common

	# Color legend
	if effective_focus == "Polarity":
	updates.append(gr.update(visible=True, value=_POLARITY_LEGEND))
	elif effective_focus == "Topic":
	updates.append(gr.update(visible=True, value=_TOPIC_LEGEND))
	else:
	updates.append(gr.update(visible=False, value=""))

	return tuple(updates)

	fetch_reviews_button.click(
	fn=_validate_and_start_fetch,
	inputs=[openreview_link_input],
	outputs=[status_html, fetch_reviews_button]
	).success(
	fn=fetch_openreview_reviews,
	inputs=[openreview_link_input],
	outputs=[review1_textbox, review2_textbox, review3_textbox, review4_textbox, review5_textbox, review6_textbox,
	openreview_title, openreview_rebuttal, status_html]
	).success(
	fn=lambda r4, r5, r6: (
	gr.update(visible=bool(r4.strip())),
	gr.update(visible=bool(r5.strip())),
	gr.update(visible=bool(r6.strip())),
	),
	inputs=[review4_textbox, review5_textbox, review6_textbox],
	outputs=[review4_textbox, review5_textbox, review6_textbox]
	).success(
	fn=_show_raw_and_switch,
	inputs=[review1_textbox, review2_textbox, review3_textbox, review4_textbox, review5_textbox, review6_textbox,
	openreview_rebuttal, openreview_title],
	outputs=[none_text1, none_text2, none_text3, none_text4, none_text5, none_text6,
	input_section, results_section, back_to_input_btn, paper_title_html, view_results_btn, focus_radio,
	polarity_progress_html, agreement_progress_html,
	interactive_rebuttal_toggle,
	rebuttal_for_review1, rebuttal_for_review2, rebuttal_for_review3,
	rebuttal_for_review4, rebuttal_for_review5, rebuttal_for_review6,
	interactive_rebuttal_display, interactive_review_count,
	interactive_rebuttal_state, interactive_legend_html,
	processing_thread_state]
	).success(
	fn=process_interactive_reviews_fast,
	inputs=_interactive_inputs,
	outputs=_interactive_outputs
	).success(
	fn=lambda: (
	gr.update(visible=False, value=""),
	gr.update(choices=["No Highlighting", "Polarity", "Topic", "Agreement ⏳"], interactive=True),
	),
	inputs=[],
	outputs=[polarity_progress_html, focus_radio]
	).success(
	fn=toggle_display_mode,
	inputs=[focus_radio, interactive_review_count],
	outputs=[
	none_text1, none_text2, none_text3, none_text4, none_text5, none_text6,
	polarity_text1, polarity_text2, polarity_text3, polarity_text4, polarity_text5, polarity_text6,
	topic_text1, topic_text2, topic_text3, topic_text4, topic_text5, topic_text6,
	agreement_text1, agreement_text2, agreement_text3, agreement_text4, agreement_text5, agreement_text6,
	most_divergent, most_common,
	interactive_legend_html,
	]
	).success(
	fn=lambda: gr.update(interactive=True),
	inputs=[],
	outputs=[fetch_reviews_button]
	).success(
	fn=compute_rsa_in_background,
	inputs=[rsa_computation_state, focus_radio],
	outputs=_rsa_outputs
	)

	# Process (Paste Reviews): show raw reviews immediately → fast scoring → async RSA
	submit_button.click(
	fn=lambda: gr.update(interactive=False),
	inputs=[],
	outputs=[submit_button]
	).success(
	fn=_show_raw_and_switch,
	inputs=[review1_textbox, review2_textbox, review3_textbox, review4_textbox, review5_textbox, review6_textbox,
	paste_rebuttal, no_title_state],
	outputs=[none_text1, none_text2, none_text3, none_text4, none_text5, none_text6,
	input_section, results_section, back_to_input_btn, paper_title_html, view_results_btn, focus_radio,
	polarity_progress_html, agreement_progress_html,
	interactive_rebuttal_toggle,
	rebuttal_for_review1, rebuttal_for_review2, rebuttal_for_review3,
	rebuttal_for_review4, rebuttal_for_review5, rebuttal_for_review6,
	interactive_rebuttal_display, interactive_review_count,
	interactive_rebuttal_state, interactive_legend_html,
	processing_thread_state]
	).success(
	fn=process_interactive_reviews_fast,
	inputs=_interactive_inputs,
	outputs=_interactive_outputs
	).success(
	fn=lambda: (
	gr.update(visible=False, value=""),
	gr.update(choices=["No Highlighting", "Polarity", "Topic", "Agreement ⏳"], interactive=True),
	),
	inputs=[],
	outputs=[polarity_progress_html, focus_radio]
	).success(
	fn=toggle_display_mode,
	inputs=[focus_radio, interactive_review_count],
	outputs=[
	none_text1, none_text2, none_text3, none_text4, none_text5, none_text6,
	polarity_text1, polarity_text2, polarity_text3, polarity_text4, polarity_text5, polarity_text6,
	topic_text1, topic_text2, topic_text3, topic_text4, topic_text5, topic_text6,
	agreement_text1, agreement_text2, agreement_text3, agreement_text4, agreement_text5, agreement_text6,
	most_divergent, most_common,
	interactive_legend_html,
	]
	).success(
	fn=lambda: gr.update(interactive=True),
	inputs=[],
	outputs=[submit_button]
	).success(
	fn=compute_rsa_in_background,
	inputs=[rsa_computation_state, focus_radio],
	outputs=_rsa_outputs
	)

	# Top bar: Back to input
	back_to_input_btn.click(
	fn=lambda: (
	gr.update(visible=True), # show input
	gr.update(visible=False), # hide results
	gr.update(visible=False), # hide "back to input"
	gr.update(visible=False), # hide paper title
	gr.update(visible=True), # show "view results"
	),
	inputs=[],
	outputs=[input_section, results_section, back_to_input_btn, paper_title_html, view_results_btn]
	)

	# Top bar: View Results (toggle back without re-processing)
	view_results_btn.click(
	fn=lambda: (
	gr.update(visible=False), # hide input
	gr.update(visible=True), # show results
	gr.update(visible=True), # show "back to input"
	gr.update(visible=True), # show paper title
	gr.update(visible=False), # hide "view results"
	),
	inputs=[],
	outputs=[input_section, results_section, back_to_input_btn, paper_title_html, view_results_btn]
	)

	# Clear button
	clear_button.click(
	fn=lambda: (
	"", "", "", "", "", "", # clear all textboxes
	"", # clear paste_rebuttal
	3, # reset count
	"", "", # clear most common/divergent
	([""] 6), ([""] 6), ([""] 6), ([""] 6), # clear all output panels (none, agree, polar, topic)
	{}, # reset rsa_computation_state
	),
	inputs=[],
	outputs=[
	review1_textbox, review2_textbox, review3_textbox, review4_textbox, review5_textbox, review6_textbox,
	paste_rebuttal,
	interactive_review_count,
	most_common, most_divergent,
	none_text1, none_text2, none_text3, none_text4, none_text5, none_text6,
	agreement_text1, agreement_text2, agreement_text3, agreement_text4, agreement_text5, agreement_text6,
	polarity_text1, polarity_text2, polarity_text3, polarity_text4, polarity_text5, polarity_text6,
	topic_text1, topic_text2, topic_text3, topic_text4, topic_text5, topic_text6,
	rsa_computation_state,
	]
	).then(
	fn=lambda: (
	gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # review4-6
	gr.update(visible=False, value=""), # rebuttal toggle
	gr.update(visible=False, value=""), gr.update(visible=False, value=""), gr.update(visible=False, value=""), # per-review rebuttals 1-3
	gr.update(visible=False, value=""), gr.update(visible=False, value=""), gr.update(visible=False, value=""), # per-review rebuttals 4-6
	gr.update(visible=False, value=""), # consolidated rebuttal
	gr.update(visible=False, value=""), # paper_title_html
	gr.update(visible=False, value=""), # polarity_progress_html
	gr.update(visible=False, value=""), # agreement_progress_html
	),
	inputs=[],
	outputs=[review4_textbox, review5_textbox, review6_textbox,
	interactive_rebuttal_toggle,
	rebuttal_for_review1, rebuttal_for_review2, rebuttal_for_review3,
	rebuttal_for_review4, rebuttal_for_review5, rebuttal_for_review6,
	interactive_rebuttal_display, paper_title_html,
	polarity_progress_html, agreement_progress_html]
	)

	# Color legend HTML snippets for polarity/topic modes
	_POLARITY_LEGEND = (
	'<div style="display:flex;gap:12px;align-items:center;padding:8px 0;font-size:0.8em;">'
	'<span style="background:#d4fcd6;padding:2px 8px;border-radius:4px;">Positive</span>'
	'<span style="background:#fcd6d6;padding:2px 8px;border-radius:4px;">Negative</span>'
	'<span style="color:#9ca3af;">Neutral (no highlight)</span>'
	'</div>'
	)
	_TOPIC_LEGEND = (
	'<div style="display:flex;flex-wrap:wrap;gap:4px;align-items:center;padding:8px 0;">'
	+ " ".join(
	f'<span style="background:{color};padding:2px 8px;border-radius:4px;'
	f'font-size:0.8em;margin-right:4px;">{_html.escape(name)}</span>'
	for name, color in _TOPIC_HTML_COLORS.items()
	)
	+ '</div>'
	)

	focus_radio.change(
	fn=toggle_display_mode,
	inputs=[focus_radio, interactive_review_count],
	outputs=[
	none_text1, none_text2, none_text3, none_text4, none_text5, none_text6,
	polarity_text1, polarity_text2, polarity_text3, polarity_text4, polarity_text5, polarity_text6,
	topic_text1, topic_text2, topic_text3, topic_text4, topic_text5, topic_text6,
	agreement_text1, agreement_text2, agreement_text3, agreement_text4, agreement_text5, agreement_text6,
	most_divergent, most_common,
	interactive_legend_html,
	]
	)

	# Add Review button: show next hidden textbox (reviews 4-6)
	def add_review(count):
	new_count = min(count + 1, MAX_INTERACTIVE_REVIEWS)
	vis = [gr.update(visible=(i + 4 <= new_count)) for i in range(MAX_INTERACTIVE_REVIEWS - 3)]
	return (new_count, *vis)

	add_review_btn.click(
	fn=add_review,
	inputs=[interactive_review_count],
	outputs=[interactive_review_count, review4_textbox, review5_textbox, review6_textbox]
	)

	# Populate pre-processed tab with initial data on page load
	demo.load(
	fn=lambda s: update_review_display(s, "No Highlighting"),
	inputs=[state],
	outputs=_review_outputs,
	)

	# Pre-load interactive processor models at startup so first request isn't slow
	get_interactive_processor()

	demo.launch(share=False, ssr_mode=False)