feat: update for soundswallower 0.4.0

dhdaines · dhdaines · commit 7c98e45420cc · 2022-11-08T14:21:39.000-05:00
diff --git a/readalongs/align.py b/readalongs/align.py
@@ -393,7 +393,7 @@ def align_sequence(
             or None to not save them.
 
     Returns:
-        Iterable[soundswallower.Segment]: Word (or other unit) alignments.
+        Iterable[soundswallower.Seg]: Word (or other unit) alignments.
 
     Raises:
         RuntimeError: If alignment fails (TODO: figure out why).
@@ -432,38 +432,41 @@ def align_sequence(
     ps.process_raw(audio_segment.raw_data, no_search=False, full_utt=True)
     ps.end_utt()
 
-    return ps.seg()
+    return ps.seg
 
 
 def process_segmentation(
-    segmentation: Iterable[soundswallower.Segment],
+    segmentation: Iterable[soundswallower.Seg],
     curr_removed_segments: List[dict],
     noisewords: Set[str],
     frame_size: float,
     debug_aligner: Optional[bool] = False,
 ) -> List[Dict[str, Any]]:
     """Correct output alignments based on do-not-align segments."""
-    aligned_words = []
+    aligned_words: List[Dict[str, Any]] = []
     for word_seg in segmentation:
-        if word_seg.word in noisewords:
+        if word_seg.text in noisewords:
             continue
-        start = word_seg.start_frame * frame_size
-        end = (word_seg.end_frame + 1) * frame_size
-        # change to ms
-        start_ms = int(start * 1000)
-        end_ms = int(end * 1000)
+        start = word_seg.start
+        end = word_seg.start + word_seg.duration
+        # round to milliseconds to avoid imprecisions
+        start_ms = round(start * 1000)
+        end_ms = round(end * 1000)
+        # possibly adjust for removed sections
         if curr_removed_segments:
             start_ms += calculate_adjustment(start_ms, curr_removed_segments)
             end_ms += calculate_adjustment(end_ms, curr_removed_segments)
             start_ms, end_ms = correct_adjustments(
                 start_ms, end_ms, curr_removed_segments
             )
-            # change back to seconds to write to smil
-            start = start_ms / 1000
-            end = end_ms / 1000
-        aligned_words.append({"id": word_seg.word, "start": start, "end": end})
+        # change back to seconds
+        start = start_ms / 1000
+        end = end_ms / 1000
+        if aligned_words:
+            assert start >= aligned_words[-1]["end"]
+        aligned_words.append({"id": word_seg.text, "start": start, "end": end})
         if debug_aligner:
-            LOGGER.info("Segment: %s (%.3f : %.3f)", word_seg.word, start, end)
+            LOGGER.info("Segment: %s (%.3f : %.3f)", word_seg.text, start, end)
     return aligned_words
 
 
@@ -634,19 +637,14 @@ def align_audio(
                 audio_length_in_ms,
                 removed_segments,
             )
-            try:
-                # Process raw segmentation, adjusting alignments for DNA
-                aligned_words = process_segmentation(
-                    segmentation=segmentation,
-                    curr_removed_segments=curr_removed_segments,
-                    noisewords=noisewords,
-                    frame_size=frame_size,
-                    debug_aligner=debug_aligner,
-                )
-            except RuntimeError:
-                # We need this here because soundswallower<=0.2.2 will
-                # raise an error rather than returning an empty list
-                aligned_words = []
+            # Process raw segmentation, adjusting alignments for DNA
+            aligned_words = process_segmentation(
+                segmentation=segmentation,
+                curr_removed_segments=curr_removed_segments,
+                noisewords=noisewords,
+                frame_size=frame_size,
+                debug_aligner=debug_aligner,
+            )
 
             if len(aligned_words) != len(word_sequence.words):
                 LOGGER.warning(f"Align mode {align_modes[j]} failed for sequence {i}.")
@@ -990,8 +988,8 @@ def get_word_texts_and_sentences(
            "end": end time
     """
     sentences = []
-    sent_words: List[dict] = []
-    all_words = []
+    sent_words: List[Dict[str, Any]] = []
+    all_words: List[Dict[str, Any]] = []
     prev_sent_el = None
     for word in words:
         # The sentence is considered the set of words under the same <s> element.
@@ -1009,6 +1007,8 @@ def get_word_texts_and_sentences(
             "start": word["start"],
             "end": word["end"],
         }
+        if all_words:
+            assert word_with_text["start"] >= all_words[-1]["end"]
         sent_words.append(word_with_text)
         all_words.append(word_with_text)
     if sent_words:
diff --git a/requirements.min.txt b/requirements.min.txt
@@ -13,6 +13,6 @@ numpy>=1.16.4
 pydub==0.23.1
 pympi-ling==1.69
 python-slugify==5.0.0
-soundswallower~=0.2.2
+soundswallower~=0.4.0
 webvtt-py==0.4.2
 werkzeug==2.0.3
diff --git a/test/sound_swallower_stub.py b/test/sound_swallower_stub.py
@@ -44,49 +44,31 @@ def SoundSwallowerStub(*segments):
 class SoundSwallowerDecoderStub:
     """Stub class so we don't really call the SoundSwallower decoder"""
 
-    class Segment:
+    class Seg:
         def __init__(self, segment_desc):
             """Init self from "word_id:start:end" description, e.g. "p0s0w0:0:1"."""
-            self.word, s, e = segment_desc.split(":")
-            self.start_frame = int(s)
-            self.end_frame = int(e)
+            self.text, s, e = segment_desc.split(":")
+            self.start = float(s) / 100
+            self.duration = (float(e) - float(s)) / 100
 
         def __repr__(self):
-            return f'Segment(word="{self.word}", start_frame={self.start_frame}, end_frame={self.end_frame})'
+            return (
+                f'Seg(text="{self.text}", start={self.start}, duration={self.duration})'
+            )
 
     class Config:
         def __init__(self, *args):
             pass
 
-        def set_boolean(self, *args):
-            pass
-
-        def set_string(self, *args):
-            pass
-
-        def set_float(self, *args):
-            pass
-
-        def set_int(self, *args):
-            pass
-
-        def get_float(self, *args):
-            return 1.0
-
-        def get_string(self, *args):
-            return "SPAM"
-
-        def get_int(self, name):
-            if name == "-frate":
+        def __getitem__(self, key):
+            if key == "frate":
                 # Pretend the framerate is always 1000, so the stub times are all in ms
                 return 1000
             else:
-                return 1
+                return "SPAM"
 
     def __init__(self, *outputs):
-        self._segments = [
-            SoundSwallowerDecoderStub.Segment(segment) for segment in outputs
-        ]
+        self._segments = [SoundSwallowerDecoderStub.Seg(segment) for segment in outputs]
 
     def __call__(self, *args):
         return self
@@ -100,6 +82,7 @@ def process_raw(self, *args, **kwargs):
     def end_utt(self):
         pass
 
+    @property
     def seg(self):
         return self._segments
 
