quran_data.py

# Copyright 2022 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# 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.

import json
import os

import datasets
from datasets.tasks import AutomaticSpeechRecognition
from tqdm.auto import tqdm


# Find for instance the citation on arxiv or on the dataset repo/website
_CITATION = """\
@InProceedings{quran:dataset,
title = {Quran data},
author={Tarteel.io},
year={2022}
}
"""

# You can copy an official description
_DESCRIPTION = """\
Quran recitation dataset from various Qari's and quran recitation from Tarteel users
"""

_HOMEPAGE = "https://huggingface.co./datasets/ashraf-ali/quran-data"

_LICENSE = [
    "cc-by-sa-4.0"
]

_BASE_URL = "https://huggingface.co./datasets/ashraf-ali/quran-data/blob/main/"

# relative path to data inside dataset's repo
_DATA_URL = _BASE_URL + "{split}/{config}/{config}_{archive_id:06d}.tar"

# relative path to file containing number of audio archives inside dataset's repo
_N_SHARDS_URL = _BASE_URL + "n_shards.json"

# relative path to metadata inside dataset's repo
_MANIFEST_URL = _BASE_URL + "{split}/{config}.json"


class QuranDataConfig(datasets.BuilderConfig):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class QuranData(datasets.GeneratorBasedBuilder):
    """Quran recitation dataset."""

    VERSION = datasets.Version("1.0.0")

    BUILDER_CONFIGS = [
        QuranDataConfig(name="qari", version=VERSION,
                        description="Qari quran recitation"),
        QuranDataConfig(name="user", version=VERSION,
                        description="Quran recitation from various users"),
    ]

    DEFAULT_CONFIG_NAME = "qari"
    DEFAULT_WRITER_BATCH_SIZE = 512

    def _info(self):
        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=datasets.Features(
                {
                    "id": datasets.Value("string"),
                    "quran_id": datasets.Value("string"),
                    "audio": datasets.Audio(sampling_rate=16_000),
                    "reciter": datasets.Value("string"),
                    "duration_in_seconds": datasets.Value("float32"),
                    "text": datasets.Value("string"),
                }
            ),
            task_templates=[AutomaticSpeechRecognition()],
            homepage=_HOMEPAGE,
            license="/".join(_LICENSE),  # license must be a string
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):

        if self.config.name == "microset":
            # take only first data archive for demo purposes
            url = [_DATA_URL.format(
                split="train", config="clean", archive_id=0)]
            archive_path = dl_manager.download(url)
            local_extracted_archive_path = dl_manager.extract(
                archive_path) if not dl_manager.is_streaming else [None]
            manifest_url = _MANIFEST_URL.format(
                split="train", config="clean_000000")  # train/clean_000000.json
            manifest_path = dl_manager.download_and_extract(manifest_url)

            return [
                datasets.SplitGenerator(
                    name=datasets.Split.TRAIN,
                    gen_kwargs={
                        "local_extracted_archive_paths": local_extracted_archive_path,
                        # use iter_archive here to access the files in the TAR archives:
                        "archives": [dl_manager.iter_archive(path) for path in archive_path],
                        "manifest_path": manifest_path,
                    },
                ),
            ]

        n_shards_path = dl_manager.download_and_extract(_N_SHARDS_URL)
        with open(n_shards_path, encoding="utf-8") as f:
            n_shards = json.load(f)

        if self.config.name in ["validation", "test"]:
            splits_to_configs = {self.config.name: self.config.name}
        else:
            splits_to_configs = {
                "train": self.config.name,
                "validation": "validation",
                "test": "test"
            }

        audio_urls = {
            split: [
                _DATA_URL.format(split=split, config=config, archive_id=i) for i in range(n_shards[split][config])
            ] for split, config in splits_to_configs.items()
        }
        audio_archive_paths = dl_manager.download(audio_urls)

        # In non-streaming mode, we extract the archives to have the data locally:
        local_extracted_archive_paths = dl_manager.extract(audio_archive_paths) \
            if not dl_manager.is_streaming else \
            {split: [None] * len(audio_archive_paths)
             for split in splits_to_configs}

        manifest_urls = {
            split: _MANIFEST_URL.format(split=split, config=config) for split, config in splits_to_configs.items()
        }
        manifest_paths = dl_manager.download_and_extract(manifest_urls)

        # 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 a TAR archive.
        splits_to_names = {
            "train": datasets.Split.TRAIN,
            "validation": datasets.Split.VALIDATION,
            "test": datasets.Split.TEST,
        }
        split_generators = []
        for split in splits_to_configs:
            split_generators.append(
                datasets.SplitGenerator(
                    name=splits_to_names[split],
                    gen_kwargs={
                        "local_extracted_archive_paths": local_extracted_archive_paths[split],
                        # use iter_archive here to access the files in the TAR archives:
                        "archives": [dl_manager.iter_archive(path) for path in audio_archive_paths[split]],
                        "manifest_path": manifest_paths[split],
                    }
                )
            )

        return split_generators

    def _generate_examples(self, local_extracted_archive_paths, archives, manifest_path):
        meta = dict()
        with open(manifest_path, "r", encoding="utf-8") as f:
            for line in tqdm(f, desc="reading metadata file"):
                sample_meta = json.loads(line)
                _id = sample_meta["audio_document_id"]
                texts = sample_meta["training_data"]["label"]
                audio_filenames = sample_meta["training_data"]["name"]
                durations = sample_meta["training_data"]["duration_ms"]

                for audio_filename, text, duration in zip(audio_filenames, texts, durations):
                    audio_filename = audio_filename.lstrip("./")
                    meta[audio_filename] = {
                        "audio_document_id": _id,
                        "text": text,
                        "duration_ms": duration
                    }

        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
                yield audio_filename, {
                    "id": audio_filename,
                    "audio": {"path": path, "bytes": audio_file.read()},
                    "text": meta[audio_filename]["text"],
                    "duration_ms": meta[audio_filename]["duration_ms"]
                }