





import tempfile
import unittest

from transformers import DPRConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import DPRContextEncoder, DPRQuestionEncoder, DPRReader, DPRReaderTokenizer
			from transformers.models.dpr.modeling_dpr import (
			    DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
			    DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
			    DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
			)


class 			__lowerCAmelCase				:


	'''simple docstring'''





	def __init__(	self:	Union[str, Any],				lowerCamelCase_:	Optional[Any],				lowerCamelCase_:	Dict=13,				lowerCamelCase_:	Any=7,				lowerCamelCase_:	Tuple=False,				lowerCamelCase_:	Optional[Any]=True,				lowerCamelCase_:	List[Any]=True,				lowerCamelCase_:	Any=True,				lowerCamelCase_:	List[Any]=99,				lowerCamelCase_:	Optional[Any]=32,				lowerCamelCase_:	Tuple=5,				lowerCamelCase_:	Optional[int]=4,				lowerCamelCase_:	List[Any]=37,				lowerCamelCase_:	Optional[int]="gelu",				lowerCamelCase_:	Any=0.1,				lowerCamelCase_:	List[str]=0.1,				lowerCamelCase_:	Dict=512,				lowerCamelCase_:	List[str]=16,				lowerCamelCase_:	Dict=2,				lowerCamelCase_:	List[str]=0.0_2,				lowerCamelCase_:	Dict=3,				lowerCamelCase_:	int=4,				lowerCamelCase_:	Union[str, Any]=None,				lowerCamelCase_:	Any=0,				):
			lowercase__				:			Optional[int]            =		parent
			lowercase__				:			List[str]            =		batch_size
			lowercase__				:			List[str]            =		seq_length
			lowercase__				:			Union[str, Any]            =		is_training
			lowercase__				:			Optional[int]            =		use_input_mask
			lowercase__				:			Dict            =		use_token_type_ids
			lowercase__				:			str            =		use_labels
			lowercase__				:			Any            =		vocab_size
			lowercase__				:			Optional[Any]            =		hidden_size
			lowercase__				:			Union[str, Any]            =		num_hidden_layers
			lowercase__				:			Dict            =		num_attention_heads
			lowercase__				:			Optional[int]            =		intermediate_size
			lowercase__				:			List[str]            =		hidden_act
			lowercase__				:			Optional[Any]            =		hidden_dropout_prob
			lowercase__				:			Union[str, Any]            =		attention_probs_dropout_prob
			lowercase__				:			int            =		max_position_embeddings
			lowercase__				:			str            =		type_vocab_size
			lowercase__				:			str            =		type_sequence_label_size
			lowercase__				:			Tuple            =		initializer_range
			lowercase__				:			str            =		num_labels
			lowercase__				:			Any            =		num_choices
			lowercase__				:			Optional[int]            =		scope
			lowercase__				:			Optional[Any]            =		projection_dim

	def       snake_case__(	self:	str ):
			lowercase__				:			Tuple            =		ids_tensor([self.batch_size, self.seq_length],				self.vocab_size )

			lowercase__				:			Tuple            =		None
			if self.use_input_mask:
					lowercase__				:			List[str]            =		random_attention_mask([self.batch_size, self.seq_length] )

			lowercase__				:			Optional[Any]            =		None
			if self.use_token_type_ids:
					lowercase__				:			List[Any]            =		ids_tensor([self.batch_size, self.seq_length],				self.type_vocab_size )

			lowercase__				:			Any            =		None
			lowercase__				:			Union[str, Any]            =		None
			lowercase__				:			Any            =		None
			if self.use_labels:
					lowercase__				:			Optional[int]            =		ids_tensor([self.batch_size],				self.type_sequence_label_size )
					lowercase__				:			Optional[Any]            =		ids_tensor([self.batch_size, self.seq_length],				self.num_labels )
					lowercase__				:			Tuple            =		ids_tensor([self.batch_size],				self.num_choices )

			lowercase__				:			Optional[Any]            =		self.get_config()

			return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

	def       snake_case__(	self:	List[Any] ):
			return DPRConfig(
			    projection_dim=self.projection_dim,				vocab_size=self.vocab_size,				hidden_size=self.hidden_size,				num_hidden_layers=self.num_hidden_layers,				num_attention_heads=self.num_attention_heads,				intermediate_size=self.intermediate_size,				hidden_act=self.hidden_act,				hidden_dropout_prob=self.hidden_dropout_prob,				attention_probs_dropout_prob=self.attention_probs_dropout_prob,				max_position_embeddings=self.max_position_embeddings,				type_vocab_size=self.type_vocab_size,				initializer_range=self.initializer_range,				)

	def       snake_case__(	self:	Optional[Any],				lowerCamelCase_:	Tuple,				lowerCamelCase_:	Optional[Any],				lowerCamelCase_:	Optional[int],				lowerCamelCase_:	Tuple,				lowerCamelCase_:	Any,				lowerCamelCase_:	Optional[int],				lowerCamelCase_:	List[str] ):
			lowercase__				:			List[str]            =		DPRContextEncoder(config=lowerCamelCase_ )
			model.to(lowerCamelCase_ )
			model.eval()
			lowercase__				:			str            =		model(lowerCamelCase_,				attention_mask=lowerCamelCase_,				token_type_ids=lowerCamelCase_ )
			lowercase__				:			Optional[Any]            =		model(lowerCamelCase_,				token_type_ids=lowerCamelCase_ )
			lowercase__				:			Optional[int]            =		model(lowerCamelCase_ )
			self.parent.assertEqual(result.pooler_output.shape,				(self.batch_size, self.projection_dim or self.hidden_size) )

	def       snake_case__(	self:	Dict,				lowerCamelCase_:	Optional[int],				lowerCamelCase_:	Optional[Any],				lowerCamelCase_:	Optional[int],				lowerCamelCase_:	List[Any],				lowerCamelCase_:	str,				lowerCamelCase_:	Optional[Any],				lowerCamelCase_:	Union[str, Any] ):
			lowercase__				:			Tuple            =		DPRQuestionEncoder(config=lowerCamelCase_ )
			model.to(lowerCamelCase_ )
			model.eval()
			lowercase__				:			List[Any]            =		model(lowerCamelCase_,				attention_mask=lowerCamelCase_,				token_type_ids=lowerCamelCase_ )
			lowercase__				:			Union[str, Any]            =		model(lowerCamelCase_,				token_type_ids=lowerCamelCase_ )
			lowercase__				:			Tuple            =		model(lowerCamelCase_ )
			self.parent.assertEqual(result.pooler_output.shape,				(self.batch_size, self.projection_dim or self.hidden_size) )

	def       snake_case__(	self:	Union[str, Any],				lowerCamelCase_:	Union[str, Any],				lowerCamelCase_:	Tuple,				lowerCamelCase_:	Optional[int],				lowerCamelCase_:	List[Any],				lowerCamelCase_:	Union[str, Any],				lowerCamelCase_:	str,				lowerCamelCase_:	int ):
			lowercase__				:			int            =		DPRReader(config=lowerCamelCase_ )
			model.to(lowerCamelCase_ )
			model.eval()
			lowercase__				:			Dict            =		model(
			    lowerCamelCase_,				attention_mask=lowerCamelCase_,				)

			self.parent.assertEqual(result.start_logits.shape,				(self.batch_size, self.seq_length) )
			self.parent.assertEqual(result.end_logits.shape,				(self.batch_size, self.seq_length) )
			self.parent.assertEqual(result.relevance_logits.shape,				(self.batch_size,) )





	def       snake_case__(	self:	Union[str, Any] ):
			lowercase__				:			Any            =		self.prepare_config_and_inputs()
			(
			    lowercase__							
			)				:			Optional[int]            =		config_and_inputs
			lowercase__				:			int            =		{'input_ids': input_ids}
			return config, inputs_dict


