





'''simple docstring'''






import argparse
import json
import logging
import os
import sys
from unittest import skip
from unittest.mock import patch

import tensorflow as tf

from transformers.testing_utils import TestCasePlus, get_gpu_count, slow


__UpperCamelCase      :   str								=     [
    os.path.join(os.path.dirname(__file__), dirname)
    for dirname in [
        '''text-generation''',
        '''text-classification''',
        '''token-classification''',
        '''language-modeling''',
        '''multiple-choice''',
        '''question-answering''',
        '''summarization''',
        '''translation''',
        '''image-classification''',
    ]
]
sys.path.extend(SRC_DIRS)


if SRC_DIRS is not None:
	import run_clm
	import run_image_classification
	import run_mlm
	import run_ner
	import run_qa as run_squad
	import run_summarization
	import run_swag
	import run_text_classification
	import run_translation


logging.basicConfig(level=logging.DEBUG)

__UpperCamelCase      :   Union[str, Any]								=     logging.getLogger()





def      lowercase  (  ):



				"""simple docstring"""


				_A :				Tuple				=  argparse.ArgumentParser()
				parser.add_argument('''-f''')
				_A :				int				=  parser.parse_args()
				return args.f





def      lowercase  (  lowerCAmelCase :						Optional[int]):



				"""simple docstring"""


				_A :				str				=  {}
				_A :				Optional[int]				=  os.path.join(lowerCAmelCase   , '''all_results.json''')
				if os.path.exists(lowerCAmelCase):
								with open(lowerCAmelCase   , '''r''') as f:
												_A :				int				=  json.load(lowerCAmelCase)
				else:
								raise ValueError(f"""can't find {path}""")
				return results





def      lowercase  (  ):



				"""simple docstring"""


				return bool(tf.config.list_physical_devices('''GPU'''))


__UpperCamelCase      :   List[str]								=     logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)




