Anchor-annotator 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

{Anchor_annotator-0.7.0.dist-info → Anchor_annotator-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Anchor_annotator
-Version: 0.7.0
+Version: 0.8.0
 Summary: Anchor annotator is a program for inspecting corpora for the Montreal Forced Aligner and correcting transcriptions and pronunciations.
 Home-page: https://github.com/MontrealCorpusTools/Anchor-annotator
 Author: Montreal Corpus Tools

Anchor_annotator-0.8.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+anchor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anchor/__main__.py,sha256=5ufG8lcx2x1am-04xI991AG7saJd24dxPw5JzjmB878,45
+anchor/_version.py,sha256=vspFLRfYI6gAAN7kyihey2lhPos0jxqKaNDWFlKPlmU,411
+anchor/command_line.py,sha256=EucG805HyWk_zkMO9RXv9Yj0I0JVdDLZb1_DX2_ISjM,503
+anchor/db.py,sha256=LlZzAy4bjmJIu0v4ev5Qjg_Fh2n9sMsKI2nAY1pwd0A,5057
+anchor/main.py,sha256=3CN6wlIzdWjGxsYRSIIuqB2jQZPUdLX9PlQSRMSQ5aI,134355
+anchor/models.py,sha256=0-CRXwRlLnFNelj0pbhfVTLTXAxfj1eJvJ8qEQAGrn4,98864
+anchor/plot.py,sha256=KCSXgyAT5v2BpsX6MvPJuaq5aphTzfYvZ69jLzvcM0k,117879
+anchor/resources_rc.py,sha256=5eFkwVBdDzfc6rkcC-HSzy8EYDmxiMXnYucgAoGVGsA,3599114
+anchor/settings.py,sha256=H8RBeB-MhjE7adrwUcxOTZv2pPkMfgaIwCdxb8f012Q,52396
+anchor/ui_corpus_manager.py,sha256=e3ybOd4UdYarrLBATxI8vIFnioa4R_BHrbsEz5mJ5eA,8564
+anchor/ui_error_dialog.py,sha256=HKbjGT_jtdb9jfn9THQMbl1fmcdWyjYDazM4hCwZ5Yo,3931
+anchor/ui_main_window.py,sha256=qPHaJWMd4k6nVIelcBRqNcATBuMbkv4j2kOpggG4DoY,40191
+anchor/ui_preferences.py,sha256=_1U67al_FoTjVizcK1He4JKBEqfmh3KxUo0UEB7kt5Q,43822
+anchor/undo.py,sha256=fDy8PA2Rckd9_dsa_lM_ohvQJS-l-VdQwB_P0i-Kvbw,33098
+anchor/widgets.py,sha256=6opesi2nGs4_hv8NWdha3e2kUW9hlRAzbo-6gcMdMG0,159347
+anchor/workers.py,sha256=T81tr2wgQh5oLOXZteGfccgvSwXJrJbk3SSmTLHdnmA,191386
+Anchor_annotator-0.8.0.dist-info/LICENSE,sha256=C0oIsblENEgWQ7XMNdYoXyXsIA5wa3YF0I9lK3H7A1s,1076
+Anchor_annotator-0.8.0.dist-info/METADATA,sha256=FWSJbc9J1GcvsZF9hTHTnRTtLH_Alv5rbTwmXtPr3Gg,1500
+Anchor_annotator-0.8.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+Anchor_annotator-0.8.0.dist-info/top_level.txt,sha256=wX6ZKxImGRZKFQjs3f6XYw_TfbAp6Xs3SmbLfLbFAJ0,7
+Anchor_annotator-0.8.0.dist-info/RECORD,,

{Anchor_annotator-0.7.0.dist-info → Anchor_annotator-0.8.0.dist-info}/WHEEL

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

anchor/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.7.0'
-__version_tuple__ = version_tuple = (0, 7, 0)
+__version__ = version = '0.8.0'
+__version_tuple__ = version_tuple = (0, 8, 0)

anchor/main.py

@@ -13,7 +13,7 @@ from montreal_forced_aligner import config
 from montreal_forced_aligner.command_line.utils import check_databases
 from montreal_forced_aligner.config import MfaConfiguration, get_temporary_directory
 from montreal_forced_aligner.corpus import AcousticCorpus
-from montreal_forced_aligner.data import WorkflowType
+from montreal_forced_aligner.data import Language, WorkflowType
 from montreal_forced_aligner.db import CorpusWorkflow
 from montreal_forced_aligner.diarization.speaker_diarizer import FOUND_SPEECHBRAIN
 from montreal_forced_aligner.exceptions import DatabaseError
@@ -24,7 +24,9 @@ from montreal_forced_aligner.models import (
     LanguageModel,
     ModelManager,
 )
+from montreal_forced_aligner.transcription.models import FOUND_WHISPERX
 from montreal_forced_aligner.utils import DatasetType, inspect_database
+from montreal_forced_aligner.vad.models import MfaVAD
 from PySide6 import QtCore, QtGui, QtMultimedia, QtWidgets
 
 import anchor.db
@@ -246,11 +248,23 @@ class MainWindow(QtWidgets.QMainWindow):
         self.alignment_utterance_worker.signals.result.connect(self.finalize_utterance_alignment)
         self.workers.append(self.alignment_utterance_worker)
 
+        self.transcribe_utterance_worker = workers.TranscribeUtteranceWorker(self)
+        self.transcribe_utterance_worker.signals.error.connect(self.handle_error)
+        self.transcribe_utterance_worker.signals.result.connect(
+            self.finalize_utterance_transcription
+        )
+        self.workers.append(self.transcribe_utterance_worker)
+
         self.segment_utterance_worker = workers.SegmentUtteranceWorker(self)
         self.segment_utterance_worker.signals.error.connect(self.handle_error)
         self.segment_utterance_worker.signals.result.connect(self.finalize_segmentation)
         self.workers.append(self.segment_utterance_worker)
 
+        self.trim_utterance_worker = workers.TrimUtteranceWorker(self)
+        self.trim_utterance_worker.signals.error.connect(self.handle_error)
+        self.trim_utterance_worker.signals.result.connect(self.finalize_trimming)
+        self.workers.append(self.trim_utterance_worker)
+
         self.alignment_evaluation_worker = workers.AlignmentEvaluationWorker(self)
         self.alignment_evaluation_worker.signals.error.connect(self.handle_error)
         self.alignment_evaluation_worker.signals.finished.connect(self.finalize_adding_intervals)
@@ -270,6 +284,11 @@ class MainWindow(QtWidgets.QMainWindow):
         self.corpus_undo_stack = QtGui.QUndoStack(self)
         self.dictionary_undo_stack = QtGui.QUndoStack(self)
 
+        self.g2p_model = None
+        self.acoustic_model = None
+        self.vad_model = None
+        self.language_model = None
+        self.ivector_extractor = None
         self.set_up_models()
         if self.settings.value(AnchorSettings.AUTOLOAD):
             self.load_corpus()
@@ -280,6 +299,7 @@ class MainWindow(QtWidgets.QMainWindow):
         self.load_acoustic_model()
         self.load_language_model()
         self.load_g2p()
+        self.load_vad()
         self.create_actions()
         self.refresh_settings()
 
@@ -557,19 +577,18 @@ class MainWindow(QtWidgets.QMainWindow):
         self.ui.diarizationWidget.set_models(self.diarization_model, self.file_selection_model)
         self.ui.oovWidget.set_models(self.oov_model)
         self.file_selection_model.currentUtteranceChanged.connect(self.change_utterance)
+        self.file_selection_model.currentUtteranceChanged.connect(
+            self.selection_model.set_current_utterance
+        )
         self.selection_model.fileViewRequested.connect(self.file_selection_model.set_current_file)
         self.file_selection_model.fileChanged.connect(self.change_file)
         self.selection_model.fileAboutToChange.connect(self.check_media_stop)
         self.media_player.set_models(self.file_selection_model)
         self.corpus_model.addCommand.connect(self.update_corpus_stack)
+        self.corpus_model.transcribeRequested.connect(self.begin_utterance_transcription)
         self.file_utterances_model.addCommand.connect(self.update_corpus_stack)
         self.file_selection_model.selectionChanged.connect(self.sync_selected_utterances)
 
-        self.g2p_model = None
-        self.acoustic_model = None
-        self.language_model = None
-        self.ivector_extractor = None
-
     def sync_selected_utterances(self):
         self.selection_model.update_selected_utterances(
             self.file_selection_model.selected_utterances()
@@ -706,15 +725,21 @@ class MainWindow(QtWidgets.QMainWindow):
         self.ui.deleteUtterancesAct.setEnabled(False)
         self.ui.splitUtterancesAct.setEnabled(False)
         self.ui.alignUtteranceAct.setEnabled(False)
+        self.ui.transcribeUtteranceAct.setEnabled(False)
+        self.ui.trimUtteranceAct.setEnabled(False)
         self.ui.segmentUtteranceAct.setEnabled(False)
         if not selection and self.selection_model.current_utterance_id is None:
             return
-
         if len(selection) == 1 or self.selection_model.current_utterance_id is not None:
             self.ui.splitUtterancesAct.setEnabled(True)
-            if self.corpus_model.acoustic_model is not None and self.corpus_model.has_dictionary:
-                self.ui.alignUtteranceAct.setEnabled(True)
-                self.ui.segmentUtteranceAct.setEnabled(True)
+            self.ui.trimUtteranceAct.setEnabled(True)
+            if self.corpus_model.acoustic_model is not None:
+                if self.corpus_model.has_dictionary:
+                    self.ui.alignUtteranceAct.setEnabled(True)
+                    self.ui.transcribeUtteranceAct.setEnabled(True)
+                    self.ui.segmentUtteranceAct.setEnabled(True)
+                elif not isinstance(self.acoustic_model, AcousticModel):
+                    self.ui.transcribeUtteranceAct.setEnabled(True)
         if len(selection) > 1:
             self.ui.mergeUtterancesAct.setEnabled(True)
         else:
@@ -801,6 +826,8 @@ class MainWindow(QtWidgets.QMainWindow):
         self.ui.openPreferencesAct.triggered.connect(self.open_options)
         self.ui.openCorpusManagerAct.triggered.connect(self.open_corpus_manager)
         self.ui.loadAcousticModelAct.triggered.connect(self.change_acoustic_model)
+        self.ui.kaldiVadAct.triggered.connect(self.change_vad)
+        self.ui.speechbrainVadAct.triggered.connect(self.change_vad)
         self.ui.loadLanguageModelAct.triggered.connect(self.change_language_model)
         self.ui.loadIvectorExtractorAct.triggered.connect(self.change_ivector_extractor)
         self.ui.loadDictionaryAct.triggered.connect(self.change_dictionary)
@@ -870,6 +897,8 @@ class MainWindow(QtWidgets.QMainWindow):
             self.begin_reset_ivectors
         )
         self.ui.alignUtteranceAct.triggered.connect(self.begin_utterance_alignment)
+        self.ui.transcribeUtteranceAct.triggered.connect(self.begin_utterance_transcription)
+        self.ui.trimUtteranceAct.triggered.connect(self.begin_utterance_trimming)
         self.ui.segmentUtteranceAct.triggered.connect(self.begin_utterance_segmentation)
         self.ui.evaluateAlignmentsAct.triggered.connect(self.begin_alignment_evaluation)
         self.ui.selectMappingFileAct.triggered.connect(self.change_custom_mapping)
@@ -918,6 +947,9 @@ class MainWindow(QtWidgets.QMainWindow):
         self.acoustic_action_group = QtGui.QActionGroup(self)
         self.acoustic_action_group.setExclusive(True)
 
+        self.langauge_action_group = QtGui.QActionGroup(self)
+        self.langauge_action_group.setExclusive(True)
+
         self.g2p_action_group = QtGui.QActionGroup(self)
         self.g2p_action_group.setExclusive(True)
 
@@ -1032,6 +1064,25 @@ class MainWindow(QtWidgets.QMainWindow):
         )
 
     def refresh_model_actions(self):
