




import os
from pathlib import Path

import numpy as np
import pytest
from pack_dataset import pack_data_dir
from parameterized import parameterized
from save_len_file import save_len_file
from torch.utils.data import DataLoader

from transformers import AutoTokenizer
from transformers.models.mbart.modeling_mbart import shift_tokens_right
from transformers.testing_utils import TestCasePlus, slow
from utils import FAIRSEQ_AVAILABLE, DistributedSortishSampler, LegacySeqaSeqDataset, SeqaSeqDataset


__A        =    "bert-base-cased"
__A        =    "google/pegasus-xsum"
__A        =    [" Sam ate lunch today.", "Sams lunch ingredients."]
__A        =    ["A very interesting story about what I ate for lunch.", "Avocado, celery, turkey, coffee"]
__A        =    "patrickvonplaten/t5-tiny-random"
__A        =    "sshleifer/bart-tiny-random"
__A        =    "sshleifer/tiny-mbart"
__A        =    "sshleifer/tiny-marian-en-de"







def 			lowerCamelCase_		(       UpperCamelCase__				:      Path ,     UpperCamelCase__				:      list      )     ->       List[str]:





				"""simple docstring"""


				__lowerCamelCase		       =    '\n'.join(UpperCamelCase__      )
				Path(UpperCamelCase__      ).open('w'      ).writelines(UpperCamelCase__      )







def 			lowerCamelCase_		(       UpperCamelCase__				:      str      )     ->       Optional[int]:





				"""simple docstring"""


				for split in ["train", "val", "test"]:
								_dump_articles(os.path.join(UpperCamelCase__ ,     F"""{split}.source"""      ) ,     UpperCamelCase__      )
								_dump_articles(os.path.join(UpperCamelCase__ ,     F"""{split}.target"""      ) ,     UpperCamelCase__      )
				return tmp_dir







