Rename and reorganize

chall.py

@@ -8,6 +8,8 @@ import soundfile as sf
 import importlib.util
 
 
+_SAMPLE_RATE = 16000
+
 _DESCRIPTION = "tbd"
 _CITATION = "tbd"
 
@@ -130,7 +132,7 @@ class Chall(GeneratorBasedBuilder):
                         "text": Value("string"),
                     }
                 ),
-                "audio": Audio(sampling_rate=16_000)
+                "audio": Audio(sampling_rate=_SAMPLE_RATE)
             })
         else:
             features = Features({
@@ -168,7 +170,7 @@ class Chall(GeneratorBasedBuilder):
                         ),
                     }
                 ),
-                "audio": Audio(sampling_rate=16_000)
+                "audio": Audio(sampling_rate=_SAMPLE_RATE)
             })
 
         return DatasetInfo(
@@ -214,26 +216,58 @@ class Chall(GeneratorBasedBuilder):
             # ),
         ]
 
+    def _generate_examples(self, filepath, metafile):
+        """
+        This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
+        :param filepath: The path where the data is located.
+        :param metafile: The metafile describing the chall data
+        :return:
+        """
+
+        logger.info("generating examples from = %s", filepath)
+
+        with open(metafile, 'r') as file:
+            for line in file:
+                data = json.loads(line)
+
+                # load transcript
+                transcript_file = os.path.join(filepath, data["transcript_file"])
+                with open(transcript_file, 'r') as transcript:
+                    transcript = json.load(transcript)
+
+                audio_id = data['audio_id']
+                audio_file_path = os.path.join(filepath, data["audio_file"])
+
+                if self.config.split_segments:
+                    yield from self._generate_utterance_examples(audio_id, str(audio_file_path), data, transcript)
+                else:
+                    yield from self._generate_transcript_examples(audio_id, str(audio_file_path), data, transcript)
+
     @staticmethod
-    def _generate_examples_segments(audio_id: str, audio_file_path: str, data: dict, transcript: dict):
+    def _generate_transcript_examples(audio_id: str, audio_file_path: str, data: dict, transcript: dict):
         """
+        Generates examples based on the entire audio file and its associated transcript metadata. This method reads the
+        entire audio file, extracts speaker and segment information from the transcript, and packages these along with
+        the audio data into a dictionary that is then yielded.
 
-        :param audio_id:
-        :param audio_file_path:
-        :param data:
-        :param transcript:
-        :return:
+        :param audio_id: A unique identifier for the audio file.
+        :param audio_file_path: The file system path to the audio file.
+        :param data: A dictionary of the metadata.
+        :param transcript: A dictionary containing details of the transcript, including speakers and segments.
+        :return: Yields a tuple containing the audio ID and the enriched transcript dictionary.
         """
 
-        data["speakers"] = transcript.get("speakers", [])
-        data["segments"] = transcript.get("segments", [])
+        transcript_data = data.copy()  # Create a fresh copy of data to ensure no side effects
+        transcript_data["speakers"] = transcript.get("speakers", [])
+        transcript_data["segments"] = transcript.get("segments", [])
 
-        audio, samplerate = sf.read(audio_file_path)
-        data["audio"] = {"path": audio_file_path, "array": audio, "sampling_rate": samplerate}
+        with sf.SoundFile(audio_file_path) as audio_file:
+            audio = audio_file.read(dtype='float32')
 
-        yield audio_id, data
+        transcript_data["audio"] = {"path": audio_file_path, "array": audio, "sampling_rate": _SAMPLE_RATE}
+        yield audio_id, transcript_data
 
-    def _generate_examples_utterances(self, audio_id: str, audio_file_path: str, data: dict, transcript: dict):
+    def _generate_utterance_examples(self, audio_id: str, audio_file_path: str, data: dict, transcript: dict):
         """
         Generates examples from audio segments based on the transcript provided. Each segment is processed to produce
         an utterance which includes the audio slice and metadata.
@@ -242,56 +276,58 @@ class Chall(GeneratorBasedBuilder):
         :param audio_file_path: The filesystem path to the audio file.
         :param data: A dictionary containing the segments to be processed
         :param transcript: A dictionary containing transcript details with segments of spoken words.
-        :return: Yields a tuple of audio id and it's corresponding data
+        :return: Yields a tuple containing the audio ID and the enriched utterance dictionary.
         """
 
         segments = transcript.get("segments", [])
+        segments = self._process_segments(segments)
 
-        if self.config.max_pause_length:
-            segments = self._remove_to_long_pauses(segments)
-
-        if self.config.max_chunk_length is not None:
-            segments = self._split_long_utterances(segments)
-
-        if self.config.remove_trailing_pauses:
-            self._remove_trailing_pauses_in_segments(segments)
-
-        if self.config.max_pause_length is not None:
-            segments = self._filter_utterances_by_duration(segments, self.config.min_chunk_length, self.config.max_chunk_length)
+        with sf.SoundFile(audio_file_path) as track:
 
-        for segment_i, segment in enumerate(segments):
+            if not track.seekable():
+                raise ValueError("Audio file is not seekable.")
 
