esc-datasets.py

# coding=utf-8
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Lint as: python3
"""ESC benchmark datasets."""

import csv
from collections import defaultdict
import os
import json
import urllib
import re
import logging

import soundfile as sf
import numpy as np
from tqdm.auto import tqdm
import requests
from io import BytesIO
from pathlib import Path
from huggingface_hub import HfApi, HfFolder
import datasets


_DESCRIPTIONS = {
    "ami": """
    The AMI Meeting Corpus is a multi-modal data set consisting of 100 hours of meeting recordings. 
    The AMI Meeting Corpus consists of 100 hours of meeting recordings. The recordings use a range of signals 
    synchronized to a common timeline. These include close-talking and far-field microphones, individual and 
    room-view video cameras, and output from a slide projector and an electronic whiteboard. 
    """,
    "spgispeech": """
    The SPGISpeech corpus is derived from company earnings calls manually transcribed by S&P Global, Inc. 
    according to a professional style guide detailing conventions for capitalization, punctuation, denormalization 
    of non-standard words and tran- scription of disfluencies in spontaneous speech. The basic unit of SPGISpeech is a 
    pair consisting of a 5 to 15 second long 16 bit, 16kHz mono wav audio file and its transcription.
    """,
    "voxpopuli": """
    A large-scale multilingual speech corpus for representation learning, semi-supervised learning and interpretation. 
    The raw data is collected from 2009-2020 European Parliament event recordings. 
    """,
    "tedlium": """
    The TED-LIUM corpus is English-language TED talks, with transcriptions, sampled at 16kHz. 
    All talks and text are property of TED Conferences LLC.
    """,
    "gigaspeech": """
    GigaSpeech is an evolving, multi-domain English speech recognition corpus with 10,000 hours of high quality
    labeled audio suitable for supervised training, and 40,000 hours of total audio suitable for semi-supervised
    and unsupervised training. Around 40,000 hours of transcribed audio is first collected from audiobooks, podcasts
    and YouTube, covering both read and spontaneous speaking styles, and a variety of topics, such as arts, science,
    sports, etc. A new forced alignment and segmentation pipeline is proposed to create sentence segments suitable
    for speech recognition training, and to filter out segments with low-quality transcription. For system training,
    GigaSpeech provides five subsets of different sizes, 10h, 250h, 1000h, 2500h, and 10000h.
    """,
    "librispeech": """
    LibriSpeech is a corpus of approximately 1000 hours of read English speech with sampling rate of 16 kHz,
    prepared by Vassil Panayotov with the assistance of Daniel Povey. The data is derived from read
    audiobooks from the LibriVox project, and has been carefully segmented and aligned.
    """,
    "common_voice": """
    Common Voice is Mozilla's initiative to help teach machines how real people speak. 
    The Common Voice dataset consists of a unique MP3 and corresponding text file. 
    """,
    "earnings22": """
    The Earnings 22 dataset ( also referred to as earnings22 ) is a 119-hour corpus of English-language earnings calls 
    collected from global companies. The primary purpose is to serve as a benchmark for industrial and academic 
    automatic speech recognition (ASR) models on real-world accented speech.
    """
}

_CITATIONS = {
    "ami": """
    @inproceedings{10.1007/11677482_3,
    author = {Carletta, Jean and Ashby, Simone and Bourban, Sebastien and Flynn, Mike and Guillemot, Mael and Hain, Thomas 
    and Kadlec, Jaroslav and Karaiskos, Vasilis and Kraaij, Wessel and Kronenthal, Melissa and Lathoud, Guillaume 
    and Lincoln, Mike and Lisowska, Agnes and McCowan, Iain and Post, Wilfried and Reidsma, Dennis and Wellner, Pierre},
    title = {The AMI Meeting Corpus: A Pre-Announcement},
    year = {2005},
    isbn = {3540325492},
    publisher = {Springer-Verlag},
    address = {Berlin, Heidelberg},
    url = {https://doi.org/10.1007/11677482_3},
    doi = {10.1007/11677482_3},
    booktitle = {Proceedings of the Second International Conference on Machine Learning for Multimodal Interaction},
    pages = {28–39},
    numpages = {12},
    location = {Edinburgh, UK},
    series = {MLMI'05}
    }
    """,
    "spgispeech": """
    @article{2021arXiv210402014O,
    author = {{O'Neill}, Patrick K. and {Lavrukhin}, Vitaly and {Majumdar}, Somshubra and {Noroozi}, Vahid and {Zhang}, Yuekai 
    and {Kuchaiev}, Oleksii and {Balam}, Jagadeesh and {Dovzhenko}, Yuliya and {Freyberg}, Keenan and {Shulman}, Michael D. 
    and {Ginsburg}, Boris and {Watanabe}, Shinji and {Kucsko}, Georg},
    title = "{SPGISpeech: 5,000 hours of transcribed financial audio for fully formatted end-to-end speech recognition}",
    journal = {arXiv e-prints},
    keywords = {Computer Science - Computation and Language, Electrical Engineering and Systems Science - Audio and Speech Processing},
    year = 2021,
    month = apr,
    eid = {arXiv:2104.02014},
    pages = {arXiv:2104.02014},
    eprint = {2104.02014},
    primaryClass = {cs.CL},
    adsurl = {https://ui.adsabs.harvard.edu/abs/2021arXiv210402014O},
    adsnote = {Provided by the SAO/NASA Astrophysics Data System}
    }
    """,
    "voxpopuli": """
    @inproceedings{wang-etal-2021-voxpopuli,
    title = "{V}ox{P}opuli: A Large-Scale Multilingual Speech Corpus for Representation Learning, 
    Semi-Supervised Learning and Interpretation",
    author = "Wang, Changhan  and Riviere, Morgane  and Lee, Ann  and Wu, Anne  and Talnikar, Chaitanya  and Haziza, 
    Daniel  and Williamson, Mary  and Pino, Juan  and Dupoux, Emmanuel",
    booktitle = "Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th 
    International Joint Conference on Natural Language Processing (Volume 1: Long Papers)",
    month = aug,
    year = "2021",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.acl-long.80",
    doi = "10.18653/v1/2021.acl-long.80",
    pages = "993--1003",
    }
    """,
    "tedlium": """
    @inproceedings{hernandez2018tedlium3,
    title={TED-LIUM 3: twice as much data and corpus repartition for experiments on speaker adaptation},
    author={Hernandez, Fran{\\c{c}}ois and Nguyen, Vincent and Ghannay, Sahar and Tomashenko, Natalia and Est{\\`e}ve, Yannick},
    booktitle={International Conference on Speech and Computer},
    pages={198--208},
    year={2018},
    organization={Springer}
    }
    """,
    "gigaspeech": """
    @article{DBLP:journals/corr/abs-2106-06909,
    author    = {Guoguo Chen and Shuzhou Chai and Guanbo Wang and Jiayu Du and Wei{-}Qiang Zhang and Chao Weng and Dan Su 
    and Daniel Povey and Jan Trmal and Junbo Zhang and Mingjie Jin and Sanjeev Khudanpur and Shinji Watanabe and 
    Shuaijiang Zhao and Wei Zou and Xiangang Li and Xuchen Yao and Yongqing Wang and Yujun Wang and Zhao You and Zhiyong Yan},
    title     = {GigaSpeech: An Evolving, Multi-domain {ASR} Corpus with 10, 000 Hours
               of Transcribed Audio},
    journal   = {CoRR},
    volume    = {abs/2106.06909},
    year      = {2021},
    url       = {https://arxiv.org/abs/2106.06909},
    eprinttype = {arXiv},
    eprint    = {2106.06909},
    timestamp = {Wed, 29 Dec 2021 14:29:26 +0100},
    biburl    = {https://dblp.org/rec/journals/corr/abs-2106-06909.bib},
    bibsource = {dblp computer science bibliography, https://dblp.org}
    }
    """,
    "librispeech": """
    @inproceedings{panayotov2015librispeech,
    title={Librispeech: an ASR corpus based on public domain audio books},
    author={Panayotov, Vassil and Chen, Guoguo and Povey, Daniel and Khudanpur, Sanjeev},
    booktitle={Acoustics, Speech and Signal Processing (ICASSP), 2015 IEEE International Conference on},
    pages={5206--5210},
    year={2015},
    organization={IEEE}
    }
    """,
    "common_voice": """
    @inproceedings{commonvoice:2020,
    author = {Ardila, R. and Branson, M. and Davis, K. and Henretty, M. and Kohler, M. and Meyer, J. and Morais, R. and Saunders, L. and Tyers, F. M. and Weber, G.},
    title = {Common Voice: A Massively-Multilingual Speech Corpus},
    booktitle = {Proceedings of the 12th Conference on Language Resources and Evaluation (LREC 2020)},
    pages = {4211--4215},
    year = 2020
    }
    """,
    "earnings22": """
    @misc{https://doi.org/10.48550/arxiv.2203.15591,
    doi = {10.48550/ARXIV.2203.15591},
    url = {https://arxiv.org/abs/2203.15591},
    author = {Del Rio, Miguel and Ha, Peter and McNamara, Quinten and Miller, Corey and Chandra, Shipra},
    keywords = {Computation and Language (cs.CL), FOS: Computer and information sciences, FOS: Computer and information sciences},
    title = {Earnings-22: A Practical Benchmark for Accents in the Wild},
    publisher = {arXiv},
    year = {2022},
    copyright = {Creative Commons Attribution Share Alike 4.0 International}
    }
    """,
}

