





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
_lowerCAmelCase							:      Optional[int]						=	'''\
@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
_lowerCAmelCase							:      Optional[Any]						=	'''\
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
_lowerCAmelCase							:      Optional[Any]						=	''''''

# TODO: Add the licence for the dataset here if you can find it
_lowerCAmelCase							:      List[Any]						=	''''''

# 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)
_lowerCAmelCase							:      Dict						=	{
    '''first_domain''': '''https://huggingface.co/great-new-dataset-first_domain.zip''',
    '''second_domain''': '''https://huggingface.co/great-new-dataset-second_domain.zip''',
}


class 					__magic_name__  (							datasets.GeneratorBasedBuilder							):





     """simple docstring"""



     __UpperCamelCase					    =     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')
     __UpperCamelCase					    =     [
         datasets.BuilderConfig(name='''first_domain'''    ,				version=lowerCamelCase__    ,				description='''This part of my dataset covers a first domain'''							),
         datasets.BuilderConfig(name='''second_domain'''    ,				version=lowerCamelCase__    ,				description='''This part of my dataset covers a second domain'''							),
     ]

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



     def 						SCREAMING_SNAKE_CASE		(							self       :Optional[int]  ):





        '''simple docstring'''




        if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
           A_					:				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_					:				Any          =			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=snake_case			,      homepage=_HOMEPAGE			,      license=_LICENSE			,      citation=_CITATION			,      )



     def 						SCREAMING_SNAKE_CASE		(							self       :Dict			,      snake_case       :str  ):





        '''simple docstring'''




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





     def 						SCREAMING_SNAKE_CASE		(							self       :Union[str, Any]			,      snake_case       :List[str]			,      snake_case       :Dict  ):





        '''simple docstring'''




        with open(snake_case			,      encoding="utf-8"  ) as f:
           for key, row in enumerate(snake_case  ):
              A_					:				str          =			json.loads(snake_case  )
              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"],
                 }







from __future__ import annotations

def      __snake_case						(					_lowerCAmelCase : int	) ->						list[int]:
   assert (
       isinstance(_lowerCAmelCase				,				_lowerCAmelCase	) and mask > 0
   ), f"mask needs to be positive integer, your input {mask}"
   A_					:				Optional[Any]          =			[]
   A_					:				Optional[int]          =			mask

   while submask:
      all_submasks.append(_lowerCAmelCase	)
      A_					:				List[str]          =			(submask - 1) & mask

   return all_submasks


if __name__ == "__main__":
 import doctest

 doctest.testmod()