class  lowerCamelCase__				(						snake_case_						):


	"""simple docstring"""





	@skip('''Skipping until shape inference for to_tf_dataset PR is merged.'''			)
	def 				_lowerCamelCase				(					self			)       ->				str:
					_A :				Any				=  self.get_auto_remove_tmp_dir()
					_A :				int				=  F"""
            run_text_classification.py
            --model_name_or_path distilbert-base-uncased
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv
            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv
            --do_train
            --do_eval
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --learning_rate=1e-4
            --max_steps=10
            --warmup_steps=2
            --seed=42
            --max_seq_length=128
            """.split()

					if is_cuda_available():
									testargs.append('''--fp16'''			)

					with patch.object(UpperCAmelCase__   ,     '''argv'''   ,     UpperCAmelCase__			):
									run_text_classification.main()
									# Reset the mixed precision policy so we don't break other tests
									tf.keras.mixed_precision.set_global_policy('''float32'''			)
									_A :				Any				=  get_results(UpperCAmelCase__			)
									self.assertGreaterEqual(result['''eval_accuracy''']   ,     0.7_5			)




	def 				_lowerCamelCase				(					self			)       ->				Union[str, Any]:
					_A :				Tuple				=  self.get_auto_remove_tmp_dir()
					_A :				Optional[int]				=  F"""
            run_clm.py
            --model_name_or_path distilgpt2
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --do_train
            --do_eval
            --block_size 128
            --per_device_train_batch_size 2
            --per_device_eval_batch_size 1
            --num_train_epochs 2
            --output_dir {tmp_dir}
            --overwrite_output_dir
            """.split()

					if len(tf.config.list_physical_devices('''GPU'''			)			) > 1:
									# Skipping because there are not enough batches to train the model + would need a drop_last to work.
									return

					with patch.object(UpperCAmelCase__   ,     '''argv'''   ,     UpperCAmelCase__			):
									run_clm.main()
									_A :				Dict				=  get_results(UpperCAmelCase__			)
									self.assertLess(result['''eval_perplexity''']   ,     1_0_0			)




	def 				_lowerCamelCase				(					self			)       ->				Any:
					_A :				Any				=  self.get_auto_remove_tmp_dir()
					_A :				Tuple				=  F"""
            run_mlm.py
            --model_name_or_path distilroberta-base
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --max_seq_length 64
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --do_train
            --do_eval
            --prediction_loss_only
            --num_train_epochs=1
            --learning_rate=1e-4
        """.split()

					with patch.object(UpperCAmelCase__   ,     '''argv'''   ,     UpperCAmelCase__			):
									run_mlm.main()
									_A :				List[Any]				=  get_results(UpperCAmelCase__			)
									self.assertLess(result['''eval_perplexity''']   ,     4_2			)




	def 				_lowerCamelCase				(					self			)       ->				int:
					# with so little data distributed training needs more epochs to get the score on par with 0/1 gpu
					_A :				List[str]				=  7 if get_gpu_count() > 1 else 2

					_A :				int				=  self.get_auto_remove_tmp_dir()
					_A :				Tuple				=  F"""
            run_ner.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/conll/sample.json
            --validation_file tests/fixtures/tests_samples/conll/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --do_train
            --do_eval
            --warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=2
            --num_train_epochs={epochs}
            --seed 7
        """.split()

					with patch.object(UpperCAmelCase__   ,     '''argv'''   ,     UpperCAmelCase__			):
									run_ner.main()
									_A :				Union[str, Any]				=  get_results(UpperCAmelCase__			)
									self.assertGreaterEqual(result['''accuracy''']   ,     0.7_5			)




	def 				_lowerCamelCase				(					self			)       ->				List[Any]:
					_A :				Optional[int]				=  self.get_auto_remove_tmp_dir()
					_A :				List[Any]				=  F"""
            run_qa.py
            --model_name_or_path bert-base-uncased
            --version_2_with_negative
            --train_file tests/fixtures/tests_samples/SQUAD/sample.json
            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --max_steps=10
            --warmup_steps=2
            --do_train
            --do_eval
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
        """.split()

					with patch.object(UpperCAmelCase__   ,     '''argv'''   ,     UpperCAmelCase__			):
									run_squad.main()
									_A :				List[Any]				=  get_results(UpperCAmelCase__			)
									self.assertGreaterEqual(result['''f1''']   ,     3_0			)
									self.assertGreaterEqual(result['''exact''']   ,     3_0			)




	def 				_lowerCamelCase				(					self			)       ->				Union[str, Any]:
					_A :				Union[str, Any]				=  self.get_auto_remove_tmp_dir()
					_A :				int				=  F"""
            run_swag.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/swag/sample.json
            --validation_file tests/fixtures/tests_samples/swag/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --max_steps=20
            --warmup_steps=2
            --do_train
            --do_eval
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
        """.split()

					with patch.object(UpperCAmelCase__   ,     '''argv'''   ,     UpperCAmelCase__			):
									run_swag.main()
									_A :				Union[str, Any]				=  get_results(UpperCAmelCase__			)
									self.assertGreaterEqual(result['''val_accuracy''']   ,     0.8			)




	@slow
	def 				_lowerCamelCase				(					self			)       ->				Optional[Any]:
					_A :				Optional[Any]				=  self.get_auto_remove_tmp_dir()
					_A :				List[str]				=  F"""
            run_summarization.py
            --model_name_or_path t5-small
            --train_file tests/fixtures/tests_samples/xsum/sample.json
            --validation_file tests/fixtures/tests_samples/xsum/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --max_steps=50
            --warmup_steps=8
            --do_train
            --do_eval
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
        """.split()

					with patch.object(UpperCAmelCase__   ,     '''argv'''   ,     UpperCAmelCase__			):
									run_summarization.main()
									_A :				List[Any]				=  get_results(UpperCAmelCase__			)
									self.assertGreaterEqual(result['''rouge1''']   ,     1_0			)
									self.assertGreaterEqual(result['''rouge2''']   ,     2			)
									self.assertGreaterEqual(result['''rougeL''']   ,     7			)
									self.assertGreaterEqual(result['''rougeLsum''']   ,     7			)




	@slow
	def 				_lowerCamelCase				(					self			)       ->				Optional[Any]:
					_A :				Any				=  self.get_auto_remove_tmp_dir()
					_A :				Optional[int]				=  F"""
            run_translation.py
            --model_name_or_path Rocketknight1/student_marian_en_ro_6_1
            --source_lang en
            --target_lang ro
            --train_file tests/fixtures/tests_samples/wmt16/sample.json
            --validation_file tests/fixtures/tests_samples/wmt16/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --warmup_steps=8
            --do_train
            --do_eval
            --learning_rate=3e-3
            --num_train_epochs 12
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --source_lang en_XX
            --target_lang ro_RO
        """.split()

					with patch.object(UpperCAmelCase__   ,     '''argv'''   ,     UpperCAmelCase__			):
									run_translation.main()
									_A :				List[str]				=  get_results(UpperCAmelCase__			)
									self.assertGreaterEqual(result['''bleu''']   ,     3_0			)




	def 				_lowerCamelCase				(					self			)       ->				List[Any]:
					_A :				int				=  self.get_auto_remove_tmp_dir()
					_A :				Tuple				=  F"""
            run_image_classification.py
            --dataset_name hf-internal-testing/cats_vs_dogs_sample
            --model_name_or_path microsoft/resnet-18
            --do_train
            --do_eval
            --learning_rate 1e-4
            --per_device_train_batch_size 2
            --per_device_eval_batch_size 1
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --dataloader_num_workers 16
            --num_train_epochs 2
            --train_val_split 0.1
            --seed 42
            --ignore_mismatched_sizes True
            """.split()

					with patch.object(UpperCAmelCase__   ,     '''argv'''   ,     UpperCAmelCase__			):
									run_image_classification.main()
									_A :				Optional[Any]				=  get_results(UpperCAmelCase__			)
									self.assertGreaterEqual(result['''accuracy''']   ,     0.7			)







