+264

apps/speakers/bootstrap.py

reviewed

··· 21 21 22 22 from __future__ import annotations 23 23 24 24 + import bisect 24 25 import json 25 26 import logging 26 27 from collections import defaultdict 28 28 + from pathlib import Path 27 29 from typing import Any 28 30 29 31 import numpy as np ··· 738 740 ) 739 741 740 742 return stats 743 743 + 744 744 + 745 745 + # Import streams that contain AI chat (no real speakers to seed) 746 746 + _AI_CHAT_STREAMS = frozenset({"import.chatgpt", "import.claude", "import.gemini"}) 747 747 + 748 748 + 749 749 + def _time_str_to_seconds(time_str: str) -> int: 750 750 + """Parse HH:MM:SS to total seconds.""" 751 751 + parts = time_str.split(":") 752 752 + return int(parts[0]) * 3600 + int(parts[1]) * 60 + int(parts[2]) 753 753 + 754 754 + 755 755 + def _parse_conversation_speakers(seg_dir: Path) -> list[tuple[int, str]]: 756 756 + """Parse speaker assignments from conversation_transcript.jsonl. 757 757 + 758 758 + Returns sorted list of (start_seconds, speaker_name) tuples. 759 759 + Skips the metadata header line and entries with empty speaker fields. 760 760 + """ 761 761 + ct_path = seg_dir / "conversation_transcript.jsonl" 762 762 + if not ct_path.exists(): 763 763 + return [] 764 764 + 765 765 + entries: list[tuple[int, str]] = [] 766 766 + try: 767 767 + with open(ct_path, encoding="utf-8") as f: 768 768 + lines = f.readlines() 769 769 + except OSError: 770 770 + return [] 771 771 + 772 772 + # Skip header (line 0), parse entry lines 773 773 + for line in lines[1:]: 774 774 + try: 775 775 + entry = json.loads(line) 776 776 + except (json.JSONDecodeError, ValueError): 777 777 + continue 778 778 + speaker = entry.get("speaker", "") 779 779 + start = entry.get("start", "") 780 780 + if not speaker or not start: 781 781 + continue 782 782 + try: 783 783 + seconds = _time_str_to_seconds(start) 784 784 + except (ValueError, IndexError): 785 785 + continue 786 786 + entries.append((seconds, speaker)) 787 787 + 788 788 + entries.sort(key=lambda x: x[0]) 789 789 + return entries 790 790 + 791 791 + 792 792 + def _find_speaker_at_time( 793 793 + speaker_entries: list[tuple[int, str]], target_seconds: int 794 794 + ) -> str | None: 795 795 + """Find the speaker at a given time using binary search. 796 796 + 797 797 + Returns the speaker whose entry starts at or before target_seconds, 798 798 + or None if no entry precedes the target time. 799 799 + """ 800 800 + if not speaker_entries: 801 801 + return None 802 802 + # bisect on just the time values 803 803 + times = [e[0] for e in speaker_entries] 804 804 + idx = bisect.bisect_right(times, target_seconds) - 1 805 805 + if idx < 0: 806 806 + return None 807 807 + return speaker_entries[idx][1] 808 808 + 809 809 + 810 810 + def link_import(name: str, entity_id: str) -> dict[str, Any]: 811 811 + """Link an import participant name as an aka on an existing entity. 812 812 + 813 813 + Args: 814 814 + name: The participant name from an import transcript 815 815 + entity_id: The entity ID to link to 816 816 + 817 817 + Returns: 818 818 + Dict with link result or error 819 819 + """ 820 820 + entity = load_journal_entity(entity_id) 821 821 + if not entity: 822 822 + return {"error": f"Entity not found: {entity_id}"} 823 823 + 824 824 + existing_aka = set(entity.get("aka", [])) 825 825 + already_present = name in existing_aka 826 826 + 827 827 + if not already_present: 828 828 + existing_aka.add(name) 829 829 + entity["aka"] = sorted(existing_aka) 830 830 + entity["updated_at"] = now_ms() 831 831 + save_journal_entity(entity) 832 832 + 833 833 + return { 834 834 + "linked": True, 835 835 + "entity_id": entity_id, 836 836 + "name_added": name, 837 837 + "already_present": already_present, 838 838 + } 839 839 + 840 840 + 841 841 + def seed_from_imports(dry_run: bool = False) -> dict[str, Any]: 842 842 + """Seed voiceprints from import segments with speaker-attributed transcripts.""" 843 843 + ( 844 844 + load_embeddings_file, 845 845 + normalize_embedding, 846 846 + scan_segment_embeddings, 847 847 + _, 848 848 + ) = _routes_helpers() 849 849 + 850 850 + centroid_data = load_owner_centroid() 851 851 + if centroid_data is None: 852 852 + return {"error": "No confirmed owner centroid. Run owner detection first."} 853 853 + 854 854 + owner_centroid, owner_threshold = centroid_data 855 855 + 856 856 + journal_entities = load_all_journal_entities() 857 857 + entities_list = [e for e in journal_entities.values() if not e.get("blocked")] 858 858 + 859 859 + stats: dict[str, Any] = { 860 860 + "segments_scanned": 0, 861 861 + "segments_with_speakers": 0, 862 862 + "speakers_found": {}, 863 863 + "embeddings_saved": 0, 864 864 + "embeddings_skipped_owner": 0, 865 865 + "embeddings_skipped_duplicate": 0, 866 866 + "speakers_unmatched": [], 867 867 + "errors": [], 868 868 + } 869 869 + 870 870 + entity_embeddings: dict[str, list[tuple[np.ndarray, dict]]] = defaultdict(list) 871 871 + entity_existing: dict[str, set] = {} 872 872 + unmatched_set: set[str] = set() 873 873 + speaker_entity_cache: dict[str, Any] = {} 874 874 + 875 875 + days = sorted(day_dirs().keys()) 876 876 + 877 877 + for day_idx, day in enumerate(days): 878 878 + segments = scan_segment_embeddings(day) 879 879 + 880 880 + for segment in segments: 881 881 + stream = segment["stream"] 882 882 + if not stream.startswith("import.") or stream in _AI_CHAT_STREAMS: 883 883 + continue 884 884 + 885 885 + stats["segments_scanned"] += 1 886 886 + seg_key = segment["key"] 887 887 + seg_dir = segment_path(day, seg_key, stream) 888 888 + speaker_entries = _parse_conversation_speakers(seg_dir) 889 889 + if not speaker_entries: 890 890 + continue 891 891 + 892 892 + stats["segments_with_speakers"] += 1 893 893 + 894 894 + for source in segment["sources"]: 895 895 + source_jsonl = seg_dir / f"{source}.jsonl" 896 896 + stmt_times: dict[int, int] = {} 897 897 + if source_jsonl.exists(): 898 898 + try: 899 899 + with open(source_jsonl, encoding="utf-8") as f: 900 900 + src_lines = f.readlines() 901 901 + except OSError as exc: 902 902 + stats["errors"].append( 903 903 + f"Failed to read source transcript {day}/{seg_key}/{source}: {exc}" 904 904 + ) 905 905 + continue 906 906 + 907 907 + for i, line in enumerate(src_lines[1:], start=1): 908 908 + try: 909 909 + entry = json.loads(line) 910 910 + start = entry.get("start", "") 911 911 + if start: 912 912 + stmt_times[i] = _time_str_to_seconds(start) 913 913 + except (json.JSONDecodeError, ValueError, IndexError): 914 914 + continue 915 915 + 916 916 + emb_data = load_embeddings_file(seg_dir / f"{source}.npz") 917 917 + if emb_data is None: 918 918 + continue 919 919 + 920 920 + embeddings, statement_ids = emb_data 921 921 + 922 922 + for embedding, sid in zip(embeddings, statement_ids): 923 923 + sentence_id = int(sid) 924 924 + 925 925 + target_time = stmt_times.get(sentence_id) 926 926 + if target_time is None: 927 927 + continue 928 928 + 929 929 + speaker_name = _find_speaker_at_time(speaker_entries, target_time) 930 930 + if not speaker_name: 931 931 + continue 932 932 + 933 933 + if speaker_name not in speaker_entity_cache: 934 934 + entity = find_matching_entity(speaker_name, entities_list) 935 935 + speaker_entity_cache[speaker_name] = entity 936 936 + 937 937 + entity = speaker_entity_cache[speaker_name] 938 938 + if entity is None: 939 939 + if speaker_name not in unmatched_set: 940 940 + unmatched_set.add(speaker_name) 941 941 + stats["speakers_unmatched"].append(speaker_name) 942 942 + continue 943 943 + 944 944 + entity_id = entity["id"] 945 945 + entity_name = entity.get("name", speaker_name) 946 946 + stats["speakers_found"].setdefault(entity_name, 0) 947 947 + 948 948 + if entity_id not in entity_existing: 949 949 + entity_existing[entity_id] = _load_existing_voiceprint_keys( 950 950 + entity_id 951 951 + ) 952 952 + 953 953 + existing_keys = entity_existing[entity_id] 954 954 + vp_key = (day, seg_key, source, sentence_id) 955 955 + 956 956 + if vp_key in existing_keys: 957 957 + stats["embeddings_skipped_duplicate"] += 1 958 958 + continue 959 959 + 960 960 + normalized = normalize_embedding(embedding) 961 961 + if normalized is None: 962 962 + continue 963 963 + 964 964 + owner_score = float(np.dot(normalized, owner_centroid)) 965 965 + if owner_score >= owner_threshold: 966 966 + stats["embeddings_skipped_owner"] += 1 967 967 + continue 968 968 + 969 969 + metadata = { 970 970 + "day": day, 971 971 + "segment_key": seg_key, 972 972 + "source": source, 973 973 + "stream": stream, 974 974 + "sentence_id": sentence_id, 975 975 + "added_at": now_ms(), 976 976 + } 977 977 + 978 978 + entity_embeddings[entity_id].append((normalized, metadata)) 979 979 + existing_keys.add(vp_key) 980 980 + stats["speakers_found"][entity_name] += 1 981 981 + 982 982 + if (day_idx + 1) % 10 == 0: 983 983 + logger.info( 984 984 + "Import seeding progress: %d/%d days, %d segments, %d embeddings queued", 985 985 + day_idx + 1, 986 986 + len(days), 987 987 + stats["segments_scanned"], 988 988 + sum(len(v) for v in entity_embeddings.values()), 989 989 + ) 990 990 + 991 991 + if not dry_run: 992 992 + for entity_id, emb_list in entity_embeddings.items(): 993 993 + try: 994 994 + saved = _save_voiceprints_batch(entity_id, emb_list) 995 995 + stats["embeddings_saved"] += saved 996 996 + except Exception as e: 997 997 + stats["errors"].append(f"Failed to save for {entity_id}: {e}") 998 998 + logger.exception( 999 999 + "Failed to save import-seeded voiceprints for %s", entity_id 1000 1000 + ) 1001 1001 + else: 1002 1002 + stats["embeddings_saved"] = sum(len(v) for v in entity_embeddings.values()) 1003 1003 + 1004 1004 + return stats

