



import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


__snake_case		:List[Any] 						=	logging.get_logger(__name__)


__snake_case		:str 						=	{'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''}

# See all MVP models at https://huggingface.co/models?filter=mvp
__snake_case		:List[Any] 						=	{
    '''vocab_file''': {
        '''RUCAIBox/mvp''': '''https://huggingface.co/RUCAIBox/mvp/resolve/main/vocab.json''',
    },
    '''added_tokens.json''': {
        '''RUCAIBox/mvp''': '''https://huggingface.co/RUCAIBox/mvp/resolve/main/added_tokens.json''',
    },
    '''merges_file''': {
        '''RUCAIBox/mvp''': '''https://huggingface.co/RUCAIBox/mvp/resolve/main/merges.txt''',
    },
}

__snake_case		:List[str] 						=	{
    '''RUCAIBox/mvp''': 1024,
}





@lru_cache()
def 	__snake_case      (     ):
    __a					=							(
        list(range(ord('''!'''							)  ,					ord('''~'''							) + 1							)							) + list(range(ord('''¡'''							)  ,					ord('''¬'''							) + 1							)							) + list(range(ord('''®'''							)  ,					ord('''ÿ'''							) + 1							)							)
    )
    __a					=							bs[:]
    __a					=							0
    for b in range(2**8							):
        if b not in bs:
            bs.append(_UpperCAmelCase							)
            cs.append(2**8 + n							)
            n += 1
    __a					=							[chr(_UpperCAmelCase							) for n in cs]
    return dict(zip(_UpperCAmelCase  ,					_UpperCAmelCase							)							)





def 	__snake_case      (     _UpperCAmelCase							):
    __a					=							set()
    __a					=							word[0]
    for char in word[1:]:
        pairs.add((prev_char, char)							)
        __a					=							char
    return pairs

class        _A			(      __UpperCAmelCase       ):
       UpperCamelCase__    :       Optional[Any]		   =		VOCAB_FILES_NAMES
       UpperCamelCase__    :       Union[str, Any]		   =		PRETRAINED_VOCAB_FILES_MAP
       UpperCamelCase__    :       Optional[Any]		   =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       UpperCamelCase__    :       Tuple		   =		['''input_ids''', '''attention_mask''']



       def __init__(						self				:	Tuple	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]	,						__SCREAMING_SNAKE_CASE				:	Tuple	,						__SCREAMING_SNAKE_CASE				:	Dict="replace"	,						__SCREAMING_SNAKE_CASE				:	Optional[int]="<s>"	,						__SCREAMING_SNAKE_CASE				:	Dict="</s>"	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]="</s>"	,						__SCREAMING_SNAKE_CASE				:	Optional[int]="<s>"	,						__SCREAMING_SNAKE_CASE				:	List[Any]="<unk>"	,						__SCREAMING_SNAKE_CASE				:	Dict="<pad>"	,						__SCREAMING_SNAKE_CASE				:	int="<mask>"	,						__SCREAMING_SNAKE_CASE				:	Any=False	,						**__SCREAMING_SNAKE_CASE				:	Optional[Any]	,						):


           '''simple docstring'''

           __a					=							AddedToken(__SCREAMING_SNAKE_CASE	,						lstrip=__SCREAMING_SNAKE_CASE	,						rstrip=__SCREAMING_SNAKE_CASE) if isinstance(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE) else bos_token
           __a					=							AddedToken(__SCREAMING_SNAKE_CASE	,						lstrip=__SCREAMING_SNAKE_CASE	,						rstrip=__SCREAMING_SNAKE_CASE) if isinstance(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE) else eos_token
           __a					=							AddedToken(__SCREAMING_SNAKE_CASE	,						lstrip=__SCREAMING_SNAKE_CASE	,						rstrip=__SCREAMING_SNAKE_CASE) if isinstance(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE) else sep_token
           __a					=							AddedToken(__SCREAMING_SNAKE_CASE	,						lstrip=__SCREAMING_SNAKE_CASE	,						rstrip=__SCREAMING_SNAKE_CASE) if isinstance(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE) else cls_token
           __a					=							AddedToken(__SCREAMING_SNAKE_CASE	,						lstrip=__SCREAMING_SNAKE_CASE	,						rstrip=__SCREAMING_SNAKE_CASE) if isinstance(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE) else unk_token
           __a					=							AddedToken(__SCREAMING_SNAKE_CASE	,						lstrip=__SCREAMING_SNAKE_CASE	,						rstrip=__SCREAMING_SNAKE_CASE) if isinstance(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE) else pad_token

           # Mask token behave like a normal word, i.e. include the space before it
           __a					=							AddedToken(__SCREAMING_SNAKE_CASE	,						lstrip=__SCREAMING_SNAKE_CASE	,						rstrip=__SCREAMING_SNAKE_CASE) if isinstance(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE) else mask_token

           super().__init__(
               errors=__SCREAMING_SNAKE_CASE	,						bos_token=__SCREAMING_SNAKE_CASE	,						eos_token=__SCREAMING_SNAKE_CASE	,						unk_token=__SCREAMING_SNAKE_CASE	,						sep_token=__SCREAMING_SNAKE_CASE	,						cls_token=__SCREAMING_SNAKE_CASE	,						pad_token=__SCREAMING_SNAKE_CASE	,						mask_token=__SCREAMING_SNAKE_CASE	,						add_prefix_space=__SCREAMING_SNAKE_CASE	,						**__SCREAMING_SNAKE_CASE	,						)
           with open(__SCREAMING_SNAKE_CASE	,						encoding='''utf-8''') as vocab_handle:
               __a					=							json.load(__SCREAMING_SNAKE_CASE)
           __a					=							{v: k for k, v in self.encoder.items()}
           __a					=							errors  # how to handle errors in decoding
           __a					=							bytes_to_unicode()
           __a					=							{v: k for k, v in self.byte_encoder.items()}
           with open(__SCREAMING_SNAKE_CASE	,						encoding='''utf-8''') as merges_handle:
               __a					=							merges_handle.read().split('''\n''')[1:-1]
           __a					=							[tuple(merge.split()) for merge in bpe_merges]
           __a					=							dict(zip(__SCREAMING_SNAKE_CASE	,						range(len(__SCREAMING_SNAKE_CASE))))
           __a					=							{}
           __a					=							add_prefix_space

           # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
           __a					=							re.compile(r'''\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+''')



       @property
       def 						_lowerCamelCase     (						self				:	Tuple):


           '''simple docstring'''

           return len(self.encoder)



       def 						_lowerCamelCase     (						self				:	List[Any]):


           '''simple docstring'''

           return dict(self.encoder	,						**self.added_tokens_encoder)



       def 						_lowerCamelCase     (						self				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	int):


           '''simple docstring'''

           if token in self.cache:
               return self.cache[token]
           __a					=							tuple(__SCREAMING_SNAKE_CASE)
           __a					=							get_pairs(__SCREAMING_SNAKE_CASE)

           if not pairs:
               return token

           while True:
               __a					=							min(__SCREAMING_SNAKE_CASE	,						key=lambda __SCREAMING_SNAKE_CASE: self.bpe_ranks.get(__SCREAMING_SNAKE_CASE	,						float('''inf''')))
               if bigram not in self.bpe_ranks:
                   break
               __a			,  __a					=							bigram
               __a					=							[]
               __a					=							0
               while i < len(__SCREAMING_SNAKE_CASE):
                   try:
                       __a					=							word.index(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE)
                   except ValueError:
                       new_word.extend(word[i:])
                       break
                   else:
                       new_word.extend(word[i:j])
                       __a					=							j

                   if word[i] == first and i < len(__SCREAMING_SNAKE_CASE) - 1 and word[i + 1] == second:
                       new_word.append(first + second)
                       i += 2
                   else:
                       new_word.append(word[i])
                       i += 1
               __a					=							tuple(__SCREAMING_SNAKE_CASE)
               __a					=							new_word
               if len(__SCREAMING_SNAKE_CASE) == 1:
                   break
               else:
                   __a					=							get_pairs(__SCREAMING_SNAKE_CASE)
           __a					=							''' '''.join(__SCREAMING_SNAKE_CASE)
           __a					=							word
           return word



       def 						_lowerCamelCase     (						self				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	int):


           '''simple docstring'''

           __a					=							[]
           for token in re.findall(self.pat	,						__SCREAMING_SNAKE_CASE):
               __a					=							''''''.join(
                   self.byte_encoder[b] for b in token.encode('''utf-8'''))  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
               bpe_tokens.extend(bpe_token for bpe_token in self.bpe(__SCREAMING_SNAKE_CASE).split(''' '''))
           return bpe_tokens



       def 						_lowerCamelCase     (						self				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]):


           '''simple docstring'''

           return self.encoder.get(__SCREAMING_SNAKE_CASE	,						self.encoder.get(self.unk_token))



       def 						_lowerCamelCase     (						self				:	Dict	,						__SCREAMING_SNAKE_CASE				:	List[str]):


           '''simple docstring'''

           return self.decoder.get(__SCREAMING_SNAKE_CASE)



       def 						_lowerCamelCase     (						self				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	int):


           '''simple docstring'''

           __a					=							''''''.join(__SCREAMING_SNAKE_CASE)
           __a					=							bytearray([self.byte_decoder[c] for c in text]).decode('''utf-8'''	,						errors=self.errors)
           return text



       def 						_lowerCamelCase     (						self				:	Tuple	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	Optional[str] = None):


           '''simple docstring'''

           if not os.path.isdir(__SCREAMING_SNAKE_CASE):
               logger.error(F'Vocabulary path ({save_directory}) should be a directory')
               return
           __a					=							os.path.join(
               __SCREAMING_SNAKE_CASE	,						(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''])
           __a					=							os.path.join(
               __SCREAMING_SNAKE_CASE	,						(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file'''])

           with open(__SCREAMING_SNAKE_CASE	,						'''w'''	,						encoding='''utf-8''') as f:
               f.write(json.dumps(self.encoder	,						indent=2	,						sort_keys=__SCREAMING_SNAKE_CASE	,						ensure_ascii=__SCREAMING_SNAKE_CASE) + '''\n''')

           __a					=							0
           with open(__SCREAMING_SNAKE_CASE	,						'''w'''	,						encoding='''utf-8''') as writer:
               writer.write('''#version: 0.2\n''')
               for bpe_tokens, token_index in sorted(self.bpe_ranks.items()	,						key=lambda __SCREAMING_SNAKE_CASE: kv[1]):
                   if index != token_index:
                       logger.warning(
                           F'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
                           ''' Please check that the tokenizer is not corrupted!''')
                       __a					=							token_index
                   writer.write(''' '''.join(__SCREAMING_SNAKE_CASE) + '''\n''')
                   index += 1

           return vocab_file, merge_file



       def 						_lowerCamelCase     (						self				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	List[int]	,						__SCREAMING_SNAKE_CASE				:	Optional[List[int]] = None):


           '''simple docstring'''

           if token_ids_a is None:
               return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
           __a					=							[self.cls_token_id]
           __a					=							[self.sep_token_id]
           return cls + token_ids_a + sep + sep + token_ids_a + sep



       def 						_lowerCamelCase     (						self				:	Any	,						__SCREAMING_SNAKE_CASE				:	List[int]	,						__SCREAMING_SNAKE_CASE				:	Optional[List[int]] = None	,						__SCREAMING_SNAKE_CASE				:	bool = False):


           '''simple docstring'''

           if already_has_special_tokens:
               return super().get_special_tokens_mask(
                   token_ids_a=__SCREAMING_SNAKE_CASE	,						token_ids_a=__SCREAMING_SNAKE_CASE	,						already_has_special_tokens=__SCREAMING_SNAKE_CASE)

           if token_ids_a is None:
               return [1] + ([0] * len(__SCREAMING_SNAKE_CASE)) + [1]
           return [1] + ([0] * len(__SCREAMING_SNAKE_CASE)) + [1, 1] + ([0] * len(__SCREAMING_SNAKE_CASE)) + [1]



       def 						_lowerCamelCase     (						self				:	int	,						__SCREAMING_SNAKE_CASE				:	List[int]	,						__SCREAMING_SNAKE_CASE				:	Optional[List[int]] = None):


           '''simple docstring'''

           __a					=							[self.sep_token_id]
           __a					=							[self.cls_token_id]

           if token_ids_a is None:
               return len(cls + token_ids_a + sep) * [0]
           return len(cls + token_ids_a + sep + sep + token_ids_a + sep) * [0]





       def 						_lowerCamelCase     (						self				:	Optional[Any]	,						__SCREAMING_SNAKE_CASE				:	Optional[Any]	,						__SCREAMING_SNAKE_CASE				:	List[str]=False	,						**__SCREAMING_SNAKE_CASE				:	List[str]):


           '''simple docstring'''

           __a					=							kwargs.pop('''add_prefix_space'''	,						self.add_prefix_space)
           if (is_split_into_words or add_prefix_space) and (len(__SCREAMING_SNAKE_CASE) > 0 and not text[0].isspace()):
               __a					=							''' ''' + text
           return (text, kwargs)










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


__snake_case		:Any 						=	random.Random()





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase=1.0  ,					_UpperCAmelCase=None  ,					_UpperCAmelCase=None							):
    if rng is None:
        __a					=							global_rng

    __a					=							[]
    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				:	Dict	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	Tuple=7	,						__SCREAMING_SNAKE_CASE				:	Any=400	,						__SCREAMING_SNAKE_CASE				:	Any=2_000	,						__SCREAMING_SNAKE_CASE				:	int=1	,						__SCREAMING_SNAKE_CASE				:	Dict=0.0	,						__SCREAMING_SNAKE_CASE				:	Optional[int]=24_000	,						__SCREAMING_SNAKE_CASE				:	Dict=True	,						):


           '''simple docstring'''

           __a					=							parent
           __a					=							batch_size
           __a					=							min_seq_length
           __a					=							max_seq_length
           __a					=							(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
           __a					=							feature_size
           __a					=							padding_value
           __a					=							sampling_rate
           __a					=							return_attention_mask



       def 						_lowerCamelCase     (						self				:	List[str]):


           '''simple docstring'''

           return {
               "feature_size": self.feature_size,
               "padding_value": self.padding_value,
               "sampling_rate": self.sampling_rate,
               "return_attention_mask": self.return_attention_mask,
           }





       def 						_lowerCamelCase     (						self				:	List[Any]	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]=False	,						__SCREAMING_SNAKE_CASE				:	Optional[Any]=False):


           '''simple docstring'''

           def _flatten(__SCREAMING_SNAKE_CASE				:	List[str]):
               return list(itertools.chain(*__SCREAMING_SNAKE_CASE))

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

           return audio_inputs


