Skip to content

Speakr is a personal, self-hosted web application designed for transcribing audio recordings

Python

fix: apply speaker names through one helper in both save routes, so saving with a staged line edit also updates voice profiles and snippets, and match saved speakers ignoring case instead of creating a second profile per spelling (#395)

Murtaza Nasir31adc3b0df2f
diff --git a/src/api/recordings.py b/src/api/recordings.py
index db514cf7..d7f20f60 100644
--- a/src/api/recordings.py
+++ b/src/api/recordings.py
@@ -40,9 +40,9 @@ from src.tasks.processing import format_transcription_for_llm, _resolve_timestam
from src.utils.dates import to_utc_naive
from src.utils.ffmpeg_utils import FFmpegError, FFmpegNotFoundError
from src.utils.titles import resolve_upload_title
-from src.services.speaker import update_speaker_usage
-from src.services.speaker_embedding_matcher import update_speaker_embedding
-from src.services.speaker_snippets import create_speaker_snippets
+from src.services.speaker import (
+ update_speaker_usage, apply_speaker_map, participants_from_segments, update_voice_profiles,
+)
# Incognito mode - disabled by default, enable via environment variable
ENABLE_INCOGNITO_MODE = os.environ.get('ENABLE_INCOGNITO_MODE', 'false').lower() == 'true'
@@ -944,34 +944,11 @@ def update_speakers(recording_id):
speaker_names_used = []
+ label_to_name = {}
if is_json:
- # Handle new simplified JSON transcript (list of segments)
- for segment in transcription_data:
- original_speaker_label = segment.get('speaker')
- if original_speaker_label in speaker_map:
- new_name_info = speaker_map[original_speaker_label]
- new_name = new_name_info.get('name', '').strip()
- # If isMe is checked but no name provided, use current user's name
- if new_name_info.get('isMe') and not new_name:
- new_name = current_user.name or 'Me'
-
- if new_name:
- segment['speaker'] = new_name
- if new_name not in speaker_names_used:
- speaker_names_used.append(new_name)
-
+ speaker_names_used, label_to_name = apply_speaker_map(transcription_data, speaker_map, current_user)
recording.transcription = json.dumps(transcription_data)
-
- # Update participants only from speakers that were actually given names (not default labels)
- final_speakers = set()
- for seg in transcription_data:
- speaker = seg.get('speaker')
- if speaker and str(speaker).strip():
- # Only include speakers that have been given actual names (not default labels like "SPEAKER_01", "SPEAKER_09", etc.)
- # Check if this speaker was updated with a real name (not a default label)
- if not re.match(r'^SPEAKER_\d+$', str(speaker), re.IGNORECASE):
- final_speakers.add(speaker)
- recording.participants = ', '.join(sorted(list(final_speakers)))
+ recording.participants = participants_from_segments(transcription_data)
else:
# Handle plain text transcript
@@ -996,61 +973,8 @@ def update_speakers(recording_id):
if speaker_names_used:
update_speaker_usage(speaker_names_used)
- # Update speaker voice embeddings if available
- embeddings_updated = 0
- snippets_created = 0
- if recording.speaker_embeddings and speaker_map:
- try:
- # Parse embeddings from recording
- embeddings_data = json.loads(recording.speaker_embeddings) if isinstance(recording.speaker_embeddings, str) else recording.speaker_embeddings
-
- # Build reverse map: SPEAKER_XX -> actual name assigned
- speaker_label_to_name = {}
- for speaker_label, speaker_info in speaker_map.items():
- name = speaker_info.get('name', '').strip()
- # Handle isMe checkbox
- if speaker_info.get('isMe') and not name:
- name = current_user.name or 'Me'
-
- # Only include speakers that were given real names (not SPEAKER_XX)
- if name and not re.match(r'^SPEAKER_\d+$', name, re.IGNORECASE):
- speaker_label_to_name[speaker_label] = name
-
- # Update embeddings for each identified speaker
- for speaker_label, embedding in embeddings_data.items():
- if speaker_label in speaker_label_to_name and embedding and len(embedding) == 256:
- speaker_name = speaker_label_to_name[speaker_label]
-
- # Find or create the speaker
- speaker = Speaker.query.filter_by(
- user_id=current_user.id,
- name=speaker_name
- ).first()
-
- if speaker:
- # Update the speaker's voice embedding
- similarity = update_speaker_embedding(speaker, embedding, recording.id)
- embeddings_updated += 1
-
- if similarity is not None:
- current_app.logger.info(
- f"Updated voice profile for '{speaker_name}' "
- f"(similarity: {similarity*100:.1f}%)"
- )
- else:
- current_app.logger.info(
- f"Created initial voice profile for '{speaker_name}'"
- )
-
- # Create snippets for identified speakers
- if speaker_label_to_name:
- snippets_created = create_speaker_snippets(recording.id, speaker_map)
- if snippets_created > 0:
- current_app.logger.info(f"Created {snippets_created} speaker snippets")
-
- except Exception as e:
- current_app.logger.error(f"Error updating speaker embeddings: {e}", exc_info=True)
- # Don't fail the whole request if embedding update fails
+ # Update speaker voice embeddings and snippets if available
+ update_voice_profiles(recording, label_to_name, current_user)
db.session.commit()
@@ -1107,40 +1031,21 @@ def update_transcript(recording_id):
if not transcript_data or not isinstance(transcript_data, list):
return jsonify({'error': 'Invalid transcript data provided'}), 400
- # Update speaker names in the transcript data
- speaker_names_used = []
- for segment in transcript_data:
- original_speaker_label = segment.get('speaker')
-
- # Apply speaker name mapping if provided
- if original_speaker_label in speaker_map:
- new_name_info = speaker_map[original_speaker_label]
- new_name = new_name_info.get('name', '').strip()
- if new_name_info.get('isMe'):
- new_name = current_user.name or 'Me'
-
- if new_name:
- segment['speaker'] = new_name
- if new_name not in speaker_names_used:
- speaker_names_used.append(new_name)
+ # Apply the names exactly as update_speakers does, including the voice
+ # profiles and snippets: this route saves the names whenever the user
+ # also staged a line edit in the speaker modal.
+ speaker_names_used, label_to_name = apply_speaker_map(transcript_data, speaker_map, current_user)
# Save the updated transcript
recording.transcription = json.dumps(transcript_data)
-
- # Update participants
- final_speakers = set()
- for seg in transcript_data:
- speaker = seg.get('speaker')
- if speaker and str(speaker).strip():
- # Only include speakers with real names (not default labels)
- if not re.match(r'^SPEAKER_\d+$', str(speaker), re.IGNORECASE):
- final_speakers.add(speaker)
- recording.participants = ', '.join(sorted(list(final_speakers)))
+ recording.participants = participants_from_segments(transcript_data)
# Update speaker usage statistics
if speaker_names_used:
update_speaker_usage(speaker_names_used)
+ update_voice_profiles(recording, label_to_name, current_user)
+
db.session.commit()
# The transcript text changed — rebuild Inquire chunks so semantic
diff --git a/src/api/speakers.py b/src/api/speakers.py
index 878ee5e0..b386b573 100644
--- a/src/api/speakers.py
+++ b/src/api/speakers.py
@@ -66,17 +66,23 @@ def get_speakers():
@speakers_bp.route('/speakers/search', methods=['GET'])
@login_required
def search_speakers():
- """Search speakers by name for autocomplete functionality."""
+ """Search speakers by name for autocomplete functionality.
+
+ With an empty ``q`` and ``top=1`` it returns the most-used speakers, so a
+ name field can offer suggestions before anything is typed (#395).
+ """
try:
query = request.args.get('q', '').strip()
- if not query:
+ top = request.args.get('top', '').lower() in ('1', 'true')
+ if not query and not top:
return jsonify([])
-
- speakers = Speaker.query.filter_by(user_id=current_user.id)\
- .filter(Speaker.name.ilike(f'%{query}%'))\
- .order_by(Speaker.use_count.desc(), Speaker.last_used.desc())\
- .limit(10)\
- .all()
+
+ stmt = Speaker.query.filter_by(user_id=current_user.id)
+ if query:
+ stmt = stmt.filter(Speaker.name.ilike(f'%{query}%'))
+ speakers = stmt.order_by(Speaker.use_count.desc(), Speaker.last_used.desc())\
+ .limit(10)\
+ .all()
return jsonify([speaker.to_dict() for speaker in speakers])
except Exception as e:
diff --git a/src/services/speaker.py b/src/services/speaker.py
index da896185..06778069 100644
--- a/src/services/speaker.py
+++ b/src/services/speaker.py
@@ -2,14 +2,129 @@
Speaker identification and management services.
"""
+import re
from datetime import datetime
from flask import current_app
from flask_login import current_user
+from sqlalchemy import func
from src.database import db
from src.models import Speaker
+DEFAULT_LABEL = re.compile(r'^SPEAKER_\d+$', re.IGNORECASE)
+
+
+def find_user_speaker(user_id, name):
+ """The user's saved speaker with this name, ignoring case.
+
+ "john" and "John" are the same person. An exact lookup created a second
+ profile for each spelling, splitting the use counts and voice embeddings
+ between them (#395). When older data already holds several spellings, the
+ most-used one wins.
+ """
+ if not name:
+ return None
+ return (Speaker.query
+ .filter(Speaker.user_id == user_id, func.lower(Speaker.name) == name.strip().lower())
+ .order_by(Speaker.use_count.desc(), Speaker.id.asc())
+ .first())
+
+
+def _resolve_name(info, user):
+ name = (info or {}).get('name', '') or ''
+ name = name.strip()
+ if (info or {}).get('isMe') and not name:
+ name = (user.name if user else None) or 'Me'
+ if not name:
+ return ''
+ existing = find_user_speaker(user.id, name) if user else None
+ return existing.name if existing else name
+
+
+def apply_speaker_map(segments, speaker_map, user):
+ """Rename the segments of a JSON transcript in place.
+
+ speaker_map is {label: {'name': str, 'isMe': bool}}. A name that matches a
+ saved speaker ignoring case takes the saved spelling, so the transcript,
+ the speaker list and the voice profile all agree.
+
+ Returns (names_used, label_to_name). label_to_name only holds real names,
+ never another SPEAKER_XX label.
+ """
+ label_to_name = {}
+ spelling = {} # lowercased name -> first spelling in this save
+ for label, info in (speaker_map or {}).items():
+ name = _resolve_name(info, user)
+ if name:
+ label_to_name[label] = spelling.setdefault(name.lower(), name)
+
+ names_used = []
+ for segment in segments:
+ name = label_to_name.get(segment.get('speaker'))
+ if name:
+ segment['speaker'] = name
+ if name not in names_used:
+ names_used.append(name)
+
+ return names_used, {k: v for k, v in label_to_name.items() if not DEFAULT_LABEL.match(v)}
+
+
+def participants_from_segments(segments):
+ """Comma-separated real speaker names, leaving out SPEAKER_XX labels."""
+ names = {
+ str(seg.get('speaker')).strip() for seg in segments
+ if seg.get('speaker') and str(seg.get('speaker')).strip()
+ and not DEFAULT_LABEL.match(str(seg.get('speaker')).strip())
+ }
+ return ', '.join(sorted(names))
+
+
+def update_voice_profiles(recording, label_to_name, user):
+ """Fold this recording's per-label voice embeddings into the named profiles
+ and refresh the recording's speaker snippets.
+
+ Both save routes call this. update_transcript used to skip it, so saving
+ names alongside any line edit left voice profiles and snippets untouched.
+ Returns (embeddings_updated, snippets_created). Never raises.
+ """
+ from src.services.speaker_embedding_matcher import update_speaker_embedding
+ from src.services.speaker_snippets import create_speaker_snippets
+ import json
+
+ if not recording.speaker_embeddings or not label_to_name:
+ return 0, 0
+
+ embeddings_updated = 0
+ snippets_created = 0
+ try:
+ embeddings_data = (json.loads(recording.speaker_embeddings)
+ if isinstance(recording.speaker_embeddings, str)
+ else recording.speaker_embeddings)
+ for label, embedding in (embeddings_data or {}).items():
+ name = label_to_name.get(label)
+ if not name or not embedding or len(embedding) != 256:
+ continue
+ speaker = find_user_speaker(user.id, name)
+ if not speaker:
+ continue
+ similarity = update_speaker_embedding(speaker, embedding, recording.id)
+ embeddings_updated += 1
+ if similarity is not None:
+ current_app.logger.info(f"Updated voice profile for '{name}' (similarity: {similarity*100:.1f}%)")
+ else:
+ current_app.logger.info(f"Created initial voice profile for '{name}'")
+
+ snippets_created = create_speaker_snippets(
+ recording.id, {label: {'name': name} for label, name in label_to_name.items()})
+ if snippets_created > 0:
+ current_app.logger.info(f"Created {snippets_created} speaker snippets")
+ except Exception as e:
+ current_app.logger.error(f"Error updating speaker embeddings: {e}", exc_info=True)
+
+ return embeddings_updated, snippets_created
+
+
def update_speaker_usage(speaker_names):
"""Helper function to update speaker usage statistics."""
if not speaker_names or not current_user.is_authenticated:
@@ -21,7 +136,7 @@ def update_speaker_usage(speaker_names):
if not name:
continue
- speaker = Speaker.query.filter_by(user_id=current_user.id, name=name).first()
+ speaker = find_user_speaker(current_user.id, name)
if speaker:
speaker.use_count += 1
speaker.last_used = datetime.utcnow()
diff --git a/tests/test_speaker_save_paths.py b/tests/test_speaker_save_paths.py
new file mode 100644
index 00000000..364dd586
--- /dev/null
+++ b/tests/test_speaker_save_paths.py
@@ -0,0 +1,143 @@
+"""Both speaker save routes apply names the same way (#395).
+
+The speaker modal saves through update_speakers, or through update_transcript
+when a line edit is staged. update_transcript used to rename the segments but
+skip the voice profiles and snippets, and both routes matched saved speakers
+by exact name, so "john" created a second profile next to "John".
+
+SHARED-DB: every assertion is scoped to the user and recording the test made.
+"""
+
+import json
+import os
+import sys
+import uuid
+from unittest.mock import patch
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.app import app, db
+from src.models import User, Recording, Speaker
+
+app.config["WTF_CSRF_ENABLED"] = False
+
+EMB = [0.1] * 256
+
+
+def _user():
+ suffix = uuid.uuid4().hex[:8]
+ user = User(username=f"spk_{suffix}", email=f"spk_{suffix}@local.test", password="x", name="Owner Person")
+ db.session.add(user)
+ db.session.commit()
+ return user
+
+
+def _recording(user, segments, embeddings=None):
+ rec = Recording(user_id=user.id, title="r", status="COMPLETED",
+ audio_path="local://recordings/x.mp3", original_filename="x.mp3",
+ transcription=json.dumps(segments), speaker_embeddings=embeddings)
+ db.session.add(rec)
+ db.session.commit()
+ return rec
+
+
+def _client(user):
+ c = app.test_client()
+ with c.session_transaction() as sess:
+ sess["_user_id"] = str(user.id)
+ sess["_fresh"] = True
+ return c
+
+
+SEGMENTS = [
+ {"speaker": "SPEAKER_00", "sentence": "Good morning everyone, let us begin.", "start_time": 0.0, "end_time": 3.0},
+ {"speaker": "SPEAKER_01", "sentence": "Thanks, I have the quarterly numbers ready.", "start_time": 3.0, "end_time": 6.0},
+ {"speaker": "SPEAKER_02", "sentence": "Yes.", "start_time": 6.0, "end_time": 6.5},
+]
+
+
+def ctx():
+ with app.app_context():
+ yield
+
+
+def test_update_speakers_reuses_the_saved_spelling(ctx):
+ user = _user()
+ db.session.add(Speaker(name="John Smith", user_id=user.id, use_count=3))
+ db.session.commit()
+ rec = _recording(user, SEGMENTS)
+
+ r = _client(user).post(f"/recording/{rec.id}/update_speakers", json={
+ "speaker_map": {"SPEAKER_00": {"name": "john smith"}, "SPEAKER_01": {"name": "Ana"}},
+ })
+ assert r.status_code == 200
+ saved = json.loads(db.session.get(Recording, rec.id).transcription)
+ assert [s["speaker"] for s in saved] == ["John Smith", "Ana", "SPEAKER_02"]
+ rows = Speaker.query.filter_by(user_id=user.id).all()
+ assert sorted(s.name for s in rows) == ["Ana", "John Smith"]
+ assert next(s for s in rows if s.name == "John Smith").use_count == 4
+ assert db.session.get(Recording, rec.id).participants == "Ana, John Smith"
+
+
+def test_two_labels_with_one_name_merge_into_one_speaker(ctx):
+ user = _user()
+ rec = _recording(user, SEGMENTS)
+ r = _client(user).post(f"/recording/{rec.id}/update_speakers", json={
+ "speaker_map": {"SPEAKER_00": {"name": "Ana"}, "SPEAKER_02": {"name": "ana"}},
+ })
+ assert r.status_code == 200
+ saved = json.loads(db.session.get(Recording, rec.id).transcription)
+ # The first spelling creates the profile; the second resolves to it.
+ assert {saved[0]["speaker"], saved[2]["speaker"]} == {"Ana"}
+ assert Speaker.query.filter_by(user_id=user.id).count() == 1
+
+
[email protected]("route", ["update_speakers", "update_transcript"])
+def test_both_routes_update_voice_profiles_and_snippets(ctx, route):
+ user = _user()
+ rec = _recording(user, SEGMENTS, embeddings={"SPEAKER_00": EMB, "SPEAKER_01": EMB})
+ body = {"speaker_map": {"SPEAKER_00": {"name": "Ana"}}}
+ if route == "update_transcript":
+ staged = json.loads(rec.transcription)
+ staged[2]["speaker"] = "SPEAKER_00" # a staged per-line reassignment
+ body["transcript_data"] = staged
+
+ with patch("src.services.speaker_embedding_matcher.update_speaker_embedding", return_value=None) as upd, \
+ patch("src.services.speaker_snippets.create_speaker_snippets", return_value=2) as snip:
+ r = _client(user).post(f"/recording/{rec.id}/{route}", json=body)
+
+ assert r.status_code == 200
+ assert upd.call_count == 1
+ speaker, embedding, rec_id = upd.call_args.args
+ assert speaker.name == "Ana" and rec_id == rec.id and len(embedding) == 256
+ snip.assert_called_once()
+ assert snip.call_args.args[1] == {"SPEAKER_00": {"name": "Ana"}}
+ saved = json.loads(db.session.get(Recording, rec.id).transcription)
+ if route == "update_transcript":
+ assert saved[2]["speaker"] == "Ana"
+
+
+def test_is_me_without_a_name_uses_the_account_name(ctx):
+ user = _user()
+ rec = _recording(user, SEGMENTS)
+ r = _client(user).post(f"/recording/{rec.id}/update_transcript", json={
+ "transcript_data": json.loads(rec.transcription),
+ "speaker_map": {"SPEAKER_01": {"name": "", "isMe": True}},
+ })
+ assert r.status_code == 200
+ assert json.loads(db.session.get(Recording, rec.id).transcription)[1]["speaker"] == "Owner Person"
+
+
+def test_search_top_lists_most_used_without_a_query(ctx):
+ user = _user()
+ for name, count in (("Rare", 1), ("Frequent", 9), ("Middle", 4)):
+ db.session.add(Speaker(name=name, user_id=user.id, use_count=count))
+ db.session.commit()
+ c = _client(user)
+ assert c.get("/speakers/search?q=").get_json() == []
+ names = [s["name"] for s in c.get("/speakers/search?top=1").get_json()]
+ assert names == ["Frequent", "Middle", "Rare"]
+ assert [s["name"] for s in c.get("/speakers/search?q=mid&top=1").get_json()] == ["Middle"]