+82

apps/speakers/call.py

reviewed

··· 12 12 sol call speakers discover [--json] 13 13 sol call speakers identify <cluster-id> <name> [--entity-id ID] 14 14 sol call speakers merge-names <alias> <canonical> 15 15 + sol call speakers link-import <name> --entity-id <ID> 16 16 + sol call speakers seed-from-imports [--dry-run] [--json] 15 17 sol call speakers suggest [--limit N] [--json] 16 18 sol call speakers link-import <name> --entity-id <ID> 17 19 sol call speakers seed-from-imports [--dry-run] [--json] ··· 385 387 typer.echo(output, err=True) 386 388 raise typer.Exit(1) 387 389 typer.echo(output) 390 390 + 391 391 + 392 392 + @app.command("link-import") 393 393 + def link_import_cmd( 394 394 + name: str = typer.Argument(..., help="Import participant name to link."), 395 395 + entity_id: str = typer.Option(..., "--entity-id", help="Entity ID to link to."), 396 396 + ) -> None: 397 397 + """Link an import participant name as an aka on an existing entity.""" 398 398 + import json 399 399 + 400 400 + from apps.speakers.bootstrap import link_import 401 401 + 402 402 + result = link_import(name, entity_id) 403 403 + output = json.dumps(result, indent=2, default=str) 404 404 + if "error" in result: 405 405 + typer.echo(output, err=True) 406 406 + raise typer.Exit(1) 407 407 + typer.echo(output) 408 408 + 409 409 + 410 410 + @app.command("seed-from-imports") 411 411 + def seed_from_imports_cmd( 412 412 + dry_run: bool = typer.Option( 413 413 + False, "--dry-run", help="Show what would be saved without saving." 414 414 + ), 415 415 + json_output: bool = typer.Option( 416 416 + False, "--json", help="Output full result as JSON." 417 417 + ), 418 418 + ) -> None: 419 419 + """Seed voiceprints from import segments with speaker-attributed transcripts. 420 420 + 421 421 + Scans import streams for segments with both conversation_transcript.jsonl 422 422 + (with speaker labels) and audio embeddings. Maps each embedding to a speaker 423 423 + via time-based alignment, matches speakers to existing entities, and saves 424 424 + embeddings as voiceprints with owner contamination guard. 425 425 + """ 426 426 + from apps.speakers.bootstrap import seed_from_imports 427 427 + 428 428 + if dry_run and not json_output: 429 429 + typer.echo("DRY RUN — no voiceprints will be saved\n") 430 430 + 431 431 + if not json_output: 432 432 + typer.echo("Seeding voiceprints from import segments...") 433 433 + stats = seed_from_imports(dry_run=dry_run) 434 434 + 435 435 + if "error" in stats: 436 436 + typer.echo(f"Error: {stats['error']}", err=True) 437 437 + raise typer.Exit(1) 438 438 + if json_output: 439 439 + import json as json_mod 440 440 + 441 441 + typer.echo(json_mod.dumps(stats, indent=2, default=str)) 442 442 + return 443 443 + 444 444 + typer.echo(f"\nSegments scanned: {stats['segments_scanned']}") 445 445 + typer.echo(f"Segments with speakers: {stats['segments_with_speakers']}") 446 446 + typer.echo(f"Unique speakers: {len(stats['speakers_found'])}") 447 447 + typer.echo(f"Embeddings saved: {stats['embeddings_saved']}") 448 448 + typer.echo(f"Embeddings skipped (owner): {stats['embeddings_skipped_owner']}") 449 449 + typer.echo( 450 450 + f"Embeddings skipped (duplicate): {stats['embeddings_skipped_duplicate']}" 451 451 + ) 452 452 + 453 453 + if stats["speakers_found"]: 454 454 + typer.echo("\nSpeakers by embedding count:") 455 455 + sorted_speakers = sorted( 456 456 + stats["speakers_found"].items(), key=lambda x: x[1], reverse=True 457 457 + ) 458 458 + for name, count in sorted_speakers[:15]: 459 459 + typer.echo(f" {name}: {count}") 460 460 + 461 461 + if stats["speakers_unmatched"]: 462 462 + typer.echo(f"\nUnmatched speakers ({len(stats['speakers_unmatched'])}):") 463 463 + for name in stats["speakers_unmatched"]: 464 464 + typer.echo(f" {name}") 465 465 + 466 466 + if stats["errors"]: 467 467 + typer.echo(f"\nErrors ({len(stats['errors'])}):", err=True) 468 468 + for err in stats["errors"]: 469 469 + typer.echo(f" {err}", err=True) 388 470 389 471 390 472 @app.command()

