




'''simple docstring'''






import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    CLIPConfig,
    CLIPImageProcessor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER


sys.path.append(str(Path(__file__).parent.parent.parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_image_processing import CustomImageProcessor  # noqa E402



class 					A		( unittest.TestCase		):




				'''simple docstring'''





				def        a_       (self			)	->       Any:
							__UpperCamelCase      :			str									=   0
				def        a_       (self			)	->       Tuple:
							__UpperCamelCase      :			str									=   AutoImageProcessor.from_pretrained("openai/clip-vit-base-patch32"			)
							self.assertIsInstance(_A ,  _A			)
				def        a_       (self			)	->       Any:







							with tempfile.TemporaryDirectory() as tmpdirname:
										__UpperCamelCase      :			List[str]									=   Path(_A			) / "preprocessor_config.json"
										__UpperCamelCase      :			Tuple									=   Path(_A			) / "config.json"
										json.dump(
										    {"image_processor_type": "CLIPImageProcessor", "processor_class": "CLIPProcessor"} ,  open(_A ,  "w"			) ,  )
										json.dump({"model_type": "clip"} ,  open(_A ,  "w"			)			)

										__UpperCamelCase      :			Optional[int]									=   AutoImageProcessor.from_pretrained(_A			)
										self.assertIsInstance(_A ,  _A			)
				def        a_       (self			)	->       str:







							with tempfile.TemporaryDirectory() as tmpdirname:
										__UpperCamelCase      :			Optional[Any]									=   Path(_A			) / "preprocessor_config.json"
										__UpperCamelCase      :			List[Any]									=   Path(_A			) / "config.json"
										json.dump(
										    {"feature_extractor_type": "CLIPFeatureExtractor", "processor_class": "CLIPProcessor"} ,  open(_A ,  "w"			) ,  )
										json.dump({"model_type": "clip"} ,  open(_A ,  "w"			)			)

										__UpperCamelCase      :			Union[str, Any]									=   AutoImageProcessor.from_pretrained(_A			)
										self.assertIsInstance(_A ,  _A			)
				def        a_       (self			)	->       Dict:







							with tempfile.TemporaryDirectory() as tmpdirname:
										__UpperCamelCase      :			Dict									=   CLIPConfig()

										# Create a dummy config file with image_proceesor_type
										__UpperCamelCase      :			int									=   Path(_A			) / "preprocessor_config.json"
										__UpperCamelCase      :			List[str]									=   Path(_A			) / "config.json"
										json.dump(
										    {"image_processor_type": "CLIPImageProcessor", "processor_class": "CLIPProcessor"} ,  open(_A ,  "w"			) ,  )
										json.dump({"model_type": "clip"} ,  open(_A ,  "w"			)			)

										# remove image_processor_type to make sure config.json alone is enough to load image processor locally
										__UpperCamelCase      :			List[Any]									=   AutoImageProcessor.from_pretrained(_A			).to_dict()

										config_dict.pop("image_processor_type"			)
										__UpperCamelCase      :			List[str]									=   CLIPImageProcessor(**_A			)

										# save in new folder
										model_config.save_pretrained(_A			)
										config.save_pretrained(_A			)

										__UpperCamelCase      :			str									=   AutoImageProcessor.from_pretrained(_A			)

										# make sure private variable is not incorrectly saved
										__UpperCamelCase      :			Optional[Any]									=   json.loads(config.to_json_string()			)
										self.assertTrue("_processor_class" not in dict_as_saved			)

							self.assertIsInstance(_A ,  _A			)
				def        a_       (self			)	->       Dict:







							with tempfile.TemporaryDirectory() as tmpdirname:
										__UpperCamelCase      :			List[Any]									=   Path(_A			) / "preprocessor_config.json"
										json.dump(
										    {"image_processor_type": "CLIPImageProcessor", "processor_class": "CLIPProcessor"} ,  open(_A ,  "w"			) ,  )

										__UpperCamelCase      :			int									=   AutoImageProcessor.from_pretrained(_A			)
										self.assertIsInstance(_A ,  _A			)
				def        a_       (self			)	->       List[Any]:







							with self.assertRaisesRegex(
							    _A ,  "clip-base is not a local folder and is not a valid model identifier"			):
										__UpperCamelCase      :			Optional[int]									=   AutoImageProcessor.from_pretrained("clip-base"			)
				def        a_       (self			)	->       Union[str, Any]:







							with self.assertRaisesRegex(
							    _A ,  R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"			):
										__UpperCamelCase      :			Tuple									=   AutoImageProcessor.from_pretrained(_A ,  revision="aaaaaa"			)
				def        a_       (self			)	->       Tuple:







							with self.assertRaisesRegex(
							    _A ,  "hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json." ,  ):
										__UpperCamelCase      :			List[Any]									=   AutoImageProcessor.from_pretrained("hf-internal-testing/config-no-model"			)
				def        a_       (self			)	->       Optional[int]:







							with self.assertRaises(_A			):
										__UpperCamelCase      :			Tuple									=   AutoImageProcessor.from_pretrained("hf-internal-testing/test_dynamic_image_processor"			)
							# If remote code is disabled, we can't load this config.
							with self.assertRaises(_A			):
										__UpperCamelCase      :			Tuple									=   AutoImageProcessor.from_pretrained(
										    "hf-internal-testing/test_dynamic_image_processor" ,  trust_remote_code=_A			)

							__UpperCamelCase      :			Union[str, Any]									=   AutoImageProcessor.from_pretrained(
							    "hf-internal-testing/test_dynamic_image_processor" ,  trust_remote_code=_A			)
							self.assertEqual(image_processor.__class__.__name__ ,  "NewImageProcessor"			)

							# Test image processor can be reloaded.
							with tempfile.TemporaryDirectory() as tmp_dir:
										image_processor.save_pretrained(_A			)
										__UpperCamelCase      :			List[str]									=   AutoImageProcessor.from_pretrained(_A ,  trust_remote_code=_A			)
							self.assertEqual(reloaded_image_processor.__class__.__name__ ,  "NewImageProcessor"			)
				def        a_       (self			)	->       Tuple:







							try:
										AutoConfig.register("custom" ,  _A			)
										AutoImageProcessor.register(_A ,  _A			)
										# Trying to register something existing in the Transformers library will raise an error
										with self.assertRaises(_A			):
													AutoImageProcessor.register(_A ,  _A			)

										with tempfile.TemporaryDirectory() as tmpdirname:
													__UpperCamelCase      :			Union[str, Any]									=   Path(_A			) / "preprocessor_config.json"
													__UpperCamelCase      :			Dict									=   Path(_A			) / "config.json"
													json.dump(
													    {"feature_extractor_type": "CLIPFeatureExtractor", "processor_class": "CLIPProcessor"} ,  open(_A ,  "w"			) ,  )
													json.dump({"model_type": "clip"} ,  open(_A ,  "w"			)			)

													__UpperCamelCase      :			int									=   CustomImageProcessor.from_pretrained(_A			)

										# Now that the config is registered, it can be used as any other config with the auto-API
										with tempfile.TemporaryDirectory() as tmp_dir:
													image_processor.save_pretrained(_A			)
													__UpperCamelCase      :			List[Any]									=   AutoImageProcessor.from_pretrained(_A			)
													self.assertIsInstance(_A ,  _A			)

							finally:
										if "custom" in CONFIG_MAPPING._extra_content:
													del CONFIG_MAPPING._extra_content["custom"]
										if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
													del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]





				def        a_       (self			)	->       Optional[Any]:



							class 					A		( a_		):




											'''simple docstring'''





											A      	=				True

							try:
										AutoConfig.register("custom" ,  _A			)
										AutoImageProcessor.register(_A ,  _A			)
										# If remote code is not set, the default is to use local
										__UpperCamelCase      :			Tuple									=   AutoImageProcessor.from_pretrained("hf-internal-testing/test_dynamic_image_processor"			)
										self.assertEqual(image_processor.__class__.__name__ ,  "NewImageProcessor"			)
										self.assertTrue(image_processor.is_local			)

										# If remote code is disabled, we load the local one.
										__UpperCamelCase      :			Optional[Any]									=   AutoImageProcessor.from_pretrained(
										    "hf-internal-testing/test_dynamic_image_processor" ,  trust_remote_code=_A			)
										self.assertEqual(image_processor.__class__.__name__ ,  "NewImageProcessor"			)
										self.assertTrue(image_processor.is_local			)

										# If remote is enabled, we load from the Hub
										__UpperCamelCase      :			Union[str, Any]									=   AutoImageProcessor.from_pretrained(
										    "hf-internal-testing/test_dynamic_image_processor" ,  trust_remote_code=_A			)
										self.assertEqual(image_processor.__class__.__name__ ,  "NewImageProcessor"			)
										self.assertTrue(not hasattr(_A ,  "is_local"			)			)

							finally:
										if "custom" in CONFIG_MAPPING._extra_content:
													del CONFIG_MAPPING._extra_content["custom"]
										if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
													del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]










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





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__			,			UpperCamelCase__=1.0			,			UpperCamelCase__=None			,			UpperCamelCase__=None )  ->				Tuple:







			'''simple docstring'''

			if rng is None:
						UpperCAmelCase   		=				global_rng

			UpperCAmelCase   		=				[]
			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 	A_       (unittest.TestCase			):
	def __init__(    self							,					_A							,					_A=7							,					_A=4_0_0							,					_A=2_0_0_0							,					_A=1							,					_A=0.0							,					_A=1_6_0_0_0							,					_A=True							,					_A=8_0							,					_A=1_6							,					_A=6_4							,					_A="hann_window"							,					_A=8_0							,					_A=7_6_0_0							,					_A=1E-10							,					_A=True							,					):






				'''simple docstring'''







				UpperCAmelCase   		=				parent
				UpperCAmelCase   		=				batch_size
				UpperCAmelCase   		=				min_seq_length
				UpperCAmelCase   		=				max_seq_length
				UpperCAmelCase   		=				(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
				UpperCAmelCase   		=				feature_size
				UpperCAmelCase   		=				padding_value
				UpperCAmelCase   		=				sampling_rate
				UpperCAmelCase   		=				do_normalize
				UpperCAmelCase   		=				num_mel_bins
				UpperCAmelCase   		=				hop_length
				UpperCAmelCase   		=				win_length
				UpperCAmelCase   		=				win_function
				UpperCAmelCase   		=				fmin
				UpperCAmelCase   		=				fmax
				UpperCAmelCase   		=				mel_floor
				UpperCAmelCase   		=				return_attention_mask
	def      _lowercase				(    self		):






				'''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      _lowercase				(    self							,					_A=False							,					_A=False		):






				'''simple docstring'''







				def _flatten(_A		):
							return list(itertools.chain(*_A		)		)

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

				return speech_inputs







	def      _lowercase				(    self							,					_A=False							,					_A=False		):






				'''simple docstring'''







				if equal_length:
							UpperCAmelCase   		=				[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   		=				[
							    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   		=				[np.asarray(_A		) for x in speech_inputs]

				return speech_inputs

@require_torch
class 	A_       (a_     ,							unittest.TestCase			):
	UpperCAmelCase__					=			SpeechTaFeatureExtractor
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				SpeechTaFeatureExtractionTester(self		)
	def      _lowercase				(    self							,					_A		):






				'''simple docstring'''







				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      _lowercase				(    self		):






				'''simple docstring'''







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

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

				# Test batched
				UpperCAmelCase   		=				feat_extract(_A							,					return_tensors='''np'''		).input_values
				UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







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

				UpperCAmelCase   		=				['''longest''', '''max_length''', '''do_not_pad''']
				UpperCAmelCase   		=				[None, 1_6_0_0, None]
				for max_length, padding in zip(_A							,					_A		):
							UpperCAmelCase   		=				feat_extract(_A							,					padding=_A							,					max_length=_A							,					return_tensors='''np'''		)
							UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







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

				UpperCAmelCase   		=				['''longest''', '''max_length''', '''do_not_pad''']
				UpperCAmelCase   		=				[None, 1_6_0_0, None]

				for max_length, padding in zip(_A							,					_A		):
							UpperCAmelCase   		=				feat_extract(_A							,					max_length=_A							,					padding=_A		)
							UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in range(8_0_0							,					1_4_0_0							,					2_0_0		)]
				UpperCAmelCase   		=				feat_extract(
				    _A							,					truncation=_A							,					max_length=1_0_0_0							,					padding='''max_length'''							,					return_tensors='''np'''		)
				UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in range(8_0_0							,					1_4_0_0							,					2_0_0		)]
				UpperCAmelCase   		=				feat_extract(
				    _A							,					truncation=_A							,					max_length=1_0_0_0							,					padding='''longest'''							,					return_tensors='''np'''		)
				UpperCAmelCase   		=				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   		=				[floats_list((1, x)		)[0] for x in range(8_0_0							,					1_4_0_0							,					2_0_0		)]
				UpperCAmelCase   		=				feat_extract(
				    _A							,					truncation=_A							,					max_length=2_0_0_0							,					padding='''longest'''							,					return_tensors='''np'''		)
				UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				np.random.rand(1_0_0		).astype(np.floataa		)
				UpperCAmelCase   		=				np_speech_inputs.tolist()

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






				'''simple docstring'''







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

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

				# Test batched
				UpperCAmelCase   		=				feature_extractor(_A							,					return_tensors='''np'''		).input_values
				UpperCAmelCase   		=				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   		=				[floats_list((1, x)		)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
				UpperCAmelCase   		=				np.asarray(_A		)
				UpperCAmelCase   		=				feature_extractor(_A							,					return_tensors='''np'''		).input_values
				UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feat_extract_tester.prepare_inputs_for_target()
				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_dict		)
				UpperCAmelCase   		=				feat_extract.model_input_names[0]

				UpperCAmelCase   		=				BatchFeature({input_name: speech_inputs}		)

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

				UpperCAmelCase   		=				self.feat_extract_tester.prepare_inputs_for_target(equal_length=_A		)
				UpperCAmelCase   		=				BatchFeature({input_name: speech_inputs}							,					tensor_type='''np'''		)

				UpperCAmelCase   		=				processed_features[input_name]

				if len(batch_features_input.shape		) < 3:
							UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feat_extract_tester.prepare_inputs_for_target(equal_length=_A		)
				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_dict		)
				UpperCAmelCase   		=				feat_extract.model_input_names[0]

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

				UpperCAmelCase   		=				processed_features[input_name]

				if len(batch_features_input.shape		) < 3:
							UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_dict		)
				UpperCAmelCase   		=				self.feat_extract_tester.prepare_inputs_for_target()
				UpperCAmelCase   		=				feat_extract.model_input_names[0]

				UpperCAmelCase   		=				BatchFeature({input_name: speech_inputs}		)

				UpperCAmelCase   		=				feat_extract.num_mel_bins  # hack!

				UpperCAmelCase   		=				feat_extract.pad(_A							,					padding='''longest'''							,					return_tensors='''np'''		)[input_name]
				UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feat_extract_dict
				UpperCAmelCase   		=				True
				UpperCAmelCase   		=				self.feature_extraction_class(**_A		)
				UpperCAmelCase   		=				self.feat_extract_tester.prepare_inputs_for_target()
				UpperCAmelCase   		=				[len(_A		) for x in speech_inputs]
				UpperCAmelCase   		=				feat_extract.model_input_names[0]

				UpperCAmelCase   		=				BatchFeature({input_name: speech_inputs}		)

				UpperCAmelCase   		=				feat_extract.num_mel_bins  # hack!

				UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feat_extract_dict
				UpperCAmelCase   		=				True
				UpperCAmelCase   		=				self.feature_extraction_class(**_A		)
				UpperCAmelCase   		=				self.feat_extract_tester.prepare_inputs_for_target()
				UpperCAmelCase   		=				[len(_A		) for x in speech_inputs]
				UpperCAmelCase   		=				feat_extract.model_input_names[0]

				UpperCAmelCase   		=				BatchFeature({input_name: speech_inputs}		)
				UpperCAmelCase   		=				min(_A		)

				UpperCAmelCase   		=				feat_extract.num_mel_bins  # hack!

				UpperCAmelCase   		=				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      _lowercase				(    self							,					_A		):






				'''simple docstring'''







				from datasets import load_dataset

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

				return [x["array"] for x in speech_samples]
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				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   		=				self._load_datasamples(1		)
				UpperCAmelCase   		=				SpeechTaFeatureExtractor()
				UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				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

				UpperCAmelCase   		=				self._load_datasamples(1		)
				UpperCAmelCase   		=				SpeechTaFeatureExtractor()
				UpperCAmelCase   		=				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		)		)



