From ea57492763f09b68445e12daaa7c167529761827 Mon Sep 17 00:00:00 2001 From: pretyflaco Date: Thu, 5 Nov 2026 13:07:59 +0300 Subject: [PATCH 1/2] tests: neutral fixtures Made-up team slugs (team-a, team-b), names and synthetic session ids instead of real ones. No behavior change. --- CHANGELOG.md | 5 ++ tests/test_clips.py | 22 ++--- tests/test_frontmatter.py | 6 +- tests/test_label.py | 118 +++++++++++++------------- tests/test_paths.py | 18 ++-- tests/test_pdf.py | 6 +- tests/test_speaker_repair.py | 8 +- tests/test_ssl_cert_injection.py | 2 +- tests/test_summarize_frames.py | 2 +- tests/test_summarize_tinfoil_retry.py | 2 +- tests/test_sync_team.py | 32 +++---- tests/test_transcribe.py | 18 ++-- tests/test_voiceprint_gate.py | 64 +++++++------- 13 files changed, 154 insertions(+), 149 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e0564d7..b436b67 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,10 @@ # Changelog +## Unreleased — neutral test fixtures + +* Tests use made-up team slugs (`team-a`, `team-b`), names and synthetic + session ids instead of real ones. No behavior change. + ## Unreleased — no deployment- or organization-specific references * Package author is `twentyone.ist`. diff --git a/tests/test_clips.py b/tests/test_clips.py index c9e92cb..8b4d8cb 100644 --- a/tests/test_clips.py +++ b/tests/test_clips.py @@ -263,10 +263,10 @@ def test_relabel_clips_file(tmp_path): segs = _segs() path = write_clips(_summary({"clips": [_clip(segs, 2, 5)]}), _txn(segs), tmp_path, "s") before = json.loads(path.read_text())["clips"][0] - assert relabel_clips_file(path, {"SPEAKER_00": "Kemal"}) + assert relabel_clips_file(path, {"SPEAKER_00": "Nora"}) after = json.loads(path.read_text())["clips"][0] - assert after["speakers"] == ["Kemal"] - assert after["text"].startswith("Kemal: line 2") + assert after["speakers"] == ["Nora"] + assert after["text"].startswith("Nora: line 2") assert after["start_s"] == before["start_s"] assert not relabel_clips_file(path, {"NOBODY": "x"}) @@ -288,11 +288,11 @@ def test_regenerate_writes_clips(self, tmp_path): with patch("millet.summarize.is_backend_available", return_value=True), \ patch("millet.summarize.summarize", return_value=fake), \ patch("millet.transcribe.ensure_gpu_available", lambda *a, **k: None): - files = apply_labels(sdir, {"SPEAKER_00": "Kemal"}, regenerate_summary=True, + files = apply_labels(sdir, {"SPEAKER_00": "Nora"}, regenerate_summary=True, summary_template="video-clipping") assert files["clips"] == sdir / "01ABC.clips.json" doc = json.loads(files["clips"].read_text()) - assert doc["clips"][0]["speakers"] == ["Kemal"] + assert doc["clips"][0]["speakers"] == ["Nora"] assert (sdir / "01ABC.video-clipping.md").exists() def test_other_templates_write_no_clips(self, tmp_path): @@ -307,9 +307,9 @@ def test_other_templates_write_no_clips(self, tmp_path): def test_relabel_without_regenerate_renames_inside_clips(self, tmp_path): sdir, segs = self._session(tmp_path) write_clips(_summary({"clips": [_clip(segs, 2, 5)]}), _txn(segs), sdir, "01ABC") - apply_labels(sdir, {"SPEAKER_00": "Kemal"}, regenerate_summary=False) + apply_labels(sdir, {"SPEAKER_00": "Nora"}, regenerate_summary=False) doc = json.loads((sdir / "01ABC.clips.json").read_text()) - assert doc["clips"][0]["speakers"] == ["Kemal"] + assert doc["clips"][0]["speakers"] == ["Nora"] def test_clips_json_never_mistaken_for_transcript(self, tmp_path): # ".clips.json" sorts before ".json". Use a session dir @@ -574,10 +574,10 @@ def test_merges_speakers_and_skips_odd_entries(self, tmp_path): {"speakers": ["A", "B"], "text": "A: hi\nB: yo\nno label here"}, {"speakers": "A", "text": None}, ]})) - assert relabel_clips_file(p, {"A": "Kemal", "B": "Kemal"}) + assert relabel_clips_file(p, {"A": "Nora", "B": "Nora"}) clip = json.loads(p.read_text())["clips"][1] - assert clip["speakers"] == ["Kemal"] - assert clip["text"] == "Kemal: hi\nKemal: yo\nno label here" + assert clip["speakers"] == ["Nora"] + assert clip["text"] == "Nora: hi\nNora: yo\nno label here" def test_relabel_failure_is_logged_not_raised(self, tmp_path): sdir = tmp_path / "01ABC" @@ -585,7 +585,7 @@ def test_relabel_failure_is_logged_not_raised(self, tmp_path): _txn(_segs()).save(sdir, basename="01ABC") (sdir / "01ABC.clips.json").write_text("not json") logs: list[str] = [] - apply_labels(sdir, {"SPEAKER_00": "Kemal"}, regenerate_summary=False, + apply_labels(sdir, {"SPEAKER_00": "Nora"}, regenerate_summary=False, progress_callback=logs.append) assert any("Clip relabel failed" in m for m in logs) diff --git a/tests/test_frontmatter.py b/tests/test_frontmatter.py index 20ddf36..cfbbe78 100644 --- a/tests/test_frontmatter.py +++ b/tests/test_frontmatter.py @@ -124,12 +124,12 @@ def test_minimal_context(self): def test_crosstalk_is_never_a_participant(self): ctx = FrontmatterContext( - transcript_speakers=["Kemal", "CROSSTALK"], + transcript_speakers=["Nora", "CROSSTALK"], speaker_channels={"CROSSTALK": "system"}, ) - fm = build_frontmatter({"participants": ["crosstalk", "Lukas"]}, ctx) + fm = build_frontmatter({"participants": ["crosstalk", "Pia"]}, ctx) validate_frontmatter(fm) - assert [p["name"] for p in fm["participants"]] == ["Kemal", "Lukas"] + assert [p["name"] for p in fm["participants"]] == ["Nora", "Pia"] def test_with_extracted_data(self): ctx = FrontmatterContext( diff --git a/tests/test_label.py b/tests/test_label.py index f397d7f..6df1ee6 100644 --- a/tests/test_label.py +++ b/tests/test_label.py @@ -124,8 +124,8 @@ def test_writes_keyed_by_id_with_confidence(self, tmp_path): json_path = tmp_path / "meeting-20260314-100000.json" json_path.write_text("{}") matches = { - "Openoms": SimpleNamespace(name="Openoms", confidence=0.93), - "Kemal": SimpleNamespace(name="Kemal", confidence=0.8827), + "Sam": SimpleNamespace(name="Sam", confidence=0.93), + "Nora": SimpleNamespace(name="Nora", confidence=0.8827), } _write_autoid_sidecar(json_path, matches) @@ -133,10 +133,10 @@ def test_writes_keyed_by_id_with_confidence(self, tmp_path): assert sidecar.exists() data = json.loads(sidecar.read_text()) assert data["version"] == 1 - assert data["suggestions"]["Openoms"]["name"] == "Openoms" - assert data["suggestions"]["Openoms"]["confidence"] == 0.93 + assert data["suggestions"]["Sam"]["name"] == "Sam" + assert data["suggestions"]["Sam"]["confidence"] == 0.93 # confidence rounded to 4 dp - assert data["suggestions"]["Kemal"]["confidence"] == 0.8827 + assert data["suggestions"]["Nora"]["confidence"] == 0.8827 def test_empty_matches_writes_empty_suggestions(self, tmp_path): from millet.cli.label import _write_autoid_sidecar @@ -458,23 +458,23 @@ def test_find_replace_summary_swap(self, session_dir): """A swap {A:B, B:A} must swap, not collapse both to one name. Regression: sequential per-key re.sub chained on the same string — - replacing Alaaddin->Kemal first, then Kemal->Alaaddin re-caught the - just-written Kemals and collapsed BOTH speakers to a single name in + replacing Walter->Nora first, then Nora->Walter re-caught the + just-written Noras and collapsed BOTH speakers to a single name in the summary/frontmatter/PDF. The relabel must be a single atomic pass. """ summary_path = session_dir / "meeting-20260314-100000.summary.md" summary_path.write_text( - "Alaaddin opened. Kemal replied. Alaaddin closed.\n" + "Walter opened. Nora replied. Walter closed.\n" ) apply_labels( session_dir, - {"Alaaddin": "Kemal", "Kemal": "Alaaddin"}, + {"Walter": "Nora", "Nora": "Walter"}, regenerate_summary=False, ) new_text = summary_path.read_text() - assert "Kemal opened." in new_text - assert "Alaaddin replied." in new_text - assert "Kemal closed." in new_text + assert "Nora opened." in new_text + assert "Walter replied." in new_text + assert "Nora closed." in new_text def test_find_replace_summary_chain_single_pass(self, session_dir): """{A:B, B:C} must not chain A->B->C: each source position is @@ -580,7 +580,7 @@ def _fake_summary(self): from millet.summarize import MeetingSummary return MeetingSummary( markdown="## Overview\nFine.", backend="test", model="m", - elapsed_seconds=0.1, data={"participants": ["CROSSTALK", "Kemal"]}, + elapsed_seconds=0.1, data={"participants": ["CROSSTALK", "Nora"]}, data_error=None, ) @@ -599,17 +599,17 @@ def test_summary_input_excludes_crosstalk(self, tmp_path): patch("millet.summarize.summarize", return_value=self._fake_summary()) as summ, \ patch("millet.transcribe.ensure_gpu_available", lambda *a, **k: None): apply_labels( - sdir, {"SPEAKER_00": "Kemal", "REMOTE": CROSSTALK}, + sdir, {"SPEAKER_00": "Nora", "REMOTE": CROSSTALK}, regenerate_summary=True, ) text = summ.call_args.args[0] - assert "Kemal: real content" in text + assert "Nora: real content" in text assert CROSSTALK not in text and "Bye." not in text # The transcript itself keeps the line, honestly labeled. assert f"{CROSSTALK}: Bye." in (sdir / "s1.txt").read_text() # LLM-listed "CROSSTALK" is not a participant. fm = json.loads((sdir / "s1.frontmatter.json").read_text()) - assert [p["name"] for p in fm["participants"]] == ["Kemal"] + assert [p["name"] for p in fm["participants"]] == ["Nora"] def test_find_and_replace_path_drops_crosstalk_participant(self, tmp_path): # vezir's `label --auto --no-summary` path: the transcribe-time @@ -625,32 +625,32 @@ def test_find_and_replace_path_drops_crosstalk_participant(self, tmp_path): render_frontmatter_block(fm) + "## Overview\nREMOTE said bye.\n", ) apply_labels( - sdir, {"SPEAKER_00": "Kemal", "REMOTE": CROSSTALK}, + sdir, {"SPEAKER_00": "Nora", "REMOTE": CROSSTALK}, regenerate_summary=False, ) side = json.loads((sdir / "s1.frontmatter.json").read_text()) - assert [p["name"] for p in side["participants"]] == ["Kemal"] + assert [p["name"] for p in side["participants"]] == ["Nora"] def test_find_and_replace_path_dedupes_renamed_participant(self, tmp_path): - # Incident 01M6EV6Z: the transcribe-time summary listed SPEAKER_01 - # and the "Kemal" the model read from the text; SPEAKER_01 -> Kemal - # left Kemal in the participants twice. + # The transcribe-time summary listed SPEAKER_01 + # and the "Nora" the model read from the text; SPEAKER_01 -> Nora + # left Nora in the participants twice. from millet.frontmatter import render_frontmatter_block sdir = self._session(tmp_path) fm = {"schema_version": 1, "type": "meeting", "participants": [ - {"name": "Kemal", "role": None, "channel": None}, + {"name": "Nora", "role": None, "channel": None}, {"name": "SPEAKER_00", "role": None, "channel": "mic"}, ]} (sdir / "s1.summary.md").write_text( render_frontmatter_block(fm) + "## Overview\nSPEAKER_00 talked.\n", ) - apply_labels(sdir, {"SPEAKER_00": "Kemal"}, regenerate_summary=False) + apply_labels(sdir, {"SPEAKER_00": "Nora"}, regenerate_summary=False) side = json.loads((sdir / "s1.frontmatter.json").read_text()) assert side["participants"] == [ - {"name": "Kemal", "role": None, "channel": "mic"}, + {"name": "Nora", "role": None, "channel": "mic"}, ] - assert "Kemal talked." in (sdir / "s1.summary.md").read_text() + assert "Nora talked." in (sdir / "s1.summary.md").read_text() class TestDedupeParticipants: @@ -718,7 +718,7 @@ def test_template_writes_own_artifact(self, session_dir): # ─── relabel_transcript_in_memory: same-name speaker collapse (0.12.11) ────── # Diarization over-segments one person into several clusters; once they resolve # to the same name (via many-to-one voiceprint match or a human naming each), -# they must collapse into ONE speaker entry instead of "Destiny, Destiny, …". +# they must collapse into ONE speaker entry instead of "Quinn, Quinn, …". class TestRelabelSpeakerDedup: def _txn(self, speakers, segments): @@ -733,7 +733,7 @@ def _txn(self, speakers, segments): def test_label_map_collapses_duplicate_names(self): # Three raw clusters, two of which a human (or many-to-one) maps to - # Destiny; the result must have a single Destiny speaker. + # Quinn; the result must have a single Quinn speaker. txn = self._txn( speakers=[ Speaker(id="SPEAKER_00", label="SPEAKER_00"), @@ -748,39 +748,39 @@ def test_label_map_collapses_duplicate_names(self): ) out = relabel_transcript_in_memory( txn, - {"SPEAKER_00": "Destiny", "SPEAKER_01": "Andrej", "SPEAKER_02": "Destiny"}, + {"SPEAKER_00": "Quinn", "SPEAKER_01": "Uma", "SPEAKER_02": "Quinn"}, ) ids = [s.id for s in out.speakers] - assert ids == ["Destiny", "Andrej"] # de-duped, first-seen order - # All Destiny segments now share the one id. - assert {seg.speaker for seg in out.segments} == {"Destiny", "Andrej"} - assert sum(1 for seg in out.segments if seg.speaker == "Destiny") == 2 + assert ids == ["Quinn", "Uma"] # de-duped, first-seen order + # All Quinn segments now share the one id. + assert {seg.speaker for seg in out.segments} == {"Quinn", "Uma"} + assert sum(1 for seg in out.segments if seg.speaker == "Quinn") == 2 def test_empty_map_dedupes_preexisting_duplicates(self): - # Backfill case: a transcript already carrying duplicate "Destiny" + # Backfill case: a transcript already carrying duplicate "Quinn" # entries collapses with an empty label_map. txn = self._txn( speakers=[ - Speaker(id="Destiny", label="Destiny"), - Speaker(id="Destiny", label="Destiny"), - Speaker(id="Andrej", label="Andrej"), - Speaker(id="Destiny", label="Destiny"), + Speaker(id="Quinn", label="Quinn"), + Speaker(id="Quinn", label="Quinn"), + Speaker(id="Uma", label="Uma"), + Speaker(id="Quinn", label="Quinn"), ], segments=[ - Segment(start=0.0, end=2.0, text="a", speaker="Destiny"), - Segment(start=2.0, end=4.0, text="b", speaker="Andrej"), + Segment(start=0.0, end=2.0, text="a", speaker="Quinn"), + Segment(start=2.0, end=4.0, text="b", speaker="Uma"), ], ) out = relabel_transcript_in_memory(txn, {}) - assert [s.id for s in out.speakers] == ["Destiny", "Andrej"] + assert [s.id for s in out.speakers] == ["Quinn", "Uma"] def test_empty_map_no_dupes_is_noop(self): txn = self._txn( speakers=[ - Speaker(id="Destiny", label="Destiny"), - Speaker(id="Andrej", label="Andrej"), + Speaker(id="Quinn", label="Quinn"), + Speaker(id="Uma", label="Uma"), ], - segments=[Segment(start=0.0, end=2.0, text="a", speaker="Destiny")], + segments=[Segment(start=0.0, end=2.0, text="a", speaker="Quinn")], ) out = relabel_transcript_in_memory(txn, {}) assert out is txn # unchanged object (fast path) @@ -826,7 +826,7 @@ def _raw_txn(segments, duration=4000.0): def _devstandup_segments(): - """Shape of session 01M3RS442M3XX4D2AGK80641A7: named-able raw clusters + """Shape of session 01JFRC3N09J6R3SS03CS3PBMNJ: named-able raw clusters carrying the meeting, plus a 10-segment / 3.2 s REMOTE of fillers, one of which is a line leaking from another speaker.""" segs = [] @@ -859,7 +859,7 @@ def test_needs_no_named_speaker(self): assert crosstalk_label_map(txn, set()) == {"REMOTE": CROSSTALK} def test_many_fillers_in_long_meeting_still_crosstalk(self): - # 44 fillers / ~22 s in a ~3 h call (session 01M0NQT1): over the old + # 44 fillers / ~22 s in a ~3 h call: over the old # fixed 25-segment cap, but still < 1% of the meeting. segs = [ Segment(start=i * 60.0, end=i * 60.0 + 55.0, text="talk " * 100, @@ -976,11 +976,11 @@ def test_tiny_remote_folds_into_unmatched_dominant(self): def test_tiny_remote_folds_into_named_when_present(self): segs = [ - Segment(start=0.0, end=300.0, text="long", speaker="Openoms"), + Segment(start=0.0, end=300.0, text="long", speaker="Sam"), Segment(start=310.0, end=310.2, text="yeah", speaker="REMOTE"), ] txn = self._txn(segs) - assert absorb_tiny_speakers(txn, {"Openoms"}) == {"REMOTE": "Openoms"} + assert absorb_tiny_speakers(txn, {"Sam"}) == {"REMOTE": "Sam"} def test_substantial_unmatched_not_folded(self): # A genuine unlabeled participant (above thresholds) stays raw. @@ -1038,18 +1038,18 @@ def test_just_over_segment_threshold_not_tiny(self): def test_short_voiceprint_match_is_not_noise(self): # Regression: the CLI passed label-map VALUES (names), so a short raw - # cluster voiceprint had confidently matched (SPEAKER_01 → Andrej) - # still counted as unresolved noise and was folded into Kemal. + # cluster voiceprint had confidently matched (SPEAKER_01 → Uma) + # still counted as unresolved noise and was folded into Nora. segs = [ Segment(start=0.0, end=60.0, text="a", speaker="SPEAKER_00"), Segment(start=61.0, end=63.0, text="short matched guy", speaker="SPEAKER_01"), ] txn = self._txn(segs) - label_map = {"SPEAKER_00": "Kemal", "SPEAKER_01": "Andrej"} + label_map = {"SPEAKER_00": "Nora", "SPEAKER_01": "Uma"} assert absorb_tiny_speakers(txn, set(label_map)) == {} def test_tiny_cluster_with_a_real_sentence_is_not_noise(self): - # Incident 01M6EV6Z (58 s phone interview): the one segment pyannote + # A 58 s phone interview: the one segment pyannote # split off for the interviewee (4.4 s, 21 words) was folded into # the interviewer, and the session came back with one speaker. segs = [ @@ -1086,7 +1086,7 @@ class TestLabelAutoCrosstalk: --no-audio --no-summary, on a fresh transcript that still has raw ids.""" def _session(self, tmp_path): - sdir = tmp_path / "01M3RS442M3XX4D2AGK80641A7" + sdir = tmp_path / "01JFRC3N09J6R3SS03CS3PBMNJ" sdir.mkdir() _raw_txn(_devstandup_segments()).save(sdir, basename=sdir.name) # Existence is all the CLI checks; channel detection is mocked. @@ -1113,9 +1113,9 @@ def _run(self, sdir, matches): def test_ghost_remote_becomes_crosstalk_and_matches_apply(self, tmp_path): sdir = self._session(tmp_path) - data, upd, out = self._run(sdir, {"SPEAKER_00": "Kemal", "SPEAKER_01": "Lukas"}) + data, upd, out = self._run(sdir, {"SPEAKER_00": "Nora", "SPEAKER_01": "Pia"}) ids = {sp["id"] for sp in data["speakers"]} - assert ids == {"Kemal", "Lukas", CROSSTALK} + assert ids == {"Nora", "Pia", CROSSTALK} bye = [s for s in data["segments"] if s["text"] == "Bye."] assert bye and all(s["speaker"] == CROSSTALK for s in bye) assert "cannot be assigned to a speaker" in out @@ -1131,19 +1131,19 @@ def test_crosstalk_without_any_voiceprint_match(self, tmp_path): upd.assert_not_called() def test_ghost_wins_over_a_strong_voiceprint_match(self, tmp_path): - # The "Pattern" incident: a polluted profile matched the filler + # The "Peggy" incident: a polluted profile matched the filler # bucket at ~0.9, naming it after a person and keeping it out of # CROSSTALK. A ghost bucket has no single voice to match. sdir = self._session(tmp_path) data, upd, out = self._run( - sdir, {"SPEAKER_00": "Kemal", "SPEAKER_01": "Lukas", "REMOTE": "Pattern"}, + sdir, {"SPEAKER_00": "Nora", "SPEAKER_01": "Pia", "REMOTE": "Peggy"}, ) ids = {sp["id"] for sp in data["speakers"]} - assert ids == {"Kemal", "Lukas", CROSSTALK} - assert "Ignoring voiceprint match REMOTE -> Pattern" in out + assert ids == {"Nora", "Pia", CROSSTALK} + assert "Ignoring voiceprint match REMOTE -> Peggy" in out # Nor is it offered as an auto-id suggestion to the labeling UI. sidecar = json.loads((sdir / f"{sdir.name}.autoid.json").read_text()) - assert "Pattern" not in {v["name"] for v in sidecar["suggestions"].values()} + assert "Peggy" not in {v["name"] for v in sidecar["suggestions"].values()} upd.assert_not_called() diff --git a/tests/test_paths.py b/tests/test_paths.py index e24e624..288123c 100644 --- a/tests/test_paths.py +++ b/tests/test_paths.py @@ -20,8 +20,8 @@ def test_team_profiles_path(monkeypatch, tmp_path): monkeypatch.setenv("HOME", str(tmp_path)) monkeypatch.delenv("MEET_PROFILES_PATH", raising=False) monkeypatch.delenv("MEET_CONFIG_DIR", raising=False) - p = paths.profiles_path("blink") - assert p == tmp_path / ".config" / "meet" / "blink" / "speaker_profiles.json" + p = paths.profiles_path("team-a") + assert p == tmp_path / ".config" / "meet" / "team-a" / "speaker_profiles.json" def test_env_override_wins_when_no_team(monkeypatch, tmp_path): @@ -54,8 +54,8 @@ def test_team_ignores_env_override(monkeypatch, tmp_path): monkeypatch.setenv("HOME", str(tmp_path)) monkeypatch.setenv("MEET_PROFILES_PATH", "/custom/profiles.json") monkeypatch.delenv("MEET_CONFIG_DIR", raising=False) - p = paths.profiles_path("blink") - assert p == tmp_path / ".config" / "meet" / "blink" / "speaker_profiles.json" + p = paths.profiles_path("team-a") + assert p == tmp_path / ".config" / "meet" / "team-a" / "speaker_profiles.json" def test_sync_config_path_team(monkeypatch, tmp_path): @@ -64,8 +64,8 @@ def test_sync_config_path_team(monkeypatch, tmp_path): assert paths.sync_config_path() == ( tmp_path / ".config" / "meet" / "sync_config.json" ) - assert paths.sync_config_path("twentyone") == ( - tmp_path / ".config" / "meet" / "twentyone" / "sync_config.json" + assert paths.sync_config_path("team-b") == ( + tmp_path / ".config" / "meet" / "team-b" / "sync_config.json" ) @@ -73,13 +73,13 @@ def test_recordings_dir_team(monkeypatch, tmp_path): monkeypatch.setenv("HOME", str(tmp_path)) monkeypatch.delenv("MEET_RECORDINGS_DIR", raising=False) assert paths.recordings_dir() == tmp_path / "meet-recordings" - assert paths.recordings_dir("blink") == tmp_path / "meet-recordings" / "blink" + assert paths.recordings_dir("team-a") == tmp_path / "meet-recordings" / "team-a" def test_recordings_dir_env_override(monkeypatch, tmp_path): monkeypatch.setenv("MILLET_RECORDINGS_DIR", str(tmp_path / "rec")) assert paths.recordings_dir() == tmp_path / "rec" - assert paths.recordings_dir("blink") == tmp_path / "rec" / "blink" + assert paths.recordings_dir("team-a") == tmp_path / "rec" / "team-a" @pytest.mark.parametrize("bad", ["AB", "a", "ab", "1team", "has space", "UPPER", @@ -89,7 +89,7 @@ def test_invalid_team_slug_rejected(bad): paths.profiles_path(bad) -@pytest.mark.parametrize("good", ["blink", "twentyone", "team-a", "abc", +@pytest.mark.parametrize("good", ["team-a", "team-b", "team-a", "abc", "a1b2c3"]) def test_valid_team_slugs_accepted(good, monkeypatch, tmp_path): monkeypatch.setenv("HOME", str(tmp_path)) diff --git a/tests/test_pdf.py b/tests/test_pdf.py index 6737d19..726bd9a 100644 --- a/tests/test_pdf.py +++ b/tests/test_pdf.py @@ -218,12 +218,12 @@ def spy(text): monkeypatch.setattr(_pdf, "_escape_xml", spy) t = Transcript( segments=[ - Segment(start=0.0, end=5.0, text="hello", speaker="Kemal"), + Segment(start=0.0, end=5.0, text="hello", speaker="Nora"), Segment(start=6.0, end=6.2, text="Bye.", speaker="CROSSTALK"), ], - speakers=[Speaker(id="Kemal", label="Kemal"), + speakers=[Speaker(id="Nora", label="Nora"), Speaker(id="CROSSTALK", label="CROSSTALK")], language="en", audio_file="x.ogg", duration=10.0, ) generate_pdf(t, tmp_path / "out.pdf") - assert "Participants: Kemal" in seen + assert "Participants: Nora" in seen diff --git a/tests/test_speaker_repair.py b/tests/test_speaker_repair.py index 740b67f..f752326 100644 --- a/tests/test_speaker_repair.py +++ b/tests/test_speaker_repair.py @@ -42,7 +42,7 @@ def _items(spec, seed=0): def _interview(with_rob_cluster: bool): - """Shape of 01M6EV6Z: everything in SPEAKER_01, Rob's answers included.""" + """Shape of the 58 s interview: everything in SPEAKER_01, Ravi's answers included.""" spec = [] for k in range(17): spec.append(("SPEAKER_01", KEMAL, 1.5)) @@ -193,7 +193,7 @@ def _run(self, monkeypatch, tmp_path, **config_kwargs): wf.writeframes(np.zeros(16000 * 3, dtype=np.int16).tobytes()) asr = {"language": "en", "segments": [ - {"start": 0.0, "end": 1.0, "text": "Hey Rob, how are you?"}, + {"start": 0.0, "end": 1.0, "text": "Hey Ravi, how are you?"}, {"start": 1.0, "end": 2.0, "text": "I'm doing well."}, ]} @@ -294,8 +294,8 @@ def _setup(self, monkeypatch, fail_to=False): def test_filters_and_embeds(self, monkeypatch): inf, audio = self._setup(monkeypatch) segs = [ - Segment(0.0, 1.0, "a", "SPEAKER_00"), # Kemal - Segment(1.0, 2.0, "b", "SPEAKER_00"), # Rob + Segment(0.0, 1.0, "a", "SPEAKER_00"), # Nora + Segment(1.0, 2.0, "b", "SPEAKER_00"), # Ravi Segment(2.0, 3.0, "c", "SPEAKER_00"), # silence: below RMS floor Segment(3.0, 3.3, "d", "SPEAKER_00"), # too short Segment(3.0, 4.0, "e", None), # unlabeled diff --git a/tests/test_ssl_cert_injection.py b/tests/test_ssl_cert_injection.py index 92c359d..20ae959 100644 --- a/tests/test_ssl_cert_injection.py +++ b/tests/test_ssl_cert_injection.py @@ -1,6 +1,6 @@ """Tests for the F3 SSL_CERT_FILE injection in meet/__init__.py. -Reported by @patternn in the M8 retrospective: ``meet download `` +Reported by @peggy in the M8 retrospective: ``meet download `` failed with ``CERTIFICATE_VERIFY_FAILED`` on a python.org Python build on macOS, because torchaudio's alignment-model fetcher uses raw urllib which inherits the (empty) default SSL context. The fix injects diff --git a/tests/test_summarize_frames.py b/tests/test_summarize_frames.py index de7023d..ce350d1 100644 --- a/tests/test_summarize_frames.py +++ b/tests/test_summarize_frames.py @@ -98,7 +98,7 @@ def test_caps_frame_count(self, tmp_path): def test_over_cap_samples_evenly_not_head(self, tmp_path): """18 cue frames on a ~4-minute recording (session - 01M2P6FTRG4WAKKE5T7TV6HNFM) exceeded the endpoint's 10-image cap. + 01J9P94YQEE4VVQ3RCJJ3ZDTDC) exceeded the endpoint's 10-image cap. The sample must span the whole timeline: first + last kept, not a head-truncation that summarizes only the opening minutes.""" frames = [_png(tmp_path / f"cue_{i:04d}.png") for i in range(18)] diff --git a/tests/test_summarize_tinfoil_retry.py b/tests/test_summarize_tinfoil_retry.py index f10a78c..c5d4217 100644 --- a/tests/test_summarize_tinfoil_retry.py +++ b/tests/test_summarize_tinfoil_retry.py @@ -135,7 +135,7 @@ def behavior(attempt): assert state["attempt"] == 1 # no retry on a real auth error -# ── hard wall-clock deadline (incident 2026-09-15) ────────────────────────── +# ── hard wall-clock deadline ──────────────────────────────────────────────── # # The SDK's custom httpx transport can block in ssl.read() with no effective # timeout: millet's per-request timeout=600 never fired and a summary attempt diff --git a/tests/test_sync_team.py b/tests/test_sync_team.py index 33217e0..7b286e5 100644 --- a/tests/test_sync_team.py +++ b/tests/test_sync_team.py @@ -14,40 +14,40 @@ def home(monkeypatch, tmp_path): def test_per_team_config_roundtrip(home): - sync.save_sync_config({"repo_url": "https://example.com/blink.git"}, team="blink") + sync.save_sync_config({"repo_url": "https://example.com/team-a.git"}, team="team-a") sync.save_sync_config( - {"repo_url": "https://example.com/twentyone.git"}, team="twentyone" + {"repo_url": "https://example.com/team-b.git"}, team="team-b" ) - blink = sync.load_sync_config(team="blink") - twentyone = sync.load_sync_config(team="twentyone") - assert blink["repo_url"].endswith("blink.git") - assert twentyone["repo_url"].endswith("twentyone.git") + team_a = sync.load_sync_config(team="team-a") + team_b = sync.load_sync_config(team="team-b") + assert team_a["repo_url"].endswith("team-a.git") + assert team_b["repo_url"].endswith("team-b.git") # Files live in separate per-team dirs. - assert (home / ".config" / "meet" / "blink" / "sync_config.json").exists() - assert (home / ".config" / "meet" / "twentyone" / "sync_config.json").exists() + assert (home / ".config" / "meet" / "team-a" / "sync_config.json").exists() + assert (home / ".config" / "meet" / "team-b" / "sync_config.json").exists() # The global file is untouched. assert not (home / ".config" / "meet" / "sync_config.json").exists() def test_is_sync_configured_per_team(home): - assert sync.is_sync_configured(team="blink") is False - sync.save_sync_config({"repo_url": "https://example.com/blink.git"}, team="blink") - assert sync.is_sync_configured(team="blink") is True + assert sync.is_sync_configured(team="team-a") is False + sync.save_sync_config({"repo_url": "https://example.com/team-a.git"}, team="team-a") + assert sync.is_sync_configured(team="team-a") is True # A different team is still unconfigured. - assert sync.is_sync_configured(team="twentyone") is False + assert sync.is_sync_configured(team="team-b") is False def test_clone_dir_namespaced_by_team(home): """Two teams pointing at same-named repos get distinct clone dirs.""" url_a = "https://github.com/org-a/meetings.git" url_b = "https://github.com/org-b/meetings.git" - dir_a = sync._clone_dir_for(url_a, "blink") - dir_b = sync._clone_dir_for(url_b, "twentyone") + dir_a = sync._clone_dir_for(url_a, "team-a") + dir_b = sync._clone_dir_for(url_b, "team-b") assert dir_a != dir_b - assert dir_a.parent.name == "blink" - assert dir_b.parent.name == "twentyone" + assert dir_a.parent.name == "team-a" + assert dir_b.parent.name == "team-b" # Teamless keeps the flat layout. flat = sync._clone_dir_for(url_a, None) assert flat == sync.CLONE_BASE_DIR / "meetings" diff --git a/tests/test_transcribe.py b/tests/test_transcribe.py index 6f1bb7c..9c7b13c 100644 --- a/tests/test_transcribe.py +++ b/tests/test_transcribe.py @@ -320,7 +320,7 @@ def test_mac_sidecar_g4_default_assigns_you_via_margin(self, tmp_path): as a labeler contract: future tuning of either side (sidecar gain, labeler thresholds) must keep the Mac path working. - Calibration source: patternn's M6c.ii.b sign-off run + Calibration source: peggy's M6c.ii.b sign-off run (2026-05-14, meetscribe-record 0.2.0a1, Apple M1 / macOS 26.4.1) reported ``you_ratio = 0.242``. The synthetic amplitudes here reproduce that ratio: a sine-of-amplitude @@ -1154,11 +1154,11 @@ def test_ambiguous_segment_not_flipped(self, tmp_path): def test_noop_without_you_or_remote(self, tmp_path): """Correction is a no-op when there is no YOU+REMOTE pair.""" wav = _write_stereo(tmp_path / "m.wav", [(0.0, 2.0, "mic")]) - segs = [Segment(0.0, 2.0, "named", speaker="Kemal")] + segs = [Segment(0.0, 2.0, "named", speaker="Nora")] out, sp = _channel_correct_segments( - wav, segs, [Speaker(id="Kemal")], margin=0.30 + wav, segs, [Speaker(id="Nora")], margin=0.30 ) - assert out[0].speaker == "Kemal" + assert out[0].speaker == "Nora" class TestCorrectMicBleedSegments: @@ -1180,11 +1180,11 @@ def test_system_dominant_mic_segment_reassigned_to_overlapping_remote( Segment(0.0, 2.0, "genuine local", speaker="YOU"), Segment(2.0, 4.0, "bled remote", speaker="YOU"), ] - sys_segs = [Segment(2.0, 4.0, "remote speech", speaker="Openoms")] + sys_segs = [Segment(2.0, 4.0, "remote speech", speaker="Sam")] out = _correct_mic_bleed_segments(wav, mic_segs, sys_segs, margin=0.30) by_text = {s.text: s.speaker for s in out} assert by_text["genuine local"] == "YOU" - assert by_text["bled remote"] == "Openoms" # reassigned, not dropped + assert by_text["bled remote"] == "Sam" # reassigned, not dropped def test_bled_segment_without_overlap_uses_fallback(self, tmp_path): """A bled 'YOU' segment with no overlapping remote -> generic fallback.""" @@ -1211,11 +1211,11 @@ def test_echo_duplicate_of_remote_reassigned(self, tmp_path): Segment(0.0, 3.0, "the servers now to control", speaker="YOU"), ] sys_segs = [ - Segment(0.2, 3.2, "the servers now to control", speaker="Openoms"), + Segment(0.2, 3.2, "the servers now to control", speaker="Sam"), ] out = _correct_mic_bleed_segments(wav, mic_segs, sys_segs, margin=0.30) assert [(s.text, s.speaker) for s in out] == [ - ("the servers now to control", "Openoms") + ("the servers now to control", "Sam") ] def test_empty_segment_dropped(self, tmp_path): @@ -1384,7 +1384,7 @@ def _cfg(self, **kw): ) def test_isolated_short_fragment_flagged(self): - # Mirrors the Kim case: tiny early fragments, then real speech 25 min on. + # Mirrors the Omar case: tiny early fragments, then real speech 25 min on. segs = [ _seg(11.0, 11.5, "SPEAKER_02"), # 0.5s, isolated _seg(53.5, 53.8, "SPEAKER_02"), # 0.3s, isolated diff --git a/tests/test_voiceprint_gate.py b/tests/test_voiceprint_gate.py index d7eab27..22345b5 100644 --- a/tests/test_voiceprint_gate.py +++ b/tests/test_voiceprint_gate.py @@ -17,8 +17,8 @@ def test_strong_well_separated_match_applies(): - """0.93 confidence / 0.40 margin (a real Lukas-style match) → applies.""" - m = SpeakerMatch("Lukas", 0.93, evidence_seconds=958.0, margin=0.40) + """0.93 confidence / 0.40 margin (a real Pia-style match) → applies.""" + m = SpeakerMatch("Pia", 0.93, evidence_seconds=958.0, margin=0.40) assert weak_match_reason(m) is None @@ -66,7 +66,7 @@ def test_positional_backcompat_not_gated(): # ─── many-to-one matching (0.12.11) ────────────────────────────────────────── # Regression: diarization over-segments ONE person into several clusters # (volume/mic changes, cross-channel bleed). Greedy 1:1 matching used to name -# only the first cluster and leave the rest raw → needs_labeling + "Destiny ×3". +# only the first cluster and leave the rest raw → needs_labeling + "Quinn ×3". # identify_speakers now lets an already-claimed profile ALSO claim additional # clusters when each is confident on its own. @@ -128,43 +128,43 @@ def fake_embed(samples, sr, selected, inference): def test_two_clusters_same_person_both_matched(monkeypatch): - """Two near-identical Destiny clusters → BOTH named Destiny (many-to-one).""" + """Two near-identical Quinn clusters → BOTH named Quinn (many-to-one).""" destiny = _unit(1.0, 0.0, 0.0) andrej = _unit(0.0, 1.0, 0.0) matches = _run_identify( monkeypatch, cluster_embeddings={ - "SPEAKER_00": _unit(1.0, 0.02, 0.0), # Destiny (best) - "SPEAKER_01": andrej, # Andrej - "SPEAKER_02": _unit(0.98, 0.05, 0.0), # Destiny again (high conf) + "SPEAKER_00": _unit(1.0, 0.02, 0.0), # Quinn (best) + "SPEAKER_01": andrej, # Uma + "SPEAKER_02": _unit(0.98, 0.05, 0.0), # Quinn again (high conf) }, profiles={ - "Destiny": SpeakerProfile("Destiny", destiny, 3), - "Andrej": SpeakerProfile("Andrej", andrej, 3), + "Quinn": SpeakerProfile("Quinn", destiny, 3), + "Uma": SpeakerProfile("Uma", andrej, 3), }, ) - assert matches["SPEAKER_00"].name == "Destiny" - assert matches["SPEAKER_02"].name == "Destiny" # would be raw under 1:1 - assert matches["SPEAKER_01"].name == "Andrej" + assert matches["SPEAKER_00"].name == "Quinn" + assert matches["SPEAKER_02"].name == "Quinn" # would be raw under 1:1 + assert matches["SPEAKER_01"].name == "Uma" def test_secondary_cluster_below_autoapply_stays_unmatched(monkeypatch): """A 2nd cluster that only weakly resembles the claimed profile is NOT folded on (stays raw → human review), guarding against over-merge.""" destiny = _unit(1.0, 0.0, 0.0) - # Second 'Destiny-ish' cluster at ~0.66 cosine: above MATCH_THRESHOLD (0.65) + # Second 'Quinn-ish' cluster at ~0.66 cosine: above MATCH_THRESHOLD (0.65) # but below the many-to-one fold floor → not auto-folded. weak = _unit(0.66, 0.751, 0.0) assert float(np.dot(weak, destiny)) < MATCH_MANY_TO_ONE_CONFIDENCE matches = _run_identify( monkeypatch, cluster_embeddings={ - "SPEAKER_00": destiny, # strong Destiny + "SPEAKER_00": destiny, # strong Quinn "SPEAKER_01": weak, # weak resemblance }, - profiles={"Destiny": SpeakerProfile("Destiny", destiny, 3)}, + profiles={"Quinn": SpeakerProfile("Quinn", destiny, 3)}, ) - assert matches["SPEAKER_00"].name == "Destiny" + assert matches["SPEAKER_00"].name == "Quinn" assert "SPEAKER_01" not in matches @@ -237,12 +237,12 @@ def test_single_cluster_per_profile_unchanged(monkeypatch): monkeypatch, cluster_embeddings={"SPEAKER_00": destiny, "SPEAKER_01": andrej}, profiles={ - "Destiny": SpeakerProfile("Destiny", destiny, 3), - "Andrej": SpeakerProfile("Andrej", andrej, 3), + "Quinn": SpeakerProfile("Quinn", destiny, 3), + "Uma": SpeakerProfile("Uma", andrej, 3), }, ) - assert matches["SPEAKER_00"].name == "Destiny" - assert matches["SPEAKER_01"].name == "Andrej" + assert matches["SPEAKER_00"].name == "Quinn" + assert matches["SPEAKER_01"].name == "Uma" # ─── CROSSTALK is reserved: never enrolled, never matched ──────────────────── @@ -253,17 +253,17 @@ def test_single_cluster_per_profile_unchanged(monkeypatch): def test_crosstalk_profile_is_never_matched(monkeypatch): """Even if an older build enrolled a CROSSTALK profile, identify ignores it.""" crosstalk = _unit(1.0, 0.0, 0.0) - kemal = _unit(0.0, 1.0, 0.0) + nora = _unit(0.0, 1.0, 0.0) matches = _run_identify( monkeypatch, - cluster_embeddings={"SPEAKER_00": crosstalk, "SPEAKER_01": kemal}, + cluster_embeddings={"SPEAKER_00": crosstalk, "SPEAKER_01": nora}, profiles={ "CROSSTALK": SpeakerProfile("CROSSTALK", crosstalk, 5), - "Kemal": SpeakerProfile("Kemal", kemal, 5), + "Nora": SpeakerProfile("Nora", nora, 5), }, ) assert "SPEAKER_00" not in matches - assert matches["SPEAKER_01"].name == "Kemal" + assert matches["SPEAKER_01"].name == "Nora" def test_crosstalk_label_never_updates_profiles(monkeypatch): @@ -281,7 +281,7 @@ def boom(): # ─── Learning hygiene: only dense real speech builds a profile ─────────────── -# The "Pattern" incident (vezir, 2026-09): profile updates took a cluster's +# The "Peggy" incident (vezir, 2026-09): profile updates took a cluster's # LONGEST segments — for a filler cluster, fillers Whisper stretched over # silence, i.e. room tone + the scribe's echo. The profile ended up 0.86 to # the scribe's echo and 0.10 to the person it was named after, then matched @@ -293,8 +293,8 @@ def boom(): ) -def _pattern_cluster(sid="Pattern"): - """Filler cluster as it appeared on 01M3QN8F: stretched 'Yeah.'s.""" +def _pattern_cluster(sid="Peggy"): + """Filler cluster as it appeared in a real session: stretched 'Yeah.'s.""" return [ Segment(start=10.0, end=16.7, text="Yeah.", speaker=sid), Segment(start=40.0, end=45.2, text="Okay.", speaker=sid), @@ -305,7 +305,7 @@ def _pattern_cluster(sid="Pattern"): def test_filler_cluster_is_not_learnable(): - assert learnable_segments(_pattern_cluster(), "Pattern") == [] + assert learnable_segments(_pattern_cluster(), "Peggy") == [] def test_dense_speech_is_learnable_most_words_first(): @@ -347,8 +347,8 @@ def boom(*a, **k): monkeypatch.setattr(_vp, "_get_inference", boom) monkeypatch.setattr(_vp, "save_profiles", boom) _vp.update_profiles_from_confirmed_labels( - Path("/tmp/fake.ogg"), _pattern_cluster(), {"Pattern": "Pattern"}, - {"Pattern": "system"}, profiles_path=Path("/tmp/profiles.json"), + Path("/tmp/fake.ogg"), _pattern_cluster(), {"Peggy": "Peggy"}, + {"Peggy": "system"}, profiles_path=Path("/tmp/profiles.json"), ) @@ -376,11 +376,11 @@ def fake_embed(samples, sr, selected, inference): speaker="SPEAKER_01"), ] _vp.update_profiles_from_confirmed_labels( - Path("/tmp/fake.ogg"), segs, {"SPEAKER_01": "Gustavo"}, {"SPEAKER_01": "system"}, + Path("/tmp/fake.ogg"), segs, {"SPEAKER_01": "Rosa"}, {"SPEAKER_01": "system"}, profiles_path=Path("/tmp/profiles.json"), ) # Neither the stretched "Yeah." (6.7 s) nor "Okay." (5.2 s) — the longest # segments, which the old selection preferred — reach the embedding; the # one real line in the filler part does (6 words in 2.1 s), most words first. assert seen["spans"] == [(200.0, 204.0), (210.0, 213.0), (95.0, 97.1)] - assert "Gustavo" in seen["saved"] + assert "Rosa" in seen["saved"] From 7f366ceb974b27b11705680967af25e5c7abcfdc Mon Sep 17 00:00:00 2001 From: pretyflaco Date: Thu, 5 Nov 2026 13:22:16 +0300 Subject: [PATCH 2/2] chore: drop remaining real session ids and incident dates Real session ids (full and prefixes) in a comment, a doc and a test, and production incident dates in comments. Dates of external API verifications are kept. --- docs/tee-summarization-evaluation.md | 2 +- millet/label.py | 2 +- millet/speaker_repair.py | 2 +- millet/summarize.py | 4 ++-- tests/test_label.py | 2 +- tests/test_voiceprint_gate.py | 2 +- 6 files changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/tee-summarization-evaluation.md b/docs/tee-summarization-evaluation.md index e987859..545627b 100644 --- a/docs/tee-summarization-evaluation.md +++ b/docs/tee-summarization-evaluation.md @@ -144,7 +144,7 @@ did not clear the bar to become the default. 3. **Baselines are historical**, not fresh re-runs: same prompts and temperature, but generated between 2026-05 and 2026-09 against whatever `claude-sonnet-4-6` resolved to then. -4. **One baseline predates a prompt change.** `01KQZ561CR` (TR) was +4. **One baseline predates a prompt change.** One Turkish meeting was summarized 2026-05-06, before the 2026-05-24 prompt edit. The other 9 used prompts identical to the candidate runs; the default summary prompts have not changed since (v0.17.0 only *added* iteration-plan diff --git a/millet/label.py b/millet/label.py index 7106167..96d4c79 100644 --- a/millet/label.py +++ b/millet/label.py @@ -446,7 +446,7 @@ def absorb_tiny_speakers( real conversation, not to name it. A small cluster holding a real sentence (:func:`is_dense_utterance`) is not - noise and is left for a human. Incident 2026-11-02: in a 58 s phone + noise and is left for a human. In a 58 s phone interview, the only segment pyannote split off for the second speaker (4.4 s, 21 words) was folded into the interviewer, so the session came back with one speaker. Replaying 704 sessions, this keeps 6 tiny clusters raw. diff --git a/millet/speaker_repair.py b/millet/speaker_repair.py index 0bb057a..b1a8958 100644 --- a/millet/speaker_repair.py +++ b/millet/speaker_repair.py @@ -1,6 +1,6 @@ """Per-segment speaker repair for the mono diarization path. -pyannote sometimes puts two people into one cluster. Incident 2026-11-02: in +pyannote sometimes puts two people into one cluster. In a 58 s phone interview with quick question/answer turns it produced one turn for the first 43 s, and the interviewee's answers all landed in the interviewer's cluster. The two voices were easy to tell apart (centroid diff --git a/millet/summarize.py b/millet/summarize.py index cbf0097..20e5f01 100644 --- a/millet/summarize.py +++ b/millet/summarize.py @@ -307,7 +307,7 @@ def verify_model(backend: str, model: str, *, timeout: int = 10) -> str | None: # Hard endpoint limit, not a budget choice: the attested vision endpoints # reject a request carrying more than 10 images outright — verified live -# 2026-09-17 (session 01M2P6FTRG4WAKKE5T7TV6HNFM, 18 cue frames → venice +# 2026-09-17 (a session with 18 cue frames → venice # 400 "At most 10 image(s) may be provided in one request"). The job log # only carries the chain's last error, so tinfoil's own failure text went # uncaptured — the cap is applied to every vision backend so whichever one @@ -1335,7 +1335,7 @@ class _TinfoilAttemptStuck(TimeoutError): def _run_under_deadline(fn, *, seconds: float): """Run ``fn()`` under a hard wall-clock deadline in a daemon thread. - Incident 2026-09-15: the Tinfoil SDK's custom httpx transport can block + The Tinfoil SDK's custom httpx transport can block in ``ssl.read()`` with no effective timeout — a summary attempt pinned a vezir job in ``transcribing`` for 30+ minutes while millet's per-request ``timeout=600`` never fired (faulthandler stack: openai -> httpx -> diff --git a/tests/test_label.py b/tests/test_label.py index 6df1ee6..8b57476 100644 --- a/tests/test_label.py +++ b/tests/test_label.py @@ -963,7 +963,7 @@ def _txn(self, segments): ) def test_tiny_remote_folds_into_unmatched_dominant(self): - # The 01KV8G41 case: big UNMATCHED SPEAKER_00 + tiny REMOTE. + # A real case: big UNMATCHED SPEAKER_00 + tiny REMOTE. segs = [ Segment(start=0.0, end=300.0, text="long unmatched turn", speaker="SPEAKER_00"), Segment(start=312.6, end=313.7, text="Thank you.", speaker="REMOTE"), diff --git a/tests/test_voiceprint_gate.py b/tests/test_voiceprint_gate.py index 22345b5..de6cb09 100644 --- a/tests/test_voiceprint_gate.py +++ b/tests/test_voiceprint_gate.py @@ -281,7 +281,7 @@ def boom(): # ─── Learning hygiene: only dense real speech builds a profile ─────────────── -# The "Peggy" incident (vezir, 2026-09): profile updates took a cluster's +# A polluted-profile incident: profile updates took a cluster's # LONGEST segments — for a filler cluster, fillers Whisper stretched over # silence, i.e. room tone + the scribe's echo. The profile ended up 0.86 to # the scribe's echo and 0.10 to the person it was named after, then matched