@require_torch
class 			__lowerCAmelCase				(					_UpperCamelCase      ,						_UpperCamelCase      ,						unittest.TestCase			):


	'''simple docstring'''





	_A       	=							(
	    (
	        DPRContextEncoder,
	        DPRQuestionEncoder,
	        DPRReader,
	    )
	    if is_torch_available()
	    else ()
	)
	_A       	=							{"feature-extraction": DPRQuestionEncoder} if is_torch_available() else {}

	_A       	=							False
	_A       	=							False  # why?
	_A       	=							False
	_A       	=							False

	def       snake_case__(	self:	Optional[Any] ):
			lowercase__				:			Union[str, Any]            =		DPRModelTester(self )
			lowercase__				:			Tuple            =		ConfigTester(self,				config_class=lowerCamelCase_,				hidden_size=37 )

	def       snake_case__(	self:	Optional[Any] ):
			self.config_tester.run_common_tests()

	def       snake_case__(	self:	Tuple ):
			lowercase__				:			Dict            =		self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_context_encoder(*lowerCamelCase_ )

	def       snake_case__(	self:	List[str] ):
			lowercase__				:			List[str]            =		self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_question_encoder(*lowerCamelCase_ )

	def       snake_case__(	self:	int ):
			lowercase__				:			Union[str, Any]            =		self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_reader(*lowerCamelCase_ )

	def       snake_case__(	self:	Any ):
			lowercase__				:			str            =		self.model_tester.prepare_config_and_inputs()[0]

			lowercase__				:			int            =		DPRQuestionEncoder(config=lowerCamelCase_ )
			model.to(lowerCamelCase_ )
			model.eval()

			with tempfile.TemporaryDirectory() as tmp_dirname:
					model.save_pretrained(lowerCamelCase_ )
					lowercase__				:			Tuple            =		DPRQuestionEncoder.from_pretrained(lowerCamelCase_,				projection_dim=512 )

			self.assertIsNotNone(lowerCamelCase_ )





	@slow
	def       snake_case__(	self:	Optional[Any] ):
			for model_name in DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__				:			List[Any]            =		DPRContextEncoder.from_pretrained(lowerCamelCase_ )
					self.assertIsNotNone(lowerCamelCase_ )

			for model_name in DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__				:			int            =		DPRContextEncoder.from_pretrained(lowerCamelCase_ )
					self.assertIsNotNone(lowerCamelCase_ )

			for model_name in DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__				:			Tuple            =		DPRQuestionEncoder.from_pretrained(lowerCamelCase_ )
					self.assertIsNotNone(lowerCamelCase_ )

			for model_name in DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__				:			Optional[int]            =		DPRReader.from_pretrained(lowerCamelCase_ )
					self.assertIsNotNone(lowerCamelCase_ )


