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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Anchor_annotator
-Version: 0.5.0
+Version: 0.7.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.7.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=akvr8ObxvMF-aaLBzW41juT4_KL3BjQUrjbwkIuQXMk,411
+anchor/command_line.py,sha256=EucG805HyWk_zkMO9RXv9Yj0I0JVdDLZb1_DX2_ISjM,503
+anchor/db.py,sha256=LlZzAy4bjmJIu0v4ev5Qjg_Fh2n9sMsKI2nAY1pwd0A,5057
+anchor/main.py,sha256=Lyr3ppr-nzxaU7ZmWXc-luMsOtRBbV4ebCzk3rygur4,127781
+anchor/models.py,sha256=35l7Kw3LVy-_ozdV_0ApSkKyCPViBwBmAukoq-jw90o,97668
+anchor/plot.py,sha256=imNRLI76VgEf4n9UGNvIaTsqn65hqnN396e4iwRTh70,113387
+anchor/resources_rc.py,sha256=tzJHrJw3MpjAlnj-DtCmaR4A8gAaLF966XEXs5HNIjc,8464375
+anchor/settings.py,sha256=N2gRFQEpY4pLYgcDz1Aq-2c7CfmbNxmRmVcPijrHsCo,52118
+anchor/ui_corpus_manager.py,sha256=e3ybOd4UdYarrLBATxI8vIFnioa4R_BHrbsEz5mJ5eA,8564
+anchor/ui_error_dialog.py,sha256=HKbjGT_jtdb9jfn9THQMbl1fmcdWyjYDazM4hCwZ5Yo,3931
+anchor/ui_main_window.py,sha256=XK91lhFAIEURZ6nwxIA74X-8j-P76JuJsN-ahun65rw,37043
+anchor/ui_preferences.py,sha256=g3tcjAMFKIAqUJNEke7ww4LkdeTFA1zb8_lrhF6k5fo,43271
+anchor/undo.py,sha256=T8CJpSZVZbItpU7KMZU2F49mNv1wo0rvMWtNIEbieeo,32856
+anchor/widgets.py,sha256=NjQAc02QVu97QClhXcylj_P6IP0DsxWae_eiZR5Bw3M,159300
+anchor/workers.py,sha256=ciVOlK15MiDq7juAivcQB6PEiEs7DemP0BOrcpnm2to,182624
+Anchor_annotator-0.7.0.dist-info/LICENSE,sha256=C0oIsblENEgWQ7XMNdYoXyXsIA5wa3YF0I9lK3H7A1s,1076
+Anchor_annotator-0.7.0.dist-info/METADATA,sha256=hvYb1JLmhGJEfwyTNGckZl6tqtj407fmYYdPqPOgwcE,1500
+Anchor_annotator-0.7.0.dist-info/WHEEL,sha256=FZ75kcLy9M91ncbIgG8dnpCncbiKXSRGJ_PFILs6SFg,91
+Anchor_annotator-0.7.0.dist-info/top_level.txt,sha256=wX6ZKxImGRZKFQjs3f6XYw_TfbAp6Xs3SmbLfLbFAJ0,7
+Anchor_annotator-0.7.0.dist-info/RECORD,,

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

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (71.0.1)
 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.5.0'
-__version_tuple__ = version_tuple = (0, 5, 0)
+__version__ = version = '0.7.0'
+__version_tuple__ = version_tuple = (0, 7, 0)

anchor/db.py

@@ -105,6 +105,7 @@ class AnchorCorpus(AnchorSqlBase):
     custom_mapping_path = Column(PathType, nullable=True)
     reference_directory = Column(PathType, nullable=True)
     current = Column(Boolean, nullable=False, default=False, index=True)
+    # last_used = Column(DateTime, nullable=False, server_default=sqlalchemy.func.now(), index=True)
 
     acoustic_model_id = Column(Integer, ForeignKey("acoustic_model.id"), index=True, nullable=True)
     acoustic_model = relationship("AcousticModel", back_populates="corpora")

anchor/main.py

@@ -123,6 +123,7 @@ class MainWindow(QtWidgets.QMainWindow):
         self.media_player = MediaPlayer(self)
         self.media_player.playbackStateChanged.connect(self.handleAudioState)
         self.media_player.audioReady.connect(self.file_loaded)
+        self.media_player.playingChanged.connect(self.update_play_button)
         self.media_player.timeChanged.connect(
             self.ui.utteranceDetailWidget.plot_widget.audio_plot.update_play_line
         )
@@ -345,14 +346,11 @@ class MainWindow(QtWidgets.QMainWindow):
             session.commit()
 
     def file_loaded(self, ready):
