




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
__SCREAMING_SNAKE_CASE    :   Optional[Any]       ="""\
@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
__SCREAMING_SNAKE_CASE    :   List[str]       ="""\
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
__SCREAMING_SNAKE_CASE    :   Dict       =""""""

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

# 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)
__SCREAMING_SNAKE_CASE    :   Union[str, Any]       ={
    """first_domain""": """https://huggingface.co/great-new-dataset-first_domain.zip""",
    """second_domain""": """https://huggingface.co/great-new-dataset-second_domain.zip""",
}






class 			A			(		datasets.GeneratorBasedBuilder		):
     """simple docstring"""

     _snake_case:	Union[str, Any]     =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')
     _snake_case:	List[Any]     =[
         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"		),
     ]

     _snake_case:	Union[str, Any]     ="first_domain"  # It's not mandatory to have a default configuration. Just use one if it make sense.




     def  __snake_case   (    self  :   Dict			)				->       Tuple:
           # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
           if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
                 lowerCamelCase__        =				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__        =				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=A__	,  homepage=_HOMEPAGE	,  license=_LICENSE	,  citation=_CITATION	,  )




     def  __snake_case   (    self  :   Any	,  A__  :   Any			)				->       Any:
           # TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
           # If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name

           # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
           # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
           # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
           lowerCamelCase__        =				_URLS[self.config.name]
           lowerCamelCase__        =				dl_manager.download_and_extract(A__			)
           return [
               datasets.SplitGenerator(
                   name=datasets.Split.TRAIN	,  gen_kwargs={
                       'filepath': os.path.join(A__	,  'train.jsonl'			),
                       'split': 'train',
                   }	,  ),
               datasets.SplitGenerator(
                   name=datasets.Split.VALIDATION	,  gen_kwargs={
                       'filepath': os.path.join(A__	,  'dev.jsonl'			),
                       'split': 'dev',
                   }	,  ),
               datasets.SplitGenerator(
                   name=datasets.Split.TEST	,  gen_kwargs={
                       'filepath': os.path.join(A__	,  'test.jsonl'			),
                       'split': 'test'
                   }	,  ),
           ]




     def  __snake_case   (    self  :   str	,  A__  :   Optional[Any]	,  A__  :   Any			)				->       Optional[int]:
           # TODO: This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
           # The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
           with open(A__	,  encoding='utf-8'			) as f:
                 for key, row in enumerate(A__			):
                       lowerCamelCase__        =				json.loads(A__			)
                       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"],
                             }





import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_longformer import LongformerTokenizer


