Simplify Common Voice code (#3817)

* simplify common_voice

* one iter_archive per split

Commit from https://github.com/huggingface/datasets/commit/f5929980e7d857d491a20c35305ea01a24c25326

common_voice.py

@@ -659,135 +659,100 @@ class CommonVoice(datasets.GeneratorBasedBuilder):
 
     def _split_generators(self, dl_manager):
         """Returns SplitGenerators."""
-        streaming = dl_manager.is_streaming
+        # Download the TAR archive that contains the audio files:
         archive_path = dl_manager.download(_DATA_URL.format(self.config.name))
-        if streaming:
-            # Here we use iter_archive in streaming mode because dl_manager.download_and_extract
-            # doesn't work to stream TAR archives (we have to stream the files in the archive one by one).
-            #
-            # The iter_archive method returns an iterable of (path_within_archive, file_obj) for every
-            # file in the TAR archive.
-            #
-            archive_iterator = dl_manager.iter_archive(archive_path)
-            # we locate the data using the path within the archive
-            path_to_data = "/".join(["cv-corpus-6.1-2020-12-11", self.config.name])
-            path_to_clips = "/".join([path_to_data, "clips"])
-            metadata_filepaths = {
-                split: "/".join([path_to_data, f"{split}.tsv"])
-                for split in ["train", "test", "dev", "other", "validated", "invalidated"]
-            }
-        else:
-            # In non-streaming we can extract the archive locally as usual
-            extracted_dir = dl_manager.extract(archive_path)
-            archive_iterator = None
-            # we locate the data using the local path
-            path_to_data = os.path.join(extracted_dir, "cv-corpus-6.1-2020-12-11", self.config.name)
-            path_to_clips = os.path.join(path_to_data, "clips")
-            metadata_filepaths = {
-                split: os.path.join(path_to_data, f"{split}.tsv")
-                for split in ["train", "test", "dev", "other", "validated", "invalidated"]
-            }
+
+        # First we locate the data using the path within the archive:
+        path_to_data = "/".join(["cv-corpus-6.1-2020-12-11", self.config.name])
+        path_to_clips = "/".join([path_to_data, "clips"])
+        metadata_filepaths = {
+            split: "/".join([path_to_data, f"{split}.tsv"])
+            for split in ["train", "test", "dev", "other", "validated", "invalidated"]
+        }
+        # (Optional) In non-streaming mode, we can extract the archive locally to have actual local audio files:
+        local_extracted_archive = dl_manager.extract(archive_path) if not dl_manager.is_streaming else None
+
+        # To access the audio data from the TAR archives using the download manager,
+        # we have to use the dl_manager.iter_archive method.
+        #
+        # This is because dl_manager.download_and_extract
+        # doesn't work to stream TAR archives in streaming mode.
+        # (we have to stream the files of a TAR archive one by one)
+        #
+        # The iter_archive method returns an iterable of (path_within_archive, file_obj) for every
+        # file in the TAR archive.
 
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
-                    "streaming": streaming,
-                    "archive_iterator": archive_iterator,
-                    "filepath": metadata_filepaths["train"],
+                    "local_extracted_archive": local_extracted_archive,
+                    "archive_iterator": dl_manager.iter_archive(
+                        archive_path
+                    ),  # use iter_archive here to access the files in the TAR archives
+                    "metadata_filepath": metadata_filepaths["train"],
                     "path_to_clips": path_to_clips,
                 },
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.TEST,
                 gen_kwargs={
-                    "streaming": streaming,
-                    "archive_iterator": archive_iterator,
-                    "filepath": metadata_filepaths["test"],
+                    "local_extracted_archive": local_extracted_archive,
+                    "archive_iterator": dl_manager.iter_archive(
+                        archive_path
+                    ),  # use iter_archive here to access the files in the TAR archives
+                    "metadata_filepath": metadata_filepaths["test"],
                     "path_to_clips": path_to_clips,
                 },
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.VALIDATION,
                 gen_kwargs={
-                    "streaming": streaming,
-                    "archive_iterator": archive_iterator,
-                    "filepath": metadata_filepaths["dev"],
+                    "local_extracted_archive": local_extracted_archive,
+                    "archive_iterator": dl_manager.iter_archive(
+                        archive_path
+                    ),  # use iter_archive here to access the files in the TAR archives
+                    "metadata_filepath": metadata_filepaths["dev"],
                     "path_to_clips": path_to_clips,
                 },
             ),
             datasets.SplitGenerator(
                 name="other",
                 gen_kwargs={
-                    "streaming": streaming,
-                    "archive_iterator": archive_iterator,
-                    "filepath": metadata_filepaths["other"],
+                    "local_extracted_archive": local_extracted_archive,
+                    "archive_iterator": dl_manager.iter_archive(
+                        archive_path
+                    ),  # use iter_archive here to access the files in the TAR archives
+                    "metadata_filepath": metadata_filepaths["other"],
                     "path_to_clips": path_to_clips,
                 },
             ),
             datasets.SplitGenerator(
                 name="validated",
                 gen_kwargs={
-                    "streaming": streaming,
-                    "archive_iterator": archive_iterator,
-                    "filepath": metadata_filepaths["validated"],
+                    "local_extracted_archive": local_extracted_archive,
+                    "archive_iterator": dl_manager.iter_archive(
+                        archive_path
+                    ),  # use iter_archive here to access the files in the TAR archives
+                    "metadata_filepath": metadata_filepaths["validated"],
                     "path_to_clips": path_to_clips,
                 },
             ),
             datasets.SplitGenerator(
                 name="invalidated",
                 gen_kwargs={
-                    "streaming": streaming,
-                    "archive_iterator": archive_iterator,
-                    "filepath": metadata_filepaths["invalidated"],
+                    "local_extracted_archive": local_extracted_archive,
+                    "archive_iterator": dl_manager.iter_archive(
+                        archive_path
+                    ),  # use iter_archive here to access the files in the TAR archives
+                    "metadata_filepath": metadata_filepaths["invalidated"],
                     "path_to_clips": path_to_clips,
                 },
             ),
         ]
 