-        if ready:
-            self.ui.playAct.setEnabled(ready)
-            self.ui.muteAct.setEnabled(ready)
-        else:
-            self.ui.playAct.setEnabled(False)
-            self.ui.playAct.setChecked(False)
-            self.ui.muteAct.setChecked(False)
-            self.ui.muteAct.setEnabled(False)
+        self.ui.playAct.setEnabled(ready)
+        self.ui.muteAct.setEnabled(ready)
+
+    def update_play_button(self, playing):
+        self.ui.playAct.setChecked(playing)
 
     def corpus_changed(self, clean):
         if clean:
@@ -406,9 +404,15 @@ class MainWindow(QtWidgets.QMainWindow):
         elif function == "Diarizing utterances":
             worker = workers.SpeakerDiarizationWorker(self.corpus_model.session, **extra_args[0])
             worker.signals.result.connect(finished_function)
-        elif function == "Counting diarization results":
+        elif function == "Diarizing speakers":
+            worker = workers.SpeakerUtterancesWorker(self.corpus_model.session, **extra_args[0])
+            worker.signals.result.connect(finished_function)
+        elif function == "Counting utterance diarization results":
             worker = workers.SpeakerDiarizationWorker(self.corpus_model.session, **extra_args[0])
             worker.signals.result.connect(finished_function)
+        elif function == "Counting speaker diarization results":
+            worker = workers.SpeakerUtterancesWorker(self.corpus_model.session, **extra_args[0])
+            worker.signals.result.connect(finished_function)
         elif function == "Merging speakers":
             self.set_application_state("loading")
             worker = workers.MergeSpeakersWorker(self.corpus_model.session, **extra_args[0])
@@ -720,7 +724,6 @@ class MainWindow(QtWidgets.QMainWindow):
     def closeEvent(self, a0: QtGui.QCloseEvent) -> None:
         for worker in self.workers:
             worker.stopped.set()
-        self.file_selection_model.clean_up_for_close()
         self.file_utterances_model.clean_up_for_close()
         self.settings.setValue(
             AnchorSettings.UTTERANCES_VISIBLE, self.ui.utteranceDockWidget.isVisible()
@@ -765,6 +768,8 @@ class MainWindow(QtWidgets.QMainWindow):
                 return
         if self.thread_pool.activeThreadCount() > 0:
             return
+        if self.file_selection_model.thread_pool.activeThreadCount() > 0:
+            return
         if self.corpus_model.session is not None:
             self.corpus_model.session = None
             self.corpus_model.corpus.cleanup_connections()
@@ -851,8 +856,10 @@ class MainWindow(QtWidgets.QMainWindow):
         self.ui.transcriptionWidget.button.setDefaultAction(self.ui.transcribeCorpusAct)
         self.ui.utteranceListWidget.oov_button.setDefaultAction(self.ui.oovsOnlyAct)
         self.ui.alignmentWidget.button.setDefaultAction(self.ui.alignCorpusAct)
+        self.ui.alignmentWidget.verify_button.setDefaultAction(self.ui.verifyTranscriptsAct)
 
         self.ui.alignCorpusAct.triggered.connect(self.begin_alignment)
+        self.ui.verifyTranscriptsAct.triggered.connect(self.begin_verify_transcripts)
         self.ui.diarizationWidget.refresh_ivectors_action.triggered.connect(
             self.begin_refresh_ivectors
         )
@@ -1324,6 +1331,9 @@ class MainWindow(QtWidgets.QMainWindow):
                     self.corpus_model.has_reference_alignments = True
                 elif w.workflow_type is WorkflowType.transcription:
                     self.corpus_model.has_transcribed_alignments = True
+                elif w.workflow_type is WorkflowType.transcript_verification:
+                    self.corpus_model.has_transcribed_alignments = True
+                    self.corpus_model.has_transcript_verification_alignments = True
                 elif w.workflow_type is WorkflowType.per_speaker_transcription:
                     self.corpus_model.has_per_speaker_transcribed_alignments = True
 
@@ -1407,6 +1417,15 @@ class MainWindow(QtWidgets.QMainWindow):
         self.set_application_state("loading")
         self.ui.loadingScreen.setCorpusName("Performing alignment...")
 
+    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.alignment_worker.start()
+        self.set_application_state("loading")
+        self.ui.loadingScreen.setCorpusName("Verifying transcriptions...")
+
     def begin_refresh_ivectors(self):
         self.enableMfaActions(False)
         self.compute_ivectors_worker.set_params(self.corpus_model, reset=False)
@@ -1560,6 +1579,7 @@ class MainWindow(QtWidgets.QMainWindow):
         )
         self.corpus_model.update_data()
         self.check_actions()
