





from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


__UpperCamelCase:  int   =   logging.get_logger(__name__)

__UpperCamelCase:  str   =   {
    """facebook/mbart-large-cc25""": """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json""",
    # See all MBART models at https://huggingface.co/models?filter=mbart
}


class 			__lowerCAmelCase				(					_UpperCamelCase			):


	'''simple docstring'''





	_A       	=							"mbart"
	_A       	=							["past_key_values"]
	_A       	=							{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}

	def __init__(	self:	Any,				lowerCamelCase_:	Any=50265,				lowerCamelCase_:	Optional[int]=1024,				lowerCamelCase_:	List[Any]=12,				lowerCamelCase_:	Union[str, Any]=4096,				lowerCamelCase_:	Any=16,				lowerCamelCase_:	Optional[Any]=12,				lowerCamelCase_:	Any=4096,				lowerCamelCase_:	Optional[int]=16,				lowerCamelCase_:	Tuple=0.0,				lowerCamelCase_:	Optional[Any]=0.0,				lowerCamelCase_:	str=True,				lowerCamelCase_:	int=True,				lowerCamelCase_:	Optional[Any]="gelu",				lowerCamelCase_:	str=1024,				lowerCamelCase_:	List[Any]=0.1,				lowerCamelCase_:	Union[str, Any]=0.0,				lowerCamelCase_:	Union[str, Any]=0.0,				lowerCamelCase_:	Union[str, Any]=0.0_2,				lowerCamelCase_:	List[Any]=0.0,				lowerCamelCase_:	Tuple=False,				lowerCamelCase_:	List[str]=1,				lowerCamelCase_:	str=0,				lowerCamelCase_:	Any=2,				lowerCamelCase_:	Optional[Any]=2,				**lowerCamelCase_:	List[str],				):
			lowercase__				:			List[str]            =		vocab_size
			lowercase__				:			Optional[Any]            =		max_position_embeddings
			lowercase__				:			List[Any]            =		d_model
			lowercase__				:			Dict            =		encoder_ffn_dim
			lowercase__				:			Any            =		encoder_layers
			lowercase__				:			List[str]            =		encoder_attention_heads
			lowercase__				:			Any            =		decoder_ffn_dim
			lowercase__				:			List[str]            =		decoder_layers
			lowercase__				:			Any            =		decoder_attention_heads
			lowercase__				:			Union[str, Any]            =		dropout
			lowercase__				:			Dict            =		attention_dropout
			lowercase__				:			Union[str, Any]            =		activation_dropout
			lowercase__				:			Union[str, Any]            =		activation_function
			lowercase__				:			str            =		init_std
			lowercase__				:			List[Any]            =		encoder_layerdrop
			lowercase__				:			Union[str, Any]            =		decoder_layerdrop
			lowercase__				:			Any            =		classifier_dropout
			lowercase__				:			Union[str, Any]            =		use_cache
			lowercase__				:			Dict            =		encoder_layers
			lowercase__				:			int            =		scale_embedding  # scale factor will be sqrt(d_model) if True
			super().__init__(
			    pad_token_id=lowerCamelCase_,				bos_token_id=lowerCamelCase_,				eos_token_id=lowerCamelCase_,				is_encoder_decoder=lowerCamelCase_,				forced_eos_token_id=lowerCamelCase_,				**lowerCamelCase_,				)