class     __lowerCAmelCase (       __magic_name__ ):

			"""simple docstring"""







			@parameterized.expand(
			    [
			        MBART_TINY,
			        MARIAN_TINY,
			        T5_TINY,
			        BART_TINY,
			        PEGASUS_XSUM,
			    ]			,						)
			@slow
			def       lowercase_    (      self			,						lowerCamelCase__							)    ->      Any:



							'''simple docstring'''
							__lowerCamelCase		       =    AutoTokenizer.from_pretrained(lowerCamelCase__							)
							__lowerCamelCase		       =    make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()							)
							__lowerCamelCase		       =    max(len(tokenizer.encode(lowerCamelCase__							)							) for a in ARTICLES							)
							__lowerCamelCase		       =    max(len(tokenizer.encode(lowerCamelCase__							)							) for a in SUMMARIES							)
							__lowerCamelCase		       =    4
							__lowerCamelCase		       =    8
							assert max_len_target > max_src_len  # Will be truncated
							assert max_len_source > max_src_len  # Will be truncated
							__lowerCamelCase       ,						__lowerCamelCase		       =    'ro_RO', 'de_DE'  # ignored for all but mbart, but never causes error.
							__lowerCamelCase		       =    SeqaSeqDataset(
							    lowerCamelCase__			,						data_dir=lowerCamelCase__			,						type_path='train'			,						max_source_length=lowerCamelCase__			,						max_target_length=lowerCamelCase__			,						src_lang=lowerCamelCase__			,						tgt_lang=lowerCamelCase__			,						)
							__lowerCamelCase		       =    DataLoader(lowerCamelCase__			,						batch_size=2			,						collate_fn=train_dataset.collate_fn							)
							for batch in dataloader:
											assert isinstance(lowerCamelCase__			,						lowerCamelCase__							)
											assert batch["attention_mask"].shape == batch["input_ids"].shape
											# show that articles were trimmed.
											assert batch["input_ids"].shape[1] == max_src_len
											# show that targets are the same len
											assert batch["labels"].shape[1] == max_tgt_len
											if tok_name != MBART_TINY:
															continue
											# check language codes in correct place
											__lowerCamelCase		       =    shift_tokens_right(batch['labels']			,						tokenizer.pad_token_id							)
											assert batch["decoder_input_ids"][0, 0].item() == tokenizer.lang_code_to_id[tgt_lang]
											assert batch["decoder_input_ids"][0, -1].item() == tokenizer.eos_token_id
											assert batch["input_ids"][0, -2].item() == tokenizer.eos_token_id
											assert batch["input_ids"][0, -1].item() == tokenizer.lang_code_to_id[src_lang]

											break  # No need to test every batch


			@parameterized.expand([BART_TINY, BERT_BASE_CASED]							)
			def       lowercase_    (      self			,						lowerCamelCase__							)    ->      Tuple:



							'''simple docstring'''
							__lowerCamelCase		       =    AutoTokenizer.from_pretrained(lowerCamelCase__							)
							__lowerCamelCase		       =    make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()							)
							__lowerCamelCase		       =    max(len(tokenizer.encode(lowerCamelCase__							)							) for a in ARTICLES							)
							__lowerCamelCase		       =    max(len(tokenizer.encode(lowerCamelCase__							)							) for a in SUMMARIES							)
							__lowerCamelCase		       =    4
							__lowerCamelCase		       =    LegacySeqaSeqDataset(
							    lowerCamelCase__			,						data_dir=lowerCamelCase__			,						type_path='train'			,						max_source_length=20			,						max_target_length=lowerCamelCase__			,						)
							__lowerCamelCase		       =    DataLoader(lowerCamelCase__			,						batch_size=2			,						collate_fn=train_dataset.collate_fn							)
							for batch in dataloader:
											assert batch["attention_mask"].shape == batch["input_ids"].shape
											# show that articles were trimmed.
											assert batch["input_ids"].shape[1] == max_len_source
											assert 20 >= batch["input_ids"].shape[1]  # trimmed significantly
											# show that targets were truncated
											assert batch["labels"].shape[1] == trunc_target  # Truncated
											assert max_len_target > trunc_target  # Truncated
											break  # No need to test every batch


			def       lowercase_    (      self							)    ->      Optional[int]:



							'''simple docstring'''
							__lowerCamelCase		       =    AutoTokenizer.from_pretrained('facebook/mbart-large-cc25'							)

							__lowerCamelCase		       =    Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()							)							)
							__lowerCamelCase		       =    tmp_dir.joinpath('train.source'							).open().readlines()
							__lowerCamelCase		       =    Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()							)							)
							pack_data_dir(lowerCamelCase__			,						lowerCamelCase__			,						128			,						lowerCamelCase__							)
							__lowerCamelCase		       =    {x.name for x in tmp_dir.iterdir()}
							__lowerCamelCase		       =    {x.name for x in save_dir.iterdir()}
							__lowerCamelCase		       =    save_dir.joinpath('train.source'							).open().readlines()
							# orig: [' Sam ate lunch today.\n', 'Sams lunch ingredients.']
							# desired_packed: [' Sam ate lunch today.\n Sams lunch ingredients.']
							assert len(lowerCamelCase__							) < len(lowerCamelCase__							)
							assert len(lowerCamelCase__							) == 1
							assert len(packed_examples[0]							) == sum(len(lowerCamelCase__							) for x in orig_examples							)
							assert orig_paths == new_paths


			@pytest.mark.skipif(not FAIRSEQ_AVAILABLE			,						reason='This test requires fairseq'							)
			def       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							if not FAIRSEQ_AVAILABLE:
											return
							__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase		       =    self._get_dataset(max_len=64							)
							__lowerCamelCase		       =    64
							__lowerCamelCase		       =    ds.make_dynamic_sampler(lowerCamelCase__			,						required_batch_size_multiple=lowerCamelCase__							)
							__lowerCamelCase		       =    [len(lowerCamelCase__							) for x in batch_sampler]
							assert len(set(lowerCamelCase__							)							) > 1  # it's not dynamic batch size if every batch is the same length
							assert sum(lowerCamelCase__							) == len(lowerCamelCase__							)  # no dropped or added examples
							__lowerCamelCase		       =    DataLoader(lowerCamelCase__			,						batch_sampler=lowerCamelCase__			,						collate_fn=ds.collate_fn			,						num_workers=2							)
							__lowerCamelCase		       =    []
							__lowerCamelCase		       =    []
							for batch in data_loader:
											__lowerCamelCase		       =    batch['input_ids'].shape
											__lowerCamelCase		       =    src_shape[0]
											assert bs % required_batch_size_multiple == 0 or bs < required_batch_size_multiple
											__lowerCamelCase		       =    np.product(batch['input_ids'].shape							)
											num_src_per_batch.append(lowerCamelCase__							)
											if num_src_tokens > (max_tokens * 1.1):
															failures.append(lowerCamelCase__							)
							assert num_src_per_batch[0] == max(lowerCamelCase__							)
							if failures:
											raise AssertionError(f"""too many tokens in {len(lowerCamelCase__							)} batches"""							)


			def       lowercase_    (      self							)    ->      Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase		       =    self._get_dataset(max_len=512							)
							__lowerCamelCase		       =    2
							__lowerCamelCase		       =    ds.make_sortish_sampler(lowerCamelCase__			,						shuffle=lowerCamelCase__							)

							__lowerCamelCase		       =    DataLoader(lowerCamelCase__			,						batch_size=lowerCamelCase__			,						collate_fn=ds.collate_fn			,						num_workers=2							)
							__lowerCamelCase		       =    DataLoader(lowerCamelCase__			,						batch_size=lowerCamelCase__			,						collate_fn=ds.collate_fn			,						num_workers=2			,						sampler=lowerCamelCase__							)

							__lowerCamelCase		       =    tokenizer.pad_token_id

							def count_pad_tokens(lowerCamelCase__			,						lowerCamelCase__="input_ids"							):
											return [batch[k].eq(lowerCamelCase__							).sum().item() for batch in data_loader]

							assert sum(count_pad_tokens(lowerCamelCase__			,						k='labels'							)							) < sum(count_pad_tokens(lowerCamelCase__			,						k='labels'							)							)
							assert sum(count_pad_tokens(lowerCamelCase__							)							) < sum(count_pad_tokens(lowerCamelCase__							)							)
							assert len(lowerCamelCase__							) == len(lowerCamelCase__							)


			def       lowercase_    (      self			,						lowerCamelCase__=1_000			,						lowerCamelCase__=128							)    ->      Dict:



							'''simple docstring'''
							if os.getenv('USE_REAL_DATA'			,						lowerCamelCase__							):
											__lowerCamelCase		       =    'examples/seq2seq/wmt_en_ro'
											__lowerCamelCase		       =    max_len * 2 * 64
											if not Path(lowerCamelCase__							).joinpath('train.len'							).exists():
															save_len_file(lowerCamelCase__			,						lowerCamelCase__							)
							else:
											__lowerCamelCase		       =    'examples/seq2seq/test_data/wmt_en_ro'
											__lowerCamelCase		       =    max_len * 4
											save_len_file(lowerCamelCase__			,						lowerCamelCase__							)

							__lowerCamelCase		       =    AutoTokenizer.from_pretrained(lowerCamelCase__							)
							__lowerCamelCase		       =    SeqaSeqDataset(
							    lowerCamelCase__			,						data_dir=lowerCamelCase__			,						type_path='train'			,						max_source_length=lowerCamelCase__			,						max_target_length=lowerCamelCase__			,						n_obs=lowerCamelCase__			,						)
							return ds, max_tokens, tokenizer


			def       lowercase_    (      self							)    ->      Tuple:



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase		       =    self._get_dataset()
							__lowerCamelCase		       =    set(DistributedSortishSampler(lowerCamelCase__			,						256			,						num_replicas=2			,						rank=0			,						add_extra_examples=lowerCamelCase__							)							)
							__lowerCamelCase		       =    set(DistributedSortishSampler(lowerCamelCase__			,						256			,						num_replicas=2			,						rank=1			,						add_extra_examples=lowerCamelCase__							)							)
							assert idsa.intersection(lowerCamelCase__							) == set()






			@parameterized.expand(
			    [
			        MBART_TINY,
			        MARIAN_TINY,
			        T5_TINY,
			        BART_TINY,
			        PEGASUS_XSUM,
			    ]			,						)
			def       lowercase_    (      self			,						lowerCamelCase__							)    ->      Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    AutoTokenizer.from_pretrained(lowerCamelCase__			,						use_fast=lowerCamelCase__							)
							if tok_name == MBART_TINY:
											__lowerCamelCase		       =    SeqaSeqDataset(
											    lowerCamelCase__			,						data_dir=make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()							)			,						type_path='train'			,						max_source_length=4			,						max_target_length=8			,						src_lang='EN'			,						tgt_lang='FR'			,						)
											__lowerCamelCase		       =    train_dataset.dataset_kwargs
											assert "src_lang" in kwargs and "tgt_lang" in kwargs
							else:
											__lowerCamelCase		       =    SeqaSeqDataset(
											    lowerCamelCase__			,						data_dir=make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()							)			,						type_path='train'			,						max_source_length=4			,						max_target_length=8			,						)
											__lowerCamelCase		       =    train_dataset.dataset_kwargs
											assert "add_prefix_space" not in kwargs if tok_name != BART_TINY else "add_prefix_space" in kwargs
											assert len(lowerCamelCase__							) == 1 if tok_name == BART_TINY else len(lowerCamelCase__							) == 0