@require_torch
class 			__lowerCAmelCase				(					unittest.TestCase			):


	'''simple docstring'''





	@slow
	def       snake_case__(	self:	Tuple ):
			lowercase__				:			Optional[Any]            =		DPRQuestionEncoder.from_pretrained('facebook/dpr-question_encoder-single-nq-base',				return_dict=lowerCamelCase_ )
			model.to(lowerCamelCase_ )

			lowercase__				:			Tuple            =		torch.tensor(
			    [[101, 7592, 1010, 2003, 2026, 3899, 10140, 1029, 102]],				dtype=torch.long,				device=lowerCamelCase_ )  # [CLS] hello, is my dog cute? [SEP]
			lowercase__				:			List[Any]            =		model(lowerCamelCase_ )[0]  # embedding shape = (1, 768)
			# compare the actual values for a slice.
			lowercase__				:			str            =		torch.tensor(
			    [
			        [
			            0.0_3_2_3_6_2_5_3,
			            0.1_2_7_5_3_3_3_5,
			            0.1_6_8_1_8_5_0_9,
			            0.0_0_2_7_9_7_8_6,
			            0.3_8_9_6_9_3_3,
			            0.2_4_2_6_4_9_4_5,
			            0.2_1_7_8_9_7_1,
			            -0.0_2_3_3_5_2_2_7,
			            -0.0_8_4_8_1_9_5_9,
			            -0.1_4_3_2_4_1_1_7,
			        ]
			    ],				dtype=torch.float,				device=lowerCamelCase_,				)
			self.assertTrue(torch.allclose(output[:, :10],				lowerCamelCase_,				atol=1E-4 ) )





	@slow
	def       snake_case__(	self:	Dict ):
			lowercase__				:			Optional[int]            =		DPRReaderTokenizer.from_pretrained('facebook/dpr-reader-single-nq-base' )
			lowercase__				:			str            =		DPRReader.from_pretrained('facebook/dpr-reader-single-nq-base' )
			model.to(lowerCamelCase_ )

			lowercase__				:			List[str]            =		tokenizer(
			    questions='What is love ?',				titles='Haddaway',				texts='What Is Love is a song recorded by the artist Haddaway',				padding=lowerCamelCase_,				return_tensors='pt',				)
			encoded_inputs.to(lowerCamelCase_ )

			lowercase__				:			Tuple            =		model(**lowerCamelCase_ )

			# compare the actual values for a slice.
			lowercase__				:			Optional[int]            =		torch.tensor(
			    [[-10.3005, -10.7765, -11.4872, -11.6841, -11.9312, -10.3002, -9.8_5_4_4, -11.7378, -12.0821, -10.2975]],				dtype=torch.float,				device=lowerCamelCase_,				)

			lowercase__				:			Optional[Any]            =		torch.tensor(
			    [[-11.0684, -11.7041, -11.5397, -10.3465, -10.8791, -6.8_4_4_3, -11.9959, -11.0364, -10.0096, -6.8_4_0_5]],				dtype=torch.float,				device=lowerCamelCase_,				)
			self.assertTrue(torch.allclose(outputs.start_logits[:, :10],				lowerCamelCase_,				atol=1E-4 ) )
			self.assertTrue(torch.allclose(outputs.end_logits[:, :10],				lowerCamelCase_,				atol=1E-4 ) )









