
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     				=			'''\
@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
UpperCAmelCase     				=			'''\
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
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 	A_       (      datasets.GeneratorBasedBuilder       ):




	'''simple docstring'''


	_UpperCamelCase					:					List[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')
	_UpperCamelCase					:					Dict										=	[
	    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					:					List[str]										=	"""first_domain"""  # It's not mandatory to have a default configuration. Just use one if it make sense.





	def      SCREAMING_SNAKE_CASE__						(	self	):
		# 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=snake_case		,   homepage=_HOMEPAGE		,   license=_LICENSE		,   citation=_CITATION		,   )





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case	):
		# 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
		lowercase					  =   _URLS[self.config.name]
		lowercase					  =   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		,   snake_case		,   snake_case	):
		# 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(snake_case		,   encoding='utf-8'	) as f:
			for key, row in enumerate(snake_case	):
				lowercase					  =   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"],
					}



import unittest
from timeit import timeit






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE			,							__SCREAMING_SNAKE_CASE							):
	lowercase					  =   first_num if first_num >= second_num else second_num
	lowercase					  =   max_num
	while (common_mult % first_num > 0) or (common_mult % second_num > 0):
		common_mult += max_num
	return common_mult






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE			,							__SCREAMING_SNAKE_CASE							):
	return b if a == 0 else greatest_common_divisor(b % a			,							__SCREAMING_SNAKE_CASE							)






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE			,							__SCREAMING_SNAKE_CASE							):
	return first_num // greatest_common_divisor(__SCREAMING_SNAKE_CASE			,							__SCREAMING_SNAKE_CASE							) * second_num






def 							UpperCAmelCase_		(							):
	lowercase					  =   (
	    'from __main__ import least_common_multiple_slow, least_common_multiple_fast'
	)
	print(
	    'least_common_multiple_slow():'			,							timeit('least_common_multiple_slow(1000, 999)'			,							setup=__SCREAMING_SNAKE_CASE							)			,							)
	print(
	    'least_common_multiple_fast():'			,							timeit('least_common_multiple_fast(1000, 999)'			,							setup=__SCREAMING_SNAKE_CASE							)			,							)







class 	A_       (      unittest.TestCase       ):




	'''simple docstring'''


	_UpperCamelCase					:					Any										=	(
	    (10, 20),
	    (13, 15),
	    (4, 31),
	    (10, 42),
	    (43, 34),
	    (5, 12),
	    (12, 25),
	    (10, 25),
	    (6, 9),
	)
	_UpperCamelCase					:					int										=	(20, 195, 124, 210, 1462, 60, 300, 50, 18)





	def      SCREAMING_SNAKE_CASE__						(	self	):
		for i, (first_num, second_num) in enumerate(self.test_inputs	):
			lowercase					  =   least_common_multiple_slow(snake_case		,   snake_case	)
			lowercase					  =   least_common_multiple_fast(snake_case		,   snake_case	)
			with self.subTest(i=snake_case	):
				self.assertEqual(snake_case		,   self.expected_results[i]	)
				self.assertEqual(snake_case		,   self.expected_results[i]	)


if __name__ == "__main__":
	benchmark()
	unittest.main()

