






import shutil
import tempfile
import unittest
from unittest.mock import patch

from transformers import (
    DefaultFlowCallback,
    IntervalStrategy,
    PrinterCallback,
    ProgressCallback,
    Trainer,
    TrainerCallback,
    TrainingArguments,
    is_torch_available,
)
from transformers.testing_utils import require_torch


if is_torch_available():
					from transformers.trainer import DEFAULT_CALLBACKS

					from .test_trainer import RegressionDataset, RegressionModelConfig, RegressionPreTrainedModel
class 						lowerCamelCase_				(      lowerCamelCase ):







				def __init__(						self     ):
								"""simple docstring"""
								__magic_name__		:Any        =      []







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_init_end'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_train_begin'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_train_end'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_epoch_begin'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_epoch_end'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_step_begin'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_step_end'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_evaluate'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_predict'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_save'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_log'''     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								self.events.append('''on_prediction_step'''     )







@require_torch
class 						lowerCamelCase_				(      unittest.TestCase ):







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      tempfile.mkdtemp()







				def 			A	(						self     ):
								"""simple docstring"""
								shutil.rmtree(self.output_dir     )







				def 			A	(						self       ,					__lowerCAmelCase=0       ,					__lowerCAmelCase=0       ,					__lowerCAmelCase=6_4       ,					__lowerCAmelCase=6_4       ,					__lowerCAmelCase=None       ,					__lowerCAmelCase=False       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								# disable_tqdm in TrainingArguments has a flaky default since it depends on the level of logging. We make sure
								# its set to False since the tests later on depend on its value.
								__magic_name__		:List[Any]        =      RegressionDataset(length=__lowerCAmelCase     )
								__magic_name__		:Any        =      RegressionDataset(length=__lowerCAmelCase     )
								__magic_name__		:Any        =      RegressionModelConfig(a=__lowerCAmelCase       ,					b=__lowerCAmelCase     )
								__magic_name__		:Tuple        =      RegressionPreTrainedModel(__lowerCAmelCase     )

								__magic_name__		:Optional[Any]        =      TrainingArguments(self.output_dir       ,					disable_tqdm=__lowerCAmelCase       ,					report_to=[]       ,					**__lowerCAmelCase     )
								return Trainer(
								    __lowerCAmelCase       ,					__lowerCAmelCase       ,					train_dataset=__lowerCAmelCase       ,					eval_dataset=__lowerCAmelCase       ,					callbacks=__lowerCAmelCase       ,					)







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase     ):
								"""simple docstring"""
								self.assertEqual(len(__lowerCAmelCase     )       ,					len(__lowerCAmelCase     )     )

								# Order doesn't matter
								__magic_name__		:Union[str, Any]        =      sorted(__lowerCAmelCase       ,					key=lambda __lowerCAmelCase     : cb.__name__ if isinstance(__lowerCAmelCase       ,					__lowerCAmelCase     ) else cb.__class__.__name__     )
								__magic_name__		:Optional[int]        =      sorted(__lowerCAmelCase       ,					key=lambda __lowerCAmelCase     : cb.__name__ if isinstance(__lowerCAmelCase       ,					__lowerCAmelCase     ) else cb.__class__.__name__     )

								for cba, cba in zip(__lowerCAmelCase       ,					__lowerCAmelCase     ):
												if isinstance(__lowerCAmelCase       ,					__lowerCAmelCase     ) and isinstance(__lowerCAmelCase       ,					__lowerCAmelCase     ):
																self.assertEqual(__lowerCAmelCase       ,					__lowerCAmelCase     )
												elif isinstance(__lowerCAmelCase       ,					__lowerCAmelCase     ) and not isinstance(__lowerCAmelCase       ,					__lowerCAmelCase     ):
																self.assertEqual(__lowerCAmelCase       ,					cba.__class__     )
												elif not isinstance(__lowerCAmelCase       ,					__lowerCAmelCase     ) and isinstance(__lowerCAmelCase       ,					__lowerCAmelCase     ):
																self.assertEqual(cba.__class__       ,					__lowerCAmelCase     )
												else:
																self.assertEqual(__lowerCAmelCase       ,					__lowerCAmelCase     )







				def 			A	(						self       ,					__lowerCAmelCase     ):
								"""simple docstring"""
								__magic_name__		:Optional[int]        =      ['''on_init_end''', '''on_train_begin''']
								__magic_name__		:Optional[Any]        =      0
								__magic_name__		:str        =      len(trainer.get_eval_dataloader()     )
								__magic_name__		:Optional[int]        =      ['''on_prediction_step'''] * len(trainer.get_eval_dataloader()     ) + ['''on_log''', '''on_evaluate''']
								for _ in range(trainer.state.num_train_epochs     ):
												expected_events.append('''on_epoch_begin'''     )
												for _ in range(__lowerCAmelCase     ):
																step += 1
																expected_events += ["on_step_begin", "on_step_end"]
																if step % trainer.args.logging_steps == 0:
																				expected_events.append('''on_log'''     )
																if trainer.args.evaluation_strategy == IntervalStrategy.STEPS and step % trainer.args.eval_steps == 0:
																				expected_events += evaluation_events.copy()
																if step % trainer.args.save_steps == 0:
																				expected_events.append('''on_save'''     )
												expected_events.append('''on_epoch_end'''     )
												if trainer.args.evaluation_strategy == IntervalStrategy.EPOCH:
																expected_events += evaluation_events.copy()
								expected_events += ["on_log", "on_train_end"]
								return expected_events







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]        =      self.get_trainer()
								__magic_name__		:int        =      DEFAULT_CALLBACKS.copy() + [ProgressCallback]
								self.check_callbacks_equality(trainer.callback_handler.callbacks       ,					__lowerCAmelCase     )

								# Callbacks passed at init are added to the default callbacks
								__magic_name__		:str        =      self.get_trainer(callbacks=[MyTestTrainerCallback]     )
								expected_callbacks.append(__lowerCAmelCase     )
								self.check_callbacks_equality(trainer.callback_handler.callbacks       ,					__lowerCAmelCase     )

								# TrainingArguments.disable_tqdm controls if use ProgressCallback or PrinterCallback
								__magic_name__		:List[Any]        =      self.get_trainer(disable_tqdm=__lowerCAmelCase     )
								__magic_name__		:Dict        =      DEFAULT_CALLBACKS.copy() + [PrinterCallback]
								self.check_callbacks_equality(trainer.callback_handler.callbacks       ,					__lowerCAmelCase     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[int]        =      DEFAULT_CALLBACKS.copy() + [ProgressCallback]
								__magic_name__		:Dict        =      self.get_trainer()

								# We can add, pop, or remove by class name
								trainer.remove_callback(__lowerCAmelCase     )
								expected_callbacks.remove(__lowerCAmelCase     )
								self.check_callbacks_equality(trainer.callback_handler.callbacks       ,					__lowerCAmelCase     )

								__magic_name__		:Any        =      self.get_trainer()
								__magic_name__		:Optional[int]        =      trainer.pop_callback(__lowerCAmelCase     )
								self.assertEqual(cb.__class__       ,					__lowerCAmelCase     )
								self.check_callbacks_equality(trainer.callback_handler.callbacks       ,					__lowerCAmelCase     )

								trainer.add_callback(__lowerCAmelCase     )
								expected_callbacks.insert(0       ,					__lowerCAmelCase     )
								self.check_callbacks_equality(trainer.callback_handler.callbacks       ,					__lowerCAmelCase     )

								# We can also add, pop, or remove by instance
								__magic_name__		:Tuple        =      self.get_trainer()
								__magic_name__		:Dict        =      trainer.callback_handler.callbacks[0]
								trainer.remove_callback(__lowerCAmelCase     )
								expected_callbacks.remove(__lowerCAmelCase     )
								self.check_callbacks_equality(trainer.callback_handler.callbacks       ,					__lowerCAmelCase     )

								__magic_name__		:int        =      self.get_trainer()
								__magic_name__		:List[Any]        =      trainer.callback_handler.callbacks[0]
								__magic_name__		:int        =      trainer.pop_callback(__lowerCAmelCase     )
								self.assertEqual(__lowerCAmelCase       ,					__lowerCAmelCase     )
								self.check_callbacks_equality(trainer.callback_handler.callbacks       ,					__lowerCAmelCase     )

								trainer.add_callback(__lowerCAmelCase     )
								expected_callbacks.insert(0       ,					__lowerCAmelCase     )
								self.check_callbacks_equality(trainer.callback_handler.callbacks       ,					__lowerCAmelCase     )







				def 			A	(						self     ):
								"""simple docstring"""
								import warnings

								# XXX: for now ignore scatter_gather warnings in this test since it's not relevant to what's being tested
								warnings.simplefilter(action='''ignore'''       ,					category=__lowerCAmelCase     )

								__magic_name__		:Optional[int]        =      self.get_trainer(callbacks=[MyTestTrainerCallback]     )
								trainer.train()
								__magic_name__		:str        =      trainer.callback_handler.callbacks[-2].events
								self.assertEqual(__lowerCAmelCase       ,					self.get_expected_events(__lowerCAmelCase     )     )

								# Independent log/save/eval
								__magic_name__		:str        =      self.get_trainer(callbacks=[MyTestTrainerCallback]       ,					logging_steps=5     )
								trainer.train()
								__magic_name__		:Dict        =      trainer.callback_handler.callbacks[-2].events
								self.assertEqual(__lowerCAmelCase       ,					self.get_expected_events(__lowerCAmelCase     )     )

								__magic_name__		:Tuple        =      self.get_trainer(callbacks=[MyTestTrainerCallback]       ,					save_steps=5     )
								trainer.train()
								__magic_name__		:List[Any]        =      trainer.callback_handler.callbacks[-2].events
								self.assertEqual(__lowerCAmelCase       ,					self.get_expected_events(__lowerCAmelCase     )     )

								__magic_name__		:Tuple        =      self.get_trainer(callbacks=[MyTestTrainerCallback]       ,					eval_steps=5       ,					evaluation_strategy='''steps'''     )
								trainer.train()
								__magic_name__		:Any        =      trainer.callback_handler.callbacks[-2].events
								self.assertEqual(__lowerCAmelCase       ,					self.get_expected_events(__lowerCAmelCase     )     )

								__magic_name__		:Union[str, Any]        =      self.get_trainer(callbacks=[MyTestTrainerCallback]       ,					evaluation_strategy='''epoch'''     )
								trainer.train()
								__magic_name__		:str        =      trainer.callback_handler.callbacks[-2].events
								self.assertEqual(__lowerCAmelCase       ,					self.get_expected_events(__lowerCAmelCase     )     )

								# A bit of everything
								__magic_name__		:Optional[int]        =      self.get_trainer(
								    callbacks=[MyTestTrainerCallback]       ,					logging_steps=3       ,					save_steps=1_0       ,					eval_steps=5       ,					evaluation_strategy='''steps'''       ,					)
								trainer.train()
								__magic_name__		:Union[str, Any]        =      trainer.callback_handler.callbacks[-2].events
								self.assertEqual(__lowerCAmelCase       ,					self.get_expected_events(__lowerCAmelCase     )     )

								# warning should be emitted for duplicated callbacks
								with patch('''transformers.trainer_callback.logger.warning'''     ) as warn_mock:
												__magic_name__		:int        =      self.get_trainer(
												    callbacks=[MyTestTrainerCallback, MyTestTrainerCallback]       ,					)
												assert str(__lowerCAmelCase     ) in warn_mock.call_args[0][0]














from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available


SCREAMING_SNAKE_CASE__      :			Union[str, Any]							=		{"""tokenization_herbert""": ["""HerbertTokenizer"""]}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__      :			Optional[Any]							=		["""HerbertTokenizerFast"""]


if TYPE_CHECKING:
					from .tokenization_herbert import HerbertTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_herbert_fast import HerbertTokenizerFast

else:
					import sys

					SCREAMING_SNAKE_CASE__      :			Union[str, Any]							=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






