lore-ai 0.1.2__py3-none-any.whl

audio/normalise.py

@@ -0,0 +1,45 @@
+import subprocess
+from pathlib import Path
+import imageio_ffmpeg
+
+
+class AudioNormaliseError(Exception):
+    """Raised when audio normalization fails."""
+
+    pass
+
+
+def normalise(input_path: Path, output_path: Path) -> None:
+    """
+    Normalise audio to 16kHz mono PCM with EBU R128 loudness normalisation.
+    This is required for optimal faster-whisper transcription of archival audio.
+    """
+    ffmpeg_exe = imageio_ffmpeg.get_ffmpeg_exe()
+
+    cmd = [
+        ffmpeg_exe,
+        "-y",  # Overwrite output files
+        "-i",
+        str(input_path),
+        "-af",
+        "loudnorm",  # EBU R128 loudness normalization
+        "-ar",
+        "16000",  # 16 kHz sample rate
+        "-ac",
+        "1",  # Mono (1 channel)
+        "-acodec",
+        "pcm_s16le",  # 16-bit PCM
+        str(output_path),
+    ]
+
+    try:
+        # Run ffmpeg subprocess, capturing output for error reporting
+        subprocess.run(
+            cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+        )
+    except subprocess.CalledProcessError as e:
+        raise AudioNormaliseError(
+            f"FFmpeg failed with exit code {e.returncode}:\n{e.stderr}"
+        )
+    except Exception as e:
+        raise AudioNormaliseError(f"Failed to execute FFmpeg: {str(e)}")

audio/player.py

@@ -0,0 +1,49 @@
+from PyQt6.QtCore import QObject, pyqtSignal, QUrl
+from PyQt6.QtMultimedia import QMediaPlayer, QAudioOutput
+
+
+class AudioPlayer(QObject):
+    """
+    AudioPlayer wraps QMediaPlayer to provide precise playback control
+    and frequent position updates for UI syncing.
+    """
+
+    position_changed = pyqtSignal(int)
+    duration_changed = pyqtSignal(int)
+    state_changed = pyqtSignal(QMediaPlayer.PlaybackState)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._player = QMediaPlayer(self)
+        self._audio_output = QAudioOutput(self)
+        self._player.setAudioOutput(self._audio_output)
+
+        # Fire position_changed every 50ms for tight waveform/transcript sync
+        self._player.positionChanged.connect(self.position_changed.emit)
+        self._player.durationChanged.connect(self.duration_changed.emit)
+        self._player.playbackStateChanged.connect(self.state_changed.emit)
+
+        # In PyQt6, notify interval can be set via QTimer, but QMediaPlayer handles it intrinsically or via positionChanged
+        # Actually QMediaPlayer in Qt6 emits positionChanged rapidly during playback.
+
+    def load(self, file_path: str):
+        self._player.setSource(QUrl.fromLocalFile(file_path))
+
+    def play(self):
+        self._player.play()
+
+    def pause(self):
+        self._player.pause()
+
+    def seek(self, ms: int):
+        self._player.setPosition(ms)
+
+    def position_ms(self) -> int:
+        return self._player.position()
+
+    def duration_ms(self) -> int:
+        return self._player.duration()
+
+    def set_volume(self, volume: float):
+        """Volume between 0.0 and 1.0"""
+        self._audio_output.setVolume(volume)