'''simple docstring'''






import importlib
import inspect
from functools import wraps
from typing import TYPE_CHECKING, Optional, Union

from .download.streaming_download_manager import (
    xbasename,
    xdirname,
    xet_parse,
    xexists,
    xgetsize,
    xglob,
    xgzip_open,
    xisdir,
    xisfile,
    xjoin,
    xlistdir,
    xnumpy_load,
    xopen,
    xpandas_read_csv,
    xpandas_read_excel,
    xPath,
    xrelpath,
    xsio_loadmat,
    xsplit,
    xsplitext,
    xwalk,
    xxml_dom_minidom_parse,
)
from .utils.logging import get_logger
from .utils.patching import patch_submodule
from .utils.py_utils import get_imports


__UpperCamelCase      :   List[Any]								=     get_logger(__name__)


if TYPE_CHECKING:
	from .builder import DatasetBuilder





def      lowercase  (  lowerCAmelCase :						List[str]   , lowerCAmelCase :						Optional[Union[str, bool]] = None):



				"""simple docstring"""


				_A :				Union[str, Any]				=  importlib.import_module(lowerCAmelCase)

				# TODO(QL): always update the module to add subsequent new authentication
				if hasattr(lowerCAmelCase   , '''_patched_for_streaming''') and module._patched_for_streaming:
								return

				def wrap_auth(lowerCAmelCase :						Union[str, Any]):
								@wraps(lowerCAmelCase)
								def wrapper(*lowerCAmelCase :						Union[str, Any]   , **lowerCAmelCase :						int):
												return function(*lowerCAmelCase   , use_auth_token=lowerCAmelCase   , **lowerCAmelCase)

								_A :				Optional[Any]				=  '''wrap_auth'''
								return wrapper

				# open files in a streaming fashion
				patch_submodule(lowerCAmelCase   , '''open'''   , wrap_auth(lowerCAmelCase)).start()
				patch_submodule(lowerCAmelCase   , '''os.listdir'''   , wrap_auth(lowerCAmelCase)).start()
				patch_submodule(lowerCAmelCase   , '''os.walk'''   , wrap_auth(lowerCAmelCase)).start()
				patch_submodule(lowerCAmelCase   , '''glob.glob'''   , wrap_auth(lowerCAmelCase)).start()
				# allow to navigate in remote zip files
				patch_submodule(lowerCAmelCase   , '''os.path.join'''   , lowerCAmelCase).start()
				patch_submodule(lowerCAmelCase   , '''os.path.dirname'''   , lowerCAmelCase).start()
				patch_submodule(lowerCAmelCase   , '''os.path.basename'''   , lowerCAmelCase).start()
				patch_submodule(lowerCAmelCase   , '''os.path.relpath'''   , lowerCAmelCase).start()
				patch_submodule(lowerCAmelCase   , '''os.path.split'''   , lowerCAmelCase).start()
				patch_submodule(lowerCAmelCase   , '''os.path.splitext'''   , lowerCAmelCase).start()
				# allow checks on paths
				patch_submodule(lowerCAmelCase   , '''os.path.exists'''   , wrap_auth(lowerCAmelCase)).start()
				patch_submodule(lowerCAmelCase   , '''os.path.isdir'''   , wrap_auth(lowerCAmelCase)).start()
				patch_submodule(lowerCAmelCase   , '''os.path.isfile'''   , wrap_auth(lowerCAmelCase)).start()
				patch_submodule(lowerCAmelCase   , '''os.path.getsize'''   , wrap_auth(lowerCAmelCase)).start()
				patch_submodule(lowerCAmelCase   , '''pathlib.Path'''   , lowerCAmelCase).start()
				# file readers
				patch_submodule(lowerCAmelCase   , '''gzip.open'''   , wrap_auth(lowerCAmelCase)).start()
				patch_submodule(lowerCAmelCase   , '''numpy.load'''   , wrap_auth(lowerCAmelCase)).start()
				patch_submodule(lowerCAmelCase   , '''pandas.read_csv'''   , wrap_auth(lowerCAmelCase)   , attrs=['''__version__''']).start()
				patch_submodule(lowerCAmelCase   , '''pandas.read_excel'''   , wrap_auth(lowerCAmelCase)   , attrs=['''__version__''']).start()
				patch_submodule(lowerCAmelCase   , '''scipy.io.loadmat'''   , wrap_auth(lowerCAmelCase)   , attrs=['''__version__''']).start()
				patch_submodule(lowerCAmelCase   , '''xml.etree.ElementTree.parse'''   , wrap_auth(lowerCAmelCase)).start()
				patch_submodule(lowerCAmelCase   , '''xml.dom.minidom.parse'''   , wrap_auth(lowerCAmelCase)).start()
				_A :				Optional[int]				=  True