class 			__lowerCAmelCase				(					_UpperCamelCase			):


	'''simple docstring'''





	@property
	def       snake_case__(	self:	str ):
			if self.task in ["default", "seq2seq-lm"]:
					lowercase__				:			int            =		OrderedDict(
					    [
					        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
					        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
					    ] )

					if self.use_past:
							lowercase__				:			str            =		{0: 'batch'}
							lowercase__				:			int            =		{0: 'batch', 1: 'past_decoder_sequence + sequence'}
					else:
							lowercase__				:			int            =		{0: 'batch', 1: 'decoder_sequence'}
							lowercase__				:			Any            =		{0: 'batch', 1: 'decoder_sequence'}

					if self.use_past:
							self.fill_with_past_key_values_(lowerCamelCase_,				direction='inputs' )
			elif self.task == "causal-lm":
					# TODO: figure this case out.
					lowercase__				:			Any            =		OrderedDict(
					    [
					        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
					        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
					    ] )
					if self.use_past:
							lowercase__      ,							lowercase__				:			Optional[int]            =		self.num_layers
							for i in range(lowerCamelCase_ ):
									lowercase__				:			Any            =		{0: 'batch', 2: 'past_sequence + sequence'}
									lowercase__				:			Any            =		{0: 'batch', 2: 'past_sequence + sequence'}
			else:
					lowercase__				:			Union[str, Any]            =		OrderedDict(
					    [
					        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
					        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
					        ('decoder_input_ids', {0: 'batch', 1: 'decoder_sequence'}),
					        ('decoder_attention_mask', {0: 'batch', 1: 'decoder_sequence'}),
					    ] )

			return common_inputs

	@property
	def       snake_case__(	self:	Tuple ):
			if self.task in ["default", "seq2seq-lm"]:
					lowercase__				:			List[Any]            =		super().outputs
			else:
					lowercase__				:			Union[str, Any]            =		super(lowerCamelCase_,				self ).outputs
					if self.use_past:
							lowercase__      ,							lowercase__				:			Any            =		self.num_layers
							for i in range(lowerCamelCase_ ):
									lowercase__				:			Optional[int]            =		{0: 'batch', 2: 'past_sequence + sequence'}
									lowercase__				:			int            =		{0: 'batch', 2: 'past_sequence + sequence'}
			return common_outputs

	def       snake_case__(	self:	Optional[Any],				lowerCamelCase_:	PreTrainedTokenizer,				lowerCamelCase_:	int = -1,				lowerCamelCase_:	int = -1,				lowerCamelCase_:	bool = False,				lowerCamelCase_:	Optional[TensorType] = None,				):
			lowercase__				:			int            =		self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
			    lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_ )

			# Generate decoder inputs
			lowercase__				:			Optional[Any]            =		seq_length if not self.use_past else 1
			lowercase__				:			List[str]            =		self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
			    lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_ )
			lowercase__				:			List[Any]            =		{F"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
			lowercase__				:			int            =		dict(**lowerCamelCase_,				**lowerCamelCase_ )

			if self.use_past:
					if not is_torch_available():
							raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.' )
					else:
							import torch
					lowercase__      ,							lowercase__				:			int            =		common_inputs['input_ids'].shape
					lowercase__				:			int            =		common_inputs['decoder_input_ids'].shape[1]
					lowercase__      ,							lowercase__				:			str            =		self.num_attention_heads
					lowercase__				:			List[str]            =		(
					    batch,
					    num_encoder_attention_heads,
					    encoder_seq_length,
					    self._config.hidden_size // num_encoder_attention_heads,
					)
					lowercase__				:			Union[str, Any]            =		decoder_seq_length + 3
					lowercase__				:			Optional[Any]            =		(
					    batch,
					    num_decoder_attention_heads,
					    decoder_past_length,
					    self._config.hidden_size // num_decoder_attention_heads,
					)

					lowercase__				:			List[str]            =		torch.cat(
					    [common_inputs['decoder_attention_mask'], torch.ones(lowerCamelCase_,				lowerCamelCase_ )],				dim=1 )

					lowercase__				:			Union[str, Any]            =		[]
					# If the number of encoder and decoder layers are present in the model configuration, both are considered
					lowercase__      ,							lowercase__				:			Optional[Any]            =		self.num_layers
					lowercase__				:			int            =		min(lowerCamelCase_,				lowerCamelCase_ )
					lowercase__				:			Any            =		max(lowerCamelCase_,				lowerCamelCase_ ) - min_num_layers
					lowercase__				:			Tuple            =		'encoder' if num_encoder_layers > num_decoder_layers else 'decoder'

					for _ in range(lowerCamelCase_ ):
							common_inputs["past_key_values"].append(
							    (
							        torch.zeros(lowerCamelCase_ ),
							        torch.zeros(lowerCamelCase_ ),
							        torch.zeros(lowerCamelCase_ ),
							        torch.zeros(lowerCamelCase_ ),
							    ) )
					# TODO: test this.
					lowercase__				:			Union[str, Any]            =		encoder_shape if remaining_side_name == 'encoder' else decoder_shape
					for _ in range(lowerCamelCase_,				lowerCamelCase_ ):
							common_inputs["past_key_values"].append((torch.zeros(lowerCamelCase_ ), torch.zeros(lowerCamelCase_ )) )
			return common_inputs

	def       snake_case__(	self:	Optional[int],				lowerCamelCase_:	PreTrainedTokenizer,				lowerCamelCase_:	int = -1,				lowerCamelCase_:	int = -1,				lowerCamelCase_:	bool = False,				lowerCamelCase_:	Optional[TensorType] = None,				):
			lowercase__				:			Dict            =		self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
			    lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_ )

			if self.use_past:
					if not is_torch_available():
							raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.' )
					else:
							import torch
					lowercase__      ,							lowercase__				:			Dict            =		common_inputs['input_ids'].shape
					# Not using the same length for past_key_values
					lowercase__				:			str            =		seqlen + 2
					lowercase__      ,							lowercase__				:			Tuple            =		self.num_layers
					lowercase__      ,							lowercase__				:			str            =		self.num_attention_heads
					lowercase__				:			List[Any]            =		(
					    batch,
					    num_encoder_attention_heads,
					    past_key_values_length,
					    self._config.hidden_size // num_encoder_attention_heads,
					)

					lowercase__				:			Optional[Any]            =		common_inputs['attention_mask'].dtype
					lowercase__				:			Dict            =		torch.cat(
					    [common_inputs['attention_mask'], torch.ones(lowerCamelCase_,				lowerCamelCase_,				dtype=lowerCamelCase_ )],				dim=1 )
					lowercase__				:			Optional[int]            =		[
					    (torch.zeros(lowerCamelCase_ ), torch.zeros(lowerCamelCase_ )) for _ in range(lowerCamelCase_ )
					]
			return common_inputs

	def       snake_case__(	self:	Tuple,				lowerCamelCase_:	PreTrainedTokenizer,				lowerCamelCase_:	int = -1,				lowerCamelCase_:	int = -1,				lowerCamelCase_:	bool = False,				lowerCamelCase_:	Optional[TensorType] = None,				):
			# Copied from OnnxConfig.generate_dummy_inputs
			# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
			# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
			lowercase__				:			List[str]            =		compute_effective_axis_dimension(
			    lowerCamelCase_,				fixed_dimension=OnnxConfig.default_fixed_batch,				num_token_to_add=0 )

			# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
			lowercase__				:			List[str]            =		tokenizer.num_special_tokens_to_add(lowerCamelCase_ )
			lowercase__				:			int            =		compute_effective_axis_dimension(
			    lowerCamelCase_,				fixed_dimension=OnnxConfig.default_fixed_sequence,				num_token_to_add=lowerCamelCase_ )

			# Generate dummy inputs according to compute batch and sequence
			lowercase__				:			str            =		[' '.join([tokenizer.unk_token] ) * seq_length] * batch_size
			lowercase__				:			List[str]            =		dict(tokenizer(lowerCamelCase_,				return_tensors=lowerCamelCase_ ) )
			return common_inputs

	def       snake_case__(	self:	Union[str, Any],				lowerCamelCase_:	PreTrainedTokenizer,				lowerCamelCase_:	int = -1,				lowerCamelCase_:	int = -1,				lowerCamelCase_:	bool = False,				lowerCamelCase_:	Optional[TensorType] = None,				):
			if self.task in ["default", "seq2seq-lm"]:
					lowercase__				:			str            =		self._generate_dummy_inputs_for_default_and_seqaseq_lm(
					    lowerCamelCase_,				batch_size=lowerCamelCase_,				seq_length=lowerCamelCase_,				is_pair=lowerCamelCase_,				framework=lowerCamelCase_ )

			elif self.task == "causal-lm":
					lowercase__				:			Tuple            =		self._generate_dummy_inputs_for_causal_lm(
					    lowerCamelCase_,				batch_size=lowerCamelCase_,				seq_length=lowerCamelCase_,				is_pair=lowerCamelCase_,				framework=lowerCamelCase_ )
			else:
					lowercase__				:			Optional[int]            =		self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    lowerCamelCase_,				batch_size=lowerCamelCase_,				seq_length=lowerCamelCase_,				is_pair=lowerCamelCase_,				framework=lowerCamelCase_ )

			return common_inputs





	def       snake_case__(	self:	Union[str, Any],				lowerCamelCase_:	List[Any],				lowerCamelCase_:	List[str],				lowerCamelCase_:	List[str],				lowerCamelCase_:	List[str] ):
			if self.task in ["default", "seq2seq-lm"]:
					lowercase__				:			Any            =		super()._flatten_past_key_values_(lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_ )
			else:
					lowercase__				:			str            =		super(lowerCamelCase_,				self )._flatten_past_key_values_(
					    lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_,				lowerCamelCase_ )









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