_HOMEPAGE_URLS = {
    "ami": "https://groups.inf.ed.ac.uk/ami/corpus/",
    "spgispeech": "https://datasets.kensho.com/datasets/spgispeech",
    "voxpopuli": "https://github.com/facebookresearch/voxpopuli",
    "tedlium": "https://www.openslr.org/51/",
    "gigaspeech": "https://github.com/SpeechColab/GigaSpeech",
    "librispeech": "http://www.openslr.org/12",
    "common_voice": "https://commonvoice.mozilla.org/en/datasets",
    "earnings22": "https://github.com/revdotcom/speech-datasets/tree/main/earnings22",
}

_LICENSES = {
    "ami": "CC BY 4.0",
    "spgispeech": "Custom license (academic use only)",
    "voxpopuli": "CC0, also see https://www.europarl.europa.eu/legal-notice/en/",
    "tedlium": "Creative Commons BY-NC-ND 3.0 (http://creativecommons.org/licenses/by-nc-nd/3.0/deed.en)",
    "gigaspeech": "Apache License 2.0",
    "librispeech": "CC BY 4.0",
    "common_voice": "Mozilla Public License 2.0 (https://github.com/common-voice/common-voice/blob/main/LICENSE)",
    "earnings22": "CC BY-SA 4.0",
}

_DATASET_TO_CONFIGS = {
    "spgispeech": ["l", "s", "m"],
    "gigaspeech": ["l", "xs", "s", "m", "xl"],
    "librispeech": ["default", "clean.100", "clean.360", "other.500"],
}

_ALL_CONFIGS = list(_DATASET_TO_CONFIGS) + ["earnings22", "ami", "tedlium", "voxpopuli", "common_voice"]


class ESCConfig(datasets.BuilderConfig):
    """BuilderConfig for ESC benchmark dataset. """

    def __init__(self, name, subconfig, description, citation, homepage, license, **kwargs):
        """
        Args:
          name: `string`, name of a dataset to be downloaded (for example, "gigaspeech")
          subconfig: `string`, specific configuration of a dataset, relevant for "spgispeech", "gigaspeech", and "librispeech"
          description: `string`: dataset decsription
          citation: `string`: dataset citation
          homepage: `string`: dataset homepage
          license: `string`: dataset license
          **kwargs: keyword arguments forwarded to super.
        """
        if name in _DATASET_TO_CONFIGS:
            # first config is the default one
            self.subconfig = _DATASET_TO_CONFIGS[name][0] if subconfig == "default" else subconfig
        else:
            self.subconfig = None

        super(ESCConfig, self).__init__(
            name=name,
            version=datasets.Version("1.0.0", ""),
            **kwargs
        )
        self.description = description
        self.citation = citation
        self.homepage = homepage
        self.license = license


def _build_config(name, subconfig):
    return ESCConfig(
        name=name,
        subconfig=subconfig,
        description=_DESCRIPTIONS[name],
        citation=_CITATIONS[name],
        homepage=_HOMEPAGE_URLS[name],
        license=_LICENSES[name],
    )