import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np
import torch

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


__A        =    logging.get_logger(__name__)







class     __lowerCAmelCase (       __magic_name__ ):

			"""simple docstring"""







			snake_case_   		=       ['''input_features''', '''is_longer''']


			def __init__(      self			,						lowerCamelCase__=64			,						lowerCamelCase__=48_000			,						lowerCamelCase__=480			,						lowerCamelCase__=10			,						lowerCamelCase__=1_024			,						lowerCamelCase__=0.0			,						lowerCamelCase__=False			,						lowerCamelCase__ = 0			,						lowerCamelCase__ = 14_000			,						lowerCamelCase__ = None			,						lowerCamelCase__ = "fusion"			,						lowerCamelCase__ = "repeatpad"			,						**lowerCamelCase__			,						)    ->      Tuple:



							'''simple docstring'''
							super().__init__(
							    feature_size=lowerCamelCase__			,						sampling_rate=lowerCamelCase__			,						padding_value=lowerCamelCase__			,						return_attention_mask=lowerCamelCase__			,						**lowerCamelCase__			,						)
							__lowerCamelCase		       =    top_db
							__lowerCamelCase		       =    truncation
							__lowerCamelCase		       =    padding
							__lowerCamelCase		       =    fft_window_size
							__lowerCamelCase		       =    (fft_window_size >> 1) + 1
							__lowerCamelCase		       =    hop_length
							__lowerCamelCase		       =    max_length_s
							__lowerCamelCase		       =    max_length_s * sampling_rate
							__lowerCamelCase		       =    sampling_rate
							__lowerCamelCase		       =    frequency_min
							__lowerCamelCase		       =    frequency_max
							__lowerCamelCase		       =    mel_filter_bank(
							    num_frequency_bins=self.nb_frequency_bins			,						num_mel_filters=lowerCamelCase__			,						min_frequency=lowerCamelCase__			,						max_frequency=lowerCamelCase__			,						sampling_rate=lowerCamelCase__			,						norm=lowerCamelCase__			,						mel_scale='htk'			,						)
							__lowerCamelCase		       =    mel_filter_bank(
							    num_frequency_bins=self.nb_frequency_bins			,						num_mel_filters=lowerCamelCase__			,						min_frequency=lowerCamelCase__			,						max_frequency=lowerCamelCase__			,						sampling_rate=lowerCamelCase__			,						norm='slaney'			,						mel_scale='slaney'			,						)


			def       lowercase_    (      self							)    ->      Dict[str, Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    copy.deepcopy(self.__dict__							)
							__lowerCamelCase		       =    self.__class__.__name__
							if "mel_filters" in output:
											del output["mel_filters"]
							if "mel_filters_slaney" in output:
											del output["mel_filters_slaney"]
							return output


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__ = None							)    ->      np.ndarray:



							'''simple docstring'''
							__lowerCamelCase		       =    spectrogram(
							    lowerCamelCase__			,						window_function(self.fft_window_size			,						'hann'							)			,						frame_length=self.fft_window_size			,						hop_length=self.hop_length			,						power=2.0			,						mel_filters=lowerCamelCase__			,						log_mel='dB'			,						)
							return log_mel_spectrogram.T


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      int:



							'''simple docstring'''
							__lowerCamelCase		       =    np.array_split(list(range(0			,						total_frames - chunk_frames + 1							)							)			,						3							)
							if len(ranges[1]							) == 0:
											# if the audio is too short, we just use the first chunk
											__lowerCamelCase		       =    [0]
							if len(ranges[2]							) == 0:
											# if the audio is too short, we just use the first chunk
											__lowerCamelCase		       =    [0]
							# randomly choose index for each part
							__lowerCamelCase		       =    np.random.choice(ranges[0]							)
							__lowerCamelCase		       =    np.random.choice(ranges[1]							)
							__lowerCamelCase		       =    np.random.choice(ranges[2]							)

							__lowerCamelCase		       =    mel[idx_front : idx_front + chunk_frames, :]
							__lowerCamelCase		       =    mel[idx_middle : idx_middle + chunk_frames, :]
							__lowerCamelCase		       =    mel[idx_back : idx_back + chunk_frames, :]

							__lowerCamelCase		       =    torch.tensor(mel[None, None, :]							)
							__lowerCamelCase		       =    torch.nn.functional.interpolate(
							    lowerCamelCase__			,						size=[chunk_frames, 64]			,						mode='bilinear'			,						align_corners=lowerCamelCase__							)
							__lowerCamelCase		       =    mel_shrink[0][0].numpy()
							__lowerCamelCase		       =    np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back]			,						axis=0							)
							return mel_fusion


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      np.array:



							'''simple docstring'''
							if waveform.shape[0] > max_length:
											if truncation == "rand_trunc":
															__lowerCamelCase		       =    True
															# random crop to max_length (for compatibility) -> this should be handled by self.pad
															__lowerCamelCase		       =    len(lowerCamelCase__							) - max_length
															__lowerCamelCase		       =    np.random.randint(0			,						overflow + 1							)
															__lowerCamelCase		       =    waveform[idx : idx + max_length]
															__lowerCamelCase		       =    self._np_extract_fbank_features(lowerCamelCase__			,						self.mel_filters_slaney							)[None, :]
											elif truncation == "fusion":
															__lowerCamelCase		       =    self._np_extract_fbank_features(lowerCamelCase__			,						self.mel_filters							)
															__lowerCamelCase		       =    max_length // self.hop_length + 1  # the +1 related to how the spectrogram is computed
															__lowerCamelCase		       =    mel.shape[0]
															if chunk_frames == total_frames:
																			# there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
																			# In this case, we just use the whole audio.
																			__lowerCamelCase		       =    np.stack([mel, mel, mel, mel]			,						axis=0							)
																			__lowerCamelCase		       =    False
															else:
																			__lowerCamelCase		       =    self._random_mel_fusion(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)
																			__lowerCamelCase		       =    True
											else:
															raise NotImplementedError(f"""data_truncating {truncation} not implemented"""							)

							else:
											__lowerCamelCase		       =    False
											# only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
											if waveform.shape[0] < max_length:
															if padding == "repeat":
																			__lowerCamelCase		       =    int(max_length / len(lowerCamelCase__							)							)
																			__lowerCamelCase		       =    np.stack(np.tile(lowerCamelCase__			,						n_repeat + 1							)							)[:max_length]
															if padding == "repeatpad":
																			__lowerCamelCase		       =    int(max_length / len(lowerCamelCase__							)							)
																			__lowerCamelCase		       =    np.stack(np.tile(lowerCamelCase__			,						lowerCamelCase__							)							)
															__lowerCamelCase		       =    np.pad(lowerCamelCase__			,						(0, max_length - waveform.shape[0])			,						mode='constant'			,						constant_values=0							)

											if truncation == "fusion":
															__lowerCamelCase		       =    self._np_extract_fbank_features(lowerCamelCase__			,						self.mel_filters							)
															__lowerCamelCase		       =    np.stack([input_mel, input_mel, input_mel, input_mel]			,						axis=0							)
											else:
															__lowerCamelCase		       =    self._np_extract_fbank_features(lowerCamelCase__			,						self.mel_filters_slaney							)[None, :]

							return input_mel, longer






			def __call__(      self			,						lowerCamelCase__			,						lowerCamelCase__ = None			,						lowerCamelCase__ = None			,						lowerCamelCase__ = None			,						lowerCamelCase__ = None			,						lowerCamelCase__ = None			,						**lowerCamelCase__			,						)    ->      BatchFeature:



							'''simple docstring'''
							__lowerCamelCase		       =    truncation if truncation is not None else self.truncation
							__lowerCamelCase		       =    padding if padding else self.padding

							if sampling_rate is not None:
											if sampling_rate != self.sampling_rate:
															raise ValueError(
															    f"""The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"""
															    f""" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"""
															    f""" was sampled with {self.sampling_rate} and not {sampling_rate}."""							)
							else:
											logger.warning(
											    'It is strongly recommended to pass the `sampling_rate` argument to this function. '
											    'Failing to do so can result in silent errors that might be hard to debug.'							)

							__lowerCamelCase		       =    isinstance(lowerCamelCase__			,						np.ndarray							) and len(raw_speech.shape							) > 1
							if is_batched_numpy and len(raw_speech.shape							) > 2:
											raise ValueError(f"""Only mono-channel audio is supported for input to {self}"""							)
							__lowerCamelCase		       =    is_batched_numpy or (
							    isinstance(lowerCamelCase__			,						(list, tuple)							) and (isinstance(raw_speech[0]			,						(np.ndarray, tuple, list)							))
							)

							if is_batched:
											__lowerCamelCase		       =    [np.asarray(lowerCamelCase__			,						dtype=np.floataa							) for speech in raw_speech]
							elif not is_batched and not isinstance(lowerCamelCase__			,						np.ndarray							):
											__lowerCamelCase		       =    np.asarray(lowerCamelCase__			,						dtype=np.floataa							)
							elif isinstance(lowerCamelCase__			,						np.ndarray							) and raw_speech.dtype is np.dtype(np.floataa							):
											__lowerCamelCase		       =    raw_speech.astype(np.floataa							)

							# always return batch
							if not is_batched:
											__lowerCamelCase		       =    [np.asarray(lowerCamelCase__							)]

							# convert to mel spectrogram, truncate and pad if needed.
							__lowerCamelCase		       =    [
							    self._get_input_mel(lowerCamelCase__			,						max_length if max_length else self.nb_max_samples			,						lowerCamelCase__			,						lowerCamelCase__							)
							    for waveform in raw_speech
							]

							__lowerCamelCase		       =    []
							__lowerCamelCase		       =    []
							for mel, longer in padded_inputs:
											input_mel.append(lowerCamelCase__							)
											is_longer.append(lowerCamelCase__							)

							if truncation == "fusion" and sum(lowerCamelCase__							) == 0:
											# if no audio is longer than 10s, then randomly select one audio to be longer
											__lowerCamelCase		       =    np.random.randint(0			,						len(lowerCamelCase__							)							)
											__lowerCamelCase		       =    True

							if isinstance(input_mel[0]			,						lowerCamelCase__							):
											__lowerCamelCase		       =    [np.asarray(lowerCamelCase__			,						dtype=np.floataa							) for feature in input_mel]

							# is_longer is a list of bool
							__lowerCamelCase		       =    [[longer] for longer in is_longer]

							__lowerCamelCase		       =    {'input_features': input_mel, 'is_longer': is_longer}
							__lowerCamelCase		       =    BatchFeature(lowerCamelCase__							)

							if return_tensors is not None:
											__lowerCamelCase		       =    input_features.convert_to_tensors(lowerCamelCase__							)

							return input_features