lore_ai-0.1.2.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: lore-ai
+Version: 0.1.2
+Summary: Privacy-first, local-only oral history transcription.
+Author: Digital Heritage Lab
+License: MIT
+Project-URL: Homepage, https://github.com/mabo-du/lore
+Project-URL: Documentation, https://github.com/mabo-du/lore/blob/main/USER_GUIDE.md
+Project-URL: Repository, https://github.com/mabo-du/lore.git
+Project-URL: Issue Tracker, https://github.com/mabo-du/lore/issues
+Keywords: oral-history,transcription,whisper,archival,offline
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: faster-whisper
+Requires-Dist: PyQt6
+Requires-Dist: imageio-ffmpeg
+Requires-Dist: platformdirs
+Requires-Dist: lxml
+Requires-Dist: numpy
+Requires-Dist: tsdownsample
+Requires-Dist: pyannote-audio==3.3.2
+Requires-Dist: resemblyzer>=0.1.4
+Requires-Dist: gliner2-onnx>=0.1.1
+Requires-Dist: llama-cpp-python>=0.3.25
+Requires-Dist: sqlite-vec>=0.1.9
+Requires-Dist: fastembed>=0.8.0
+Requires-Dist: cryptography>=42.0
+Provides-Extra: diarization
+Requires-Dist: pyannote-audio; extra == "diarization"
+Requires-Dist: Resemblyzer; extra == "diarization"
+Dynamic: license-file
+
+<div align="center">
+  <img src="https://img.shields.io/badge/Local_First-100%25-brightgreen.svg?style=for-the-badge" alt="Local First">
+  <img src="https://img.shields.io/badge/Python-3.12+-blue.svg?style=for-the-badge&logo=python" alt="Python 3.12+">
+  <img src="https://img.shields.io/badge/PyQt6-UI-blueviolet.svg?style=for-the-badge" alt="PyQt6">
+  <img src="https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge" alt="MIT License">
+  <img src="https://img.shields.io/github/actions/workflow/status/mabo-du/lore/ci.yml?branch=main&style=for-the-badge" alt="CI">
+  <img src="https://img.shields.io/pypi/v/lore-ai.svg?style=for-the-badge" alt="PyPI">
+
+  <h1>Lore 🎙️</h1>
+
+  <p><strong>Privacy-First, Local-Only Oral History Transcription & Archiving</strong></p>
+</div>
+
+---
+
+**Lore** is a desktop application designed for historians, archivists, and researchers. It provides state-of-the-art AI transcription, speaker diarization, named entity recognition, and translation—**100% offline, on your own hardware.**
+
+No data leaves your computer. No cloud subscriptions. Just powerful, open-source AI packaged into a clean, intuitive PyQt6 interface.
+
+<img src="https://raw.githubusercontent.com/mabo-du/lore/main/docs/images/lore_main.png" alt="Lore Main Window" width="800">
+
+## ✨ Features
+
+- 🎧 **Offline Transcription:** Powered by `faster-whisper`, optimized for CPU inference with low memory overhead (< 8GB RAM).
+- 🗣️ **Speaker Diarization:** Automatically identifies and labels different speakers using `pyannote.audio`.
+- 🔍 **Word-Level Confidence:** Low-confidence words are visually highlighted so you can quickly spot potential hallucinations.
+- 🌍 **Local Translation:** Translate transcripts to over 200 languages completely offline using Meta's `NLLB-200` model.
+- 📖 **Custom Vocabulary:** Provide local jargon, proper nouns, and historical terms to guide Whisper's decoding graph for maximum accuracy.
+- 🏷️ **Named Entity Recognition:** Uses `GLiNER` to automatically extract people, organizations, dates, and locations.
+- 📦 **Archival Exporting:** Export your work to the **OHMS XML** format or create an **RFC 8493 BagIt** archival package with SHA-256 checksum verification.
+- 🔎 **Global Archive Search:** A unified SQLite database (`FTS5` + `sqlite-vec`) lets you instantly search across all your past projects using keyword or semantic/conceptual search.
+
+## 🚀 Installation
+
+### Option 1: Pre-built Installers (Recommended)
+
+Download the installer for your platform from the [latest release](https://github.com/mabo-du/lore/releases/latest):
+
+| Platform | Installer |
+|----------|-----------|
+| 🪟 **Windows** | `lore-windows-x86_64.zip` — Extract and run `lore.exe` |
+| 🍎 **macOS** | `lore-macos-arm64.tar.gz` — Extract and run `lore` |
+| 🐧 **Linux** | `lore-linux-x86_64.tar.gz` — Extract and run `lore` |
+
+### Option 2: Install from PyPI
+
+```bash
+pip install lore-ai
+lore
+```
+
+### Option 3: Install from Source
+
+Lore requires **Python 3.12+** and is cross-platform (Windows, macOS, Linux).
+
+1. **Clone the repository:**
+   ```bash
+   git clone https://github.com/mabo-du/lore.git
+   cd lore
+   ```
+
+2. **Set up a virtual environment:**
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   ```
+
+3. **Install the application:**
+   ```bash
+   pip install -e .
+   ```
+
+## 🎮 Usage
+
+Start the Lore application:
+
+```bash
+lore
+```
+
+Or launch from your system's application menu if installed via the pre-built installer.
+
+1. **Select an Audio File:** Click "Browse" to select any standard audio format (WAV, MP3, M4A, OGG, FLAC).
+2. **Configure Settings:** Click the ⚙️ Settings icon to set your Custom Vocabulary and speaker diarization preferences.
+
+   <img src="https://raw.githubusercontent.com/mabo-du/lore/main/docs/images/lore_settings.png" alt="Lore Settings" width="400">
+
+3. **Transcribe & Diarize:** Click "Transcribe" on the toolbar. If recording has multiple speakers, check the "Enable Speaker Diarization" box.
+4. **Edit & Review:** Play the audio, click on segments to edit them, and review any low-confidence words highlighted in red.
+5. **Translate:** Select a target language from the dropdown and click "Translate" for fully offline translation.
+6. **Export:** Fill out the Metadata panel and export to **OHMS XML** or an Archival **BagIt Package**.
+
+For detailed instructions, see the [User Guide](USER_GUIDE.md).
+
+## 🏗️ Architecture
+
+Lore is designed with strict sequential memory management to run on older hardware.
+- Models are loaded into memory one at a time (e.g., Whisper loads, transcribes, unloads → NLLB loads, translates, unloads).
+- Heavy use of CTranslate2 (INT8 quantization) ensures models run blazingly fast without needing a dedicated GPU.
+- The UI runs asynchronously using PyQt6's `QThread` and Signals, keeping the interface completely responsive during heavy AI workloads.
+
+## 🤝 Contributing
+
+Lore is an open-source project. We welcome pull requests, bug reports, and feature requests. Please see our [User Guide](USER_GUIDE.md) for more detailed workflows and documentation on the codebase.
+
+## 📜 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

lore_ai-0.1.2.dist-info/RECORD

@@ -0,0 +1,34 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+main.py,sha256=spCRCxWGemZ_-HEevm_YsaK4HzX6tGdxTxI_mwbptfI,498
+audio/normalise.py,sha256=9cAraDZLmtZLRK2k8EWqa8l5fBijW0gVNLSJJuFykR0,1283
+audio/player.py,sha256=UI5wJ3GBJMcxBk46HBXxBUqjUjLk1KRewuCH5LGxbsM,1684
+lore_ai-0.1.2.dist-info/licenses/LICENSE,sha256=w-C0_pWcTlDR35tDQTYslatZ-F98zvvXBbTIRhUEjF8,1074
+lore_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lore_core/audio_classifier.py,sha256=JYbQoiixuCFxHp3qi1KkIRgcJmDFpI4jfd13dqyApTs,4518
+lore_core/bagit_exporter.py,sha256=fTTj1v6dsYhIaBzQZBeWAzYEqNBdP20iZkgbVtWSz04,3283
+lore_core/diarization.py,sha256=dqV7Up3IrNmULR3-e2JhKijvMex2_6MO-3aohECmktM,4881
+lore_core/engine.py,sha256=6ORbGtPJ-G9-uak3w4gQikqLmHcfpDdU3ogmqmoh6PM,2376
+lore_core/global_search.py,sha256=qqgBvVaIutHcQ1uC1fXNywxLqNaR1WXaQwpTQDecHo0,7056
+lore_core/languages.py,sha256=-fybKmEuCIQxxuZvdC-0aq_D7JFrAIdN3gQNkjgS99w,1319
+lore_core/llm_worker.py,sha256=aKmi1ad5Ivqrc45XB0FuH4LMyyleJkHaJBOfnAgvdo8,3215
+lore_core/ner_worker.py,sha256=h-p4oC1o3xaIY-D__2eaSJ_euSwZBKrs49mKmV4Eod8,2730
+lore_core/ohms_exporter.py,sha256=_G_CYfzILsDybggyO84WN7_VsginSSqNL8McyuiGHQ0,6024
+lore_core/rag_worker.py,sha256=j4hO0SsMKW6-Y7B1sV6VlvF9kJnHZK1hFncbBJ7_hgE,3123
+lore_core/taxonomy_manager.py,sha256=bbp90orKk-hieqn-7LhFRhqOKBtJimLMZ-e0-9tvizE,5143
+lore_core/translation_worker.py,sha256=DQpd11BcXAYkrd4tygYaXV9OHMbLOpHGBnD2T6nyP-U,3970
+lore_core/exporters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+transcription/worker.py,sha256=eQ7aKjwwnvgfm1mx9NzTiurbok4FVYyvkP6Wv_k62e0,3475
+ui/file_picker.py,sha256=39JwM4_jyqOMt5uf6j5pweR2vrG87FENxq7FmWleLd4,3387
+ui/global_search_dialog.py,sha256=jFZ_4UXS9D41I0R56mKzm8rhRAGZox22RGa9y4ErAck,5246
+ui/main_window.py,sha256=hFxHoE0_0_wMNfcXBm-XJ9a9tv8EcogmxeQUysd88l8,18115
+ui/metadata_widget.py,sha256=EzO-2uDlleDRrEBf_hrsViM0kLLsDEm8Lrgis04lqiI,4714
+ui/settings_dialog.py,sha256=5hs4SF1VB43W-PQ7xsr_6XhON9VkOcIJhkn9096vSmc,4629
+ui/transcript_widget.py,sha256=dsIDhj-xxNPad2rv_N1TDjjjnyRk0Owvva3Xkg2oAKg,8526
+ui/waveform_widget.py,sha256=yvCBl1v0_G5nKgwKoYoVX7AzT-dabIOn5Nt8GbBG0UU,5014
+utils/model_manager.py,sha256=c2V-8KjxPOqbVz9E_LuVUiBPHjtbZZyAfokzApB8sWY,4209
+utils/token_vault.py,sha256=9jEvmY0jPDVyc7qgJVT1epnuhrKMoYC0UoOEqFbaX48,1692
+lore_ai-0.1.2.dist-info/METADATA,sha256=sqO3Lvp3M8_6AGuCJq4WnQE778uFuvx3Xx7mRNEmIqg,6916
+lore_ai-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lore_ai-0.1.2.dist-info/entry_points.txt,sha256=Dmpa-951VDrnOQeHc2KGQKYzUA6CiTH5AFlJmWgEicw,39
+lore_ai-0.1.2.dist-info/top_level.txt,sha256=uPjWM9Tov2ewh98GMSFo8VsaW2nCSYvYkCzgBOk3_iw,53
+lore_ai-0.1.2.dist-info/RECORD,,

lore_ai-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lore_ai-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lore = src.main:main

lore_ai-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lore Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lore_ai-0.1.2.dist-info/top_level.txt

@@ -0,0 +1,7 @@
+__init__
+audio
+lore_core
+main
+transcription
+ui
+utils

lore_core/audio_classifier.py

@@ -0,0 +1,126 @@
+from pathlib import Path
+import wave
+import numpy as np
+import onnxruntime as ort
+from PyQt6.QtCore import QThread, pyqtSignal
+
+from models.transcript import Segment
+from utils.model_manager import ModelManager
+
+
+class AudioClassifyWorker(QThread):
+    """
+    Runs YAMNet Audio Classification in a background thread to detect Non-Verbal events.
+    Emits events like [Laughter] and [Crying].
+    """
+
+    event_detected = pyqtSignal(Segment)
+    finished = pyqtSignal()
+    error = pyqtSignal(str)
+
+    def __init__(self, audio_path: Path, parent=None):
+        super().__init__(parent)
+        self.audio_path = audio_path
+        # We only care about laughter and crying indices
+        self.target_indices = {
+            13: "Laughter",
+            14: "Laughter",
+            17: "Laughter",
+            19: "Crying",
+            20: "Crying",
+        }
+        self.threshold = 0.35  # Confidence threshold
+
+    def run(self):
+        try:
+            model_path_str = ModelManager.ensure_model("YAMNet")
+            onnx_file = Path(model_path_str) / "yamnet.onnx"
+
+            # CPU only
+            session = ort.InferenceSession(
+                str(onnx_file), providers=["CPUExecutionProvider"]
+            )
+            input_name = session.get_inputs()[0].name
+
+            # Read 16kHz Mono PCM Audio
+            with wave.open(str(self.audio_path), "rb") as wf:
+                framerate = wf.getframerate()
+                if framerate != 16000:
+                    raise ValueError(f"YAMNet requires 16000Hz, got {framerate}Hz")
+                if wf.getnchannels() != 1:
+                    raise ValueError("YAMNet requires Mono audio")
+
+                n_frames = wf.getnframes()
+                audio_data = wf.readframes(n_frames)
+
+            # Convert to float32 [-1.0, 1.0]
+            audio_np = (
+                np.frombuffer(audio_data, dtype=np.int16).astype(np.float32) / 32768.0
+            )
+
+            # YAMNet can process arbitrary length 1D array
+            outputs = session.run(None, {input_name: audio_np})
+            scores = outputs[0]  # Shape (N, 521)
+
+            # Each frame in YAMNet is roughly 0.48s hop size
+            hop_size_s = 0.48
+
+            # Process frames and merge contiguous events of the same type
+            current_event = None
+            current_start_s = 0.0
+
+            for frame_idx, frame_scores in enumerate(scores):
+                frame_time_s = frame_idx * hop_size_s
+
+                # Find the target class with the highest score above threshold
+                best_class = None
+                best_score = 0.0
+                for idx, label in self.target_indices.items():
+                    if (
+                        frame_scores[idx] > self.threshold
+                        and frame_scores[idx] > best_score
+                    ):
+                        best_score = frame_scores[idx]
+                        best_class = label
+
+                if best_class:
+                    if current_event == best_class:
+                        # Continue event
+                        pass
+                    else:
+                        # Close previous event if exists
+                        if current_event:
+                            self._emit_event(
+                                current_event, current_start_s, frame_time_s
+                            )
+                        # Start new event
+                        current_event = best_class
+                        current_start_s = frame_time_s
+                else:
+                    if current_event:
+                        # Close previous event
+                        self._emit_event(current_event, current_start_s, frame_time_s)
+                        current_event = None
+
+            # Close hanging event
+            if current_event:
+                self._emit_event(
+                    current_event, current_start_s, (len(scores)) * hop_size_s
+                )
+
+            self.finished.emit()
+
+        except Exception as e:
+            self.error.emit(str(e))
+
+    def _emit_event(self, event_label: str, start_s: float, end_s: float):
+        # Only emit events that last at least 0.5s to avoid spurious noise
+        duration = end_s - start_s
+        if duration >= 0.48:
+            segment = Segment(
+                start_ms=int(start_s * 1000),
+                end_ms=int(end_s * 1000),
+                text=f"[{event_label}]",
+                speaker_label="SYSTEM",
+            )
+            self.event_detected.emit(segment)

lore_core/bagit_exporter.py

@@ -0,0 +1,88 @@
+import shutil
+import hashlib
+from pathlib import Path
+from datetime import datetime
+from models.transcript import Transcript
+from lore_core.ohms_exporter import OhmsExporter
+
+
+class BagItPackager:
+    """
+    Creates a BagIt (RFC 8493) compliant package for the transcript and audio.
+    """
+
+    def __init__(self):
+        self.version = "1.0"
+        self.encoding = "UTF-8"
+
+    def _hash_file(self, file_path: Path) -> str:
+        """Calculate SHA-256 hash of a file."""
+        hasher = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                hasher.update(chunk)
+        return hasher.hexdigest()
+
+    def create_bag(
+        self,
+        audio_path: Path,
+        transcript: Transcript,
+        output_dir: Path,
+        project_id: str,
+    ):
+        """
+        Generates a BagIt structure at output_dir.
+        """
+        output_dir = Path(output_dir)
+        bag_dir = output_dir / f"lore_bag_{project_id}"
+
+        # Ensure we start clean
+        if bag_dir.exists():
+            shutil.rmtree(bag_dir)
+
+        bag_dir.mkdir(parents=True)
+        data_dir = bag_dir / "data"
+        data_dir.mkdir()
+
+        # 1. Copy audio payload
+        bag_audio_path = data_dir / audio_path.name
+        shutil.copy2(audio_path, bag_audio_path)
+
+        # 2. Export OHMS XML payload
+        bag_xml_path = data_dir / "transcript.xml"
+        OhmsExporter.export(transcript, {"title": project_id}, bag_xml_path)
+
+        # 3. Create bagit.txt
+        with open(bag_dir / "bagit.txt", "w", encoding="utf-8") as f:
+            f.write(f"BagIt-Version: {self.version}\n")
+            f.write(f"Tag-File-Character-Encoding: {self.encoding}\n")
+
+        # 4. Create bag-info.txt
+        with open(bag_dir / "bag-info.txt", "w", encoding="utf-8") as f:
+            f.write("Source-Organization: Lore Oral History App\n")
+            f.write(f"Bagging-Date: {datetime.now().strftime('%Y-%m-%d')}\n")
+            f.write(f"External-Identifier: {project_id}\n")
+            # Calculate total payload size and oxum
+            audio_size = bag_audio_path.stat().st_size
+            xml_size = bag_xml_path.stat().st_size
+            total_size = audio_size + xml_size
+            f.write(f"Payload-Oxum: {total_size}.2\n")
+            f.write(f"Bag-Size: {total_size / (1024 * 1024):.2f} MB\n")
+
+        # 5. Create payload manifest (manifest-sha256.txt)
+        with open(bag_dir / "manifest-sha256.txt", "w", encoding="utf-8") as f:
+            audio_hash = self._hash_file(bag_audio_path)
+            xml_hash = self._hash_file(bag_xml_path)
+            f.write(f"{audio_hash} data/{bag_audio_path.name}\n")
+            f.write(f"{xml_hash} data/transcript.xml\n")
+
+        # 6. Create tag manifest (tagmanifest-sha256.txt)
+        with open(bag_dir / "tagmanifest-sha256.txt", "w", encoding="utf-8") as f:
+            bagit_hash = self._hash_file(bag_dir / "bagit.txt")
+            baginfo_hash = self._hash_file(bag_dir / "bag-info.txt")
+            manifest_hash = self._hash_file(bag_dir / "manifest-sha256.txt")
+            f.write(f"{bagit_hash} bagit.txt\n")
+            f.write(f"{baginfo_hash} bag-info.txt\n")
+            f.write(f"{manifest_hash} manifest-sha256.txt\n")
+
+        return bag_dir

lore_core/diarization.py

@@ -0,0 +1,130 @@
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+# We import these inside the functions to avoid massive load times or crashes if missing
+
+
+class DiarizationEngine:
+    def __init__(self, use_pyannote: bool = False, hf_token: Optional[str] = None):
+        self.use_pyannote = use_pyannote
+        self.hf_token = hf_token
+
+    def run_diarization(self, audio_path: Path) -> List[Tuple[float, float, str]]:
+        """
+        Runs diarization on the given audio file.
+        Returns a list of (start_s, end_s, speaker_label) tuples.
+        """
+        if self.use_pyannote:
+            return self._run_pyannote(audio_path)
+        else:
+            return self._run_resemblyzer(audio_path)
+
+    def _run_pyannote(self, audio_path: Path) -> List[Tuple[float, float, str]]:
+        if not self.hf_token:
+            raise ValueError("HuggingFace token is required for Pyannote.")
+
+        import torch
+        from pyannote.audio import Pipeline
+
+        # Initialize pipeline (loads from HuggingFace cache or downloads if missing)
+        pipeline = Pipeline.from_pretrained(
+            "pyannote/speaker-diarization-3.1", use_auth_token=self.hf_token
+        )
+
+        if pipeline is None:
+            raise RuntimeError(
+                "Failed to load Pyannote pipeline. Check your token and license acceptance."
+            )
+
+        # Send to CPU (or GPU if available, but we'll stick to CPU for reliability)
+        pipeline.to(torch.device("cpu"))
+
+        diarization = pipeline(str(audio_path))
+
+        results = []
+        for turn, _, speaker in diarization.itertracks(yield_label=True):
+            results.append((turn.start, turn.end, speaker))
+
+        return results
+
+    def _run_resemblyzer(self, audio_path: Path) -> List[Tuple[float, float, str]]:
+        """
+        Lightweight, ungated fallback using Resemblyzer.
+        Since Resemblyzer is just an embedding extractor, we cluster the embeddings manually.
+        """
+        from resemblyzer import VoiceEncoder, preprocess_wav
+        from sklearn.cluster import KMeans
+
+        encoder = VoiceEncoder("cpu")
+        wav = preprocess_wav(str(audio_path))
+
+        # Extract embeddings using a sliding window.
+        _, cont_embeds, wav_splits = encoder.embed_utterance(
+            wav, return_partials=True, rate=16
+        )
+
+        if len(cont_embeds) == 0:
+            return [(0.0, len(wav) / 16000.0, "SPEAKER_00")]
+
+        # We assume 2 speakers for oral history by default in Resemblyzer fallback
+        clusterer = KMeans(n_clusters=2, n_init=10, random_state=42)
+        labels = clusterer.fit_predict(cont_embeds)
+
+        # Guard against length mismatch between embeddings and wav_splits
+        if len(cont_embeds) != len(wav_splits):
+            return [(0.0, len(wav) / 16000.0, "SPEAKER_00")]
+
+        results = []
+        # Reconstruct timestamps based on wav_splits which are in samples
+        sample_rate = 16000
+        for (split, label) in zip(wav_splits, labels):
+            start_s = split.start / sample_rate
+            end_s = split.stop / sample_rate
+            speaker = f"SPEAKER_{label:02d}"
+
+            # Merge contiguous segments with same speaker
+            if (
+                results
+                and results[-1][2] == speaker
+                and (start_s - results[-1][1] < 0.5)
+            ):
+                results[-1] = (results[-1][0], end_s, speaker)
+            else:
+                results.append((start_s, end_s, speaker))
+
+        return results
+
+    @staticmethod
+    def align_speakers_to_segments(
+        segments: List["Segment"],  # noqa: F821
+        diarization_results: List[Tuple[float, float, str]],
+    ) -> None:
+        """
+        Aligns coarse speaker turns to fine-grained ASR segments.
+        Modifies the 'speaker_label' property of the provided Segments in place.
+        """
+        if not diarization_results:
+            return
+
+        for seg in segments:
+            seg_mid = (seg.start_ms + seg.end_ms) / 2000.0  # Midpoint in seconds
+
+            # Find which diarization segment contains this midpoint
+            assigned_speaker = None
+            for d_start, d_end, speaker in diarization_results:
+                if d_start <= seg_mid <= d_end:
+                    assigned_speaker = speaker
+                    break
+
+            # If the midpoint falls in a gap, find the closest segment
+            if not assigned_speaker:
+                closest_speaker = None
+                min_dist = float("inf")
+                for d_start, d_end, speaker in diarization_results:
+                    dist = min(abs(d_start - seg_mid), abs(d_end - seg_mid))
+                    if dist < min_dist:
+                        min_dist = dist
+                        closest_speaker = speaker
+                assigned_speaker = closest_speaker
+
+            seg.speaker_label = assigned_speaker