



"""simple docstring"""






import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
   import torch


lowerCAmelCase__              =							random.Random()






def 			snake_case_    ( A_   :						Union[str, Any],							A_   :						Union[str, Any]=1.0,							A_   :						Optional[Any]=None,							A_   :						int=None		):


       '''simple docstring'''





       if rng is None:
              _lowerCamelCase		:							int            =					global_rng

       _lowerCamelCase		:							Tuple            =					[]
       for batch_idx in range(shape[0]		):
              values.append([]		)
              for _ in range(shape[1]		):
                     values[-1].append(rng.random() * scale		)

       return values






@require_torch
class 			__snake_case			(      unittest.TestCase):




  def __init__(					self	:		List[str]		,   __lowerCAmelCase	:		Optional[Any]		,   __lowerCAmelCase	:		str=7		,   __lowerCAmelCase	:		Any=4_0_0		,   __lowerCAmelCase	:		Dict=2_0_0_0		,   __lowerCAmelCase	:		str=1		,   __lowerCAmelCase	:		Optional[int]=0.0		,   __lowerCAmelCase	:		Union[str, Any]=1_6_0_0_0		,   __lowerCAmelCase	:		Dict=True		,   __lowerCAmelCase	:		str=8_0		,   __lowerCAmelCase	:		Tuple=1_6		,   __lowerCAmelCase	:		Dict=6_4		,   __lowerCAmelCase	:		Any="hann_window"		,   __lowerCAmelCase	:		str=8_0		,   __lowerCAmelCase	:		int=7_6_0_0		,   __lowerCAmelCase	:		Optional[int]=1E-10		,   __lowerCAmelCase	:		str=True		,   ):






         """simple docstring"""






         _lowerCamelCase		:							List[Any]            =					parent
         _lowerCamelCase		:							List[str]            =					batch_size
         _lowerCamelCase		:							Union[str, Any]            =					min_seq_length
         _lowerCamelCase		:							List[Any]            =					max_seq_length
         _lowerCamelCase		:							List[Any]            =					(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
         _lowerCamelCase		:							str            =					feature_size
         _lowerCamelCase		:							Optional[Any]            =					padding_value
         _lowerCamelCase		:							Optional[Any]            =					sampling_rate
         _lowerCamelCase		:							List[Any]            =					do_normalize
         _lowerCamelCase		:							str            =					num_mel_bins
         _lowerCamelCase		:							int            =					hop_length
         _lowerCamelCase		:							Union[str, Any]            =					win_length
         _lowerCamelCase		:							str            =					win_function
         _lowerCamelCase		:							Tuple            =					fmin
         _lowerCamelCase		:							Optional[int]            =					fmax
         _lowerCamelCase		:							Dict            =					mel_floor
         _lowerCamelCase		:							Optional[Any]            =					return_attention_mask




  def 		SCREAMING_SNAKE_CASE							(					self	:		str						):






         """simple docstring"""






         return {
             "feature_size": self.feature_size,
             "padding_value": self.padding_value,
             "sampling_rate": self.sampling_rate,
             "do_normalize": self.do_normalize,
             "num_mel_bins": self.num_mel_bins,
             "hop_length": self.hop_length,
             "win_length": self.win_length,
             "win_function": self.win_function,
             "fmin": self.fmin,
             "fmax": self.fmax,
             "mel_floor": self.mel_floor,
             "return_attention_mask": self.return_attention_mask,
         }




  def 		SCREAMING_SNAKE_CASE							(					self	:		Optional[Any]		,   __lowerCAmelCase	:		Optional[int]=False		,   __lowerCAmelCase	:		Any=False						):






         """simple docstring"""






         def _flatten(__lowerCAmelCase	:		Tuple						):
                return list(itertools.chain(*__lowerCAmelCase						)						)

         if equal_length:
                _lowerCamelCase		:							str            =					floats_list((self.batch_size, self.max_seq_length)						)
         else:
                # make sure that inputs increase in size
                _lowerCamelCase		:							Tuple            =					[
                    _flatten(floats_list((x, self.feature_size)						)						)
                    for x in range(self.min_seq_length		,   self.max_seq_length		,   self.seq_length_diff						)
                ]

         if numpify:
                _lowerCamelCase		:							List[str]            =					[np.asarray(__lowerCAmelCase						) for x in speech_inputs]

         return speech_inputs




  def 		SCREAMING_SNAKE_CASE							(					self	:		List[str]		,   __lowerCAmelCase	:		Optional[Any]=False		,   __lowerCAmelCase	:		int=False						):






         """simple docstring"""






         if equal_length:
                _lowerCamelCase		:							List[Any]            =					[floats_list((self.max_seq_length, self.num_mel_bins)						) for _ in range(self.batch_size						)]
         else:
                # make sure that inputs increase in size
                _lowerCamelCase		:							Dict            =					[
                    floats_list((x, self.num_mel_bins)						)
                    for x in range(self.min_seq_length		,   self.max_seq_length		,   self.seq_length_diff						)
                ]

         if numpify:
                _lowerCamelCase		:							Any            =					[np.asarray(__lowerCAmelCase						) for x in speech_inputs]

         return speech_inputs






@require_torch
class 			__snake_case			(      _lowercase    ,	unittest.TestCase):
  snake_case__							:  Dict         =		SpeechTaFeatureExtractor




  def 		SCREAMING_SNAKE_CASE							(					self	:		Union[str, Any]						):






         """simple docstring"""






         _lowerCamelCase		:							Optional[int]            =					SpeechTaFeatureExtractionTester(self						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		Any		,   __lowerCAmelCase	:		List[str]						):






         """simple docstring"""






         self.assertTrue(np.all(np.mean(__lowerCAmelCase		,   axis=0						) < 1E-3						)						)
         self.assertTrue(np.all(np.abs(np.var(__lowerCAmelCase		,   axis=0						) - 1						) < 1E-3						)						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		Union[str, Any]						):






         """simple docstring"""






         _lowerCamelCase		:							int            =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
         # create three inputs of length 800, 1000, and 1200
         _lowerCamelCase		:							Dict            =					[floats_list((1, x)						)[0] for x in range(8_0_0		,   1_4_0_0		,   2_0_0						)]
         _lowerCamelCase		:							Tuple            =					[np.asarray(__lowerCAmelCase						) for speech_input in speech_inputs]

         # Test not batched input
         _lowerCamelCase		:							Optional[Any]            =					feat_extract(speech_inputs[0]		,   return_tensors='''np'''						).input_values
         _lowerCamelCase		:							Any            =					feat_extract(np_speech_inputs[0]		,   return_tensors='''np'''						).input_values
         self.assertTrue(np.allclose(__lowerCAmelCase		,   __lowerCAmelCase		,   atol=1E-3						)						)

         # Test batched
         _lowerCamelCase		:							Union[str, Any]            =					feat_extract(__lowerCAmelCase		,   return_tensors='''np'''						).input_values
         _lowerCamelCase		:							List[Any]            =					feat_extract(__lowerCAmelCase		,   return_tensors='''np'''						).input_values
         for enc_seq_a, enc_seq_a in zip(__lowerCAmelCase		,   __lowerCAmelCase						):
                self.assertTrue(np.allclose(__lowerCAmelCase		,   __lowerCAmelCase		,   atol=1E-3						)						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		Optional[int]						):






         """simple docstring"""






         _lowerCamelCase		:							Any            =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
         _lowerCamelCase		:							Optional[int]            =					[floats_list((1, x)						)[0] for x in range(8_0_0		,   1_4_0_0		,   2_0_0						)]

         _lowerCamelCase		:							str            =					['''longest''', '''max_length''', '''do_not_pad''']
         _lowerCamelCase		:							Dict            =					[None, 1_6_0_0, None]
         for max_length, padding in zip(__lowerCAmelCase		,   __lowerCAmelCase						):
                _lowerCamelCase		:							List[Any]            =					feat_extract(__lowerCAmelCase		,   padding=__lowerCAmelCase		,   max_length=__lowerCAmelCase		,   return_tensors='''np'''						)
                _lowerCamelCase		:							Optional[Any]            =					processed.input_values

                self._check_zero_mean_unit_variance(input_values[0][:8_0_0]						)
                self.assertTrue(input_values[0][8_0_0:].sum() < 1E-6						)
                self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0]						)
                self.assertTrue(input_values[0][1_0_0_0:].sum() < 1E-6						)
                self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0]						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		Optional[Any]						):






         """simple docstring"""






         _lowerCamelCase		:							Optional[Any]            =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
         _lowerCamelCase		:							Optional[Any]            =					range(8_0_0		,   1_4_0_0		,   2_0_0						)
         _lowerCamelCase		:							List[Any]            =					[floats_list((1, x)						)[0] for x in lengths]

         _lowerCamelCase		:							Dict            =					['''longest''', '''max_length''', '''do_not_pad''']
         _lowerCamelCase		:							List[str]            =					[None, 1_6_0_0, None]

         for max_length, padding in zip(__lowerCAmelCase		,   __lowerCAmelCase						):
                _lowerCamelCase		:							List[str]            =					feat_extract(__lowerCAmelCase		,   max_length=__lowerCAmelCase		,   padding=__lowerCAmelCase						)
                _lowerCamelCase		:							Union[str, Any]            =					processed.input_values

                self._check_zero_mean_unit_variance(input_values[0][:8_0_0]						)
                self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0]						)
                self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0]						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		Optional[int]						):






         """simple docstring"""






         _lowerCamelCase		:							Optional[int]            =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
         _lowerCamelCase		:							int            =					[floats_list((1, x)						)[0] for x in range(8_0_0		,   1_4_0_0		,   2_0_0						)]
         _lowerCamelCase		:							List[str]            =					feat_extract(
             __lowerCAmelCase		,   truncation=__lowerCAmelCase		,   max_length=1_0_0_0		,   padding='''max_length'''		,   return_tensors='''np'''						)
         _lowerCamelCase		:							List[Any]            =					processed.input_values

         self._check_zero_mean_unit_variance(input_values[0, :8_0_0]						)
         self._check_zero_mean_unit_variance(input_values[1]						)
         self._check_zero_mean_unit_variance(input_values[2]						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		Tuple						):






         """simple docstring"""






         _lowerCamelCase		:							Optional[Any]            =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
         _lowerCamelCase		:							Optional[int]            =					[floats_list((1, x)						)[0] for x in range(8_0_0		,   1_4_0_0		,   2_0_0						)]
         _lowerCamelCase		:							str            =					feat_extract(
             __lowerCAmelCase		,   truncation=__lowerCAmelCase		,   max_length=1_0_0_0		,   padding='''longest'''		,   return_tensors='''np'''						)
         _lowerCamelCase		:							Tuple            =					processed.input_values

         self._check_zero_mean_unit_variance(input_values[0, :8_0_0]						)
         self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0]						)
         self._check_zero_mean_unit_variance(input_values[2]						)

         # make sure that if max_length < longest -> then pad to max_length
         self.assertTrue(input_values.shape == (3, 1_0_0_0)						)

         _lowerCamelCase		:							Union[str, Any]            =					[floats_list((1, x)						)[0] for x in range(8_0_0		,   1_4_0_0		,   2_0_0						)]
         _lowerCamelCase		:							Optional[Any]            =					feat_extract(
             __lowerCAmelCase		,   truncation=__lowerCAmelCase		,   max_length=2_0_0_0		,   padding='''longest'''		,   return_tensors='''np'''						)
         _lowerCamelCase		:							Union[str, Any]            =					processed.input_values

         self._check_zero_mean_unit_variance(input_values[0, :8_0_0]						)
         self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0]						)
         self._check_zero_mean_unit_variance(input_values[2]						)

         # make sure that if max_length > longest -> then pad to longest
         self.assertTrue(input_values.shape == (3, 1_2_0_0)						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		Tuple						):






         """simple docstring"""






         _lowerCamelCase		:							List[Any]            =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
         _lowerCamelCase		:							int            =					np.random.rand(1_0_0						).astype(np.floataa						)
         _lowerCamelCase		:							Any            =					np_speech_inputs.tolist()

         for inputs in [py_speech_inputs, np_speech_inputs]:
                _lowerCamelCase		:							Optional[Any]            =					feature_extractor.pad([{'''input_values''': inputs}]		,   return_tensors='''np'''						)
                self.assertTrue(np_processed.input_values.dtype == np.floataa						)
                _lowerCamelCase		:							str            =					feature_extractor.pad([{'''input_values''': inputs}]		,   return_tensors='''pt'''						)
                self.assertTrue(pt_processed.input_values.dtype == torch.floataa						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		str						):






         """simple docstring"""






         _lowerCamelCase		:							int            =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
         # create three inputs of length 800, 1000, and 1200
         _lowerCamelCase		:							Tuple            =					[floats_list((1, x)						)[0] for x in range(8_0_0		,   1_4_0_0		,   2_0_0						)]
         _lowerCamelCase		:							Optional[Any]            =					[np.asarray(__lowerCAmelCase						) for speech_input in speech_inputs]

         # Test feature size
         _lowerCamelCase		:							List[Any]            =					feature_extractor(audio_target=__lowerCAmelCase		,   padding=__lowerCAmelCase		,   return_tensors='''np'''						).input_values
         self.assertTrue(input_values.ndim == 3						)
         self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins						)

         # Test not batched input
         _lowerCamelCase		:							Optional[Any]            =					feature_extractor(speech_inputs[0]		,   return_tensors='''np'''						).input_values
         _lowerCamelCase		:							Dict            =					feature_extractor(np_speech_inputs[0]		,   return_tensors='''np'''						).input_values
         self.assertTrue(np.allclose(__lowerCAmelCase		,   __lowerCAmelCase		,   atol=1E-3						)						)

         # Test batched
         _lowerCamelCase		:							str            =					feature_extractor(__lowerCAmelCase		,   return_tensors='''np'''						).input_values
         _lowerCamelCase		:							Tuple            =					feature_extractor(__lowerCAmelCase		,   return_tensors='''np'''						).input_values
         for enc_seq_a, enc_seq_a in zip(__lowerCAmelCase		,   __lowerCAmelCase						):
                self.assertTrue(np.allclose(__lowerCAmelCase		,   __lowerCAmelCase		,   atol=1E-3						)						)

         # Test 2-D numpy arrays are batched.
         _lowerCamelCase		:							Tuple            =					[floats_list((1, x)						)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
         _lowerCamelCase		:							Optional[int]            =					np.asarray(__lowerCAmelCase						)
         _lowerCamelCase		:							Tuple            =					feature_extractor(__lowerCAmelCase		,   return_tensors='''np'''						).input_values
         _lowerCamelCase		:							Tuple            =					feature_extractor(__lowerCAmelCase		,   return_tensors='''np'''						).input_values
         for enc_seq_a, enc_seq_a in zip(__lowerCAmelCase		,   __lowerCAmelCase						):
                self.assertTrue(np.allclose(__lowerCAmelCase		,   __lowerCAmelCase		,   atol=1E-3						)						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		List[Any]						):






         """simple docstring"""






         _lowerCamelCase		:							Union[str, Any]            =					self.feat_extract_tester.prepare_inputs_for_target()
         _lowerCamelCase		:							Union[str, Any]            =					self.feature_extraction_class(**self.feat_extract_dict						)
         _lowerCamelCase		:							str            =					feat_extract.model_input_names[0]

         _lowerCamelCase		:							Union[str, Any]            =					BatchFeature({input_name: speech_inputs}						)

         self.assertTrue(all(len(__lowerCAmelCase						) == len(__lowerCAmelCase						) for x, y in zip(__lowerCAmelCase		,   processed_features[input_name]						)						)						)

         _lowerCamelCase		:							List[Any]            =					self.feat_extract_tester.prepare_inputs_for_target(equal_length=__lowerCAmelCase						)
         _lowerCamelCase		:							Union[str, Any]            =					BatchFeature({input_name: speech_inputs}		,   tensor_type='''np'''						)

         _lowerCamelCase		:							int            =					processed_features[input_name]

         if len(batch_features_input.shape						) < 3:
                _lowerCamelCase		:							List[Any]            =					batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]						), self.feat_extract_tester.num_mel_bins)						)




  @require_torch
  def 		SCREAMING_SNAKE_CASE							(					self	:		Tuple						):






         """simple docstring"""






         _lowerCamelCase		:							Optional[int]            =					self.feat_extract_tester.prepare_inputs_for_target(equal_length=__lowerCAmelCase						)
         _lowerCamelCase		:							List[str]            =					self.feature_extraction_class(**self.feat_extract_dict						)
         _lowerCamelCase		:							List[str]            =					feat_extract.model_input_names[0]

         _lowerCamelCase		:							Dict            =					BatchFeature({input_name: speech_inputs}		,   tensor_type='''pt'''						)

         _lowerCamelCase		:							Tuple            =					processed_features[input_name]

         if len(batch_features_input.shape						) < 3:
                _lowerCamelCase		:							Optional[int]            =					batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]						), self.feat_extract_tester.num_mel_bins)						)




  @require_torch
  def 		SCREAMING_SNAKE_CASE							(					self	:		Any						):






         """simple docstring"""






         _lowerCamelCase		:							Optional[int]            =					self.feature_extraction_class(**self.feat_extract_dict						)
         _lowerCamelCase		:							Union[str, Any]            =					self.feat_extract_tester.prepare_inputs_for_target()
         _lowerCamelCase		:							Tuple            =					feat_extract.model_input_names[0]

         _lowerCamelCase		:							Optional[int]            =					BatchFeature({input_name: speech_inputs}						)

         _lowerCamelCase		:							Tuple            =					feat_extract.num_mel_bins  # hack!

         _lowerCamelCase		:							Any            =					feat_extract.pad(__lowerCAmelCase		,   padding='''longest'''		,   return_tensors='''np'''						)[input_name]
         _lowerCamelCase		:							List[str]            =					feat_extract.pad(__lowerCAmelCase		,   padding='''longest'''		,   return_tensors='''pt'''						)[input_name]

         self.assertTrue(abs(input_np.astype(np.floataa						).sum() - input_pt.numpy().astype(np.floataa						).sum()						) < 1E-2						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		List[str]						):






         """simple docstring"""






         _lowerCamelCase		:							Optional[Any]            =					self.feat_extract_dict
         _lowerCamelCase		:							List[str]            =					True
         _lowerCamelCase		:							Union[str, Any]            =					self.feature_extraction_class(**__lowerCAmelCase						)
         _lowerCamelCase		:							str            =					self.feat_extract_tester.prepare_inputs_for_target()
         _lowerCamelCase		:							List[str]            =					[len(__lowerCAmelCase						) for x in speech_inputs]
         _lowerCamelCase		:							List[Any]            =					feat_extract.model_input_names[0]

         _lowerCamelCase		:							str            =					BatchFeature({input_name: speech_inputs}						)

         _lowerCamelCase		:							Optional[Any]            =					feat_extract.num_mel_bins  # hack!

         _lowerCamelCase		:							Dict            =					feat_extract.pad(__lowerCAmelCase		,   padding='''longest'''		,   return_tensors='''np'''						)
         self.assertIn('''attention_mask'''		,   __lowerCAmelCase						)
         self.assertListEqual(list(processed.attention_mask.shape						)		,   list(processed[input_name].shape[:2]						)						)
         self.assertListEqual(processed.attention_mask.sum(-1						).tolist()		,   __lowerCAmelCase						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		Optional[int]						):






         """simple docstring"""






         _lowerCamelCase		:							List[Any]            =					self.feat_extract_dict
         _lowerCamelCase		:							List[str]            =					True
         _lowerCamelCase		:							Union[str, Any]            =					self.feature_extraction_class(**__lowerCAmelCase						)
         _lowerCamelCase		:							Optional[int]            =					self.feat_extract_tester.prepare_inputs_for_target()
         _lowerCamelCase		:							int            =					[len(__lowerCAmelCase						) for x in speech_inputs]
         _lowerCamelCase		:							Any            =					feat_extract.model_input_names[0]

         _lowerCamelCase		:							List[Any]            =					BatchFeature({input_name: speech_inputs}						)
         _lowerCamelCase		:							Optional[int]            =					min(__lowerCAmelCase						)

         _lowerCamelCase		:							int            =					feat_extract.num_mel_bins  # hack!

         _lowerCamelCase		:							Dict            =					feat_extract.pad(
             __lowerCAmelCase		,   padding='''max_length'''		,   max_length=__lowerCAmelCase		,   truncation=__lowerCAmelCase		,   return_tensors='''np'''						)
         self.assertIn('''attention_mask'''		,   __lowerCAmelCase						)
         self.assertListEqual(
             list(processed_pad.attention_mask.shape						)		,   [processed_pad[input_name].shape[0], max_length]						)
         self.assertListEqual(
             processed_pad.attention_mask[:, :max_length].sum(-1						).tolist()		,   [max_length for x in speech_inputs]						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		int		,   __lowerCAmelCase	:		Union[str, Any]						):






         """simple docstring"""






         from datasets import load_dataset

         _lowerCamelCase		:							Union[str, Any]            =					load_dataset('''hf-internal-testing/librispeech_asr_dummy'''		,   '''clean'''		,   split='''validation'''						)
         # automatic decoding with librispeech
         _lowerCamelCase		:							Optional[Any]            =					ds.sort('''id'''						).select(range(__lowerCAmelCase						)						)[:num_samples]['''audio''']

         return [x["array"] for x in speech_samples]




  def 		SCREAMING_SNAKE_CASE							(					self	:		Union[str, Any]						):






         """simple docstring"""






         _lowerCamelCase		:							Dict            =					torch.tensor(
             [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
              3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
              2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
              4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
              7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
              4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03]						)
         # fmt: on

         _lowerCamelCase		:							Dict            =					self._load_datasamples(1						)
         _lowerCamelCase		:							List[Any]            =					SpeechTaFeatureExtractor()
         _lowerCamelCase		:							Optional[Any]            =					feature_extractor(__lowerCAmelCase		,   return_tensors='''pt'''						).input_values
         self.assertEquals(input_values.shape		,   (1, 9_3_6_8_0)						)
         self.assertTrue(torch.allclose(input_values[0, :3_0]		,   __lowerCAmelCase		,   atol=1E-6						)						)




  def 		SCREAMING_SNAKE_CASE							(					self	:		Tuple						):






         """simple docstring"""






         _lowerCamelCase		:							Optional[Any]            =					torch.tensor(
             [-2.68_70, -3.01_04, -3.13_56, -3.53_52, -3.00_44, -3.03_53, -3.47_19, -3.67_77,
              -3.15_20, -2.94_35, -2.65_53, -2.87_95, -2.99_44, -2.59_21, -3.02_79, -3.03_86,
              -3.08_64, -3.12_91, -3.23_53, -2.74_44, -2.68_31, -2.72_87, -3.17_61, -3.15_71,
              -3.27_26, -3.05_82, -3.10_07, -3.45_33, -3.46_95, -3.09_98]						)
         # fmt: on

         _lowerCamelCase		:							Dict            =					self._load_datasamples(1						)
         _lowerCamelCase		:							Optional[Any]            =					SpeechTaFeatureExtractor()
         _lowerCamelCase		:							List[Any]            =					feature_extractor(audio_target=__lowerCAmelCase		,   return_tensors='''pt'''						).input_values
         self.assertEquals(input_values.shape		,   (1, 3_6_6, 8_0)						)
         self.assertTrue(torch.allclose(input_values[0, 0, :3_0]		,   __lowerCAmelCase		,   atol=1E-4						)						)




