| """ |
| Shared utilities for the subjective evaluation apps (Block 1 and Block 2). |
| """ |
|
|
| from __future__ import annotations |
|
|
| import datetime as dt |
| import json |
| import random |
| import re |
| import time |
| from pathlib import Path |
| from typing import Dict, List, Optional, Set, Tuple |
|
|
| import pandas as pd |
| import streamlit as st |
|
|
| |
| |
| |
| _APP_DIR = Path(__file__).parent |
| BLOCK_1_AUDIO_DIR = _APP_DIR / "block_1_audio" |
| BLOCK_2_AUDIO_DIR = _APP_DIR / "block_2_audio" |
| BLOCK_1_METADATA_PATH = _APP_DIR / "block_1_metadata.json" |
| BLOCK_2_METADATA_PATH = _APP_DIR / "block_2_metadata.json" |
| RESPONSES_DIR = _APP_DIR / "responses" |
| BLOCK_1_RESPONSES_DIR = _APP_DIR / "responses_block1" |
| BLOCK_2_RESPONSES_DIR = _APP_DIR / "responses_block2" |
| INTRO_IMAGE_PATH = _APP_DIR / "intro_image.png" |
|
|
| |
| |
| |
| MOS_SCALE = [1, 2, 3, 4, 5] |
| MOS_LABELS = { |
| 1: "1 – Very Poor", |
| 2: "2 – Poor", |
| 3: "3 – Fair", |
| 4: "4 – Good", |
| 5: "5 – Excellent", |
| } |
|
|
| |
| |
| |
| RESPONSE_BASE_COLUMNS = [ |
| "timestamp_utc", |
| "participant_id", |
| "participant_name", |
| "hearing_condition", |
| "uses_hearing_aids", |
| "using_headphones", |
| "quiet_environment", |
| "consent_acknowledged", |
| "block", |
| "sample_id", |
| "model_name", |
| "mixture_audio_path", |
| "output_audio_path", |
| "scene_name", |
| "instruction", |
| "instruction_followed", |
| "instruction_following_mos", |
| "extraction_quality_mos", |
| "spatial_preservation_mos", |
| "contextual_correct", |
| "response_duration_sec", |
| ] |
|
|
| |
| |
| |
| HEARING_OPTIONS = [ |
| "No", |
| "Yes, mild", |
| "Yes, moderate or severe", |
| ] |
|
|
| BOOLEAN_OPTIONS = ["Yes", "No"] |
|
|
| |
| |
| |
| SIDEBAR_INSTRUCTIONS_SHORT = ( |
| "**Step 1:** Listen to both clips (mixture + output).\n\n" |
| "**Step 2:** Answer the questions for each sample.\n\n" |
| "MOS scale: 1 Very Poor – 5 Excellent\n\n" |
| "You can take a break at any time and resume later with the same participant ID." |
| ) |
|
|
|
|
| |
| |
| |
|
|
| def rerun_app() -> None: |
| """Compatibility wrapper for Streamlit rerun API.""" |
| if hasattr(st, "experimental_rerun"): |
| st.experimental_rerun() |
| else: |
| st.rerun() |
|
|
|
|
| def sanitize_participant_id(participant_id: str) -> str: |
| safe = re.sub(r"[^A-Za-z0-9_-]+", "_", participant_id.strip()) |
| return safe.strip("_") |
|
|
|
|
| def render_sidebar_image() -> None: |
| if INTRO_IMAGE_PATH.exists(): |
| st.sidebar.image(str(INTRO_IMAGE_PATH), use_container_width=True) |
|
|
|
|
| |
| |
| |
|
|
| def load_block_metadata(block: int) -> List[Dict]: |
| """Load metadata JSON for a block. Returns list of sample dicts.""" |
| path = BLOCK_1_METADATA_PATH if block == 1 else BLOCK_2_METADATA_PATH |
| if not path.exists(): |
| st.error(f"Metadata file not found: {path}") |
| st.stop() |
| with open(path) as f: |
| data = json.load(f) |
| return data["samples"] |
|
|
|
|
| def get_block_audio_dir(block: int) -> Path: |
| return BLOCK_1_AUDIO_DIR if block == 1 else BLOCK_2_AUDIO_DIR |
|
|
|
|
| def validate_audio_files(samples: List[Dict], audio_dir: Path) -> List[Dict]: |
| """Keep only samples where both mixture and output WAV files exist.""" |
| valid = [] |
| for s in samples: |
| mixture_path = audio_dir / s["mixture_file"] |
| output_path = audio_dir / s["output_file"] |
| if mixture_path.exists() and output_path.exists(): |
| valid.append(s) |
| return valid |
|
|
|
|
| |
| |
| |
|
|
| def _responses_dir_for_block(block_num: int) -> Path: |
| if block_num == 1: |
| return BLOCK_1_RESPONSES_DIR |
| return BLOCK_2_RESPONSES_DIR |
|
|
|
|
| def response_path_for_participant(participant_id: str, block_num: int) -> Path: |
| resp_dir = _responses_dir_for_block(block_num) |
| resp_dir.mkdir(parents=True, exist_ok=True) |
| safe_id = sanitize_participant_id(participant_id) |
| filename = f"responses_{safe_id}.csv" if safe_id else "responses.csv" |
| return resp_dir / filename |
|
|
|
|
| def completed_samples_from_responses(participant_id: str, block_num: int, block_filter: Optional[str] = None) -> Set[Tuple[str, str]]: |
| """Return set of (block, sample_id) already completed by this participant. |
| |
| If block_filter is provided (e.g. "block_1"), only return entries for that block. |
| """ |
| path = response_path_for_participant(participant_id, block_num) |
| if not path.exists(): |
| return set() |
| try: |
| df = pd.read_csv(path) |
| except Exception: |
| return set() |
| completed: Set[Tuple[str, str]] = set() |
| if "block" not in df.columns or "sample_id" not in df.columns: |
| return completed |
| for _, row in df.iterrows(): |
| block = str(row.get("block", "")) |
| sample_id = str(row.get("sample_id", "")) |
| if block and sample_id: |
| if block_filter is None or block == block_filter: |
| completed.add((block, sample_id)) |
| return completed |
|
|
|
|
| def build_response_record( |
| sample: Dict, |
| block: str, |
| audio_dir: Path, |
| instruction_followed: str = "", |
| instruction_following_mos: object = "", |
| extraction_quality_mos: object = "", |
| spatial_preservation_mos: object = "", |
| contextual_correct: str = "", |
| start_time_key: str = "", |
| ) -> Dict: |
| profile = st.session_state.get("participant_profile", {}) |
| start_time = st.session_state.get(start_time_key) |
| duration = max(0.0, time.time() - start_time) if isinstance(start_time, (int, float)) else 0.0 |
|
|
| return { |
| "timestamp_utc": dt.datetime.utcnow().isoformat(), |
| "participant_id": st.session_state.participant_id, |
| "participant_name": profile.get("participant_name", ""), |
| "hearing_condition": profile.get("hearing_condition", ""), |
| "uses_hearing_aids": profile.get("uses_hearing_aids", ""), |
| "using_headphones": profile.get("using_headphones", ""), |
| "quiet_environment": profile.get("quiet_environment", ""), |
| "consent_acknowledged": profile.get("consent_acknowledged", ""), |
| "block": block, |
| "sample_id": sample["sample_id"], |
| "model_name": sample.get("model_name", ""), |
| "mixture_audio_path": str(audio_dir / sample["mixture_file"]), |
| "output_audio_path": str(audio_dir / sample["output_file"]), |
| "scene_name": sample.get("scene_name", ""), |
| "instruction": sample.get("instruction", ""), |
| "instruction_followed": instruction_followed, |
| "instruction_following_mos": instruction_following_mos, |
| "extraction_quality_mos": extraction_quality_mos, |
| "spatial_preservation_mos": spatial_preservation_mos, |
| "contextual_correct": contextual_correct, |
| "response_duration_sec": f"{duration:.2f}", |
| } |
|
|
|
|
| def append_response(record: Dict, participant_id: str, block_num: int) -> None: |
| response_path = response_path_for_participant(participant_id, block_num) |
| new_df = pd.DataFrame([record]) |
| if response_path.exists(): |
| existing = pd.read_csv(response_path) |
| combined = pd.concat([existing, new_df], ignore_index=True) |
| else: |
| combined = new_df |
|
|
| column_order = [col for col in RESPONSE_BASE_COLUMNS if col in combined.columns] |
| remaining = sorted(col for col in combined.columns if col not in column_order) |
| combined = combined[column_order + remaining] |
| combined.to_csv(response_path, index=False) |
|
|
|
|
| |
| |
| |
|
|
| def init_session_state_single_block() -> None: |
| """Initialise session state for a single-block study.""" |
| defaults = { |
| "participant_initialized": False, |
| "participant_id": "", |
| "participant_profile": {}, |
| "participant_pending_id": "", |
| "intro_page_complete": False, |
| "instructions_page_complete": False, |
| "sample_order": [], |
| "sample_index": 0, |
| "block_complete": False, |
| "completed_samples": set(), |
| "responses": [], |
| } |
| for key, val in defaults.items(): |
| st.session_state.setdefault(key, val) |
|
|
|
|
| def start_single_block_session( |
| participant_id: str, |
| block_num: int, |
| samples: List[Dict], |
| ) -> None: |
| """Set up a session for a single-block study.""" |
| participant_id = participant_id.strip() |
| st.session_state.participant_id = participant_id |
| st.session_state.participant_initialized = True |
|
|
| |
| ids = [s["sample_id"] for s in samples] |
| random.Random(participant_id + f"_block{block_num}").shuffle(ids) |
| st.session_state.sample_order = ids |
|
|
| |
| block_label = f"block_{block_num}" |
| completed = completed_samples_from_responses(participant_id, block_num, block_filter=block_label) |
| st.session_state.completed_samples = completed |
|
|
| idx = 0 |
| all_done = True |
| for i, sid in enumerate(ids): |
| if (block_label, sid) not in completed: |
| idx = i |
| all_done = False |
| break |
| if all_done: |
| idx = len(ids) |
|
|
| st.session_state.block_complete = all_done |
| st.session_state.sample_index = idx |
| st.session_state.responses = [] |
|
|
|
|
| def advance_sample(block_num: int, sample_id: str) -> None: |
| """Mark sample complete and advance the index.""" |
| completed = set(st.session_state.get("completed_samples", set())) |
| completed.add((f"block_{block_num}", sample_id)) |
| st.session_state.completed_samples = completed |
|
|
| st.session_state.sample_index = st.session_state.get("sample_index", 0) + 1 |
|
|
| |
| prefix = f"b{block_num}" |
| for suffix in ["_unlocked", "_start"]: |
| key = f"{prefix}_{sample_id}{suffix}" |
| st.session_state.pop(key, None) |
|
|
|
|
| |
| |
| |
|
|
| def render_participant_gate( |
| block_num: int, |
| samples: List[Dict], |
| study_title: str = "Model Evaluation Study", |
| ) -> None: |
| st.sidebar.markdown( |
| f"<div style='font-size:1.3rem; font-weight:600;'>{study_title}</div>", |
| unsafe_allow_html=True, |
| ) |
| st.subheader("Fill this form to begin") |
|
|
| participant_name = st.text_input( |
| "Name or Participant ID * (to resume a previous session, enter the same ID)", |
| key="participant_name_input", |
| ) |
|
|
| if participant_name.strip(): |
| block_label = f"block_{block_num}" |
| completed = completed_samples_from_responses(participant_name, block_num, block_filter=block_label) |
| if completed: |
| total = len(samples) |
| done = len(completed) |
| remaining = max(0, total - done) |
| pct = (done / total) * 100 if total else 0 |
| if remaining: |
| st.info( |
| f"Welcome back! You've completed {done} of {total} samples " |
| f"({pct:.0f}%). {remaining} samples remain — you'll resume " |
| "where you left off." |
| ) |
| else: |
| st.success( |
| f"Great news, {participant_name.strip()}! " |
| f"You've already completed all {total} samples." |
| ) |
|
|
| if "participant_hearing_condition" not in st.session_state: |
| st.session_state.participant_hearing_condition = HEARING_OPTIONS[0] |
| hearing_condition = st.radio( |
| "Do you have any known hearing loss or hearing-related conditions?", |
| HEARING_OPTIONS, |
| key="participant_hearing_condition", |
| horizontal=True, |
| ) |
|
|
| if "participant_uses_hearing_aids" not in st.session_state: |
| st.session_state.participant_uses_hearing_aids = BOOLEAN_OPTIONS[1] |
| uses_hearing_aids = st.radio( |
| "Are you currently wearing hearing aids or assistive listening devices?", |
| BOOLEAN_OPTIONS, |
| key="participant_uses_hearing_aids", |
| horizontal=True, |
| ) |
|
|
| headphone_options = [ |
| "Yes, I confirm I am using headphones/earphones", |
| "No, I am not using headphones", |
| ] |
| if "participant_using_headphones" not in st.session_state: |
| st.session_state.participant_using_headphones = headphone_options[0] |
| using_headphones = st.radio( |
| "Are you using headphones or earphones for this study? " |
| "(Please switch to headphones if not.)", |
| headphone_options, |
| key="participant_using_headphones", |
| ) |
|
|
| if "participant_quiet_environment" not in st.session_state: |
| st.session_state.participant_quiet_environment = BOOLEAN_OPTIONS[0] |
| quiet_environment = st.radio( |
| "We recommend a quiet environment. Are you in a quiet space right now?", |
| BOOLEAN_OPTIONS, |
| key="participant_quiet_environment", |
| horizontal=True, |
| ) |
|
|
| if "participant_consent_ack" not in st.session_state: |
| st.session_state.participant_consent_ack = False |
| consent_ack = st.checkbox( |
| "I have read and understood the above, and I agree to participate in this audio-based study.", |
| key="participant_consent_ack", |
| ) |
|
|
| begin = st.button("I confirm and would like to begin the study") |
|
|
| if begin: |
| participant_name_clean = participant_name.strip() |
| errors = [] |
| if not participant_name_clean: |
| errors.append("Please provide your name or participant ID.") |
| if using_headphones == headphone_options[1]: |
| errors.append("Please switch to headphones before continuing.") |
| if not consent_ack: |
| errors.append("You must acknowledge the participation agreement to continue.") |
|
|
| if errors: |
| for msg in errors: |
| st.warning(msg) |
| return |
|
|
| profile = { |
| "participant_name": participant_name_clean, |
| "hearing_condition": hearing_condition, |
| "uses_hearing_aids": uses_hearing_aids, |
| "using_headphones": using_headphones, |
| "quiet_environment": quiet_environment, |
| "consent_acknowledged": "Yes" if consent_ack else "No", |
| } |
| st.session_state.participant_profile = profile |
| st.session_state.participant_pending_id = participant_name_clean |
| st.session_state.participant_initialized = False |
| st.session_state.intro_page_complete = False |
| st.session_state.instructions_page_complete = False |
| block_label = f"block_{block_num}" |
| st.session_state.completed_samples = completed_samples_from_responses( |
| participant_name_clean, block_num, block_filter=block_label |
| ) |
| rerun_app() |
|
|
|
|
| def render_intro_page(description: str) -> None: |
| render_sidebar_image() |
| st.title("Welcome to the Model Evaluation Study") |
| intro_html = ( |
| "<div style='font-size:1.15rem; line-height:1.8;'>" |
| + description.strip().replace("\n\n", "<br><br>").replace("\n", "<br>") |
| + "</div>" |
| ) |
| st.markdown(intro_html, unsafe_allow_html=True) |
| if st.button("Next: Detailed instructions"): |
| st.session_state.intro_page_complete = True |
| rerun_app() |
|
|
|
|
| def render_instruction_page( |
| block_num: int, |
| samples: List[Dict], |
| instructions_text: str, |
| ) -> None: |
| render_sidebar_image() |
| st.title("Study Instructions") |
| st.markdown( |
| instructions_text.replace("\n\n", "<br><br>").replace("\n", "<br>"), |
| unsafe_allow_html=True, |
| ) |
|
|
| if st.button("I understand and I'm ready to begin"): |
| participant_id = st.session_state.get("participant_pending_id", "").strip() |
| if not participant_id: |
| st.warning("Participant information missing. Please refill the form.") |
| st.session_state.participant_profile = {} |
| st.session_state.intro_page_complete = False |
| st.session_state.instructions_page_complete = False |
| rerun_app() |
| return |
| start_single_block_session(participant_id, block_num, samples) |
| st.session_state.instructions_page_complete = True |
| rerun_app() |
|
|
|
|
| def render_sidebar_progress(block_num: int) -> None: |
| pid = st.session_state.participant_id |
| st.sidebar.markdown(f"**Participant:** {pid}") |
|
|
| completed = st.session_state.get("completed_samples", set()) |
| total = len(st.session_state.sample_order) |
| block_label = f"block_{block_num}" |
| done = sum(1 for b, _ in completed if b == block_label) |
|
|
| if total > 0: |
| st.sidebar.progress(done / total) |
| st.sidebar.markdown(f"Progress: **{done} / {total}**") |
|
|
| st.sidebar.markdown("---") |
| st.sidebar.markdown("**Instructions (for reference)**") |
| st.sidebar.markdown(SIDEBAR_INSTRUCTIONS_SHORT) |
|
|