+94

apps/speakers/tests/conftest.py

reviewed

··· 310 310 311 311 return labels_path 312 312 313 313 + def create_import_segment( 314 314 + self, 315 315 + day: str, 316 316 + segment_key: str, 317 317 + speakers: list[tuple[str, str]], 318 318 + *, 319 319 + stream: str = "import.granola", 320 320 + embeddings: np.ndarray | None = None, 321 321 + ) -> Path: 322 322 + """Create an import segment with conversation_transcript and embeddings. 323 323 + 324 324 + Creates both a conversation_transcript.jsonl (with speaker labels) and 325 325 + imported_audio.{jsonl,npz,flac} (with aligned embeddings) in the 326 326 + same segment directory. 327 327 + 328 328 + Args: 329 329 + day: Day string (YYYYMMDD) 330 330 + segment_key: Segment key (HHMMSS_LEN) 331 331 + speakers: List of (speaker_name, text) tuples for each sentence 332 332 + stream: Import stream name (default: import.granola) 333 333 + embeddings: Optional pre-built embeddings array (num_sentences x 256) 334 334 + """ 335 335 + segment_dir = self.journal / day / stream / segment_key 336 336 + segment_dir.mkdir(parents=True, exist_ok=True) 337 337 + 338 338 + num_sentences = len(speakers) 339 339 + 340 340 + time_part = segment_key.split("_")[0] 341 341 + base_h = int(time_part[0:2]) 342 342 + base_m = int(time_part[2:4]) 343 343 + base_s = int(time_part[4:6]) 344 344 + base_seconds = base_h * 3600 + base_m * 60 + base_s 345 345 + 346 346 + ct_lines = [ 347 347 + json.dumps({"imported": {"id": "test-import"}, "topics": "test"}) 348 348 + ] 349 349 + for i, (speaker, text) in enumerate(speakers): 350 350 + offset = i * 5 351 351 + abs_seconds = base_seconds + offset 352 352 + h = (abs_seconds // 3600) % 24 353 353 + m = (abs_seconds % 3600) // 60 354 354 + s = abs_seconds % 60 355 355 + ct_lines.append( 356 356 + json.dumps( 357 357 + { 358 358 + "start": f"{h:02d}:{m:02d}:{s:02d}", 359 359 + "speaker": speaker, 360 360 + "text": text, 361 361 + "source": "import", 362 362 + } 363 363 + ) 364 364 + ) 365 365 + ct_path = segment_dir / "conversation_transcript.jsonl" 366 366 + ct_path.write_text("\n".join(ct_lines) + "\n") 367 367 + 368 368 + audio_lines = [ 369 369 + json.dumps({"raw": "imported_audio.flac", "model": "medium.en"}) 370 370 + ] 371 371 + for i, (_speaker, text) in enumerate(speakers): 372 372 + offset = i * 5 373 373 + abs_seconds = base_seconds + offset 374 374 + h = (abs_seconds // 3600) % 24 375 375 + m = (abs_seconds % 3600) // 60 376 376 + s = abs_seconds % 60 377 377 + audio_lines.append( 378 378 + json.dumps( 379 379 + { 380 380 + "start": f"{h:02d}:{m:02d}:{s:02d}", 381 381 + "text": text, 382 382 + } 383 383 + ) 384 384 + ) 385 385 + audio_jsonl_path = segment_dir / "imported_audio.jsonl" 386 386 + audio_jsonl_path.write_text("\n".join(audio_lines) + "\n") 387 387 + 388 388 + if embeddings is None: 389 389 + source_embeddings = np.random.randn(num_sentences, 256).astype( 390 390 + np.float32 391 391 + ) 392 392 + norms = np.linalg.norm(source_embeddings, axis=1, keepdims=True) 393 393 + source_embeddings = source_embeddings / norms 394 394 + else: 395 395 + source_embeddings = embeddings.astype(np.float32) 396 396 + statement_ids = np.arange(1, num_sentences + 1, dtype=np.int32) 397 397 + np.savez_compressed( 398 398 + segment_dir / "imported_audio.npz", 399 399 + embeddings=source_embeddings, 400 400 + statement_ids=statement_ids, 401 401 + ) 402 402 + 403 403 + (segment_dir / "imported_audio.flac").write_bytes(b"") 404 404 + 405 405 + return segment_dir 406 406 + 313 407 def _create(): 314 408 return SpeakersEnv(tmp_path) 315 409

+234

apps/speakers/tests/test_import_composition.py

reviewed

··· 1 1 + # SPDX-License-Identifier: AGPL-3.0-only 2 2 + # Copyright (c) 2026 sol pbc 3 3 + 4 4 + """Tests for import-linking and import-based voiceprint seeding.""" 5 5 + 6 6 + from __future__ import annotations 7 7 + 8 8 + import json 9 9 + 10 10 + import numpy as np 11 11 + from typer.testing import CliRunner 12 12 + 13 13 + from apps.speakers.bootstrap import link_import, seed_from_imports 14 14 + from apps.speakers.call import app as speakers_app 15 15 + from think.entities.journal import load_journal_entity 16 16 + 17 17 + _runner = CliRunner() 18 18 + 19 19 + 20 20 + def _normalized_vector(seed: int) -> np.ndarray: 21 21 + rng = np.random.default_rng(seed) 22 22 + vec = rng.standard_normal(256).astype(np.float32) 23 23 + return vec / np.linalg.norm(vec) 24 24 + 25 25 + 26 26 + def _mock_owner(monkeypatch, vector: np.ndarray, threshold: float = 0.85) -> None: 27 27 + monkeypatch.setattr( 28 28 + "apps.speakers.bootstrap.load_owner_centroid", 29 29 + lambda: (vector.astype(np.float32), threshold), 30 30 + ) 31 31 + 32 32 + 33 33 + def test_link_import_success(speakers_env): 34 34 + env = speakers_env() 35 35 + env.create_entity("Alice Test") 36 36 + 37 37 + result = link_import("Alice Imported", "alice_test") 38 38 + 39 39 + assert result["linked"] is True 40 40 + assert result["already_present"] is False 41 41 + entity = load_journal_entity("alice_test") 42 42 + assert entity is not None 43 43 + assert "Alice Imported" in entity.get("aka", []) 44 44 + 45 45 + 46 46 + def test_link_import_entity_not_found(speakers_env): 47 47 + speakers_env() 48 48 + 49 49 + result = link_import("Alice", "nonexistent") 50 50 + 51 51 + assert "error" in result 52 52 + 53 53 + 54 54 + def test_link_import_already_present(speakers_env): 55 55 + env = speakers_env() 56 56 + entity_dir = env.create_entity("Alice Test") 57 57 + entity_path = entity_dir / "entity.json" 58 58 + entity = json.loads(entity_path.read_text(encoding="utf-8")) 59 59 + entity["aka"] = ["Alice Imported"] 60 60 + entity_path.write_text(json.dumps(entity), encoding="utf-8") 61 61 + 62 62 + result = link_import("Alice Imported", "alice_test") 63 63 + 64 64 + assert result["linked"] is True 65 65 + assert result["already_present"] is True 66 66 + 67 67 + 68 68 + def test_seed_from_imports_basic(speakers_env, monkeypatch): 69 69 + env = speakers_env() 70 70 + env.create_entity("Alice Test") 71 71 + embeddings = np.vstack([_normalized_vector(i) for i in range(3)]).astype(np.float32) 72 72 + env.create_import_segment( 73 73 + "20240101", 74 74 + "120000_300", 75 75 + [("Alice Test", "Hello")] * 3, 76 76 + embeddings=embeddings, 77 77 + ) 78 78 + _mock_owner(monkeypatch, _normalized_vector(99), threshold=0.99) 79 79 + 80 80 + result = seed_from_imports() 81 81 + 82 82 + assert result["segments_scanned"] == 1 83 83 + assert result["segments_with_speakers"] == 1 84 84 + assert result["embeddings_saved"] == 3 85 85 + assert result["speakers_found"] == {"Alice Test": 3} 86 86 + vp_path = env.journal / "entities" / "alice_test" / "voiceprints.npz" 87 87 + assert vp_path.exists() 88 88 + 89 89 + 90 90 + def test_seed_from_imports_dry_run(speakers_env, monkeypatch): 91 91 + env = speakers_env() 92 92 + env.create_entity("Alice Test") 93 93 + embeddings = np.vstack([_normalized_vector(i) for i in range(3)]).astype(np.float32) 94 94 + env.create_import_segment( 95 95 + "20240101", 96 96 + "120000_300", 97 97 + [("Alice Test", "Hello")] * 3, 98 98 + embeddings=embeddings, 99 99 + ) 100 100 + _mock_owner(monkeypatch, _normalized_vector(77), threshold=0.99) 101 101 + 102 102 + result = seed_from_imports(dry_run=True) 103 103 + 104 104 + assert result["embeddings_saved"] == 3 105 105 + vp_path = env.journal / "entities" / "alice_test" / "voiceprints.npz" 106 106 + assert not vp_path.exists() 107 107 + 108 108 + 109 109 + def test_seed_from_imports_owner_skip(speakers_env, monkeypatch): 110 110 + env = speakers_env() 111 111 + env.create_entity("Alice Test") 112 112 + owner_vec = _normalized_vector(123) 113 113 + embeddings = np.vstack([owner_vec, owner_vec, owner_vec]).astype(np.float32) 114 114 + env.create_import_segment( 115 115 + "20240101", 116 116 + "120000_300", 117 117 + [("Alice Test", "Hello")] * 3, 118 118 + embeddings=embeddings, 119 119 + ) 120 120 + _mock_owner(monkeypatch, owner_vec, threshold=0.8) 121 121 + 122 122 + result = seed_from_imports() 123 123 + 124 124 + assert result["embeddings_saved"] == 0 125 125 + assert result["embeddings_skipped_owner"] == 3 126 126 + 127 127 + 128 128 + def test_seed_from_imports_dedup(speakers_env, monkeypatch): 129 129 + env = speakers_env() 130 130 + env.create_entity("Alice Test") 131 131 + embeddings = np.vstack([_normalized_vector(i) for i in range(3)]).astype(np.float32) 132 132 + env.create_import_segment( 133 133 + "20240101", 134 134 + "120000_300", 135 135 + [("Alice Test", "Hello")] * 3, 136 136 + embeddings=embeddings, 137 137 + ) 138 138 + _mock_owner(monkeypatch, _normalized_vector(88), threshold=0.99) 139 139 + 140 140 + first = seed_from_imports() 141 141 + second = seed_from_imports() 142 142 + 143 143 + assert first["embeddings_saved"] == 3 144 144 + assert second["embeddings_saved"] == 0 145 145 + assert second["embeddings_skipped_duplicate"] == 3 146 146 + 147 147 + 148 148 + def test_seed_from_imports_unmatched_speaker(speakers_env, monkeypatch): 149 149 + env = speakers_env() 150 150 + embeddings = np.vstack([_normalized_vector(i) for i in range(2)]).astype(np.float32) 151 151 + env.create_import_segment( 152 152 + "20240101", 153 153 + "120000_300", 154 154 + [("Unknown Person", "Hello")] * 2, 155 155 + embeddings=embeddings, 156 156 + ) 157 157 + _mock_owner(monkeypatch, _normalized_vector(55), threshold=0.99) 158 158 + 159 159 + result = seed_from_imports() 160 160 + 161 161 + assert result["embeddings_saved"] == 0 162 162 + assert result["speakers_unmatched"] == ["Unknown Person"] 163 163 + 164 164 + 165 165 + def test_seed_from_imports_ai_chat_skip(speakers_env, monkeypatch): 166 166 + env = speakers_env() 167 167 + env.create_entity("Alice Test") 168 168 + embeddings = np.vstack([_normalized_vector(i) for i in range(2)]).astype(np.float32) 169 169 + env.create_import_segment( 170 170 + "20240101", 171 171 + "120000_300", 172 172 + [("Alice Test", "Hello")] * 2, 173 173 + stream="import.chatgpt", 174 174 + embeddings=embeddings, 175 175 + ) 176 176 + _mock_owner(monkeypatch, _normalized_vector(44), threshold=0.99) 177 177 + 178 178 + result = seed_from_imports() 179 179 + 180 180 + assert result["segments_scanned"] == 0 181 181 + assert result["segments_with_speakers"] == 0 182 182 + assert result["embeddings_saved"] == 0 183 183 + 184 184 + 185 185 + def test_seed_from_imports_empty_speaker(speakers_env, monkeypatch): 186 186 + env = speakers_env() 187 187 + env.create_entity("Alice Test") 188 188 + embeddings = np.vstack([_normalized_vector(i) for i in range(3)]).astype(np.float32) 189 189 + env.create_import_segment( 190 190 + "20240101", 191 191 + "120000_300", 192 192 + [("", "skip one"), ("", "skip two"), ("Alice Test", "keep this")], 193 193 + embeddings=embeddings, 194 194 + ) 195 195 + _mock_owner(monkeypatch, _normalized_vector(33), threshold=0.99) 196 196 + 197 197 + result = seed_from_imports() 198 198 + 199 199 + assert result["embeddings_saved"] == 1 200 200 + assert result["speakers_found"] == {"Alice Test": 1} 201 201 + 202 202 + 203 203 + def test_link_import_cli_json_success(speakers_env): 204 204 + env = speakers_env() 205 205 + env.create_entity("Alice Test") 206 206 + 207 207 + result = _runner.invoke( 208 208 + speakers_app, 209 209 + ["link-import", "Alice Imported", "--entity-id", "alice_test"], 210 210 + ) 211 211 + 212 212 + assert result.exit_code == 0 213 213 + data = json.loads(result.output) 214 214 + assert data["linked"] is True 215 215 + assert data["entity_id"] == "alice_test" 216 216 + 217 217 + 218 218 + def test_seed_from_imports_cli_json_success(speakers_env, monkeypatch): 219 219 + env = speakers_env() 220 220 + env.create_entity("Alice Test") 221 221 + embeddings = np.vstack([_normalized_vector(i) for i in range(2)]).astype(np.float32) 222 222 + env.create_import_segment( 223 223 + "20240101", 224 224 + "120000_300", 225 225 + [("Alice Test", "Hello")] * 2, 226 226 + embeddings=embeddings, 227 227 + ) 228 228 + _mock_owner(monkeypatch, _normalized_vector(22), threshold=0.99) 229 229 + 230 230 + result = _runner.invoke(speakers_app, ["seed-from-imports", "--json"]) 231 231 + 232 232 + assert result.exit_code == 0 233 233 + data = json.loads(result.output) 234 234 + assert data["embeddings_saved"] == 2