





'''simple docstring'''





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       A__     ( __snake_case    ):





      def __init__(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      Any 			=     []





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_init_end"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_train_begin"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_train_end"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_epoch_begin"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_epoch_end"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_step_begin"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_step_end"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_evaluate"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_predict"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_save"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_log"     )





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_ ,							**A_     ):
       '''simple docstring'''




       self.events.append("on_prediction_step"     )



@require_torch
class       A__     ( unittest.TestCase    ):





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      Any 			=     tempfile.mkdtemp()





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       shutil.rmtree(self.output_dir     )





      def  __UpperCamelCase(				self ,							A_=0 ,							A_=0 ,							A_=64 ,							A_=64 ,							A_=None ,							A_=False ,							**A_     ):
       '''simple docstring'''




       UpperCamelCase			:      Dict 			=     RegressionDataset(length=A_     )
       UpperCamelCase			:      int 			=     RegressionDataset(length=A_     )
       UpperCamelCase			:      List[Any] 			=     RegressionModelConfig(a=A_ ,							b=A_     )
       UpperCamelCase			:      Any 			=     RegressionPreTrainedModel(A_     )

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





      def  __UpperCamelCase(				self ,							A_ ,							A_     ):
       '''simple docstring'''




       self.assertEqual(len(A_     ) ,							len(A_     )     )

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

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





      def  __UpperCamelCase(				self ,							A_     ):
       '''simple docstring'''




       UpperCamelCase			:      Any 			=     ["on_init_end", "on_train_begin"]
       UpperCamelCase			:      int 			=     0
       UpperCamelCase			:      str 			=     len(trainer.get_eval_dataloader()     )
       UpperCamelCase			:      Tuple 			=     ["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(A_     ):
         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  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      Union[str, Any] 			=     self.get_trainer()
       UpperCamelCase			:      Any 			=     DEFAULT_CALLBACKS.copy() + [ProgressCallback]
       self.check_callbacks_equality(trainer.callback_handler.callbacks ,							A_     )

       # Callbacks passed at init are added to the default callbacks
       UpperCamelCase			:      List[Any] 			=     self.get_trainer(callbacks=[MyTestTrainerCallback]     )
       expected_callbacks.append(A_     )
       self.check_callbacks_equality(trainer.callback_handler.callbacks ,							A_     )

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





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      Optional[Any] 			=     DEFAULT_CALLBACKS.copy() + [ProgressCallback]
       UpperCamelCase			:      Any 			=     self.get_trainer()

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

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

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

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

       UpperCamelCase			:      List[Any] 			=     self.get_trainer()
       UpperCamelCase			:      Tuple 			=     trainer.callback_handler.callbacks[0]
       UpperCamelCase			:      Optional[Any] 			=     trainer.pop_callback(A_     )
       self.assertEqual(A_ ,							A_     )
       self.check_callbacks_equality(trainer.callback_handler.callbacks ,							A_     )

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





      def  __UpperCamelCase(				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=A_     )

       UpperCamelCase			:      str 			=     self.get_trainer(callbacks=[MyTestTrainerCallback]     )
       trainer.train()
       UpperCamelCase			:      List[str] 			=     trainer.callback_handler.callbacks[-2].events
       self.assertEqual(A_ ,							self.get_expected_events(A_     )     )

       # Independent log/save/eval
       UpperCamelCase			:      int 			=     self.get_trainer(callbacks=[MyTestTrainerCallback] ,							logging_steps=5     )
       trainer.train()
       UpperCamelCase			:      Any 			=     trainer.callback_handler.callbacks[-2].events
       self.assertEqual(A_ ,							self.get_expected_events(A_     )     )

       UpperCamelCase			:      Union[str, Any] 			=     self.get_trainer(callbacks=[MyTestTrainerCallback] ,							save_steps=5     )
       trainer.train()
       UpperCamelCase			:      int 			=     trainer.callback_handler.callbacks[-2].events
       self.assertEqual(A_ ,							self.get_expected_events(A_     )     )

       UpperCamelCase			:      Tuple 			=     self.get_trainer(callbacks=[MyTestTrainerCallback] ,							eval_steps=5 ,							evaluation_strategy="steps"     )
       trainer.train()
       UpperCamelCase			:      str 			=     trainer.callback_handler.callbacks[-2].events
       self.assertEqual(A_ ,							self.get_expected_events(A_     )     )

       UpperCamelCase			:      Dict 			=     self.get_trainer(callbacks=[MyTestTrainerCallback] ,							evaluation_strategy="epoch"     )
       trainer.train()
       UpperCamelCase			:      str 			=     trainer.callback_handler.callbacks[-2].events
       self.assertEqual(A_ ,							self.get_expected_events(A_     )     )

       # A bit of everything
       UpperCamelCase			:      Optional[Any] 			=     self.get_trainer(
           callbacks=[MyTestTrainerCallback] ,							logging_steps=3 ,							save_steps=10 ,							eval_steps=5 ,							evaluation_strategy="steps" ,							)
       trainer.train()
       UpperCamelCase			:      List[Any] 			=     trainer.callback_handler.callbacks[-2].events
       self.assertEqual(A_ ,							self.get_expected_events(A_     )     )

       # warning should be emitted for duplicated callbacks
       with patch("transformers.trainer_callback.logger.warning"     ) as warn_mock:
        UpperCamelCase			:      Dict 			=     self.get_trainer(
            callbacks=[MyTestTrainerCallback, MyTestTrainerCallback] ,							)
        assert str(A_     ) in warn_mock.call_args[0][0]







from math import loga



def 	A_       (  _lowerCAmelCase  )		->				int:
 if a < 0:
  raise ValueError("Input value must be a positive integer"  )
 elif isinstance(_lowerCAmelCase							,     _lowerCAmelCase  ):
  raise TypeError("Input value must be a 'int' type"  )
 return 0 if (a == 0) else int(loga(a & -a  )  )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