def      lowercase  (  lowerCAmelCase :						"DatasetBuilder"):



				"""simple docstring"""


				extend_module_for_streaming(builder.__module__   , use_auth_token=builder.use_auth_token)
				# if needed, we also have to extend additional internal imports (like wmt14 -> wmt_utils)
				if not builder.__module__.startswith('''datasets.'''):  # check that it's not a packaged builder like csv
								for imports in get_imports(inspect.getfile(builder.__class__)):
												if imports[0] == "internal":
																_A :				Optional[int]				=  imports[1]
																_A :				str				=  '''.'''.join(builder.__module__.split('''.''')[:-1] + [internal_import_name])
																extend_module_for_streaming(lowerCAmelCase   , use_auth_token=builder.use_auth_token)

    # builders can inherit from other builders that might use streaming functionality
    # (for example, ImageFolder and AudioFolder inherit from FolderBuilder which implements examples generation)
    # but these parents builders are not patched automatically as they are not instantiated, so we patch them here
				from .builder import DatasetBuilder

				_A :				Tuple				=  [
				    cls.__module__
				    for cls in type(lowerCAmelCase).__mro__[1:]  # make sure it's not the same module we've already patched
				    if issubclass(cls   , lowerCAmelCase) and cls.__module__ != DatasetBuilder.__module__
				]  # check it's not a standard builder from datasets.builder
				for module in parent_builder_modules:
								extend_module_for_streaming(lowerCAmelCase   , use_auth_token=builder.use_auth_token)