import itertools
import random
import unittest

import numpy as np

from transformers import EncodecFeatureExtractor
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


__UpperCamelCase:  int   =   random.Random()


def 			SCREAMING_SNAKE_CASE__     (					_lowercase    :   int      ,						_lowercase    :   List[Any]=1.0      ,						_lowercase    :   Dict=None      ,						_lowercase    :   List[str]=None )      ->       List[str]:




		'''simple docstring'''
		if rng is None:
				lowercase__				:			int            =		global_rng

		lowercase__				:			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 			__lowerCAmelCase				(					unittest.TestCase			):


	'''simple docstring'''





	def __init__(	self:	Union[str, Any],				lowerCamelCase_:	Union[str, Any],				lowerCamelCase_:	int=7,				lowerCamelCase_:	Tuple=400,				lowerCamelCase_:	Union[str, Any]=2000,				lowerCamelCase_:	Optional[int]=1,				lowerCamelCase_:	int=0.0,				lowerCamelCase_:	Any=24000,				lowerCamelCase_:	Dict=True,				):
			lowercase__				:			List[str]            =		parent
			lowercase__				:			Any            =		batch_size
			lowercase__				:			List[str]            =		min_seq_length
			lowercase__				:			Tuple            =		max_seq_length
			lowercase__				:			Optional[Any]            =		(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
			lowercase__				:			int            =		feature_size
			lowercase__				:			Optional[Any]            =		padding_value
			lowercase__				:			Optional[int]            =		sampling_rate
			lowercase__				:			str            =		return_attention_mask

	def       snake_case__(	self:	str ):
			return {
			    "feature_size": self.feature_size,
			    "padding_value": self.padding_value,
			    "sampling_rate": self.sampling_rate,
			    "return_attention_mask": self.return_attention_mask,
			}





	def       snake_case__(	self:	Dict,				lowerCamelCase_:	int=False,				lowerCamelCase_:	Optional[Any]=False ):
			def _flatten(lowerCamelCase_:	int ):
					return list(itertools.chain(*lowerCamelCase_ ) )

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

			return audio_inputs


@require_torch
class 			__lowerCAmelCase				(					_UpperCamelCase      ,						unittest.TestCase			):


	'''simple docstring'''





	_A       	=							EncodecFeatureExtractor

	def       snake_case__(	self:	List[Any] ):
			lowercase__				:			List[Any]            =		EnCodecFeatureExtractionTester(self )

	def       snake_case__(	self:	Optional[int] ):
			# Tests that all call wrap to encode_plus and batch_encode_plus
			lowercase__				:			List[str]            =		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
			# create three inputs of length 800, 1000, and 1200
			lowercase__				:			Dict            =		[floats_list((1, x) )[0] for x in range(800,				1400,				200 )]
			lowercase__				:			List[Any]            =		[np.asarray(lowerCamelCase_ ) for audio_input in audio_inputs]

			# Test not batched input
			lowercase__				:			List[str]            =		feat_extract(audio_inputs[0],				return_tensors='np' ).input_values
			lowercase__				:			List[str]            =		feat_extract(np_audio_inputs[0],				return_tensors='np' ).input_values
			self.assertTrue(np.allclose(lowerCamelCase_,				lowerCamelCase_,				atol=1E-3 ) )

			# Test batched
			lowercase__				:			Any            =		feat_extract(lowerCamelCase_,				padding=lowerCamelCase_,				return_tensors='np' ).input_values
			lowercase__				:			List[str]            =		feat_extract(lowerCamelCase_,				padding=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       snake_case__(	self:	List[Any] ):
			lowercase__				:			Union[str, Any]            =		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
			lowercase__				:			Optional[int]            =		np.random.rand(100 ).astype(np.floataa )
			lowercase__				:			Optional[int]            =		np_audio_inputs.tolist()

			for inputs in [py_audio_inputs, np_audio_inputs]:
					lowercase__				:			int            =		feature_extractor.pad([{'input_values': inputs}],				return_tensors='np' )
					self.assertTrue(np_processed.input_values.dtype == np.floataa )
					lowercase__				:			int            =		feature_extractor.pad([{'input_values': inputs}],				return_tensors='pt' )
					self.assertTrue(pt_processed.input_values.dtype == torch.floataa )

	def       snake_case__(	self:	Any,				lowerCamelCase_:	Any ):
			from datasets import load_dataset

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

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

	def       snake_case__(	self:	List[str] ):
			# fmt: off
			lowercase__				:			Optional[int]            =		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
			lowercase__				:			Tuple            =		self._load_datasamples(1 )
			lowercase__				:			List[Any]            =		EncodecFeatureExtractor()
			lowercase__				:			Optional[int]            =		feature_extractor(lowerCamelCase_,				return_tensors='pt' ).input_values
			self.assertEquals(input_values.shape,				(1, 1, 93680) )
			self.assertTrue(torch.allclose(input_values[0, 0, :30],				lowerCamelCase_,				atol=1E-6 ) )

	def       snake_case__(	self:	Dict ):
			# fmt: off
			lowercase__				:			Union[str, Any]            =		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
			lowercase__				:			Dict            =		self._load_datasamples(1 )
			lowercase__				:			Tuple            =		[np.tile(input_audio[0][None],				reps=(2, 1) )]
			input_audio[0][1] *= 0.5
			lowercase__				:			Tuple            =		EncodecFeatureExtractor(feature_size=2 )
			lowercase__				:			Dict            =		feature_extractor(lowerCamelCase_,				return_tensors='pt' ).input_values
			self.assertEquals(input_values.shape,				(1, 2, 93680) )
			self.assertTrue(torch.allclose(input_values[0, 0, :30],				lowerCamelCase_,				atol=1E-6 ) )
			self.assertTrue(torch.allclose(input_values[0, 1, :30],				EXPECTED_INPUT_VALUES * 0.5,				atol=1E-6 ) )





	def       snake_case__(	self:	List[str] ):
			lowercase__				:			List[Any]            =		self._load_datasamples(2 )
			# would be easier if the stride was like
			lowercase__				:			List[str]            =		EncodecFeatureExtractor(feature_size=1,				chunk_length_s=1,				overlap=0.0_1 )

			# pad and trunc raise an error ?
			with self.assertRaisesRegex(
			    lowerCamelCase_,				'^Both padding and truncation were set. Make sure you only set one.$',				):
					lowercase__				:			Tuple            =		feature_extractor(
					    lowerCamelCase_,				padding='max_length',				truncation=lowerCamelCase_,				return_tensors='pt' ).input_values

			# truncate to chunk
			lowercase__				:			List[str]            =		feature_extractor(lowerCamelCase_,				truncation=lowerCamelCase_,				return_tensors='pt' ).input_values
			self.assertEquals(truncated_outputs.shape,				(2, 1, 71520) )  # 2 chunks

			# force truncate to max_length
			lowercase__				:			int            =		feature_extractor(
			    lowerCamelCase_,				truncation=lowerCamelCase_,				max_length=48000,				return_tensors='pt' ).input_values
			self.assertEquals(truncated_outputs.shape,				(2, 1, 48000) )

			# pad to chunk
			lowercase__				:			str            =		feature_extractor(lowerCamelCase_,				padding=lowerCamelCase_,				return_tensors='pt' ).input_values
			self.assertEquals(padded_outputs.shape,				(2, 1, 95280) )

			# pad to chunk
			lowercase__				:			Tuple            =		feature_extractor(lowerCamelCase_,				return_tensors='pt' ).input_values
			self.assertEquals(truncated_outputs.shape,				(2, 1, 95280) )

			# force pad to max length
			lowercase__				:			Any            =		feature_extractor(
			    lowerCamelCase_,				padding='max_length',				max_length=100000,				return_tensors='pt' ).input_values
			self.assertEquals(truncated_outputs.shape,				(2, 1, 100000) )

			# force no pad
			with self.assertRaisesRegex(
			    lowerCamelCase_,				'^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$',				):
					lowercase__				:			List[str]            =		feature_extractor(lowerCamelCase_,				padding=lowerCamelCase_,				return_tensors='pt' ).input_values

			lowercase__				:			List[str]            =		feature_extractor(input_audio[0],				padding=lowerCamelCase_,				return_tensors='pt' ).input_values
			self.assertEquals(truncated_outputs.shape,				(1, 1, 93680) )

			# no pad if no chunk_length_s
			lowercase__				:			Dict            =		None
			with self.assertRaisesRegex(
			    lowerCamelCase_,				'^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$',				):
					lowercase__				:			List[Any]            =		feature_extractor(lowerCamelCase_,				padding=lowerCamelCase_,				return_tensors='pt' ).input_values

			lowercase__				:			Any            =		feature_extractor(input_audio[0],				padding=lowerCamelCase_,				return_tensors='pt' ).input_values
			self.assertEquals(truncated_outputs.shape,				(1, 1, 93680) )

			# no pad if no overlap
			lowercase__				:			str            =		2
			lowercase__				:			Tuple            =		None
			with self.assertRaisesRegex(
			    lowerCamelCase_,				'^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$',				):
					lowercase__				:			Optional[Any]            =		feature_extractor(lowerCamelCase_,				padding=lowerCamelCase_,				return_tensors='pt' ).input_values

			lowercase__				:			List[str]            =		feature_extractor(input_audio[0],				padding=lowerCamelCase_,				return_tensors='pt' ).input_values
			self.assertEquals(truncated_outputs.shape,				(1, 1, 93680) )


