





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
_UpperCAmelCase			   =							'\\n@InProceedings{huggingface:dataset,\ntitle = {A great new dataset},\nauthor={huggingface, Inc.\n},\nyear={2020}\n}\n'

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

# TODO: Add a link to an official homepage for the dataset here
_UpperCAmelCase			   =							''

# TODO: Add the licence for the dataset here if you can find it
_UpperCAmelCase			   =							''

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






class    snake_case_				(		datasets.GeneratorBasedBuilder						):
  A_										=    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')
  A_										=    [
      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'						),
  ]

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






  def       UpperCAmelCase__						(							self :     Optional[Any]			)->Dict:






   '''simple docstring'''

   if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
    __lowerCAmelCase     :       Dict						=   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"
    __lowerCAmelCase     :       Optional[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=_snake_case   ,  homepage=_HOMEPAGE   ,  license=_LICENSE   ,  citation=_CITATION   ,  )






  def       UpperCAmelCase__						(							self :     Tuple   ,  _snake_case :     List[str]			)->List[Any]:






   '''simple docstring'''

   __lowerCAmelCase     :       Optional[int]						=   _URLS[self.config.name]
   __lowerCAmelCase     :       Union[str, Any]						=   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       UpperCAmelCase__						(							self :     Optional[int]   ,  _snake_case :     Dict   ,  _snake_case :     List[str]			)->Union[str, Any]:






   '''simple docstring'''

   with open(_snake_case   ,  encoding="""utf-8"""			) as f:
    for key, row in enumerate(_snake_case			):
     __lowerCAmelCase     :       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 SCREAMING_SNAKE_CASE (   lowercase_:		int						,  lowercase_:		int						,  lowercase_:		int ):
       assert n > 1 and a > 0 and greatest_common_divisor(lowercase_						,  lowercase_ ) == 1
       ((_UpperCamelCase)  ,					(_UpperCamelCase)  ,					(_UpperCamelCase))   :				Optional[int]       =     extended_gcd(lowercase_						,  lowercase_ )  # Implemented below
       _UpperCamelCase   :				str       =     (b * s) % n
       return x


def SCREAMING_SNAKE_CASE (   lowercase_:		int						,  lowercase_:		int ):
       ((_UpperCamelCase)  ,					(_UpperCamelCase))   :				Union[str, Any]       =     extended_euclid(lowercase_						,  lowercase_ )  # Implemented below
       if b < 0:
              _UpperCamelCase   :				Union[str, Any]       =     (b % n + n) % n
       return b


def SCREAMING_SNAKE_CASE (   lowercase_:		int						,  lowercase_:		int						,  lowercase_:		int ):
       _UpperCamelCase   :				Union[str, Any]       =     invert_modulo(lowercase_						,  lowercase_ )
       _UpperCamelCase   :				str       =     (b * s) % n
       return x


def SCREAMING_SNAKE_CASE (   lowercase_:		int						,  lowercase_:		int ):
       assert a >= 0 and b >= 0

       if b == 0:
              _UpperCamelCase  ,					_UpperCamelCase  ,					_UpperCamelCase   :				Any       =     a, 1, 0
       else:
              ((_UpperCamelCase)  ,					(_UpperCamelCase)  ,					(_UpperCamelCase))   :				Dict       =     extended_gcd(lowercase_						,  a % b )
              _UpperCamelCase   :				List[str]       =     q
              _UpperCamelCase   :				Any       =     p - q * (a // b)

       assert a % d == 0 and b % d == 0
       assert d == a * x + b * y

       return (d, x, y)


def SCREAMING_SNAKE_CASE (   lowercase_:		int						,  lowercase_:		int ):
       if b == 0:
              return (1, 0)
       ((_UpperCamelCase)  ,					(_UpperCamelCase))   :				Optional[Any]       =     extended_euclid(lowercase_						,  a % b )
       _UpperCamelCase   :				List[Any]       =     a // b
       return (y, x - k * y)


def SCREAMING_SNAKE_CASE (   lowercase_:		int						,  lowercase_:		int ):
       if a < b:
              _UpperCamelCase  ,					_UpperCamelCase   :				Optional[int]       =     b, a

       while a % b != 0:
              _UpperCamelCase  ,					_UpperCamelCase   :				Union[str, Any]       =     b, a % b

       return b


if __name__ == "__main__":
 from doctest import testmod

 testmod(name='''modular_division''', verbose=True)
 testmod(name='''modular_division2''', verbose=True)
 testmod(name='''invert_modulo''', verbose=True)
 testmod(name='''extended_gcd''', verbose=True)
 testmod(name='''extended_euclid''', verbose=True)
 testmod(name='''greatest_common_divisor''', verbose=True)