class ESCDatasets(datasets.GeneratorBasedBuilder):
    """ESC benchmark dataset dataset."""

    DEFAULT_WRITER_BATCH_SIZE = 256
    BUILDER_CONFIGS = [
        _build_config(name, subconfig="default") for name in _ALL_CONFIGS
    ]

    def _info(self):
        features = datasets.Features(
                    {
                        "audio": datasets.Audio(sampling_rate=16_000),
                        "dataset": datasets.Value("string"),
                        "text": datasets.Value("string"),
                        "id": datasets.Value("string"),
                    }
                )
        return datasets.DatasetInfo(  # TODO: add benchmark's own license and description
                features=features,
                description=self.config.description,
                homepage=self.config.homepage,
                license=self.config.license,
                citation=self.config.citation,
            )

    def _split_generators(self, dl_manager):
        if self.config.name == "ami":
            return self._ami_split_generators(dl_manager)
        elif self.config.name == "spgispeech":
            return self._spgispeech_split_generators(dl_manager)
        elif self.config.name == "voxpopuli":
            return self._voxpopuli_split_generators(dl_manager)
        elif self.config.name == "tedlium":
            return self._tedlium_split_generators(dl_manager)
        elif self.config.name == "gigaspeech":
            return self._gigaspeech_split_generators(dl_manager)
        elif self.config.name == "librispeech":
            return self._librispeech_split_generators(dl_manager)
        elif self.config.name == "common_voice":
            return self._common_voice_split_generators(dl_manager)
        elif self.config.name == "earnings22":
            return self._earnings_split_generators(dl_manager)

    def _generate_examples(self, *args, **kwargs):
        if self.config.name == "ami":
            yield from self._ami_generate_examples(*args, **kwargs)
        elif self.config.name == "spgispeech":
            yield from self._spgispeech_generate_examples(*args, **kwargs)
        elif self.config.name == "voxpopuli":
            yield from self._voxpopuli_generate_examples(*args, **kwargs)
        elif self.config.name == "tedlium":
            yield from self._tedlium_generate_examples(*args, **kwargs)
        elif self.config.name == "gigaspeech":
            yield from self._gigaspeech_generate_examples(*args, **kwargs)
        elif self.config.name == "librispeech":
            yield from self._librispeech_generate_examples(*args, **kwargs)
        elif self.config.name == "common_voice":
            yield from self._common_voice_generate_examples(*args, **kwargs)
        elif self.config.name == "earnings22":
            yield from self._earnings_generate_examples(*args, **kwargs)

    def _ami_split_generators(self, dl_manager):
        splits = ["train", "dev", "eval"]

        audio_archives_urls = {}
        for split in splits:
            audio_archives_urls[split] = [
                _AMI_AUDIO_ARCHIVE_URL.format(split=split, _id=m) for m in _AMI_SAMPLE_IDS[split]
            ]

        audio_archives = dl_manager.download(audio_archives_urls)
        local_extracted_archives_paths = dl_manager.extract(audio_archives) if not dl_manager.is_streaming else {
            split: [None] * len(audio_archives[split]) for split in splits
        }

        annotations_urls = {split: _AMI_ANNOTATIONS_ARCHIVE_URL.format(split=split) for split in splits}
        annotations = dl_manager.download(annotations_urls)

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "audio_archives": [dl_manager.iter_archive(archive) for archive in audio_archives["train"]],
                    "local_extracted_archives_paths": local_extracted_archives_paths["train"],
                    "annotation": annotations["train"],
                    "split": "train"
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={
                    "audio_archives": [dl_manager.iter_archive(archive) for archive in audio_archives["dev"]],
                    "local_extracted_archives_paths": local_extracted_archives_paths["dev"],
                    "annotation": annotations["dev"],
                    "split": "dev"
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "audio_archives": [dl_manager.iter_archive(archive) for archive in audio_archives["eval"]],
                    "local_extracted_archives_paths": local_extracted_archives_paths["eval"],
                    "annotation": annotations["eval"],
                    "split": "eval"
                },
            ),
        ]

    def _ami_generate_examples(self, audio_archives, local_extracted_archives_paths, annotation, split):
        assert len(audio_archives) == len(local_extracted_archives_paths)

        with open(annotation, "r", encoding="utf-8") as f:
            transcriptions = {}
            for line in f.readlines():
                line_items = line.strip().split()
                _id = line_items[0]
                text = " ".join(line_items[1:])
                _, meeting_id, microphone_id, speaker_id, begin_time, end_time = _id.split("_")
                audio_filename = "_".join([split, _id.lower()]) + ".wav"

                transcriptions[audio_filename] = {
                    "id": _id,
                    "text": text if split != "eval" else "",
                }

        features = ["id", "text"]
        for archive, local_archive_path in zip(audio_archives, local_extracted_archives_paths):
            for audio_path, audio_file in archive:
                # audio_path is like 'EN2001a/train_ami_en2001a_h00_mee068_0414915_0415078.wav'
                audio_meta = transcriptions[audio_path.split("/")[-1]]

                yield audio_path, {
                    "audio": {
                        "path": os.path.join(local_archive_path, audio_path) if local_archive_path else audio_path,
                        "bytes": audio_file.read(),
                    },
                    "dataset": "ami",
                    **{feature: audio_meta[feature] for feature in features}
                }

    def _spgispeech_split_generators(self, dl_manager):
        subconfig = self.config.subconfig
        subsets = [subconfig] + ["dev", "test"]

        meta_path = dl_manager.download_and_extract(
            {subset: os.path.join(_SPGISPEECH_META_BASE_URL, _SPGISPEECH_META_FILENAMES[subset]) for subset in subsets}
        )

        archive_urls = defaultdict(list)
        for subset in subsets:
            for subset_dir in _SPGISPEECH_SUBSET_TO_DIR[subset]:
                for archive_name in _SPGISPEECH_AUDIO_ARCHIVES_NAMES[subset_dir]:
                    archive_urls[subset].append(os.path.join(_SPGISPEECH_AUDIO_BASE_URL, subset_dir, archive_name))

        archive_paths = dl_manager.download(archive_urls)

        local_extracted_archive_paths = (
            dl_manager.extract(archive_paths)
            if not dl_manager.is_streaming
            else {subset: [None] * len(archive_paths[subset]) for subset in subsets}
        )

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "local_extracted_archive_paths": local_extracted_archive_paths[subconfig],
                    "archives": [dl_manager.iter_archive(path) for path in archive_paths[subconfig]],
                    "meta_path": meta_path[subconfig],
                    "is_test": False,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={
                    "local_extracted_archive_paths": local_extracted_archive_paths["dev"],
                    "archives": [dl_manager.iter_archive(path) for path in archive_paths["dev"]],
                    "meta_path": meta_path["dev"],
                    "is_test": False,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "local_extracted_archive_paths": local_extracted_archive_paths["test"],
                    "archives": [dl_manager.iter_archive(path) for path in archive_paths["test"]],
                    "meta_path": meta_path["test"],
                    "is_test": True,
                },
            ),
        ]

    def _spgispeech_generate_examples(self, local_extracted_archive_paths, archives, meta_path, is_test):
        # define the expected metadata dict keys,
        # some files have metadata with erroneous entries that we have to filter out
        dict_keys = {"id": "wav_filename", "text": "transcript"}

        logging.info("Reading spgispeech metadata")
        with open(meta_path, encoding="utf-8") as f:
            csvreader = csv.DictReader(f, delimiter="|")
            metadata = {x["wav_filename"]: dict((k, x[v]) for k, v in dict_keys.items()) for x in tqdm(csvreader, leave=False)}

        for local_extracted_archive_path, archive in zip(local_extracted_archive_paths, archives):
            # Here we iterate over all the files within the TAR archive:
            for audio_filename, audio_file in archive:
                audio_filename = audio_filename.lstrip("./")
                # if an audio file exists locally (i.e. in default, non-streaming mode) set the full path to it
                # joining path to directory that the archive was extracted to and audio filename.
                path = (
                    os.path.join(local_extracted_archive_path, audio_filename)
                    if local_extracted_archive_path
                    else audio_filename
                )
                # get the .wav filename by removing the directory path from the audio filename
                wav_filename = "/".join(audio_filename.split("/")[-2:])
                example = dict(metadata[wav_filename])
                if is_test: example["text"] = ""
                example["audio"] = {"path": path, "bytes": audio_file.read()}
                example["dataset"] = "spgispeech"
                yield audio_filename, example

    def _voxpopuli_split_generators(self, dl_manager):
        n_shards_path = dl_manager.download_and_extract(_VOXPOPULI_N_SHARDS_FILE)
        with open(n_shards_path) as f:
            n_shards = json.load(f)["en"]  # we use only English language in this benchmark
        splits = ["train", "dev", "test"]

        audio_urls = {}
        for split in splits:
            audio_urls[split] = [
                _VOXPOPULI_AUDIO_ARCHIVE_PATH.format(split=split, n_shard=i) for i in range(n_shards[split])
            ]

        meta_urls = {
            split: _VOXPOPULI_METADATA_PATH.format(split=split) for split in splits
        }

        dl_manager.download_config.num_proc = len(audio_urls["train"]) // 4
        meta_paths = dl_manager.download_and_extract(meta_urls)
        audio_paths = dl_manager.download(audio_urls)

        local_extracted_audio_paths = (
            dl_manager.extract(audio_paths) if not dl_manager.is_streaming else
            {
                split: [None] * len(audio_paths[split]) for split in splits
            }
        )
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "audio_archives": [dl_manager.iter_archive(archive) for archive in audio_paths["train"]],
                    "local_extracted_archives_paths": local_extracted_audio_paths["train"],
                    "meta_path": meta_paths["train"],
                    "is_test": False,
                }
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={
                    "audio_archives": [dl_manager.iter_archive(archive) for archive in audio_paths["dev"]],
                    "local_extracted_archives_paths": local_extracted_audio_paths["dev"],
                    "meta_path": meta_paths["dev"],
                    "is_test": False,
                }
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "audio_archives": [dl_manager.iter_archive(archive) for archive in audio_paths["test"]],
                    "local_extracted_archives_paths": local_extracted_audio_paths["test"],
                    "meta_path": meta_paths["test"],
                    "is_test": True,
                }
            ),
        ]

    def _voxpopuli_generate_examples(self, audio_archives, local_extracted_archives_paths, meta_path, is_test):
        assert len(audio_archives) == len(local_extracted_archives_paths)

        logging.info("Reading voxpopuli metadata.")
        with open(meta_path) as f:
            metadata = {x["id"]: x for x in tqdm(csv.DictReader(f, delimiter="\t"), leave=False)}

        for audio_archive, local_extracted_archive_path in zip(audio_archives, local_extracted_archives_paths):
            for audio_filename, audio_file in audio_archive:
                audio_id = audio_filename.split(os.sep)[-1].split(".wav")[0]
                path = os.path.join(local_extracted_archive_path, audio_filename) if local_extracted_archive_path else audio_filename

                yield audio_id, {
                    "id": audio_id,
                    "text": metadata[audio_id]["normalized_text"].lower() if not is_test else "",
                    "audio": {"path": path, "bytes": audio_file.read()},
                    "dataset": "voxpopuli",
                }

    def _librispeech_split_generators(self, dl_manager):
        dev_splits, test_splits = ["dev.clean", "dev.other"], ["test.clean", "test.other"]
        train_splits = ["train.clean.100", "train.clean.360", "train.other.500"] \
            if self.config.subconfig == "default" else [f"train.{self.config.subconfig}"]
        dl_urls = {config_name: _LIBRISPEECH_DL_URLS[config_name] for config_name in train_splits + dev_splits + test_splits}
        archive_paths = dl_manager.download(dl_urls)
        # (Optional) In non-streaming mode, we can extract the archive locally to have actual local audio files:
        local_extracted_archives = dl_manager.extract(archive_paths) if not dl_manager.is_streaming else {}
        train_split = [
            datasets.SplitGenerator(
                name="train",
                gen_kwargs={
                    "local_extracted_archives": [local_extracted_archives.get(train_name) for train_name in train_splits],
                    "archives": [dl_manager.iter_archive(archive_paths[train_name]) for train_name in train_splits],
                    "is_test": False,
                },
            )
        ]
        dev_splits = [
            datasets.SplitGenerator(
                name="validation.clean",
                gen_kwargs={
                    "local_extracted_archives": [local_extracted_archives.get("dev.clean")],
                    "archives": [dl_manager.iter_archive(archive_paths["dev.clean"])],
                    "is_test": False,
                },
            ),
            datasets.SplitGenerator(
                name="validation.other",
                gen_kwargs={
                    "local_extracted_archives": [local_extracted_archives.get("dev.other")],
                    "archives": [dl_manager.iter_archive(archive_paths["dev.other"])],
                    "is_test": False,
                },
            ),
        ]
        test_splits = [
            datasets.SplitGenerator(
                name="test.clean",
                gen_kwargs={
                    "local_extracted_archives": [local_extracted_archives.get("test.clean")],
                    "archives": [dl_manager.iter_archive(archive_paths["test.clean"])],
                    "is_test": True,
                },
            ),
            datasets.SplitGenerator(
                name="test.other",
                gen_kwargs={
                    "local_extracted_archives": [local_extracted_archives.get("test.other")],
                    "archives": [dl_manager.iter_archive(archive_paths["test.other"])],
                    "is_test": True,
                },
            ),
        ]
        return train_split + dev_splits + test_splits

    def _librispeech_generate_examples(self, archives, local_extracted_archives, is_test):
        key = 0
        audio_data = {}
        transcripts = []
        for archive, local_extracted_archive in zip(archives, local_extracted_archives):
            for path, f in archive:
                if path.endswith(".flac"):
                    id_ = path.split("/")[-1][: -len(".flac")]
                    audio_data[id_] = f.read()
                elif path.endswith(".trans.txt"):
                    for line in f:
                        if line:
                            line = line.decode("utf-8").strip()
                            id_, transcript = line.split(" ", 1)

                            # Error correction
                            transcript = transcript.lower()

                            audio_file = f"{id_}.flac"
                            audio_file = (
                                os.path.join(local_extracted_archive, audio_file)
                                if local_extracted_archive
                                else audio_file
                            )
                            transcripts.append(
                                {
                                    "id": id_,
                                    "file": audio_file,
                                    "text": transcript if not is_test else "",
                                }
                            )
                if audio_data and len(audio_data) == len(transcripts):
                    for transcript in transcripts:
                        audio = {"path": transcript["file"], "bytes": audio_data[transcript["id"]]}
                        del transcript["file"]
                        yield key, {"audio": audio, "dataset": "librispeech", **transcript}
                        key += 1
                    audio_data = {}
                    transcripts = []

    def _common_voice_get_bundle_url(self, locale, url_template):
        # path = encodeURIComponent(path)
        path = url_template.replace("{locale}", locale)
        path = urllib.parse.quote(path.encode("utf-8"), safe="~()*!.'")
        # use_cdn = self.config.size_bytes < 20 * 1024 * 1024 * 1024
        # response = requests.get(f"{_API_URL}/bucket/dataset/{path}/{use_cdn}", timeout=10.0).json()
        response = requests.get(f"{_COMMON_VOICE_API_URL}/bucket/dataset/{path}", timeout=10.0).json()
        return response["url"]

    def _common_voice_log_download(self, locale, bundle_version, auth_token):
        if isinstance(auth_token, bool):
            auth_token = HfFolder().get_token()
        whoami = HfApi().whoami(auth_token)
        email = whoami["email"] if "email" in whoami else ""
        payload = {"email": email, "locale": locale, "dataset": bundle_version}
        requests.post(f"{_COMMON_VOICE_API_URL}/{locale}/downloaders", json=payload).json()

    def _common_voice_split_generators(self, dl_manager):
        """Returns SplitGenerators."""
        hf_auth_token = dl_manager.download_config.use_auth_token
        if hf_auth_token is None:
            raise ConnectionError(
                "Please set use_auth_token=True or use_auth_token='<TOKEN>' to download this dataset"
            )

        bundle_version = _COMMON_VOICE_BUNDLE_URL_TEMPLATE.split("/")[0]
        dl_manager.download_config.ignore_url_params = True

        self._common_voice_log_download("en", bundle_version, hf_auth_token)
        archive_path = dl_manager.download(self._common_voice_get_bundle_url("en", _COMMON_VOICE_BUNDLE_URL_TEMPLATE))
        local_extracted_archive = dl_manager.extract(archive_path) if not dl_manager.is_streaming else None

        path_to_data = "/".join([bundle_version, "en"])
        path_to_clips = "/".join([path_to_data, "clips"]) if path_to_data else "clips"

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "local_extracted_archive": local_extracted_archive,
                    "archive_iterator": dl_manager.iter_archive(archive_path),
                    "metadata_filepath": "/".join([path_to_data, "train.tsv"]) if path_to_data else "train.tsv",
                    "path_to_clips": path_to_clips,
                    "is_test": False,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={
                    "local_extracted_archive": local_extracted_archive,
                    "archive_iterator": dl_manager.iter_archive(archive_path),
                    "metadata_filepath": "/".join([path_to_data, "dev.tsv"]) if path_to_data else "dev.tsv",
                    "path_to_clips": path_to_clips,
                    "is_test": False,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "local_extracted_archive": local_extracted_archive,
                    "archive_iterator": dl_manager.iter_archive(archive_path),
                    "metadata_filepath": "/".join([path_to_data, "test.tsv"]) if path_to_data else "test.tsv",
                    "path_to_clips": path_to_clips,
                    "is_test": True,
                },
            ),
        ]

    def _common_voice_generate_examples(
        self,
        local_extracted_archive,
        archive_iterator,
        metadata_filepath,
        path_to_clips,
        is_test,
    ):
        """Yields examples."""
        data_fields = list(self._info().features.keys())
        metadata = {}
        metadata_found = False
        for path, f in archive_iterator:
            if path == metadata_filepath:
                metadata_found = True
                lines = (line.decode("utf-8") for line in f)
                reader = csv.DictReader(lines, delimiter="\t", quoting=csv.QUOTE_NONE)
                for row in reader:
                    # set absolute path for mp3 audio file
                    if not row["path"].endswith(".mp3"):
                        row["path"] += ".mp3"
                    row["path"] = os.path.join(path_to_clips, row["path"])
                    # accent -> accents in CV 8.0
                    if "accents" in row:
                        row["accent"] = row["accents"]
                        del row["accents"]
                    # if data is incomplete, fill with empty values
                    for field in data_fields:
                        if field not in row:
                            row[field] = ""
                    metadata[row["path"]] = row
            elif path.startswith(path_to_clips):
                assert metadata_found, "Found audio clips before the metadata TSV file."
                if not metadata:
                    break
                if path in metadata:
                    dict_result = dict(metadata[path])
                    # set the audio feature and the path to the extracted file
                    path = os.path.join(local_extracted_archive, path) if local_extracted_archive else path
                    result = {"id": dict_result["client_id"], "dataset": "common_voice",
                              "audio": {"path": path, "bytes": f.read()}}

                    # Error correction
                    text = dict_result["sentence"]
                    if text.startswith('"') and text.endswith('"'):
                        # we can remove trailing quotation marks as they do not affect the transcription
                        text = text[1:-1]
                    # replace double quotation marks with single
                    text = text.replace('""', '"')
                    result["text"] = text if not is_test else ""

                    yield path, result

    def _tedlium_split_generators(self, dl_manager):
        archive_path = dl_manager.download(_TEDLIUM_URLS)
        # (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 {}
        split_paths = [
                          (datasets.Split.TRAIN, "train"),
                          (datasets.Split.VALIDATION, "dev"),
                          (datasets.Split.TEST, "test"),
                      ]
        splits = []
        for split, split_name in split_paths:
            kwargs = {
                "filepath": [dl_manager.iter_archive(sharded_path) for sharded_path in archive_path[split_name]],
                "local_extracted_archive": local_extracted_archive.get(split_name),
                "split_path": split_name,
            }
            splits.append(datasets.SplitGenerator(name=split, gen_kwargs=kwargs))
        return splits

    def _tedlium_generate_examples(self, filepath, local_extracted_archive, split_path):
        """Generate examples from a TED-LIUM stm file."""
        if local_extracted_archive:
            for local_archive in local_extracted_archive:
                # The stm directory houses the speaker and transcription information in .stm format
                split_dir = os.path.join(local_archive, split_path)
                stm_files = [os.path.join(split_dir, f) for f in os.listdir(split_dir) if f.endswith(".stm")]
                for file in stm_files:
                    # the .sph speaker file almost always has the same file name as the .stm file
                    speaker_file = Path(file).stem
                    audio_file = os.path.join(split_dir, speaker_file + ".sph")
                    segment, sampling_rate = sf.read(audio_file, dtype=np.int16)
                    with open(file) as f:
                        for line in f:
                            line = line.strip()
                            fn, channel, speaker, start, end, label, transcript = line.split(" ", 6)
                            transcript = _maybe_trim_suffix(transcript)

                            # Error correction
                            transcript = transcript.lower()
                            if transcript in ignore_segments:
                                continue
                            # delete the <unk> token from the text
                            transcript = transcript.replace("<unk>", "")
                            # replace spaced apostrophes with un-spaced (it 's -> it's)
                            for contraction in tedlium_contractions:
                                transcript = transcript.replace(contraction, contraction[1:])
                            # JIWER compliance (for WER/CER calc.)
                            # remove multiple spaces
                            transcript = re.sub(r"\s\s+", " ", transcript)
                            # strip trailing spaces
                            transcript = transcript.strip()
                            if len(transcript) == 0:
                                continue

                            if speaker_file != fn:
                                # handle the case where the stm file does not have the same file name as the transcript
                                speaker_file = fn
                                audio_file = os.path.join(split_dir, speaker_file + ".sph")
                                segment, sampling_rate = sf.read(audio_file, dtype=np.int16)
                            samples = _extract_audio_segment(segment, sampling_rate, float(start), float(end))
                            key = "-".join([speaker, start, end, label])
                            example = {
                                "audio": {"path": audio_file, "array": samples, "sampling_rate": sampling_rate},
                                "text": transcript if split_path != "test" else "",
                                "id": key,
                                "dataset": "tedlium",
                            }
                            yield key, example

        else:
            audio_data = {}
            transcripts = defaultdict(list)
            for file in filepath:
                for path, f in file:
                    if path.endswith(".sph"):
                        # get the speaker id
                        fn = path.split("/")[-1].strip(".sph")
                        # read the audio data from raw byte form and add key-value pair to dict
                        audio_data[fn] = sf.read(BytesIO(f.read()), dtype=np.int16)
                    elif path.endswith(".stm"):
                        for line in f:
                            if line:
                                line = line.decode("utf-8").strip()
                                fn, channel, speaker, start, end, label, transcript = line.split(" ", 6)
                                transcript = _maybe_trim_suffix(transcript)

                                # Error correction
                                transcript = transcript.lower()
                                if transcript in ignore_segments:
                                    continue
                                # delete the <unk> token from the text
                                transcript = transcript.replace("<unk>", "")
                                # replace spaced apostrophes with un-spaced (it 's -> it's)
                                for contraction in tedlium_contractions:
                                    transcript = transcript.replace(contraction, contraction[1:])
                                # JIWER compliance (for WER/CER calc.)
                                # remove multiple spaces
                                transcript = re.sub(r"\s\s+", " ", transcript)
                                # strip trailing spaces
                                transcript = transcript.strip()
                                if len(transcript) == 0:
                                    continue

                                audio_file = path.replace("stm", "sph")
                                key = "-".join([speaker, start, end, label])
                                # append metadata information to the dict of transcripts for the associated speaker
                                transcripts[fn].append(
                                    {
                                        "text": transcript,
                                        "file": audio_file,
                                        "id": key,
                                        "start": start,
                                        "end": end,
                                        "channel": channel,
                                        "fn": fn,
                                    }
                                )

                    if audio_data and audio_data.keys() == transcripts.keys():
                        for fn, speaker in transcripts.items():
                            for transcript in speaker:
                                segment, sampling_rate = audio_data[transcript["fn"]]
                                samples = _extract_audio_segment(
                                    segment,
                                    sampling_rate,
                                    float(transcript["start"]),
                                    float(transcript["end"]),
                                )
                                audio = {"path": transcript["file"], "array": samples,
                                         "sampling_rate": sampling_rate}
                                key = transcript["id"]
                                yield key, {
                                    "audio": audio,
                                    "text": transcript["text"] if split_path != "test" else "",
                                    "dataset": "tedlium",
                                    "id": transcript["id"],
                                }
                        audio_data = {}
                        transcripts = defaultdict(list)

    def _gigaspeech_split_generators(self, dl_manager):
        splits_to_configs = {
            "train": _GIGASPEECH_CONFIGS_TO_ALL_CONFIGS[self.config.subconfig],
            "dev": ["dev"],
            "test": ["test"],
        }

        # 1. prepare sharded archives with audio files
        audio_archives_urls = defaultdict(list)
        for split, subsets in splits_to_configs.items():
            for subset in subsets:
                audio_archives_urls[split].extend(
                    [
                        _GIGASPEECH_AUDIO_ARCHIVE_URL.format(subset=subset, is_additional=_is_additional(subset),
                                                             archive_id=i)
                        for i in range(_GIGASPEECH_N_ARCHIVES[subset])
                    ]
                )
        audio_archives_paths = dl_manager.download(audio_archives_urls)
        local_audio_archives_paths = dl_manager.extract(audio_archives_paths) if not dl_manager.is_streaming \
            else {}

        # 2. prepare sharded metadata csv files
        meta_urls = defaultdict(list)
        for split, subsets in splits_to_configs.items():
            for subset in subsets:
                meta_urls[split].extend(
                    [
                        _GIGASPEECH_META_URL.format(subset=subset, is_additional=_is_additional(subset), archive_id=i)
                        for i in range(_GIGASPEECH_N_ARCHIVES[subset])
                    ]
                )
        meta_paths = dl_manager.download_and_extract(meta_urls)

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "audio_archives_iterators": [
                        dl_manager.iter_archive(archive_path) for archive_path in audio_archives_paths["train"]
                    ],
                    "local_audio_archives_paths": local_audio_archives_paths.get("train"),
                    "meta_paths": meta_paths["train"],
                    "is_test": False,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={
                    "audio_archives_iterators": [
                        dl_manager.iter_archive(archive_path) for archive_path in audio_archives_paths["dev"]
                    ],
                    "local_audio_archives_paths": local_audio_archives_paths.get("dev"),
                    "meta_paths": meta_paths["dev"],
                    "is_test": False,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "audio_archives_iterators": [
                        dl_manager.iter_archive(archive_path) for archive_path in audio_archives_paths["test"]
                    ],
                    "local_audio_archives_paths": local_audio_archives_paths.get("test"),
                    "meta_paths": meta_paths["test"],
                    "is_test": True,
                },
            ),
        ]

    def _gigaspeech_generate_examples(self, audio_archives_iterators, local_audio_archives_paths, meta_paths, is_test):
        assert len(audio_archives_iterators) == len(meta_paths)
        if local_audio_archives_paths:
            assert len(audio_archives_iterators) == len(local_audio_archives_paths)

        for i, (meta_path, audio_archive_iterator) in enumerate(zip(meta_paths, audio_archives_iterators)):
            meta_dict = dict()
            with open(meta_path) as csvfile:
                meta_csv = csv.DictReader(csvfile)
                for line in meta_csv:
                    meta_dict[line["sid"]] = line

            for audio_path_in_archive, audio_file in audio_archive_iterator:
                # `audio_path_in_archive` is like "dev_chunks_0000/YOU1000000029_S0000095.wav"
                audio_filename = os.path.split(audio_path_in_archive)[1]
                audio_id = audio_filename.split(".wav")[0]
                audio_meta = meta_dict[audio_id]
                audio_meta["id"] = audio_meta.pop("sid")
                text = audio_meta.pop("text_tn")

                # Error correction
                text = text.lower()
                if text in ignore_segments:
                    continue
                for junk_token in gigaspeech_junk_tokens:
                    text = text.replace(junk_token, "")
                # convert spelled out punctuation to symbolic form
                for punctuation, replacement in gigaspeech_punctuation.items():
                    text = text.replace(punctuation, replacement)
                # JIWER compliance (for WER/CER calc.)
                # remove multiple spaces
                text = re.sub(r"\s\s+", " ", text)
                # strip trailing spaces
                text = text.strip()
                if len(text) == 0:
                    continue

                audio_meta["text"] = text if not is_test else ""

                path = os.path.join(local_audio_archives_paths[i], audio_path_in_archive) if local_audio_archives_paths \
                    else audio_path_in_archive

                yield audio_id, {
                    "audio": {"path": path, "bytes": audio_file.read()},
                    "dataset": "gigaspeech",
                    **{feature: value for feature, value in audio_meta.items() if feature in self.info.features}
                }

    def _earnings_split_generators(self, dl_manager):
        meta_url = _EARNINGS_BASE_URL + "metadata.csv"
        meta_path = dl_manager.download_and_extract(meta_url)

        with open(meta_path, encoding="utf-8") as f:
            csvreader = csv.DictReader(f, delimiter=",")
            metadata, all_ids = {}, set()
            for row in csvreader:
                all_ids.update([row["source_id"]])
                metadata[row["file"]] = row["sentence"]  # we need only text in this benchmark

        train_ids = all_ids - _EARNINGS_DEV_IDS - _EARNINGS_TEST_IDS
        split_to_ids = {"train": train_ids, "dev": _EARNINGS_DEV_IDS, "test": _EARNINGS_TEST_IDS}

        dl_urls = {}
        for split, split_ids in split_to_ids.items():
            dl_urls[split] = [_EARNINGS_BASE_URL + f"data/{source_id}.tar.gz" for source_id in split_ids]
        archive_paths = dl_manager.download(dl_urls)

        local_extracted_archive_paths = (
            dl_manager.extract(archive_paths)
            if not dl_manager.is_streaming
            else {split: [None] * len(archive_paths[split]) for split in ["train", "dev", "test"]}
        )

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "local_extracted_archive_paths": local_extracted_archive_paths["train"],
                    "archives": [dl_manager.iter_archive(path) for path in archive_paths["train"]],
                    "metadata": metadata,
                    "is_test": False,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={
                    "local_extracted_archive_paths": local_extracted_archive_paths["dev"],
                    "archives": [dl_manager.iter_archive(path) for path in archive_paths["dev"]],
                    "metadata": metadata,
                    "is_test": False,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "local_extracted_archive_paths": local_extracted_archive_paths["test"],
                    "archives": [dl_manager.iter_archive(path) for path in archive_paths["test"]],
                    "metadata": metadata,
                    "is_test": True,
                },
            ),
        ]

    def _earnings_generate_examples(self, local_extracted_archive_paths, archives, metadata, is_test):
        for local_extracted_archive_path, archive in zip(local_extracted_archive_paths, archives):
            # Here we iterate over all the files within the TAR archive:
            for audio_filename, audio_file in archive:
                audio_filename = audio_filename.lstrip("./")
                # if an audio file exists locally (i.e. in default, non-streaming mode) set the full path to it
                # joining path to directory that the archive was extracted to and audio filename.
                path = (
                    os.path.join(local_extracted_archive_path, audio_filename)
                    if local_extracted_archive_path
                    else audio_filename
                )

                # Error correction
                text = metadata[audio_filename]
                if text.lower() in ignore_segments:
                    continue
                # Remove  junk tokens
                for junk_token in earnings_junk_tokens:
                    text = text.replace(junk_token, "")
                # JIWER compliance (for WER/CER calc.)
                # remove multiple spaces
                text = re.sub(r"\s\s+", " ", text)
                # strip trailing spaces
                text = text.strip()
                if len(text) == 0:
                    continue

                yield audio_filename, {
                    "id": audio_filename,
                    "text": text if not is_test else "",
                    "dataset": "earnings22",
                    "audio": {"path": path, "bytes": audio_file.read()}
                }


