Skip to content

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.py
index 0594ee5d..47d9092b 100644
--- a/src/api/api_v1.py
+++ b/src/api/api_v1.py
@@ -30,6 +30,7 @@ from werkzeug.exceptions import RequestEntityTooLarge
from werkzeug.utils import secure_filename
from src.database import db
+from src.services.recording_state import get_user_archived, set_user_archived, parse_archived_flag
from src.models import Recording, User, Tag, RecordingTag, Speaker, Event
from src.models.processing_job import ProcessingJob
from 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'}), 403
target_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():
continue
try:
- # 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.py
index 59901b75..9fa5a377 100644
--- a/src/api/recordings.py
+++ b/src/api/recordings.py
@@ -23,6 +23,7 @@ from email.utils import encode_rfc2231
from urllib.parse import quote
from src.database import db
+from src.services.recording_deletion import delete_recording_completely, cleanup_orphaned_speakers_quietly
from 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_required
def 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 select
try:
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.py
index 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, skip
pass
+ # 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.title
current = 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 user
item['in_current_space'] = effective_space(r.space_id) == current
samples.append(item)
return jsonify({'summary': voice_summary(speaker, rows), 'samples': samples})
diff --git a/src/services/recording_merge.py b/src/services/recording_merge.py
index 382bbd74..607ccdb3 100644
--- a/src/services/recording_merge.py
+++ b/src/services/recording_merge.py
@@ -38,6 +38,7 @@ from datetime import datetime
from flask import current_app
from src.database import db
+from src.services.recording_deletion import delete_recording_completely
from src.models import Recording, RecordingTag
from src.services.job_queue import job_queue
from 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.py
index 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.py
index 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, source
if 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 = None
if 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, source
Each key is traced back to its diarization label through the recording's
label map, so a correction reaches the embedding even after the transcript
shows 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 summary
columns. 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, source
seconds = (seconds_by_key or {}).get(key) if seconds_by_key is not None else None
if 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, source
speaker = 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, source
present = {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.py
new file mode 100644
index 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()