__SCREAMING_SNAKE_CASE    :   Dict       =logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE    :   str       ={"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""}

__SCREAMING_SNAKE_CASE    :   Dict       ={
    """vocab_file""": {
        """allenai/longformer-base-4096""": """https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json""",
        """allenai/longformer-large-4096""": (
            """https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json"""
        ),
        """allenai/longformer-large-4096-finetuned-triviaqa""": (
            """https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json"""
        ),
        """allenai/longformer-base-4096-extra.pos.embd.only""": (
            """https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json"""
        ),
        """allenai/longformer-large-4096-extra.pos.embd.only""": (
            """https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json"""
        ),
    },
    """merges_file""": {
        """allenai/longformer-base-4096""": """https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt""",
        """allenai/longformer-large-4096""": (
            """https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt"""
        ),
        """allenai/longformer-large-4096-finetuned-triviaqa""": (
            """https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt"""
        ),
        """allenai/longformer-base-4096-extra.pos.embd.only""": (
            """https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt"""
        ),
        """allenai/longformer-large-4096-extra.pos.embd.only""": (
            """https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt"""
        ),
    },
    """tokenizer_file""": {
        """allenai/longformer-base-4096""": (
            """https://huggingface.co/allenai/longformer-base-4096/resolve/main/tokenizer.json"""
        ),
        """allenai/longformer-large-4096""": (
            """https://huggingface.co/allenai/longformer-large-4096/resolve/main/tokenizer.json"""
        ),
        """allenai/longformer-large-4096-finetuned-triviaqa""": (
            """https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/tokenizer.json"""
        ),
        """allenai/longformer-base-4096-extra.pos.embd.only""": (
            """https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/tokenizer.json"""
        ),
        """allenai/longformer-large-4096-extra.pos.embd.only""": (
            """https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/tokenizer.json"""
        ),
    },
}

__SCREAMING_SNAKE_CASE    :   int       ={
    """allenai/longformer-base-4096""": 4_096,
    """allenai/longformer-large-4096""": 4_096,
    """allenai/longformer-large-4096-finetuned-triviaqa""": 4_096,
    """allenai/longformer-base-4096-extra.pos.embd.only""": 4_096,
    """allenai/longformer-large-4096-extra.pos.embd.only""": 4_096,
}






class 			A			(		_lowerCAmelCase		):
     """simple docstring"""

     _snake_case:	Optional[Any]     =VOCAB_FILES_NAMES
     _snake_case:	List[str]     =PRETRAINED_VOCAB_FILES_MAP
     _snake_case:	str     =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     _snake_case:	str     =["input_ids", "attention_mask"]
     _snake_case:	Union[str, Any]     =LongformerTokenizer




     def __init__(    self  :   str	,  A__  :   Optional[Any]=None	,  A__  :   Dict=None	,  A__  :   Any=None	,  A__  :   Optional[Any]="replace"	,  A__  :   Tuple="<s>"	,  A__  :   Any="</s>"	,  A__  :   Dict="</s>"	,  A__  :   Any="<s>"	,  A__  :   Optional[Any]="<unk>"	,  A__  :   Tuple="<pad>"	,  A__  :   Union[str, Any]="<mask>"	,  A__  :   List[str]=False	,  A__  :   List[str]=True	,  **A__  :   Optional[int]	,  )				->       List[str]:
           super().__init__(
               A__	,  A__	,  tokenizer_file=A__	,  errors=A__	,  bos_token=A__	,  eos_token=A__	,  sep_token=A__	,  cls_token=A__	,  unk_token=A__	,  pad_token=A__	,  mask_token=A__	,  add_prefix_space=A__	,  trim_offsets=A__	,  **A__	,  )

           lowerCamelCase__        =				json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()			)
           if pre_tok_state.get('add_prefix_space'	,  A__			) != add_prefix_space:
                 lowerCamelCase__        =				getattr(A__	,  pre_tok_state.pop('type'			)			)
                 lowerCamelCase__        =				add_prefix_space
                 lowerCamelCase__        =				pre_tok_class(**A__			)

           lowerCamelCase__        =				add_prefix_space

           lowerCamelCase__        =				'post_processor'
           lowerCamelCase__        =				getattr(self.backend_tokenizer	,  A__	,  A__			)
           if tokenizer_component_instance:
                 lowerCamelCase__        =				json.loads(tokenizer_component_instance.__getstate__()			)

                 # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
                 if "sep" in state:
                       lowerCamelCase__        =				tuple(state['sep']			)
                 if "cls" in state:
                       lowerCamelCase__        =				tuple(state['cls']			)

                 lowerCamelCase__        =				False

                 if state.get('add_prefix_space'	,  A__			) != add_prefix_space:
                       lowerCamelCase__        =				add_prefix_space
                       lowerCamelCase__        =				True

                 if state.get('trim_offsets'	,  A__			) != trim_offsets:
                       lowerCamelCase__        =				trim_offsets
                       lowerCamelCase__        =				True

                 if changes_to_apply:
                       lowerCamelCase__        =				getattr(A__	,  state.pop('type'			)			)
                       lowerCamelCase__        =				component_class(**A__			)
                       setattr(self.backend_tokenizer	,  A__	,  A__			)




     @property
     def  __snake_case   (    self  :   Tuple			)				->       str:
           if self._mask_token is None:
                 if self.verbose:
                       logger.error('Using mask_token, but it is not set yet.'			)
                 return None
           return str(self._mask_token			)




     @mask_token.setter
     def  __snake_case   (    self  :   Dict	,  A__  :   Tuple			)				->       int:
           lowerCamelCase__        =				AddedToken(A__	,  lstrip=A__	,  rstrip=A__			) if isinstance(A__	,  A__			) else value
           lowerCamelCase__        =				value




     def  __snake_case   (    self  :   Any	,  *A__  :   Any	,  **A__  :   Any			)				->       BatchEncoding:
           lowerCamelCase__        =				kwargs.get('is_split_into_words'	,  A__			)
           assert self.add_prefix_space or not is_split_into_words, (
               F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
               "to use it with pretokenized inputs."
           )

           return super()._batch_encode_plus(*A__	,  **A__			)




     def  __snake_case   (    self  :   Tuple	,  *A__  :   str	,  **A__  :   int			)				->       BatchEncoding:
           lowerCamelCase__        =				kwargs.get('is_split_into_words'	,  A__			)

           assert self.add_prefix_space or not is_split_into_words, (
               F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
               "to use it with pretokenized inputs."
           )

           return super()._encode_plus(*A__	,  **A__			)




     def  __snake_case   (    self  :   Union[str, Any]	,  A__  :   str	,  A__  :   Optional[str] = None			)				->       Tuple[str]:
           lowerCamelCase__        =				self._tokenizer.model.save(A__	,  name=A__			)
           return tuple(A__			)




     def  __snake_case   (    self  :   Any	,  A__  :   int	,  A__  :   List[str]=None			)				->       Dict:
           lowerCamelCase__        =				[self.bos_token_id] + token_ids_a + [self.eos_token_id]
           if token_ids_a is None:
                 return output

           return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]




     def  __snake_case   (    self  :   Union[str, Any]	,  A__  :   List[int]	,  A__  :   Optional[List[int]] = None			)				->       List[int]:
           lowerCamelCase__        =				[self.sep_token_id]
           lowerCamelCase__        =				[self.cls_token_id]

           if token_ids_a is None:
                 return len(cls + token_ids_a + sep			) * [0]
           return len(cls + token_ids_a + sep + sep + token_ids_a + sep			) * [0]