def _maybe_trim_suffix(transcript):
    # stm files for the TEDLIUM release 1 train split contain a key (enclosed in
    # parens) at the end.
    splits = transcript.rsplit(" ", 1)
    transcript = splits[0]
    if len(splits) > 1:
        suffix = splits[-1]
        if not suffix.startswith("("):
            transcript += " " + suffix
    return transcript


def _extract_audio_segment(segment, sampling_rate, start_sec, end_sec):
    """Extracts segment of audio samples (as an ndarray) from the given segment."""
    # The dataset only contains mono audio.
    start_sample = int(start_sec * sampling_rate)
    end_sample = min(int(end_sec * sampling_rate), segment.shape[0])
    samples = segment[start_sample:end_sample]
    return samples


def _parse_gender(label_str):
    """Parse gender string from STM "<label>" field."""
    gender = re.split(",|_", label_str)[-1][:-1]
    # Fix inconsistencies in the data.
    if not gender:
        gender = -1  # Missing label.
    elif gender == "<NA":  # In TEDLIUM release 3 training data.
        gender = -1  # Missing label.
    elif gender == "F":
        gender = "female"
    elif gender == "M":
        gender = "male"
    return gender


def _is_additional(name):
    if name in {"s", "m", "l", "xl"}:
        return "_additional"
    return ""