+        self.ui.menuLanguage.clear()
+        for lang in sorted(Language, key=lambda x: x.display_name):
+            a = QtGui.QAction(lang.display_name, parent=self)
+            a.setCheckable(True)
+            if lang.name == self.settings.value(self.settings.LANGUAGE):
+                a.setChecked(True)
+            self.langauge_action_group.addAction(a)
+            a.triggered.connect(self.change_language)
+            self.ui.menuLanguage.addAction(a)
+        if not FOUND_SPEECHBRAIN:
+            self.ui.speechbrainVadAct.setChecked(False)
+            self.ui.speechbrainVadAct.setEnabled(False)
+            self.settings.setValue(self.settings.VAD_MODEL, "kaldi")
+            self.ui.kaldiVadAct.setChecked(True)
+        else:
+            self.ui.speechbrainVadAct.setEnabled(True)
+            if self.settings.value(self.settings.VAD_MODEL) == "speechbrain":
+                self.ui.speechbrainVadAct.setChecked(True)
+
         self.ui.menuDownload_acoustic_model.clear()
         self.ui.menuDownload_G2P_model.clear()
         self.ui.menuDownload_language_model.clear()
@@ -1168,11 +1219,10 @@ class MainWindow(QtWidgets.QMainWindow):
                     .first()
                 )
                 if m is None:
