



'''simple docstring'''







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      lowerCamelCase__     (     datasets.GeneratorBasedBuilder				):






	'''simple docstring'''

	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      lowercase__							(  self		:  int					)     ->			Union[str, Any]:




								'''simple docstring'''





								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      lowercase__							(  self		:  Tuple   ,		__A		:  Tuple					)     ->			Optional[int]:




								'''simple docstring'''





								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      lowercase__							(  self		:  int   ,		__A		:  List[Any]   ,		__A		:  int					)     ->			List[str]:




								'''simple docstring'''





								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"],
																													}










'''simple docstring'''







_UpperCamelCase  						=			{
    "kilogram": 1,
    "gram": pow(10, 3),
    "milligram": pow(10, 6),
    "metric-ton": pow(10, -3),
    "long-ton": 0.0009842073,
    "short-ton": 0.0011023122,
    "pound": 2.2046244202,
    "stone": 0.1574731728,
    "ounce": 35.273990723,
    "carrat": 5000,
    "atomic-mass-unit": 6.0_2213_6652e26,
}

_UpperCamelCase  						=			{
    "kilogram": 1,
    "gram": pow(10, -3),
    "milligram": pow(10, -6),
    "metric-ton": pow(10, 3),
    "long-ton": 1016.04608,
    "short-ton": 907.184,
    "pound": 0.453592,
    "stone": 6.35029,
    "ounce": 0.0283495,
    "carrat": 0.0002,
    "atomic-mass-unit": 1.6_6054_0199e-27,
}
def 			_lowerCAmelCase(      UpperCAmelCase_      :	str					, UpperCAmelCase_      :	str					, UpperCAmelCase_      :	float						) ->							float:
							if to_type not in KILOGRAM_CHART or from_type not in WEIGHT_TYPE_CHART:
														lowerCAmelCase__  =   (
														    F'''Invalid \'from_type\' or \'to_type\' value: {from_type!r}, {to_type!r}\n'''
														    F'''Supported values are: {", ".join(UpperCAmelCase_						)}'''
														)
														raise ValueError(UpperCAmelCase_						)
							return value * KILOGRAM_CHART[to_type] * WEIGHT_TYPE_CHART[from_type]


if __name__ == "__main__":
		import doctest

		doctest.testmod()