-            id_ = f"{audio_id}_{str(segment_i).rjust(3, '0')}"
+            for segment_i, segment in enumerate(segments):
+                segment_data = data.copy()  # Create a fresh copy of data for each segment
+                segment_id = f"{audio_id}_{str(segment_i).rjust(3, '0')}"
 
-            data["audio_id"] = id_
-            data["speaker_id"] = segment["speaker"]
-            data["words"] = segment["words"]
+                segment_data["audio_id"] = segment_id
+                segment_data["speaker_id"] = segment["speaker"]
+                segment_data["words"] = segment["words"]
 
-            track = sf.SoundFile(audio_file_path)
+                start_time = segment["words"][0]["start"]
+                end_time = segment["words"][-1]["end"]
+                start_frame = int(_SAMPLE_RATE * start_time)
+                frames_to_read = int(_SAMPLE_RATE * (end_time - start_time))
 
-            can_seek = track.seekable()
-            if not can_seek:
-                raise ValueError("Not compatible with seeking")
+                track.seek(start_frame)
+                audio = track.read(frames_to_read)
+                segment_data["audio"] = {"path": audio_file_path, "array": audio, "sampling_rate": _SAMPLE_RATE}
 
-            sr = track.samplerate
-            start_time = segment["words"][0]["start"]
-            end_time = segment["words"][-1]["end"]
+                yield segment_id, segment_data
 
-            start_frame = int(sr * start_time)
-            frames_to_read = int(sr * (end_time - start_time))
+    def _process_segments(self, segments):
+        """
+        Processes the list of segments based on configured rules.
+        :param segments: A list of segment dictionaries
+        :return: A list of processed segment dictionaries after applying all the filtering and splitting rules.
+        """
+        if self.config.max_pause_length:
+            segments = self._split_and_remove_long_pauses(segments)
 
-            # Seek to the start frame
-            track.seek(start_frame)
+        if self.config.max_chunk_length is not None:
+            segments = self._split_long_segments(segments)
 
-            # Read the desired frames
-            audio = track.read(frames_to_read)
+        if self.config.remove_trailing_pauses:
+            segments = self._remove_trailing_pauses(segments)
 
-            data["audio"] = {"path": audio_file_path, "array": audio, "sampling_rate": sr}
+        if self.config.max_pause_length is not None:
+            segments = self._filter_segments_by_duration(segments, self.config.min_chunk_length, self.config.max_chunk_length)
 
-            yield id_, data
+        return segments
 
     @staticmethod
-    def _remove_trailing_pauses_in_segments(segments: List[dict]) -> None:
+    def _remove_trailing_pauses(segments: List[dict]) -> List[dict]:
         """
         Removes pauses at the end/start of utterances in each segment to eliminate pauses between segments.
 
@@ -310,10 +346,11 @@ class Chall(GeneratorBasedBuilder):
             # Remove segment if no words left
             if not segment["words"]:
                 segments.remove(segment)
+        return segments
 
-    def _remove_to_long_pauses(self, segments: List[dict]) -> List[dict]:
+    def _split_and_remove_long_pauses(self, segments: List[dict]) -> List[dict]:
         """
-        Remove to long pauses in a segment by splitting the segment in two segments and removing the filled pause.
+        Remove too long pauses in a segment by splitting the segment in two segments and removing the filled pause.
 
         Example (assuming (...) is longer than max_pause_length):
             [["Hello", "(...)", "World!"]] --> [["Hello"], ["World!"]]
@@ -339,7 +376,7 @@ class Chall(GeneratorBasedBuilder):
         return split_segments
 
     @staticmethod
-    def _filter_utterances_by_duration(segments: List[dict], min_duration: float = None, max_duration: float = None, ):
+    def _filter_segments_by_duration(segments: List[dict], min_duration: float = None, max_duration: float = None, ):
         """
         Removes segments with invalid duration
         :param min_duration: The minimum duration allowed for a segment.
@@ -357,7 +394,7 @@ class Chall(GeneratorBasedBuilder):
 
         return filtered_segments
 
-    def _split_long_utterances(self, segments: List[dict]) -> List[dict]:
+    def _split_long_segments(self, segments: List[dict]) -> List[dict]:
         """
         Splits segments into smaller chunks if their duration exceeds the maximum chunk length specified in the config.
 
@@ -406,29 +443,4 @@ class Chall(GeneratorBasedBuilder):
 
         return list_of_chunks
 
-    def _generate_examples(self, filepath, metafile):
-        """
-        This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
-        :param filepath: The path where the data is located.
-        :param metafile: The metafile describing the chall data
-        :return:
-        """
-
-        logger.info("generating examples from = %s", filepath)
-
-        with open(metafile, 'r') as file:
-            for line in file:
-                data = json.loads(line)
-
-                # load transcript
-                transcript_file = os.path.join(filepath, data["transcript_file"])
-                with open(transcript_file, 'r') as transcript:
-                    transcript = json.load(transcript)
-
-                audio_id = data['audio_id']
-                audio_file_path = os.path.join(filepath, data["audio_file"])
 
-                if self.config.split_segments:
-                    yield from self._generate_examples_utterances(audio_id, str(audio_file_path), data, transcript)
-                else:
-                    yield from self._generate_examples_segments(audio_id, str(audio_file_path), data, transcript)