+        self.corpus_model.update_latest_alignment_workflow()
         self.set_application_state("loaded")
 
     def finalize_utterance_alignment(self, utterance_id: int):
@@ -2532,6 +2552,7 @@ class OptionsDialog(QtWidgets.QDialog):
         self.ui.tabWidget.setCurrentIndex(0)
         # self.setFont(self.settings.font)
         # self.setStyleSheet(self.settings.style_sheet)
+        self.update_preset_theme()
 
     def set_theme(self, theme):
         self.ui.primaryBaseEdit.set_color(theme[self.settings.PRIMARY_BASE_COLOR])

anchor/models.py

@@ -22,8 +22,8 @@ from montreal_forced_aligner.corpus.acoustic_corpus import (
     AcousticCorpus,
     AcousticCorpusWithPronunciations,
 )
-from montreal_forced_aligner.data import PhoneType, WordType
-from montreal_forced_aligner.db import File, Phone, Speaker, Utterance
+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,
@@ -97,14 +97,13 @@ class TextFilterQuery:
             if not text.endswith(word_break_set):
                 text += word_break_set
         if posix:
-            text = text.replace(r"\b", word_break_set)
+            text = text.replace(r"\b", r"\y")
             if text.startswith(r"\b"):
                 text = rf"((?<={WORD_BREAK_REGEX_SET})|(?<=^))" + text[2:]
             if text.endswith(r"\b"):
                 text = text[:-2] + rf"((?={WORD_BREAK_REGEX_SET})|(?=$))"
-        if self.regex or self.word:
-            if not self.case_sensitive:
-                text = "(?i)" + text
+        if not self.case_sensitive:
+            text = "(?i)" + text
         return text
 
 
@@ -202,10 +201,10 @@ class FileUtterancesModel(QtCore.QAbstractListModel):
         self.reversed_indices = {}
         self.speaker_channel_mapping = {}
         self.corpus_model: CorpusModel = None
-        self.waveform_worker = workers.WaveformWorker()
-        self.speaker_tier_worker = workers.SpeakerTierWorker()
-        self.speaker_tier_worker.signals.result.connect(self.finalize_loading_utterances)
-        self.waveform_worker.signals.result.connect(self.finalize_loading_wave_form)
+        self.closing = False
+
+        self.thread_pool = QtCore.QThreadPool()
+        self.thread_pool.setMaxThreadCount(4)
 
     def get_utterance(self, utterance_id: int) -> Utterance:
         try:
@@ -217,8 +216,7 @@ class FileUtterancesModel(QtCore.QAbstractListModel):
         self.corpus_model = corpus_model
 
     def clean_up_for_close(self):
-        self.waveform_worker.stop()
-        self.speaker_tier_worker.stop()
+        self.closing = True
 
     def set_file(self, file_id):
         self.file = (
@@ -226,11 +224,13 @@ class FileUtterancesModel(QtCore.QAbstractListModel):
         )
         self.y = None
         self.get_utterances()
-        self.waveform_worker.stop()
-        self.waveform_worker.set_params(self.file.sound_file.sound_file_path)
-        self.waveform_worker.start()
+        waveform_worker = workers.WaveformWorker(self.file.sound_file.sound_file_path)
+        waveform_worker.signals.result.connect(self.finalize_loading_wave_form)
+        self.thread_pool.start(waveform_worker)
 
     def finalize_loading_utterances(self, results):
+        if self.closing:
+            return
         utterances, file_id = results
         if file_id != self.file.id:
             return
@@ -246,6 +246,8 @@ class FileUtterancesModel(QtCore.QAbstractListModel):
         self.utterancesReady.emit()
 
     def finalize_loading_wave_form(self, results):
+        if self.closing:
+            return
         y, file_path = results
         if self.file is None or file_path != self.file.sound_file.sound_file_path:
             return
@@ -264,15 +266,17 @@ class FileUtterancesModel(QtCore.QAbstractListModel):
         self.endRemoveRows()
         if self.file is None:
             return
