





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 ceil
from typing import List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import BatchFeature, SequenceFeatureExtractor
from ...utils import TensorType, logging


__lowerCamelCase :  Dict										=  logging.get_logger(__name__)



class       A__     ( __snake_case    ):
      _UpperCAmelCase			:Tuple							=     ['audio_values', 'audio_mask']





      def __init__(				self ,							A_=2048 ,							A_=1 ,							A_=[16, 16] ,							A_=128 ,							A_=4_4100 ,							A_=86 ,							A_=2048 ,							A_=0.0 ,							**A_ ,							):
       '''simple docstring'''




       super().__init__(
           feature_size=A_ ,							sampling_rate=A_ ,							padding_value=A_ ,							**A_ ,							)

       UpperCamelCase			:      Optional[int] 			=     spectrogram_length
       UpperCamelCase			:      Dict 			=     num_channels
       UpperCamelCase			:      Optional[Any] 			=     patch_size
       UpperCamelCase			:      str 			=     feature_size // self.patch_size[1]
       UpperCamelCase			:      List[str] 			=     n_fft
       UpperCamelCase			:      int 			=     sampling_rate // hop_length_to_sampling_rate
       UpperCamelCase			:      Optional[int] 			=     sampling_rate
       UpperCamelCase			:      int 			=     padding_value
       UpperCamelCase			:      str 			=     mel_filter_bank(
           num_frequency_bins=1 + n_fft // 2 ,							num_mel_filters=A_ ,							min_frequency=0.0 ,							max_frequency=2_20_50.0 ,							sampling_rate=A_ ,							norm="slaney" ,							mel_scale="slaney" ,							).T





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




       UpperCamelCase			:      Union[str, Any] 			=     spectrogram(
           A_ ,							window_function(self.n_fft ,							"hann"     ) ,							frame_length=self.n_fft ,							hop_length=self.hop_length ,							power=2.0 ,							mel_filters=self.mel_filters.T ,							log_mel="dB" ,							db_range=80.0 ,							)
       UpperCamelCase			:      List[Any] 			=     log_spec[:, :-1]
       UpperCamelCase			:      Optional[int] 			=     log_spec - 20.0
       UpperCamelCase			:      str 			=     np.clip(log_spec / 40.0 ,							-2.0 ,							0.0     ) + 1.0
       return log_spec





      def __call__(				self ,							A_ ,							A_ = None ,							A_ = True ,							A_ = None ,							A_ = False ,							A_ = False ,							**A_ ,							):
       '''simple docstring'''




       if sampling_rate is not None:
        if sampling_rate != self.sampling_rate:
         raise ValueError(
             "This feature extractor is set to support sampling rate"
             F""" of {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled"""
             F""" with {self.sampling_rate} and not {sampling_rate}."""     )
       else:
        logger.warning(
            "It is strongly recommended to pass the `sampling_rate` argument to this function. "
            "Failing to do so can result in silent errors that might be hard to debug."     )

       UpperCamelCase			:      Optional[int] 			=     isinstance(A_ ,							np.ndarray     ) and len(raw_speech.shape     ) > 1
       if is_batched_numpy and len(raw_speech.shape     ) > 2:
        raise ValueError(F"""Only mono-channel audio is supported for input to {self}"""     )
       UpperCamelCase			:      Union[str, Any] 			=     is_batched_numpy or (
           isinstance(A_ ,							(list, tuple)     ) and (isinstance(raw_speech[0] ,							(np.ndarray, tuple, list)     ))
       )
       if is_batched:
        UpperCamelCase			:      int 			=     [np.asarray([speech] ,							dtype=np.floataa     ).T for speech in raw_speech]
       elif not is_batched and not isinstance(A_ ,							np.ndarray     ):
        UpperCamelCase			:      str 			=     np.asarray(A_ ,							dtype=np.floataa     )
       elif isinstance(A_ ,							np.ndarray     ) and raw_speech.dtype is np.dtype(np.floataa     ):
        UpperCamelCase			:      List[Any] 			=     raw_speech.astype(np.floataa     )
       # always return batch
       if not is_batched:
        UpperCamelCase			:      Tuple 			=     [np.asarray([raw_speech]     ).T]

       # Convert audio signals to log mel spectrograms, truncate by time axis
       UpperCamelCase			:      str 			=     [
           self._np_extract_fbank_features(waveform.squeeze()     ).T[: self.spectrogram_length] for waveform in raw_speech
       ]
       if isinstance(audio_features[0] ,							A_     ):
        UpperCamelCase			:      int 			=     [np.asarray(A_ ,							dtype=np.floataa     ) for feature in audio_features]

       # Create audio attention mask
       UpperCamelCase			:      List[str] 			=     max(
           [ceil(feature.shape[0] / self.patch_size[0]     ) * self.freq_len for feature in audio_features]     )  # The maximum number of audio patches in a batch
       if return_attention_mask:
        UpperCamelCase			:      str 			=     [
            (ceil(feature.shape[0] / self.patch_size[0]     ) * self.freq_len) * [1]
            + (max_patch_len - ceil(feature.shape[0] / self.patch_size[0]     ) * self.freq_len) * [0]
            for feature in audio_features
        ]
        UpperCamelCase			:      Tuple 			=     np.array(A_     ).astype(np.floataa     )

       # convert into correct format for padding
       UpperCamelCase			:      Union[str, Any] 			=     max_patch_len // self.freq_len * self.patch_size[0]  # The maximum audio size in a batch
       UpperCamelCase			:      Any 			=     np.ones([len(A_     ), 1, max_time_len, self.feature_size]     ).astype(np.floataa     )
       UpperCamelCase			:      List[str] 			=     padded_audio_features * self.padding_value
       for i in range(len(A_     )     ):
        UpperCamelCase			:      Union[str, Any] 			=     audio_features[i]
        UpperCamelCase			:      Optional[int] 			=     feature

       # return as BatchFeature
       if return_attention_mask:
        UpperCamelCase			:      Optional[Any] 			=     {"audio_values": padded_audio_features, "audio_mask": audio_mask}
       else:
        UpperCamelCase			:      int 			=     {"audio_values": padded_audio_features}

       UpperCamelCase			:      Any 			=     BatchFeature(data=A_ ,							tensor_type=A_     )
       return encoded_inputs