_AMI_TRAIN_SAMPLE_IDS = [
    "EN2001a",
    "EN2001b",
    "EN2001d",
    "EN2001e",
    "EN2003a",
    "EN2004a",
    "EN2005a",
    "EN2006a",
    "EN2006b",
    "EN2009b",
    "EN2009c",
    "EN2009d",
    "ES2002a",
    "ES2002b",
    "ES2002c",
    "ES2002d",
    "ES2003a",
    "ES2003b",
    "ES2003c",
    "ES2003d",
    "ES2005a",
    "ES2005b",
    "ES2005c",
    "ES2005d",
    "ES2006a",
    "ES2006b",
    "ES2006c",
    "ES2006d",
    "ES2007a",
    "ES2007b",
    "ES2007c",
    "ES2007d",
    "ES2008a",
    "ES2008b",
    "ES2008c",
    "ES2008d",
    "ES2009a",
    "ES2009b",
    "ES2009c",
    "ES2009d",
    "ES2010a",
    "ES2010b",
    "ES2010c",
    "ES2010d",
    "ES2012a",
    "ES2012b",
    "ES2012c",
    "ES2012d",
    "ES2013a",
    "ES2013b",
    "ES2013c",
    "ES2013d",
    "ES2014a",
    "ES2014b",
    "ES2014c",
    "ES2014d",
    "ES2015a",
    "ES2015b",
    "ES2015c",
    "ES2015d",
    "ES2016a",
    "ES2016b",
    "ES2016c",
    "ES2016d",
    "IB4005",
    "IN1001",
    "IN1002",
    "IN1005",
    "IN1007",
    "IN1008",
    "IN1009",
    "IN1012",
    "IN1013",
    "IN1014",
    "IN1016",
    "IS1000a",
    "IS1000b",
    "IS1000c",
    "IS1000d",
    "IS1001a",
    "IS1001b",
    "IS1001c",
    "IS1001d",
    "IS1002b",
    "IS1002c",
    "IS1002d",
    "IS1003a",
    "IS1003b",
    "IS1003c",
    "IS1003d",
    "IS1004a",
    "IS1004b",
    "IS1004c",
    "IS1004d",
    "IS1005a",
    "IS1005b",
    "IS1005c",
    "IS1006a",
    "IS1006b",
    "IS1006c",
    "IS1006d",
    "IS1007a",
    "IS1007b",
    "IS1007c",
    "IS1007d",
    "TS3005a",
    "TS3005b",
    "TS3005c",
    "TS3005d",
    "TS3006a",
    "TS3006b",
    "TS3006c",
    "TS3006d",
    "TS3007a",
    "TS3007b",
    "TS3007c",
    "TS3007d",
    "TS3008a",
    "TS3008b",
    "TS3008c",
    "TS3008d",
    "TS3009a",
    "TS3009b",
    "TS3009c",
    "TS3009d",
    "TS3010a",
    "TS3010b",
    "TS3010c",
    "TS3010d",
    "TS3011a",
    "TS3011b",
    "TS3011c",
    "TS3011d",
    "TS3012a",
    "TS3012b",
    "TS3012c",
    "TS3012d",
]

