



import io
import json

import fsspec
import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.json import JsonDatasetReader, JsonDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases


def A						(       __UpperCamelCase ,	__UpperCamelCase					)						->      Optional[Any]:
			assert isinstance(__UpperCamelCase ,	__UpperCamelCase					)
			assert dataset.num_rows == 4
			assert dataset.num_columns == 3
			assert dataset.column_names == ["col_1", "col_2", "col_3"]
			for feature, expected_dtype in expected_features.items():
						assert dataset.features[feature].dtype == expected_dtype


@pytest.mark.parametrize('keep_in_memory' ,	[False, True]					)
def A						(       __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase					)						->      Optional[Any]:
			A__       =    tmp_path / 'cache'
			A__       =    {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
			with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
						A__       =    JsonDatasetReader(__UpperCamelCase ,	cache_dir=__UpperCamelCase ,	keep_in_memory=__UpperCamelCase					).read()
			_check_json_dataset(__UpperCamelCase ,	__UpperCamelCase					)


@pytest.mark.parametrize(
    'features' ,	[
        None,
        {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'},
        {'col_1': 'string', 'col_2': 'string', 'col_3': 'string'},
        {'col_1': 'int32', 'col_2': 'int32', 'col_3': 'int32'},
        {'col_1': 'float32', 'col_2': 'float32', 'col_3': 'float32'},
    ] ,	)
def A						(       __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase					)						->      str:
			A__       =    tmp_path / 'cache'
			A__       =    {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
			A__       =    features.copy() if features else default_expected_features
			A__       =    (
			    Features({feature: Value(__UpperCamelCase					) for feature, dtype in features.items()}					) if features is not None else None
			)
			A__       =    JsonDatasetReader(__UpperCamelCase ,	features=__UpperCamelCase ,	cache_dir=__UpperCamelCase					).read()
			_check_json_dataset(__UpperCamelCase ,	__UpperCamelCase					)


@pytest.mark.parametrize(
    'features' ,	[
        None,
        {'col_3': 'float64', 'col_1': 'string', 'col_2': 'int64'},
    ] ,	)
def A						(       __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase					)						->      List[Any]:
			A__       =    tmp_path / 'cache'
			A__       =    {'col_3': 'float64', 'col_1': 'string', 'col_2': 'int64'}
			A__       =    features.copy() if features else default_expected_features
			A__       =    (
			    Features({feature: Value(__UpperCamelCase					) for feature, dtype in features.items()}					) if features is not None else None
			)
			A__       =    JsonDatasetReader(__UpperCamelCase ,	features=__UpperCamelCase ,	cache_dir=__UpperCamelCase					).read()
			assert isinstance(__UpperCamelCase ,	__UpperCamelCase					)
			assert dataset.num_rows == 2
			assert dataset.num_columns == 3
			assert dataset.column_names == ["col_3", "col_1", "col_2"]
			for feature, expected_dtype in expected_features.items():
						assert dataset.features[feature].dtype == expected_dtype


def A						(       __UpperCamelCase ,	__UpperCamelCase					)						->      List[Any]:
			# jsonl_312_path features are {"col_3": "float64", "col_1": "string", "col_2": "int64"}
			A__       =    {'col_2': 'int64', 'col_3': 'float64', 'col_1': 'string'}
			A__       =    features.copy()
			A__       =    (
			    Features({feature: Value(__UpperCamelCase					) for feature, dtype in features.items()}					) if features is not None else None
			)
			A__       =    tmp_path / 'cache'
			A__       =    JsonDatasetReader(__UpperCamelCase ,	features=__UpperCamelCase ,	cache_dir=__UpperCamelCase					).read()
			assert isinstance(__UpperCamelCase ,	__UpperCamelCase					)
			assert dataset.num_rows == 2
			assert dataset.num_columns == 3
			assert dataset.column_names == ["col_2", "col_3", "col_1"]
			for feature, expected_dtype in expected_features.items():
						assert dataset.features[feature].dtype == expected_dtype


@pytest.mark.parametrize('split' ,	[None, NamedSplit('train'					), 'train', 'test']					)
def A						(       __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase					)						->      int:
			A__       =    tmp_path / 'cache'
			A__       =    {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
			A__       =    JsonDatasetReader(__UpperCamelCase ,	cache_dir=__UpperCamelCase ,	split=__UpperCamelCase					).read()
			_check_json_dataset(__UpperCamelCase ,	__UpperCamelCase					)
			assert dataset.split == split if split else "train"


@pytest.mark.parametrize('path_type' ,	[str, list]					)
def A						(       __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase					)						->      List[str]:
			if issubclass(__UpperCamelCase ,	__UpperCamelCase					):
						A__       =    jsonl_path
			elif issubclass(__UpperCamelCase ,	__UpperCamelCase					):
						A__       =    [jsonl_path]
			A__       =    tmp_path / 'cache'
			A__       =    {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
			A__       =    JsonDatasetReader(__UpperCamelCase ,	cache_dir=__UpperCamelCase					).read()
			_check_json_dataset(__UpperCamelCase ,	__UpperCamelCase					)


def A						(       __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase=("train",)					)						->      Optional[int]:
			assert isinstance(__UpperCamelCase ,	__UpperCamelCase					)
			for split in splits:
						A__       =    dataset_dict[split]
						assert dataset.num_rows == 4
						assert dataset.num_columns == 3
						assert dataset.column_names == ["col_1", "col_2", "col_3"]
						for feature, expected_dtype in expected_features.items():
									assert dataset.features[feature].dtype == expected_dtype


@pytest.mark.parametrize('keep_in_memory' ,	[False, True]					)
def A						(       __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase					)						->      int:
			A__       =    tmp_path / 'cache'
			A__       =    {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
			with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
						A__       =    JsonDatasetReader({'train': jsonl_path} ,	cache_dir=__UpperCamelCase ,	keep_in_memory=__UpperCamelCase					).read()
			_check_json_datasetdict(__UpperCamelCase ,	__UpperCamelCase					)


@pytest.mark.parametrize(
    'features' ,	[
        None,
        {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'},
        {'col_1': 'string', 'col_2': 'string', 'col_3': 'string'},
        {'col_1': 'int32', 'col_2': 'int32', 'col_3': 'int32'},
        {'col_1': 'float32', 'col_2': 'float32', 'col_3': 'float32'},
    ] ,	)
def A						(       __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase					)						->      Union[str, Any]:
			A__       =    tmp_path / 'cache'
			A__       =    {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
			A__       =    features.copy() if features else default_expected_features
			A__       =    (
			    Features({feature: Value(__UpperCamelCase					) for feature, dtype in features.items()}					) if features is not None else None
			)
			A__       =    JsonDatasetReader({'train': jsonl_path} ,	features=__UpperCamelCase ,	cache_dir=__UpperCamelCase					).read()
			_check_json_datasetdict(__UpperCamelCase ,	__UpperCamelCase					)


@pytest.mark.parametrize('split' ,	[None, NamedSplit('train'					), 'train', 'test']					)
def A						(       __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase					)						->      Tuple:
			if split:
						A__       =    {split: jsonl_path}
			else:
						A__       =    'train'
						A__       =    {'train': jsonl_path, 'test': jsonl_path}
			A__       =    tmp_path / 'cache'
			A__       =    {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
			A__       =    JsonDatasetReader(__UpperCamelCase ,	cache_dir=__UpperCamelCase					).read()
			_check_json_datasetdict(__UpperCamelCase ,	__UpperCamelCase ,	splits=list(path.keys()					)					)
			assert all(dataset[split].split == split for split in path.keys()					)


def A						(       __UpperCamelCase					)						->      List[str]:
			return json.load(__UpperCamelCase					)


def A						(       __UpperCamelCase					)						->      Any:
			return [json.loads(__UpperCamelCase					) for line in buffer]






class      __lowerCAmelCase     :
					"""simple docstring"""






					@pytest.mark.parametrize('lines, load_json_function'				,					[(True, load_json_lines), (False, load_json)]					)
					def     _a							(     self					:       int				,					_snake_case					:       Dict				,					_snake_case					:       int				,					_snake_case					:       Any					):






								"""simple docstring"""


								with io.BytesIO() as buffer:
											JsonDatasetWriter(_snake_case				,					_snake_case				,					lines=_snake_case					).write()
											buffer.seek(0					)
											A__       =    load_json_function(_snake_case					)
								assert isinstance(_snake_case				,					_snake_case					)
								assert isinstance(exported_content[0]				,					_snake_case					)
								assert len(_snake_case					) == 10



					@pytest.mark.parametrize(
					    'orient, container, keys, len_at'				,					[
					        ('records', list, {'tokens', 'labels', 'answers', 'id'}, None),
					        ('split', dict, {'columns', 'data'}, 'data'),
					        ('index', dict, set('0123456789'					), None),
					        ('columns', dict, {'tokens', 'labels', 'answers', 'id'}, 'tokens'),
					        ('values', list, None, None),
					        ('table', dict, {'schema', 'data'}, 'data'),
					    ]				,					)
					def     _a							(     self					:       Optional[int]				,					_snake_case					:       Dict				,					_snake_case					:       Union[str, Any]				,					_snake_case					:       str				,					_snake_case					:       Optional[Any]				,					_snake_case					:       str					):






								"""simple docstring"""


								with io.BytesIO() as buffer:
											JsonDatasetWriter(_snake_case				,					_snake_case				,					lines=_snake_case				,					orient=_snake_case					).write()
											buffer.seek(0					)
											A__       =    load_json(_snake_case					)
								assert isinstance(_snake_case				,					_snake_case					)
								if keys:
											if container is dict:
														assert exported_content.keys() == keys
											else:
														assert exported_content[0].keys() == keys
								else:
											assert not hasattr(_snake_case				,					'keys'					) and not hasattr(exported_content[0]				,					'keys'					)
								if len_at:
											assert len(exported_content[len_at]					) == 10
								else:
											assert len(_snake_case					) == 10



					@pytest.mark.parametrize('lines, load_json_function'				,					[(True, load_json_lines), (False, load_json)]					)
					def     _a							(     self					:       Optional[Any]				,					_snake_case					:       List[Any]				,					_snake_case					:       Tuple				,					_snake_case					:       Tuple					):






								"""simple docstring"""


								with io.BytesIO() as buffer:
											JsonDatasetWriter(_snake_case				,					_snake_case				,					lines=_snake_case				,					num_proc=2					).write()
											buffer.seek(0					)
											A__       =    load_json_function(_snake_case					)
								assert isinstance(_snake_case				,					_snake_case					)
								assert isinstance(exported_content[0]				,					_snake_case					)
								assert len(_snake_case					) == 10



					@pytest.mark.parametrize(
					    'orient, container, keys, len_at'				,					[
					        ('records', list, {'tokens', 'labels', 'answers', 'id'}, None),
					        ('split', dict, {'columns', 'data'}, 'data'),
					        ('index', dict, set('0123456789'					), None),
					        ('columns', dict, {'tokens', 'labels', 'answers', 'id'}, 'tokens'),
					        ('values', list, None, None),
					        ('table', dict, {'schema', 'data'}, 'data'),
					    ]				,					)
					def     _a							(     self					:       Union[str, Any]				,					_snake_case					:       Any				,					_snake_case					:       Optional[int]				,					_snake_case					:       Union[str, Any]				,					_snake_case					:       Union[str, Any]				,					_snake_case					:       Tuple					):






								"""simple docstring"""


								with io.BytesIO() as buffer:
											JsonDatasetWriter(_snake_case				,					_snake_case				,					lines=_snake_case				,					orient=_snake_case				,					num_proc=2					).write()
											buffer.seek(0					)
											A__       =    load_json(_snake_case					)
								assert isinstance(_snake_case				,					_snake_case					)
								if keys:
											if container is dict:
														assert exported_content.keys() == keys
											else:
														assert exported_content[0].keys() == keys
								else:
											assert not hasattr(_snake_case				,					'keys'					) and not hasattr(exported_content[0]				,					'keys'					)
								if len_at:
											assert len(exported_content[len_at]					) == 10
								else:
											assert len(_snake_case					) == 10



					def     _a							(     self					:       Tuple				,					_snake_case					:       Optional[int]					):






								"""simple docstring"""


								with pytest.raises(_snake_case					):
											with io.BytesIO() as buffer:
														JsonDatasetWriter(_snake_case				,					_snake_case				,					num_proc=0					)



					@pytest.mark.parametrize('compression, extension'				,					[('gzip', 'gz'), ('bz2', 'bz2'), ('xz', 'xz')]					)
					def     _a							(     self					:       Optional[int]				,					_snake_case					:       Optional[Any]				,					_snake_case					:       str				,					_snake_case					:       List[str]				,					_snake_case					:       Union[str, Any]				,					_snake_case					:       Dict					):






								"""simple docstring"""


								A__       =    tmp_path_factory.mktemp('data'					) / F'''test.json.{extension}'''
								A__       =    str(shared_datadir / F'''test_file.json.{extension}'''					)
								JsonDatasetWriter(_snake_case				,					_snake_case				,					compression=_snake_case					).write()

								with fsspec.open(_snake_case				,					'rb'				,					compression='infer'					) as f:
											A__       =    f.read()
								with fsspec.open(_snake_case				,					'rb'				,					compression='infer'					) as f:
											A__       =    f.read()
								assert exported_content == original_content









import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import numpy as np
from utils_multiple_choice import MultipleChoiceDataset, Split, processors

import transformers
from transformers import (
    AutoConfig,
    AutoModelForMultipleChoice,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import is_main_process


SCREAMING_SNAKE_CASE__       =      logging.getLogger(__name__)


def A						(       __UpperCamelCase ,	__UpperCamelCase					)						->      List[Any]:
			return (preds == labels).mean()


@dataclass
class      __lowerCAmelCase     :
					"""simple docstring"""






					A__				:		str			       =    field(
					    metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}      )
					A__				:		Optional[str]			       =    field(
					    default=UpperCAmelCase_							,     metadata={"help": "Pretrained config name or path if not the same as model_name"}      )
					A__				:		Optional[str]			       =    field(
					    default=UpperCAmelCase_							,     metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}      )
					A__				:		Optional[str]			       =    field(
					    default=UpperCAmelCase_							,     metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}							,     )







@dataclass
class      __lowerCAmelCase     :
					"""simple docstring"""






					A__				:		str			       =    field(metadata={"help": "The name of the task to train on: " + ", ".join(processors.keys()      )}      )
					A__				:		str			       =    field(metadata={"help": "Should contain the data files for the task."}      )
					A__				:		int			       =    field(
					    default=1_28							,     metadata={
					        "help": (
					            "The maximum total input sequence length after tokenization. Sequences longer "
					            "than this will be truncated, sequences shorter will be padded."
					        )
					    }							,     )
					A__				:		bool			       =    field(
					    default=UpperCAmelCase_							,     metadata={"help": "Overwrite the cached training and evaluation sets"}      )







def A						(       )						->      Any:
			# See all possible arguments in src/transformers/training_args.py
			# or by passing the --help flag to this script.
			# We now keep distinct sets of args, for a cleaner separation of concerns.

			A__       =    HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)					)
			A__     , A__     , A__       =    parser.parse_args_into_dataclasses()

			if (
			    os.path.exists(training_args.output_dir					)
			    and os.listdir(training_args.output_dir					)
			    and training_args.do_train
			    and not training_args.overwrite_output_dir
			):
						raise ValueError(
						    f'''Output directory ({training_args.output_dir}) already exists and is not empty. Use'''
						    ' --overwrite_output_dir to overcome.'					)

			# Setup logging
			logging.basicConfig(
			    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' ,	datefmt='%m/%d/%Y %H:%M:%S' ,	level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN ,	)
			logger.warning(
			    'Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s' ,	training_args.local_rank ,	training_args.device ,	training_args.n_gpu ,	bool(training_args.local_rank != -1					) ,	training_args.fpaa ,	)
			# Set the verbosity to info of the Transformers logger (on main process only):
			if is_main_process(training_args.local_rank					):
						transformers.utils.logging.set_verbosity_info()
						transformers.utils.logging.enable_default_handler()
						transformers.utils.logging.enable_explicit_format()
			logger.info('Training/evaluation parameters %s' ,	__UpperCamelCase					)

			# Set seed
			set_seed(training_args.seed					)

			try:
						A__       =    processors[data_args.task_name]()
						A__       =    processor.get_labels()
						A__       =    len(__UpperCamelCase					)
			except KeyError:
						raise ValueError('Task not found: %s' % (data_args.task_name)					)

			# Load pretrained model and tokenizer
			#
			# Distributed training:
			# The .from_pretrained methods guarantee that only one local process can concurrently
			# download model & vocab.

			A__       =    AutoConfig.from_pretrained(
			    model_args.config_name if model_args.config_name else model_args.model_name_or_path ,	num_labels=__UpperCamelCase ,	finetuning_task=data_args.task_name ,	cache_dir=model_args.cache_dir ,	)
			A__       =    AutoTokenizer.from_pretrained(
			    model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path ,	cache_dir=model_args.cache_dir ,	)
			A__       =    AutoModelForMultipleChoice.from_pretrained(
			    model_args.model_name_or_path ,	from_tf=bool('.ckpt' in model_args.model_name_or_path					) ,	config=__UpperCamelCase ,	cache_dir=model_args.cache_dir ,	)

			# Get datasets
			A__       =    (
			    MultipleChoiceDataset(
			        data_dir=data_args.data_dir ,	tokenizer=__UpperCamelCase ,	task=data_args.task_name ,	max_seq_length=data_args.max_seq_length ,	overwrite_cache=data_args.overwrite_cache ,	mode=Split.train ,	)
			    if training_args.do_train
			    else None
			)
			A__       =    (
			    MultipleChoiceDataset(
			        data_dir=data_args.data_dir ,	tokenizer=__UpperCamelCase ,	task=data_args.task_name ,	max_seq_length=data_args.max_seq_length ,	overwrite_cache=data_args.overwrite_cache ,	mode=Split.dev ,	)
			    if training_args.do_eval
			    else None
			)

			def compute_metrics(__UpperCamelCase					) -> Dict:
						A__       =    np.argmax(p.predictions ,	axis=1					)
						return {"acc": simple_accuracy(__UpperCamelCase ,	p.label_ids					)}

			# Data collator
			A__       =    DataCollatorWithPadding(__UpperCamelCase ,	pad_to_multiple_of=8					) if training_args.fpaa else None

			# Initialize our Trainer
			A__       =    Trainer(
			    model=__UpperCamelCase ,	args=__UpperCamelCase ,	train_dataset=__UpperCamelCase ,	eval_dataset=__UpperCamelCase ,	compute_metrics=__UpperCamelCase ,	data_collator=__UpperCamelCase ,	)

			# Training
			if training_args.do_train:
						trainer.train(
						    model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path					) else None					)
						trainer.save_model()
						# For convenience, we also re-save the tokenizer to the same directory,
						# so that you can share your model easily on huggingface.co/models =)
						if trainer.is_world_master():
									tokenizer.save_pretrained(training_args.output_dir					)

    # Evaluation
			A__       =    {}
			if training_args.do_eval:
						logger.info('*** Evaluate ***'					)

						A__       =    trainer.evaluate()

						A__       =    os.path.join(training_args.output_dir ,	'eval_results.txt'					)
						if trainer.is_world_master():
									with open(__UpperCamelCase ,	'w'					) as writer:
												logger.info('***** Eval results *****'					)
												for key, value in result.items():
															logger.info('  %s = %s' ,	__UpperCamelCase ,	__UpperCamelCase					)
															writer.write('%s = %s\n' % (key, value)					)

												results.update(__UpperCamelCase					)

			return results


def A						(       __UpperCamelCase					)						->      List[Any]:
			# For xla_spawn (TPUs)
			main()


if __name__ == "__main__":
							main()




