

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    :       Any        =							random.Random()

def       a__					(		UpperCAmelCase							:      int    ,			UpperCAmelCase							:      int=1.0    ,			UpperCAmelCase							:      Union[str, Any]=None    ,			UpperCAmelCase							:      Tuple=None      )  ->						Optional[Any]:
  if rng is None:
    UpperCAmelCase	:							Optional[Any]						=			global_rng

  UpperCAmelCase	:							Any						=			[]
  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  __UpperCAmelCase					(	unittest.TestCase						):



   def __init__(							self							:					str,		__A							:					Optional[Any],		__A							:					Union[str, Any]=7,		__A							:					Optional[int]=4_0_0,		__A							:					Any=2_0_0_0,		__A							:					Union[str, Any]=1,		__A							:					List[str]=0.0,		__A							:					Dict=1_6_0_0_0,		__A							:					List[Any]=True,		__A							:					Optional[int]=8_0,		__A							:					Optional[Any]=1_6,		__A							:					Any=6_4,		__A							:					str="hann_window",		__A							:					Any=8_0,		__A							:					Tuple=7_6_0_0,		__A							:					str=1E-10,		__A							:					List[Any]=True,		):
     UpperCAmelCase	:							Optional[int]						=			parent
     UpperCAmelCase	:							int						=			batch_size
     UpperCAmelCase	:							Tuple						=			min_seq_length
     UpperCAmelCase	:							int						=			max_seq_length
     UpperCAmelCase	:							Optional[int]						=			(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
     UpperCAmelCase	:							Union[str, Any]						=			feature_size
     UpperCAmelCase	:							Tuple						=			padding_value
     UpperCAmelCase	:							str						=			sampling_rate
     UpperCAmelCase	:							Dict						=			do_normalize
     UpperCAmelCase	:							int						=			num_mel_bins
     UpperCAmelCase	:							Dict						=			hop_length
     UpperCAmelCase	:							Dict						=			win_length
     UpperCAmelCase	:							Dict						=			win_function
     UpperCAmelCase	:							int						=			fmin
     UpperCAmelCase	:							str						=			fmax
     UpperCAmelCase	:							List[str]						=			mel_floor
     UpperCAmelCase	:							List[str]						=			return_attention_mask



   def 	__magic_name__   (							self							:					Optional[Any]						):
     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 	__magic_name__   (							self							:					Optional[Any],		__A							:					Optional[int]=False,		__A							:					Union[str, Any]=False						):
     def _flatten(__A							:					Union[str, Any]						):
       return list(itertools.chain(*__A						)						)

     if equal_length:
       UpperCAmelCase	:							int						=			floats_list((self.batch_size, self.max_seq_length)						)
     else:
       # make sure that inputs increase in size
       UpperCAmelCase	:							str						=			[
           _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:
       UpperCAmelCase	:							int						=			[np.asarray(__A						) for x in speech_inputs]

     return speech_inputs





   def 	__magic_name__   (							self							:					int,		__A							:					List[str]=False,		__A							:					Optional[int]=False						):
     if equal_length:
       UpperCAmelCase	:							Dict						=			[floats_list((self.max_seq_length, self.num_mel_bins)						) for _ in range(self.batch_size						)]
     else:
       # make sure that inputs increase in size
       UpperCAmelCase	:							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:
       UpperCAmelCase	:							int						=			[np.asarray(__A						) for x in speech_inputs]

     return speech_inputs






@require_torch
class  __UpperCAmelCase					(	lowerCamelCase__      ,  unittest.TestCase						):
   UpperCamelCase       					=					SpeechTaFeatureExtractor



   def 	__magic_name__   (							self							:					Optional[Any]						):
     UpperCAmelCase	:							str						=			SpeechTaFeatureExtractionTester(self						)



   def 	__magic_name__   (							self							:					Union[str, Any],		__A							:					str						):
     self.assertTrue(np.all(np.mean(__A,		axis=0						) < 1E-3						)						)
     self.assertTrue(np.all(np.abs(np.var(__A,		axis=0						) - 1						) < 1E-3						)						)



   def 	__magic_name__   (							self							:					Dict						):
     # Tests that all call wrap to encode_plus and batch_encode_plus
     UpperCAmelCase	:							Dict						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
     # create three inputs of length 800, 1000, and 1200
     UpperCAmelCase	:							int						=			[floats_list((1, x)						)[0] for x in range(8_0_0,		1_4_0_0,		2_0_0						)]
     UpperCAmelCase	:							Optional[Any]						=			[np.asarray(__A						) for speech_input in speech_inputs]

     # Test not batched input
     UpperCAmelCase	:							Tuple						=			feat_extract(speech_inputs[0],		return_tensors='''np'''						).input_values
     UpperCAmelCase	:							Union[str, Any]						=			feat_extract(np_speech_inputs[0],		return_tensors='''np'''						).input_values
     self.assertTrue(np.allclose(__A,		__A,		atol=1E-3						)						)

     # Test batched
     UpperCAmelCase	:							Optional[Any]						=			feat_extract(__A,		return_tensors='''np'''						).input_values
     UpperCAmelCase	:							int						=			feat_extract(__A,		return_tensors='''np'''						).input_values
     for enc_seq_a, enc_seq_a in zip(__A,		__A						):
       self.assertTrue(np.allclose(__A,		__A,		atol=1E-3						)						)



   def 	__magic_name__   (							self							:					str						):
     UpperCAmelCase	:							Dict						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
     UpperCAmelCase	:							Dict						=			[floats_list((1, x)						)[0] for x in range(8_0_0,		1_4_0_0,		2_0_0						)]

     UpperCAmelCase	:							Optional[int]						=			['''longest''', '''max_length''', '''do_not_pad''']
     UpperCAmelCase	:							str						=			[None, 1_6_0_0, None]
     for max_length, padding in zip(__A,		__A						):
       UpperCAmelCase	:							Tuple						=			feat_extract(__A,		padding=__A,		max_length=__A,		return_tensors='''np'''						)
       UpperCAmelCase	:							Union[str, 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 	__magic_name__   (							self							:					Optional[int]						):
     UpperCAmelCase	:							str						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
     UpperCAmelCase	:							List[str]						=			range(8_0_0,		1_4_0_0,		2_0_0						)
     UpperCAmelCase	:							str						=			[floats_list((1, x)						)[0] for x in lengths]

     UpperCAmelCase	:							List[Any]						=			['''longest''', '''max_length''', '''do_not_pad''']
     UpperCAmelCase	:							str						=			[None, 1_6_0_0, None]

     for max_length, padding in zip(__A,		__A						):
       UpperCAmelCase	:							List[Any]						=			feat_extract(__A,		max_length=__A,		padding=__A						)
       UpperCAmelCase	:							int						=			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 	__magic_name__   (							self							:					Optional[int]						):
     UpperCAmelCase	:							List[str]						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
     UpperCAmelCase	:							str						=			[floats_list((1, x)						)[0] for x in range(8_0_0,		1_4_0_0,		2_0_0						)]
     UpperCAmelCase	:							Union[str, Any]						=			feat_extract(
         __A,		truncation=__A,		max_length=1_0_0_0,		padding='''max_length''',		return_tensors='''np'''						)
     UpperCAmelCase	:							Dict						=			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 	__magic_name__   (							self							:					Tuple						):
     UpperCAmelCase	:							Any						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
     UpperCAmelCase	:							Any						=			[floats_list((1, x)						)[0] for x in range(8_0_0,		1_4_0_0,		2_0_0						)]
     UpperCAmelCase	:							Tuple						=			feat_extract(
         __A,		truncation=__A,		max_length=1_0_0_0,		padding='''longest''',		return_tensors='''np'''						)
     UpperCAmelCase	:							Optional[int]						=			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)						)

     UpperCAmelCase	:							Any						=			[floats_list((1, x)						)[0] for x in range(8_0_0,		1_4_0_0,		2_0_0						)]
     UpperCAmelCase	:							str						=			feat_extract(
         __A,		truncation=__A,		max_length=2_0_0_0,		padding='''longest''',		return_tensors='''np'''						)
     UpperCAmelCase	:							str						=			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 	__magic_name__   (							self							:					Optional[Any]						):
     UpperCAmelCase	:							Optional[Any]						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
     UpperCAmelCase	:							Any						=			np.random.rand(1_0_0						).astype(np.floataa						)
     UpperCAmelCase	:							Optional[int]						=			np_speech_inputs.tolist()

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



   def 	__magic_name__   (							self							:					Optional[Any]						):
     # Tests that all call wrap to encode_plus and batch_encode_plus
     UpperCAmelCase	:							Union[str, Any]						=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
     # create three inputs of length 800, 1000, and 1200
     UpperCAmelCase	:							Optional[int]						=			[floats_list((1, x)						)[0] for x in range(8_0_0,		1_4_0_0,		2_0_0						)]
     UpperCAmelCase	:							List[str]						=			[np.asarray(__A						) for speech_input in speech_inputs]

     # Test feature size
     UpperCAmelCase	:							Tuple						=			feature_extractor(audio_target=__A,		padding=__A,		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
     UpperCAmelCase	:							Dict						=			feature_extractor(speech_inputs[0],		return_tensors='''np'''						).input_values
     UpperCAmelCase	:							List[Any]						=			feature_extractor(np_speech_inputs[0],		return_tensors='''np'''						).input_values
     self.assertTrue(np.allclose(__A,		__A,		atol=1E-3						)						)

     # Test batched
     UpperCAmelCase	:							Optional[Any]						=			feature_extractor(__A,		return_tensors='''np'''						).input_values
     UpperCAmelCase	:							Dict						=			feature_extractor(__A,		return_tensors='''np'''						).input_values
     for enc_seq_a, enc_seq_a in zip(__A,		__A						):
       self.assertTrue(np.allclose(__A,		__A,		atol=1E-3						)						)

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



   def 	__magic_name__   (							self							:					Dict						):
     UpperCAmelCase	:							List[Any]						=			self.feat_extract_tester.prepare_inputs_for_target()
     UpperCAmelCase	:							Any						=			self.feature_extraction_class(**self.feat_extract_dict						)
     UpperCAmelCase	:							Optional[int]						=			feat_extract.model_input_names[0]

     UpperCAmelCase	:							Dict						=			BatchFeature({input_name: speech_inputs}						)

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

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

     UpperCAmelCase	:							Dict						=			processed_features[input_name]

     if len(batch_features_input.shape						) < 3:
       UpperCAmelCase	:							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 	__magic_name__   (							self							:					Tuple						):
     UpperCAmelCase	:							Tuple						=			self.feat_extract_tester.prepare_inputs_for_target(equal_length=__A						)
     UpperCAmelCase	:							Dict						=			self.feature_extraction_class(**self.feat_extract_dict						)
     UpperCAmelCase	:							List[str]						=			feat_extract.model_input_names[0]

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

     UpperCAmelCase	:							Optional[Any]						=			processed_features[input_name]

     if len(batch_features_input.shape						) < 3:
       UpperCAmelCase	:							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 	__magic_name__   (							self							:					List[Any]						):
     UpperCAmelCase	:							List[str]						=			self.feature_extraction_class(**self.feat_extract_dict						)
     UpperCAmelCase	:							str						=			self.feat_extract_tester.prepare_inputs_for_target()
     UpperCAmelCase	:							Any						=			feat_extract.model_input_names[0]

     UpperCAmelCase	:							List[Any]						=			BatchFeature({input_name: speech_inputs}						)

     UpperCAmelCase	:							Union[str, Any]						=			feat_extract.num_mel_bins  # hack!

     UpperCAmelCase	:							List[str]						=			feat_extract.pad(__A,		padding='''longest''',		return_tensors='''np'''						)[input_name]
     UpperCAmelCase	:							Dict						=			feat_extract.pad(__A,		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 	__magic_name__   (							self							:					int						):
     UpperCAmelCase	:							List[str]						=			self.feat_extract_dict
     UpperCAmelCase	:							Any						=			True
     UpperCAmelCase	:							Dict						=			self.feature_extraction_class(**__A						)
     UpperCAmelCase	:							Tuple						=			self.feat_extract_tester.prepare_inputs_for_target()
     UpperCAmelCase	:							Any						=			[len(__A						) for x in speech_inputs]
     UpperCAmelCase	:							Tuple						=			feat_extract.model_input_names[0]

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

     UpperCAmelCase	:							List[Any]						=			feat_extract.num_mel_bins  # hack!

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



   def 	__magic_name__   (							self							:					Tuple						):
     UpperCAmelCase	:							Dict						=			self.feat_extract_dict
     UpperCAmelCase	:							Optional[int]						=			True
     UpperCAmelCase	:							Optional[int]						=			self.feature_extraction_class(**__A						)
     UpperCAmelCase	:							Any						=			self.feat_extract_tester.prepare_inputs_for_target()
     UpperCAmelCase	:							Union[str, Any]						=			[len(__A						) for x in speech_inputs]
     UpperCAmelCase	:							str						=			feat_extract.model_input_names[0]

     UpperCAmelCase	:							Tuple						=			BatchFeature({input_name: speech_inputs}						)
     UpperCAmelCase	:							Optional[Any]						=			min(__A						)

     UpperCAmelCase	:							List[Any]						=			feat_extract.num_mel_bins  # hack!

     UpperCAmelCase	:							str						=			feat_extract.pad(
         __A,		padding='''max_length''',		max_length=__A,		truncation=__A,		return_tensors='''np'''						)
     self.assertIn('''attention_mask''',		__A						)
     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 	__magic_name__   (							self							:					List[Any],		__A							:					List[Any]						):
     from datasets import load_dataset

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

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



   def 	__magic_name__   (							self							:					Optional[Any]						):
     # fmt: off
     UpperCAmelCase	:							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

     UpperCAmelCase	:							Optional[int]						=			self._load_datasamples(1						)
     UpperCAmelCase	:							Optional[Any]						=			SpeechTaFeatureExtractor()
     UpperCAmelCase	:							str						=			feature_extractor(__A,		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],		__A,		atol=1E-6						)						)





   def 	__magic_name__   (							self							:					Union[str, Any]						):
     # fmt: off
     UpperCAmelCase	:							List[Any]						=			torch.tensor(
         [-2.6_8_7_0, -3.0_1_0_4, -3.1_3_5_6, -3.5_3_5_2, -3.0_0_4_4, -3.0_3_5_3, -3.4_7_1_9, -3.6_7_7_7,
          -3.1_5_2_0, -2.9_4_3_5, -2.6_5_5_3, -2.8_7_9_5, -2.9_9_4_4, -2.5_9_2_1, -3.0_2_7_9, -3.0_3_8_6,
          -3.0_8_6_4, -3.1_2_9_1, -3.2_3_5_3, -2.7_4_4_4, -2.6_8_3_1, -2.7_2_8_7, -3.1_7_6_1, -3.1_5_7_1,
          -3.2_7_2_6, -3.0_5_8_2, -3.1_0_0_7, -3.4_5_3_3, -3.4_6_9_5, -3.0_9_9_8]						)
     # fmt: on

     UpperCAmelCase	:							int						=			self._load_datasamples(1						)
     UpperCAmelCase	:							Tuple						=			SpeechTaFeatureExtractor()
     UpperCAmelCase	:							List[str]						=			feature_extractor(audio_target=__A,		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],		__A,		atol=1E-4						)						)








def       a__					(		UpperCAmelCase							:      int    ,			UpperCAmelCase							:      int      )  ->						str:
  if a < 0 or b < 0:
    raise ValueError('''the value of both inputs must be positive'''      )
  UpperCAmelCase	:							List[Any]						=			str(bin(UpperCAmelCase      )      )[2:]  # remove the leading "0b"
  UpperCAmelCase	:							List[str]						=			str(bin(UpperCAmelCase      )      )[2:]
  UpperCAmelCase	:							Optional[Any]						=			max(len(UpperCAmelCase      )    ,			len(UpperCAmelCase      )      )
  return "0b" + "".join(
      str(int('''1''' in (char_a, char_b)      )      )
      for char_a, char_b in zip(a_binary.zfill(UpperCAmelCase      )    ,			b_binary.zfill(UpperCAmelCase      )      )      )


if __name__ == "__main__":
     import doctest

     doctest.testmod()