_AMI_VALIDATION_SAMPLE_IDS = [
    "ES2011a",
    "ES2011c",
    "IB4001",
    "IB4003",
    "IB4010",
    "IS1008a",
    "IS1008c",
    "TS3004a",
    "TS3004c",
    "ES2011b",
    "ES2011d",
    "IB4002",
    "IB4004",
    "IB4011",
    "IS1008b",
    "IS1008d",
    "TS3004b",
    "TS3004d",
]

_AMI_EVAL_SAMPLE_IDS = [
    "EN2002a",
    "EN2002b",
    "EN2002c",
    "EN2002d",
    "ES2004a",
    "ES2004b",
    "ES2004c",
    "ES2004d",
    "IS1009a",
    "IS1009b",
    "IS1009c",
    "IS1009d",
    "TS3003a",
    "TS3003b",
    "TS3003c",
    "TS3003d",
]

_AMI_SAMPLE_IDS = {
    "train": _AMI_TRAIN_SAMPLE_IDS,
    "dev": _AMI_VALIDATION_SAMPLE_IDS,
    "eval": _AMI_EVAL_SAMPLE_IDS,
}

_AMI_BASE_DATA_URL = "https://huggingface.co/datasets/speech-seq2seq/ami/resolve/main/"

_AMI_AUDIO_ARCHIVE_URL = _AMI_BASE_DATA_URL + "audio/ihm/{split}/{_id}.tar.gz"

