






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"""
        __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]














import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)
class 						lowerCamelCase_				(      unittest.TestCase ):







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      Vector([1, 2, 3]     )
								self.assertEqual(x.component(0     )       ,					1     )
								self.assertEqual(x.component(2     )       ,					3     )
								__magic_name__		:Tuple        =      Vector()







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Any        =      Vector([0, 0, 0, 0, 0, 1]     )
								self.assertEqual(str(__lowerCAmelCase     )       ,					'''(0,0,0,0,0,1)'''     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[int]        =      Vector([1, 2, 3, 4]     )
								self.assertEqual(len(__lowerCAmelCase     )       ,					4     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]        =      Vector([1, 2]     )
								__magic_name__		:int        =      Vector([1, 2, 3, 4, 5]     )
								__magic_name__		:Any        =      Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]     )
								__magic_name__		:Optional[Any]        =      Vector([1, -1, 1, -1, 2, -3, 4, -5]     )
								self.assertAlmostEqual(x.euclidean_length()       ,					2.236       ,					3     )
								self.assertAlmostEqual(y.euclidean_length()       ,					7.416       ,					3     )
								self.assertEqual(z.euclidean_length()       ,					0     )
								self.assertAlmostEqual(w.euclidean_length()       ,					7.616       ,					3     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      Vector([1, 2, 3]     )
								__magic_name__		:List[str]        =      Vector([1, 1, 1]     )
								self.assertEqual((x + y).component(0     )       ,					2     )
								self.assertEqual((x + y).component(1     )       ,					3     )
								self.assertEqual((x + y).component(2     )       ,					4     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      Vector([1, 2, 3]     )
								__magic_name__		:Union[str, Any]        =      Vector([1, 1, 1]     )
								self.assertEqual((x - y).component(0     )       ,					0     )
								self.assertEqual((x - y).component(1     )       ,					1     )
								self.assertEqual((x - y).component(2     )       ,					2     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:int        =      Vector([1, 2, 3]     )
								__magic_name__		:Optional[int]        =      Vector([2, -1, 4]     )  # for test of dot product
								__magic_name__		:List[Any]        =      Vector([1, -2, -1]     )
								self.assertEqual(str(x * 3.0     )       ,					'''(3.0,6.0,9.0)'''     )
								self.assertEqual((a * b)       ,					0     )







				def 			A	(						self     ):
								"""simple docstring"""
								self.assertEqual(str(zero_vector(1_0     )     ).count('''0'''     )       ,					1_0     )







				def 			A	(						self     ):
								"""simple docstring"""
								self.assertEqual(str(unit_basis_vector(3       ,					1     )     )       ,					'''(0,1,0)'''     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Dict        =      Vector([1, 2, 3]     )
								__magic_name__		:List[Any]        =      Vector([1, 0, 1]     )
								self.assertEqual(str(axpy(2       ,					__lowerCAmelCase       ,					__lowerCAmelCase     )     )       ,					'''(3,4,7)'''     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      Vector([1, 0, 0, 0, 0, 0]     )
								__magic_name__		:Optional[int]        =      x.copy()
								self.assertEqual(str(__lowerCAmelCase     )       ,					str(__lowerCAmelCase     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      Vector([1, 0, 0]     )
								x.change_component(0       ,					0     )
								x.change_component(1       ,					1     )
								self.assertEqual(str(__lowerCAmelCase     )       ,					'''(0,1,0)'''     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Any        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								self.assertEqual('''|1,2,3|\n|2,4,5|\n|6,7,8|\n'''       ,					str(__lowerCAmelCase     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								__magic_name__		:List[str]        =      [[-3, -1_4, -1_0], [-5, -1_0, -5], [-2, -1, 0]]
								for x in range(a.height()     ):
												for y in range(a.width()     ):
																self.assertEqual(minors[x][y]       ,					a.minor(__lowerCAmelCase       ,					__lowerCAmelCase     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:int        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								__magic_name__		:Any        =      [[-3, 1_4, -1_0], [5, -1_0, 5], [-2, 1, 0]]
								for x in range(a.height()     ):
												for y in range(a.width()     ):
																self.assertEqual(cofactors[x][y]       ,					a.cofactor(__lowerCAmelCase       ,					__lowerCAmelCase     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Tuple        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								self.assertEqual(-5       ,					a.determinant()     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:str        =      Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]       ,					3       ,					3     )
								__magic_name__		:Any        =      Vector([1, 2, 3]     )
								self.assertEqual('''(14,32,50)'''       ,					str(a * x     )     )
								self.assertEqual('''|2,4,6|\n|8,10,12|\n|14,16,18|\n'''       ,					str(a * 2     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[Any]        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								a.change_component(0       ,					2       ,					5     )
								self.assertEqual('''|1,2,5|\n|2,4,5|\n|6,7,8|\n'''       ,					str(__lowerCAmelCase     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[Any]        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								self.assertEqual(7       ,					a.component(2       ,					1     )       ,					0.01     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								__magic_name__		:Optional[Any]        =      Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]       ,					3       ,					3     )
								self.assertEqual('''|2,4,10|\n|4,8,10|\n|12,14,18|\n'''       ,					str(a + b     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Dict        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								__magic_name__		:Union[str, Any]        =      Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]       ,					3       ,					3     )
								self.assertEqual('''|0,0,-4|\n|0,0,0|\n|0,0,-2|\n'''       ,					str(a - b     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								self.assertEqual(
								    '''|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n'''       ,					str(square_zero_matrix(5     )     )       ,					)


if __name__ == "__main__":
					unittest.main()






