Skip to content

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

Python

Delete the snippets with all speakers and remove snippets already orphaned (#475)

Murtaza Nasir120ed65ac5ec
diff --git a/src/api/speakers.py b/src/api/speakers.py
index 29dc9400..0ed04a27 100644
--- a/src/api/speakers.py
+++ b/src/api/speakers.py
@@ -220,8 +220,13 @@ def delete_speaker(speaker_id):
def delete_all_speakers():
"""Delete all speakers for the current user."""
try:
- # Bulk delete skips ORM cascades, so the voice samples go first.
+ # Bulk delete skips ORM cascades, and SQLite does not enforce the
+ # ON DELETE CASCADE rules, so the snippets and voice samples go first (#475).
from src.models import SpeakerVoiceSample
+ from src.models.speaker_snippet import SpeakerSnippet
+ speaker_ids = db.session.query(Speaker.id).filter_by(user_id=current_user.id)
+ SpeakerSnippet.query.filter(SpeakerSnippet.speaker_id.in_(speaker_ids)).delete(
+ synchronize_session=False)
SpeakerVoiceSample.query.filter_by(user_id=current_user.id).delete()
deleted_count = Speaker.query.filter_by(user_id=current_user.id).delete()
db.session.commit()
diff --git a/src/init_db.py b/src/init_db.py
index 7e4b2767..ef877e01 100644
--- a/src/init_db.py
+++ b/src/init_db.py
@@ -105,6 +105,24 @@ def _remove_orphaned_user_new(engine, app):
app.logger.warning(f"Could not clean up orphaned user_new table: {e}")
+def _remove_orphaned_speaker_rows(engine, app):
+ """Delete speaker snippets and voice samples whose speaker or recording is gone.
+
+ SQLite does not enforce ON DELETE CASCADE, and before #475 "delete all
+ speakers" did not remove these rows itself.
+ """
+ with engine.begin() as conn:
+ snippets = conn.execute(text(
+ 'DELETE FROM speaker_snippet WHERE speaker_id NOT IN (SELECT id FROM speaker) '
+ 'OR recording_id NOT IN (SELECT id FROM recording)')).rowcount
+ samples = conn.execute(text(
+ 'DELETE FROM speaker_voice_sample '
+ 'WHERE speaker_id NOT IN (SELECT id FROM speaker)')).rowcount
+ if snippets or samples:
+ app.logger.info(f"Removed {snippets} orphaned speaker snippet(s) "
+ f"and {samples} orphaned voice sample(s)")
+
+
def initialize_database(app):
"""
Initialize database schema and run migrations.
@@ -1166,6 +1184,14 @@ def _run_migrations(app, engine):
db.session.rollback()
app.logger.warning(f"Transcript speaker linking skipped, retried next start: {e}")
+ # "Delete all speakers" used to leave the speakers' snippets behind (#475).
+ try:
+ run_once(engine, '0004_remove_orphaned_speaker_rows',
+ lambda eng: _remove_orphaned_speaker_rows(eng, app), logger=app.logger)
+ except Exception as e:
+ db.session.rollback()
+ app.logger.warning(f"Orphaned speaker row cleanup skipped, retried next start: {e}")
+
with _migration_section(app, failures, "inquire mode chunk backfill"):
# Process existing recordings for inquire mode (chunk and embed them)
# Only run if inquire mode is enabled
diff --git a/tests/test_speaker_bulk_delete.py b/tests/test_speaker_bulk_delete.py
new file mode 100644
index 00000000..69c5a394
--- /dev/null
+++ b/tests/test_speaker_bulk_delete.py
@@ -0,0 +1,102 @@
+"""Deleting all speakers removes their snippets and voice samples (#475).
+
+SHARED-DB: users, speakers, snippets and recordings are removed afterwards.
+"""
+
+import os
+import secrets
+import sys
+
+import pytest
+from sqlalchemy import text
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.app import app, db
+from src.init_db import _remove_orphaned_speaker_rows
+from src.models import Recording, Speaker, SpeakerVoiceSample, User
+from src.models.speaker_snippet import SpeakerSnippet
+
+
+def _make_speaker_with_rows(user, rec, name):
+ speaker = Speaker(name=name, user_id=user.id)
+ db.session.add(speaker)
+ db.session.commit()
+ db.session.add(SpeakerSnippet(speaker_id=speaker.id, recording_id=rec.id,
+ segment_index=0, text_snippet='hello there'))
+ db.session.add(SpeakerVoiceSample(user_id=user.id, speaker_id=speaker.id,
+ embedding=b'\0' * 16, dimension=4))
+ db.session.commit()
+ return speaker.id
+
+
+def world():
+ saved = app.config.get('WTF_CSRF_ENABLED', True)
+ app.config['WTF_CSRF_ENABLED'] = False
+ with app.app_context():
+ s = secrets.token_hex(4)
+ owner = User(username=f"sbd_{s}", email=f"sbd_{s}@local.test", password="x")
+ other = User(username=f"sbdo_{s}", email=f"sbdo_{s}@local.test", password="x")
+ db.session.add_all([owner, other])
+ db.session.commit()
+ rec = Recording(user_id=owner.id, title='t', status='COMPLETED')
+ other_rec = Recording(user_id=other.id, title='t', status='COMPLETED')
+ db.session.add_all([rec, other_rec])
+ db.session.commit()
+ ids = dict(owner=owner.id, other=other.id, recs=[rec.id, other_rec.id],
+ mine=_make_speaker_with_rows(owner, rec, 'Dana'),
+ theirs=_make_speaker_with_rows(other, other_rec, 'Lee'))
+ yield ids
+ app.config['WTF_CSRF_ENABLED'] = saved
+ with app.app_context():
+ db.session.rollback()
+ users = [ids['owner'], ids['other']]
+ SpeakerSnippet.query.filter(SpeakerSnippet.recording_id.in_(ids['recs'])).delete(synchronize_session=False)
+ SpeakerVoiceSample.query.filter(SpeakerVoiceSample.user_id.in_(users)).delete(synchronize_session=False)
+ Speaker.query.filter(Speaker.user_id.in_(users)).delete(synchronize_session=False)
+ Recording.query.filter(Recording.id.in_(ids['recs'])).delete(synchronize_session=False)
+ User.query.filter(User.id.in_(users)).delete(synchronize_session=False)
+ db.session.commit()
+
+
+def _client_for(user_id):
+ from flask import g
+ client = app.test_client()
+ with client.session_transaction() as sess:
+ sess['_user_id'] = db.session.get(User, user_id).get_id()
+ sess['_fresh'] = True
+ g.pop('_login_user', None)
+ return client
+
+
+def test_delete_all_removes_snippets_and_voice_samples(world):
+ with app.app_context():
+ resp = _client_for(world['owner']).delete('/speakers/delete_all')
+ assert resp.status_code == 200, resp.data
+ assert resp.get_json()['deleted_count'] == 1
+ db.session.expire_all()
+ assert SpeakerSnippet.query.filter_by(speaker_id=world['mine']).count() == 0
+ assert SpeakerVoiceSample.query.filter_by(speaker_id=world['mine']).count() == 0
+ # Another user's speaker and rows are untouched.
+ assert db.session.get(Speaker, world['theirs']) is not None
+ assert SpeakerSnippet.query.filter_by(speaker_id=world['theirs']).count() == 1
+ assert SpeakerVoiceSample.query.filter_by(speaker_id=world['theirs']).count() == 1
+
+
+def test_cleanup_removes_rows_left_by_the_old_bulk_delete(world):
+ with app.app_context():
+ if db.engine.dialect.name != 'sqlite':
+ pytest.skip('Only SQLite can hold these orphans; PostgreSQL enforces the cascade')
+ # Reproduce the old bulk delete: the speaker row goes, its rows stay.
+ with db.engine.begin() as conn:
+ conn.execute(text('DELETE FROM speaker WHERE id = :id'), {'id': world['mine']})
+ assert SpeakerSnippet.query.filter_by(speaker_id=world['mine']).count() == 1
+
+ _remove_orphaned_speaker_rows(db.engine, app)
+
+ db.session.expire_all()
+ assert SpeakerSnippet.query.filter_by(speaker_id=world['mine']).count() == 0
+ assert SpeakerVoiceSample.query.filter_by(speaker_id=world['mine']).count() == 0
+ assert SpeakerSnippet.query.filter_by(speaker_id=world['theirs']).count() == 1
+ assert SpeakerVoiceSample.query.filter_by(speaker_id=world['theirs']).count() == 1