_AMI_ANNOTATIONS_ARCHIVE_URL = _AMI_BASE_DATA_URL + "annotations/{split}/text"

_SPGISPEECH_BASE_URL = "https://huggingface.co/datasets/kensho/spgispeech/resolve/main/data/"

_SPGISPEECH_AUDIO_BASE_URL = _SPGISPEECH_BASE_URL + "audio"

_SPGISPEECH_SUBSET_TO_DIR = {
    "s": ["s"],
    "m": ["s", "m_additional"],
    "l": ["s", "m_additional", "l_additional"],
    "dev": ["dev"],
    "test": ["test"],
}

# the second number in range is the number of archives (shards) in a subset
_SPGISPEECH_AUDIO_ARCHIVES_NAMES = {
    "s": [f"s_part_{i}.tar.gz" for i in range(0, 6)],
    "m_additional": [f"m_part_{i}.tar.gz" for i in range(0, 21)],
    "l_additional": [f"l_part_{i}.tar.gz" for i in range(0, 103)],
    "dev": [f"dev_part_{i}.tar.gz" for i in range(0, 3)],
    "test": [f"test_part_{i}.tar.gz" for i in range(0, 3)],
}

_SPGISPEECH_META_BASE_URL = _SPGISPEECH_BASE_URL + "meta"

