pauq.py

# coding=utf-8
# Copyright 2020 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.
"""PAUQ: Text-to-SQL in Russian"""

import json
import os

import datasets

logger = datasets.logging.get_logger(__name__)

_CITATION = """\
@inproceedings{bakshandaeva-etal-2022-pauq,
    title = "{PAUQ}: Text-to-{SQL} in {R}ussian",
    author = "Bakshandaeva, Daria  and
      Somov, Oleg  and
      Dmitrieva, Ekaterina  and
      Davydova, Vera  and
      Tutubalina, Elena",
    booktitle = "Findings of the Association for Computational Linguistics: EMNLP 2022",
    month = dec,
    year = "2022",
    address = "Abu Dhabi, United Arab Emirates",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2022.findings-emnlp.175",
"""

_DESCRIPTION = """\
    Pauq is a first Russian text-to-SQL dataset translated from original Spider dataset 
    with corrections and refinements of question, queries and databases.
"""

_LICENSE = "CC BY-SA 4.0"

_HOMEPAGE = "https://github.com/ai-spiderweb/pauq"

_URL = "https://huggingface.co./datasets/composite/pauq/resolve/main/formatted_pauq.zip"

RUSSIAN_PAUQ_TRL_DESCRIPTION = "Russian PAUQ train/test split based on target length of SQL query. Long query template in train, short query template in test."
ENGLISH_PAUQ_TRL_DESCRIPTION = "English PAUQ train/test split based on target length of SQL query. Long query template in train, short query template in test."

RUSSIAN_PAUQ_TSL_DESCRIPTION = "Russian PAUQ train/test split based on target length of SQL query. Short query template in train, long query template in test."
ENGLISH_PAUQ_TSL_DESCRIPTION = "English PAUQ train/test split based on target length of SQL query. Short query template in train, long query template in test."

RUSSIAN_PAUQ_OS_DESCRIPTION = "Independent and identical Russian PAUQ train/test split. Сorresponds to original Spider splitting."
ENGLISH_PAUQ_OS_DESCRIPTION = "Independent and identical English PAUQ train/test split. Сorresponds to original Spider splitting."