-    def _generate_examples(self, streaming, archive_iterator, filepath, path_to_clips):
+    def _generate_examples(self, local_extracted_archive, archive_iterator, metadata_filepath, path_to_clips):
         """Yields examples."""
-        if streaming:
-            yield from self._generate_examples_streaming(archive_iterator, filepath, path_to_clips)
-        else:
-            yield from self._generate_examples_non_streaming(filepath, path_to_clips)
-
-    def _generate_examples_non_streaming(self, filepath, path_to_clips):
-
-        data_fields = list(self._info().features.keys())
-
-        # audio is not a header of the csv files
-        data_fields.remove("audio")
-        path_idx = data_fields.index("path")
-
-        with open(filepath, encoding="utf-8") as f:
-            lines = f.readlines()
-            headline = lines[0]
-
-            column_names = headline.strip().split("\t")
-            assert (
-                column_names == data_fields
-            ), f"The file should have {data_fields} as column names, but has {column_names}"
-
-            for id_, line in enumerate(lines[1:]):
-                field_values = line.strip().split("\t")
-
-                # set absolute path for mp3 audio file
-                field_values[path_idx] = os.path.join(path_to_clips, field_values[path_idx])
-
-                # if data is incomplete, fill with empty values
-                if len(field_values) < len(data_fields):
-                    field_values += (len(data_fields) - len(field_values)) * ["''"]
-
-                result = {key: value for key, value in zip(data_fields, field_values)}
-
-                # set audio feature
-                result["audio"] = field_values[path_idx]
-
-                yield id_, result
-
-    def _generate_examples_streaming(self, archive_iterator, filepath, path_to_clips):
-        """Yields examples in streaming mode."""
         data_fields = list(self._info().features.keys())
 
         # audio is not a header of the csv files
@@ -796,8 +761,10 @@ class CommonVoice(datasets.GeneratorBasedBuilder):
 
         all_field_values = {}
         metadata_found = False
+        # Here we iterate over all the files within the TAR archive:
         for path, f in archive_iterator:
-            if path == filepath:
+            # Parse the metadata CSV file
+            if path == metadata_filepath:
                 metadata_found = True
                 lines = f.readlines()
                 headline = lines[0].decode("utf-8")
@@ -811,11 +778,13 @@ class CommonVoice(datasets.GeneratorBasedBuilder):
                     # set full path for mp3 audio file
                     audio_path = "/".join([path_to_clips, field_values[path_idx]])
                     all_field_values[audio_path] = field_values
+            # Else, read the audio file and yield an example
             elif path.startswith(path_to_clips):
                 assert metadata_found, "Found audio clips before the metadata TSV file."
                 if not all_field_values:
                     break
                 if path in all_field_values:
+                    # retrieve the metadata corresponding to this audio file
                     field_values = all_field_values[path]
 
                     # if data is incomplete, fill with empty values
@@ -826,7 +795,7 @@ class CommonVoice(datasets.GeneratorBasedBuilder):
 
                     # set audio feature
                     result["audio"] = {"path": path, "bytes": f.read()}
-                    # set path to None since the path doesn't exist locally in streaming mode
-                    result["path"] = None
+                    # set path to None if the audio file doesn't exist locally (i.e. in streaming mode)
+                    result["path"] = os.path.join(local_extracted_archive, path) if local_extracted_archive else None
 
                     yield path, result