from __future__ import annotations

lowercase    :   Dict						=			tuple[int, int, int]
lowercase    :   List[str]						=			tuple[str, str, str]


# used alphabet --------------------------
# from string.ascii_uppercase
lowercase    :   int						=			'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

# -------------------------- default selection --------------------------
# rotors --------------------------
lowercase    :   Optional[int]						=			'EGZWVONAHDCLFQMSIPJBYUKXTR'
lowercase    :   Optional[Any]						=			'FOBHMDKEXQNRAULPGSJVTYICZW'
lowercase    :   str						=			'ZJXESIUQLHAVRMDOYGTNFWPBKC'
# reflector --------------------------
lowercase    :   Tuple						=			{
    'A': 'N',
    'N': 'A',
    'B': 'O',
    'O': 'B',
    'C': 'P',
    'P': 'C',
    'D': 'Q',
    'Q': 'D',
    'E': 'R',
    'R': 'E',
    'F': 'S',
    'S': 'F',
    'G': 'T',
    'T': 'G',
    'H': 'U',
    'U': 'H',
    'I': 'V',
    'V': 'I',
    'J': 'W',
    'W': 'J',
    'K': 'X',
    'X': 'K',
    'L': 'Y',
    'Y': 'L',
    'M': 'Z',
    'Z': 'M',
}