class Pauq(datasets.GeneratorBasedBuilder):
    VERSION = datasets.Version("1.0.0")

    BUILDER_CONFIGS = [
        datasets.BuilderConfig(
            name="ru_trl",
            version=VERSION,
            description=RUSSIAN_PAUQ_TRL_DESCRIPTION,
        ),
        datasets.BuilderConfig(
            name="en_trl",
            version=VERSION,
            description=ENGLISH_PAUQ_TRL_DESCRIPTION,
        ),
        datasets.BuilderConfig(
            name="ru_tsl",
            version=VERSION,
            description=RUSSIAN_PAUQ_TSL_DESCRIPTION,
        ),
        datasets.BuilderConfig(
            name="en_tsl",
            version=VERSION,
            description=ENGLISH_PAUQ_TSL_DESCRIPTION,
        ),
        datasets.BuilderConfig(
            name="ru_os",
            version=VERSION,
            description=RUSSIAN_PAUQ_OS_DESCRIPTION,
        ),
        datasets.BuilderConfig(
            name="en_os",
            version=VERSION,
            description=ENGLISH_PAUQ_OS_DESCRIPTION,
        ),
    ]

    def _info(self):
        features = datasets.Features(
            {
                "id": datasets.Value("string"),
                "db_id": datasets.Value("string"),
                "source": datasets.Value("string"),
                "type": datasets.Value("string"),
                "question": datasets.Value("string"),
                "query": datasets.Value("string"),
                "sql": datasets.features.Sequence(datasets.Value("string")),
                "question_toks": datasets.features.Sequence(datasets.Value("string")),
                "query_toks": datasets.features.Sequence(datasets.Value("string")),
                "query_toks_no_values": datasets.features.Sequence(datasets.Value("string")),
                "template": datasets.Value("string")
            }
        )
        dataset_info = None
        if self.config.name == 'ru_trl':
            dataset_info = datasets.DatasetInfo(
                description=RUSSIAN_PAUQ_TRL_DESCRIPTION,
                features=features,
                supervised_keys=None,
                homepage=_HOMEPAGE,
                license=_LICENSE,
                citation=_CITATION,
                config_name="ru_trl")
        elif self.config.name == "en_trl":
            dataset_info = datasets.DatasetInfo(
                description=ENGLISH_PAUQ_TRL_DESCRIPTION,
                features=features,
                supervised_keys=None,
                homepage=_HOMEPAGE,
                license=_LICENSE,
                citation=_CITATION,
                config_name="en_trl")
        elif self.config.name == 'ru_os':
            dataset_info = datasets.DatasetInfo(
                description=RUSSIAN_PAUQ_OS_DESCRIPTION,
                features=features,
                supervised_keys=None,
                homepage=_HOMEPAGE,
                license=_LICENSE,
                citation=_CITATION,
                config_name="ru_os")
        elif self.config.name == 'en_os':
            dataset_info = datasets.DatasetInfo(
                description=ENGLISH_PAUQ_OS_DESCRIPTION,
                features=features,
                supervised_keys=None,
                homepage=_HOMEPAGE,
                license=_LICENSE,
                citation=_CITATION,
                config_name="en_os")
        elif self.config.name == 'ru_tsl':
            dataset_info = datasets.DatasetInfo(
                description=RUSSIAN_PAUQ_TSL_DESCRIPTION,
                features=features,
                supervised_keys=None,
                homepage=_HOMEPAGE,
                license=_LICENSE,
                citation=_CITATION,
                config_name="ru_tsl")
        elif self.config.name == "en_tsl":
            dataset_info = datasets.DatasetInfo(
                description=ENGLISH_PAUQ_TSL_DESCRIPTION,
                features=features,
                supervised_keys=None,
                homepage=_HOMEPAGE,
                license=_LICENSE,
                citation=_CITATION,
                config_name="en_tsl")

        return dataset_info

    def _split_generators(self, dl_manager):
        downloaded_filepath = dl_manager.download_and_extract(_URL)
        
        dataset_name = self.config.name
        
        splits = []
        if dataset_name == 'ru_trl':
            splits = [
                datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/ru_trl_train.json"),
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/ru_trl_test.json"),
                },
            )
            ]
        elif dataset_name == 'en_trl':
            splits = [
                datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/en_trl_train.json"),
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/en_trl_test.json"),
                },
            )]
        elif dataset_name == 'ru_os':
            splits = [
                datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/ru_os_train.json"),
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/ru_os_test.json"),
                },
            )
            ]
        elif dataset_name == 'en_os':
            splits = [
                datasets.SplitGenerator(
                    name=datasets.Split.TRAIN,
                    gen_kwargs={
                        "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/en_os_train.json"),
                    },
                ),
                datasets.SplitGenerator(
                    name=datasets.Split.TEST,
                    gen_kwargs={
                        "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/en_os_test.json"),
                    },
                )
            ]
        elif dataset_name == 'ru_tsl':
            splits = [
                datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/ru_tsl_train.json"),
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/ru_tsl_test.json"),
                },
            )
            ]
        elif dataset_name == 'en_tsl':
            splits = [
                datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/en_tsl_train.json"),
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "data_filepath": os.path.join(downloaded_filepath, "formatted_pauq/splits/en_tsl_test.json"),
                },
            )]
        return splits

    def _generate_examples(self, data_filepath):
        """This function returns the examples in the raw (text) form."""
        logger.info("generating examples from = %s", data_filepath)
        with open(data_filepath, encoding="utf-8") as f:
            pauq = json.load(f)
            for idx, sample in enumerate(pauq):
                yield idx, {
                    "id": sample["id"],
                    "db_id": sample["db_id"],
                    "source": sample["source"],
                    "type": sample["type"],
                    "query": sample["query"],
                    "sql": sample['sql'],
                    "question": sample["question"],
                    "question_toks": sample["question_toks"],
                    "query_toks": sample["query_toks"],
                    "query_toks_no_values": sample["query_toks_no_values"],
                    "template": sample["masked_query"]
                }