Speakr is a personal, self-hosted web application designed for transcribing audio recordings
Python
Fix pre-release review findings: per-user voice samples, label map on rename, one complete delete for bulk/batch/merge, per-user API v1 archive with strict parsing, vectorised calibration, audio-removed endpoint alias
Murtaza Nasir18ffcd072d30
diff --git a/src/api/api_v1.py b/src/api/api_v1.pyindex 0594ee5d..47d9092b 100644--- a/src/api/api_v1.py+++ b/src/api/api_v1.py@@ -30,6 +30,7 @@ from werkzeug.exceptions import RequestEntityTooLargefrom werkzeug.utils import secure_filenamefrom src.database import db+from src.services.recording_state import get_user_archived, set_user_archived, parse_archived_flagfrom src.models import Recording, User, Tag, RecordingTag, Speaker, Eventfrom src.models.processing_job import ProcessingJobfrom src.models.token_usage import TokenUsage@@ -1025,7 +1026,7 @@ def get_recording(recording_id):'mime_type': recording.mime_type,'is_inbox': recording.is_inbox,'is_highlighted': recording.is_highlighted,- 'is_archived': bool(recording.is_archived),+ 'is_archived': get_user_archived(recording, current_user),'audio_available': recording.audio_deleted_at is None,'audio_duration': recording.get_audio_duration(),'processing_time_seconds': recording.processing_time_seconds,@@ -1263,7 +1264,12 @@ def update_recording(recording_id):recording.is_highlighted = bool(data['is_highlighted'])changed_fields.append('is_highlighted')if 'is_archived' in data:- recording.is_archived = bool(data['is_archived'])+ archived = parse_archived_flag(data['is_archived'])+ if archived is None:+ return jsonify({'error': 'is_archived must be a boolean'}), 400+ # Per user, like the web app: a shared editor archives it for+ # themselves only (#394).+ set_user_archived(recording, current_user, archived, commit=False)changed_fields.append('is_archived')if 'folder_id' in data:new_folder_id = data['folder_id']@@ -1319,7 +1325,7 @@ def update_recording(recording_id):'meeting_date': recording.meeting_date.isoformat() if recording.meeting_date else None,'is_inbox': recording.is_inbox,'is_highlighted': recording.is_highlighted,- 'is_archived': bool(recording.is_archived),+ 'is_archived': get_user_archived(recording, current_user),'folder_id': recording.folder_id}})@@ -2681,6 +2687,12 @@ def batch_update_recordings():return jsonify({'error': 'No access to target folder'}), 403target_folder_id = new_folder_id+ batch_archived = None+ if 'is_archived' in updates:+ batch_archived = parse_archived_flag(updates['is_archived'])+ if batch_archived is None:+ return jsonify({'error': 'is_archived must be a boolean'}), 400+results = []for recording_id in recording_ids:recording = db.session.get(Recording, recording_id)@@ -2698,7 +2710,7 @@ def batch_update_recordings():if 'is_highlighted' in updates:recording.is_highlighted = bool(updates['is_highlighted'])if 'is_archived' in updates:- recording.is_archived = bool(updates['is_archived'])+ set_user_archived(recording, current_user, batch_archived, commit=False)if 'folder_id' in updates:# `target_folder_id` already validated above (None to remove,# or a valid folder id the caller has access to).@@ -2807,18 +2819,17 @@ def batch_delete_recordings():continuetry:- # Delete audio file- if recording.audio_path:- audio_path = os.path.join(current_app.config.get('UPLOAD_FOLDER', 'uploads'), recording.audio_path)- if os.path.exists(audio_path):- os.remove(audio_path)-- db.session.delete(recording)+ from src.services.recording_deletion import delete_recording_completely+ delete_recording_completely(recording)results.append({'id': recording_id, 'success': True})except Exception as e:- results.append({'id': recording_id, 'success': False, 'error': str(e)})+ db.session.rollback()+ current_app.logger.error(f"Error deleting recording {recording_id}: {e}")+ results.append({'id': recording_id, 'success': False, 'error': 'Delete failed'})- db.session.commit()+ if any(r['success'] for r in results):+ from src.services.recording_deletion import cleanup_orphaned_speakers_quietly+ cleanup_orphaned_speakers_quietly()success_count = sum(1 for r in results if r['success'])return jsonify({diff --git a/src/api/recordings.py b/src/api/recordings.pyindex 59901b75..9fa5a377 100644--- a/src/api/recordings.py+++ b/src/api/recordings.py@@ -23,6 +23,7 @@ from email.utils import encode_rfc2231from urllib.parse import quotefrom src.database import db+from src.services.recording_deletion import delete_recording_completely, cleanup_orphaned_speakers_quietlyfrom src.models import *from src.utils import *from src.config.app_config import ASR_MIN_SPEAKERS, ASR_MAX_SPEAKERS, ASR_DIARIZE, USE_NEW_TRANSCRIPTION_ARCHITECTURE@@ -3463,10 +3464,16 @@ def get_inbox_recordings():return jsonify({'error': str(e)}), 500+@recordings_bp.route('/api/recordings/audio-removed', methods=['GET'])@recordings_bp.route('/api/recordings/archived', methods=['GET'])@login_requireddef get_archived_recordings():- """Get recordings where audio has been deleted but transcription remains."""+ """Get recordings where audio has been deleted but transcription remains.++ /api/recordings/archived is the name from before #394 and is kept for+ existing callers; it does not list recordings archived by the user (use+ GET /api/recordings?archived=true for those).+ """from sqlalchemy import selecttry:search_query = request.args.get('q', '').strip()@@ -4374,28 +4381,16 @@ def bulk_delete_recordings():errors.append(f"No permission for recording {recording_id}")continue- # Delete audio file- if recording.audio_path:- try:- get_storage_service().delete(recording.audio_path, missing_ok=True)- except Exception as e:- current_app.logger.error(f"Error deleting audio file {recording.audio_path}: {e}")-- # Delete associated records with NOT NULL recording_id constraints- from src.models import ProcessingJob- from src.models.speaker_snippet import SpeakerSnippet- SpeakerSnippet.query.filter_by(recording_id=recording_id).delete()- ProcessingJob.query.filter_by(recording_id=recording_id).delete()-- # Delete the recording- db.session.delete(recording)+ delete_recording_completely(recording, storage=get_storage_service())deleted_ids.append(recording_id)except Exception as e:+ db.session.rollback()current_app.logger.error(f"Error deleting recording {recording_id}: {e}")errors.append(f"Error with recording {recording_id}")- db.session.commit()+ if deleted_ids:+ cleanup_orphaned_speakers_quietly()return jsonify({'success': True,diff --git a/src/api/speakers.py b/src/api/speakers.pyindex 6da046a3..5b00c4b1 100644--- a/src/api/speakers.py+++ b/src/api/speakers.py@@ -216,6 +216,14 @@ def update_speaker(speaker_id):# Not JSON or invalid format, skippass+ # The label map records which name each diarization label shows;+ # without this the next save would think the voice was removed.+ if recording.speaker_label_map and old_name in recording.speaker_label_map.values():+ recording.speaker_label_map = {+ label: (new_name if name == old_name else name)+ for label, name in recording.speaker_label_map.items()}+ updated = True+if updated:recordings_updated += 1@@ -398,7 +406,8 @@ def list_voice_samples(speaker_id):rec_ids = [r.recording_id for r in rows if r.recording_id]if rec_ids:for rec in Recording.query.filter(Recording.id.in_(rec_ids)).all():- titles[rec.id] = rec.title+ if has_recording_access(rec, current_user, require_edit=False):+ titles[rec.id] = rec.titlecurrent = effective_space(current_space_id())samples = []if not rows and speaker.average_embedding:@@ -412,6 +421,8 @@ def list_voice_samples(speaker_id):for r in sorted(rows, key=lambda r: r.updated_at or r.created_at, reverse=True):item = r.to_dict()item['recording_title'] = titles.get(r.recording_id)+ if r.recording_id not in titles:+ item['recording_id'] = None # deleted, or no longer shared with this useritem['in_current_space'] = effective_space(r.space_id) == currentsamples.append(item)return jsonify({'summary': voice_summary(speaker, rows), 'samples': samples})diff --git a/src/services/recording_merge.py b/src/services/recording_merge.pyindex 382bbd74..607ccdb3 100644--- a/src/services/recording_merge.py+++ b/src/services/recording_merge.py@@ -38,6 +38,7 @@ from datetime import datetimefrom flask import current_appfrom src.database import db+from src.services.recording_deletion import delete_recording_completelyfrom src.models import Recording, RecordingTagfrom src.services.job_queue import job_queuefrom src.services.storage.service import get_storage_service@@ -362,10 +363,10 @@ def run_merge_job(recording, params):if delete_originals:for rec in sources:try:- _delete_recording(rec, storage)+ delete_recording_completely(rec, storage=storage)except Exception as e:+ db.session.rollback()current_app.logger.warning(f"Failed to delete source recording {rec.id} after merge: {e}")- db.session.commit()# Queue transcription with the SAME resolved params a normal upload gets, so# the merged file honors all of the owner's tag/folder/account preferences@@ -382,16 +383,6 @@ def run_merge_job(recording, params):)-def _delete_recording(recording, storage):- """Delete a source recording's audio and row. Best-effort on the file."""- if recording.audio_path:- try:- storage.delete(recording.audio_path, missing_ok=True)- except Exception as e:- current_app.logger.warning(f"Could not delete audio for recording {recording.id}: {e}")- db.session.delete(recording)--def _safe_unlink(path):try:if path and os.path.exists(path):diff --git a/src/services/recording_state.py b/src/services/recording_state.pyindex 12e25c11..688719a8 100644--- a/src/services/recording_state.py+++ b/src/services/recording_state.py@@ -23,7 +23,7 @@ def get_user_archived(recording, user):return bool(state and state.is_archived)-def set_user_archived(recording, user, value):+def set_user_archived(recording, user, value, commit=True):value = bool(value)if recording.user_id == user.id:recording.is_archived = value@@ -34,10 +34,25 @@ def set_user_archived(recording, user, value):is_inbox=True, is_highlighted=False)db.session.add(state)state.is_archived = value- db.session.commit()+ if commit:+ db.session.commit()return value+def parse_archived_flag(value):+ """Strict boolean for an API is_archived field; None when it is not one.++ bool("false") is True, so a string must be parsed, not cast.+ """+ if isinstance(value, bool):+ return value+ if isinstance(value, int) and value in (0, 1):+ return bool(value)+ if isinstance(value, str) and value.strip().lower() in ('true', '1', 'false', '0'):+ return value.strip().lower() in ('true', '1')+ return None++def archived_condition(recording_model, user_id):"""SQL condition: the recording is archived for this user.diff --git a/src/services/voice_profiles.py b/src/services/voice_profiles.pyindex 65f29ea2..cd66e738 100644--- a/src/services/voice_profiles.py+++ b/src/services/voice_profiles.py@@ -336,7 +336,8 @@ def record_sample(speaker, recording, label, vector, speech_seconds=None, sourceif vec is None:return 'invalid'space = recording.speaker_embeddings_space_id- existing = SpeakerVoiceSample.query.filter_by(recording_id=recording.id, label=label).first()+ existing = SpeakerVoiceSample.query.filter_by(+ user_id=speaker.user_id, recording_id=recording.id, label=label).first()_materialize_legacy(speaker)others = [s for s in samples_for(speaker, space)@@ -599,14 +600,27 @@ def calibrated_threshold(space_id):by_user.setdefault(row.user_id, {}).setdefault(row.speaker_id, []).append(vec)genuine, impostor = [], []for people in by_user.values():+ # One similarity matrix per user and dimension; only equal-size+ # vectors are ever compared.+ by_dim = {}for pid, vecs in people.items():- for i, v in enumerate(vecs):- own = [float(np.dot(v, w)) for j, w in enumerate(vecs) if j != i and w.shape == v.shape]- if own:- genuine.append(max(own))- other = [float(np.dot(v, w)) for qid, ws in people.items() if qid != pid for w in ws if w.shape == v.shape]- if other:- impostor.append(max(other))+ for v in vecs:+ by_dim.setdefault(v.shape[0], ([], []))+ by_dim[v.shape[0]][0].append(v)+ by_dim[v.shape[0]][1].append(pid)+ for vecs, pids in by_dim.values():+ if len(vecs) < 2:+ continue+ m = np.vstack(vecs)+ sims = m @ m.T+ pids = np.asarray(pids)+ same = pids[:, None] == pids[None, :]+ np.fill_diagonal(same, False)+ other = pids[:, None] != pids[None, :]+ own_best = np.where(same, sims, -np.inf).max(axis=1)+ other_best = np.where(other, sims, -np.inf).max(axis=1)+ genuine.extend(float(x) for x in own_best[np.isfinite(own_best)])+ impostor.extend(float(x) for x in other_best[np.isfinite(other_best)])value = Noneif len(genuine) >= MIN_CALIBRATION_PAIRS and len(impostor) >= MIN_CALIBRATION_PAIRS:g10 = float(np.percentile(genuine, 10))@@ -639,7 +653,8 @@ def apply_names_to_profiles(recording, key_to_name, seconds_by_key, user, sourceEach key is traced back to its diarization label through the recording'slabel map, so a correction reaches the embedding even after the transcriptshows names. Labels that no longer appear in the transcript (merged away)- lose their sample. Updates the label map and the affected people's summary+ lose their sample. Only the saving user's samples are read or changed:+ each user who can edit a recording keeps their own. Updates the label map and the affected people's summarycolumns. Does not commit.Returns {'stored': n, 'rejected': n, 'skipped_short': n}.@@ -666,7 +681,7 @@ def apply_names_to_profiles(recording, key_to_name, seconds_by_key, user, sourceseconds = (seconds_by_key or {}).get(key) if seconds_by_key is not None else Noneif seconds_by_key is not None and (seconds or 0.0) < MIN_SPEECH_SECONDS:stats['skipped_short'] += 1- old = SpeakerVoiceSample.query.filter_by(recording_id=recording.id, label=label).first()+ old = SpeakerVoiceSample.query.filter_by(user_id=user.id, recording_id=recording.id, label=label).first()if old is not None:touched.add(old.speaker_id)db.session.delete(old)@@ -674,7 +689,7 @@ def apply_names_to_profiles(recording, key_to_name, seconds_by_key, user, sourcespeaker = find_user_speaker(user.id, name)if speaker is None:continue- old = SpeakerVoiceSample.query.filter_by(recording_id=recording.id, label=label).first()+ old = SpeakerVoiceSample.query.filter_by(user_id=user.id, recording_id=recording.id, label=label).first()if old is not None and old.speaker_id != speaker.id:touched.add(old.speaker_id)result = record_sample(speaker, recording, label, embeddings[label], seconds, source)@@ -687,10 +702,14 @@ def apply_names_to_profiles(recording, key_to_name, seconds_by_key, user, sourcepresent = {s.get('speaker') for s in json.loads(recording.transcription or '[]') if isinstance(s, dict)}except (TypeError, ValueError):present = None+ # A person renamed since the map was written still counts as present.if present is not None:- for row in SpeakerVoiceSample.query.filter_by(recording_id=recording.id).all():+ from src.models import Speaker as _Speaker+ for row in SpeakerVoiceSample.query.filter_by(user_id=user.id, recording_id=recording.id).all():shown = label_map.get(row.label, row.label)- if row.label not in present and shown not in present:+ person = db.session.get(_Speaker, row.speaker_id) if row.speaker_id else None+ if row.label not in present and shown not in present and \+ not (person is not None and person.name in present):touched.add(row.speaker_id)db.session.delete(row)diff --git a/tests/test_review_fixes.py b/tests/test_review_fixes.pynew file mode 100644index 00000000..c1d486fd--- /dev/null+++ b/tests/test_review_fixes.py@@ -0,0 +1,348 @@+"""Fixes from the pre-release review of v0.10.7.++1. A shared editor's save trains their own voice profiles and leaves the+ owner's samples alone.+2. Renaming a person everywhere keeps the recording label maps in step, so+ the next save does not read the voice as removed.+3. Bulk delete, API v1 batch delete and merge go through the one complete+ delete (voice samples detached, snippets and jobs removed, webhook sent).+4. API v1 is_archived is per user and parsed strictly.+5. The vectorised threshold calibration matches the pairwise definition.++SHARED-DB: every test uses its own users and removes its recordings.+"""++import json+import os+import sys+import uuid+from unittest.mock import patch, MagicMock++import numpy as np+import pytest+from flask import g+from flask.testing import FlaskClient++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, SpeakerVoiceSample, SystemSetting, ProcessingJob+from src.models.sharing import InternalShare, SharedRecordingState+from src.services import voice_profiles as vp+from src.services.recording_state import parse_archived_flag++app.config["WTF_CSRF_ENABLED"] = False+RNG = np.random.default_rng(11)+DIM = 256+_created = []+++def unit(v):+ v = np.asarray(v, dtype=np.float32)+ return v / np.linalg.norm(v)+++def person():+ return unit(RNG.normal(size=DIM))+++def near(base, noise=0.15):+ return unit(base + noise * RNG.normal(size=DIM) / np.sqrt(DIM) * 4)+++class _Client(FlaskClient):+ def open(self, *args, **kwargs):+ g.pop('_login_user', None)+ return super().open(*args, **kwargs)+++def ctx():+ with app.app_context():+ saved = {k: SystemSetting.get_setting(k, None) for k in (vp.SETTING_CURRENT_SPACE, vp.SETTING_LEGACY_SPACE)}+ vp._calibration_cache.clear()+ yield+ db.session.rollback()+ for rec_id in _created:+ SpeakerVoiceSample.query.filter_by(recording_id=rec_id).update({'recording_id': None})+ InternalShare.query.filter_by(recording_id=rec_id).delete()+ SharedRecordingState.query.filter_by(recording_id=rec_id).delete()+ ProcessingJob.query.filter_by(recording_id=rec_id).delete()+ Recording.query.filter_by(id=rec_id).delete()+ db.session.commit()+ _created.clear()+ for k, v in saved.items():+ SystemSetting.set_setting(k, v or '', setting_type='string')+ vp._calibration_cache.clear()+++def _user():+ s = uuid.uuid4().hex[:8]+ u = User(username=f"rf_{s}", email=f"rf_{s}@local.test", password="x")+ db.session.add(u)+ db.session.commit()+ return u+++def _recording(user, embeddings=None, names=None):+ embeddings = embeddings or {}+ segs, t = [], 0.0+ for label in embeddings or {"A": None}:+ segs.append({"speaker": (names or {}).get(label, label), "sentence": "words " * 5,+ "start_time": t, "end_time": t + 60.0})+ t += 60.0+ rec = Recording(user_id=user.id, title=f"rf_{uuid.uuid4().hex[:8]}", status="COMPLETED",+ audio_path="local://recordings/x.mp3", original_filename="x.mp3",+ transcription=json.dumps(segs),+ speaker_embeddings={k: [float(x) for x in v] for k, v in embeddings.items()} or None)+ db.session.add(rec)+ db.session.commit()+ _created.append(rec.id)+ return rec+++def _client(user):+ c = _Client(app, app.response_class)+ with c.session_transaction() as sess:+ sess["_user_id"] = str(user.id)+ sess["_fresh"] = True+ return c+++def _share(rec, owner, other, can_edit=True):+ db.session.add(InternalShare(recording_id=rec.id, owner_id=owner.id,+ shared_with_user_id=other.id, can_edit=can_edit))+ db.session.commit()+++def _save_names(user, rec, mapping):+ body = {"speaker_map": {k: {"name": v} for k, v in mapping.items()}, "regenerate_summary": False}+ with patch("src.services.speaker_snippets.create_speaker_snippets", return_value=0):+ r = _client(user).post(f"/recording/{rec.id}/update_speakers", json=body)+ assert r.status_code == 200, r.get_data(as_text=True)+ db.session.expire_all()+++def _samples(user, rec):+ return {s.label: s for s in SpeakerVoiceSample.query.filter_by(user_id=user.id, recording_id=rec.id).all()}+++# ------------------------------------------------ 1. shared editor's save++def test_shared_editors_save_leaves_the_owners_samples(ctx):+ owner, editor = _user(), _user()+ rec = _recording(owner, {"SPEAKER_00": person(), "SPEAKER_01": person()})+ _save_names(owner, rec, {"SPEAKER_00": "Alice", "SPEAKER_01": "Ben"})+ owners = _samples(owner, rec)+ assert set(owners) == {"SPEAKER_00", "SPEAKER_01"}+ alice_id = owners["SPEAKER_00"].speaker_id++ _share(rec, owner, editor)+ _save_names(editor, rec, {"Alice": "Alice Ng"})++ owners = _samples(owner, rec)+ assert set(owners) == {"SPEAKER_00", "SPEAKER_01"}+ assert owners["SPEAKER_00"].speaker_id == alice_id+ editors = _samples(editor, rec)+ assert set(editors) == {"SPEAKER_00"}+ assert db.session.get(Speaker, editors["SPEAKER_00"].speaker_id).user_id == editor.id+++def test_sample_list_hides_titles_of_recordings_no_longer_shared(ctx):+ owner, editor = _user(), _user()+ rec = _recording(owner, {"SPEAKER_00": person()})+ _share(rec, owner, editor)+ _save_names(editor, rec, {"SPEAKER_00": "Dana"})+ speaker = Speaker.query.filter_by(user_id=editor.id, name="Dana").first()++ body = _client(editor).get(f"/speakers/{speaker.id}/voice_samples").get_json()+ assert body["samples"][0]["recording_title"] == rec.title++ InternalShare.query.filter_by(recording_id=rec.id).delete()+ db.session.commit()+ body = _client(editor).get(f"/speakers/{speaker.id}/voice_samples").get_json()+ assert body["samples"][0]["recording_title"] is None+ assert body["samples"][0]["recording_id"] is None+++# --------------------------------------------------- 2. rename everywhere++def test_global_rename_keeps_the_sample_on_the_next_save(ctx):+ user = _user()+ rec = _recording(user, {"SPEAKER_00": person(), "SPEAKER_01": person()})+ _save_names(user, rec, {"SPEAKER_00": "Alice", "SPEAKER_01": "Ben"})+ alice = Speaker.query.filter_by(user_id=user.id, name="Alice").first()++ r = _client(user).put(f"/speakers/{alice.id}", json={"name": "Alicia"})+ assert r.status_code == 200, r.get_data(as_text=True)+ db.session.expire_all()+ assert db.session.get(Recording, rec.id).speaker_label_map["SPEAKER_00"] == "Alicia"++ _save_names(user, db.session.get(Recording, rec.id), {"Ben": "Benjamin"})+ samples = _samples(user, rec)+ assert samples["SPEAKER_00"].speaker_id == alice.id+++def test_stale_label_map_still_keeps_a_renamed_persons_sample(ctx):+ """A recording whose map was not rewritten (for example one only shared+ with the user) still counts the person's current name as present."""+ user = _user()+ rec = _recording(user, {"SPEAKER_00": person(), "SPEAKER_01": person()})+ _save_names(user, rec, {"SPEAKER_00": "Alice", "SPEAKER_01": "Ben"})+ alice = Speaker.query.filter_by(user_id=user.id, name="Alice").first()+ alice.name = "Alicia"+ rec = db.session.get(Recording, rec.id)+ segs = json.loads(rec.transcription)+ for s in segs:+ if s["speaker"] == "Alice":+ s["speaker"] = "Alicia"+ rec.transcription = json.dumps(segs)+ db.session.commit()++ _save_names(user, rec, {"Ben": "Benjamin"})+ assert "SPEAKER_00" in _samples(user, rec)+++# ------------------------------------------------ 3. one complete delete++def _with_trail(user):+ rec = _recording(user, {"SPEAKER_00": person()})+ _save_names(user, rec, {"SPEAKER_00": "Erin"})+ db.session.add(ProcessingJob(user_id=user.id, recording_id=rec.id, job_type='transcribe', status='COMPLETED'))+ db.session.commit()+ sample_id = _samples(user, rec)["SPEAKER_00"].id+ return rec.id, sample_id+++def _assert_completely_deleted(rec_id, sample_id, webhook):+ db.session.expire_all()+ assert db.session.get(Recording, rec_id) is None+ assert ProcessingJob.query.filter_by(recording_id=rec_id).count() == 0+ sample = db.session.get(SpeakerVoiceSample, sample_id)+ assert sample is not None and sample.recording_id is None+ assert any(c.kwargs.get('event_type') == 'recording.deleted' and c.kwargs['data']['recording_id'] == rec_id+ for c in webhook.call_args_list)+++def test_bulk_delete_is_a_complete_delete(ctx):+ user = _user()+ rec_id, sample_id = _with_trail(user)+ storage = MagicMock()+ with patch("src.api.recordings.get_storage_service", return_value=storage), \+ patch("src.services.webhook_dispatch.emit_webhook_event") as webhook:+ r = _client(user).delete("/api/recordings/bulk", json={"recording_ids": [rec_id]})+ assert r.status_code == 200, r.get_data(as_text=True)+ assert r.get_json()["deleted_ids"] == [rec_id]+ storage.delete.assert_called_once_with("local://recordings/x.mp3", missing_ok=True)+ _assert_completely_deleted(rec_id, sample_id, webhook)+++def test_api_v1_batch_delete_is_a_complete_delete(ctx):+ user = _user()+ rec_id, sample_id = _with_trail(user)+ storage = MagicMock()+ with patch("src.services.storage.get_storage_service", return_value=storage), \+ patch("src.services.webhook_dispatch.emit_webhook_event") as webhook:+ r = _client(user).delete("/api/v1/recordings/batch", json={"recording_ids": [rec_id]})+ assert r.status_code == 200, r.get_data(as_text=True)+ assert r.get_json()["deleted"] == 1+ storage.delete.assert_called_once_with("local://recordings/x.mp3", missing_ok=True)+ _assert_completely_deleted(rec_id, sample_id, webhook)+++def test_merge_deletes_originals_through_the_complete_delete():+ from src.services import recording_merge+ assert not hasattr(recording_merge, "_delete_recording")+ assert recording_merge.delete_recording_completely.__module__ == "src.services.recording_deletion"+++# ------------------------------------------------ 4. API v1 archive per user+[email protected]("value,expected", [+ (True, True), (False, False), ("true", True), ("false", False), ("False", False),+ (1, True), (0, False), ("1", True), ("0", False), ("maybe", None), (None, None), (2, None), ([], None),+])+def test_parse_archived_flag(value, expected):+ assert parse_archived_flag(value) is expected+++def test_api_v1_archive_by_a_shared_editor_is_personal(ctx):+ owner, editor = _user(), _user()+ rec = _recording(owner)+ _share(rec, owner, editor)++ r = _client(editor).patch(f"/api/v1/recordings/{rec.id}", json={"is_archived": True})+ assert r.status_code == 200, r.get_data(as_text=True)+ assert r.get_json()["recording"]["is_archived"] is True+ db.session.expire_all()+ assert not db.session.get(Recording, rec.id).is_archived++ assert _client(editor).get(f"/api/v1/recordings/{rec.id}").get_json()["is_archived"] is True+ assert _client(owner).get(f"/api/v1/recordings/{rec.id}").get_json()["is_archived"] is False+++def test_api_v1_archive_parses_strings_and_rejects_junk(ctx):+ user = _user()+ rec = _recording(user)+ c = _client(user)+ c.patch(f"/api/v1/recordings/{rec.id}", json={"is_archived": True})+ r = c.patch(f"/api/v1/recordings/{rec.id}", json={"is_archived": "false"})+ assert r.status_code == 200 and r.get_json()["recording"]["is_archived"] is False+ assert c.patch(f"/api/v1/recordings/{rec.id}", json={"is_archived": "maybe"}).status_code == 400++ r = c.patch("/api/v1/recordings/batch", json={"recording_ids": [rec.id], "updates": {"is_archived": "yes please"}})+ assert r.status_code == 400+ r = c.patch("/api/v1/recordings/batch", json={"recording_ids": [rec.id], "updates": {"is_archived": "true"}})+ assert r.status_code == 200, r.get_data(as_text=True)+ db.session.expire_all()+ assert db.session.get(Recording, rec.id).is_archived is True+++def test_api_v1_batch_archive_by_a_shared_editor_is_personal(ctx):+ owner, editor = _user(), _user()+ rec = _recording(owner)+ _share(rec, owner, editor)+ r = _client(editor).patch("/api/v1/recordings/batch",+ json={"recording_ids": [rec.id], "updates": {"is_archived": True}})+ assert r.status_code == 200, r.get_data(as_text=True)+ db.session.expire_all()+ assert not db.session.get(Recording, rec.id).is_archived+ state = SharedRecordingState.query.filter_by(recording_id=rec.id, user_id=editor.id).first()+ assert state is not None and state.is_archived+++# ------------------------------------------------ 5. calibration++def test_vectorised_calibration_matches_the_pairwise_definition(ctx):+ user = _user()+ people = {name: person() for name in ("P1", "P2", "P3", "P4")}+ vectors = {}+ for i, (name, base) in enumerate(people.items()):+ sp = Speaker(user_id=user.id, name=f"{name}_{uuid.uuid4().hex[:6]}", use_count=1)+ db.session.add(sp)+ db.session.flush()+ for k in range(5):+ v = near(base, noise=0.3)+ vectors.setdefault(sp.id, []).append(v)+ db.session.add(SpeakerVoiceSample(user_id=user.id, speaker_id=sp.id, label=f"S{i}{k}",+ embedding=vp.to_bytes(v), dimension=DIM,+ space_id=None, source='confirmed', weight=1.0))+ db.session.commit()+ try:+ # Only this user's samples, so other tests' rows do not shift the result.+ mine = db.session.query(SpeakerVoiceSample).filter_by(user_id=user.id).all()+ with patch.object(SpeakerVoiceSample, "query") as q:+ q.all.return_value = mine+ got = vp.calibrated_threshold(None)++ genuine, impostor = [], []+ for pid, vecs in vectors.items():+ for i, v in enumerate(vecs):+ genuine.append(max(float(np.dot(v, w)) for j, w in enumerate(vecs) if j != i))+ impostor.append(max(float(np.dot(v, w)) for qid, ws in vectors.items() if qid != pid for w in ws))+ want = round(min(0.85, max(0.45, (np.percentile(genuine, 10) + np.percentile(impostor, 95)) / 2.0)), 3)+ assert got is not None+ assert got == pytest.approx(want, abs=1e-3)+ finally:+ db.session.query(SpeakerVoiceSample).filter_by(user_id=user.id).delete()+ db.session.commit()