@require_torch
class        _A			(      __UpperCAmelCase ,unittest.TestCase       ):
       UpperCamelCase__    :       str		   =		EncodecFeatureExtractor



       def 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

           __a					=							EnCodecFeatureExtractionTester(self)



       def 						_lowerCamelCase     (						self				:	Optional[int]):


           '''simple docstring'''

           __a					=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
           # create three inputs of length 800, 1000, and 1200
           __a					=							[floats_list((1, x))[0] for x in range(800	,						1_400	,						200)]
           __a					=							[np.asarray(__SCREAMING_SNAKE_CASE) for audio_input in audio_inputs]

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

           # Test batched
           __a					=							feat_extract(__SCREAMING_SNAKE_CASE	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''np''').input_values
           __a					=							feat_extract(__SCREAMING_SNAKE_CASE	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''np''').input_values
           for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE):
               self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						atol=1E-3))



       def 						_lowerCamelCase     (						self				:	Optional[Any]):


           '''simple docstring'''

           __a					=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
           __a					=							np.random.rand(100).astype(np.floataa)
           __a					=							np_audio_inputs.tolist()

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



       def 						_lowerCamelCase     (						self				:	Tuple	,						__SCREAMING_SNAKE_CASE				:	str):


           '''simple docstring'''

           from datasets import load_dataset

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

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



       def 						_lowerCamelCase     (						self				:	int):


           '''simple docstring'''

           __a					=							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
           __a					=							self._load_datasamples(1)
           __a					=							EncodecFeatureExtractor()
           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(input_values.shape	,						(1, 1, 93_680))
           self.assertTrue(torch.allclose(input_values[0, 0, :30]	,						__SCREAMING_SNAKE_CASE	,						atol=1E-6))



       def 						_lowerCamelCase     (						self				:	Optional[int]):


           '''simple docstring'''

           __a					=							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
           __a					=							self._load_datasamples(1)
           __a					=							[np.tile(input_audio[0][None]	,						reps=(2, 1))]
           input_audio[0][1] *= 0.5
           __a					=							EncodecFeatureExtractor(feature_size=2)
           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(input_values.shape	,						(1, 2, 93_680))
           self.assertTrue(torch.allclose(input_values[0, 0, :30]	,						__SCREAMING_SNAKE_CASE	,						atol=1E-6))
           self.assertTrue(torch.allclose(input_values[0, 1, :30]	,						EXPECTED_INPUT_VALUES * 0.5	,						atol=1E-6))





       def 						_lowerCamelCase     (						self				:	Any):


           '''simple docstring'''

           __a					=							self._load_datasamples(2)
           # would be easier if the stride was like
           __a					=							EncodecFeatureExtractor(feature_size=1	,						chunk_length_s=1	,						overlap=0.01)

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

           # truncate to chunk
           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						truncation=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(2, 1, 71_520))  # 2 chunks

           # force truncate to max_length
           __a					=							feature_extractor(
               __SCREAMING_SNAKE_CASE	,						truncation=__SCREAMING_SNAKE_CASE	,						max_length=48_000	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(2, 1, 48_000))

           # pad to chunk
           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(padded_outputs.shape	,						(2, 1, 95_280))

           # pad to chunk
           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(2, 1, 95_280))

           # force pad to max length
           __a					=							feature_extractor(
               __SCREAMING_SNAKE_CASE	,						padding='''max_length'''	,						max_length=100_000	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(2, 1, 100_000))

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

           __a					=							feature_extractor(input_audio[0]	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(1, 1, 93_680))

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

           __a					=							feature_extractor(input_audio[0]	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(1, 1, 93_680))

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

           __a					=							feature_extractor(input_audio[0]	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(1, 1, 93_680))