_SPGISPEECH_META_FILENAMES = {
    "s": "train_small.csv",
    "m": "train_medium.csv",
    "l": "train.csv",
    "dev": "dev.csv",
    "test": "test.csv",
}

_VOXPOPULI_BASE_DATA_DIR = "https://huggingface.co/datasets/polinaeterna/voxpopuli/resolve/main/data/"

_VOXPOPULI_N_SHARDS_FILE = _VOXPOPULI_BASE_DATA_DIR + "n_files.json"

_VOXPOPULI_AUDIO_ARCHIVE_PATH = _VOXPOPULI_BASE_DATA_DIR + "en/{split}/{split}_part_{n_shard}.tar.gz"

_VOXPOPULI_METADATA_PATH = _VOXPOPULI_BASE_DATA_DIR + "en/asr_{split}.tsv"

_LIBRISPEECH_DL_URL = "http://www.openslr.org/resources/12/"

_LIBRISPEECH_DL_URLS = {
    "dev.clean": _LIBRISPEECH_DL_URL + "dev-clean.tar.gz",
    "dev.other": _LIBRISPEECH_DL_URL + "dev-other.tar.gz",
    "test.clean": _LIBRISPEECH_DL_URL + "test-clean.tar.gz",
    "test.other": _LIBRISPEECH_DL_URL + "test-other.tar.gz",
    "train.clean.100": _LIBRISPEECH_DL_URL + "train-clean-100.tar.gz",
    "train.clean.360": _LIBRISPEECH_DL_URL + "train-clean-360.tar.gz",
    "train.other.500": _LIBRISPEECH_DL_URL + "train-other-500.tar.gz",
}

_COMMON_VOICE_API_URL = "https://commonvoice.mozilla.org/api/v1"

_COMMON_VOICE_BUNDLE_URL_TEMPLATE = 'cv-corpus-9.0-2022-04-27/cv-corpus-9.0-2022-04-27-{locale}.tar.gz'

_TEDLIUM_BASE_URL = "https://huggingface.co/datasets/LIUM/tedlium/resolve/main/TEDLIUM_release3/legacy/"

_TEDLIUM_URLS = {
    "train": [_TEDLIUM_BASE_URL + "train_1.tar.gz", _TEDLIUM_BASE_URL + "train_2.tar.gz"],
    "dev": [_TEDLIUM_BASE_URL + "dev.tar.gz"],
    "test": [_TEDLIUM_BASE_URL + "test.tar.gz"],
}

_GIGASPEECH_BASE_DATA_URL = "https://huggingface.co/datasets/speechcolab/gigaspeech/resolve/main/data/"

_GIGASPEECH_AUDIO_ARCHIVE_URL = _GIGASPEECH_BASE_DATA_URL + "audio/{subset}_files{is_additional}/{subset}_chunks_{archive_id:04}.tar.gz"

_GIGASPEECH_META_URL = _GIGASPEECH_BASE_DATA_URL + "metadata/{subset}_metadata{is_additional}/{subset}_chunks_{archive_id:04}_metadata.csv"

_GIGASPEECH_CONFIGS_TO_ALL_CONFIGS = {
    "xs": ["xs"],
    "s": ["xs", "s"],
    "m": ["xs", "s", "m"],
    "l": ["xs", "s", "m", "l"],
    "xl": ["xs", "s", "m", "l", "xl"],
}

_GIGASPEECH_N_ARCHIVES = {
    "xs": 1,
    "s": 23,
    "m": 69,
    "l": 136,
    "xl": 602,
    "dev": 1,
    "test": 3,
}

_EARNINGS_BASE_URL = "https://huggingface.co/datasets/anton-l/earnings22_baseline_5_gram/resolve/main/"

_EARNINGS_DEV_IDS = {
    "4420696",
    "4448760",
    "4461799",
    "4469836",
    "4473238",
    "4482110",
}
_EARNINGS_TEST_IDS = {
    "4432298",
    "4450488",
    "4470290",
    "4479741",
    "4483338",
    "4485244",
}


tedlium_contractions = [" 's", " 't", " 're", " 've", " 'm", " 'll", " 'd", " 'clock", " 'all"]
gigaspeech_punctuation = {" <comma>": ",", " <period>": ".", " <questionmark>": "?", " <exclamationpoint>": "!"}
gigaspeech_junk_tokens = ["<other>", "<sil>"]
swb_junk_tokens = ["[noise]", "[laughter]", "[silence]", "[vocalized-noise]", "<a_aside>", "<b_aside>", "<e_aside>",
                    "[laughter-", "_1", "[laugh]", "[sigh]", "[cough]", "[mn]", "[breath]", "[lipsmack]",
                    "[sneeze]", "[skip]", "[pause]", "(%hesitation)", "(%HESITATION)"]
swb_punctuations = ["{", "}", "[", "]-", "]", "((", "))", "(", ")", "."]
swb_fillers = r"\b(uh|uhm|um|hmm|mm|mhm|mmm)\b"
earnings_junk_tokens = ["<noise>", "<crosstalk>", "<affirmative>", "<inaudible>", "inaudible", "<laugh>", "<silence>"]
ignore_segments = ["ignore_time_segment_in_scoring", "<noise>", "<music>", "[noise]", "[laughter]", "[silence]",
                   "[vocalized-noise]", "<crosstalk>", "<affirmative>", "<inaudible>", "<laugh>", ""]
ignore_segments = ignore_segments + gigaspeech_junk_tokens + swb_junk_tokens + earnings_junk_tokens