# -------------------------- extra rotors --------------------------
lowercase    :   Optional[int]						=			'RMDJXFUWGISLHVTCQNKYPBEZOA'
lowercase    :   List[Any]						=			'SGLCPQWZHKXAREONTFBVIYJUDM'
lowercase    :   Dict						=			'HVSICLTYKQUBXDWAJZOMFGPREN'
lowercase    :   List[Any]						=			'RZWQHFMVDBKICJLNTUXAGYPSOE'
lowercase    :   Optional[Any]						=			'LFKIJODBEGAMQPXVUHYSTCZRWN'
lowercase    :   Tuple						=			'KOAEGVDHXPQZMLFTYWJNBRCIUS'




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     RotorPositionT		,    _lowerCamelCase					:     RotorSelectionT		,    _lowerCamelCase					:     str)   ->       tuple[RotorPositionT, RotorSelectionT, dict[str, str]]:






							'''simple docstring'''





							if (unique_rotsel := len(set(_lowerCamelCase))) < 3:
														__UpperCamelCase      :  Tuple       =   F'Please use 3 unique rotors (not {unique_rotsel})'
														raise Exception(_lowerCamelCase)

							# Checks if rotor positions are valid
							__UpperCamelCase  ,		__UpperCamelCase  ,		__UpperCamelCase      :  str       =   rotpos
							if not 0 < rotorposa <= len(_lowerCamelCase):
														__UpperCamelCase      :  Union[str, Any]       =   F'First rotor position is not within range of 1..26 ({rotorposa}'
														raise ValueError(_lowerCamelCase)
							if not 0 < rotorposa <= len(_lowerCamelCase):
														__UpperCamelCase      :  int       =   F'Second rotor position is not within range of 1..26 ({rotorposa})'
														raise ValueError(_lowerCamelCase)
							if not 0 < rotorposa <= len(_lowerCamelCase):
														__UpperCamelCase      :  List[Any]       =   F'Third rotor position is not within range of 1..26 ({rotorposa})'
														raise ValueError(_lowerCamelCase)

							# Validates string and returns dict
							__UpperCamelCase      :  str       =   _plugboard(_lowerCamelCase)

							return rotpos, rotsel, pbdict




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     str)   ->       dict[str, str]:






							'''simple docstring'''





							if not isinstance(_lowerCamelCase		,    _lowerCamelCase):
														__UpperCamelCase      :  Union[str, Any]       =   F'Plugboard setting isn\'t type string ({type(_lowerCamelCase)})'
														raise TypeError(_lowerCamelCase)
							elif len(_lowerCamelCase) % 2 != 0:
														__UpperCamelCase      :  int       =   F'Odd number of symbols ({len(_lowerCamelCase)})'
														raise Exception(_lowerCamelCase)
							elif pbstring == "":
														return {}

							pbstring.replace(" "		,    "")

							# Checks if all characters are unique
							__UpperCamelCase      :  Optional[int]       =   set()
							for i in pbstring:
														if i not in abc:
																					__UpperCamelCase      :  Tuple       =   F'\'{i}\' not in list of symbols'
																					raise Exception(_lowerCamelCase)
														elif i in tmppbl:
																					__UpperCamelCase      :  Tuple       =   F'Duplicate symbol ({i})'
																					raise Exception(_lowerCamelCase)
														else:
																					tmppbl.add(_lowerCamelCase)
							del tmppbl

							# Created the dictionary
							__UpperCamelCase      :  Union[str, Any]       =   {}
							for j in range(0		,    len(_lowerCamelCase) - 1		,    2):
														__UpperCamelCase      :  Union[str, Any]       =   pbstring[j + 1]
														__UpperCamelCase      :  str       =   pbstring[j]

							return pb




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     str		,    _lowerCamelCase					:     RotorPositionT		,    _lowerCamelCase					:     RotorSelectionT = (rotora, rotora, rotora)		,    _lowerCamelCase					:     str = ""		,    )   ->       str:






							'''simple docstring'''





							__UpperCamelCase      :  List[Any]       =   text.upper()
							__UpperCamelCase  ,		__UpperCamelCase  ,		__UpperCamelCase      :  Optional[int]       =   _validator(
							    _lowerCamelCase		,    _lowerCamelCase		,    plugb.upper())

							__UpperCamelCase  ,		__UpperCamelCase  ,		__UpperCamelCase      :  Tuple       =   rotor_position
							__UpperCamelCase  ,		__UpperCamelCase  ,		__UpperCamelCase      :  List[Any]       =   rotor_selection
							rotorposa -= 1
							rotorposa -= 1
							rotorposa -= 1

							__UpperCamelCase      :  List[str]       =   []

							# encryption/decryption process --------------------------
							for symbol in text:
														if symbol in abc:
																					# 1st plugboard --------------------------
																					if symbol in plugboard:
																												__UpperCamelCase      :  Dict       =   plugboard[symbol]

																					# rotor ra --------------------------
																					__UpperCamelCase      :  Optional[int]       =   abc.index(_lowerCamelCase) + rotorposa
																					__UpperCamelCase      :  List[Any]       =   rotora[index % len(_lowerCamelCase)]

																					# rotor rb --------------------------
																					__UpperCamelCase      :  Dict       =   abc.index(_lowerCamelCase) + rotorposa
																					__UpperCamelCase      :  Any       =   rotora[index % len(_lowerCamelCase)]

																					# rotor rc --------------------------
																					__UpperCamelCase      :  str       =   abc.index(_lowerCamelCase) + rotorposa
																					__UpperCamelCase      :  Union[str, Any]       =   rotora[index % len(_lowerCamelCase)]

																					# reflector --------------------------
																					# this is the reason you don't need another machine to decipher

																					__UpperCamelCase      :  Union[str, Any]       =   reflector[symbol]

																					# 2nd rotors
																					__UpperCamelCase      :  Optional[int]       =   abc[rotora.index(_lowerCamelCase) - rotorposa]
																					__UpperCamelCase      :  Optional[Any]       =   abc[rotora.index(_lowerCamelCase) - rotorposa]
																					__UpperCamelCase      :  str       =   abc[rotora.index(_lowerCamelCase) - rotorposa]

																					# 2nd plugboard
																					if symbol in plugboard:
																												__UpperCamelCase      :  Optional[Any]       =   plugboard[symbol]

																					# moves/resets rotor positions
																					rotorposa += 1
																					if rotorposa >= len(_lowerCamelCase):
																												__UpperCamelCase      :  Any       =   0
																												rotorposa += 1
																					if rotorposa >= len(_lowerCamelCase):
																												__UpperCamelCase      :  Tuple       =   0
																												rotorposa += 1
																					if rotorposa >= len(_lowerCamelCase):
																												__UpperCamelCase      :  List[str]       =   0

        # else:
        #    pass
        #    Error could be also raised
        #    raise ValueError(
        #       'Invalid symbol('+repr(symbol)+')')
														result.append(_lowerCamelCase)

							return "".join(_lowerCamelCase)


if __name__ == "__main__":
		lowercase    :   Optional[Any]						=			'This is my Python script that emulates the Enigma machine from WWII.'
		lowercase    :   int						=			(1, 1, 1)
		lowercase    :   Optional[Any]						=			'pictures'
		lowercase    :   Optional[Any]						=			(rotora, rotora, rotora)
		lowercase    :   Optional[Any]						=			enigma(message, rotor_pos, rotor_sel, pb)

		print('Encrypted message:', en)
		print('Decrypted message:', enigma(en, rotor_pos, rotor_sel, pb))