






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
A__     :      List[Any]             =			'\\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
A__     :      int             =			'\\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
A__     :      Any             =			''

# TODO: Add the licence for the dataset here if you can find it
A__     :      Union[str, 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)
A__     :      str             =			{
    '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"""




				lowercase__    							=	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')
				lowercase__    							=	[
				    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"""     ),
				]

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




				def     lowercase__       (					self						:   List[Any]  ):

								'''simple docstring'''
								# 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
												lowercase__       			=      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"
												lowercase__       			=      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     lowercase__       (					self						:   Dict,  lowerCamelCase						:   Optional[Any]  ):

								'''simple docstring'''
								lowercase__       			=      _URLS[self.config.name]
								lowercase__       			=      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     lowercase__       (					self						:   Dict,  lowerCamelCase						:   Optional[Any],  lowerCamelCase						:   int  ):

								'''simple docstring'''
								# 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(lowerCamelCase,  encoding='''utf-8'''  ) as f:
												for key, row in enumerate(lowerCamelCase  ):
																lowercase__       			=      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"],
																				}










import unittest

from datasets import load_dataset

from transformers import load_tool

from .test_tools_common import ToolTesterMixin
class 				_UpperCAmelCase (	unittest.TestCase		,A__     ):

				"""simple docstring"""




				def     lowercase__       (					self						:   str  ):

								'''simple docstring'''
								lowercase__       			=      load_tool('''document-question-answering'''  )
								self.tool.setup()
								lowercase__       			=      load_tool('''document-question-answering''',  remote=lowerCamelCase  )




				def     lowercase__       (					self						:   List[Any]  ):

								'''simple docstring'''
								lowercase__       			=      load_dataset('''hf-internal-testing/example-documents''',  split='''test'''  )
								lowercase__       			=      dataset[0]['''image''']

								lowercase__       			=      self.tool(lowerCamelCase,  '''When is the coffee break?'''  )
								self.assertEqual(lowerCamelCase,  '''11-14 to 11:39 a.m.'''  )




				def     lowercase__       (					self						:   Optional[Any]  ):

								'''simple docstring'''
								lowercase__       			=      load_dataset('''hf-internal-testing/example-documents''',  split='''test'''  )
								lowercase__       			=      dataset[0]['''image''']

								lowercase__       			=      self.remote_tool(lowerCamelCase,  '''When is the coffee break?'''  )
								self.assertEqual(lowerCamelCase,  '''11-14 to 11:39 a.m.'''  )




				def     lowercase__       (					self						:   Any  ):

								'''simple docstring'''
								lowercase__       			=      load_dataset('''hf-internal-testing/example-documents''',  split='''test'''  )
								lowercase__       			=      dataset[0]['''image''']

								self.tool(document=lowerCamelCase,  question='''When is the coffee break?'''  )




				def     lowercase__       (					self						:   Tuple  ):

								'''simple docstring'''
								lowercase__       			=      load_dataset('''hf-internal-testing/example-documents''',  split='''test'''  )
								lowercase__       			=      dataset[0]['''image''']

								lowercase__       			=      self.remote_tool(document=lowerCamelCase,  question='''When is the coffee break?'''  )
								self.assertEqual(lowerCamelCase,  '''11-14 to 11:39 a.m.'''  )