-        self.speaker_tier_worker.stop()
-        self.speaker_tier_worker.query_alignment = (
-            self.corpus_model.has_alignments
-            or self.corpus_model.has_reference_alignments
-            or self.corpus_model.has_transcribed_alignments
+        speaker_tier_worker = workers.SpeakerTierWorker(
+            self.corpus_model.session,
+            self.file.id,
+            query_alignment=(
+                self.corpus_model.has_alignments
+                or self.corpus_model.has_reference_alignments
+                or self.corpus_model.has_transcribed_alignments
+            ),
         )
-        self.speaker_tier_worker.session = self.corpus_model.session
-        self.speaker_tier_worker.set_params(self.file.id)
-        self.speaker_tier_worker.start()
+        speaker_tier_worker.signals.result.connect(self.finalize_loading_utterances)
+        self.thread_pool.start(speaker_tier_worker)
 
     def create_utterance(self, speaker_id: Optional[int], begin: float, end: float):
         if not self.corpus_model.editable:
@@ -602,18 +606,17 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
         self.waveform_x = None
         self.waveform_y = None
         self.requested_utterance_id = None
-        self.auto_waveform_worker = workers.AutoWaveformWorker()
-        self.spectrogram_worker = workers.SpectrogramWorker()
-        self.pitch_track_worker = workers.PitchWorker()
-        self.auto_waveform_worker.signals.result.connect(self.finalize_loading_auto_wave_form)
-        self.spectrogram_worker.signals.result.connect(self.finalize_loading_spectrogram)
-        self.pitch_track_worker.signals.result.connect(self.finalize_loading_pitch_track)
+        self.closing = False
+
+        self.thread_pool = QtCore.QThreadPool()
+        self.thread_pool.setMaxThreadCount(self.settings.value(self.settings.PLOT_THREAD_COUNT))
         self.model().waveformReady.connect(self.load_audio_selection)
         self.model().utterancesReady.connect(self.finalize_set_new_file)
         self.viewChanged.connect(self.load_audio_selection)
         self.model().selectionRequested.connect(self.update_selected_utterances)
         self.view_change_timer = QtCore.QTimer()
-        self.view_change_timer.setInterval(50)
+        self.view_change_timer.setSingleShot(True)
+        self.view_change_timer.setInterval(10)
         self.view_change_timer.timeout.connect(self.send_selection_update)
 
     def selected_utterances(self):
@@ -633,18 +636,17 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
             y = self.model().y[begin_samp:end_samp, self.selected_channel]
         else:
             y = self.model().y[begin_samp:end_samp]
-        self.spectrogram_worker.stop()
-        self.spectrogram_worker.set_params(
+        spectrogram_worker = workers.SpectrogramWorker(
             y,
             self.model().file.sound_file.sample_rate,
             self.min_time,
             self.max_time,
             self.selected_channel,
         )
-        self.spectrogram_worker.start()
+        spectrogram_worker.signals.result.connect(self.finalize_loading_spectrogram)
+        self.thread_pool.start(spectrogram_worker)
 
-        self.pitch_track_worker.stop()
-        self.pitch_track_worker.set_params(
+        pitch_track_worker = workers.PitchWorker(
             y,
             self.model().file.sound_file.sample_rate,
             self.min_time,
@@ -653,10 +655,10 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
             self.bottom_point,
             self.separator_point,
         )
-        self.pitch_track_worker.start()
+        pitch_track_worker.signals.result.connect(self.finalize_loading_pitch_track)
+        self.thread_pool.start(pitch_track_worker)
 
-        self.auto_waveform_worker.stop()
-        self.auto_waveform_worker.set_params(
+        auto_waveform_worker = workers.AutoWaveformWorker(
             y,
             self.separator_point,
             self.top_point,
@@ -664,12 +666,11 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
             self.max_time,
             self.selected_channel,
         )
-        self.auto_waveform_worker.start()
+        auto_waveform_worker.signals.result.connect(self.finalize_loading_auto_wave_form)
+        self.thread_pool.start(auto_waveform_worker)
 
     def clean_up_for_close(self):
-        self.spectrogram_worker.stop()
-        self.pitch_track_worker.stop()
-        self.auto_waveform_worker.stop()
+        self.closing = True
 
     @property
     def plot_min(self):
@@ -684,6 +685,8 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
         return self.max_time
 
     def finalize_loading_spectrogram(self, results):
+        if self.closing:
+            return
         if results is None:
             self.spectrogram = None
             self.min_db = None
@@ -691,28 +694,28 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
             self.spectrogramReady.emit()
             return
         stft, channel, begin, end, min_db, max_db = results
+        if begin != self.min_time or end != self.max_time:
+            return
         if self.settings.right_to_left:
             stft = np.flip(stft, 1)
-            begin, end = -end, -begin
-        if begin != self.plot_min or end != self.plot_max:
-            return
         self.spectrogram = stft
         self.min_db = self.min_db
         self.max_db = self.max_db
         self.spectrogramReady.emit()
 
     def finalize_loading_pitch_track(self, results):
+        if self.closing:
+            return
         if results is None:
             self.pitch_track_y = None
             self.pitch_track_x = None
             self.pitchTrackReady.emit()
             return
         pitch_track, voicing_track, channel, begin, end, min_f0, max_f0 = results
+        if begin != self.min_time or end != self.max_time:
+            return
         if self.settings.right_to_left:
             pitch_track = np.flip(pitch_track, 0)
-            begin, end = -end, -begin
-        if begin != self.plot_min or end != self.plot_max:
-            return
         self.pitch_track_y = pitch_track
         if pitch_track is None:
             return
@@ -725,23 +728,24 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
         self.pitchTrackReady.emit()
 
     def finalize_loading_auto_wave_form(self, results):
+        if self.closing:
+            return
         y, begin, end, channel = results
+        if begin != self.min_time or end != self.max_time:
+            return
         if self.settings.right_to_left:
             y = np.flip(y, 0)
-            begin, end = -end, -begin
-        if begin != self.plot_min or end != self.plot_max:
-            return
         x = np.linspace(start=self.plot_min, stop=self.plot_max, num=y.shape[0])
         self.waveform_x = x
         self.waveform_y = y
         self.waveformReady.emit()
 
     def select_audio(self, begin, end):
-        if end is not None and end - begin < 0.05:
+        if end is not None and end - begin < 0.025:
             end = None
         self.selected_min_time = begin
         self.selected_max_time = end
-        if self.selected_min_time != self.min_time:
+        if self.selected_min_time != self.min_time or end is not None:
             self.selectionAudioChanged.emit(False)
 
     def request_start_time(self, start_time, update=False):
@@ -881,7 +885,6 @@ class FileSelectionModel(QtCore.QItemSelectionModel):
         self.view_change_timer.start()
 
     def send_selection_update(self):
-        self.view_change_timer.stop()
         self.viewChanged.emit(self.min_time, self.max_time)
 
     def set_current_file(self, file_id, begin, end, utterance_id, speaker_id, force_update=False):
@@ -1916,14 +1919,30 @@ class DiarizationModel(TableModel):
         self.runFunction.emit("Reassigning utterances for speaker", self.update_data, [kwargs])
 
     def update_result_count(self):
-        self.runFunction.emit(
-            "Counting diarization results", self.finalize_result_count, [self.count_kwargs]
-        )
+        if self.in_speakers:
+            self.runFunction.emit(
+                "Counting speaker diarization results",
+                self.finalize_result_count,
+                [self.count_kwargs],
+            )
+        else:
+            self.runFunction.emit(
+                "Counting utterance diarization results",
+                self.finalize_result_count,
+                [self.count_kwargs],
+            )
 
     def update_data(self):
         if not self.corpus_model.corpus.has_any_ivectors():
             return
-        self.runFunction.emit("Diarizing utterances", self.finish_update_data, [self.query_kwargs])
+        if self.in_speakers:
+            self.runFunction.emit(
+                "Diarizing speakers", self.finish_update_data, [self.query_kwargs]
+            )
+        else:
+            self.runFunction.emit(
+                "Diarizing utterances", self.finish_update_data, [self.query_kwargs]
+            )
 
 
 class CorpusModel(TableModel):
@@ -2040,6 +2059,31 @@ class CorpusModel(TableModel):
         self.has_reference_alignments = False
         self.has_transcribed_alignments = False
         self.has_per_speaker_transcribed_alignments = False
+        self.has_transcript_verification_alignments = False
+        self.latest_alignment_workflow = None
+
+    def update_latest_alignment_workflow(self):
+        with self.corpus.session() as session:
+            query = (
+                session.query(CorpusWorkflow.id)
+                .filter(CorpusWorkflow.workflow_type.in_(WorkflowType.alignment_workflows()))
+                .order_by(sqlalchemy.desc(CorpusWorkflow.time_stamp))
+                .limit(1)
+            ).first()
+            if query is not None:
+                query = query[0]
+            self.latest_alignment_workflow = query
+
+    def get_interjection_count(self):
+        if self.corpus is None:
+            return 0
+        with self.corpus.session() as session:
+            count = (
+                session.query(sqlalchemy.func.count(Word.id))
+                .filter(Word.word_type == WordType.interjection)
+                .first()[0]
+            )
+        return count
 
     def get_speaker_name(self, speaker_id: int):
         if speaker_id not in self.speaker_id_mapping:
@@ -2326,6 +2370,7 @@ class CorpusModel(TableModel):
             self.refresh_files()
             self.refresh_speakers()
             self.refresh_utterances()
+            self.update_latest_alignment_workflow()
 
     def search(
         self,