




'''simple docstring'''




import csv
import json
import os

import datasets


# TODO: Add BibTeX citation
# Find for instance the citation on arxiv or on the dataset repo/website
snake_case__ 							=    """\
@InProceedings{huggingface:dataset,
title = {A great new dataset},
author={huggingface, Inc.
},
year={2020}
}
"""

# TODO: Add description of the dataset here
# You can copy an official description
snake_case__ 							=    """\
This new dataset is designed to solve this great NLP task and is crafted with a lot of care.
"""

# TODO: Add a link to an official homepage for the dataset here
snake_case__ 							=    """"""

# TODO: Add the licence for the dataset here if you can find it
snake_case__ 							=    """"""

# TODO: Add link to the official dataset URLs here
# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
snake_case__ 							=    {
    """first_domain""": """https://huggingface.co/great-new-dataset-first_domain.zip""",
    """second_domain""": """https://huggingface.co/great-new-dataset-second_domain.zip""",
}






class      UpperCamelCase_  (datasets.GeneratorBasedBuilder  ):







						"""simple docstring"""


						_lowerCAmelCase         =       datasets.Version('1.1.0'  )

						# This is an example of a dataset with multiple configurations.
						# If you don't want/need to define several sub-sets in your dataset,
						# just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.

						# If you need to make complex sub-parts in the datasets with configurable options
						# You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
						# BUILDER_CONFIG_CLASS = MyBuilderConfig

						# You will be able to load one or the other configurations in the following list with
						# data = datasets.load_dataset('my_dataset', 'first_domain')
						# data = datasets.load_dataset('my_dataset', 'second_domain')
						_lowerCAmelCase         =       [
						    datasets.BuilderConfig(name='first_domain',   version=a__,   description='This part of my dataset covers a first domain'  ),
						    datasets.BuilderConfig(name='second_domain',   version=a__,   description='This part of my dataset covers a second domain'  ),
						]

						_lowerCAmelCase         =       'first_domain'  # It's not mandatory to have a default configuration. Just use one if it make sense.







						def    _a     (  self   :							str     ):





											"""simple docstring"""







											if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
																A_			:  Union[str, Any]			=				datasets.Features(
																    {
																        '''sentence''': datasets.Value('''string'''     ),
																        '''option1''': datasets.Value('''string'''     ),
																        '''answer''': datasets.Value('''string'''     )
																        # These are the features of your dataset like images, labels ...
																    }     )
											else:  # This is an example to show how to have different features for "first_domain" and "second_domain"
																A_			:  int			=				datasets.Features(
																    {
																        '''sentence''': datasets.Value('''string'''     ),
																        '''option2''': datasets.Value('''string'''     ),
																        '''second_domain_answer''': datasets.Value('''string'''     )
																        # These are the features of your dataset like images, labels ...
																    }     )
											return datasets.DatasetInfo(
											    # This is the description that will appear on the datasets page.
											    description=_DESCRIPTION				,			features=_lowerCamelCase				,			homepage=_HOMEPAGE				,			license=_LICENSE				,			citation=_CITATION				,			)







						def    _a     (  self   :							str				,			_lowerCamelCase   :							Tuple     ):





											"""simple docstring"""







											A_			:  List[Any]			=				_URLS[self.config.name]
											A_			:  List[str]			=				dl_manager.download_and_extract(_lowerCamelCase     )
											return [
											    datasets.SplitGenerator(
											        name=datasets.Split.TRAIN				,			gen_kwargs={
											            '''filepath''': os.path.join(_lowerCamelCase				,			'''train.jsonl'''     ),
											            '''split''': '''train''',
											        }				,			),
											    datasets.SplitGenerator(
											        name=datasets.Split.VALIDATION				,			gen_kwargs={
											            '''filepath''': os.path.join(_lowerCamelCase				,			'''dev.jsonl'''     ),
											            '''split''': '''dev''',
											        }				,			),
											    datasets.SplitGenerator(
											        name=datasets.Split.TEST				,			gen_kwargs={
											            '''filepath''': os.path.join(_lowerCamelCase				,			'''test.jsonl'''     ),
											            '''split''': '''test'''
											        }				,			),
											]







						def    _a     (  self   :							Optional[int]				,			_lowerCamelCase   :							int				,			_lowerCamelCase   :							Any     ):





											"""simple docstring"""







											with open(_lowerCamelCase				,			encoding='''utf-8'''     ) as f:
																for key, row in enumerate(_lowerCamelCase     ):
																					A_			:  Optional[Any]			=				json.loads(_lowerCamelCase     )
																					if self.config.name == "first_domain":
																										# Yields examples as (key, example) tuples
																										yield key, {
																										    "sentence": data["sentence"],
																										    "option1": data["option1"],
																										    "answer": "" if split == "test" else data["answer"],
																										}
																					else:
																										yield key, {
																										    "sentence": data["sentence"],
																										    "option2": data["option2"],
																										    "second_domain_answer": "" if split == "test" else data["second_domain_answer"],
																										}









'''simple docstring'''




import abc
import copy
import dataclasses
from dataclasses import dataclass
from typing import ClassVar, Dict, Type, TypeVar

from ..features import Features


snake_case__ 							=    TypeVar("""T""", bound="""TaskTemplate""")






@dataclass(frozen=a__  )
class      UpperCamelCase_  (abc.ABC  ):







						"""simple docstring"""


						_lowerCAmelCase         =       42
						_lowerCAmelCase         =       42
						_lowerCAmelCase         =       42







						def    _a     (  self   :							T				,			_lowerCamelCase   :							Features     ):





											"""simple docstring"""







											return copy.deepcopy(self     )







						@property
						def    _a     (  self   :							List[str]     ):





											"""simple docstring"""







											return Features(**self.input_schema				,			**self.label_schema     )







						@property
						@abc.abstractmethod
						def    _a     (  self   :							int     ):





											"""simple docstring"""







											raise NotImplementedError







						@classmethod
						def    _a     (  cls   :							Type[T]				,			_lowerCamelCase   :							dict     ):





											"""simple docstring"""







											A_			:  Dict			=				{f.name for f in dataclasses.fields(cls     )}
											return cls(**{k: v for k, v in template_dict.items() if k in field_names}     )