-                    session.add(
-                        anchor.db.IvectorExtractor(
-                            name="speechbrain", path="speechbrain", available_locally=True
-                        )
+                    m = anchor.db.IvectorExtractor(
+                        name="speechbrain", path="speechbrain", available_locally=True
                     )
+                    session.add(m)
                     session.flush()
                     session.commit()
                 a = QtGui.QAction(text="speechbrain", parent=self)
@@ -1180,6 +1230,24 @@ class MainWindow(QtWidgets.QMainWindow):
                 a.triggered.connect(self.change_ivector_extractor)
                 self.ui.ivectorExtractorMenu.addAction(a)
                 self.ivector_action_group.addAction(a)
+            for m_name, found in [("speechbrain", FOUND_SPEECHBRAIN), ("whisper", FOUND_WHISPERX)]:
+                if not found:
+                    continue
+                m = (
+                    session.query(anchor.db.AcousticModel)
+                    .filter(anchor.db.AcousticModel.path == m_name)
+                    .first()
+                )
+                if m is None:
+                    m = anchor.db.AcousticModel(name=m_name, path=m_name, available_locally=True)
+                    session.add(m)
+                    session.flush()
+                    session.commit()
+                a = QtGui.QAction(text=m_name, parent=self)
+                a.setData(m.id)
+                a.triggered.connect(self.change_acoustic_model)
+                self.ui.acousticModelMenu.addAction(a)
+                self.acoustic_action_group.addAction(a)
 
             for m in (
                 session.query(anchor.db.IvectorExtractor)
@@ -1411,7 +1479,10 @@ class MainWindow(QtWidgets.QMainWindow):
     def begin_alignment(self):
         self.enableMfaActions(False)
         self.alignment_worker.set_params(
-            self.corpus_model.corpus, self.acoustic_model, self.ui.alignmentWidget.parameters()
+            self.corpus_model.corpus,
+            self.acoustic_model,
+            verify_transcripts=False,
+            parameters=self.ui.alignmentWidget.parameters(),
         )
         self.alignment_worker.start()
         self.set_application_state("loading")
@@ -1420,7 +1491,10 @@ class MainWindow(QtWidgets.QMainWindow):
     def begin_verify_transcripts(self):
         self.enableMfaActions(False)
         self.alignment_worker.set_params(
-            self.corpus_model.corpus, self.acoustic_model, self.ui.alignmentWidget.parameters()
+            self.corpus_model.corpus,
+            self.acoustic_model,
+            verify_transcripts=True,
+            parameters=self.ui.alignmentWidget.parameters(),
         )
         self.alignment_worker.start()
         self.set_application_state("loading")
@@ -1475,6 +1549,12 @@ class MainWindow(QtWidgets.QMainWindow):
         self.set_application_state("loading")
         self.ui.loadingScreen.setCorpusName("Performing alignment...")
 
+    def begin_utterance_transcription(self, utterance_id: int = None):
+        if not utterance_id:
+            utterance_id = self.selection_model.current_utterance_id
+        self.transcribe_utterance_worker.set_params(self.corpus_model, utterance_id)
+        self.transcribe_utterance_worker.start()
+
     def begin_utterance_segmentation(self):
         if self.selection_model.current_utterance_id is None:
             return
@@ -1483,6 +1563,14 @@ class MainWindow(QtWidgets.QMainWindow):
         )
         self.segment_utterance_worker.start()
 
+    def begin_utterance_trimming(self):
+        if self.selection_model.current_utterance_id is None:
+            return
+        self.trim_utterance_worker.set_params(
+            self.corpus_model, self.selection_model.current_utterance_id
+        )
+        self.trim_utterance_worker.start()
+
     def begin_alignment_evaluation(self):
         self.enableMfaActions(False)
         with sqlalchemy.orm.Session(self.db_engine) as session:
@@ -1588,11 +1676,23 @@ class MainWindow(QtWidgets.QMainWindow):
         self.check_actions()
         self.set_application_state("loaded")
 
+    def finalize_utterance_transcription(self, data):
+        utterance_id, transcription = data
+
+        utt = self.file_utterances_model.get_utterance(utterance_id)
+        utt.transcription_text = transcription
+        self.file_utterances_model.utterancesReady.emit()
+
     def finalize_segmentation(self, data):
         original_utterance_id, split_data = data
         self.file_utterances_model.split_vad_utterance(original_utterance_id, split_data)
         self.ensure_utterance_panel_visible()
 
+    def finalize_trimming(self, data):
+        original_utterance_id, begin, end = data
+        self.file_utterances_model.update_utterance_times(original_utterance_id, begin, end)
+        self.ui.utteranceDetailWidget.plot_widget.refresh_text_grid()
+
     def finalize_saving(self):
         self.check_actions()
 
@@ -1914,6 +2014,9 @@ class MainWindow(QtWidgets.QMainWindow):
                 self.ui.alignUtteranceAct.setIcon(
                     QtGui.QIcon.fromTheme(QtGui.QIcon.ThemeIcon.FormatTextUnderline)
                 )
+                self.ui.trimUtteranceAct.setIcon(
+                    QtGui.QIcon.fromTheme(QtGui.QIcon.ThemeIcon.FormatTextUnderline)
+                )
                 self.ui.cancelCorpusLoadAct.setIcon(
                     QtGui.QIcon.fromTheme(QtGui.QIcon.ThemeIcon.ProcessStop)
                 )
@@ -1961,6 +2064,31 @@ class MainWindow(QtWidgets.QMainWindow):
         )
         self.download_worker.start()
 
