"""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
__lowerCamelCase									=	"\\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
__lowerCamelCase									=	"\\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
__lowerCamelCase									=	""

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

# 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)
__lowerCamelCase									=	{
    "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			):
						lowerCAmelCase__	:    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')
						lowerCAmelCase__	:    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'			),
						]

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





						def 					snake_case__						(							self  )       ->					List[str]:





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





						def 					snake_case__						(							self		,__UpperCAmelCase  )       ->					Optional[int]:
													A__						  =				_URLS[self.config.name]
													A__						  =				dl_manager.download_and_extract(__UpperCAmelCase  )
													return [
													    datasets.SplitGenerator(
													        name=datasets.Split.TRAIN		,gen_kwargs={
													            'filepath': os.path.join(__UpperCAmelCase		,'train.jsonl'  ),
													            'split': 'train',
													        }		,),
													    datasets.SplitGenerator(
													        name=datasets.Split.VALIDATION		,gen_kwargs={
													            'filepath': os.path.join(__UpperCAmelCase		,'dev.jsonl'  ),
													            'split': 'dev',
													        }		,),
													    datasets.SplitGenerator(
													        name=datasets.Split.TEST		,gen_kwargs={
													            'filepath': os.path.join(__UpperCAmelCase		,'test.jsonl'  ),
													            'split': 'test'
													        }		,),
													]





						def 					snake_case__						(							self		,__UpperCAmelCase		,__UpperCAmelCase  )       ->					List[str]:





													with open(__UpperCAmelCase		,encoding='utf-8'  ) as f:
																				for key, row in enumerate(__UpperCAmelCase  ):
																											A__						  =				json.loads(__UpperCAmelCase  )
																											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"""
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

# Load iris file
lowercase__   			=      load_iris()
iris.keys()


print(f"Target names: \n {iris.target_names} ")
print(f"\n Features: \n {iris.feature_names}")

# Train set e Test set
lowercase__			,   lowercase__			,   lowercase__			,   lowercase__   			=      train_test_split(
    iris['data'], iris['target'], random_state=4
)

# KNN

lowercase__   			=      KNeighborsClassifier(n_neighbors=1)
knn.fit(X_train, y_train)

# new array to test
lowercase__   			=      [[1, 2, 1, 4], [2, 3, 4, 5]]

lowercase__   			=      knn.predict(X_new)

print(
    f"\nNew array: \n {X_new}\n\nTarget Names Prediction: \n"
    f" {iris['target_names'][prediction]}"
)


