


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


A	:  Union[str, Any]            =     random.Random()


def _lowerCamelCase      (						_UpperCamelCase       ,					_UpperCamelCase=1.0       ,					_UpperCamelCase=None       ,					_UpperCamelCase=None ):

			'''simple docstring'''




			if rng is None:
						__lowerCAmelCase							       =     global_rng

			__lowerCAmelCase							       =     []
			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						):
							'''simple docstring'''







							def __init__(	self       ,  __a       ,  __a=7       ,  __a=4_00       ,  __a=20_00       ,  __a=1       ,  __a=0.0       ,  __a=1_60_00       ,  __a=True       ,  __a=80       ,  __a=16       ,  __a=64       ,  __a="hann_window"       ,  __a=80       ,  __a=76_00       ,  __a=1e-1_0       ,  __a=True       ,  ):
										__lowerCAmelCase							       =     parent
										__lowerCAmelCase							       =     batch_size
										__lowerCAmelCase							       =     min_seq_length
										__lowerCAmelCase							       =     max_seq_length
										__lowerCAmelCase							       =     (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
										__lowerCAmelCase							       =     feature_size
										__lowerCAmelCase							       =     padding_value
										__lowerCAmelCase							       =     sampling_rate
										__lowerCAmelCase							       =     do_normalize
										__lowerCAmelCase							       =     num_mel_bins
										__lowerCAmelCase							       =     hop_length
										__lowerCAmelCase							       =     win_length
										__lowerCAmelCase							       =     win_function
										__lowerCAmelCase							       =     fmin
										__lowerCAmelCase							       =     fmax
										__lowerCAmelCase							       =     mel_floor
										__lowerCAmelCase							       =     return_attention_mask

							def      snake_case							(	self      ):
										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      snake_case							(	self       ,  __a=False       ,  __a=False      ):
										def _flatten(__a      ):
													return list(itertools.chain(*__a      )      )

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

										return speech_inputs



							def      snake_case							(	self       ,  __a=False       ,  __a=False      ):
										if equal_length:
													__lowerCAmelCase							       =     [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							       =     [
													    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							       =     [np.asarray(__a      ) for x in speech_inputs]

										return speech_inputs
@require_torch
class     _UpperCamelCase    (  lowerCAmelCase__			,unittest.TestCase						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =SpeechTaFeatureExtractor

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     SpeechTaFeatureExtractionTester(self      )

							def      snake_case							(	self       ,  __a      ):
										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      snake_case							(	self      ):
										# Tests that all call wrap to encode_plus and batch_encode_plus
										__lowerCAmelCase							       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
										# create three inputs of length 800, 1000, and 1200
										__lowerCAmelCase							       =     [floats_list((1, x)      )[0] for x in range(8_00       ,  14_00       ,  2_00      )]
										__lowerCAmelCase							       =     [np.asarray(__a      ) for speech_input in speech_inputs]

										# Test not batched input
										__lowerCAmelCase							       =     feat_extract(speech_inputs[0]       ,  return_tensors="np"      ).input_values
										__lowerCAmelCase							       =     feat_extract(np_speech_inputs[0]       ,  return_tensors="np"      ).input_values
										self.assertTrue(np.allclose(__a       ,  __a       ,  atol=1e-3      )      )

										# Test batched
										__lowerCAmelCase							       =     feat_extract(__a       ,  return_tensors="np"      ).input_values
										__lowerCAmelCase							       =     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      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
										__lowerCAmelCase							       =     [floats_list((1, x)      )[0] for x in range(8_00       ,  14_00       ,  2_00      )]

										__lowerCAmelCase							       =     ["longest", "max_length", "do_not_pad"]
										__lowerCAmelCase							       =     [None, 16_00, None]
										for max_length, padding in zip(__a       ,  __a      ):
													__lowerCAmelCase							       =     feat_extract(__a       ,  padding=__a       ,  max_length=__a       ,  return_tensors="np"      )
													__lowerCAmelCase							       =     processed.input_values

													self._check_zero_mean_unit_variance(input_values[0][:8_00]      )
													self.assertTrue(input_values[0][8_00:].sum() < 1e-6      )
													self._check_zero_mean_unit_variance(input_values[1][:10_00]      )
													self.assertTrue(input_values[0][10_00:].sum() < 1e-6      )
													self._check_zero_mean_unit_variance(input_values[2][:12_00]      )

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
										__lowerCAmelCase							       =     range(8_00       ,  14_00       ,  2_00      )
										__lowerCAmelCase							       =     [floats_list((1, x)      )[0] for x in lengths]

										__lowerCAmelCase							       =     ["longest", "max_length", "do_not_pad"]
										__lowerCAmelCase							       =     [None, 16_00, None]

										for max_length, padding in zip(__a       ,  __a      ):
													__lowerCAmelCase							       =     feat_extract(__a       ,  max_length=__a       ,  padding=__a      )
													__lowerCAmelCase							       =     processed.input_values

													self._check_zero_mean_unit_variance(input_values[0][:8_00]      )
													self._check_zero_mean_unit_variance(input_values[1][:10_00]      )
													self._check_zero_mean_unit_variance(input_values[2][:12_00]      )

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
										__lowerCAmelCase							       =     [floats_list((1, x)      )[0] for x in range(8_00       ,  14_00       ,  2_00      )]
										__lowerCAmelCase							       =     feat_extract(
										    __a       ,  truncation=__a       ,  max_length=10_00       ,  padding="max_length"       ,  return_tensors="np"      )
										__lowerCAmelCase							       =     processed.input_values

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

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
										__lowerCAmelCase							       =     [floats_list((1, x)      )[0] for x in range(8_00       ,  14_00       ,  2_00      )]
										__lowerCAmelCase							       =     feat_extract(
										    __a       ,  truncation=__a       ,  max_length=10_00       ,  padding="longest"       ,  return_tensors="np"      )
										__lowerCAmelCase							       =     processed.input_values

										self._check_zero_mean_unit_variance(input_values[0, :8_00]      )
										self._check_zero_mean_unit_variance(input_values[1, :10_00]      )
										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, 10_00)      )

										__lowerCAmelCase							       =     [floats_list((1, x)      )[0] for x in range(8_00       ,  14_00       ,  2_00      )]
										__lowerCAmelCase							       =     feat_extract(
										    __a       ,  truncation=__a       ,  max_length=20_00       ,  padding="longest"       ,  return_tensors="np"      )
										__lowerCAmelCase							       =     processed.input_values

										self._check_zero_mean_unit_variance(input_values[0, :8_00]      )
										self._check_zero_mean_unit_variance(input_values[1, :10_00]      )
										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, 12_00)      )

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
										__lowerCAmelCase							       =     np.random.rand(1_00      ).astype(np.floataa      )
										__lowerCAmelCase							       =     np_speech_inputs.tolist()

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

							def      snake_case							(	self      ):
										# Tests that all call wrap to encode_plus and batch_encode_plus
										__lowerCAmelCase							       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
										# create three inputs of length 800, 1000, and 1200
										__lowerCAmelCase							       =     [floats_list((1, x)      )[0] for x in range(8_00       ,  14_00       ,  2_00      )]
										__lowerCAmelCase							       =     [np.asarray(__a      ) for speech_input in speech_inputs]

										# Test feature size
										__lowerCAmelCase							       =     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
										__lowerCAmelCase							       =     feature_extractor(speech_inputs[0]       ,  return_tensors="np"      ).input_values
										__lowerCAmelCase							       =     feature_extractor(np_speech_inputs[0]       ,  return_tensors="np"      ).input_values
										self.assertTrue(np.allclose(__a       ,  __a       ,  atol=1e-3      )      )

										# Test batched
										__lowerCAmelCase							       =     feature_extractor(__a       ,  return_tensors="np"      ).input_values
										__lowerCAmelCase							       =     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.
										__lowerCAmelCase							       =     [floats_list((1, x)      )[0] for x in (8_00, 8_00, 8_00)]
										__lowerCAmelCase							       =     np.asarray(__a      )
										__lowerCAmelCase							       =     feature_extractor(__a       ,  return_tensors="np"      ).input_values
										__lowerCAmelCase							       =     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      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.feat_extract_tester.prepare_inputs_for_target()
										__lowerCAmelCase							       =     self.feature_extraction_class(**self.feat_extract_dict      )
										__lowerCAmelCase							       =     feat_extract.model_input_names[0]

										__lowerCAmelCase							       =     BatchFeature({input_name: speech_inputs}      )

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

										__lowerCAmelCase							       =     self.feat_extract_tester.prepare_inputs_for_target(equal_length=__a      )
										__lowerCAmelCase							       =     BatchFeature({input_name: speech_inputs}       ,  tensor_type="np"      )

										__lowerCAmelCase							       =     processed_features[input_name]

										if len(batch_features_input.shape      ) < 3:
													__lowerCAmelCase							       =     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      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.feat_extract_tester.prepare_inputs_for_target(equal_length=__a      )
										__lowerCAmelCase							       =     self.feature_extraction_class(**self.feat_extract_dict      )
										__lowerCAmelCase							       =     feat_extract.model_input_names[0]

										__lowerCAmelCase							       =     BatchFeature({input_name: speech_inputs}       ,  tensor_type="pt"      )

										__lowerCAmelCase							       =     processed_features[input_name]

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

										__lowerCAmelCase							       =     BatchFeature({input_name: speech_inputs}      )

										__lowerCAmelCase							       =     feat_extract.num_mel_bins  # hack!

										__lowerCAmelCase							       =     feat_extract.pad(__a       ,  padding="longest"       ,  return_tensors="np"      )[input_name]
										__lowerCAmelCase							       =     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      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.feat_extract_dict
										__lowerCAmelCase							       =     True
										__lowerCAmelCase							       =     self.feature_extraction_class(**__a      )
										__lowerCAmelCase							       =     self.feat_extract_tester.prepare_inputs_for_target()
										__lowerCAmelCase							       =     [len(__a      ) for x in speech_inputs]
										__lowerCAmelCase							       =     feat_extract.model_input_names[0]

										__lowerCAmelCase							       =     BatchFeature({input_name: speech_inputs}      )

										__lowerCAmelCase							       =     feat_extract.num_mel_bins  # hack!

										__lowerCAmelCase							       =     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      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.feat_extract_dict
										__lowerCAmelCase							       =     True
										__lowerCAmelCase							       =     self.feature_extraction_class(**__a      )
										__lowerCAmelCase							       =     self.feat_extract_tester.prepare_inputs_for_target()
										__lowerCAmelCase							       =     [len(__a      ) for x in speech_inputs]
										__lowerCAmelCase							       =     feat_extract.model_input_names[0]

										__lowerCAmelCase							       =     BatchFeature({input_name: speech_inputs}      )
										__lowerCAmelCase							       =     min(__a      )

										__lowerCAmelCase							       =     feat_extract.num_mel_bins  # hack!

										__lowerCAmelCase							       =     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      snake_case							(	self       ,  __a      ):
										from datasets import load_dataset

										__lowerCAmelCase							       =     load_dataset("hf-internal-testing/librispeech_asr_dummy"       ,  "clean"       ,  split="validation"      )
										# automatic decoding with librispeech
										__lowerCAmelCase							       =     ds.sort("id"      ).select(range(__a      )      )[:num_samples]["audio"]

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

							def      snake_case							(	self      ):
										# fmt: off
										__lowerCAmelCase							       =     torch.tensor(
										    [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
										     3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
										     2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
										     4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
										     7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
										     4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]      )
										# fmt: on

										__lowerCAmelCase							       =     self._load_datasamples(1      )
										__lowerCAmelCase							       =     SpeechTaFeatureExtractor()
										__lowerCAmelCase							       =     feature_extractor(__a       ,  return_tensors="pt"      ).input_values
										self.assertEquals(input_values.shape       ,  (1, 9_36_80)      )
										self.assertTrue(torch.allclose(input_values[0, :30]       ,  __a       ,  atol=1e-6      )      )



							def      snake_case							(	self      ):
										# fmt: off
										__lowerCAmelCase							       =     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

										__lowerCAmelCase							       =     self._load_datasamples(1      )
										__lowerCAmelCase							       =     SpeechTaFeatureExtractor()
										__lowerCAmelCase							       =     feature_extractor(audio_target=__a       ,  return_tensors="pt"      ).input_values
										self.assertEquals(input_values.shape       ,  (1, 3_66, 80)      )
										self.assertTrue(torch.allclose(input_values[0, 0, :30]       ,  __a       ,  atol=1e-4      )      )








"""simple docstring"""


import baseaa


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			return baseaa.baaencode(string.encode("utf-8" ) )


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			return baseaa.baadecode(_UpperCamelCase ).decode("utf-8" )


if __name__ == "__main__":
	A	:  List[str]            =     "Hello World!"
	A	:  Any            =     baseaa_encode(test)
	print(encoded)

	A	:  List[Any]            =     baseaa_decode(encoded)
	print(decoded)