+    def change_language(self):
+        from montreal_forced_aligner.transcription.models import MfaFasterWhisperPipeline
+
+        self.settings.setValue(self.settings.LANGUAGE, self.sender().text().lower())
+        if isinstance(self.acoustic_model, MfaFasterWhisperPipeline):
+            self.acoustic_model.set_language(self.sender().text().lower())
+
+    def change_vad(self):
+        self.settings.setValue(self.settings.VAD_MODEL, self.sender().text().lower())
+        self.load_vad()
+
+    def load_vad(self):
+        if self.settings.value(self.settings.VAD_MODEL) == "speechbrain":
+            model_dir = os.path.join(config.TEMPORARY_DIRECTORY, "models", "VAD")
+            os.makedirs(model_dir, exist_ok=True)
+            run_opts = None
+            if self.settings.value(self.settings.CUDA):
+                run_opts = {"device": "cuda"}
+            self.vad_model = MfaVAD.from_hparams(
+                source="speechbrain/vad-crdnn-libriparty", savedir=model_dir, run_opts=run_opts
+            )
+        else:
+            self.vad_model = None
+        self.trim_utterance_worker.set_vad_model(self.vad_model)
+
     def download_acoustic_model(self):
         self.download_worker.set_params(
             self.db_string, "acoustic", self.sender().text(), self.model_manager
@@ -2502,6 +2630,8 @@ class OptionsDialog(QtWidgets.QDialog):
         self.ui.cudaCheckBox.setChecked(self.settings.value(self.settings.CUDA))
         if config.GITHUB_TOKEN is not None:
             self.ui.githubTokenEdit.setText(config.GITHUB_TOKEN)
+        if config.HF_TOKEN is not None:
+            self.ui.hfTokenEdit.setText(config.HF_TOKEN)
 
         self.ui.autoloadLastUsedCorpusCheckBox.setChecked(
             self.settings.value(self.settings.AUTOLOAD)
@@ -2634,11 +2764,16 @@ class OptionsDialog(QtWidgets.QDialog):
         config.NUM_JOBS = self.ui.numJobsEdit.value()
         config.USE_MP = self.ui.useMpCheckBox.isChecked()
         config.GITHUB_TOKEN = self.ui.githubTokenEdit.text()
+        config.HF_TOKEN = self.ui.hfTokenEdit.text()
         config.GLOBAL_CONFIG.current_profile.num_jobs = config.NUM_JOBS
         config.GLOBAL_CONFIG.current_profile.use_mp = config.USE_MP
         config.GLOBAL_CONFIG.current_profile.github_token = config.GITHUB_TOKEN
+        config.GLOBAL_CONFIG.current_profile.hf_token = config.HF_TOKEN
         config.GLOBAL_CONFIG.save()
 
+        self.settings.setValue(self.settings.GITHUB_TOKEN, self.ui.githubTokenEdit.text())
+        self.settings.setValue(self.settings.HF_TOKEN, self.ui.hfTokenEdit.text())
+
         self.settings.setValue(
             self.settings.SPEC_DYNAMIC_RANGE, int(self.ui.dynamicRangeEdit.value())
         )

anchor/models.py

@@ -6,6 +6,7 @@ import os
 import re
 import subprocess
 import typing
+import unicodedata
 from threading import Lock
 from typing import Any, Optional, Union
 
@@ -23,12 +24,14 @@ from montreal_forced_aligner.corpus.acoustic_corpus import (
     AcousticCorpusWithPronunciations,
 )
 from montreal_forced_aligner.data import PhoneType, WordType, WorkflowType
-from montreal_forced_aligner.db import CorpusWorkflow, File, Phone, Speaker, Utterance, Word
-from montreal_forced_aligner.dictionary.mixins import (
-    DEFAULT_CLITIC_MARKERS,
-    DEFAULT_COMPOUND_MARKERS,
-    DEFAULT_PUNCTUATION,
-    DEFAULT_WORD_BREAK_MARKERS,
+from montreal_forced_aligner.db import (
+    CorpusWorkflow,
+    File,
+    Grapheme,
+    Phone,
+    Speaker,
+    Utterance,
+    Word,
 )
 from montreal_forced_aligner.g2p.generator import PyniniValidator
 from montreal_forced_aligner.models import (
@@ -51,23 +54,6 @@ if typing.TYPE_CHECKING:
 logger = logging.getLogger("anchor")
 
 
-WORD_BREAK_SET = "".join(
-    sorted(
-        set(
-            DEFAULT_WORD_BREAK_MARKERS
-            + DEFAULT_PUNCTUATION
-            + DEFAULT_CLITIC_MARKERS
-            + DEFAULT_COMPOUND_MARKERS
-        )
-    )
-)
-
-if "-" in WORD_BREAK_SET:
-    WORD_BREAK_SET = "" + WORD_BREAK_SET.replace("-", "")
-
-WORD_BREAK_REGEX_SET = rf"[\s{WORD_BREAK_SET}]"
-
-
 # noinspection PyUnresolvedReferences
 @dataclass(slots=True)
 class TextFilterQuery:
@@ -75,6 +61,7 @@ class TextFilterQuery:
     regex: bool = False
     word: bool = False
     case_sensitive: bool = False
+    graphemes: typing.Collection[str] = None
 
     @property
     def search_text(self):
@@ -83,6 +70,11 @@ class TextFilterQuery:
         return self.text
 
     def generate_expression(self, posix=False):
+        word_symbols = r"\w"
+        if self.graphemes:
+            dash_prefix = "-" if "-" in self.graphemes else ""
+            graphemes = "".join([x for x in self.graphemes if x != "-"])
+            word_symbols = rf"[{dash_prefix}\w{graphemes}]"
         text = self.text
         if not self.case_sensitive:
             text = text.lower()
@@ -97,11 +89,10 @@ class TextFilterQuery:
             if not text.endswith(word_break_set):
                 text += word_break_set
         if posix:
-            text = text.replace(r"\b", r"\y")
             if text.startswith(r"\b"):
-                text = rf"((?<={WORD_BREAK_REGEX_SET})|(?<=^))" + text[2:]
+                text = rf"((?<!{word_symbols})|(?<=^))" + text[2:]
             if text.endswith(r"\b"):
-                text = text[:-2] + rf"((?={WORD_BREAK_REGEX_SET})|(?=$))"
+                text = text[:-2] + rf"((?!{word_symbols})|(?=$))"
         if not self.case_sensitive:
             text = "(?i)" + text
         return text
@@ -385,7 +376,7 @@ class FileUtterancesModel(QtCore.QAbstractListModel):
         if isinstance(utterance, int):
             if utterance not in self.reversed_indices:
                 return
-            utterance = self.reversed_indices[utterance]
+            utterance = self.utterances[self.reversed_indices[utterance]]
         old_speaker_id = utterance.speaker_id
         if old_speaker_id == speaker_id:
             return
@@ -395,10 +386,18 @@ class FileUtterancesModel(QtCore.QAbstractListModel):
         self.corpus_model.set_speaker_modified(old_speaker_id)
 
     def update_utterance_times(
-        self, utterance: Utterance, begin: Optional[float] = None, end: Optional[float] = None
+        self,
+        utterance: typing.Union[Utterance, int],
+        begin: Optional[float] = None,
+        end: Optional[float] = None,
     ):
         if not self.corpus_model.editable:
             return
+        if isinstance(utterance, int):
+            if utterance not in self.reversed_indices:
+                return
+            utterance = self.utterances[self.reversed_indices[utterance]]
+
         if utterance.begin == begin and utterance.end == end:
             return
         self.addCommand.emit(undo.UpdateUtteranceTimesCommand(utterance, begin, end, self))
@@ -578,7 +577,7 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
     resetView = QtCore.Signal()
     viewChanged = QtCore.Signal(object, object)
     selectionAudioChanged = QtCore.Signal(object)
-    currentUtteranceChanged = QtCore.Signal()
+    currentUtteranceChanged = QtCore.Signal(object)
     speakerRequested = QtCore.Signal(object)
 
     spectrogramReady = QtCore.Signal()
@@ -636,13 +635,22 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
             y = self.model().y[begin_samp:end_samp, self.selected_channel]
         else:
             y = self.model().y[begin_samp:end_samp]
-        spectrogram_worker = workers.SpectrogramWorker(
-            y,
-            self.model().file.sound_file.sample_rate,
-            self.min_time,
-            self.max_time,
-            self.selected_channel,
-        )
+        if self.settings.value(self.settings.SPECTRAL_FEATURES) == "mfcc":
+            spectrogram_worker = workers.MfccWorker(
+                y,
+                self.model().file.sound_file.sample_rate,
+                self.min_time,
+                self.max_time,
+                self.selected_channel,
+            )
+        else:
+            spectrogram_worker = workers.SpectrogramWorker(
+                y,
+                self.model().file.sound_file.sample_rate,
+                self.min_time,
+                self.max_time,
+                self.selected_channel,
+            )
         spectrogram_worker.signals.result.connect(self.finalize_loading_spectrogram)
         self.thread_pool.start(spectrogram_worker)
 
@@ -865,7 +873,7 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
     def model(self) -> FileUtterancesModel:
         return super().model()
 
-    def set_view_times(self, begin, end):
+    def set_view_times(self, begin, end, new_file=False):
         begin = max(begin, 0)
         end = min(end, self.model().file.duration)
         if (begin, end) == (self.min_time, self.max_time):
@@ -882,7 +890,8 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
             and not self.min_time <= self.selected_max_time <= self.max_time
         ):
             self.selected_max_time = None
-        self.view_change_timer.start()
+        if not new_file:
+            self.view_change_timer.start()
 
     def send_selection_update(self):
         self.viewChanged.emit(self.min_time, self.max_time)
@@ -902,7 +911,7 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
         else:
             self.finalize_set_new_file()
             self.speakerRequested.emit(speaker_id)
-        self.set_view_times(begin, end)
+        self.set_view_times(begin, end, new_file=True)
 
     def finalize_set_new_file(self):
         if self.requested_utterance_id is None:
@@ -930,16 +939,18 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
             return
         flags = QtCore.QItemSelectionModel.SelectionFlag.Rows
         flags |= QtCore.QItemSelectionModel.SelectionFlag.Select
+        current_index = None
         for u in utterances:
             if u.id not in self.model().reversed_indices:
                 continue
+            current_index = u.id
             row = self.model().reversed_indices[u.id]
 
             index = self.model().index(row, 0)
             if not index.isValid():
                 return
             self.select(index, flags)
-        self.currentUtteranceChanged.emit()
+        self.currentUtteranceChanged.emit(current_index)
 
     def update_select(self, utterance_id: int, deselect=False, reset=False):
         if reset and [x.id for x in self.selected_utterances()] == [utterance_id]:
@@ -961,7 +972,7 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
         self.select(index, flags)
         if not deselect:
             self.select_audio(self.model().utterances[row].begin, self.model().utterances[row].end)
-        self.currentUtteranceChanged.emit()
+        self.currentUtteranceChanged.emit(utterance_id)
 
 
 class CorpusSelectionModel(QtCore.QItemSelectionModel):
@@ -992,6 +1003,7 @@ class CorpusSelectionModel(QtCore.QItemSelectionModel):
         # self.selectionChanged.connect(self.update_selection_audio)
         # self.model().newResults.connect(self.check_selection)
         self.model().unlockCorpus.connect(self.fileChanged.emit)
+        self.model().layoutChanged.connect(self._update_selection)
 
     def set_current_utterance(self, utterance_id):
         self.current_utterance_id = utterance_id
@@ -1078,8 +1090,10 @@ class CorpusSelectionModel(QtCore.QItemSelectionModel):
         if not index.isValid():
             return
         m = self.model()
-        self.current_utterance_id = m._indices[index.row()]
-        self.currentUtteranceChanged.emit()
+        try:
+            self.current_utterance_id = m._indices[index.row()]
+        except IndexError:
+            self.current_utterance_id = None
 
     def selected_utterances(self):
         current_utterance = self.current_utterance_id
@@ -1225,6 +1239,7 @@ class DictionaryTableModel(TableModel):
         self.word_sets = {}
         self.speaker_mapping = {}
         self.phones = []
+        self.graphemes = []
         self.reference_phone_set = set()
         self.custom_mapping = {}
 
@@ -1240,7 +1255,7 @@ class DictionaryTableModel(TableModel):
         except KeyError:
             return True
         if dictionary_id is not None and self.word_sets[dictionary_id]:
-            return word.lower() in self.word_sets[dictionary_id]
+            return unicodedata.normalize("NFKC", word.lower()) in self.word_sets[dictionary_id]
         return True
 
     def lookup_word(self, word: str) -> None:
@@ -1270,6 +1285,19 @@ class DictionaryTableModel(TableModel):
         if self.corpus_model.corpus.position_dependent_phones:
             phones = sorted(set(x.rsplit("_", maxsplit=1)[0] for x in phones))
         self.phones = phones
+        specials = self.corpus_model.corpus.specials_set
+        specials.update(
+            [
+                "#0",
+                "<space>",
+            ]
+        )
+        self.graphemes = [
+            x
+            for x, in self.corpus_model.session.query(Grapheme.grapheme).filter(
+                ~Grapheme.grapheme.in_(specials)
+            )
+        ]
 
     def flags(
         self, index: Union[QtCore.QModelIndex, QtCore.QPersistentModelIndex]
@@ -1339,7 +1367,7 @@ class DictionaryTableModel(TableModel):
                             continue
                         existing_pronunciations.add(self._data[r][2])
                     candidates = self.g2p_generator.rewriter(word)
-                    for c in candidates:
+                    for c, _ in candidates:
                         if c in existing_pronunciations:
                             continue
                         pronunciation = c
@@ -1969,6 +1997,8 @@ class CorpusModel(TableModel):
     filesSaved = QtCore.Signal()
     dictionarySaved = QtCore.Signal()
     selectionRequested = QtCore.Signal(object)
+    transcribeRequested = QtCore.Signal(object)
+    alignRequested = QtCore.Signal(object)
     requestFileView = QtCore.Signal(object)
     utteranceTextUpdated = QtCore.Signal(object, object)
     refreshUtteranceText = QtCore.Signal(object, object)
@@ -2061,6 +2091,7 @@ class CorpusModel(TableModel):
         self.has_per_speaker_transcribed_alignments = False
         self.has_transcript_verification_alignments = False
         self.latest_alignment_workflow = None
+        self.language = None
 
     def update_latest_alignment_workflow(self):
         with self.corpus.session() as session: